query
stringlengths 9
3.4k
| document
stringlengths 9
87.4k
| metadata
dict | negatives
sequencelengths 4
101
| negative_scores
sequencelengths 4
101
| document_score
stringlengths 3
10
| document_rank
stringclasses 102
values |
|---|---|---|---|---|---|---|
Set initial value from editor version using edit format option | def setInitDefault(self, editText):
if editText in TimeFormat.timeStampStrings:
self.initDefault = TimeFormat.timeStampStrings[0]
else:
TextFormat.setInitDefault(self, editText) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setInitDefault(self, editText):\n if editText in DateFormat.dateStampStrings:\n self.initDefault = DateFormat.dateStampStrings[0]\n else:\n TextFormat.setInitDefault(self, editText)",
"def getEditInitDefault(self):\n if self.initDefault in DateFormat.dateStampStrings:\n return DateFormat.dateStampStrings[1]\n return TextFormat.getEditInitDefault(self)",
"def getEditInitDefault(self):\n return self.formatEditText(self.initDefault)[0]",
"def setInitDefault(self, editText):\n self.initDefault = self.storedText(editText)[0]",
"def getEditInitDefault(self):\n if self.initDefault in TimeFormat.timeStampStrings:\n return TimeFormat.timeStampStrings[1]\n return TextFormat.getEditInitDefault(self)",
"def on_editor_save(self):\n self.text = self.textWidget.get(\"1.0\", tk.END)",
"def setModelData(self, editor, model, index):\n try:\n date = datetime.strptime(str(editor.text()), self.format)\n model.setData(index, date, Qt.EditRole)\n except:\n pass # If the text does not conform to the date format, do nothing.",
"def on_edit_changed(self, edit):\n\t\tself.emit('value-changed', edit.get_text())",
"def initFormat(self):\n pass",
"def update_editor ( self ):\n font = self.factory.to_wx_font( self )\n try:\n self._facename.SetStringSelection( font.GetFaceName() )\n except:\n self._facename.SetSelection( 0 )\n try:\n self._point_size.SetStringSelection( str( font.GetPointSize() ) )\n except:\n self._point_size.SetSelection( 0 )\n font.SetPointSize( min( 10, font.GetPointSize() ) )\n self._font.SetValue( self.str_value )\n self._font.SetFont( font )",
"def set_format(cls,format):\n import __main__\n IP = __main__.__dict__['__IP']\n prompt = getattr(IP.outputcache,cls._prompt)\n prompt.p_template = format\n prompt.set_p_str()\n cls._format = format",
"def _set_settings_version(c, settings_path, version_line):\n version_const = \"VERSION\"\n\n print(f\"Adjusting {version_const} in {settings_path} to {version_line}...\")\n c.run(f'sed -i .orig \\'s/^{version_const} =.*$/{version_const} = \"{version_line}\"/\\' \"{settings_path}\"')",
"def readVersion(self):\n ds = self.root.findall(\"[@format]\")[0]\n raw_format = ds.attrib['format']\n try:\n self.documentFormatVersion = int(raw_format)\n except ValueError:\n # as of fontTools >= 3.27 'format' is formatted as a float \"4.0\"\n self.documentFormatVersion = float(raw_format)",
"def setValue(self,val):\n if self._plain:\n self.input.setPlainText(str(val))\n else:\n updateText(self.input,str(val))",
"def defaultLoad (self):\n self.srcEditor.setText( \"\" )\n self.srcEditor.setFocus()\n self.setReadOnly( readOnly=False )",
"def createEditor(self, parent, option, index):\n editor = QLineEdit(parent)\n date = index.model().data(index, Qt.DisplayRole)\n editor.setText(date.strftime(self.format))\n return editor",
"def testSetEditorValue(self):\r\n \r\n lineEdit = QtGui.QLineEdit()\r\n self._editorFactory.setEditorValue(lineEdit, u\"Test\")\r\n self.assertTrue(lineEdit.text() == u\"Test\" )\r\n \r\n spinBox = QtGui.QDoubleSpinBox()\r\n self._editorFactory.setEditorValue(spinBox, 2.05)\r\n self.assertTrue(spinBox.value() == 2.05)\r\n \r\n checkBox = QtGui.QCheckBox()\r\n self._editorFactory.setEditorValue(checkBox, True)\r\n self.assertTrue(checkBox.isChecked() == True)",
"def edit():",
"def setValue(self,val):\n val = str(val)\n if self._plain:\n self.input.setText(val)\n else:\n updateText(self.input,val)",
"def set_initial(self, value):\n # TODO: Make an Initial Stock Adjust here\n pass",
"def setContentData(self, content):\n original = content\n if IVersionedObject.providedBy(original):\n content = original.get_editable()\n if content is None:\n self.widgetFactoryFactory = SMIDisplayWidgetFactory\n content = original.get_previewable()\n\n super(SMIEditForm, self).setContentData(content)",
"def initFormat(self):\n self.html = True",
"def initFormat(self):\n self.html = True",
"def setValue(self,val):\n val = int(val)\n self.input.setText(str(val))",
"def after_init(self):\n if self.options.format.appended:\n self.error_format = self.options.format.appended[0]",
"def setEditorData(self, ledit, midx):\n cond = self._sel.give_cond(midx.row())\n val = cond[midx.column()]\n txt = \"\"\n if val is not None:\n txt = str(val)\n ledit.setText(txt)",
"def setEditorData(self, ledit, midx):\n cond = self._sel.give_cond(midx.row())\n val = cond[midx.column()]\n txt = \"\"\n if val is not None:\n txt = str(val)\n ledit.setText(txt)",
"def edition(self, key, value):\n return clean_val(\"a\", value, str).replace(\"ed.\", \"\")",
"def on_widget_edited(self, value): # this is a slot\n # note this is exactly the same as @value.setter...\n self.value = value",
"def update_format_string(self):\n if self._show_units:\n units = \" {}\".format(self._unit)\n else:\n units = \"\"\n\n if self._show_step_exponent:\n self.setSuffix(\"{0} Step: 1E{1}\".format(units, self.step_exponent))\n self.lineEdit().setToolTip(\"\")\n else:\n self.setSuffix(units)\n self.lineEdit().setToolTip('Step: 1E{0:+d}'.format(self.step_exponent))",
"def storedText(self, editText):\n format = globalref.options.strData('EditDateFormat', True)\n try:\n return (repr(GenDate().setFromStr(editText, format)), True)\n except GenDateError:\n return (editText, not editText and not self.isRequired)",
"def __set__(self, instance, value):\n # make sure value follows \"major,minor,build\" convention\n if not is_version_valid(value):\n raise InvalidVersionFormat(\"Version: {0} is invalid\".format(value))\n\n super().__set__(instance, value)",
"def setContentData(self, content):\n original = content\n if IVersionedObject.providedBy(original):\n content = original.get_editable()\n if content is None:\n self.widgetFactoryFactory = SMIDisplayWidgetFactory\n content = original.get_previewable()\n\n super(SMISubEditForm, self).setContentData(content)",
"def initFormat(self):\n self.formatList = self.splitText(self.format)",
"def opt_format(self, fmt):\n key = get_enum_key(fmt, FORMATTERS)\n if key is not None:\n self.conf[\"format\"] = key\n print(\"Set format %r\" % key)\n else:\n print(\"Unknown format %r\" % fmt)",
"def setValue(self,val):\n self.input.setText(str(val))",
"def special_case(self):\n Input.clear_display(self, self.entries[4])\n self.entries[4].insert(INSERT, '1712/02/30 was a real date in Sweden')\n self.entries[4].configure(state='readonly')",
"def _set_real_format(self, fmt):\n # try to use the _nomax variant if available\n if not self._max and fmt + '_nomax' in self.formats:\n self._format = self.formats[fmt + '_nomax']\n elif fmt in self.formats:\n self._format = self.formats[fmt]\n else:\n self._format = fmt\n\n self._format_line_count = self._format.count('\\n')",
"def updateeng(self):\n self.enstr = self.enEdit.text()",
"def format_cell_updated(self, cell, value=None):\n self.is_not_used()\n if value is not None:\n cell.value = value\n\n cell.fill = PatternFill(start_color='7fffd4', end_color='7fffd4', fill_type='solid')\n cell.font = Font(name='Ubuntu', size=11, color='555555', bold=False, italic=False)",
"def convert_format(self, new_format):\n if new_format not in [0, 1, 2, 3]:\n raise ValueError(\"Unknown format specified\")\n\n inp_format = new_format\n if inp_format == 3:\n new_format = 2\n\n for block in self.frd.blocks:\n if hasattr(block, 'format'):\n block.format = new_format\n\n self.frd.node_block.format = inp_format",
"def dummy():\n\t\t\tself.edit = True",
"def setValue(self,val):\n val = float(val)\n self.input.setText(str(val))",
"def entry_a_modified(self, content):\n if content.isdigit():\n self.model.number_a = int(content)\n self.show_calculations()",
"def _init_edit(self):\n def edit(core, args):\n month = ' '.join(getattr(args, 'month', []))\n core.edit(month)\n\n usage = 'stl edit [month]'\n desc = (\n 'lets you vim the right file'\n )\n\n subp = self.subparsers.add_parser(\n 'edit', usage=usage, description=desc, help=desc)\n\n subp.add_argument(\n 'month', nargs=argparse.REMAINDER,\n help='the month you want to edit, e.g. oct 2016')\n\n subp.set_defaults(func=edit)",
"def set_version(self, bundle, ctx, filename, version):",
"def __init__(self, value: str):\n self.options = [\n \"v1.0\"\n ]",
"def change_exteditor(self):\r\n path, valid = QInputDialog.getText(self, self.tr('External editor'),\r\n self.tr('External editor executable path:'),\r\n QLineEdit.Normal,\r\n CONF.get(self.ID, 'external_editor/path'))\r\n if valid:\r\n CONF.set(self.ID, 'external_editor/path', unicode(path))",
"def set_version(v):\n old = get_version()\n sys.stderr.write('%s -> %s\\n' % (old, v))\n with open(INIT, 'r+') as f:\n text = f.read()\n text = pattern.sub(\"__version__ = %r\" % v, text)\n f.seek(0)\n f.truncate()\n f.write(text)",
"def _init_obo_version(self, line):\n if line[0:14] == \"format-version\":\n self.format_version = line[16:-1]\n if line[0:12] == \"data-version\":\n self.data_version = line[14:-1]",
"def reformat():\n toolkit.reformat()",
"def _on_changed(self, entry, index):\r\n\r\n from re import sub\r\n from decimal import Decimal\r\n\r\n if index == 5:\r\n _text = entry.get_text()\r\n _text = Decimal(sub(r'[^\\d.]', '', _text))\r\n elif index in [16, 17]:\r\n _text = int(entry.get_text())\r\n else:\r\n _text = float(entry.get_text())\r\n\r\n self._modulebook.update(index, _text)\r\n\r\n return False",
"def edit_text(self, _, val):\n t_edit = text_editor.TextEditor(val, \"value\")\n t_edit.execute = self.execute",
"def format(self):\n ...",
"def _update_default(self, default_value):\n if self.type == \"uri_folder\" or self.type == \"uri_file\":\n self.default = default_value\n return\n else:\n if isinstance(default_value, float) and not math.isfinite(default_value):\n # Since nan/inf cannot be stored in the backend, just ignore them.\n # logger.warning(\"Float default value %r is not allowed, ignored.\" % default_value)\n return\n \"\"\"Update provided default values.\n Here we need to make sure the type of default value is allowed or it could be parsed..\n \"\"\"\n if default_value is not None and not isinstance(default_value, self._allowed_types):\n try:\n default_value = self._parse(default_value)\n except Exception as e:\n if self.name is None:\n msg = \"Default value of %s Input cannot be parsed, got '%s', type = %s.\" % (\n self.type,\n default_value,\n type(default_value),\n )\n else:\n msg = \"Default value of %s Input '%s' cannot be parsed, got '%s', type = %s.\" % (\n self.type,\n self.name,\n default_value,\n type(default_value),\n )\n raise MldesignerComponentDefiningError(cause=msg) from e\n self.default = default_value",
"def edit_date(entry):\n entry.date = get_date()\n entry.save()\n input(\"Edit successful. \")\n return entry",
"def setDefaultValue(self, value: int, extend_range: bool=False):\n self.setPlaceholderText(str(self.__validate(value, extend_range)))\n if self.getCurrentValue() is None:\n self.__commitValue()",
"def _update_editor(self):\n root = self.model.data_list\n root.append(RowModel(name='', value=''))\n del root[-1]",
"def set_field_value(index, value):\r\n elem = world.css_find('.metadata_edit div.wrapper-comp-setting input.setting-input')[index]\r\n elem.value = value\r\n elem.type(Keys.TAB)",
"def edit(self, new_content: str) -> None:\n\n # YOUR CODE HERE\n self.content = new_content",
"def setField(self, data):\n\t\tview = self.view\n\t\tview.sbAbstraccion.setValue(data['sbAbstraccion'])",
"def update_column_format(self):\n pass",
"def rec_default(self):\n self.phase_triggers.setText('(0,1,320)')\n self.phase_min.setText('-1.57')\n self.phase_max.setText('1.57')",
"def set_statement_default_value(self, value):\n self.set_value_into_input_field(self.statement_default_value_textbox_locator, value)\n self.click_element(self.statement_fields_bulk_edit_popup_title_locator)",
"def createEditor(self, parent, options, midx):\n ledit = qt.QLineEdit(parent)\n vmin, vmax = self._vrange\n dnb = self._decimals_nb\n ledit.setValidator(ValueValidator(vmin, vmax, dnb, ledit))\n return ledit",
"def __init__(self, value: str):\n self.options = [\n \"m\",\n ]",
"def setvalue(self,num,name,val):\n self.M.reconfigure(num,{name:float(val)})",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def with_default_format(self, other):\n return evolve(\n self,\n set_format=self.set_format or other,\n default_format=other\n )",
"def _setEditorText(self, text):\n if self.__lineEditKind:\n self._editor.setText(text)\n else:\n self._editor.setEditText(text)\n if text and self._editor.findText(text) == -1:\n self._editor.insertItem(0, text)",
"def updateText(widget,text,format=''):\n # autorecognition\n if format not in ['plain','html','rest']:\n if type(text) is str and text.startswith('..'):\n format = 'rest'\n\n # conversion\n if format == 'rest' and pf.options.rst2html:\n html = utils.rst2html(text)\n if html[:10] == text[:10]:\n #print \"CONVERSION TO HTML FAILED\"\n text += \"\\n\\nNote: This reStructuredText is displayed as plain text because it could not be converted to html. If you install python-docutils, you will see this text (and other pyFormex messages) in a much nicer layout!\\n\"\n else:\n text = html\n\n # We leave the format undefined, because we are not sure\n # that the conversion function (docutils) is available\n # and always produces good results\n format = ''\n\n if format == 'plain':\n widget.setPlainText(text)\n elif format == 'html':\n widget.setHtml(text)\n else:\n # As a last rescue, try QT4's autorecognition\n widget.setText(text)",
"def set_default_mode(args):\n default_repr = parser_opts[args.inputFormat].default_representation\n if not args.representation:\n args.representation = default_repr\n if args.representation != default_repr:\n log.info(\"Will convert from %s -> %s representation\", default_repr, args.representation)\n else:\n log.info(\"Using default %s particle representation\", args.representation)",
"def set_edits(self):\n self._window.input_line.setPlaceholderText('Input item to import')\n self._window.output_text.setPlaceholderText('Import Item')",
"def reset(self):\n self.setPlainText(self.label)\n self.setEditable(False)\n if (len(str(self.label)) > 0):\n self.setTextWidth(-1)\n else:\n self.setTextWidth(CurrentTheme.VERSION_LABEL_MARGIN[0])\n \n if self.isTag:\n self.setFont(CurrentTheme.VERSION_FONT)\n else:\n self.setFont(CurrentTheme.VERSION_DESCRIPTION_FONT) \n self.updatePos()\n self.parentItem().updateWidthFromLabel()",
"def initFormat(self):\n self.formatList = []",
"def update(self, instance: Snippet, validated_data: dict) -> Snippet:\n instance.title = validated_data.get('title', default=instance.title)\n instance.code = validated_data.get('code', default=instance.code)\n instance.language = validated_data.get('language', default=instance.language)\n instance.style = validated_data.get('style', default=instance.style)\n instance.save()\n return instance",
"def entry_b_modified(self, content):\n if content.isdigit():\n self.model.number_b = int(content)\n self.show_calculations()",
"def setCurrentValue(self, value: int, extend_range: bool=False):\n self.setText(str(self.__validate(value, extend_range)))\n self.__commitValue()",
"def asformat(self, format):",
"def __init__(self, value: str):\n self.options = [\n \"mg.min.m-3\",\n \"kg.s.m-3\"\n ]",
"def str_entered(self, tf, name):\n section, option = name\n text = tf.text\n _stash.config.set(section, option, text)\n self.save()",
"def getInitDefault(self):\n if self.initDefault in DateFormat.dateStampStrings:\n return GenDate().dateStr()\n return TextFormat.getInitDefault(self)",
"def __init__(self, value: str):\n self.options = [\n \"m3.s-1\",\n ]",
"def __editorConfigChanged(self, editor):\n fn = editor.getFileName()\n line, pos = editor.getCursorPosition()\n enc = editor.getEncoding()\n lang = editor.getLanguage()\n eol = editor.getEolIndicator()\n zoom = editor.getZoom()\n self.__setSbFile(\n fn, line + 1, pos, encoding=enc, language=lang, eol=eol, zoom=zoom)\n self._checkActions(editor, False)",
"def get_initial(self):\n\t\n\t#Getting the initial data and setting it\n initial = super(UpdateView, self).get_initial()\n\timage_ref = default_value.get_setting('compute', 'image_ref') \n flavor_ref = default_value.get_setting('compute', 'flavor_ref')\n initial.update({'test_id': self.kwargs['test_id'], 'image_ref': image_ref, 'flavor_ref': flavor_ref})\n return initial",
"def set_modified(self, value):\n self.modified = value\n self.save_button.setEnabled(value)",
"def set_modified(self, value):\n self.modified = value\n self.save_button.setEnabled(value)",
"def DoEdit(self,event):\r\n raise UncodedError",
"def rec_default(self):\n self.new_func_triggers.setText('(0,5)')\n self.new_param.setText('1')",
"def setValue(self, value):\n self.setText(str(value))",
"def __init__(self, value: str):\n self.options = [\n \"kg.m-3\"\n ]",
"def assign_format(self):\n if self.is_output or self.is_req_output:\n if self.pname in self.tool_data[self.tool_name]['output_fmt']:\n return self.tool_data[self.tool_name]['output_fmt'][self.pname]\n elif self.pname in self.gen_out_fmt:\n return self.gen_out_fmt[self.pname]\n elif self.is_input:\n if self.pname in self.tool_data[self.tool_name]['input_fmt']:\n print(self.tool_data[self.tool_name])\n return self.tool_data[self.tool_name]['input_fmt'][self.pname]\n elif self.pname in self.gen_in_fmt:\n return self.gen_in_fmt[self.pname]\n else:\n # Not sure yet what this will be used for, but I think we need it.\n return ''",
"def edit(self):\n _, tmp = tempfile.mkstemp()\n with open(tmp, 'w') as f:\n f.write(\"\".join([x + self.newline for x in self.buffer]))\n cledit = os.getenv('EDITOR') or 'vi'\n p = subprocess.Popen([cledit, tmp])\n p.wait()\n buffer = editor.contents(tmp)\n if not buffer:\n return\n else:\n self.buffer = buffer",
"def format_(self):\n return self.set_format or self.default_format or self.FALLBACK_FORMAT",
"def get_model_format_version(self):\n return None if self.model is None else self.model.get_format_version()",
"def edit(self):\n\n pass",
"def set_value_to_default(self):\n self.setValue(self.default_value)",
"def run(self, edit, text):\n\n self.view.replace(edit, sublime.Region(0, self.view.size()), text)",
"def testGetValueFromEditor(self):\r\n \r\n lineEdit = QtGui.QLineEdit()\r\n lineEdit.setText(QtCore.QString(u\"TestValue\"))\r\n self.assertEquals(self._editorFactory.getValueFromEditor(lineEdit), u\"TestValue\")\r\n \r\n lineEdit = QtGui.QLineEdit()\r\n lineEdit.setText(QtCore.QString(u\"\"))\r\n self.assertEquals(self._editorFactory.getValueFromEditor(lineEdit), None)\r\n \r\n spinBox = QtGui.QDoubleSpinBox()\r\n spinBox.setValue(23.04)\r\n self.assertEquals(self._editorFactory.getValueFromEditor(spinBox), 23.04)\r\n \r\n checkBox = QtGui.QCheckBox()\r\n checkBox.setChecked(True)\r\n self.assertTrue(self._editorFactory.getValueFromEditor(checkBox))\r\n \r\n comboBox = QtGui.QComboBox()\r\n comboBox.addItems([u\"test1\"])\r\n self.assertEquals(self._editorFactory.getValueFromEditor(comboBox), u\"test1\")\r\n \r\n listEditor = ListEditor(dict(), self._editorFactory, [\"test\"])\r\n self.assertEquals(self._editorFactory.getValueFromEditor(listEditor), [\"test\"])\r\n \r\n listEditor = ListEditor(dict(), self._editorFactory)\r\n self.assertEquals(self._editorFactory.getValueFromEditor(listEditor), list())",
"def update_editor ( self ):\n super( SimpleFontEditor, self ).update_editor()\n set_font( self )"
] | [
"0.62972623",
"0.62713385",
"0.62475604",
"0.6216652",
"0.60933644",
"0.60778177",
"0.6009081",
"0.5782725",
"0.561945",
"0.5530775",
"0.54974884",
"0.549157",
"0.54463965",
"0.54128057",
"0.5395345",
"0.5382154",
"0.53760034",
"0.5361667",
"0.53412473",
"0.52998084",
"0.5289389",
"0.52869236",
"0.52869236",
"0.5259486",
"0.5258819",
"0.52222645",
"0.52222645",
"0.5215186",
"0.5185209",
"0.51613635",
"0.5159629",
"0.5156949",
"0.51537293",
"0.5149537",
"0.51475304",
"0.5142282",
"0.51360196",
"0.5129256",
"0.51132214",
"0.5093449",
"0.50853586",
"0.50847447",
"0.50830996",
"0.5079649",
"0.5073335",
"0.5070425",
"0.5065359",
"0.50636923",
"0.505949",
"0.5054124",
"0.5048021",
"0.50445235",
"0.50234437",
"0.5021516",
"0.5009924",
"0.50038314",
"0.49990717",
"0.49904346",
"0.49880743",
"0.49787438",
"0.49762034",
"0.49664184",
"0.49618316",
"0.49618265",
"0.4934095",
"0.492767",
"0.49204952",
"0.49121454",
"0.49046645",
"0.48975104",
"0.48964268",
"0.48951375",
"0.48920292",
"0.4882344",
"0.48813882",
"0.4873522",
"0.48650837",
"0.48650536",
"0.48596686",
"0.48518443",
"0.48500192",
"0.48462826",
"0.48410955",
"0.48317665",
"0.48291975",
"0.48284602",
"0.48284602",
"0.4828238",
"0.48231953",
"0.48153916",
"0.48150164",
"0.48150015",
"0.4812036",
"0.4806887",
"0.4806189",
"0.4804705",
"0.47982624",
"0.47940466",
"0.47935316",
"0.47929528"
] | 0.6084278 | 5 |
Return initial value in edit format, found in edit format option | def getEditInitDefault(self):
if self.initDefault in TimeFormat.timeStampStrings:
return TimeFormat.timeStampStrings[1]
return TextFormat.getEditInitDefault(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getEditInitDefault(self):\n return self.formatEditText(self.initDefault)[0]",
"def getEditInitDefault(self):\n if self.initDefault in DateFormat.dateStampStrings:\n return DateFormat.dateStampStrings[1]\n return TextFormat.getEditInitDefault(self)",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def storedText(self, editText):\n format = globalref.options.strData('EditDateFormat', True)\n try:\n return (repr(GenDate().setFromStr(editText, format)), True)\n except GenDateError:\n return (editText, not editText and not self.isRequired)",
"def setInitDefault(self, editText):\n self.initDefault = self.storedText(editText)[0]",
"def setInitDefault(self, editText):\n if editText in DateFormat.dateStampStrings:\n self.initDefault = DateFormat.dateStampStrings[0]\n else:\n TextFormat.setInitDefault(self, editText)",
"def setInitDefault(self, editText):\n if editText in TimeFormat.timeStampStrings:\n self.initDefault = TimeFormat.timeStampStrings[0]\n else:\n TextFormat.setInitDefault(self, editText)",
"def on_edit_changed(self, edit):\n\t\tself.emit('value-changed', edit.get_text())",
"def assign_format(self):\n if self.is_output or self.is_req_output:\n if self.pname in self.tool_data[self.tool_name]['output_fmt']:\n return self.tool_data[self.tool_name]['output_fmt'][self.pname]\n elif self.pname in self.gen_out_fmt:\n return self.gen_out_fmt[self.pname]\n elif self.is_input:\n if self.pname in self.tool_data[self.tool_name]['input_fmt']:\n print(self.tool_data[self.tool_name])\n return self.tool_data[self.tool_name]['input_fmt'][self.pname]\n elif self.pname in self.gen_in_fmt:\n return self.gen_in_fmt[self.pname]\n else:\n # Not sure yet what this will be used for, but I think we need it.\n return ''",
"def editText(self, item):\n storedText = item.data.get(self.name, '')\n result = self.formatEditText(storedText)\n if self.isRequired and not result[0]:\n return (result[0], False)\n return result",
"def retrieve_input():\r\n inputValue = simpleText.get(\"1.0\",\"end-1c\") #Our Variable\r\n #\"1.0\" = start from first character in the text widget\r\n #\"end-1c = delete the last character that Text creates every time\"\r\n return inputValue",
"def get_initial(self):\n\t\treturn self.initial",
"def storedText(self, editText):\n try:\n return (repr(GenNumber().setFromStr(editText, self.format)), True)\n except GenNumberError:\n return (editText, not editText and not self.isRequired)",
"def make_input(value):\n what = value[0]\n if what.startswith('not editable'):\n what = what.replace('not editable:', '').replace(\"'\", \"\\'\")\n if what.startswith('attribute:value:'):\n what = what.replace('attribute:value:', '').replace(\"'\", \"\\'\")\n return what",
"def get_val_str(self):\n fmt_str = self.template.get_format_str()\n if self.val_obj is None:\n return \"\"\n elif fmt_str:\n return fmt_str % (self.val_obj.val)\n else:\n return str(self.val_obj.val)",
"def get_opt_formatted(self, command):\n if \"formatted\" in self.command_dict[\"commands\"][command].keys():\n return self.command_dict[\"commands\"][command][\"formatted\"]\n else:\n return CommandDict.DEFAULT_OPT_FORMATTED",
"def formatsrc(self):\n return self[\"formatsrc\"]",
"def formatsrc(self):\n return self[\"formatsrc\"]",
"def formatEditText(self, storedText):\n format = globalref.options.strData('EditDateFormat', True)\n try:\n return (GenDate(storedText).dateStr(format), True)\n except GenDateError:\n return (storedText, not storedText)",
"def get_initial(self):\n return self.initial",
"def getInitDefault(self):\n if self.initDefault in DateFormat.dateStampStrings:\n return GenDate().dateStr()\n return TextFormat.getInitDefault(self)",
"def storedText(self, editText):\n if editText in self.formatList:\n return (editText, True)\n return (editText, not editText and not self.isRequired)",
"def format(self):\n return self.getparam(\"FORMAT\")",
"def format(self):\n return self.getparam(\"FORMAT\")",
"def _getAlterToFormat(cls, alter):\n if alter == '':\n alter = ['', '']\n if isinstance(alter, str): # nothing to do if it is dict\n alter = ['', alter]\n return alter",
"def value(self):\n return str(self.input.currentText())",
"def presentation(self, value):\r\n return value",
"def default_formatter(self, data):\n return data",
"def get_format(self):\n return self._format[0]",
"def initial_value(self):\n return self._initial_value",
"def get_value_display(self):\r\n if self.display_as == 'percentage':\r\n return '{0}%'.format(self.latest_value)\r\n if self.display_as == 'boolean':\r\n return bool(self.latest_value)\r\n if self.display_as == 'byte':\r\n return defaultfilters.filesizeformat(self.latest_value)\r\n if self.display_as == 'second':\r\n return time.strftime('%H:%M:%S', time.gmtime(self.latest_value))\r\n return self.latest_value",
"def edition(self, key, value):\n return clean_val(\"a\", value, str).replace(\"ed.\", \"\")",
"def format_(self):\n return self.set_format or self.default_format or self.FALLBACK_FORMAT",
"def formatEditText(self, storedText):\n return (storedText, True)",
"def formatEditText(self, storedText):\n return (storedText, True)",
"def get_format(self):\n pass",
"def get_value ( self, object ):\n try:\n if self.format_func is not None:\n return self.format_func( self.get_raw_value( object ) )\n\n return self.format % ( self.get_raw_value( object ), )\n except:\n logger.exception( 'Error occurred trying to format a %s value' %\n self.__class__.__name__ )\n return 'Format!'",
"def format(self) -> str:",
"def int_format(self):\n ...",
"def get_input_data(input_section: Dict) -> str:\n default_value = input_section.get(\"value\")\n if isinstance(default_value, str):\n return default_value\n\n if default_value:\n complex_field = default_value.get(\"complex\")\n if complex_field:\n if complex_field.get(\"accessor\"):\n return f\"{complex_field.get('root')}.{complex_field.get('accessor')}\"\n else:\n return f\"{complex_field.get('root')}\"\n return default_value.get(\"simple\")\n\n return \"\"",
"def _get_field_edit_widget(self, row_index):\n field_row = self.field_rows[row_index]\n if not field_row.editable:\n raise TypeError(\"Cannot edit a boolean or dropdown field. (Internal error, tell the developer!)\")\n field_type = field_row.field_type\n field_value = self.get_field_dict(self.get_entry_id(self.active_row_index))[field_row.field_name]\n initial_text = repr(sorted(field_value)) if issubclass(field_type, list) else str(field_value)\n return self.Entry(\n field_row.value_box,\n initial_text=initial_text,\n integers_only=field_type == int,\n numbers_only=field_type == float,\n sticky=\"ew\",\n width=5,\n )",
"def formatEditText(self, storedText):\n try:\n return (GenNumber(storedText).numStr(self.format), True)\n except GenNumberError:\n return (storedText, not storedText)",
"def get_value ( self, object ):\n try:\n value = getattr( object, self.name )\n try:\n return self.format % ( value, )\n except:\n return 'Format!'\n except:\n return 'Undefined!'",
"def value(self):\n self.refresh_default_value()\n return self.default_value",
"def initial(self):\n return self.args[3]",
"def asformat(self, format):",
"def _format_default_value(self, default):\n return json.dumps(default)",
"def getValue(self):\n return self.field.currentText()",
"def format(self):\n return self._format",
"def createEditor(self, parent, option, index):\n editor = QLineEdit(parent)\n date = index.model().data(index, Qt.DisplayRole)\n editor.setText(date.strftime(self.format))\n return editor",
"def _getDefaultValue(self):\n value = self._getDefaultValue()\n return value.getData() if value else None",
"def _getAlter(self):\n return self._getAlterToFormat(self.attr('alter'))",
"def format( self ) :\n\n return( self.__format )",
"def format(self):\n return self[\"format\"]",
"def format(self):\n return self[\"format\"]",
"def display_value(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"display_value\")",
"def display_value(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"display_value\")",
"def initFormat(self):\n pass",
"def after_init(self):\n if self.options.format.appended:\n self.error_format = self.options.format.appended[0]",
"def format(self) -> str:\n return pulumi.get(self, \"format\")",
"def default_from(self):\n\n return \"\"",
"def value_unformatted(self):\n return self._unformated_value",
"def get_prep_value(self, value):\n\n try:\n return value.isoformat()\n except:\n pass\n\n # maybe value is a string containing a PartialDate?\n try:\n pd = string_to_partialdate(value)\n return pd.isoformat()\n except:\n return ''",
"def default(self):\n\n return self._get_field(\"value\")",
"def special_case(self):\n Input.clear_display(self, self.entries[4])\n self.entries[4].insert(INSERT, '1712/02/30 was a real date in Sweden')\n self.entries[4].configure(state='readonly')",
"def format(self):\n ...",
"def __str__(self):\n return '[{0}, {1}]'.format(self.timeValuePairs, self.defaultValue)",
"def get_value( self, trans, grid, repository ):\n select_field = grids_util.build_changeset_revision_select_field( trans, repository, downloadable=False )\n if select_field.options:\n return select_field.options[ 0 ][ 0 ]\n return ''",
"def format_field(model, name, value):\n if value is None: return value\n t = type( getattr(model,name) )\n if t == datetime:\n return value.replace('T',' ')\n return value",
"def update_format_string(self):\n if self._show_units:\n units = \" {}\".format(self._unit)\n else:\n units = \"\"\n\n if self._show_step_exponent:\n self.setSuffix(\"{0} Step: 1E{1}\".format(units, self.step_exponent))\n self.lineEdit().setToolTip(\"\")\n else:\n self.setSuffix(units)\n self.lineEdit().setToolTip('Step: 1E{0:+d}'.format(self.step_exponent))",
"def _get_FIELD_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n template = ''\n template += '{:d}' if field.decimals == 0 else '{:.%sf}' % field.decimals\n template += ' ' if field.spaced_display else ''\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def get_value(self, key, args, kwargs):\n if self.default is not None:\n try:\n return string.Formatter.get_value(self, key, args, kwargs)\n except KeyError:\n return self.default\n else:\n return string.Formatter.get_value(self, key, args, kwargs)",
"def get_value( self, trans, grid, repository ):\n # A repository's metadata revisions may not all be installable, as some may contain only invalid tools.\n select_field = grids_util.build_changeset_revision_select_field( trans, repository, downloadable=False )\n if len( select_field.options ) > 1:\n return select_field.get_html()\n elif len( select_field.options ) == 1:\n option_items = select_field.options[ 0 ][ 0 ]\n rev_label, rev_date = option_items.split( ' ' )\n rev_date = '<i><font color=\"#666666\">%s</font></i>' % rev_date\n return '%s %s' % ( rev_label, rev_date )\n return select_field.options[ 0 ][ 0 ]\n return ''",
"def edit():",
"def get_value( self, trans, grid, repository ):\n select_field = grids_util.build_changeset_revision_select_field( trans, repository, downloadable=True )\n if len( select_field.options ) > 1:\n return select_field.get_html()\n elif len( select_field.options ) == 1:\n return select_field.options[ 0 ][ 0 ]\n return ''",
"def get_new_value(self):\r\n if self.initial_value is None:\r\n return None\r\n\r\n return deepcopy(self.initial_value)",
"def value(self):\n return str(self.input.text())",
"def fmt_option_val(option):\n if option is None:\n return \"\"\n return str(option)",
"def getInitDefault(self):\n if self.initDefault in TimeFormat.timeStampStrings:\n return GenTime().timeStr()\n return TextFormat.getInitDefault(self)",
"def get_default_value(self):\n pass",
"def storedText(self, editText):\n try:\n return (repr(GenBoolean(editText)), True)\n except GenBooleanError:\n if editText in self.formatList:\n return (editText, True)\n return (editText, not editText and not self.isRequired)",
"def get_one(self, *args, **kw):\n #this would probably only be realized as a json stream\n tmpl_context.widget = self.edit_form\n pks = self.provider.get_primary_fields(self.model)\n kw = {}\n for i, pk in enumerate(pks):\n kw[pk] = args[i]\n value = self.edit_filler.get_value(kw)\n return dict(value=value,model=self.model.__name__)",
"def getValue(self):\n return self.initValue",
"def get_note_value(self):\n return f\"{self.first_name} {self.last_name}\"",
"def _get_nullformat(self, newformat):\n if self._type == int:\n length = len(str(newformat % 1))\n return '%'+str(length)+'s'\n elif self._type == float:\n length = len(str(newformat % 1.0))\n return '%'+str(length)+'s'\n else:\n return newformat",
"def getEditChoices(self, currentText=''):\n return [(text, '') for text in self.formatList]",
"def set_format(cls,format):\n import __main__\n IP = __main__.__dict__['__IP']\n prompt = getattr(IP.outputcache,cls._prompt)\n prompt.p_template = format\n prompt.set_p_str()\n cls._format = format",
"def value(self):\n s = str(self.input.toPlainText())\n if self._is_string_:\n return s\n else:\n return eval(s)",
"def get_initial(self):\n return self.initial[:]",
"def value(self):\n value = super(SpeciesListFilter, self).value()\n if value is None:\n if self.default_value is None:\n first_species = Book.objects.order_by('title').first()\n value = None if first_species is None else first_species.id\n self.default_value = value\n else:\n value = self.default_value\n return str(value)",
"def formatEditText(self, storedText):\n format = globalref.options.strData('EditTimeFormat', True)\n try:\n return (GenTime(storedText).timeStr(format), True)\n except GenTimeError:\n return (storedText, not storedText)",
"def storedText(self, editText):\n choices, valid = self.sortedChoices(editText)\n if valid:\n return (self.editSep.join(choices), True)\n else:\n return (editText, not editText and not self.isRequired)",
"def render_input(env_spec_entry):\n default_value = env_spec_entry[\"default_value\"]\n default_value_state = f'value=\"{default_value}\"' if default_value else \"\"\n\n env_spec_entry_input = (\n f'<input id=\"env_spec_{env_spec_entry[\"name\"].lower()}\" '\n f'name=\"{env_spec_entry[\"name\"].lower()}\" type=\"{env_spec_entry[\"type\"]}\" '\n f'{default_value_state}\" />\\n'\n )\n return env_spec_entry_input",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def format_default(reg):\n\t\tif reg.size == \"accum\":\n\t\t\treturn str(float(reg.default)) + \"k\"\n\t\telse:\n\t\t\treturn str(int(reg.default)) + \"L\"",
"def field_value(self):\n return \"{}_{}\".format(self.place.id, self.line_location)",
"def Value(self) -> str:",
"def get_display_value(self):\n\n\t\treturn self.__display_value",
"def default_field_formatter(variable_name: str, field: Field) -> str:\n return \"{{ \" + f\"form.{variable_name}\" + \" }}\"",
"def adjust(self):\n if self._adjust is None:\n return \"\"\n return self._adjust"
] | [
"0.7327655",
"0.69168735",
"0.6163817",
"0.5962609",
"0.59190995",
"0.5825621",
"0.5639453",
"0.55958575",
"0.5588548",
"0.55880916",
"0.55728984",
"0.5547174",
"0.55372924",
"0.5518307",
"0.55125266",
"0.54999983",
"0.54888153",
"0.54888153",
"0.54887563",
"0.5471209",
"0.5466419",
"0.545412",
"0.54069316",
"0.54069316",
"0.53839904",
"0.5377033",
"0.53640187",
"0.53620666",
"0.5355793",
"0.5349789",
"0.5343258",
"0.5341933",
"0.533963",
"0.53153485",
"0.53153485",
"0.5288899",
"0.5269197",
"0.5263535",
"0.5258517",
"0.5249449",
"0.52473253",
"0.5231447",
"0.52152646",
"0.5197711",
"0.5186485",
"0.51838565",
"0.51748896",
"0.5161524",
"0.51536065",
"0.51321536",
"0.51240325",
"0.51217145",
"0.5121519",
"0.5117097",
"0.5117097",
"0.51054955",
"0.51054955",
"0.5105423",
"0.5100754",
"0.50976294",
"0.5095106",
"0.50944275",
"0.50924397",
"0.508725",
"0.5084116",
"0.5081867",
"0.50796103",
"0.5072638",
"0.5071877",
"0.5069576",
"0.50672466",
"0.50647104",
"0.5051511",
"0.5050451",
"0.50481766",
"0.5046123",
"0.49976718",
"0.49971545",
"0.49888214",
"0.49814808",
"0.4975419",
"0.4968391",
"0.4959143",
"0.49534622",
"0.4947233",
"0.49469805",
"0.4945034",
"0.49448776",
"0.4943174",
"0.49430725",
"0.493905",
"0.49366254",
"0.49283075",
"0.49213216",
"0.4913436",
"0.49123442",
"0.49113816",
"0.49082282",
"0.49070314",
"0.4901602"
] | 0.6777391 | 2 |
Return a list of choices for setting the init default | def initDefaultChoices(self):
choices = [entry[0] for entry in self.getEditChoices()]
choices.insert(0, TimeFormat.timeStampStrings[1])
return choices | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initDefaultChoices(self):\n return []",
"def initDefaultChoices(self):\n return [entry[0] for entry in self.getEditChoices()]",
"def initDefaultChoices(self):\n return [text for text in self.formatList]",
"def initDefaultChoices(self):\n choices = [entry[0] for entry in self.getEditChoices()]\n choices.insert(0, DateFormat.dateStampStrings[1])\n return choices",
"def get_choices(self):\n raise NotImplementedError()",
"def get_choices(self):\n raise NotImplementedError()",
"def get_choices(self, instance):\n if instance.type == BaseParameter.CHOICE_TYPE:\n return [\n x.value\n for x in instance.get_typed_parameter().get_available_choices()\n ]\n else:\n return None",
"def choices(self):\n return self.__class__.get_setting_choices(self.key, **self.get_kwargs())",
"def choices() -> List[str]:\n return [t.name.upper() for t in ConfigurationVariable]",
"def choices(self) -> list:\n return [self.mapper(i) for i in self.keys()]",
"def as_choices():\n return (\n # Live is currently disabled as a choice\n # pending implementation\n (\"live\", \"Use working directory\"),\n (\"latest\", \"Use latest snapshot\"),\n (\"pinned\", \"Pinned to snapshot\"),\n )",
"def choices(self):\n # Needs to be implmented by subclass\n raise Exception(NotImplemented)",
"def choices(cls):\n _choices = []\n for attr in _user_attributes(cls):\n val = getattr(cls, attr)\n setattr(cls, attr[1:], val[0])\n _choices.append((val[0], val[1]))\n setattr(cls, 'CHOICES', tuple(_choices))\n return cls",
"def valid_options(self):\n choices = self.choices()\n\n if not choices:\n return None\n\n return [opt[0] for opt in choices]",
"def choices(cls):\n # return list(map(tuple, cls.__members__.items()))\n return [(int(code), name) for name, code in cls.__members__.items()]",
"def choices(self):\n\n if self._choices == None:\n self._choices = [ExperimentChoice(self, choice_name) for choice_name in self.choice_names]\n\n return self._choices",
"def get_choices(cls):\n return cls.values.items()",
"def __init__(self,choices,caption='ListSelection',default=[],single=False,check=False,sort=False,*args,**kargs):\n InputDialog.__init__(self,caption=caption,items = [\n dict(name='input',value=default,itemtype='list',choices=choices,\n text='',single=single,check=check,sort=sort,*args,**kargs),\n ],)",
"def choices(self):\n return tuple(self._choices)",
"def get_choices_for_model_field(cls):\n return [c[0:2] for c in cls.attr_choices]",
"def multiple_choice():\n\n return [\"MAR\", \"MAR\", \"NI\", \"NI\", \"MCAR\"]",
"def choices(cls):\n return tuple(item.as_tuple for item in list(cls))",
"def as_choices(cls, key_type=None):\n if key_type is None:\n key_type = cls.get_default_choice_type()\n return cls.enum_class.as_choices(key_type)",
"def _set_default_suits(self):\n # set up suits\n suit_types = [('Spades', 1), ('Hearts', 2), ('Diamonds', 3), ('Clubs', 4)]\n # populate the list of suits\n suit_list = list()\n for s in suit_types:\n suit_list.append(Suit(s[0], s[1]))\n\n return suit_list",
"def choices(self) -> list:\n return [self.mapper(item) for item in self]",
"def _resolve_defaults(self, **kwargs):\n res = list()\n for name, value in kwargs.items():\n if value is None:\n value = self.default(name)\n if value is None:\n raise RuntimeError(f\"Missing default {name}\")\n res.append(value)\n return res",
"def __init__(self, *args, **kwargs):\n super(ChoiceFieldType, self).__init__(*args, **kwargs)\n\n self.choices = self.get_field_info_key('choices')",
"def get_setting_choices(cls, key, **kwargs):\n setting = cls.get_setting_definition(key, **kwargs)\n\n choices = setting.get('choices', None)\n\n if callable(choices):\n # Evaluate the function (we expect it will return a list of tuples...)\n return choices()\n\n return choices",
"def initDefaults(self):\n return _libsbml.Parameter_initDefaults(self)",
"def create_default_repo_choice(self, default_repo):\n return (default_repo, default_repo)",
"def get_template_base_dir_choices() -> list[tuple[str, str]]:\n # handle predefined choices\n choices, seen = [], set()\n for template_name in TemplateName:\n choices.append((template_name.value, template_name.label))\n seen.add(template_name.value)\n\n # handle custom choices via settings\n for template_name, display_name in getattr(settings, \"CAST_CUSTOM_THEMES\", []):\n if template_name not in seen:\n choices.append((template_name, display_name))\n seen.add(template_name)\n\n # search for template base directories\n template_directories = get_template_directories()\n template_base_dir_candidates = get_template_base_dir_candidates(template_directories)\n for candidate in template_base_dir_candidates:\n if candidate not in seen:\n choices.append((candidate, candidate))\n\n return choices",
"def initialise_options():\r\n default_options = list(range(NUMBER_OF_TILES))\r\n default_weights = [1/NUMBER_OF_TILES]*NUMBER_OF_TILES\r\n return default_options, default_weights",
"def default_controls(self):\n\t\tcontrol_list = []\n\t\tconfig = ConfigParser.ConfigParser()\n\t\tconfig.read(\"./config.ini\")\n\t\tcontrols = config.options(\"default_controls\")\n\t\tfor c in controls:\n\t\t\ttry: control_list.append( config.get(\"default_controls\", c) )\n\t\t\texcept:\n\t\t\t\tprint \"ERROR: missing control settings. Check config.ini.\"\n\t\t\t\traise(SystemExit)\n\t\treturn control_list",
"def default_variation(random, candidates, args):\r\n return candidates",
"def default_variation(random, candidates, args):\r\n return candidates",
"def get_default_options():\n return GROUPS_.values()",
"def __init__(self, *initial):\n self.prompt_list = list(initial)",
"def get_choices_new_protected():\n ret = []\n ret.append( (1, _(u'Nur Community-Mitglieder dürfen neue Beiträge leisten')) )\n ret.append( (-1, _(u'Offener Zugang')) )\n return ret",
"def choices(self, var):\r\n return (self.curr_domains or self.domains)[var]",
"def choices(self, choices):\n\n self._choices = choices",
"def get_choices_for_var(self, var):\n return self.choices[var]",
"def get_options(self):\n return []",
"def getEditChoices(self, currentText=''):\n return [(text, '') for text in self.formatList]",
"def set_defaults(self):\r\n for name, option in self.options.iteritems():\r\n if not option.is_required():\r\n self.set_value(name, option, option.default)",
"def default_value_list(sources: List[str] = None):\n if not default:\n return list()\n if not sources:\n return [default]\n else:\n return sources",
"def _get_target_choices():\n apps = [('public', _(\"Public website\"))]\n for model, entity in registry.registry.items():\n if entity.menu:\n appname = model._meta.app_label.lower()\n apps.append((appname, unicode(entity.label)))\n return tuple(apps)",
"def get_generic_choices(model, key, allow_null=False):\n CHOICES = [('', '--------')] if allow_null else []\n for i in model.objects.all().values_list(key, flat=True).distinct():\n CHOICES.append((str(i), str(i)))\n CHOICES.sort()\n\n return CHOICES",
"def get_default_is_selected_index(self, choicesdata):\n\n return 0",
"def _create_defaults(self):\n return DefaultCommandOptionValues(\n min_confidence=3, output_format='vs7')",
"def __init__(self, choices, *args, **kwargs):\n super(RangePollChoiceForm, self).__init__(*args, **kwargs)\n nominees = [(i, '%d' % i) for i in range(0, choices.count()+1)]\n for choice in choices:\n self.fields['range_poll__%s' % str(choice.id)] = (\n forms.ChoiceField(widget=forms.Select(),\n choices=nominees,\n label=choice.nominee.get_full_name()))",
"def create_options(self):\n return []",
"def Choices(cls):\n attr = '_choice_attr_' + cls.__name__\n if hasattr(cls, attr):\n return getattr(cls, attr)\n\n choices = set()\n for (k, v) in cls.__dict__.items():\n if not k.startswith('_') and issubclass(type(v), (str, unicode)):\n choices.add(v)\n for base in cls.__bases__:\n if issubclass(base, ChoiceBase) and base is not ChoiceBase:\n choices = set.union(choices, base.Choices())\n setattr(cls, attr, choices)\n\n return choices",
"def multiple_choices(self, choices, response):\n for elem in self.method_order:\n if elem in choices:\n return [elem]\n raise NoData",
"def form_SelectChoiceDefault(request):\n schema = schemaish.Structure()\n schema.add('mySelect', schemaish.Integer())\n options = [(1,'a'),(2,'b'),(3,'c')]\n\n form = formish.Form(schema, 'form')\n form['mySelect'].widget = formish.SelectChoice(options)\n form['mySelect'].default = 2\n return form",
"def season_choices():\n return [(s, s) for s in range(0, 3)]",
"def is_a_list_of_choices(self):\n pass",
"def setChoices(self, choices):\n self.getGtkObject('property_liststore').clear()\n for choice in choices:\n self.getGtkObject('property_liststore').append([str(choice)])",
"def _get_choices ( self, context, path = '' ):\n choices = []\n gdc = context.get_data_context\n for name in context.data_contexts:\n next_path = path_for( path, name )\n choices.append( TemplateChoice( choice_value = next_path ) )\n choices.extend( self._get_choices( gdc( name ), next_path ) )\n \n return choices",
"def choices(symbols, k):\n return [R.choice(symbols) for _ in range(k)]",
"def episode_choices():\n return [(e, e) for e in range(0, 2)]",
"def setAll(self):\n self.setValue(self._choices_)",
"def configure_list_of_choices_type_question(self, question_data):\n self.driver.find_radio_button(LIST_OF_CHOICE_RB).click()\n index = 1\n for choice in fetch_(CHOICE, from_(question_data)):\n if index > 1:\n self.driver.find(ADD_CHOICE_LINK).click()\n self.driver.find_text_box(by_xpath(CHOICE_XPATH_LOCATOR + \"[\" + str(index) + \"]\" + CHOICE_TB_XPATH_LOCATOR)).enter_text(choice)\n index += 1\n choice_type = fetch_(ALLOWED_CHOICE, from_(question_data))\n if ONLY_ONE_ANSWER == choice_type:\n self.driver.find_radio_button(ONLY_ONE_ANSWER_RB).click()\n elif MULTIPLE_ANSWERS == choice_type:\n self.driver.find_radio_button(MULTIPLE_ANSWER_RB).click()\n return self",
"def get_init_list(self):\n\n return self.convert_compartments_to_list(self.init_compartments)",
"def __init__(self, choiceList=None, prompt=DEFAULT_PROMPT, title=DEFAULT_TITLE):\n self.choice = None\n \n wpf.LoadComponent(self, GUI_XAML_FILE)\n \n self.Title = title\n self.lblPrompt.Content = prompt\n \n self.choicesBox.ItemsSource = choiceList",
"def initDefaults(self):\n return _libsbml.Species_initDefaults(self)",
"def __init__(self, *args, **kwargs):\n super(TaggedContentItemForm, self).__init__(*args, **kwargs)\n wtf = Tag.objects.filter(group__system=False)\n wlist = [w for t, w in self.fields.items() if t.endswith(\"tags\")]\n choices = []\n for choice in wtf:\n choices.append((choice.id, str(choice)))\n [setattr(w, 'choices', choices) for w in wlist]",
"def _get_choices_str(self):\n return ', '.join(\n '\"%s\"' % choice\n for choice in self.choices\n )",
"def get_defaults(self):\n\t\treturn self.__defaults",
"def choices(self):\n self._choices = self.getChoices()\n return len(self._choices)",
"def init_defaults(self, defaults):\r\n for (sect, opt, default) in defaults:\r\n self._default(sect, opt, default)",
"def choices(self, cl):\n # TODO: Determine if non-static choices would be cleaner here.\n # Honestly, I tried a more generic version and it was even harder to\n # follow than this version.\n yield {\n 'selected': not (self.lookup_val_gte or self.lookup_val_lt),\n 'query_string': cl.get_query_string({}, [self.lookup_kwarg_gte,\n self.lookup_kwarg_lt]),\n 'display': 'All'\n }\n\n goal = settings.FACEBOOK_CLICK_GOAL\n yield {\n 'selected': self.lookup_val_gte and not self.lookup_val_lt,\n 'query_string': cl.get_query_string({self.lookup_kwarg_gte: goal},\n [self.lookup_kwarg_lt]),\n 'display': 'Yes'\n }\n yield {\n 'selected': self.lookup_val_lt and not self.lookup_val_gte,\n 'query_string': cl.get_query_string({self.lookup_kwarg_lt: goal},\n [self.lookup_kwarg_gte]),\n 'display': 'No'\n }",
"def choices(self, typename, value_field='description'):\n rows = self.type(typename).values('id', value_field)\n return [(r['id'], r[value_field]) for r in rows]",
"def default_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"default_values\")",
"def test_get_prior_string_list(self):\n categories = list(range(10))\n categories[0] = \"asdfa\"\n categories[2] = \"lalala\"\n dim = Categorical(\n \"yolo\", categories, shape=2, default_value=[\"asdfa\", \"lalala\"]\n )\n assert dim.get_prior_string() == (\n \"choices(['asdfa', 1, 'lalala', 3, 4, 5, 6, 7, 8, 9], \"\n \"shape=2, default_value=['asdfa', 'lalala'])\"\n )",
"def get_choices(self, cutoff=None):\n queryset = self.get_queryset()\n if queryset is None:\n # Ensure that field.choices returns something sensible\n # even when accessed with a read-only field.\n return {}\n\n if cutoff is not None:\n queryset = queryset[:cutoff]\n\n return OrderedDict(\n [\n (\n # This line below is modifed.\n item.pk,\n self.display_value(item),\n )\n for item in queryset\n ]\n )",
"def choices(self, choices: Iterable[Tuple[str, str]]):\n try:\n iter(choices)\n except TypeError:\n raise TypeError(\"'choices' isn't a valid iterable\")\n\n apply_choices = []\n for i, (choice_id, choice_label) in enumerate(choices):\n apply_choices.append((str(choice_id), str(choice_label)))\n\n if len(apply_choices) < 2:\n raise ValueError(\"you need to specify at least two choices\")\n\n self._choices = apply_choices\n self.specific.refresh()\n self._selected = 0",
"def choose_option(self, state):\n options = [o for o in self.options if o.initiation_set[state] == 1]\n return random.choice(options)",
"def setUp(self):\n current_date = date.today()\n name = 'name'\n possible_meals = [Meal(date=current_date, name=name)]\n self.possible_meals_choices = [(possible_meal.id, possible_meal.name)\n for possible_meal in possible_meals]",
"def all_options():\n return _OptionRegistry.values()",
"def __init__(self, name, attrs={}):\n ChoiceFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n ChoiceFormat.__init__(self, name, attrs)",
"async def choices(self, ctx, *, options):\n choices = options.split('-')\n choice = random.choice(choices)\n await ctx.send(f'My choice is\\\"{choice}\\\"')",
"def get_chosen_options(user):\n user_profile = user.get_profile()\n user_application = user_profile.application\n np = user_application.np\n ocl = eval(user_application.options_selected)\n chosen_options = []\n for oc in ocl:\n chosen_options.append(Option.objects.get(opt_code=int(oc))) \n return chosen_options",
"def initialize_options(self):",
"def initDefaults(self):\n return _libsbml.Reaction_initDefaults(self)",
"def calendar_choices(self):\n if not self._calendars:\n if self.authenticated:\n default = self.account.schedule().get_default_calendar()\n # {\n # \"default\" : <DEFAULT_CALENDAR>,\n # \"<CALENDAR_NAME>: <CALENDAR>,\n # ...\n # }\n self._calendars = {\n DEFAULT_CALENDAR: default,\n **{\n c.name: c\n for c in self.account.schedule().list_calendars() if c.name != default.name\n }\n }\n\n return self._calendars",
"def get_options(self):\r\n return self._option_values",
"def getOptionsNames(self) -> List[unicode]:\n ...",
"def default_args(self) -> Optional[list[str]]:\n _args: list[Arg] = []\n _ctx = self._select(\"defaultArgs\", _args)\n return _ctx.execute_sync(Optional[list[str]])",
"def get_choicesdata(self):\n # selected_value = self.get_cleaned_value()\n # choicesdata = []\n # found_selected_value = False\n # for value, label in self.get_choices():\n # is_selected = value == selected_value\n # if is_selected:\n # found_selected_value = True\n # url = self.build_set_values_url(values=[value])\n # choicesdata.append({\n # 'url': url,\n # 'label': label,\n # 'is_selected': is_selected\n # })\n choicesdata, found_selected_value = self.__make_choicesdata_list(\n choices=self.get_choices(),\n selected_value=self.get_cleaned_value())\n if not found_selected_value and len(choicesdata) > 0:\n selected_index = self.get_default_is_selected_index(choicesdata=choicesdata)\n choicesdata[selected_index]['is_selected'] = True\n return choicesdata",
"def available_binary_choices() -> Iterable[str]:\n for name, _ in inspect.getmembers(sys.modules[__name__], inspect.isclass):\n if name.startswith('Binary'):\n yield name",
"def initDefaults(self):\n return _libsbml.Event_initDefaults(self)",
"def form_CheckboxMultiChoiceDefault(request):\n schema = schemaish.Structure()\n schema.add('multiChoice', schemaish.Sequence(schemaish.Integer()))\n options = [(1,'a'),(2,'b'),(3,'c')]\n\n form = formish.Form(schema, 'form')\n form['multiChoice'].widget = formish.CheckboxMultiChoice(options)\n form['multiChoice'].default = [2]\n return form",
"def default_selection(random, population, args):\r\n return population",
"def form_SequenceOfStringsWithDefault(request):\n schema = schemaish.Structure()\n schema.add( 'myList', schemaish.Sequence( schemaish.String() ))\n\n form = formish.Form(schema, 'form')\n form.defaults = {'myList': ['a','b']}\n return form",
"def test_model_choices_all_models(self):\n unique_action_admin = UniqueActionAdmin(UniqueAction, self.site)\n\n self.assertFalse(getattr(unique_action_admin, '_model_choices', False))\n\n model_choices = unique_action_admin.model_choices()\n\n self.assertTrue(getattr(unique_action_admin, '_model_choices'))\n self.assertTrue(isinstance(model_choices, list))",
"def sel_prep(self):\n sel_blob = []\n for sel in self.blob['options']:\n if self.blob['defaultValue'] == sel['name']:\n sel_blob.append({'value': sel['name'], 'selected': 'true'})\n else:\n sel_blob.append({'value': sel['name'], 'selected': 'false'})\n\n return sel_blob",
"def test_default(self):\n for n in range(1, 5):\n for prefix in ['', 'git-', 'gbp-']:\n parser = GbpOptionParser('%scmd%d' % (prefix, n))\n self.assertEqual(parser.config['default_option'], 'default_default1')",
"def setChoices(self,report):\n\t\tif report is not None:\n\t\t\tbrowser = report[1]['objects']\n\n\t\t\tif browser is not None:\n\t\t\t\tbrowserChoices = list()\n\t\n\t\t\t\t#compute select list\n\t\t\t\tfor b in browser:\n\t\t\t\t\tif \"chrome\" in b['name'].lower():\n\t\t\t\t\t\tformString = constConfig.HISTORY_FORM_CHROME\n\t\t\t\t\telif \"firefox\" in b['name'].lower():\n\t\t\t\t\t\tformString = constConfig.HISTORY_FORM_FF\n\t\t\t\t\telif \"thunderbird\" in b['name'].lower():\n\t\t\t\t\t\tformString = constConfig.HISTORY_FORM_TH\n\n\t\t\t\t\tfor p in b['profiles']:\n\t\t\t\t\t\tformValue = str(formString)+\"_\"+p['profileName']\t\n\t\t\t\t\t\tbrowserChoices.append((formValue,b['name']+\" - \"+p['profileName']))\n\t\t\t\n\t\t\t\tch = forms.ChoiceField(label=\"Profile\",widget=forms.Select(attrs={'class':'form-control'}),choices=browserChoices)\n\t\t\t\tself.fields['choices'] = ch",
"def form_SelectWithOtherChoiceDefault(request):\n schema = schemaish.Structure()\n schema.add('mySelect', schemaish.Integer())\n options = [(1,'a'),(2,'b'),(3,'c')]\n\n form = formish.Form(schema, 'form')\n form['mySelect'].widget = formish.SelectWithOtherChoice(options)\n form['mySelect'].default = 2\n return form"
] | [
"0.8791058",
"0.83096915",
"0.8089902",
"0.7565213",
"0.699929",
"0.699929",
"0.680488",
"0.67091656",
"0.66209406",
"0.65692645",
"0.6532258",
"0.6486172",
"0.64289325",
"0.6406578",
"0.63146526",
"0.62376446",
"0.62375015",
"0.62119025",
"0.61605716",
"0.6160515",
"0.6089932",
"0.6064072",
"0.60535115",
"0.60409874",
"0.6025764",
"0.6001356",
"0.5992603",
"0.5973309",
"0.59606636",
"0.5928593",
"0.59253234",
"0.59120667",
"0.59013265",
"0.5882774",
"0.5882774",
"0.58603424",
"0.5836189",
"0.58113027",
"0.57965106",
"0.5786334",
"0.57581234",
"0.5740283",
"0.573565",
"0.57340217",
"0.57094455",
"0.5690138",
"0.56835073",
"0.56539315",
"0.5648747",
"0.5648359",
"0.5643329",
"0.56336606",
"0.5628389",
"0.5607492",
"0.5601162",
"0.55952716",
"0.5583834",
"0.5582097",
"0.55678433",
"0.5567291",
"0.5554405",
"0.55435175",
"0.5521484",
"0.5509103",
"0.549984",
"0.5486964",
"0.54801327",
"0.5473168",
"0.54703456",
"0.5448587",
"0.5415777",
"0.5399514",
"0.5390045",
"0.5388922",
"0.5384503",
"0.5379113",
"0.53730917",
"0.53626585",
"0.5349482",
"0.53474087",
"0.53474087",
"0.534685",
"0.5342996",
"0.5342234",
"0.5339548",
"0.533718",
"0.53333235",
"0.5328711",
"0.5322346",
"0.53161764",
"0.53090143",
"0.5302724",
"0.52999085",
"0.52886415",
"0.52831566",
"0.5275521",
"0.5271917",
"0.52677983",
"0.52644336",
"0.525422"
] | 0.7451019 | 4 |
Return conditional comparison value with realtime adjustments, used for date and time types' 'now' value | def adjustedCompareValue(self, value):
if value.startswith('now'):
return repr(GenTime())
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def adjustedCompareValue(self, value):\n if value.startswith('now'):\n return repr(GenDate())\n return value",
"def condition(self):\n HH = str(time.localtime().tm_hour)\n MM = str(time.localtime().tm_min)\n return eval(self._cond_str)",
"def get_state_by_time(python_time):\n present = datetime.now()\n\n if python_time <= present:\n return 2\n else:\n return 1",
"def now(self):\n return conditional_now() + self.timedelta(**self.now_shift_kwargs)",
"def check(self, comparison, value, value_type, second_value=None):\n now = datetime.now()\n if value_type == \"WEEKDAY\":\n if comparison not in [\"NE\", \"E\", \"WEEKDAY\", \"WEEKEND\"]:\n raise Exception(f\"Comparison {comparison} \"\n \"not valid for WEEKDAY\")\n if comparison == \"E\":\n return now.weekday() == value\n elif comparison == \"NE\":\n return now.weekday() != value\n elif comparison == \"WEEKDAY\":\n return now.weekday() < 5 # ISO counts from 0\n else:\n return now.weekday() > 4 # so Sat,Sun are 5,6\n if value_type == \"DATE\":\n dt = datetime.strptime(value, DATE_FMT)\n dt = dt.date()\n now = now.date()\n elif value_type == \"TIME\":\n dt = datetime.strptime(value, TIME_FMT)\n dt = dt.time()\n now = now.time()\n else:\n dt = datetime.strptime(value, DATETIME_FMT)\n if comparison == \"LE\":\n return now <= dt\n elif comparison == \"E\":\n return now == dt\n elif comparison == \"GE\":\n return now >= dt\n # At this point, we're doing either IN or OUT, so read second time\n # format\n if value_type == \"DATE\":\n second = datetime.strptime(second_value, DATE_FMT)\n second = second.date()\n elif value_type == \"TIME\":\n second = datetime.strptime(second_value, TIME_FMT)\n second = second.time()\n else:\n second = datetime.strptime(second_value, DATETIME_FMT)\n if comparison == \"IN\":\n return now >= dt and now <= second\n elif comparison == \"OUT\":\n return now <= dt or now >= second",
"def __gt__(self, other):\n return self.to_seconds() > other.to_seconds()",
"def __gt__(self, other):\n return self.to_seconds() > other.to_seconds()",
"def conditional_value(self) -> global___Expression.ConditionalOperator:",
"def get(self):\n now = datetime.datetime.utcnow()\n if now > self.time_of_next_update:\n self._update_value()\n return self.value",
"def set_when(day, today):\n if day < today:\n return \"past\"\n if day == today:\n return \"present\"\n return \"future\"",
"def greater_than_or_equal(self) -> global___Expression:",
"def __cmp__(self, other):\n return (self._cmp(self.seconds, other.seconds)\n or self._cmp(self.nanosecond, other.nanosecond))",
"def __gt__(self, other):\n if self.date > other.date:\n return True\n else:\n return False",
"def test_expression_dates(self):\n import datetime\n import time\n time1 = datetime.datetime.now()\n time.sleep(0.01)\n time2 = datetime.datetime.now()\n\n # Checks on a specified attribute with operators \"==\" and \"!=\" with integers\n expression = BooleanExpression(\"NORMAL\", models.Network.updated_at < time2)\n value = expression.evaluate(KeyedTuple([{\"updated_at\": time1}], [\"networks\"]))\n self.assertTrue(value, \"models.Network.updated_at < time2 with models.Network.id=time1\")\n\n expression = BooleanExpression(\"NORMAL\", models.Network.updated_at > time2)\n value = expression.evaluate(KeyedTuple([{\"updated_at\": time1}], [\"networks\"]))\n self.assertFalse(value, \"models.Network.updated_at < time2 with models.Network.id=time1\")\n\n expression = BooleanExpression(\"NORMAL\", models.Network.updated_at < time1)\n value = expression.evaluate(KeyedTuple([{\"updated_at\": time2}], [\"networks\"]))\n self.assertFalse(value, \"models.Network.updated_at < time1 with models.Network.id=time2\")\n\n expression = BooleanExpression(\"NORMAL\", models.Network.updated_at > time1)\n value = expression.evaluate(KeyedTuple([{\"updated_at\": time2}], [\"networks\"]))\n self.assertTrue(value, \"models.Network.updated_at < time1 with models.Network.id=time2\")\n\n expression = BooleanExpression(\"NORMAL\", models.Network.updated_at == time1)\n value = expression.evaluate(KeyedTuple([{\"updated_at\": time1}], [\"networks\"]))\n self.assertTrue(value, \"models.Network.updated_at < time1 with models.Network.id=time2\")\n\n expression = BooleanExpression(\"NORMAL\", models.Network.updated_at == time2)\n value = expression.evaluate(KeyedTuple([{\"updated_at\": time1}], [\"networks\"]))\n self.assertFalse(value, \"models.Network.updated_at < time1 with models.Network.id=time2\")",
"def less_than_or_equal(self) -> global___Expression:",
"def current_time(cls) -> float:",
"def next_update_in(self, now):\n # Never updated: NOW!\n if self.last_tested is None:\n return 0.0\n\n # Was updated\n seconds_ago = (now - self.last_tested).total_seconds()\n delay = self.real_period - seconds_ago\n return max(delay, 0.0) # don't allow it to be negative",
"def after(v1,v2):\n return v1.time_left>v2.time_left",
"def check_time_since_last_data(device_origin):\n actual_time = time.time()\n sec_since_last_data = actual_time - mon_item.read_device_status_values(device_origin)[1]\n min_since_last_data = sec_since_last_data / 60\n min_since_last_data = int(min_since_last_data)\n latest_data_hr = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(latest_data))\n return min_since_last_data",
"def test_process_filter_value():\n now = dt.utcnow()\n now_ts = now.timestamp()\n filter_ = {'column': \"ts_created_at\", 'value': now_ts, type: 'leq'}\n assert process_filter_value(filter_) == now\n\n filter_ = {'column': \"created_at\", 'value': now_ts, type: 'leq'}\n assert process_filter_value(filter_) == now_ts",
"def compare(x, y):\n if x >= y:\n return 1.0\n else:\n return 0.0",
"def newer(a, b):\n\treturn modtime(a) < modtime(b) # smaller is earlier",
"def test_larger_lhs(self):\n from sosbeacon.utils import get_latest_datetime\n\n lhs = datetime(2012, 9, 20, 3, 45)\n rhs = datetime(2012, 9, 20, 2, 45)\n\n result = get_latest_datetime(lhs, rhs)\n\n self.assertIs(lhs, result)",
"def test_get_current_time_is_constant() -> None:\n time_provider = TimeProvider()\n current_time_1 = time_provider.get_current_time()\n current_time_2 = time_provider.get_current_time()\n\n assert current_time_1 == current_time_2",
"def _compare(self, value, target):\n result = getattr(self.reg, target) - value\n self.reg.N = result >> 7\n self.reg.C = getattr(self.reg, target) >= value\n self.reg.Z = result == 0",
"def search_cond(ts):\n ts = convert(ts, mode='timestamp')\n at = [\"year\", \"month\", \"day\", \"hour\", \"minute\"]\n if all(getattr(ts, a) == getattr(upper_bound, a) for a in at):\n return 0\n elif ts < upper_bound:\n return -1\n elif ts > upper_bound:\n return 1",
"def time_before(time_a, time_b=None) -> bool:\n if time_b is None:\n time_b = time_now()\n\n # make sure both times are floats\n time_a = float(date_to_epoch(time_a))\n time_b = float(date_to_epoch(time_b))\n return time_a < time_b",
"def native_value(self) -> float:\n if (self.coordinator.data is None) or (self._last_updated is not None and \"last_updated\" in self.coordinator.data and self._last_updated > self.coordinator.data[\"last_updated\"]):\n self._attributes[\"last_updated_timestamp\"] = self._last_updated\n return self._state\n \n self._attributes[\"last_updated_timestamp\"] = self.coordinator.data[\"last_updated\"]\n self._state = self.coordinator.data[\"charge_limit_weekday\"]\n \n return self._state",
"def less_than(self) -> global___Expression:",
"def _comparison_function(comp, value=0.0, **kwargs):\n if comp == 'g' or comp == '>':\n func = np.greater\n elif comp == 'ge' or comp == '>=':\n func = np.greater_equal\n elif comp == 'l' or comp == '<':\n func = np.less\n elif comp == 'le' or comp == '<=':\n func = np.less_equal\n elif comp == 'e' or comp == '=' or comp == '==':\n func = np.equal\n elif comp == 'ne' or comp == '!=':\n func = np.not_equal\n else:\n raise ValueError(\"Unrecognized comparison '{}'.\".format(comp))\n\n def comp_func(xx):\n return func(xx, value, **kwargs)\n\n return comp_func",
"def report_status(scheduled_time, estimated_time):\n if scheduled_time == estimated_time:\n return 'on time'\n elif scheduled_time > estimated_time:\n return 'early'\n else:\n return 'delayed'",
"def is_before(self,other_date):",
"def REAL_TIME_ADVANCE(dt):",
"def __gt__(self, other):\n self_list = self.date.split(\"/\")\n other_list = other.date.split(\"/\")\n if self_list[2] > other_list[2]:\n return True\n else:\n if self_list[2] == other_list[2]:\n if self_list[1] > other_list[1]:\n return True\n elif self_list[1] == other_list[1]:\n if self_list[0] > other_list[0]:\n return True\n return False",
"def __gt__(self, other):\n return self._metric_value > other.metric_value()",
"def last_checked(self):\n\t\treturn self.current().time",
"def greater_than(self) -> global___Expression:",
"def ge(self, val):\n\t\treturn GreaterOrEquals(self, val)",
"def when(self):\n\n # current UTC time\n now = datetime.datetime.utcnow()\n # calculate timedelta and return\n return now - self.creation_time",
"def _greater_than_or_equal_to_op(spec):",
"def test_since(self):\n import datetime\n dt1 = datetime.datetime(2013, 12, 15, 10, 10, 10)\n dt2 = datetime.datetime(2013, 12, 15, 10, 11, 10)\n\n check_list = health.CheckList(refresh=1)\n check_list._refreshed_at = dt1\n\n mock_datetime = self.mocker.replace(datetime)\n mock_datetime.datetime.now()\n self.mocker.result(dt2)\n self.mocker.replay()\n\n self.assertEqual(check_list.since(), '0:01:00')",
"def comparison(self):\n return self._comparison",
"def __gt__(self, other):\n if isinstance(other, float):\n return self.floatvalue > other\n else:\n return not self.negative and not self == other",
"def __gt__(self, value):\n self = self.__ge__(value)\n return self.__invert__()",
"def deciding(self):\n\n if not self.db.cacheEmpty():\n cacheMsgs = self.db.getCacheMsgs()\n prev = datetime.datetime.min\n prev_location = \"FOO LOCATION\"\n for msg in cacheMsgs:\n neutrinoTime = msg[\"neutrino_time\"]\n # go through messages to check if any two or more are within the time threshold\n if neutrinoTime - datetime.timedelta(seconds=self.coinc_threshold) <= prev:\n # verify the locations are different\n if msg[\"location\"] != prev_location:\n return True\n prev = neutrinoTime\n prev_location = msg[\"location\"]\n return False\n\n # return not self.db.cacheEmpty()",
"def acceptable(self):\n now = datetime.datetime.now()\n origin = datetime.datetime.combine(self.date, datetime.time.min)\n start = origin + datetime.timedelta(hours=6)\n end = origin + datetime.timedelta(days=1)\n morning = end + datetime.timedelta(hours=6)\n if now < origin or now > morning:\n return 0\n if now >= end or now <= start:\n return 1\n return 3",
"def time_after(time_a, time_b=None) -> bool:\n if time_b is None:\n time_b = time_now()\n\n # make sure both times are floats\n time_a = float(date_to_epoch(time_a))\n time_b = float(date_to_epoch(time_b))\n return time_a > time_b",
"def debugTest(self):\n startTime = datetime.today()\n serverTzInfo = self.serverTimeZone\n startTime = startTime.replace(tzinfo=serverTzInfo)\n self.notify.info('startTime = %s' % startTime)\n serverTime = self.getCurServerDateTime()\n self.notify.info(\"serverTime = %s\" % serverTime)\n result = startTime <= serverTime\n self.notify.info(\"start < serverTime %s\" % result)\n startTime1MinAgo = startTime + timedelta(minutes = -1)\n self.notify.info('startTime1MinAgo = %s' % startTime1MinAgo)\n result2 = startTime1MinAgo <= serverTime\n self.notify.info(\"startTime1MinAgo < serverTime %s\" % result2)\n serverTimeForComparison = self.getCurServerDateTimeForComparison()\n self.notify.info(\"serverTimeForComparison = %s\" % serverTimeForComparison)\n result3 = startTime1MinAgo <= serverTimeForComparison\n self.notify.info(\"startTime1MinAgo < serverTimeForComparison %s\" % result3)",
"def __gt__(self, other):\n\t\ttry:\n\t\t\treturn self.val > other.val\n\t\texcept:\n\t\t\treturn self.val > other",
"def compare(self, value: int, /) -> None:",
"def adjustedCompareValue(self, value):\n return value",
"def _update_time(self):\n if self.time.year != datetime.datetime.now().year or self._this_year is None:\n self._this_year = _data.this_year(self.df, 'case_timestamp')\n if self.time.month != datetime.datetime.now().month or self._this_month is None:\n self._this_month = _data.this_month(self.df, 'case_timestamp')\n if self.time.day != datetime.datetime.now().day or self._today is None:\n self._today = _data.today(self.df, 'case_timestamp')\n self.time = datetime.datetime.now()",
"def check_last_update(self):\n now = self.get_clock().now()\n diff_L = (now - self.last_stamp_L).nanoseconds * 1e-9\n diff_R = (now - self.last_stamp_R).nanoseconds * 1e-9\n if diff_L > 0.1:\n self.duty_left = 0.0\n if diff_R > 0.1:\n self.duty_right = 0.0",
"def __gt__(self, other):\n return self.__f > other.get_f()",
"def is_after(t1,t2):\n return (t1.hour, t1.minute, t1.second) > (t2.hour, t2.minute, t2.second)",
"def curr_time():\r\n try:\r\n curr_time = datetime.datetime.now().strftime(\"%H:%M:%S\")\r\n except Exception as e:\r\n print(e)\r\n curr_time = False\r\n return curr_time",
"def __ge__( self, value ):\r\n\t\treturn ( self > value ) or ( self == value )",
"def evaluate_stopping_condition(self, current_value: Union[float, int, np.float64, np.ndarray]):\n\n if self.__reference_value is not None:\n\n if type(current_value) in [float, int, np.float64]:\n if not self.__smaller_value_required:\n if not self.__equal_required:\n return current_value > self.__reference_value\n else:\n return current_value >= self.__reference_value\n else:\n if not self.__equal_required:\n return current_value < self.__reference_value\n else:\n return current_value <= self.__reference_value\n\n elif type(current_value) == np.ndarray:\n if not self.__smaller_value_required:\n if not self.__equal_required:\n return (current_value > self.__reference_value).all()\n else:\n return (current_value >= self.__reference_value).all()\n else:\n if not self.__equal_required:\n return (current_value < self.__reference_value).all()\n else:\n return (current_value <= self.__reference_value).all()\n\n else:\n raise NotImplementedError\n\n else:\n return False",
"def statusCompare (x, y):\n xs = db.status.get(x, 'order')\n ys = db.status.get(y, 'order')\n c = float(xs) - float(ys)\n if c >= 0.0: \n return int(c)\n else:\n return -int(abs(c))",
"def test_larger_rhs(self):\n from sosbeacon.utils import get_latest_datetime\n\n lhs = datetime(2012, 9, 20, 2, 59)\n rhs = datetime(2012, 9, 20, 3, 00)\n\n result = get_latest_datetime(lhs, rhs)\n\n self.assertIs(rhs, result)",
"def _get_current_time_if_none(given_time):\n\t\treturn given_time or time.time()",
"def update_waiting(self):\n if self.get_value(0) is not None and self.get_value(1) is not None:\n if self.name == \"greater\":\n self.set_value(self.get_value(0) > self.get_value(1), 0)\n if self.name == \"greater or equal\":\n self.set_value(self.get_value(0) >= self.get_value(1), 0)\n if self.name == \"less\":\n self.set_value(self.get_value(0) < self.get_value(1), 0)\n if self.name == \"less or equal\":\n self.set_value(self.get_value(0) <= self.get_value(1), 0)\n if self.name == \"not equal\":\n self.set_value(self.get_value(0) != self.get_value(1), 0)\n if self.name == \"xor\":\n self.set_value(bool(self.get_value(0)) ^ bool(self.get_value(1)), 0)\n self.state = ACTIVE",
"def value_equal_keyvalue(attr, current_time=False):\n anim_val = get_anim_value_at_current_frame(attr)\n if current_time:\n val = cmds.getAttr(attr, time=current_time)\n else:\n val = cmds.getAttr(attr)\n if anim_val == val:\n return True",
"def check_time():\n times = get_times()\n time_difference = abs((times['local'] - times['target']).total_seconds())\n return time_difference < post_time_tol_seconds",
"def compare_dates(date1, date2, flag):\n if date1 > date2:\n if flag == \"l\":\n return date1\n return date2\n if flag == \"l\":\n return date2\n return date1",
"def _get_comparison_func(self, adjective):\n return self.SONG_ADJECTIVES.get(adjective, {}).get(\"comparison\")",
"def above_threshold(self, value):\n # We use floating point number here so we have to take care\n return finf(value,self.min) or finf(self.max,value)",
"def __le__(self, other):\n return self.timestamp <= other.timestamp",
"def getValueAt(self, time):\n for tvp in self.timeValuePairs:\n if time <= tvp[0]:\n return tvp[1]\n return self.defaultValue",
"def __cmp__(self, other):\n if not isinstance(other, datetime):\n types = (type(other), datetime)\n raise TypeError('Type mismatch: %s not instance of %s' % types)\n # pylint: disable=protected-access\n return (self._cmp(self._days, other._days)\n or self._cmp(self.seconds, other.seconds)\n or self._cmp(self.nanosecond, other.nanosecond))",
"def dynamic_comparison(v1, op, v2):\n assert op in ['gt', 'lt']\n\n operator_map = {'gt': operator.gt,\n 'lt': operator.lt}\n\n return operator_map[op](v1, v2)",
"def ge(self, y):\n return 1 - self.lt(y)",
"def less_equal(value, other):\n return value >= other",
"def test_equal_inputs(self):\n from sosbeacon.utils import get_latest_datetime\n\n lhs = rhs = datetime(2012, 9, 20, 2, 59)\n\n result = get_latest_datetime(lhs, rhs)\n\n self.assertIs(rhs, result)\n self.assertIs(lhs, result)",
"def check_compare(change, reference_value):\n rounded_change = round(change, 2)\n compare_values(reference_value, rounded_change)",
"def _greater_than_op(spec):",
"def _get_delta(self, now, then):\n if now.__class__ is not then.__class__:\n now = datetime.date(now.year, now.month, now.day)\n then = datetime.date(then.year, then.month, then.day)\n if now < then:\n raise ValueError(\"Cannot determine moderation rules because date field is set to a value in the future\")\n return now - then",
"def lessThanEqualTo(self, t):\n if t is None:\n return False\n if isinstance(t, (float, int)):\n return self._micros <= long(t * 1000000)\n else:\n return self._micros <= t._micros",
"def currentTime(*args, update: bool=True, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[time, Any]:\n pass",
"def get_now():\n return datetime.now()",
"def get_now():\n return datetime.now()",
"def __ge__(self, other):\n self.conds.append((self.name, '>=', other))\n return self\n return self.name, '>=', other",
"def __get_timeval():\n return convert_timeval(time.time())",
"def absulute2relative_time(x): \n if x.viewed:\n x.viewed_reltime=x.viewed_time-x.start\n \n if x.completed:\n x.completed_reltime=x.completed_time-x.start\n \n return x",
"def ComputeTimeReward(self, currentTime, expectedTime):\r\n return (expectedTime - currentTime) * 1 if currentTime < expectedTime else (expectedTime - currentTime) * 1",
"def _get_half_time(self):\n return self.__half_time",
"def lessThan(self, t):\n if t is None:\n return False\n if isinstance(t, (float, int)):\n return self._micros < long(t * 1000000)\n else:\n return self._micros < t._micros",
"def new_value(self):\n on_val = get_usable_value(self._momentary_mode_on_prop)\n follow_val = get_usable_value(self._momentary_follow_sense_prop)\n on_off_val = get_usable_value(self._momentary_on_off_trigger_prop)\n\n new_value = _calc_relay_mode(on_val, follow_val, on_off_val)\n if new_value == self.value:\n return None\n return new_value",
"def __gt__(self, other):\n return self.greaterThan(other)",
"def is_after(t1, t2):\n return (t1.hour, t1.minute, t1.second) > (t2.hour, t2.minute, t2.second)",
"def __ge__(self, other):\n # self >= other\n return self.runtime.greater_than_equal(self, other)",
"def match(self, dt):\n logic_map = {\n CLOSED_CLOSED: ((self.start is None or dt >= self.start) and\n (self.end is None or dt <= self.end)),\n CLOSED_OPEN: ((self.start is None or dt >= self.start) and\n (self.end is None or dt < self.end)),\n OPEN_CLOSED: ((self.start is None or dt > self.start) and\n (self.end is None or dt <= self.end)),\n OPEN_OPEN: ((self.start is None or dt > self.start) and\n (self.end is None or dt < self.end)),\n }\n return logic_map[self.interval]",
"def check(self):\r\n boto.log.info('checking Task[%s]-now=%s, last=%s' % (self.name, self.now, self.last_executed))\r\n\r\n if self.hourly and not self.last_executed:\r\n return 0\r\n \r\n if self.daily and not self.last_executed:\r\n if int(self.hour) == self.now.hour:\r\n return 0\r\n else:\r\n return max( (int(self.hour)-self.now.hour), (self.now.hour-int(self.hour)) )*60*60\r\n\r\n delta = self.now - self.last_executed\r\n if self.hourly:\r\n if delta.seconds >= 60*60:\r\n return 0\r\n else:\r\n return 60*60 - delta.seconds\r\n else:\r\n if int(self.hour) == self.now.hour:\r\n if delta.days >= 1:\r\n return 0\r\n else:\r\n return 82800 # 23 hours, just to be safe\r\n else:\r\n return max( (int(self.hour)-self.now.hour), (self.now.hour-int(self.hour)) )*60*60",
"def __gt__(self, *args):\n return _ida_hexrays.cdo_t___gt__(self, *args)",
"def _get_detection_time_multiplier(self):\n return self.__detection_time_multiplier",
"def test_details_time(self):\n self.assertLess(self.details.time, datetime.now(timezone.utc))",
"def compare_datetime(self_datetime, other_datetime):\n # pylint: disable=superfluous-parens\n if (isinstance(self_datetime and other_datetime, (datetime, type(None)))):\n return (\n (self_datetime == other_datetime\n if all(str(_.time()) != \"00:00:00\"\n for _ in [self_datetime, other_datetime])\n else self_datetime.date() == other_datetime.date())\n if self_datetime and other_datetime\n else self_datetime == other_datetime)\n else:\n Representation.attrs_values_types_error(\n self_attr=self_datetime, other_attr=other_datetime,\n expected_types=(datetime.__name__, type(None).__name__))",
"def comparison(self) -> str:\n return self._values.get('comparison')",
"def compare(date1,date2):\n d1,m1,y1 = breakdate(date1)\n d2,m2,y2 = breakdate(date2)\n if y2>y1:\n return -1\n elif y1>y2:\n return 1\n else:\n if m2>m1:\n return -1\n elif m1>m2:\n return 1\n else:\n if d2>d1:\n return -1\n elif d1>d2:\n return 1\n else:\n return 0",
"def test_greater_than(self):\n utils.compare_tracing_methods(\n SimpleCompareOpsModule(\"greaterThan\"),\n torch.randn(3, 4, 5),\n torch.randn(3, 4, 5),\n fusible_ops={\"aten::gt\"},\n )"
] | [
"0.68978775",
"0.6119225",
"0.6032928",
"0.6031085",
"0.5851345",
"0.5813949",
"0.5813949",
"0.5806566",
"0.56923884",
"0.5676319",
"0.5638131",
"0.55917704",
"0.55903226",
"0.55771613",
"0.55758727",
"0.5568553",
"0.54968023",
"0.54886967",
"0.54710984",
"0.54660606",
"0.544368",
"0.53952295",
"0.5366562",
"0.5361186",
"0.53564334",
"0.53201556",
"0.5318052",
"0.5310881",
"0.5303645",
"0.52755153",
"0.5272409",
"0.5262794",
"0.5258515",
"0.5256121",
"0.52434045",
"0.52325535",
"0.523171",
"0.5228605",
"0.522731",
"0.52242196",
"0.52232134",
"0.5216645",
"0.5199141",
"0.5187131",
"0.5183496",
"0.5182936",
"0.51828176",
"0.5178984",
"0.5175569",
"0.5174605",
"0.517255",
"0.51587236",
"0.5157001",
"0.5151883",
"0.51388234",
"0.5123184",
"0.5120271",
"0.51154375",
"0.5112017",
"0.5105371",
"0.51031363",
"0.51031",
"0.5093432",
"0.50890315",
"0.50822043",
"0.5077461",
"0.5077231",
"0.50700665",
"0.506701",
"0.5064411",
"0.5051433",
"0.5049141",
"0.50409293",
"0.50377417",
"0.50377274",
"0.50368404",
"0.50367427",
"0.5035383",
"0.5034206",
"0.50341815",
"0.50341815",
"0.50307596",
"0.50266206",
"0.5020685",
"0.50196445",
"0.5018548",
"0.50045717",
"0.50015664",
"0.50012237",
"0.500016",
"0.499985",
"0.4993337",
"0.4989434",
"0.49886602",
"0.49812794",
"0.4979396",
"0.497474",
"0.49682534",
"0.49667332",
"0.4966258"
] | 0.71401125 | 0 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
ChoiceFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.735201",
"0.6754294",
"0.67166066",
"0.67071074",
"0.66780305",
"0.65807486",
"0.6522693",
"0.6522693",
"0.65187657",
"0.6471306",
"0.6269984",
"0.62653935",
"0.6153201",
"0.6090701",
"0.60323846",
"0.60278016",
"0.6011661",
"0.60042846",
"0.59841794",
"0.5941162",
"0.59205276",
"0.5918955",
"0.59121054",
"0.5903962",
"0.5884743",
"0.5876164",
"0.5857109",
"0.5851559",
"0.583173",
"0.58274394",
"0.5816038",
"0.58061635",
"0.5784312",
"0.5755998",
"0.5755998",
"0.57360405",
"0.57051307",
"0.5701552",
"0.5687975",
"0.5650812",
"0.5618766",
"0.561154",
"0.5605911",
"0.56030387",
"0.5602799",
"0.55926436",
"0.5587559",
"0.5571399",
"0.5567558",
"0.55631375",
"0.555545",
"0.5550559",
"0.55490625",
"0.55470836",
"0.55410224",
"0.5519966",
"0.55098814",
"0.5492064",
"0.547102",
"0.5470936",
"0.54692423",
"0.5467515",
"0.54661024",
"0.54518676",
"0.54405665",
"0.5438651",
"0.54003173",
"0.5388153",
"0.5382598",
"0.5375904",
"0.5375076",
"0.53706104",
"0.5359634",
"0.5354708",
"0.5354708",
"0.5331472",
"0.5324531",
"0.53227526",
"0.5316361",
"0.5309617",
"0.5308968",
"0.53067",
"0.5306182",
"0.5299369",
"0.52990687",
"0.5287107",
"0.52791494",
"0.5277907",
"0.5276578",
"0.52742803",
"0.5270845",
"0.52608305",
"0.52524847",
"0.5244876",
"0.5239417",
"0.5234171",
"0.5224983",
"0.5215326",
"0.521457",
"0.5212088",
"0.5203955"
] | 0.0 | -1 |
Return formatted text, properly escaped if not in titleMode | def formatOutput(self, storedText, titleMode, internal=False):
if storedText not in self.formatList:
try:
storedText = GenBoolean(storedText).boolStr(self.format)
except GenBooleanError:
storedText = _errorStr
return TextFormat.formatOutput(self, storedText, titleMode, internal) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def title(text, level=0):\n return '\\n' + text + '\\n' + '=-~_#%^' [level] * len(text) + '\\n\\n'",
"def format_title(self, data):\n return data",
"def output_plain_sep_title(title):\n print(f\"{plain_sep_mark}\\t{title}{plain_sep_mark}\")",
"def formatOutput(self, storedText, titleMode, internal=False):\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def get_text(downgrade_titles=False):",
"def PROPER(text):\n return text.title()",
"def title(self, string):\n return self.bold(string)",
"def html_title(title):\n return '<center><h1>%s</h1></center>' % (title)",
"def _get_title_text(self):\n return Text(\n self,\n self.settings.font_bold_filename,\n 96,\n self.settings.font_color,\n 'zuckbot',\n {'center': self.screen_rect.center},\n 0,\n -50,\n )",
"def get_title_repr(self) -> str:\n try:\n return Title[self.title].value\n except (KeyError, ValueError):\n pass",
"def editModeHeading(text):\n return u'<p style=\"editModeHeading\">%s</p>' % text",
"def generate_title(self, title=None):\n if title is None:\n title = self.header.get('title', self.title)\n\n title = self.generate(title)\n title = title.replace('<p>', '').replace('</p>', '')\n # no trailing newlines\n title = re.sub(r'\\n+', ' ', title).rstrip()\n return title",
"def formatText(s, bold=False, underlined=False, negative=False):\n\n if not FORMATTING_AVAILABLE:\n return s\n\n head = \"\"\n if bold: head += \"\\033[1m\"\n if underlined: head += \"\\033[4m\"\n if negative: head += \"\\033[7m\"\n\n return head + s + \"\\033[0m\"",
"def emph_text(text):\n\n if use_color():\n return colorama.Style.BRIGHT + text + colorama.Style.RESET_ALL\n else:\n return text",
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def title_string(self):\n return ' '.join(self.title).replace(' - ', '')",
"def formatOutput(self, storedText, titleMode, internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = ['<img src=\"%s\">' % escape(url, treedoc.escDict) for url\n in paths]\n return u'<br />'.join(results)",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def print_with_title(title, content, before='', after='', hl='='):\n cont_maxlen = max(len(s) for s in content.split('\\n'))\n hl_len = max(cont_maxlen, len(title))\n print('{}{}\\n{}\\n{}{}'.format(before, title, hl * hl_len, content, after))",
"def title(self, txt):\n num = len(txt)\n ticks = \"=\" * num\n print(ticks)\n print(txt)\n print(ticks)",
"def test_title(self):\n self.assertEquals(\"Title\\n=====\", trans(\"== Title ==\"))\n self.assertEquals(\"Title\\n-----\", trans(\"=== Title ===\"))\n self.assertEquals(\"#### Title\", trans(\"==== Title ====\"))\n self.assertEquals(\"##### Title\", trans(\"===== Title =====\"))",
"def helptext(self):\n return \"\"",
"def book_title(book_text):\n search = re.search(\"Title:(.*)\", book_text)\n title = search.group(1).replace(\"\\r\", \" \").strip()\n return title",
"def get_title():",
"def __str__(self):\n date_str = self.date.strftime(self.journal.config['timeformat'])\n title = date_str + \" \" + self.title\n body = self.body.strip()\n\n return \"{title}{sep}{body}\\n\".format(\n title=title,\n sep=\"\\n\" if self.body else \"\",\n body=body\n )",
"def __str__(self) -> str:\n return textwrap.wrap(self.title, _POST_TITLE_MAX_LENGTH // 4)[0]",
"def title_draw():\n nonlocal width\n widthTitle = len(self.str_title)\n if widthTitle > width:\n self.str_title = self.str_title[0:width-5] + '...'\n widthTitle = len(self.str_title)\n h_len = widthTitle + self.l_padding + self.r_padding\n top = ''.join(['┌'] + ['─' * h_len] + ['┐']) + '\\n'\n result = top + \\\n '│' + \\\n ' ' * self.l_padding + \\\n self.str_title + \\\n ' ' * self.r_padding + \\\n '│' + self.str_shadow + '\\n'\n offset = 2 + self.l_padding + len(self.str_title) + self.r_padding\n return result, offset",
"def show_title():\r\n complement = (\r\n '\\n __ ')\r\n title = ('\\n _______ _______________ ____ _______ __ ___ _ _______/ /_ ____ _____ ____ ____ ')\r\n title += ('\\n / ___/ / / / ___/ ___/ _ \\/ __ \\/ ___/ / / / / _ \\| |/_/ ___/ __ \\/ __ `/ __ \\/ __ `/ _ \\ ')\r\n title += ('\\n/ /__/ /_/ / / / / / __/ / / / /__/ /_/ / / __/> </ /__/ / / / /_/ / / / / /_/ / __/ ')\r\n title += ('\\n\\___/\\__,_/_/ /_/ \\___/_/ /_/\\___/\\__, / \\___/_/|_|\\___/_/ /_/\\__,_/_/ /_/\\__, /\\___/ ')\r\n title += ('\\n /____/ /____/ ')\r\n # Add Styles\r\n break_line = ('-' * len(complement) + \"\\n\") * 2\r\n print(\"{}\\n{}\\n{}\\n\".format(break_line, title, break_line))",
"def format_title(self, title):\n new_title = ''.join(word.lower().strip('!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ ') for word in title)\n return new_title",
"def formatOutput(self, storedText, titleMode, internal=False):\n if storedText not in self.formatList:\n storedText = _errorStr\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def pretty_title(title):\n output = '-' * 5 + ' ' + title + ' ' + '-' * 5\n return output",
"def html_title(self, title=None):\r\n if title is None:\r\n return \"<title>PyBossa</title>\"\r\n else:\r\n return \"<title>PyBossa · %s</title>\" % title",
"def formatOutput(self, storedText, titleMode, internal=False):\n try:\n text = GenDate(storedText).dateStr(self.format)\n except GenDateError:\n text = _errorStr\n return TextFormat.formatOutput(self, text, titleMode, internal)",
"def output_sep_title(title):\n print(f\"{sep_mark}\\t{title}{sep_mark}\")",
"def make_main_title(self, end, end_center=False):\n main_title = r\"\\begin{center}\"\n if self.detector is not None:\n main_title += \"%s \"%self.detector\n if self.selection is not None:\n main_title += \"%s Event Selection \"%self.selection\n main_title += end\n if end_center:\n main_title += r\"\\end{center}\"\n return main_title",
"def title(string):\n print(\"{}\\n{}\\n\".format(bold(string), underline(string, \"=\")))",
"def get_title(self):\n if not hasattr(self, '_title'):\n self._title = 'NO TITLE'\n if self._title:\n title = _(self._title)\n title = title.replace('&', '&') \n title = title.replace('\"', '"')\n return title\n else:\n return u''",
"def escape_if_needed(text, options):\n if hasattr(text, '__html__'):\n # Text has escape itself:\n return to_string(text.__html__())\n if need_to_escape(options):\n return escape(to_string(text))\n return to_string(text)",
"def ftitle(self, text):\n return \"{} - {}\".format(self._app_name, text)",
"def get_rst_title_char(level):\n chars = (u'=', u'-', u'`', u\"'\", u'.', u'~', u'*', u'+', u'^')\n if level < len(chars):\n return chars[level]\n return chars[-1]",
"def process_title(self, title):\n\t\t# strip apostrophes\n\t\tif '\\'' in title:\n\t\t\ttitle = re.sub('\\'', '', title)\n\t\tif '.' in title:\n\t\t\ttitle = re.sub('.', '', title)\n\t\treturn title",
"def pretty_title(title):\n output = '-' * 5 + ' ' + title.lower() + ' ' + '-' * 5\n return output",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def escape_for_display(s) :\n if len(s) == 0 :\n return \"[EMPTY]\"\n return s.replace(\"\\n\",\"[NL]\").replace(\"\\t\",\"[TAB]\") #.replace(\" \",\"[SP]\") # Escape newlines so not to confuse debug output.",
"def style_title(self) -> str:\n style_title = \"\"\".title\n {margin-bottom: 10px}\\n\"\"\"\n self.html_doc = self.html_doc + style_title\n return self.html_doc",
"def formatOutput(self, storedText, titleMode, internal=False):\n try:\n text = GenNumber(storedText).numStr(self.format)\n except GenNumberError:\n text = _errorStr\n return TextFormat.formatOutput(self, text, titleMode, internal)",
"def getHTMLText(self, s):\r\n\r\n # Removes any \"<\" or \">\" from the text, and replaces line ends with <br> tags\r\n if s is not None:\r\n res = str(s)\r\n res = string.replace(res, \">\", \">\")\r\n res = string.replace(res, \"<\", \"<\")\r\n res = string.replace(s, \"\\n\", \"<br style='mso-data-placement:same-cell;'/>\")\r\n else:\r\n res = \"\"\r\n\r\n # Inserts formatting tag around text, if defined\r\n if self.formatBeginTag:\r\n res = self.formatBeginTag + res + self.formatEndTag\r\n\r\n return res",
"def escape_single_quotes(custom_data):\n # https://stackoverflow.com/questions/10569438/how-to-print-unicode-character-in-python\n # https://regex101.com/r/nM4bXf/1\n if re.search(\"(?<!u)'(?!:|}|,)\", custom_data.get('title_name', '')):\n z = re.sub(r\"(?<!u)'(?!:|}|,)\", '\\\\\\'', custom_data.get('title_name', None))\n\n custom_data['title_name'] = z\n return custom_data\n return custom_data",
"def formatOutput(self, storedText, titleMode, internal=False):\n try:\n text = GenTime(storedText).timeStr(self.format)\n except GenTimeError:\n text = _errorStr\n return TextFormat.formatOutput(self, text, titleMode, internal)",
"def format_title(self, ticket_id, subject):\n # TODO: strip block tags?\n title = \"#%i %s\" % (ticket_id, subject)\n return title.strip()",
"def subtitle(string):\n print(\"{}\\n{}\\n\".format(bold(string), underline(string, \"-\")))",
"def title(self, value):\n if len(value):\n self._title = self._wrap_line(value, self._width)\n\n # Add a blank line\n self._title.append('')",
"def emphasize(text: str, tablefmt: str | TableFormat, strong: bool = False) -> str:\n # formats a title for a table produced using tabulate,\n # in the formats tabulate understands\n if tablefmt in [\"html\", \"unsafehtml\", html_with_borders_tablefmt]: # type: ignore\n if strong:\n emph_text = f\"<strong>{text}</strong>\"\n else:\n emph_text = f\"<em>{text}</em>\"\n elif tablefmt in [\"latex\", \"latex_raw\", \"latex_booktabs\", \"latex_longtable\"]:\n if strong:\n emph_text = r\"\\textbf{\" + text + r\"}\"\n else:\n emph_text = r\"\\emph{\" + text + r\"}\"\n else: # use the emphasis for tablefmt == \"pipe\" (Markdown)\n star = \"**\" if strong else \"*\"\n emph_text = f\"{star}{text}{star}\"\n return emph_text",
"def formatOutput(self, storedText, titleMode, internal=False):\n choices, valid = self.sortedChoices(storedText)\n if valid:\n result = self.sep.join(choices)\n else:\n result = _errorStr\n return TextFormat.formatOutput(self, result, titleMode, internal)",
"def textual(title, ordering_field=None):\n def decorator(func):\n def wraps(self, obj):\n result = func(self, obj)\n return result if result else u'---'\n\n wraps.short_description = title\n wraps.allow_tags = True\n\n if ordering_field:\n wraps.admin_order_field = ordering_field\n\n return wraps\n return decorator",
"def outputText(self, item, titleMode, internal=False):\n field = None\n while not field:\n item = item.parent\n if item:\n field = item.nodeFormat().findField(self.name)\n else:\n return ''\n return field.outputText(item, titleMode, internal)",
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, internal)\n return ''",
"def inclusive_title(self):\n return self.title + (\" %s\" % (self.episode_to_string(self.latest_season, self.latest_episode),) if self.is_series() else \"\")",
"def group_title(self, group):\n group_title = group.getProperty('title')\n if self.short:\n splitted = group_title.split('(')\n if len(splitted) > 1:\n group_title = group_title.split('(')[-1][:-1]\n return html.escape(group_title)",
"def outputText(self, item, titleMode, internal=False):\n for num in range(self.parentLevel):\n item = item.parent\n if not item:\n return ''\n field = item.nodeFormat().findField(self.name)\n if not field:\n return ''\n return field.outputText(item, titleMode, internal)",
"def format_heading(self, level, text):\n underlining = ['=', '-', '~', ][level-1] * len(text)\n return '%s\\n%s\\n\\n' % (text, underlining)",
"def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n path = u'<a href=\"%s\">%s</a>' % (escape(path, treedoc.escDict),\n altText or url)\n results.append(TextFormat.formatOutput(self, path, titleMode,\n internal))\n return u'<br />'.join(results)",
"def formatted(self) -> str:\r\n ...",
"def __str__(self):\n return \"{title}\".format(title=self.title)",
"def gen_title_rst(txt):\n # Just add a few useful directives\n txt = \".. highlight:: cmake\\n\\n\" + txt\n return txt",
"def _prettyfilename(self):\n return self.title",
"def wrap_title(title, mpl_layout):\n fig = mpl_layout.canvas.figure\n ax = fig.axes[0]\n ext_pixels = ax.get_window_extent()\n ext_inches = ext_pixels.transformed(fig.dpi_scale_trans.inverted())\n magic_number = 10\n letters_per_line = int(ext_inches.width * magic_number)\n title_wrapped = '\\n'.join(textwrap.wrap(title, letters_per_line))\n return title_wrapped",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title} :\" + s\n\n return s",
"def _get_full_title(self):\n return \"%s - %s %d\" % (self.title, _('Season'), self.season)",
"def get_title(text, uuid=None):\n if uuid is not None:\n text += get_provenance_link(uuid)\n title = pn.Row(pn.pane.HTML('<h2>{}</h2>'.format(text)), align='start')\n\n return title",
"def print_title(title):\n print \"\\n\"+\"#\"*32+\"\\n# \"+title+\"\\n\"+\"#\"*32+\"\\n\"",
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n altText = ''\n if self.linkAltField:\n field = item.nodeFormat().findField(self.linkAltField)\n if field:\n altText = field.outputText(item, titleMode, internal)\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, altText, internal)\n return ''",
"def transform(text: str) -> str:\n return text.title()",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode or not internal:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n # add prefix/suffix within the executable path:\n url = TextFormat.formatOutput(self, url, titleMode, internal)\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n results.append(u'<a href=\"%s\">%s</a>' %\n (escape(path, treedoc.escDict), altText or url))\n return u'<br />'.join(results)",
"def complete_alt_title(self, obj):\n return str(obj)",
"def clean_title(\r\n title: str,\r\n mode: Literal[\"soft\", \"hard\", \"safe\"],\r\n allow_dot: bool = False,\r\n n: Optional[int] = None,\r\n) -> str:\r\n ...",
"def text(self) -> str:",
"def get_title(self):\n\n title = ''\n doc = self.article.doc\n\n title_element = self.parser.getElementsByTag(doc, tag='title')\n # no title found\n if title_element is None or len(title_element) == 0:\n return title\n\n # title elem found\n title_text = self.parser.getText(title_element[0])\n used_delimeter = False\n\n # split title with |\n if '|' in title_text:\n title_text = self.split_title(title_text, PIPE_SPLITTER)\n used_delimeter = True\n\n # split title with -\n if not used_delimeter and '-' in title_text:\n title_text = self.split_title(title_text, DASH_SPLITTER)\n used_delimeter = True\n\n # split title with »\n if not used_delimeter and u'»' in title_text:\n title_text = self.split_title(title_text, ARROWS_SPLITTER)\n used_delimeter = True\n\n # split title with :\n if not used_delimeter and ':' in title_text:\n title_text = self.split_title(title_text, COLON_SPLITTER)\n used_delimeter = True\n\n title = MOTLEY_REPLACEMENT.replaceAll(title_text)\n return title",
"def print_title(title):\n\n print(\"\\n\" + title)\n print(\"=\" * len(title))",
"def format_rich_quote(rich_text_quote):\n rich_text = format_rich_text(rich_text_quote)\n return \"> \" + \"\\n> \".join(rich_text.split(\"\\n\")) + \"\\n\"",
"def SearchableText(self):\n ctool = getToolByName(self, 'portal_cpscalendar')\n if getattr(ctool, 'event_fulltext_index', False):\n return '%s %s' % (self.title, self.description)\n return ''",
"def __str__(self):\n t = Template(\n \"\"\"\n <h4>$title</h4>\n $imgs\n $footnotes\n <hr/>\"\"\")\n # Return result.\n return t.substitute({\n \"title\": self.title,\n \"imgs\": self.render_images(),\n \"footnotes\": self.render_footnotes()\n })",
"def visit_title_reference(self, node):\n self.body.append('\\\\emph{\\\\textbf{')",
"def render(resolve_unicode,\n title_force_uppercase,\n msdos_eol_style,\n output_encoding,\n omit_fields=[]):",
"def inject_title(self,template,title):\n return re.sub('TITLE',title,template)",
"def format_screen(self,str):\n # Paragraph continue\n par_re = re.compile(r'\\\\$',re.MULTILINE)\n str = par_re.sub('',str)\n return str",
"def __format__(self, format_spec):\n # This calls the compiled regex stored on ANSIString's class to analyze the format spec.\n # It returns a dictionary.\n format_data = self.re_format.match(format_spec).groupdict()\n clean = self.clean()\n base_output = ANSIString(self.raw())\n align = format_data.get(\"align\", \"<\")\n fill = format_data.get(\"fill\", \" \")\n\n # Need to coerce width into an integer. We can be certain that it's numeric thanks to regex.\n width = format_data.get(\"width\", None)\n if width is None:\n width = len(clean)\n else:\n width = int(width)\n\n if align == \"<\":\n base_output = self.ljust(width, fill)\n elif align == \">\":\n base_output = self.rjust(width, fill)\n elif align == \"^\":\n base_output = self.center(width, fill)\n elif align == \"=\":\n pass\n\n # Return the raw string with ANSI markup, ready to be displayed.\n return base_output.raw()",
"def title_content(label=\"A title\"):\n return {'label':label}",
"def _make_title(self):\n ret = self.properties['reason'].capitalize()\n ret += ' has been reported near ' + self.properties['address'].split(',')[0]\n time = datetime.strptime(self.properties['when'], '%Y-%m-%dT%H:%M:%S')\n times = [time.strftime(i).lstrip('0') for i in ('%m', '%d', '%I:%M%p')]\n ret += ' on {}/{} at {}'.format(times[0], times[1], times[2])\n return ret",
"def title_p(self):\n self.run_command('title_p')",
"def title(self):\n # Use the first line of the articles text as title, if not title\n # exists.\n title = self._text[:min(32, self._text.find(\"\\n\"))]\n return title",
"def numbered_title(self):\n return f\"{self.title}\"",
"def numbered_title(self):\n return f\"{self.title}\"",
"def render_text(self):\n if self.text_type == 1:\n return markdown.markdown(self.text)\n else:\n return self.text",
"def dumps(self):\n\n if not self.numbering:\n num = '*'\n else:\n num = ''\n\n string = Command(self.latex_name + num, self.title).dumps()\n string += '%\\n' + self.dumps_content()\n\n return string",
"def processTitle(title):\n\n cleaned = re.sub(r'[@#\\\"]+', '', title.lower().strip())\n cleaned = re.sub(r'\\(\\d{4}.*\\)', '', cleaned)\n cleaned = re.sub(r':.+', '', cleaned).strip()\n return cleaned",
"def show(self) -> str:\n return f'[{self.font}]{self.text}[{self.font}]' if self.font else self.text"
] | [
"0.67517006",
"0.6623557",
"0.64947814",
"0.6347113",
"0.6307539",
"0.621596",
"0.6210496",
"0.60684896",
"0.60674477",
"0.60663515",
"0.60421175",
"0.6019259",
"0.59935653",
"0.59802073",
"0.59790826",
"0.5948588",
"0.5939195",
"0.590317",
"0.5872387",
"0.58521676",
"0.5838757",
"0.5835408",
"0.5834278",
"0.5832544",
"0.58303535",
"0.58232164",
"0.58196765",
"0.5818879",
"0.581837",
"0.58134586",
"0.58123326",
"0.57893336",
"0.5777435",
"0.5773666",
"0.5759935",
"0.57562524",
"0.57514244",
"0.5736761",
"0.5721786",
"0.57156",
"0.5693657",
"0.56579095",
"0.56524575",
"0.56516933",
"0.56416726",
"0.5639766",
"0.5630319",
"0.56235963",
"0.5607828",
"0.55989367",
"0.5597865",
"0.5593643",
"0.55868447",
"0.5576239",
"0.55753696",
"0.5570099",
"0.556155",
"0.55568874",
"0.55474097",
"0.5539662",
"0.5532411",
"0.5531814",
"0.5512975",
"0.5479672",
"0.54774815",
"0.54768354",
"0.5473451",
"0.54682344",
"0.5464578",
"0.54521894",
"0.5445922",
"0.5437787",
"0.54369724",
"0.5422958",
"0.5415149",
"0.5415149",
"0.5399354",
"0.539413",
"0.53890395",
"0.5382889",
"0.5382856",
"0.53564143",
"0.535306",
"0.53529805",
"0.5352455",
"0.5347083",
"0.5333787",
"0.5333257",
"0.5332394",
"0.5331696",
"0.53306514",
"0.53304696",
"0.53293514",
"0.5327383",
"0.53269297",
"0.53269297",
"0.53238297",
"0.53169096",
"0.5314785",
"0.5314103"
] | 0.595393 | 15 |
Return tuple of text in edit format and bool validity, using edit format option | def formatEditText(self, storedText):
if storedText in self.formatList:
return (storedText, True)
try:
return (GenBoolean(storedText).boolStr(self.format), True)
except GenBooleanError:
return (storedText, not storedText) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def storedText(self, editText):\n if editText in self.formatList:\n return (editText, True)\n return (editText, not editText and not self.isRequired)",
"def storedText(self, editText):\n try:\n return (repr(GenBoolean(editText)), True)\n except GenBooleanError:\n if editText in self.formatList:\n return (editText, True)\n return (editText, not editText and not self.isRequired)",
"def formatEditText(self, storedText):\n for choice in self.splitText(storedText):\n if choice not in self.formatList:\n return (storedText, not storedText)\n return (storedText, True)",
"def formatEditText(self, storedText):\n return (storedText, True)",
"def formatEditText(self, storedText):\n return (storedText, True)",
"def editText(self, item):\n storedText = item.data.get(self.name, '')\n result = self.formatEditText(storedText)\n if self.isRequired and not result[0]:\n return (result[0], False)\n return result",
"def formatEditText(self, storedText):\n if storedText in self.formatList:\n return (storedText, True)\n return (storedText, not storedText)",
"def storedText(self, editText):\n if editText:\n return (editText, True)\n return (editText, not self.isRequired)",
"def storedText(self, editText):\n choices, valid = self.sortedChoices(editText)\n if valid:\n return (self.editSep.join(choices), True)\n else:\n return (editText, not editText and not self.isRequired)",
"def storedText(self, editText):\n format = globalref.options.strData('EditDateFormat', True)\n try:\n return (repr(GenDate().setFromStr(editText, format)), True)\n except GenDateError:\n return (editText, not editText and not self.isRequired)",
"def formatEditText(self, storedText):\n try:\n return (GenNumber(storedText).numStr(self.format), True)\n except GenNumberError:\n return (storedText, not storedText)",
"def storedText(self, editText):\n try:\n return (repr(GenNumber().setFromStr(editText, self.format)), True)\n except GenNumberError:\n return (editText, not editText and not self.isRequired)",
"def storedText(self, editText):\n try:\n return (repr(GenTime(editText)), True)\n except GenTimeError:\n return (editText, not editText and not self.isRequired)",
"def formatEditText(self, storedText):\n format = globalref.options.strData('EditDateFormat', True)\n try:\n return (GenDate(storedText).dateStr(format), True)\n except GenDateError:\n return (storedText, not storedText)",
"def storedText(self, editText):\n return (editText, editText or not self.isRequired)",
"def formatEditText(self, storedText):\n format = globalref.options.strData('EditTimeFormat', True)\n try:\n return (GenTime(storedText).timeStr(format), True)\n except GenTimeError:\n return (storedText, not storedText)",
"def complete_opt_format(self, text, *_):\n return [t + \" \" for t in FORMATTERS if t.startswith(text)]",
"def reformat(ctx):\n pass",
"def task_format_check():\n return {\"actions\": [[\"black\", HERE, \"--check\"]], \"verbosity\": 1}",
"def getEditChoices(self, currentText=''):\n return [(text, '') for text in self.formatList]",
"def syntax_text():",
"def formatted(s):\n matches = re.findall(_format_re, normalize(s))\n if len(matches) == 1 and matches[0][0] != '':\n return matches[0][0]\n def to_fmt(txt_none, txt_sw, txt_rem, txt_em, txt_a):\n if txt_none != '':\n return FORMAT_NONE, txt_none\n elif txt_sw != '':\n return FORMAT_SW, txt_sw\n elif txt_rem != '':\n return FORMAT_REM, txt_rem\n elif txt_em != '':\n return FORMAT_EM, txt_em\n elif txt_a != '':\n return FORMAT_A, txt_a\n return [to_fmt(*m) for m in matches]",
"def _do_checkbox_setting(cls, text: str, title: str, replace_args: tuple) -> typing.Tuple[str, bool, bool]:\n title = title.strip()\n\n lines = []\n found = False\n modified = False\n for line, is_checkbox in cls._iterate_lines(text):\n if is_checkbox and title == cls._get_checkbox_title(line):\n found = True\n lines.append(line.replace(*replace_args))\n if line != lines[-1]:\n modified |= True\n\n continue\n\n lines.append(line)\n\n return \"\\n\".join(lines), found, modified",
"def test_format_permissions_and_docstring(self):\n self.assertEqual(\n format_permissions_and_docstring(\n [\"permission formatted string\"],\n {\"some\": \"docstring\"},\n ),\n (\n \"## Permissions\\n\\n\"\n \"permission formatted string\\n\"\n \"### Permission description\\n\\n\"\n \"- **some** : docstring\"\n ),\n )\n\n self.assertEqual(\n format_permissions_and_docstring(\n [\"permission formatted string\", \"another permission\"],\n {\"some\": \"docstring\", \"another\": \"docstring\"},\n ),\n (\n \"## Permissions\\n\\n\"\n \"- permission formatted string\\n\"\n \"- another permission\\n\"\n \"### Permission description\\n\\n\"\n \"- **some** : docstring\\n\"\n \"- **another** : docstring\"\n ),\n )",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def text(value):\n return True",
"def test_is_entry_formatted(self):\n\n valid_formats = test_case_data.get('valid_formats')\n for i, valid_entry in enumerate(test_case_data.get('valid_entries')):\n entry = [value.strip() for value in valid_entry.split(',')]\n format_fields = valid_formats[i].split(',')\n valid = self.parser._is_entry_formatted(entry, format_fields)\n self.assertTrue(valid, f'{entry} is not of a valid format')\n\n # fails with invalid entries\n for invalid_entry in test_case_data.get('invalid_entries'):\n entry = [value.strip() for value in invalid_entry.split(',')]\n for f in valid_formats:\n format_fields = f.split(',')\n entry_dict = self.parser._is_entry_formatted(entry, format_fields)\n self.assertFalse(entry_dict, f'{entry} is not of a valid format')",
"def formatText(s, bold=False, underlined=False, negative=False):\n\n if not FORMATTING_AVAILABLE:\n return s\n\n head = \"\"\n if bold: head += \"\\033[1m\"\n if underlined: head += \"\\033[4m\"\n if negative: head += \"\\033[7m\"\n\n return head + s + \"\\033[0m\"",
"def analyze_text(words, format_bolds, format_italics, de_condition={'bold':1, 'italic':-1}, en_condition={'bold':0, 'italic':-1}, end_of_item_eol=False, eoi_bold_to_unbold=False, eoi_unbold_to_bold=True, eoi_italic_to_unitalic=False, eoi_unitalic_to_italic=False):\n table = []\n de_words = ['']\n en_words = ['']\n if de_condition['bold'] != -1: de_condition['bold'] = not(not(de_condition['bold'])) # convert integer to boolean\n if de_condition['italic'] != -1: de_condition['italic'] = not(not(de_condition['italic']))\n \n last_format_bold = False\n last_format_italic = False\n de_bold_ok = False\n de_italic_ok = False\n en_bold_ok = False\n en_italic_ok = False\n item_no = 0\n for k in range(len(words)):\n if format_bolds[k] == False:\n new_format_bold = False\n elif format_bolds[k] == True:\n new_format_bold = True\n if format_italics[k] == False:\n new_format_italic = False\n elif format_italics[k] == True:\n new_format_italic = True\n\n # Check condition for switching to the new item\n flag_new = True\n if item_no>0 and end_of_item_eol and words[k]!='\\n': flag_new = False\n if item_no>0 and eoi_bold_to_unbold and not(last_format_bold and not new_format_bold): flag_new = False\n if item_no>0 and eoi_unbold_to_bold and not(not last_format_bold and new_format_bold): flag_new = False\n if item_no>0 and eoi_italic_to_unitalic and not(last_format_italic and not new_format_italic): flag_new = False\n if item_no>0 and eoi_unitalic_to_italic and not(not last_format_italic and new_format_italic): flag_new = False\n last_format_bold = new_format_bold\n last_format_italic = new_format_italic\n if flag_new:\n de_words.append('')\n en_words.append('')\n item_no += 1\n \n if words[k]!='\\n': # also format_bolds[k] and format_italics[k] must be either True or False\n if de_condition['bold'] != -1:\n de_bold_ok = not de_condition['bold']^format_bolds[k] # use XOR operator\n else: de_bold_ok = True\n if de_condition['italic'] != -1:\n de_italic_ok = not de_condition['italic']^format_bolds[k]\n else: de_italic_ok = True\n if de_bold_ok and de_italic_ok: de_words[item_no] += words[k]\n \n if en_condition['bold'] != -1:\n en_bold_ok = not en_condition['bold']^format_bolds[k]\n else: en_bold_ok = True\n if en_condition['italic'] != -1:\n en_italic_ok = not en_condition['italic']^format_bolds[k]\n else: en_italic_ok = True\n if en_bold_ok and en_italic_ok: en_words[item_no] += words[k]\n else:\n # Check if this end-of-line should be converted to a space, to connect lines\n if de_words[item_no] != '' and de_bold_ok and de_italic_ok: de_words[item_no] += ' '\n if en_words[item_no] != '' and en_bold_ok and en_italic_ok: en_words[item_no] += ' ' \n \n return de_words, en_words",
"def formatOutput(self, storedText, titleMode, internal=False):\n if storedText not in self.formatList:\n try:\n storedText = GenBoolean(storedText).boolStr(self.format)\n except GenBooleanError:\n storedText = _errorStr\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def formatter(text):\n repl_map = {\n \"degC\": \"$^o$C\",\n \"K\": \"$^o$C\",\n \"month-1\": \"month$^{{-1}}$\",\n \"day-1\": \"day$^{{-1}}$\",\n \"d-1\": \"day$^{{-1}}$\",\n \"decade-1\": \"decade$^{{-1}}$\",\n \"year-1\": \"year$^{{-1}}$\",\n \"rcp85\": \"RCP8.5\",\n \"rcp45\": \"RCP4.5\",\n \"rcp26\": \"RCP2.6\",\n \"RCP85\": \"RCP8.5\",\n \"RCP45\": \"RCP4.5\",\n \"RCP26\": \"RCP2.6\",\n \"cmip5-85\": \"RCP8.5\",\n \"cmip5-60\": \"RCP6.0\",\n \"cmip5-45\": \"RCP4.5\",\n \"cmip5-26\": \"RCP2.6\",\n \"ssp585\": \"SSP5-8.5\",\n \"ssp245\": \"SSP2-4.5\",\n \"ssp126\": \"SSP1-2.6\",\n \"SSP585\": \"SSP5-8.5\",\n \"SSP245\": \"SSP2-4.5\",\n \"SSP126\": \"SSP1-2.6\",\n \"cmip6-85\": \"SSP5-8.5\",\n \"cmip6-70\": \"SSP3-7.0\",\n \"cmip6-60\": \"SSP4-6.0\",\n \"cmip6-34\": \"SSP4-3.4\",\n \"cmip6-45\": \"SSP2-4.5\",\n \"cmip6-26\": \"SSP1-2.6\",\n \"cmip6-19\": \"SSP1-1.9\",\n \"1\": \"%\",\n \"era5\": \"ERA5\",\n \"gpcc025x025_v8\": \"GPCC\",\n \"cru\": \"CRU\",\n \"jra55\": \"JRA55\",\n \"HIGHRESMIP\": \"HighResMIP\",\n \" \": \"\",\n }\n for key, val in repl_map.items():\n if key in text:\n text = text.replace(key, val)\n break\n return text",
"def _check_style(file_path, clang_format_bin):\n with open(file_path, 'r') as f:\n is_valid_header = f.read().startswith(CppFormatter.standard_header)\n\n cmd = [\n clang_format_bin,\n \"-style=file\",\n \"-output-replacements-xml\",\n file_path,\n ]\n result = subprocess.check_output(cmd).decode(\"utf-8\")\n if \"<replacement \" in result:\n is_valid_style = False\n else:\n is_valid_style = True\n return (is_valid_style, is_valid_header)",
"def info(level):\n if level == 'basic':\n string = _(\"Basic markup\")\n text = _(\"Only basic text tags are available in this input field.\")\n elif level == 'rich':\n string = _(\"Rich markup\")\n text = _(\"Rich and basic text tags are available in this input field.\") \n elif level == 'full':\n string = _(\"Full markup\")\n text = _(\"Every tags are available in this input field.\") \n elif level == 'none':\n string = _(\"No markup\")\n text = _(\"No tags are available in this input field.\") \n\n if level != 'none':\n text = text + \" \" + _(\"Check the markup reminder in related documentation for a description of these tags.\")\n\n return '<span class=\"help\" title=' + quoteattr(text) \\\n + '><img src=\"' + settings.STATIC_MEDIA_URL \\\n + 'images/savane/common/misc.default/edit.png' \\\n + ' border=\"0\" class=\"icon\" alt=\"\" />' \\\n + string + '</span>'",
"def fancyString(inVal, correctOutput, funcOutput):\r\n checkCorrect = \"Correct = \" + u'\\u2713'*(funcOutput == correctOutput) + 'X'*(funcOutput != correctOutput)\r\n # Check mark code from site below:\r\n # https://stackoverflow.com/questions/16676101/print-the-approval-sign-check-mark-u2713-in-python\r\n return \"Input(s) = {:<15} Output = {:<25} Your Output = {:<35} \".format(str(inVal), str(correctOutput), str(funcOutput)) + checkCorrect",
"def human_readable(self):\n if self.no_flags_set():\n return \"no flags set\"\n else:\n flag_desc = []\n for name in (\"bookmarked\", \"for_validation\", \"candidate\", \"final causative\"):\n if getattr(self, \"flag_%s\" % name.replace(\" \", \"_\")):\n flag_desc.append(name)\n for name in (\"visual\", \"validation\", \"molecular\", \"phenotype_match\", \"summary\"):\n field = getattr(self, \"flag_%s\" % name)\n if field and field != \"empty\":\n flag_desc.append(\"%s rating is %s\" % (name.split(\"_\")[0], field))\n return \", \".join(flag_desc)",
"def get_format_opts(cls, format_=\"value\", fields=[]):\n return \" -f {0} {1}\".format(format_, \" \".join([\"-c \" + it for it in fields]))",
"def parse_edits(line):\n \n # Get edits inside brackets allowing parentheses\n edit_strings = re.findall(r'\\((.*?)\\)[,\\]]', line)\n \n edits = []\n for edit_string in edit_strings:\n # Splitting by comma is not enough. Some of the edits actually fix spacing\n # when commas are used, so we may can't use edit_string.split(', ')\n # For some reason, the unicode gold strings are enclosed in a list\n m = re.match(r'^(\\d+), (\\d+), (.*), \\[?(.*)\\]?$', edit_string)\n edit_items = [m.group(i) for i in range(1, 5)]\n \n # No way to handle this in regex\n if edit_items[3].endswith(']'):\n edit_items[3] = edit_items[3][:-1]\n \n # Cast the indices\n edit_items[0] = int(edit_items[0])\n edit_items[1] = int(edit_items[1])\n \n # Convert unicode-string-inside-string into actual unicode string\n edit_items[2] = codecs.decode(edit_items[2][2:-1], 'unicode_escape') or 'NIL'\n edit_items[3] = codecs.decode(edit_items[3][2:-1], 'unicode_escape') or 'NIL'\n \n edits.append(edit_items)\n \n return edits",
"def format_text(text):\n text = text.replace('to do ', '') \\\n .replace('to ', '') \\\n .replace(' at ', ' on ') \\\n .replace(' a ', ' 1 ') \\\n .replace(' an ', ' 1 ') \\\n .replace('minutes', '60') \\\n .replace('minute', '60') \\\n .replace('seconds', '1') \\\n .replace('second', '1') \\\n .replace('hours', '3600') \\\n .replace('hour', '3600')\n text = text.split(' ')\n pure_text = \"\"\n if text[-3] == 'in':\n for i in range(0, (len(text)-3)):\n pure_text += \" \" + text[i]\n final_text = [pure_text, text[-3], text[-2], text[-1]]\n else:\n for i in range(0, (len(text)-2)):\n pure_text += text[i]\n final_text = [pure_text, text[-2], text[-1]]\n if len(text) < 3:\n pprint(final_text)\n raise Exception(\"Bad remind request\")\n\n return final_text",
"def show_line_edit_dialog(text):\n dialog = QDialog()\n interface = lineEditEntryGenerated.Ui_Dialog()\n interface.setupUi(dialog)\n interface.label.setText(text)\n if dialog.exec_() == 1:\n return True, str(interface.lineEdit.text())\n else:\n return False, \"\"",
"def as_tuple(self, selected: bool) -> tuple:\n if self.check_ans:\n current = self.num.ljust(2) + self.answer\n else:\n current = self.num.ljust(2)+self.current.rjust(1)\n return ((\n \"fg:\"+self.style_fg + \" bg:\" # apply foreground color\n + (self.style_bg_selected if selected else self.style_bg),\n current\n if self.answer != \".\" else \"▐\" + \"█\" + \"▌\"), ('bg:#fefefe fg:#000', \"│\"))",
"def test_buoy_format1():\n with pytest.raises(AssertionError) as err_info:\n Check_BuoyDC.check_buoy_format(buoy_format_fail_1)\n assert str(err_info.value) == 'Input formatted incorrectly, see instructions'",
"def normalize_text_for_edit(user, text, rich_text, escape_html=True):\n if text is None:\n return ''\n\n if not rich_text and is_rich_text_default_for_user(user):\n # This isn't rich text, but it's going to be edited as rich text,\n # so escape it.\n text = djblets_markdown.markdown_escape(text)\n\n if escape_html:\n text = escape(text)\n\n return text",
"def hints(s):\n if s == 'hello':\n # string, color, bold\n return (' World', 35, False)\n return None",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def formatOutput(self, storedText, titleMode, internal=False):\n if storedText not in self.formatList:\n storedText = _errorStr\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def get_data_from_nonformat_text():\n pass",
"def FormatYesNo(value):\n if value:\n return u'Yes'\n else:\n return u'No'",
"def validateWorkFormat(format):\n\n if not(format):\n return \"You must select a work format.\"",
"def rich(text):\n return full(text, False)",
"def edit(self, text):\n return self._edit_engine(text, break_on_success=False)",
"def change_prompt_format(self, arg, **_):\n if not arg:\n message = 'Missing required argument, format.'\n return [(None, None, None, message)]\n\n self.prompt_format = self.get_prompt(arg)\n return [(None, None, None, \"Changed prompt format to %s\" % arg)]",
"def test_command_edit_info_boolean_flags():\n def f(inputfile):\n with tempfile.NamedTemporaryFile() as tmp:\n shutil.copy(inputfile, tmp.name)\n\n for flag in (\"write_protected\", \"synchronized\", \"cleaned\"):\n for true_value, false_value in ((\"1\", \"0\"),\n (\"yes\", \"no\"),\n (\"YES\", \"No\"),\n (\"true\", \"false\"),\n (\"tRuE\", \"FaLsE\")):\n wozardry.parse_args([\"edit\", \"-i\", \"%s:%s\" % (flag, true_value), tmp.name])\n with open(tmp.name, \"rb\") as tmpstream:\n woz = wozardry.WozDiskImage(tmpstream)\n assert woz.info[flag] == True\n wozardry.parse_args([\"edit\", \"-i\", \"%s:%s\" % (flag, false_value), tmp.name])\n with open(tmp.name, \"rb\") as tmpstream:\n woz = wozardry.WozDiskImage(tmpstream)\n assert woz.info[flag] == False\n f(kValid1)\n f(kValid2)",
"def getEditChoices(self, currentText=''):\n format = globalref.options.strData('EditDateFormat', True)\n today = GenDate().dateStr(format)\n yesterday = (GenDate() - 1).dateStr(format)\n tomorrow = (GenDate() + 1).dateStr(format)\n return [(today, '(%s)' % _('today')),\n (yesterday, '(%s)' % _('yesterday')),\n (tomorrow, '(%s)' % _('tomorrow'))]",
"def get_help_text(self):\n requirements = \"Your password must contain at least: {min_length} \" \\\n \"character(s), {min_uppercase} uppercase letter(s), \" \\\n \"{min_lowercase} lowercase letter(s) and \" \\\n \"{min_digits} digit(s). \".format(\n min_length=self.min_length,\n min_uppercase=self.min_uppercase,\n min_lowercase=self.min_lowercase,\n min_digits=self.min_digits)\n return requirements",
"def format_text(text: TTextType) -> typing.Iterator[TViewLine]:\n for line in text.splitlines():\n yield [(\"text\", line)]",
"def help_for(self, flag: str) -> Tuple[str, str]:\n # Obtain arg obj\n if flag not in self.flags:\n err = \"{!r} is not a valid flag for this context! Valid flags are: {!r}\" # noqa\n raise ValueError(err.format(flag, self.flags.keys()))\n arg = self.flags[flag]\n # Determine expected value type, if any\n value = {str: \"STRING\", int: \"INT\"}.get(arg.kind)\n # Format & go\n full_names = []\n for name in self.names_for(flag):\n if value:\n # Short flags are -f VAL, long are --foo=VAL\n # When optional, also, -f [VAL] and --foo[=VAL]\n if len(name.strip(\"-\")) == 1:\n value_ = (\"[{}]\".format(value)) if arg.optional else value\n valuestr = \" {}\".format(value_)\n else:\n valuestr = \"={}\".format(value)\n if arg.optional:\n valuestr = \"[{}]\".format(valuestr)\n else:\n # no value => boolean\n # check for inverse\n if name in self.inverse_flags.values():\n name = \"--[no-]{}\".format(name[2:])\n\n valuestr = \"\"\n # Tack together\n full_names.append(name + valuestr)\n namestr = \", \".join(sorted(full_names, key=len))\n helpstr = arg.help or \"\"\n return namestr, helpstr",
"def __check_format(node, lint_ctx, profile: str, allow_ext=False):\n if \"format_source\" in node.attrib and (\"ext\" in node.attrib or \"format\" in node.attrib):\n lint_ctx.warn(\n f\"Tool {node.tag} output '{node.attrib.get('name', 'with missing name')}' should use either format_source or format/ext\",\n node=node,\n )\n if \"format_source\" in node.attrib:\n return True\n if node.find(\".//action[@type='format']\") is not None:\n return True\n # if allowed (e.g. for discover_datasets), ext takes precedence over format\n fmt = None\n if allow_ext:\n fmt = node.attrib.get(\"ext\")\n if fmt is None:\n fmt = node.attrib.get(\"format\")\n if fmt == \"input\":\n message = f\"Using format='input' on {node.tag} is deprecated. Use the format_source attribute.\"\n if Version(str(profile)) <= Version(\"16.01\"):\n lint_ctx.warn(message, node=node)\n else:\n lint_ctx.error(message, node=node)\n\n return fmt is not None",
"def get_opt_formatted(self, command):\n if \"formatted\" in self.command_dict[\"commands\"][command].keys():\n return self.command_dict[\"commands\"][command][\"formatted\"]\n else:\n return CommandDict.DEFAULT_OPT_FORMATTED",
"def test_incorrect_formats(self, text):\n with pytest.raises(ValueError):\n parse_changelog(text)",
"def getEditChoices(self, currentText=''):\n format = globalref.options.strData('EditTimeFormat', True)\n now = GenTime().timeStr(format)\n choices = [(now, '(%s)' % _('now'))]\n for hr in (6, 9, 12, 15, 18, 21, 0):\n time = GenTime((hr, 0)).timeStr(format)\n choices.append((time, ''))\n return choices",
"def verify_diagnostics_and_usage_text():\r\n msg, status = \"\", True\r\n try:\r\n sleep(10)\r\n if g.platform == 'android':\r\n sleep(3)\r\n 'verify end user license agreement label'\r\n flag1,msg = element_textvalidation('Diagnostics_usage_lbl','Diagnostics and Usage')\r\n sleep(4) \r\n 'Read verification input data'\r\n text_to_verify = util.read_file(g.demomode_Diagnostcs_nd_usage_txt)\r\n 'verify end user license agreement label'\r\n flag2,msg = element_textvalidation('Diagnostics_usage_txt',text_to_verify)\r\n \r\n flag = False if not (flag1 and flag2) else True\r\n else:\r\n\r\n \r\n 'Verify diagnostics usage text'\r\n flag1 = ui_controls.ui_element(get_obj_identifier('Diagnostics_usage_lbl'))\r\n 'Verify diagnostics usage text'\r\n flag2 = ui_controls.ui_element(get_obj_identifier('Diagnostics_usage_txt'))\r\n \r\n sleep(4) \r\n \r\n flag = False if not (flag1 and flag2) else True\r\n if not flag:\r\n return False, msg\r\n else:\r\n print \"License agreement screen name is displayed properly\"\r\n \r\n \r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n return False, msg\r\n return True, msg",
"def _format_action(self, action):\n parts = super(argparse.RawDescriptionHelpFormatter, self)._format_action(action)\n if action.nargs == argparse.PARSER:\n parts = \"\\n\".join(parts.split(\"\\n\")[1:])\n return parts",
"def formatOutput(self, storedText, titleMode, internal=False):\n choices, valid = self.sortedChoices(storedText)\n if valid:\n result = self.sep.join(choices)\n else:\n result = _errorStr\n return TextFormat.formatOutput(self, result, titleMode, internal)",
"def _engine_option_string_and_comment(option: engine.Option, value: engine.ConfigValue) -> Tuple[str, str]:\n if value is None:\n value = ''\n name_equals_val = f'{option.name}={value}'\n if option.type == 'check' or option.type == 'string' or option.type == 'button':\n return (name_equals_val, f'type={option.type}')\n if option.type == 'spin':\n return (name_equals_val, f'type=spin, min={option.min}, max={option.max}')\n if option.type == 'combo':\n return (name_equals_val, f'type=combo, var={option.var}')\n return (name_equals_val, 'type=unknown')",
"def TEXT(number, format_type):\n raise NotImplementedError()",
"def test_form_help_text_is_correct(self):\n # https://stackoverflow.com/questions/24344981/how-to-change-help-\n # text-of-a-django-form-field\n\n # Above link helped figure out how to access help_text.\n self.assertEqual(\n self.form.fields[\"texture\"].help_text,\n \"One word descriptions seperated by commas.\",\n )",
"def reformat():\n toolkit.reformat()",
"def __verify_plot_options(self, options_str):\n default_line = '-'\n default_marker = ''\n default_colour = 'k'\n\n # Split str into chars list\n options_split = list(options_str)\n\n # If 0, set defaults and return early\n if len(options_split) == 0:\n return [default_line, default_marker, default_colour]\n\n # If line_style given, join the first two options if applicable\n # (some types have 2 characters)\n for char in range(0, len(options_split) - 1):\n # If char is '-' (only leading character in double length option)\n if options_split[char] == '-' and len(options_split) > 1:\n # If one of the leading characters is valid\n if options_split[char + 1] == '-' or \\\n options_split[char + 1] == '.':\n # Join the two into the first\n options_split[char] = options_split[char] \\\n + options_split[char + 1]\n # Shuffle down the rest\n for idx in range(char + 2, len(options_split)):\n options_split[idx - 1] = options_split[idx]\n # Remove duplicate extra\n options_split.pop()\n\n # If any unknown, throw error\n for option in options_split:\n if option not in self.__line_styles and \\\n option not in self.__marker_styles and \\\n option not in self.__colour_styles:\n error_string = \"Unknown character entered: '{0}'\"\n raise ValueError(error_string.format(option))\n\n ##############################\n # Verify Line Style\n ##############################\n line_style_count = 0 # Count of options used\n # Index position of index used (only used when count == 1)\n line_style_index = 0\n for option in options_split:\n if option in self.__line_styles:\n line_style_count = line_style_count + 1\n line_style_index = self.__line_styles.index(option)\n\n # If more than one, throw error\n if line_style_count > 1:\n raise ValueError(\n \"Too many line style arguments given. Only one allowed\")\n # If none, set as solid\n elif line_style_count == 0 or not any(\n item in options_split for item in self.__line_styles):\n output_line = default_line\n # If one, set as given\n else:\n output_line = self.__line_styles[line_style_index]\n ##############################\n\n ##############################\n # Verify Marker Style\n ##############################\n marker_style_count = 0 # Count of options used\n # Index position of index used (only used when count == 1)\n marker_style_index = 0\n for option in options_split:\n if option in self.__marker_styles:\n marker_style_count = marker_style_count + 1\n marker_style_index = self.__marker_styles.index(option)\n\n # If more than one, throw error\n if marker_style_count > 1:\n raise ValueError(\n \"Too many marker style arguments given. Only one allowed\")\n # If none, set as no-marker\n elif marker_style_count == 0 or not any(\n item in options_split for item in self.__marker_styles):\n output_marker = default_marker\n # If one, set as given\n else:\n output_marker = self.__marker_styles[marker_style_index]\n # If marker set and no line given, turn line to no-line\n if line_style_count == 0 or not any(\n item in options_split for item in self.__line_styles):\n output_line = ''\n ##############################\n\n ##############################\n # Verify Colour Style\n ##############################\n colour_style_count = 0 # Count of options used\n # Index position of index used (only used when count == 1)\n colour_style_index = 0\n for option in options_split:\n if option in self.__colour_styles:\n colour_style_count = colour_style_count + 1\n colour_style_index = self.__colour_styles.index(option)\n\n # If more than one, throw error\n if colour_style_count > 1:\n raise ValueError(\n \"Too many colour style arguments given. Only one allowed\")\n # If none, set as black\n elif colour_style_count == 0 or not any(\n item in options_split for item in self.__colour_styles):\n output_colour = default_colour\n # If one, set as given\n else:\n output_colour = self.__colour_styles[colour_style_index]\n ##############################\n\n return [output_line, output_marker, output_colour]",
"def getEditChoices(self, currentText=''):\n currentChoices, valid = self.sortedChoices(currentText)\n nonChoices = [text for text in self.formatList\n if text not in currentChoices]\n results = []\n for choice in nonChoices: # menu entries to add a choice\n allChoices = currentChoices + [choice]\n allChoices = [text for text in self.formatList\n if text in allChoices]\n results.append((self.editSep.join(allChoices),\n '(%s %s)' % (_('add'), choice)))\n if currentChoices:\n results.append((None, None)) # separator\n for choice in currentChoices: # menu entries to remove a choice\n allChoices = currentChoices[:]\n allChoices.remove(choice)\n allChoices = [text for text in self.formatList\n if text in allChoices]\n results.append((self.editSep.join(allChoices),\n '(%s %s)' % (_('remove'), choice)))\n return results",
"def make_input(value):\n what = value[0]\n if what.startswith('not editable'):\n what = what.replace('not editable:', '').replace(\"'\", \"\\'\")\n if what.startswith('attribute:value:'):\n what = what.replace('attribute:value:', '').replace(\"'\", \"\\'\")\n return what",
"def validate_format(self):\n raise NotImplementedError()",
"def formatOutput(self, storedText, titleMode, internal=False):\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def _validate_performatives(performative: str) -> Tuple[bool, str]:\n # check performative is not a reserved name\n if _is_reserved_name(performative):\n return (\n False,\n \"Invalid name for performative '{}'. This name is reserved.\".format(\n performative,\n ),\n )\n\n # check performative's format\n if not _is_valid_regex(PERFORMATIVE_REGEX_PATTERN, performative):\n return (\n False,\n \"Invalid name for performative '{}'. Performative names must match the following regular expression: {} \".format(\n performative, PERFORMATIVE_REGEX_PATTERN\n ),\n )\n\n return True, \"Performative '{}' is valid.\".format(performative)",
"def value_textvalidation(objectidentifier,validationtext):\r\n msg, status = \"\", True\r\n\r\n try:\r\n 'Here we will pass objectidentifier for required element'\r\n text_heading = ui_controls.text_view(get_obj_identifier(objectidentifier),value=True)\r\n print \"Current text returned by UI is==>\"+str(text_heading)\r\n\r\n 'To check if it is returning empty value here'\r\n if not text_heading:\r\n print str(validationtext)+\" text does not exist and it is returning empty value.\"\r\n return False, msg\r\n\r\n 'Comparing text retrieved from UI with validation text'\r\n if validationtext.strip() == text_heading.strip():\r\n print (str(validationtext)+\" text has been found!!!\")\r\n else:\r\n print(\"Sorry!!!text has been mismatched,it should be \"+str(validationtext))\r\n print (\"Text shown at UI is==>\"+str(text_heading))\r\n return False, msg \r\n\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg",
"def _format (color, style=''):\n _format = QtGui.QTextCharFormat()\n if color != '':\n _format.setForeground(getattr(QtCore.Qt, color))\n if 'bold' in style:\n _format.setFontWeight(QtGui.QFont.Bold)\n if 'italic' in style:\n _format.setFontItalic(True)\n return _format",
"def get_replacement():\n run_linter_throw(\"path/to/file\",\n \"{s}\\n{m} Text{e}\",\n style,\n whitelist=[\"headerblock/desc_space\"])",
"def edit_form_entry_help_text_extra(cls):\n return \"\"\"\n <ul class=\"{container_class}\">\n {edit_option_html}\n <li><a href=\"{delete_url}\">\n <span class=\"{delete_option_class}\"></span> {delete_text}</a>\n </li>\n </ul>\n <input type=\"hidden\" value=\"{form_element_position}\"\n name=\"form-{counter}-position\"\n id=\"id_form-{counter}-position\"\n class=\"form-element-position\">\n <input type=\"hidden\" value=\"{form_element_pk}\"\n name=\"form-{counter}-id\" id=\"id_form-{counter}-id\">\n \"\"\".format(\n container_class=cls.form_list_container_class,\n edit_option_html=\"{edit_option_html}\",\n delete_url=\"{delete_url}\",\n delete_option_class=cls.form_delete_form_entry_option_class,\n delete_text=\"{delete_text}\",\n form_element_position=\"{form_element_position}\",\n counter=\"{counter}\",\n form_element_pk=\"{form_element_pk}\",\n )",
"def extension (formatStr):\n assert False, \"TODO:\"",
"def _generateReadOnly(self, obj, **args):\n result = []\n if not args.get('mode', None):\n args['mode'] = self._mode\n args['stringType'] = 'readonly'\n if self._script.utilities.isReadOnlyTextArea(obj):\n result.append(self._script.formatting.getString(**args))\n return result",
"def __format__(self, format_spec):\n # This calls the compiled regex stored on ANSIString's class to analyze the format spec.\n # It returns a dictionary.\n format_data = self.re_format.match(format_spec).groupdict()\n clean = self.clean()\n base_output = ANSIString(self.raw())\n align = format_data.get(\"align\", \"<\")\n fill = format_data.get(\"fill\", \" \")\n\n # Need to coerce width into an integer. We can be certain that it's numeric thanks to regex.\n width = format_data.get(\"width\", None)\n if width is None:\n width = len(clean)\n else:\n width = int(width)\n\n if align == \"<\":\n base_output = self.ljust(width, fill)\n elif align == \">\":\n base_output = self.rjust(width, fill)\n elif align == \"^\":\n base_output = self.center(width, fill)\n elif align == \"=\":\n pass\n\n # Return the raw string with ANSI markup, ready to be displayed.\n return base_output.raw()",
"def is_valid(self):\r\n for lineedit in self.lineedits:\r\n if lineedit in self.validate_data and lineedit.isEnabled():\r\n validator, invalid_msg = self.validate_data[lineedit]\r\n text = to_text_string(lineedit.text())\r\n if not validator(text):\r\n QMessageBox.critical(self, self.get_name(),\r\n \"%s:<br><b>%s</b>\" % (invalid_msg, text),\r\n QMessageBox.Ok)\r\n return False\r\n return True",
"def test_incorrect_format_1(self):\n changelog = changelog_temp.format(\n before_changelog=\"## [Not yet released]\\n\\n### Added\\n\\n- Added a new feature\\n\"\n )\n with pytest.raises(ValueError):\n parse_changelog(changelog)",
"def test_match_entry_to_format(self):\n\n # matches valid entries with valid formats\n for valid_entry in test_case_data.get('valid_entries'):\n entry = [e.strip() for e in valid_entry.split(',')]\n entry_dict = self.parser._match_entry_to_format(entry)\n\n self.assertTrue(entry_dict, f'{entry} is not of a valid format')\n\n # fails with invalid entries\n for invalid_entry in test_case_data.get('invalid_entries'):\n entry = [e.strip() for e in invalid_entry.split(',')]\n entry_dict = self.parser._match_entry_to_format(entry)\n\n self.assertFalse(entry_dict, f'{entry} is not of a valid format')",
"def is_text_editable(path):\n return False",
"def _format_answer(self, text):\n text = str(text).replace('\\n', ' ')\n answer_width = 70\n pretty_text = '\\n\\t'.join(textwrap.wrap(text, answer_width))\n\n return pretty_text",
"def flags(self, f):\n if f.is_inlined:\n return \" (inlined)\"\n return \"\"",
"def text_to_display(level):\n if level == \"html\":\n return html_answers, html_text\n elif level == \"css\":\n return css_answers, css_text\n elif level == \"python\":\n return python_answers, python_text",
"def editorForTyp(typ):\n\n if typ == \"quint32\":\n return (\"QSpinBox\", \"setValue\", \"value\")\n elif typ == \"QString\":\n return (\"QLineEdit\", \"setText\", \"text\")\n elif typ == \"bool\":\n return (\"QCheckBox\", \"setChecked\", \"isChecked\")\n return (None, None, None)",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def show_fields(*fields):\n\n fields = filter( lambda x: x, fields )\n target_len = max( len(name) for name, value in fields ) + 2\n for name, value in fields:\n line = name + ':' + \" \" * (target_len - len(name))\n if type(value) == bool:\n line += color_text(\"Yes\", 'green') if value else color_text(\"No\", 'red')\n else:\n line += str(value)\n print line",
"def testCheckRequiredFormat(self):\n plugin = gdrive_synclog.GoogleDriveSyncLogTextPlugin()\n\n file_system_builder = fake_file_system_builder.FakeFileSystemBuilder()\n file_system_builder.AddFile('/file.txt', (\n b'2018-01-24 18:25:08,454 -0800 INFO pid=2376 7780:MainThread '\n b'logging_config.py:295 OS: Windows/6.1-SP1\\n'))\n\n file_entry = file_system_builder.file_system.GetFileEntryByPath('/file.txt')\n\n parser_mediator = self._CreateParserMediator(None, file_entry=file_entry)\n\n file_object = file_entry.GetFileObject()\n text_reader = text_parser.EncodedTextReader(file_object)\n text_reader.ReadLines()\n\n result = plugin.CheckRequiredFormat(parser_mediator, text_reader)\n self.assertTrue(result)",
"def formatted(self) -> str:\r\n ...",
"def ISTEXT(value):\n return isinstance(value, (basestring, AltText))",
"def text_editor():\n return True",
"def process_output(self, text): # pylint: disable=no-self-use\n changed = False\n return changed, text",
"def validate(self, txt, pos):\n state, rpos = qt.QDoubleValidator.validate(self, txt, pos)\n if txt.length() == 0:\n state = qt.QValidator.Acceptable\n return state, rpos"
] | [
"0.74416876",
"0.7370665",
"0.71592844",
"0.71025413",
"0.71025413",
"0.7028924",
"0.68846506",
"0.6550997",
"0.64535177",
"0.6392951",
"0.63109875",
"0.6300976",
"0.6188802",
"0.6026202",
"0.5835225",
"0.5771935",
"0.5735613",
"0.5613498",
"0.5609731",
"0.56050605",
"0.5547816",
"0.5309345",
"0.5299432",
"0.5209862",
"0.5204991",
"0.5204991",
"0.5204991",
"0.5204991",
"0.5204991",
"0.52003527",
"0.51723677",
"0.51647925",
"0.5160046",
"0.5119939",
"0.51153874",
"0.5094579",
"0.5093168",
"0.50772464",
"0.5077213",
"0.5065839",
"0.5057548",
"0.50492096",
"0.501106",
"0.50011784",
"0.49889597",
"0.49738917",
"0.49718243",
"0.49464372",
"0.49350786",
"0.4930196",
"0.49300286",
"0.492046",
"0.4900359",
"0.4896047",
"0.4889429",
"0.48845533",
"0.4872616",
"0.48598924",
"0.48541707",
"0.4853287",
"0.48496547",
"0.48475158",
"0.48429024",
"0.48423597",
"0.4839126",
"0.48285526",
"0.48253557",
"0.48237336",
"0.48226026",
"0.48198703",
"0.48191673",
"0.48190477",
"0.4813445",
"0.48076433",
"0.4807577",
"0.48015848",
"0.48007897",
"0.47960508",
"0.47933918",
"0.47912502",
"0.47794497",
"0.47762585",
"0.47564918",
"0.47562456",
"0.4751227",
"0.47500658",
"0.47482246",
"0.47376072",
"0.47373587",
"0.47357956",
"0.47351882",
"0.4733689",
"0.4732709",
"0.47288054",
"0.47235525",
"0.47193804",
"0.4715197",
"0.4714657",
"0.4711986",
"0.47118586"
] | 0.70363986 | 5 |
Return tuple of stored text from edited text and bool validity, using edit format option | def storedText(self, editText):
try:
return (repr(GenBoolean(editText)), True)
except GenBooleanError:
if editText in self.formatList:
return (editText, True)
return (editText, not editText and not self.isRequired) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def storedText(self, editText):\n if editText in self.formatList:\n return (editText, True)\n return (editText, not editText and not self.isRequired)",
"def formatEditText(self, storedText):\n return (storedText, True)",
"def formatEditText(self, storedText):\n return (storedText, True)",
"def editText(self, item):\n storedText = item.data.get(self.name, '')\n result = self.formatEditText(storedText)\n if self.isRequired and not result[0]:\n return (result[0], False)\n return result",
"def formatEditText(self, storedText):\n for choice in self.splitText(storedText):\n if choice not in self.formatList:\n return (storedText, not storedText)\n return (storedText, True)",
"def storedText(self, editText):\n if editText:\n return (editText, True)\n return (editText, not self.isRequired)",
"def formatEditText(self, storedText):\n if storedText in self.formatList:\n return (storedText, True)\n return (storedText, not storedText)",
"def formatEditText(self, storedText):\n if storedText in self.formatList:\n return (storedText, True)\n try:\n return (GenBoolean(storedText).boolStr(self.format), True)\n except GenBooleanError:\n return (storedText, not storedText)",
"def storedText(self, editText):\n format = globalref.options.strData('EditDateFormat', True)\n try:\n return (repr(GenDate().setFromStr(editText, format)), True)\n except GenDateError:\n return (editText, not editText and not self.isRequired)",
"def storedText(self, editText):\n try:\n return (repr(GenNumber().setFromStr(editText, self.format)), True)\n except GenNumberError:\n return (editText, not editText and not self.isRequired)",
"def storedText(self, editText):\n choices, valid = self.sortedChoices(editText)\n if valid:\n return (self.editSep.join(choices), True)\n else:\n return (editText, not editText and not self.isRequired)",
"def storedText(self, editText):\n try:\n return (repr(GenTime(editText)), True)\n except GenTimeError:\n return (editText, not editText and not self.isRequired)",
"def formatEditText(self, storedText):\n try:\n return (GenNumber(storedText).numStr(self.format), True)\n except GenNumberError:\n return (storedText, not storedText)",
"def storedText(self, editText):\n return (editText, editText or not self.isRequired)",
"def formatEditText(self, storedText):\n format = globalref.options.strData('EditDateFormat', True)\n try:\n return (GenDate(storedText).dateStr(format), True)\n except GenDateError:\n return (storedText, not storedText)",
"def formatEditText(self, storedText):\n format = globalref.options.strData('EditTimeFormat', True)\n try:\n return (GenTime(storedText).timeStr(format), True)\n except GenTimeError:\n return (storedText, not storedText)",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def edit(self, text):\n return self._edit_engine(text, break_on_success=False)",
"def get_data_from_nonformat_text():\n pass",
"def getEditChoices(self, currentText=''):\n return [(text, '') for text in self.formatList]",
"def syntax_text():",
"def on_edit(self, event, text):\n return None",
"def process_output(self, text): # pylint: disable=no-self-use\n changed = False\n return changed, text",
"def reformat(ctx):\n pass",
"def main(text,result=\"latex\",check_text=True,index_project='',file_name=''): # TODO detect and make a warning for genuine latex marks\n if isinstance(text,str):\n text = text.split('\\n')\n \n if check_text:\n check(text)\n \n print(text)\n \n ### managing placeholders\n text = parsers['v'].main(text)\n \n ### saving names\n if index_project:\n indexer.parse(text,index_project,file_name)\n \n \n for i in range(len(text)):\n line = text[i]\n ### managing end of line\n line = line.replace(\" ,,\",\"\\\\\\\\\")\n \n while line.count(opening_mark):\n first_part, mark, late_part = line.partition(',;')\n if not late_part:\n break\n late_part, text = parsers[late_part[0]].main(late_part = late_part,\n text=text,\n result=result,\n line_nb = i)\n line = first_part + late_part\n text[i] = line\n \n return '\\n'.join(text)",
"def analyze_text(words, format_bolds, format_italics, de_condition={'bold':1, 'italic':-1}, en_condition={'bold':0, 'italic':-1}, end_of_item_eol=False, eoi_bold_to_unbold=False, eoi_unbold_to_bold=True, eoi_italic_to_unitalic=False, eoi_unitalic_to_italic=False):\n table = []\n de_words = ['']\n en_words = ['']\n if de_condition['bold'] != -1: de_condition['bold'] = not(not(de_condition['bold'])) # convert integer to boolean\n if de_condition['italic'] != -1: de_condition['italic'] = not(not(de_condition['italic']))\n \n last_format_bold = False\n last_format_italic = False\n de_bold_ok = False\n de_italic_ok = False\n en_bold_ok = False\n en_italic_ok = False\n item_no = 0\n for k in range(len(words)):\n if format_bolds[k] == False:\n new_format_bold = False\n elif format_bolds[k] == True:\n new_format_bold = True\n if format_italics[k] == False:\n new_format_italic = False\n elif format_italics[k] == True:\n new_format_italic = True\n\n # Check condition for switching to the new item\n flag_new = True\n if item_no>0 and end_of_item_eol and words[k]!='\\n': flag_new = False\n if item_no>0 and eoi_bold_to_unbold and not(last_format_bold and not new_format_bold): flag_new = False\n if item_no>0 and eoi_unbold_to_bold and not(not last_format_bold and new_format_bold): flag_new = False\n if item_no>0 and eoi_italic_to_unitalic and not(last_format_italic and not new_format_italic): flag_new = False\n if item_no>0 and eoi_unitalic_to_italic and not(not last_format_italic and new_format_italic): flag_new = False\n last_format_bold = new_format_bold\n last_format_italic = new_format_italic\n if flag_new:\n de_words.append('')\n en_words.append('')\n item_no += 1\n \n if words[k]!='\\n': # also format_bolds[k] and format_italics[k] must be either True or False\n if de_condition['bold'] != -1:\n de_bold_ok = not de_condition['bold']^format_bolds[k] # use XOR operator\n else: de_bold_ok = True\n if de_condition['italic'] != -1:\n de_italic_ok = not de_condition['italic']^format_bolds[k]\n else: de_italic_ok = True\n if de_bold_ok and de_italic_ok: de_words[item_no] += words[k]\n \n if en_condition['bold'] != -1:\n en_bold_ok = not en_condition['bold']^format_bolds[k]\n else: en_bold_ok = True\n if en_condition['italic'] != -1:\n en_italic_ok = not en_condition['italic']^format_bolds[k]\n else: en_italic_ok = True\n if en_bold_ok and en_italic_ok: en_words[item_no] += words[k]\n else:\n # Check if this end-of-line should be converted to a space, to connect lines\n if de_words[item_no] != '' and de_bold_ok and de_italic_ok: de_words[item_no] += ' '\n if en_words[item_no] != '' and en_bold_ok and en_italic_ok: en_words[item_no] += ' ' \n \n return de_words, en_words",
"def get_edit_text(self):\n # grab edit page\n response = self._get_page('edit.php')\n html = response.text\n # parse out existing plan\n soup = bs4.BeautifulSoup(html, 'html5lib')\n plan = soup.find('textarea')\n if plan is None:\n raise PlansError(\"Couldn't get edit text, are we logged in?\")\n else:\n plan = u'' + plan.contents[0]\n # prepending the empty string somehow prevents BS from\n # escaping all the HTML characters (weird)\n assert type(plan) == str\n # convert to CRLF line endings\n plan = convert_endings(plan, 'CRLF')\n # parse out plan md5\n md5sum = soup.find('input',\n attrs={'name': 'edit_text_md5'}).attrs['value']\n # also, explicitly compute the hash, for kicks\n assert md5sum == plans_md5(plan)\n # verify that username has not changed\n assert self.username == self.parser.username\n return plan, md5sum",
"def formatOutput(self, storedText, titleMode, internal=False):\n if storedText not in self.formatList:\n try:\n storedText = GenBoolean(storedText).boolStr(self.format)\n except GenBooleanError:\n storedText = _errorStr\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def normalize_text_for_edit(user, text, rich_text, escape_html=True):\n if text is None:\n return ''\n\n if not rich_text and is_rich_text_default_for_user(user):\n # This isn't rich text, but it's going to be edited as rich text,\n # so escape it.\n text = djblets_markdown.markdown_escape(text)\n\n if escape_html:\n text = escape(text)\n\n return text",
"def parse_edits(line):\n \n # Get edits inside brackets allowing parentheses\n edit_strings = re.findall(r'\\((.*?)\\)[,\\]]', line)\n \n edits = []\n for edit_string in edit_strings:\n # Splitting by comma is not enough. Some of the edits actually fix spacing\n # when commas are used, so we may can't use edit_string.split(', ')\n # For some reason, the unicode gold strings are enclosed in a list\n m = re.match(r'^(\\d+), (\\d+), (.*), \\[?(.*)\\]?$', edit_string)\n edit_items = [m.group(i) for i in range(1, 5)]\n \n # No way to handle this in regex\n if edit_items[3].endswith(']'):\n edit_items[3] = edit_items[3][:-1]\n \n # Cast the indices\n edit_items[0] = int(edit_items[0])\n edit_items[1] = int(edit_items[1])\n \n # Convert unicode-string-inside-string into actual unicode string\n edit_items[2] = codecs.decode(edit_items[2][2:-1], 'unicode_escape') or 'NIL'\n edit_items[3] = codecs.decode(edit_items[3][2:-1], 'unicode_escape') or 'NIL'\n \n edits.append(edit_items)\n \n return edits",
"def _do_checkbox_setting(cls, text: str, title: str, replace_args: tuple) -> typing.Tuple[str, bool, bool]:\n title = title.strip()\n\n lines = []\n found = False\n modified = False\n for line, is_checkbox in cls._iterate_lines(text):\n if is_checkbox and title == cls._get_checkbox_title(line):\n found = True\n lines.append(line.replace(*replace_args))\n if line != lines[-1]:\n modified |= True\n\n continue\n\n lines.append(line)\n\n return \"\\n\".join(lines), found, modified",
"def formatOutput(self, storedText, titleMode, internal=False):\n if storedText not in self.formatList:\n storedText = _errorStr\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def get_edits(text):\n edit_p = re.compile(\"(?P<open><edit.*?>)(?P<inner>.*?)(?P<close></edit>)\")\n corr_p = re.compile(\"<corrections>.*?</corrections>\")\n edits = []\n\n offset = 0\n\n for m in re.finditer(edit_p, text):\n # Make an edit object\n edit_text = \"\".join(m.groups())\n edit = ET.XML(m.group(0))\n\n # Set the bounds of the original text and adjust offset\n inner_string = m.group('inner') \n start = m.start() - offset\n corr_m = re.search(corr_p, inner_string)\n \n if corr_m: # Replacement/insertion have a correction\n offset += len(corr_m.group(0)) \n \n if not inner_string.startswith(\"<empty/>\"):\n end = start + corr_m.start()\n else:\n offset += len(\"<empty/>\") # It is \"\" in plain text\n end = start\n else:\n # Deletions may not have a correction\n if not inner_string.startswith(\"<empty/>\"):\n end = start + len(inner_string)\n else: # Unspecified error <empty/> is \"\" in plain text\n end = start\n offset += len(inner_string)\n\n\n edit.set(\"start\", \"%d\" % start) \n edit.set(\"end\", \"%d\" % end)\n\n offset += len(m.group('open')) + len(m.group('close'))\n \n\n # Make the original text a subelement of <edit>\n # Original text may be a string or <empty/> element.\n original = ET.SubElement(edit, \"original\")\n \n if edit.text:\n original.text = edit.text\n edit.text = \"\"\n else:\n empty = edit.find('empty')\n \n try:\n edit.remove(empty)\n original.append(empty)\n except Exception as e:\n pass\n \n edits.append(edit)\n\n return edits",
"def refang(self, text: str):",
"def edit_text(self, _, val):\n t_edit = text_editor.TextEditor(val, \"value\")\n t_edit.execute = self.execute",
"def handle_data(self, text):\n if self.bankacctfrom:\n if self.bankid:\n self.compte['banque'] = text.strip()\n self.bankid = False\n if self.branchid:\n self.compte['guichet'] = text.strip()\n self.branchid = False\n if self.acctid:\n self.compte['compte'] = text.strip()\n self.acctid = False\n if self.banktranlist:\n if self.stmttrn:\n if self.dtposted:\n self.ecriture_tmp['date'] = datetime.strptime(text.strip(), \"%Y%m%d\")\n self.dtposted = False\n if self.trnamt:\n self.ecriture_tmp['montant'] = locale.atof(text.strip())\n self.trnamt = False\n if self.trntype:\n self.ecriture_tmp['type'] = text.strip()\n self.trntype = False\n if self.name:\n self.ecriture_tmp['name'] = text.strip()\n self.name = False\n if self.memo:\n self.ecriture_tmp['memo'] = text.strip()\n self.memo = False",
"def get_mark(text, short):\n\n line = text.readline()\n\n # check that the line begins with a valid entry type\n if not short and not re.match(r'^\\s*(text|mark) = \"', line):\n raise ValueError('Bad entry: ' + line)\n\n # read until the number of double-quotes is even\n while line.count('\"') % 2:\n next_line = text.readline()\n\n if not next_line:\n raise EOFError('Bad entry: ' + line[:20] + '...')\n\n line += next_line\n if short:\n pattern = r'^\"(.*?)\"\\s*$'\n else:\n pattern = r'^\\s*(text|mark) = \"(.*?)\"\\s*$'\n entry = re.match(pattern, line, re.DOTALL)\n\n return entry.groups()[-1].replace('\"\"', '\"')",
"def formatOutput(self, storedText, titleMode, internal=False):\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def getText(self):",
"def get_text(text_input):\r\n return text_input",
"def format_text(text: TTextType) -> typing.Iterator[TViewLine]:\n for line in text.splitlines():\n yield [(\"text\", line)]",
"def rich(text):\n return full(text, False)",
"def text(value):\n return True",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def formatter(text):\n repl_map = {\n \"degC\": \"$^o$C\",\n \"K\": \"$^o$C\",\n \"month-1\": \"month$^{{-1}}$\",\n \"day-1\": \"day$^{{-1}}$\",\n \"d-1\": \"day$^{{-1}}$\",\n \"decade-1\": \"decade$^{{-1}}$\",\n \"year-1\": \"year$^{{-1}}$\",\n \"rcp85\": \"RCP8.5\",\n \"rcp45\": \"RCP4.5\",\n \"rcp26\": \"RCP2.6\",\n \"RCP85\": \"RCP8.5\",\n \"RCP45\": \"RCP4.5\",\n \"RCP26\": \"RCP2.6\",\n \"cmip5-85\": \"RCP8.5\",\n \"cmip5-60\": \"RCP6.0\",\n \"cmip5-45\": \"RCP4.5\",\n \"cmip5-26\": \"RCP2.6\",\n \"ssp585\": \"SSP5-8.5\",\n \"ssp245\": \"SSP2-4.5\",\n \"ssp126\": \"SSP1-2.6\",\n \"SSP585\": \"SSP5-8.5\",\n \"SSP245\": \"SSP2-4.5\",\n \"SSP126\": \"SSP1-2.6\",\n \"cmip6-85\": \"SSP5-8.5\",\n \"cmip6-70\": \"SSP3-7.0\",\n \"cmip6-60\": \"SSP4-6.0\",\n \"cmip6-34\": \"SSP4-3.4\",\n \"cmip6-45\": \"SSP2-4.5\",\n \"cmip6-26\": \"SSP1-2.6\",\n \"cmip6-19\": \"SSP1-1.9\",\n \"1\": \"%\",\n \"era5\": \"ERA5\",\n \"gpcc025x025_v8\": \"GPCC\",\n \"cru\": \"CRU\",\n \"jra55\": \"JRA55\",\n \"HIGHRESMIP\": \"HighResMIP\",\n \" \": \"\",\n }\n for key, val in repl_map.items():\n if key in text:\n text = text.replace(key, val)\n break\n return text",
"def formatOutput(self, storedText, titleMode, internal=False):\n choices, valid = self.sortedChoices(storedText)\n if valid:\n result = self.sep.join(choices)\n else:\n result = _errorStr\n return TextFormat.formatOutput(self, result, titleMode, internal)",
"def value_textvalidation(objectidentifier,validationtext):\r\n msg, status = \"\", True\r\n\r\n try:\r\n 'Here we will pass objectidentifier for required element'\r\n text_heading = ui_controls.text_view(get_obj_identifier(objectidentifier),value=True)\r\n print \"Current text returned by UI is==>\"+str(text_heading)\r\n\r\n 'To check if it is returning empty value here'\r\n if not text_heading:\r\n print str(validationtext)+\" text does not exist and it is returning empty value.\"\r\n return False, msg\r\n\r\n 'Comparing text retrieved from UI with validation text'\r\n if validationtext.strip() == text_heading.strip():\r\n print (str(validationtext)+\" text has been found!!!\")\r\n else:\r\n print(\"Sorry!!!text has been mismatched,it should be \"+str(validationtext))\r\n print (\"Text shown at UI is==>\"+str(text_heading))\r\n return False, msg \r\n\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg",
"def edit():",
"def get_text_editor_input(initial_msg):\n EDITOR = os.environ.get('EDITOR', 'vi')\n CROP_MARK = ('\\n\\nAnything above this line will be ignored:\\n' +\n ('-' * 34) + '>8' + ('-' * 34) + '\\n')\n\n wrapper = TextWrapper(replace_whitespace=False, drop_whitespace=False)\n initial_msg = '\\n'.join(wrapper.wrap(initial_msg))\n initial_msg += CROP_MARK\n\n with tempfile.NamedTemporaryFile(suffix='.md') as temp:\n temp.write(initial_msg.encode('utf-8'))\n temp.flush() # Write buffer to the file\n subprocess.call([EDITOR, temp.name])\n\n # The pointer was already after the initial message, but we return to\n # the beginning just in case the user added content before the mark\n temp.seek(0)\n return temp.read().decode('utf-8').split(CROP_MARK, 1)[1].strip()",
"def text_example():\n \n text_store = \"01000001011000010010000001000010011000100000110100001010001100010011001000110011\"\n text.delete('1.0', tk.END) \n text.insert(tk.END, text_store) \n box=tk.Tk()\n m = tk.Message(box, text=\"You should be able to save this file and open it in a text editor like Notepad or Nano to read it. If you edit the values you may find it does not display properly as text. Unchanged, it should be interpreted by a text editor as:\\n\\nAa Bb\\n123\\n\\nAs the file was made on a Windows machines you may find other systems display the line breaks differently.\")\n m.config(padx=50, pady=50, width=350)\n m.pack()",
"def is_text_editable(path):\n return False",
"def show_line_edit_dialog(text):\n dialog = QDialog()\n interface = lineEditEntryGenerated.Ui_Dialog()\n interface.setupUi(dialog)\n interface.label.setText(text)\n if dialog.exec_() == 1:\n return True, str(interface.lineEdit.text())\n else:\n return False, \"\"",
"def on_text(self, instance, value):\n if not EVENTS['IS_OBJ']:\n EVENTS['EDITOR_SAVED'] = False\n\n if value:\n self.valid_text = True\n EVENTS['IS_RAM_EMPTY'] = False\n else:\n self.valid_text = False",
"def complete_opt_format(self, text, *_):\n return [t + \" \" for t in FORMATTERS if t.startswith(text)]",
"def edit_once(self, text):\n return self._edit_engine(text, break_on_success=True)",
"def format_text(text):\n text = text.replace('to do ', '') \\\n .replace('to ', '') \\\n .replace(' at ', ' on ') \\\n .replace(' a ', ' 1 ') \\\n .replace(' an ', ' 1 ') \\\n .replace('minutes', '60') \\\n .replace('minute', '60') \\\n .replace('seconds', '1') \\\n .replace('second', '1') \\\n .replace('hours', '3600') \\\n .replace('hour', '3600')\n text = text.split(' ')\n pure_text = \"\"\n if text[-3] == 'in':\n for i in range(0, (len(text)-3)):\n pure_text += \" \" + text[i]\n final_text = [pure_text, text[-3], text[-2], text[-1]]\n else:\n for i in range(0, (len(text)-2)):\n pure_text += text[i]\n final_text = [pure_text, text[-2], text[-1]]\n if len(text) < 3:\n pprint(final_text)\n raise Exception(\"Bad remind request\")\n\n return final_text",
"def edit_google_vision_text(self,text):\n s1=text\n try:\n log_info(\"Correcting google vision text to remove extra spacing\",MODULE_CONTEXT)\n i=0\n while(i<len(text)):\n s1=text\n if text[i] in [\"/\",\"।\",'।' ,':','|',\",\" ,'०',\"]\",\"-\",\")\",\"}\"] and text[i-1]==\" \": \n text=text[:i-1]+text[i:]\n if i > 0 :\n if text[i-1] in [\"-\",\"[\",\"{\",\"/\",\"(\"] and text[i]==\" \":\n text=text[:i]+text[i+1:]\n elif text[i] in [\"-\",\"[\",\"{\",\"/\",\"(\"] and text[i+1]==\" \":\n text=text[:i+1]+text[i+2:]\n i=i+1\n except Exception as e:\n log_exception(\"Exception while correcting google vision text\", MODULE_CONTEXT, e)\n return s1\n return text",
"def process_text(self, text, language):",
"def make_input(value):\n what = value[0]\n if what.startswith('not editable'):\n what = what.replace('not editable:', '').replace(\"'\", \"\\'\")\n if what.startswith('attribute:value:'):\n what = what.replace('attribute:value:', '').replace(\"'\", \"\\'\")\n return what",
"def get_row_input_text(self, row_idx):\n return self.row_items[row_idx][1].get()",
"def updateText(widget,text,format=''):\n # autorecognition\n if format not in ['plain','html','rest']:\n if type(text) is str and text.startswith('..'):\n format = 'rest'\n\n # conversion\n if format == 'rest' and pf.options.rst2html:\n html = utils.rst2html(text)\n if html[:10] == text[:10]:\n #print \"CONVERSION TO HTML FAILED\"\n text += \"\\n\\nNote: This reStructuredText is displayed as plain text because it could not be converted to html. If you install python-docutils, you will see this text (and other pyFormex messages) in a much nicer layout!\\n\"\n else:\n text = html\n\n # We leave the format undefined, because we are not sure\n # that the conversion function (docutils) is available\n # and always produces good results\n format = ''\n\n if format == 'plain':\n widget.setPlainText(text)\n elif format == 'html':\n widget.setHtml(text)\n else:\n # As a last rescue, try QT4's autorecognition\n widget.setText(text)",
"def modified_flag(self, event):\n text = self.get_current()\n text.modified = 1",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def get_text_from_editor():\n with tempfile.NamedTemporaryFile(suffix='.tmp', mode='w+t') as f:\n # Create a temporary file with instructions on describing bug\n f.write(message + '\\n\\n')\n f.flush()\n # Open the editor and allow the user to type\n editor = os.environ.get('EDITOR', 'vim')\n subprocess.call([editor, f.name])\n # Read and clean the file\n f.seek(0)\n text = ''.join([line.lstrip() for line in f.readlines()\n if line and not line.lstrip().startswith('#')])\n return '\\n'.join(textwrap.wrap(text, width=100))",
"def storeTextEditValue(self):\n\n\t\tcategory, attr = self.getWidgetMeta(self.sender())\n\t\tvalue = self.sender().toPlainText()\n\t\tself.storeValue(category, attr, value)",
"def _editorText(self):\n if self.__lineEditKind:\n return self._editor.text()\n else:\n return self._editor.currentText()",
"def _hidden_in_unicode(self, txt):",
"def fix_document(key, value, _format, _meta):\n if key == \"Link\":\n url = value[2][0]\n if url.startswith(\"user-manual\") or url.startswith(\"developers-guide\"):\n # Return the link text\n return value[1]\n # Reformat the text inside block quotes\n elif key == \"BlockQuote\":\n try:\n first_string = value[0][\"c\"][0][\"c\"]\n if first_string == \"[!NOTE]\":\n value[0][\"c\"][0] = Strong([Str(\"Note:\")])\n return BlockQuote(value)\n elif first_string == \"[!INFO]\":\n value[0][\"c\"][0] = Strong([Str(\"Info:\")])\n return BlockQuote(value)\n elif first_string == \"[!TIP]\":\n value[0][\"c\"][0] = Strong([Str(\"Tip:\")])\n return BlockQuote(value)\n elif first_string == \"[!WARNING]\":\n value[0][\"c\"][0] = Strong([Str(\"Warning:\")])\n return BlockQuote(value)\n elif first_string == \"[!ATTENTION]\":\n value[0][\"c\"][0] = Strong([Str(\"Attention:\")])\n return BlockQuote(value)\n except Exception:\n return\n return",
"def getEditChoices(self, currentText=''):\n format = globalref.options.strData('EditTimeFormat', True)\n now = GenTime().timeStr(format)\n choices = [(now, '(%s)' % _('now'))]\n for hr in (6, 9, 12, 15, 18, 21, 0):\n time = GenTime((hr, 0)).timeStr(format)\n choices.append((time, ''))\n return choices",
"def edit_type(self, candidate, word):\n edit = [False] * 4\n correct = \"\"\n error = \"\"\n replaced = ''\n replacer = ''\n for i in range(min([len(word), len(candidate)]) - 1):\n if candidate[0:i + 1] != word[0:i + 1]: # inconsistency in the first (i + 1) characters of the two strings\n if candidate[i:] == word[i - 1:]:\n edit[1] = True # deletion\n correct = candidate[i - 1] # candidate[i - 1] is deleted and we get word\n error = ''\n replaced = candidate[i - 2]\n replacer = candidate[i - 2] + candidate[i - 1]\n break\n elif candidate[i:] == word[i + 1:]:\n edit[0] = True # insertion\n correct = ''\n error = word[i] # word[i] is redundant\n if i == 0:\n replacer = '@'\n replaced = '@' + error\n else:\n replacer = word[i - 1]\n replaced = word[i - 1] + error\n break\n if candidate[i + 1:] == word[i + 1:]:\n edit[2] = True # substitution\n correct = candidate[i]\n error = word[i]\n replaced = error\n replacer = correct\n break\n if candidate[i] == word[i + 1] and candidate[i + 2:] == word[i + 2:]:\n edit[3] = True # transposition\n correct = candidate[i] + candidate[i + 1]\n error = word[i] + word[i + 1]\n replaced = error\n replacer = correct\n break\n\n # string inversion\n candidate = candidate[::-1]\n word = word[::-1]\n\n for i in range(min([len(word), len(candidate)]) - 1):\n if candidate[0:i + 1] != word[0:i + 1]:\n if candidate[i:] == word[i - 1:]:\n edit[1] = True\n correct = candidate[i - 1]\n error = ''\n replaced = candidate[i - 2]\n replacer = candidate[i - 2] + candidate[i - 1]\n break\n elif candidate[i:] == word[i + 1:]:\n correct = ''\n error = word[i]\n if i == 0:\n replacer = '@'\n replaced = '@' + error\n else:\n replacer = word[i - 1]\n replaced = word[i - 1] + error\n edit[0] = True\n break\n if candidate[i + 1:] == word[i + 1:]:\n edit[2] = True\n correct = candidate[i]\n error = word[i]\n replaced = error\n replacer = correct\n break\n if candidate[i] == word[i + 1] and candidate[i + 2:] == word[i + 2:]:\n edit[3] = True\n correct = candidate[i] + candidate[i + 1]\n error = word[i] + word[i + 1]\n replaced = error\n replacer = correct\n break\n\n if word == candidate:\n return \"None\", '', '', '', ''\n if edit[0]:\n return EDIT_TYPE_INSERTION, correct, error, replaced, replacer\n elif edit[1]:\n return EDIT_TYPE_DELETION, correct, error, replaced, replacer\n elif edit[2]:\n return EDIT_TYPE_SUBSTITUTION, correct, error, replaced, replacer\n elif edit[3]:\n return EDIT_TYPE_TRANSPOSITION, correct, error, replaced, replacer",
"def getEditChoices(self, currentText=''):\n currentChoices, valid = self.sortedChoices(currentText)\n nonChoices = [text for text in self.formatList\n if text not in currentChoices]\n results = []\n for choice in nonChoices: # menu entries to add a choice\n allChoices = currentChoices + [choice]\n allChoices = [text for text in self.formatList\n if text in allChoices]\n results.append((self.editSep.join(allChoices),\n '(%s %s)' % (_('add'), choice)))\n if currentChoices:\n results.append((None, None)) # separator\n for choice in currentChoices: # menu entries to remove a choice\n allChoices = currentChoices[:]\n allChoices.remove(choice)\n allChoices = [text for text in self.formatList\n if text in allChoices]\n results.append((self.editSep.join(allChoices),\n '(%s %s)' % (_('remove'), choice)))\n return results",
"def text_editor():\n return True",
"def task_format_check():\n return {\"actions\": [[\"black\", HERE, \"--check\"]], \"verbosity\": 1}",
"def getEditChoices(self, currentText=''):\n format = globalref.options.strData('EditDateFormat', True)\n today = GenDate().dateStr(format)\n yesterday = (GenDate() - 1).dateStr(format)\n tomorrow = (GenDate() + 1).dateStr(format)\n return [(today, '(%s)' % _('today')),\n (yesterday, '(%s)' % _('yesterday')),\n (tomorrow, '(%s)' % _('tomorrow'))]",
"def test_parseUnformattedText(self):\n self.assertEqual(irc.parseFormattedText(\"hello\"), A.normal[\"hello\"])",
"def stepText2Changed(build, step, text2):",
"def retrieve_input():\r\n inputValue = simpleText.get(\"1.0\",\"end-1c\") #Our Variable\r\n #\"1.0\" = start from first character in the text widget\r\n #\"end-1c = delete the last character that Text creates every time\"\r\n return inputValue",
"def on_idEdit_textChanged(self, txt):\n self.__generateDefaultCommitMessage()\n self.__updateOK()",
"def test_incorrect_formats(self, text):\n with pytest.raises(ValueError):\n parse_changelog(text)",
"def element_textvalidation(objectidentifier,validationtext):\r\n msg, status = \"\", True\r\n\r\n try:\r\n 'Here we will pass objectidentifier for required element'\r\n text_heading = ui_controls.text_view(get_obj_identifier(objectidentifier))\r\n print \"Current text returned by UI is==>\"+str(text_heading)\r\n\r\n 'To check if it is returning empty value here'\r\n if not text_heading:\r\n print str(validationtext)+\" text does not exist and it is returning empty value.\"\r\n return False, msg\r\n\r\n 'Comparing text retrieved from UI with validation text'\r\n if validationtext.strip() == text_heading.strip():\r\n print (str(validationtext)+\" text has been found!!!\")\r\n else:\r\n print(\"Sorry!!!text has been mismatched,it should be \"+str(validationtext))\r\n print (\"Text shown at UI is==>\"+str(text_heading))\r\n return False, msg \r\n\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg",
"def reformat():\n toolkit.reformat()",
"def process_raw_text(self, file_name, column_side):\n self.mvc_check()\n\n model_txt = None\n if column_side == LEFT_TEXT:\n model_txt = self.model.txt1\n elif column_side == RIGHT_TEXT:\n model_txt = self.model.txt2\n\n model_txt.open_raw(file_name)\n model_txt.process_raw()\n self.opened_txt[column_side] = True\n self.can_align = self.opened_txt[LEFT_TEXT] and self.opened_txt[RIGHT_TEXT]\n\n # Goldsmith\n model_txt.make_trie(column_side)\n model_txt.apply_goldsmith(1.1, 20, column_side)\n\n # Associate word for alignment if both text were opened\n if self.can_align:\n for view in self.views:\n view.end_task()\n view.change_task(\"Associating words\")\n self.model.associate_words(1.5)\n for view in self.views:\n view.end_task()\n\n # TODO : coherent saving to database using model.save_data\n\n return model_txt.str",
"def handleFormatText(paragraphContent):\n # We tokenize and remove the stop word\n words = tokenizeWord(paragraphContent) \n \n stemWords = []\n # We loop on each word.\n for word in words:\n stemWord = STEMMER.stem(word)\n \n # Selection on a part of string.\n stemWord = re.sub(\"[*\\'\\.+:,\\`:/]\", '', stemWord)\n if stemWord.isdigit() or len(stemWord) < 2:\n continue\n \n stemWords.append(stemWord)\n my_r_string = stemWords.pop(0)\n for word in stemWords:\n my_r_string += \" \"+str(word)\n return my_r_string",
"def formatOutput(self, storedText, titleMode, internal=False):\n try:\n text = GenNumber(storedText).numStr(self.format)\n except GenNumberError:\n text = _errorStr\n return TextFormat.formatOutput(self, text, titleMode, internal)",
"def get_text(self):\n\n if self.text: return self.text\n # retrieve from args and return if exists\n text = Settings.get_text() or None\n if text: \n self.text = text\n return text\n # prompt skip\n if not Settings.prompt(\"text\"): return None\n question = {\n 'type': 'input',\n 'name': 'text',\n 'message': 'Text:'\n }\n text = prompt(question)[\"text\"]\n # confirm text\n if not Settings.confirm(text): return self.get_text()\n self.text = text\n return self.text",
"def read_plain_txt(input_fn: str) -> Tuple[List[str], List[str]]:\n\n with open(input_fn, 'r') as f:\n migrations = []\n queries = []\n mode = 'none'\n for line in f:\n stripped = line.strip()\n if len(stripped) == 0:\n continue\n if stripped.lower() == '== migrations':\n if mode != 'none':\n raise ValueError(f'Invalid {input_fn}: The migrations section should appear first.')\n mode = 'migrations'\n elif stripped.lower() == '== queries':\n if mode != 'migrations':\n raise ValueError(f'Invalid {input_fn}: The queries section should appear after the migrations section.')\n mode = 'queries'\n elif stripped[0] == '#':\n pass\n else:\n if mode == 'migrations':\n migrations.append(stripped)\n elif mode == 'queries':\n queries.append(stripped)\n else:\n pass\n return migrations, queries",
"def on_lineEdit_textChanged(self, p0):\n # str_me = \"我爱我的祖国\"\n # self.lineEdit.setText(str_me) # 设置单行文本内容\n input_text = self.lineEdit.text()\n self.textEdit.setPlainText(input_text)\n # self.textEdit.setHtml(input_text) # 显示Html，如 <font color='red' size='20'>HELLO!</font>\n a = self.textEdit.toPlainText()\n print(a)",
"def post_process_text(self, text):\n\t\treturn text",
"def text(self) -> str:",
"def editText(self, text, jumpIndex=None, highlight=None):\n try:\n import gui\n except ImportError, e:\n print 'Could not load GUI modules: %s' % e\n return text\n editor = gui.EditBoxWindow()\n return editor.edit(text, jumpIndex=jumpIndex, highlight=highlight)",
"def alter_text_format(self):\n service = self.slides_service\n requests = [\n {\n 'updateParagraphStyle': {\n 'objectId': self.song_numbers_box_id,\n 'style': {\n 'alignment': 'CENTER'\n },\n 'fields': 'alignment'\n }\n },\n {\n 'updateTextStyle': {\n 'objectId': self.song_numbers_box_id,\n 'style': {\n 'bold': self.bold,\n 'fontFamily': 'Arial',\n 'fontSize': {\n 'magnitude': self.TITLE_FONT_SIZE, # numbers slightly larger than lyrics\n 'unit': 'PT'\n },\n 'foregroundColor': {\n 'opaqueColor': {\n 'rgbColor': {\n 'blue': 1.0,\n 'green': 1.0,\n 'red': 1.0\n }\n }\n }\n },\n 'fields': 'bold,foregroundColor,fontFamily,fontSize'\n }\n },\n {\n 'updateTextStyle': {\n 'objectId': self.left_box_id,\n 'style': {\n 'bold': self.bold,\n 'fontFamily': 'Arial',\n 'fontSize': {\n 'magnitude': self.FONT_SIZE,\n 'unit': 'PT'\n },\n 'foregroundColor': {\n 'opaqueColor': {\n 'rgbColor': {\n 'blue': 1.0,\n 'green': 1.0,\n 'red': 1.0\n }\n }\n }\n },\n 'fields': 'bold,foregroundColor,fontFamily,fontSize'\n }\n },\n {\n 'updateTextStyle': {\n 'objectId': self.right_box_id,\n 'style': {\n 'bold': self.bold,\n 'fontFamily': 'Arial',\n 'fontSize': {\n 'magnitude': self.FONT_SIZE,\n 'unit': 'PT'\n },\n 'foregroundColor': {\n 'opaqueColor': {\n 'rgbColor': {\n 'blue': 1.0,\n 'green': 1.0,\n 'red': 1.0\n }\n }\n }\n },\n 'fields': 'bold,foregroundColor,fontFamily,fontSize'\n }\n }\n ]\n body = {\n 'requests': requests\n }\n response = service.presentations().batchUpdate(presentationId=self.presentation_id, body=body).execute()\n print(f'Updated the text style for shape with ID: {self.left_box_id}')\n return response",
"def T(value):\n return (value if isinstance(value, basestring) else\n str(value) if isinstance(value, AltText) else \"\")",
"def as_tuple(self, selected: bool) -> tuple:\n if self.check_ans:\n current = self.num.ljust(2) + self.answer\n else:\n current = self.num.ljust(2)+self.current.rjust(1)\n return ((\n \"fg:\"+self.style_fg + \" bg:\" # apply foreground color\n + (self.style_bg_selected if selected else self.style_bg),\n current\n if self.answer != \".\" else \"▐\" + \"█\" + \"▌\"), ('bg:#fefefe fg:#000', \"│\"))",
"def edit(self,edits):\n\t\tself.alphanumeric=edits['alphanumeric'] if 'alphanumeric' in edits else None\n\t\tself.alphanumeric_color = edits['alphanumeric_color'] if 'alphanumeric_color' in edits else None\n\t\tif self.alphanumeric_color ==\"grey\":\n\t\t\tself.alphanumeric_color = \"gray\"\n\t\tself.background_color = edits['background_color'] if 'background_color' in edits else None\n\t\tif self.background_color == \"grey\":\n\t\t\tself.background_color = \"gray\";\n\t\tshapeChoices = dict((x,y) for x,y in Target.SHAPE_CHOICES)\n\t\tself.shape = str(shapeChoices[edits['shape']]) if 'shape' in edits else None\n\t\tself.orientation = edits['orientation'] if 'orientation' in edits else None\n\t\tself.ptype = edits['ptype']\n\t\tself.description = edits['description'] if 'description' in edits else None\n\t\tself.save()",
"def label_textvalidation(objectidentifier,validationtext):\r\n msg, status = \"\", True\r\n\r\n try:\r\n 'Here we will pass objectidentifier for required element'\r\n text_heading = ui_controls.text_view(get_obj_identifier(objectidentifier),label=True)\r\n print \"Current text returned by UI is==>\"+str(text_heading)\r\n\r\n 'To check if it is returning empty value here'\r\n if not text_heading:\r\n print str(validationtext)+\" text does not exist and it is returning empty value.\"\r\n return False, msg\r\n\r\n 'Comparing text retrieved from UI with validation text'\r\n if validationtext.strip() == text_heading.strip():\r\n print (str(validationtext)+\" text has been found!!!\")\r\n else:\r\n print(\"Sorry!!!text has been mismatched,it should be \"+str(validationtext))\r\n print (\"Text shown at UI is==>\"+str(text_heading))\r\n return False, msg \r\n\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n return status, msg",
"def displayText():\n global entryWidget,entryWidget1,entryWidget2,entryWidget3,entryWidget4 ,entryWidget5,entryWidget6\n global thefilename,itrial,do_stim, delaylen,ntest_arms,stop_if_error,timeout_arm_sec\n thefilename=entryWidget.get().strip()\n itrial=entryWidget1.get().strip()\n do_stim=entryWidget2.get().strip()\n delaylen=entryWidget3.get().strip()\n ntest_arms=entryWidget4.get().strip()\n stop_if_error=int(entryWidget5.get().strip())==1 # convert to logical\n print 'stop_if_error is ', stop_if_error\n\n\n timeout_arm_sec=entryWidget6.get().strip()\n root.destroy()\n return thefilename,itrial,do_stim,delaylen,ntest_arms,stop_if_error,timeout_arm_sec"
] | [
"0.78716373",
"0.75691116",
"0.75691116",
"0.7379154",
"0.73117137",
"0.7183602",
"0.7152062",
"0.7089976",
"0.6903923",
"0.6863199",
"0.68065554",
"0.6748621",
"0.6604557",
"0.62711895",
"0.61224514",
"0.6009547",
"0.5690611",
"0.5690611",
"0.5690611",
"0.5690611",
"0.5690611",
"0.5534457",
"0.5529326",
"0.55119324",
"0.54897064",
"0.54593766",
"0.53941077",
"0.53884834",
"0.53541094",
"0.5348279",
"0.5336523",
"0.53298044",
"0.53044033",
"0.53017735",
"0.5284678",
"0.52548796",
"0.5231703",
"0.52075195",
"0.51657903",
"0.5139631",
"0.51269805",
"0.51183087",
"0.50954133",
"0.5086037",
"0.50556576",
"0.50475675",
"0.50413114",
"0.5033974",
"0.50320536",
"0.50238174",
"0.50172436",
"0.501209",
"0.5011348",
"0.50095177",
"0.499828",
"0.49958882",
"0.49862808",
"0.49802482",
"0.49685866",
"0.49656975",
"0.49588487",
"0.4951691",
"0.49488887",
"0.49448055",
"0.49138415",
"0.49082175",
"0.48921612",
"0.48836753",
"0.48688877",
"0.48642147",
"0.48558703",
"0.48427588",
"0.48402458",
"0.48379573",
"0.48347312",
"0.4829869",
"0.48117617",
"0.48040468",
"0.48027003",
"0.47989967",
"0.47953638",
"0.47919485",
"0.47787616",
"0.47736892",
"0.47728088",
"0.47708187",
"0.4769437",
"0.4768398",
"0.47677627",
"0.47633177",
"0.47631097",
"0.4755773",
"0.47515184",
"0.4750719",
"0.47494507",
"0.47457764",
"0.47452554",
"0.4735827",
"0.47239852",
"0.47187877"
] | 0.76830506 | 1 |
Return value to be compared for sorting and conditionals | def sortValue(self, data):
storedText = data.get(self.name, '')
try:
return repr(GenBoolean(storedText))
except GenBooleanError:
return '' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare(self, value: int, /) -> None:",
"def compare(self) -> int:",
"def compareFunction( self, first, second ):\n for ascending,column in self.sortOrder:\n aValue,bValue = column.get(first),column.get(second)\n diff = cmp(aValue,bValue)\n if diff:\n if not ascending:\n return - diff \n else:\n return diff \n return 0",
"def cmpValue(subInfo1, subInfo2):\n val1 = subInfo1[VALUE]\n val2 = subInfo2[VALUE]\n return val1 > val2",
"def cmpValue(subInfo1, subInfo2):\n val1 = subInfo1[VALUE]\n val2 = subInfo2[VALUE]\n return val1 > val2",
"def compare(a, b):\n if a > b:\n return a\n return b",
"def _get_comparison_func(self, adjective):\n return self.SONG_ADJECTIVES.get(adjective, {}).get(\"comparison\")",
"def item_comparer(self):\n return self.item_comparer_value",
"def compare(a,b):\r\n if a>b:\r\n return 1\r\n elif a==b:\r\n return 0\r\n else:\r\n return -1",
"def compare(self, variable):\n if (not self.lower and variable > self.value) or \\\n (self.lower and variable < self.value):\n return pt.common.Status.SUCCESS\n return pt.common.Status.FAILURE",
"def operator(self, sort):\r\n return None",
"def comparison(self):\n return self._comparison",
"def _cmp(a, b): # pylint: disable=invalid-name\n return (a > b) - (a < b)",
"def less_than_or_equal(self) -> global___Expression:",
"def __cmp__(self,o):\n\t\tif o != None:\n\t\t\treturn cmp(self.value,o.value)\n\t\telse:\n\t\t\treturn cmp(self.value,0)",
"def __cmp__(self, x):\n if self.score < x.score: return -1\n elif self.score == x.score: return 0\n else: return 1",
"def comparison(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"comparison\")",
"def _compare(self, value, target):\n result = getattr(self.reg, target) - value\n self.reg.N = result >> 7\n self.reg.C = getattr(self.reg, target) >= value\n self.reg.Z = result == 0",
"def __ge__( self, value ):\r\n\t\treturn ( self > value ) or ( self == value )",
"def test_key_predicate(datum):\n return 0 < datum",
"def cmp(x, y):\n return (x > y) - (x < y)",
"def _less_than_or_equal_to_op(spec):",
"def cmp(a, b):\n return (a > b) - (a < b)",
"def conditional_value(self) -> global___Expression.ConditionalOperator:",
"def cmp(x, y):\n return (x > y) - (x < y)",
"def less(value, other):\n return value > other",
"def _default_eval_func(a, b):\n emphasis = \"r2\"\n a_value = getattr(a, emphasis)\n b_value = getattr(b, emphasis)\n return a_value > b_value",
"def comparison(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"comparison\")",
"def comparison(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"comparison\")",
"def comparison(self) -> str:\n return self._values.get('comparison')",
"def greater_than_or_equal(self) -> global___Expression:",
"def cmp ( self, object1, object2 ):\n return cmp( self.get_raw_value( object1 ),\n self.get_raw_value( object2 ) )",
"def _test_method_sorter(_, x, y):\n if x == 'test_gc':\n return 1\n if y == 'test_gc':\n return -1\n if x > y:\n return 1\n if x < y:\n return -1\n return 0",
"def greater(value, other):\n return value < other",
"def _greater_than_or_equal_to_op(spec):",
"def compare(a, b, larger_is_better):\n\n if larger_is_better:\n return a > b\n else:\n return a < b",
"def cmp(x, y):\n if x == y:\n return 0\n elif x is None:\n if y is None:\n return 0\n else:\n return -1\n elif y is None:\n return 1\n else:\n # TODO: consider casting the values to string or int or floats?\n # note that this is the minimal replacement function\n return (x > y) - (x < y)",
"def compare(x, y):\n if x >= y:\n return 1.0\n else:\n return 0.0",
"def __gt__(self, value):\n self = self.__ge__(value)\n return self.__invert__()",
"def __gt__(self, other):\n\t\ttry:\n\t\t\treturn self.val > other.val\n\t\texcept:\n\t\t\treturn self.val > other",
"def _custom_sorter(self, key1, key2):\n\n col = self._col\n ascending = self._colSortFlag[col]\n real = self.get_real_col(col)\n item1 = self.itemDataMap[key1][real]\n item2 = self.itemDataMap[key2][real]\n\n # Internationalization of string sorting with locale module\n if isinstance(item1, str) and isinstance(item2, str):\n cmpVal = locale.strcoll(item1, item2)\n elif isinstance(item1, bytes) or isinstance(item2, bytes):\n cmpVal = locale.strcoll(str(item1), str(item2))\n else:\n cmpVal = cmp(item1, item2)\n\n # If the items are equal, then pick something else to make the sort value unique\n if cmpVal == 0:\n cmpVal = cmp(*self.GetSecondarySortValues(col, key1, key2))\n\n if ascending:\n return cmpVal\n else:\n return -cmpVal",
"def _comparison_function(comp, value=0.0, **kwargs):\n if comp == 'g' or comp == '>':\n func = np.greater\n elif comp == 'ge' or comp == '>=':\n func = np.greater_equal\n elif comp == 'l' or comp == '<':\n func = np.less\n elif comp == 'le' or comp == '<=':\n func = np.less_equal\n elif comp == 'e' or comp == '=' or comp == '==':\n func = np.equal\n elif comp == 'ne' or comp == '!=':\n func = np.not_equal\n else:\n raise ValueError(\"Unrecognized comparison '{}'.\".format(comp))\n\n def comp_func(xx):\n return func(xx, value, **kwargs)\n\n return comp_func",
"def adjustedCompareValue(self, value):\n return value",
"def foo_2(x, y):\n\tif x > y:\n\t\treturn x\n\treturn y",
"def cmp(x, y):\n if x + y > y + x: return 1\n elif x + y == y + x: return 0\n else: return -1",
"def test_get_sort_value_with_after_object(self):\n test_object = self.test.datum_type2\n actual = test_object.get_sort_value(after_object=self.test.datum_type1)\n expected = 10101\n self.assertEqual(expected, actual)",
"def statusCompare (x, y):\n xs = db.status.get(x, 'order')\n ys = db.status.get(y, 'order')\n c = float(xs) - float(ys)\n if c >= 0.0: \n return int(c)\n else:\n return -int(abs(c))",
"def _default_eval_func(a, b):\n emphasis = \"accuracy\"\n a_value = getattr(a, emphasis)\n b_value = getattr(b, emphasis)\n return a_value > b_value",
"def __cmp__(self, other) :\n if self.strength > other.strength:\n return 1;\n elif self.strength == other.strength :\n if self.rank > other.rank :\n return 1;\n elif self.rank == other.rank :\n return 1 if self.kickers > other.kickers else -1 if self.kickers < other.kickers else 0;\n return -1;",
"def best_value(self):\r\n return self._best_value",
"def get_result(mishkaScore: int, chrisScore: int) -> bool:\n if mishkaScore > chrisScore:\n return \"M\"\n if mishkaScore < chrisScore:\n return \"C\"\n return \"D\"",
"def getValue(self):\n if self.left.getValue() >= self.right.getValue():\n return self.left.getValue()\n\n return self.right.getValue()",
"def compare(num1, num2):\n if num1 > num2:\n return num1, num2\n return num2, num1",
"def decide():",
"def compare(self, *args):\n return _ida_hexrays.creturn_t_compare(self, *args)",
"def lt_success_func(target, result):\n if result is None:\n return False\n return result < target",
"def getValue(self):\n r = 1 if self.left.getValue() > self.right.getValue() else 0\n return r",
"def test_get_sort_value_without_after_object(self):\n test_object = self.test.datum_type2\n actual = test_object.get_sort_value()\n expected = 10101\n self.assertEqual(expected, actual)",
"def compare(self, operator, value, **kw):\n\n return operator(self.comparator, value)",
"def assembly_compare(x, y) :\n if x.kinf() < y.kinf() :\n return 1\n elif x.kinf() == y.kinf() :\n return 0\n else : #x.resultType < y.resultType\n return -1",
"def _cmp(x, y):\n if x[1].count > y[1].count:\n return CmpRelation.GREATER\n if x[1].count < y[1].count:\n return CmpRelation.LESS\n if x[1].ptn_length < y[1].ptn_length:\n return CmpRelation.GREATER\n if x[1].ptn_length > y[1].ptn_length:\n return CmpRelation.LESS\n return CmpRelation.EQUAL",
"def comparator(self):\n return self.get_scores()",
"def getValue(self):\n if self.left.getValue() <= self.right.getValue():\n return self.left.getValue()\n\n return self.right.getValue()",
"def __cmp__(self, other):\n \n result = cmp(self.value, other.value)\n if result == 0:\n \"\"\"Values are identical, suits differ. Doesn't affect ranking in\n any way.\"\"\"\n result = cmp(self.suit, other.suit)\n return result",
"def getValue(self):\n r = 1 if self.left.getValue() <= self.right.getValue() else 0\n return r",
"def gt_success_func(target, result):\n if result is None:\n return False\n return result > target",
"def compare(a, b):\n return a - b",
"def getValue(self):\n r = 1 if self.left.getValue() >= self.right.getValue() else 0\n return r",
"def getValue(self):\n r = 1 if self.left.getValue() < self.right.getValue() else 0\n return r",
"def compare(self, comp_els):\n return min(comp_els, key= lambda x: x[1])[0]",
"def compare(self, *args):\n return _ida_hexrays.cwhile_t_compare(self, *args)",
"def comparator_converter(self, val):\r\n return val",
"def _greater_than_op(spec):",
"def cmp(a, b):\n if a is None and b is None:\n return 0\n elif a is None:\n return -1\n elif b is None:\n return 1\n else:\n return (a > b) - (a < b)",
"def _slack_get_value(slack_response, search_value, search_field, return_field, classifier):\n if not slack_response['ok']:\n return False\n for item in slack_response[classifier]:\n if search_field in item and search_value == item[search_field] and return_field in item:\n return item[return_field]",
"def _less_than_op(spec):",
"def compare(self, comp_els):\n return max(comp_els, key=lambda x: x[1])[0]",
"def item_comparer(self, value):\n self.item_comparer_value = value",
"def compare_to(self, other) -> int:\n if self.id == other.id:\n return 0\n if self.status != other.status:\n return -1 if self.status < other.status else 1\n if self.last_played != other.last_played:\n return -1 if self.last_played < other.last_played else 1\n return -1 if self.id < other.id else 1",
"def value(self) -> bool:",
"def compare_entities(e1, e2):\n sp1 = e1.sorting_priority\n sp2 = e2.sorting_priority\n if sp1 > sp2:\n return 1\n elif sp1 == sp2:\n return 0\n else:\n return -1",
"def try_compare(obj, key, comparison, search_value, override_value=\"\"):\n value = override_value if override_value else obj[key]\n try:\n return getattr(value, comparison)(search_value)\n except KeyError:\n return False\n except Exception as e:\n logging.warning('The following exception was ignored in {0}: {1}'.format(try_compare.__name__, e))",
"def compare(first, second):\n for i in data:\n if(i['name'] == first ):\n first_num = i['follower_count']\n if(i['name'] == second):\n second_num = i['follower_count']\n if first_num > second_num:\n return 'a'\n else:\n return 'b'",
"def compare(self, *args):\n return _ida_hexrays.fnumber_t_compare(self, *args)",
"def fn_if(self, value):\n\n condition_name, true_value, false_value = value\n if self.parser.conditions.evaluate(condition_name):\n return true_value\n else:\n return false_value",
"def compare(self, *args):\n return _ida_frame.stkpnt_t_compare(self, *args)",
"def compare(self, *args):\n return _ida_hexrays.cnumber_t_compare(self, *args)",
"def __cmp__(self, other):\n \n result = cmp(self.rank(), other.rank())\n if (result == 0):\n # Compare hand values\n for i in range(len(self.values())):\n result = cmp(self.values()[i], other.values()[i])\n if (result != 0):\n return result\n return result",
"def __cmp__(self, other):\n if options.rank_by.lower() != \"money\":\n \"\"\"flags ▲, money ▲, hints ▼, time ▼\"\"\"\n this, that = len(self.flags), len(other.flags)\n if this == that:\n this, that = self.money, other.money\n if this == that:\n this, that = len(other.hints), len(self.hints)\n if this == that:\n this, that = other.last_scored(), self.last_scored()\n else:\n \"\"\"money ▲, hints ▼, time ▼, flags ▲\"\"\"\n this, that = self.money, other.money\n if this == that:\n this, that = len(other.hints), len(self.hints)\n if this == that:\n this, that = other.last_scored(), self.last_scored()\n if this == that:\n this, that = len(self.flags), len(other.flags)\n if this < that:\n return 1\n elif this == that:\n return 0\n else:\n return -1",
"def ge_success_func(target, result):\n if result is None:\n return False\n return result >= target",
"def le(self, val):\n\t\treturn LessOrEquals(self, val)",
"def compareAUTOR(offense1, offense2):\n \n if (offense1 == offense2):\n return 0\n elif (offense1 > offense2):\n return 1\n else:\n return -1",
"def ge(self, val):\n\t\treturn GreaterOrEquals(self, val)",
"def __lt__(self, rs):\n Number.comparisons += 1\n result = self.data < rs.data\n return result",
"def __lt__(self, value):\n return self.name < value.name",
"def answer_sorter(thing):\r\n try:\r\n return float(thing[0])\r\n except ValueError:\r\n # Put all non-numerical answers first.\r\n return float('-inf')",
"def comparator(self) -> typing.Callable[[Vec, Vec, Term], bool]:\n pass",
"def __value_of(sentiment):\n if sentiment == 'positive': return 1\n if sentiment == 'negative': return -1\n return 0",
"def comparison(op):\n def comp(*args):\n if args:\n item = args[0]\n for o in args[1:]:\n if op(item, o):\n item = o\n else:\n return Boolean(False)\n return Boolean(True)\n else:\n return Boolean(True)\n return comp",
"def GetPriorityValue(self, *args, **kwargs):\n pass"
] | [
"0.68654275",
"0.68611443",
"0.66724616",
"0.6351402",
"0.6351402",
"0.63162804",
"0.6138383",
"0.6053028",
"0.6039845",
"0.5910521",
"0.58821",
"0.58723485",
"0.5849007",
"0.5812883",
"0.5799768",
"0.57915914",
"0.5790346",
"0.57894623",
"0.5771585",
"0.5759572",
"0.5746019",
"0.5740628",
"0.5739194",
"0.5738822",
"0.57271117",
"0.57232124",
"0.5721245",
"0.5719918",
"0.5719918",
"0.5710413",
"0.5666354",
"0.56614244",
"0.5653205",
"0.56457806",
"0.56438506",
"0.562456",
"0.559111",
"0.5568418",
"0.554077",
"0.55370283",
"0.55257344",
"0.5520409",
"0.5503359",
"0.550171",
"0.5500652",
"0.5496061",
"0.5495651",
"0.5479606",
"0.54749304",
"0.5464671",
"0.5463505",
"0.54627633",
"0.5460634",
"0.5458287",
"0.5454057",
"0.54538625",
"0.544756",
"0.5444319",
"0.5443308",
"0.5440087",
"0.54264873",
"0.5423893",
"0.5420949",
"0.5419035",
"0.5415935",
"0.54151773",
"0.5401301",
"0.5401075",
"0.54007626",
"0.5400393",
"0.53982997",
"0.5398238",
"0.53902316",
"0.5387147",
"0.53787",
"0.53642255",
"0.5362832",
"0.53625894",
"0.53396165",
"0.5337684",
"0.5337436",
"0.5336828",
"0.53298044",
"0.5327047",
"0.5311193",
"0.53040814",
"0.5295887",
"0.5295521",
"0.5292093",
"0.5285901",
"0.5283696",
"0.5282874",
"0.52811736",
"0.52635443",
"0.5261918",
"0.5257477",
"0.52570784",
"0.52501166",
"0.52414715",
"0.52397144"
] | 0.5488403 | 47 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
TextFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.735201",
"0.6754294",
"0.67166066",
"0.67071074",
"0.66780305",
"0.65807486",
"0.6522693",
"0.6522693",
"0.65187657",
"0.6471306",
"0.6269984",
"0.62653935",
"0.6153201",
"0.6090701",
"0.60323846",
"0.60278016",
"0.6011661",
"0.60042846",
"0.59841794",
"0.5941162",
"0.59205276",
"0.5918955",
"0.59121054",
"0.5903962",
"0.5884743",
"0.5876164",
"0.5857109",
"0.5851559",
"0.583173",
"0.58274394",
"0.5816038",
"0.58061635",
"0.5784312",
"0.5755998",
"0.5755998",
"0.57360405",
"0.57051307",
"0.5701552",
"0.5687975",
"0.5650812",
"0.5618766",
"0.561154",
"0.5605911",
"0.56030387",
"0.5602799",
"0.55926436",
"0.5587559",
"0.5571399",
"0.5567558",
"0.55631375",
"0.555545",
"0.5550559",
"0.55490625",
"0.55470836",
"0.55410224",
"0.5519966",
"0.55098814",
"0.5492064",
"0.547102",
"0.5470936",
"0.54692423",
"0.5467515",
"0.54661024",
"0.54518676",
"0.54405665",
"0.5438651",
"0.54003173",
"0.5388153",
"0.5382598",
"0.5375904",
"0.5375076",
"0.53706104",
"0.5359634",
"0.5354708",
"0.5354708",
"0.5331472",
"0.5324531",
"0.53227526",
"0.5316361",
"0.5309617",
"0.5308968",
"0.53067",
"0.5306182",
"0.5299369",
"0.52990687",
"0.5287107",
"0.52791494",
"0.5277907",
"0.5276578",
"0.52742803",
"0.5270845",
"0.52608305",
"0.52524847",
"0.5244876",
"0.5239417",
"0.5234171",
"0.5224983",
"0.5215326",
"0.521457",
"0.5212088",
"0.5203955"
] | 0.0 | -1 |
Return the next value for a new node, increment format if increment is True | def nextValue(self, increment=True):
try:
prefix, numText, suffix = UniqueIDFormat.formatRe.\
match(self.format).groups()
except AttributeError:
self.format = UniqueIDFormat.defaultFormat
return self.nextValue(increment)
value = self.format
if increment:
pattern = u'%%s%%0.%dd%%s' % len(numText)
num = int(numText) + 1
self.format = pattern % (prefix, num, suffix)
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutate(self, node, _):\n new_node = ast.Num(n=node.n + 1)\n return new_node",
"def next(self):\n with self.atomicfile.locked():\n curr = self.atomicfile.read_atomic().decode(\"utf8\")\n curr = self.initial if not curr else int(curr)\n self.atomicfile.write_atomic(str(curr + 1).encode(\"utf8\"))\n return curr",
"def next(self) -> int:\n self.index += 1\n return self.nodes_sorted[self.index]",
"def get_next(self) -> float:\n return self._current + self._offset",
"def next(self) -> int:\n node = self.list.pop()\n t = node.right\n while (t):\n self.list.append(t)\n t = t.left\n\n return node.val",
"def next(self) -> int:\n self.pointer += 1\n return self.ordered_nodes[self.pointer-1]",
"def get_next(node):\n return node['next']",
"def set_next(node, value):\n node['next'] = value",
"def getNext(self):",
"def next(self, _event):\n self.set_val(self.val + 1)",
"def get_next(current):\n return 0.5 * (current + n / current)",
"def __next__(self) -> object:\n if not self.current_node:\n raise StopIteration\n\n current_node_value = self.current_node.value()\n self.current_node = self.current_node.next()\n return current_node_value",
"def next(self) -> int:\n while (self.stack or self.node):\n if self.node:\n self.stack.append(self.node)\n self.node = self.node.left\n else:\n self.node = self.stack.pop()\n res = self.node.val\n self.node = self.node.right\n return res",
"def new_id(self):\n self.next += 1\n return self.next",
"def next(self) -> int:\n value = self.inorder[self.index]\n self.index = self.index + 1\n return value",
"def get_next(node, offset):\n row, column = node\n row_offset, column_offset = offset\n return row + row_offset, column + column_offset",
"def addNode(self, new_value): # Class O(n)\r\n if type(new_value) is not int: raise ValueError(\"Please, insert an integer\")\r\n h = self.head\r\n while 'next' in dir(h.next):\r\n h = h.next\r\n else:\r\n h.next = Node(new_value)",
"def process(self, count):\n self.data.add_node(0)\n for index in range(1, count + 1):\n # print(\"{}.: {}\".format(index, self.data))\n self.data.move_circular(self.stepforward)\n self.data.add_node(index)\n return self.data.get_next()",
"def next(self, initial):",
"def get_next():\n return \"some_value\"",
"def increment_node_index(self):\n self.node_index += 1",
"def get_next(self) -> int:\n return self._current * self._step + self._offset",
"def next(self, log=False):\n def get_next(i, l):\n for l, r in l:\n if l <= i <= r:\n return r+1\n elif l > i:\n break\n return i\n\n if log:\n r = self.next_li()\n else:\n r = self.next_cl()\n\n n = get_next(r.clidx, self.reg.get(self.liidx, []))\n self.clidx = n\n self.current = Record(self.liidx, self.clidx, None)\n return self.current",
"def next(self) -> int:\n node = self.stack.pop()\n self.push_lefts(node.right)\n return node.val",
"def get_next(self):\n return self.cur_node.next.data",
"def _advance(self):\n self._current += self._increment # Accessing the superclass's field",
"def next(self, delta=1):\n return Prufer.unrank(self.rank + delta, self.nodes)",
"def next(self):\n temp = self.n\n try:\n self.n = next(self.g)\n except Exception as e:\n self._hasNext = False\n return temp",
"def get_next_node_address(self):\n result = self.other_nodes[self.current_node]\n self.current_node = (self.current_node + 1) % self.other_nodes_len\n return result",
"def __next__(self):\n\n # pointer is the current value\n # counter is an item next to pointer\n # take value from pointer position and reduce\n # counter until counter is not 0\n # if counter == 0 move pointer to the next position\n # with value (stride=2)\n if self.counter <= 0:\n # move pointer to the next item\n self.pointer += 2\n try:\n # take counter\n self.counter = self.data[self.pointer + 1]\n except IndexError:\n raise StopIteration\n\n # take value from pointer position and reduce counter\n value = self.data[self.pointer]\n self.counter -= 1\n\n return value",
"def value_at(self, index):\n if index==0:\n return self.head.val\n\n temp_node = self.head\n for _ in range(index):\n temp_node = temp_node.next\n return temp_node.val",
"def get_next_position(self):",
"def next():",
"def next():",
"def nextVal(self, n):\n stream = self.stream\n\n stream.append(n) # appends on the right\n\n streamlength = len(stream)\n if streamlength > self.period:\n stream.popleft()\n streamlength -= 1\n if streamlength == 0:\n self.value = 0\n else:\n self.value = sum( stream ) / float( streamlength )\n\n return self.value",
"def get_next(self, formatted=True):\n self.last += 1\n self.save()\n number_length = 5\n last_length = len(str(self.last))\n number_prefix = '0'*(number_length - last_length)\n prefixed_number = number_prefix + str(self.last)\n\n if formatted and self.format:\n formatted_id = self.format % prefixed_number\n else:\n formatted_id = '{year}-{number}'.format(year=date.today().year, number=prefixed_number)\n return formatted_id",
"def _update_node(node, value):\n node.N += 1\n node.W += value\n node.Q = node.W / node.N",
"def next_node(self, value):\n if (type(value) != Node and value is not None):\n raise TypeError(\"next_node must be a Node object\")\n else:\n self.__position = value",
"def next(self):\n self.state += 1\n if self.state > 1:\n self.state = 0",
"def _get_next_nodes(self):\n next_nodes = self.data[5] if not is_nan(self.data[5]) else \"eos\"\n if is_nan(next_nodes):\n next_nodes = \"eos\"\n return next_nodes",
"def next_node(self, value):\n if isinstance(value, Node) is False:\n raise TypeError(\"next_node must be a Node object\")\n self.__next_node = value",
"def __init__(self, value, next_node=None):\n self.value = value # element at the node\n self.next_node = next_node # reference to next node",
"def update(self, value, index):\n\n length = self.get_length()\n if type(index) is int:\n if index > length:\n # The index value is out of range and prompts and exits\n print(\"Index is out of range.\")\n return\n else:\n this_node = Node(data=value)\n if index == 0:\n this_node.next = self.head.next\n this_node.prev =None\n self.head = this_node\n else:\n cur = self.head\n while index - 1:\n cur = cur.next\n index -= 1\n this_node.next = cur.next.next\n this_node.prev = cur.next.prev\n cur.next = this_node\n return\n else:\n print(\"Index value is not int.\")\n return",
"def next(self) -> str:\n raise NotImplementedError",
"def newData():\n if(reset == 1):\n metaCounter.next = 0\n flagRegistered.next = False\n decimationStyle.next = 0\n else:\n if(newValueFlag):\n metaCounter.next = 0\n flagRegistered.next = True\n else:\n if(flagRegistered):\n if(metaCounter == 8):\n decimationStyle.next = decimationStyle_ext\n metaCounter.next = 0\n flagRegistered.next = False\n else:\n metaCounter.next = metaCounter + 1\n else:\n decimationStyle.next = decimationStyle",
"def __next__(self):\n if self.idx < len(self.nodes) - 1:\n self.idx += 1\n return self.nodes[self.idx]\n else:\n if self.mode is 'circular':\n self.idx = 0\n else:\n self.idx = len(self.nodes)\n raise StopIteration",
"def __init__(self, value, next=None):\n self.value = value\n self.next = next",
"def next(self):\n\n if not self.isFinished:\n if not self.isNearlyFinished: # the next line is still defined\n self.currentLine = self.nextLine.copy()\n # Update nextLine\n try:\n self.nextLine = self.it.next()\n except StopIteration:\n self.isNearlyFinished = True\n else:\n self.isFinished = True\n self.currentLine[self.idxEvals] = numpy.nan\n #TODO: the line above was not valid for the MultiArrayReader\n\n return self.currentLine",
"def next_node(self, value):\n if not isinstance(value, Node) and value is not None:\n raise TypeError(\"next_node must be a Node object\")\n else:\n self.__next_node = value",
"def next(self):\n n, self.iter = self.nums[self.iter], self.iter+1\n return n",
"def set_next(self, new_next):\n self.next = new_next",
"def _get_next_number(self,\n num_id: str,\n level: str):\n abstract_num_id = self.num_list[num_id].abstract_num_id\n # level = ilvl + 1\n ilvl = str(int(level) - 1)\n lvl_info = self.num_list[num_id].get_level_info(ilvl)\n if lvl_info['numFmt'] == \"bullet\":\n return lvl_info['lvlText']\n\n try:\n shift = self.numerations[(abstract_num_id, ilvl)]\n except KeyError:\n shift = lvl_info[\"start\"]\n self.numerations[(abstract_num_id, ilvl)] = shift\n num_fmt = get_next_item(lvl_info['numFmt'], shift - 1)\n return num_fmt",
"def next(self):\n node = self.stack.pop()\n self.pushLeft(node.right)\n return node.val",
"def next(self) -> int: \n\n cur = self.stack.pop()\n root = cur.right\n while root: #stack存左子节点\n self.stack.append(root)\n root = root.left\n \n return cur.val",
"def increment(self):\r\n return self.add(1)",
"def _advance(self):\n self._current += 1",
"def next_num(cls):\r\n cls.num += 1\r\n return cls.num",
"def next(self) -> int:\n self.idx += 1\n return self.m[self.idx]",
"def next(self) -> int:\n self.idx += 1\n return self.m[self.idx]",
"def increment(self) -> global___Expression:",
"def _get_next_sequence_number(self):\n cur = self._next_sequence_number\n self._next_sequence_number += 1\n return cur",
"def next(self) -> int:\n node = self.stack.pop()\n ans = node.val \n self._sink(node.right)\n return ans",
"def increment(cls, value):\r\n value.value += 1",
"def next_node(self):\n return self.__next_node",
"def next_node(self):\n return self.__next_node",
"def next_node(self):\n return self.__next_node",
"def _advance(self):\n if self._is_at_end():\n return None\n self.current += 1\n return self.source[self.current - 1]",
"def __insert(self, node, value):\n #if DEBUG: print('\\t__insert({})'.format(value))\n\n new = Node(value, node.next)\n node.next = new\n return new",
"def Next(self):\n while self.stack:\n if self.stack[-1].wkids:\n # Node has children we haven't examined, so iterate into the first\n # child\n node = self.stack[-1].wkids.pop(0)\n if not self.stack[-1].wkids:\n # No more children of this node\n self.stack[-1].wkids = None\n self.nodes_examined += 1\n if self.interval and not self.nodes_examined % self.interval:\n self.PrintProgress()\n if (node not in self.history) and (node not in self.seen):\n # Haven't hit a cycle or a node we've already seen\n node.wkids = copy.copy(node.children(scan=1))\n self.stack.append(node)\n self.history.add(node)\n else:\n # Coming back from iterating, so return the next node on the stack.\n node = self.stack.pop()\n self.history.remove(node)\n self.seen.add(node)\n self.unique_nodes += 1\n return node\n return None",
"def next_node(self, value):\n if type(value) is not Node and type(value) is not None:\n raise TypeError(\"next_node must be a Node object\")\n else:\n self.__next_node = value",
"def inc(self, key):\n if key in self.key_dict:\n self.increase(key)\n return\n self.key_dict[key] = key_node = KeyNode(key, 1)\n value_node = self.value_dict.get(1)\n if value_node is None:\n self.value_dict[1] = value_node = ValueNode(1, None, self.head)\n if self.head:\n self.head.prev = value_node\n self.head = value_node\n if self.last is None:\n self.last = value_node\n self.insert_key_node(key_node)",
"def _inc(self, val):\r\n assert(len(val) == self.sequence_length)\r\n return self.sequence_string[(self.sequence_string.index(val)+1) % len(self.sequence_string)]",
"def _NextExpression(self):\r\n self.RestoreExpression()\r\n self.expressionindex+=1\r\n return self.SetExpressionByIndex(self.expressionindex)",
"def next(some_list, current_index):\n try:\n return some_list[int(current_index) + 1] # access the next element\n except:\n return '' # return empty string in case of exception",
"def next(self):\n return self.my_next",
"def __str__(self):\n if self.next is not None:\n return (str(self.value) + ' -->')\n return str(self.value)",
"def next_value(self):\n self._lock.acquire()\n try:\n id = self._next_id\n self._next_id += 1\n finally:\n self._lock.release()\n return id",
"def next(self) -> str:\r\n if self.hasNext():\r\n val = ''.join(self.comb[self.ind])\r\n self.ind += 1\r\n return val",
"def getNext(self):\n\t\t\treturn self.next",
"def _build_node(self):\n self._next_id += 1\n return _DirectedAcyclicSequenceGraphNode(self._next_id - 1)",
"def next(self):\n if self.signbit.dec_value == 1:\n method = 'prev'\n else:\n method = 'next'\n return self._step(method)",
"def get_next_val(self, sequence_name, length = 1, tuple_result = False):\n if length == 1:\n return self._get_next_val(sequence_name)\n\n cur = self.cursor()\n request = u\"\"\"\nbegin\n for i in 1 .. {LENGTH} loop\n :retval := {SEQUENCE}.nextval();\n end loop;\n\n -- next variant perform commit because has DDL operation\n -- -- First, alter the object so the next increment will jump {LENGTH} instead of just 1.\n -- execute immediate 'alter sequence {SEQUENCE} increment by {LENGTH}';\n -- -- Run a select to actually increment it by {LENGTH}\n -- select {SEQUENCE}.nextval into :retval from dual;\n -- -- Alter the object back to incrementing only 1 at a time\n -- execute immediate 'alter sequence {SEQUENCE} increment by 1';\nend;\n\"\"\"\n request = request.format(**{\"SEQUENCE\": sequence_name, \"LENGTH\": length})\n retval = cur.var(cx_Oracle.NUMBER)\n cur.execute(request, retval=retval)\n retval = int(retval.getvalue())\n cur.close()\n #return list of new ids or pair of values that correspond interval\n if tuple_result == True:\n return (retval - length + 1, retval)\n return range(retval - length + 1, retval + 1)",
"def __next__(self):\n if self._current is None:\n raise StopIteration()\n else:\n answer = self._current # hold prev value of _current\n self._advance() # update _current to next value in the\n #progression\n return answer",
"def get_next_node(node_destinatari,node_enviant):\n if node_list.index(node_destinatari)>node_list.index(node_enviant):\n #sentit=\"up\"\n node_anterior=node_list[node_list.index(id)-1]\n node_seguent=node_list[node_list.index(id)-2]\n if node_list.index(id)-3 < len(node_list):\n node_seguent2=node_list[node_list.index(id)-3]\n else:\n node_seguent2=node_seguent\n else:\n return(id,id,id)\n print(\"Get_next_node \",node_destinatari,node_enviant,\" result \",node_anterior,node_seguent,node_seguent2)\n return(node_anterior,node_seguent,node_seguent2)",
"def next_elem(list_, current_index):\n try:\n return list_[int(current_index) + 1]\n except IndexError:\n return ''",
"def next(self) -> int:\n node = self.stack.pop()\n if node.right:\n self.leftMost(node.right)\n \n return node.val",
"def __setattr__(self, key, value):\n if key == \"next\" and value:\n if value is not None:\n if not isinstance(value, Node):\n raise TypeError\n\n if Node.strict and value.next:\n # If we are in strict mode we check to make sure this\n # modification to `next` will not create a cycle.\n node = value.next\n while node:\n if node == self:\n raise ValueError(\"Cannot insert %s cycle detected\" \\\n % (value.data))\n node = node.next\n\n super(Node, self).__setattr__(key, value)",
"def _advance(self):\t\t# override inherited version\n self._current *= self._base",
"def __next__(self) -> Tuple[keyType, valueType]:\n key = None\n value = None\n # To determine if it has encountered a situation where a key has multiple values.\n if (len(self.iter_values) != 0) and (self.iter_value_index < len(self.iter_values) - 1):\n self.iter_value_index += 1\n key = self.iter_key\n value = self.iter_values[self.iter_value_index]\n return key, value\n else:\n self.iter_value_index = -1\n self.iter_values = []\n\n def get_new_head_node_index(old_head_node_index: int) -> int:\n \"\"\"\n To find next node if the nodes in this chain are all visited.\n :param old_head_node_index: Subscript of the head node where the last accessed key-value pair is.\n :return: The subscript of the head node where the key-value pair has not been accessed; else return -1, if there's no new pair.\n \"\"\"\n # '-1' means that there is no more new node not visited.\n new_head_index = -1\n if old_head_node_index < self.length - 1:\n for index in range(old_head_node_index + 1, self.length):\n if len(self.hashTable[index].keys) > 0:\n new_head_index = index\n break\n return new_head_index\n\n head_node = self.hashTable[self.iter_head_node_index]\n # head_node.count > 0 means node existing.\n if len(head_node.keys) > 0:\n # There are nodes in the linked list is not accessed\n self.iter_chain_node_index += 1\n if len(head_node.keys) > self.iter_chain_node_index:\n keys_values_list = head_node.singlyLinkedList\n node = keys_values_list[self.iter_chain_node_index]\n key = node.key\n if len(node.values) == 1:\n value = node.values[0]\n else:\n self.iter_values = node.values\n value = node.values[0]\n self.iter_key = node.key\n self.iter_value_index += 1\n\n # All nodes in the linked list have been accessed. The new node should be accessed.\n else:\n # Find the hash address of the next node.\n new_hash_address = get_new_head_node_index(self.iter_head_node_index)\n # Find a new node that has not been visited.\n if new_hash_address != -1:\n # update the hash address and the node index.\n self.iter_head_node_index = new_hash_address\n self.iter_chain_node_index = 0\n head_node = self.hashTable[new_hash_address]\n\n keys_values_list = head_node.singlyLinkedList\n node = keys_values_list[self.iter_chain_node_index]\n key = node.key\n if len(node.values) == 1:\n value = node.values[0]\n else:\n self.iter_values = node.values\n value = node.values[0]\n self.iter_key = node.key\n self.iter_value_index = 0\n # There are no new and accessible nodes.\n else:\n raise StopIteration\n else:\n new_hash_address = get_new_head_node_index(self.iter_head_node_index)\n if new_hash_address != -1:\n self.iter_head_node_index = new_hash_address\n self.iter_chain_node_index = 0\n head_node = self.hashTable[new_hash_address]\n\n keys_values_list = head_node.singlyLinkedList\n node = keys_values_list[self.iter_chain_node_index]\n key = node.key\n if len(node.values) == 1:\n value = node.values[0]\n else:\n self.iter_values = node.values\n value = node.values[0]\n self.iter_key = node.key\n self.iter_value_index = 0\n # There is no new and accessible node.\n else:\n raise StopIteration\n return key, value",
"def next_address():\n\t\tkeylist = vessel_list.keys()\n\t\tcurrentkey = keylist.index(str(node_id))\n\t\treturn vessel_list[keylist[(currentkey+1)%len(keylist)]]",
"def __get_next_unmarked(self, current):\n while self.__is_multiple(current):\n current += 1\n return current",
"def _advance(self):\n if not self._is_at_end():\n self._current += 1\n return self._previous()",
"def get_next(self):\n return self.next",
"def get_next(self):\n return self.next",
"def next_node(self):\n\n return self.__next_node",
"def next_(self, update=0):\n char = super().next_()\n\n if update == 1:\n self.highlight_current()\n elif update == 2:\n self._update_request.emit()\n\n return char",
"def next(self):\r\n self._collect()\r\n if not self._heads and not self._refresh:\r\n return Stream.EOF\r\n minimum = self._pop()\r\n if minimum:\r\n line, stream = minimum\r\n self._refresh.add(stream)\r\n return (self._labels[stream], line)",
"def _advance(self):\n self._prev, self._current = self._current, self._prev + self._current",
"def next(self) -> int:\n\t\ttop = self.stack.pop()\n\t\troot = top.right\n\t\twhile root:\n\t\t\tself.stack.append(root)\n\t\t\troot = root.left\n\t\treturn top.val",
"def next(self):\n return self.from_date(self.date_b)"
] | [
"0.66704005",
"0.63615674",
"0.63538784",
"0.6263111",
"0.6259454",
"0.625471",
"0.62121814",
"0.6187122",
"0.615829",
"0.61369663",
"0.6088049",
"0.60810864",
"0.6007773",
"0.5959815",
"0.59519273",
"0.5947382",
"0.5939667",
"0.58915627",
"0.58673847",
"0.5866701",
"0.5839652",
"0.583466",
"0.5830155",
"0.582938",
"0.5807465",
"0.5801369",
"0.5796639",
"0.5781664",
"0.5766271",
"0.5717102",
"0.5716114",
"0.5679638",
"0.5671945",
"0.5671945",
"0.5667544",
"0.5661141",
"0.56578153",
"0.5639548",
"0.5635676",
"0.56139404",
"0.5601299",
"0.55994916",
"0.5594569",
"0.55937195",
"0.55924714",
"0.5584923",
"0.5580092",
"0.55684376",
"0.55674237",
"0.55585176",
"0.5557782",
"0.5557507",
"0.55538636",
"0.55523974",
"0.55493456",
"0.5546031",
"0.55445236",
"0.5511096",
"0.5511096",
"0.5503727",
"0.54995406",
"0.54783684",
"0.54705757",
"0.5468948",
"0.5468948",
"0.5468948",
"0.5467479",
"0.5465337",
"0.5464525",
"0.5464468",
"0.5452862",
"0.54321754",
"0.5426377",
"0.5410047",
"0.5406277",
"0.54048514",
"0.54012084",
"0.53946847",
"0.539415",
"0.5390503",
"0.53902143",
"0.53897",
"0.5382953",
"0.5378844",
"0.5371497",
"0.5356382",
"0.5344815",
"0.5333576",
"0.5322958",
"0.53219736",
"0.5319582",
"0.5318833",
"0.531353",
"0.531353",
"0.53057337",
"0.5300633",
"0.52962774",
"0.5295305",
"0.5294501",
"0.5292236"
] | 0.6884581 | 0 |
Return value to be compared for sorting and conditionals | def sortValue(self, data):
storedText = data.get(self.name, '')
try:
return int(UniqueIDFormat.formatRe.match(storedText).group(2))
except AttributeError:
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare(self, value: int, /) -> None:",
"def compare(self) -> int:",
"def compareFunction( self, first, second ):\n for ascending,column in self.sortOrder:\n aValue,bValue = column.get(first),column.get(second)\n diff = cmp(aValue,bValue)\n if diff:\n if not ascending:\n return - diff \n else:\n return diff \n return 0",
"def cmpValue(subInfo1, subInfo2):\n val1 = subInfo1[VALUE]\n val2 = subInfo2[VALUE]\n return val1 > val2",
"def cmpValue(subInfo1, subInfo2):\n val1 = subInfo1[VALUE]\n val2 = subInfo2[VALUE]\n return val1 > val2",
"def compare(a, b):\n if a > b:\n return a\n return b",
"def _get_comparison_func(self, adjective):\n return self.SONG_ADJECTIVES.get(adjective, {}).get(\"comparison\")",
"def item_comparer(self):\n return self.item_comparer_value",
"def compare(a,b):\r\n if a>b:\r\n return 1\r\n elif a==b:\r\n return 0\r\n else:\r\n return -1",
"def compare(self, variable):\n if (not self.lower and variable > self.value) or \\\n (self.lower and variable < self.value):\n return pt.common.Status.SUCCESS\n return pt.common.Status.FAILURE",
"def operator(self, sort):\r\n return None",
"def comparison(self):\n return self._comparison",
"def _cmp(a, b): # pylint: disable=invalid-name\n return (a > b) - (a < b)",
"def less_than_or_equal(self) -> global___Expression:",
"def __cmp__(self,o):\n\t\tif o != None:\n\t\t\treturn cmp(self.value,o.value)\n\t\telse:\n\t\t\treturn cmp(self.value,0)",
"def comparison(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"comparison\")",
"def __cmp__(self, x):\n if self.score < x.score: return -1\n elif self.score == x.score: return 0\n else: return 1",
"def _compare(self, value, target):\n result = getattr(self.reg, target) - value\n self.reg.N = result >> 7\n self.reg.C = getattr(self.reg, target) >= value\n self.reg.Z = result == 0",
"def __ge__( self, value ):\r\n\t\treturn ( self > value ) or ( self == value )",
"def test_key_predicate(datum):\n return 0 < datum",
"def cmp(x, y):\n return (x > y) - (x < y)",
"def _less_than_or_equal_to_op(spec):",
"def cmp(a, b):\n return (a > b) - (a < b)",
"def conditional_value(self) -> global___Expression.ConditionalOperator:",
"def cmp(x, y):\n return (x > y) - (x < y)",
"def less(value, other):\n return value > other",
"def comparison(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"comparison\")",
"def comparison(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"comparison\")",
"def _default_eval_func(a, b):\n emphasis = \"r2\"\n a_value = getattr(a, emphasis)\n b_value = getattr(b, emphasis)\n return a_value > b_value",
"def comparison(self) -> str:\n return self._values.get('comparison')",
"def greater_than_or_equal(self) -> global___Expression:",
"def cmp ( self, object1, object2 ):\n return cmp( self.get_raw_value( object1 ),\n self.get_raw_value( object2 ) )",
"def _test_method_sorter(_, x, y):\n if x == 'test_gc':\n return 1\n if y == 'test_gc':\n return -1\n if x > y:\n return 1\n if x < y:\n return -1\n return 0",
"def greater(value, other):\n return value < other",
"def _greater_than_or_equal_to_op(spec):",
"def compare(a, b, larger_is_better):\n\n if larger_is_better:\n return a > b\n else:\n return a < b",
"def cmp(x, y):\n if x == y:\n return 0\n elif x is None:\n if y is None:\n return 0\n else:\n return -1\n elif y is None:\n return 1\n else:\n # TODO: consider casting the values to string or int or floats?\n # note that this is the minimal replacement function\n return (x > y) - (x < y)",
"def compare(x, y):\n if x >= y:\n return 1.0\n else:\n return 0.0",
"def __gt__(self, value):\n self = self.__ge__(value)\n return self.__invert__()",
"def __gt__(self, other):\n\t\ttry:\n\t\t\treturn self.val > other.val\n\t\texcept:\n\t\t\treturn self.val > other",
"def _custom_sorter(self, key1, key2):\n\n col = self._col\n ascending = self._colSortFlag[col]\n real = self.get_real_col(col)\n item1 = self.itemDataMap[key1][real]\n item2 = self.itemDataMap[key2][real]\n\n # Internationalization of string sorting with locale module\n if isinstance(item1, str) and isinstance(item2, str):\n cmpVal = locale.strcoll(item1, item2)\n elif isinstance(item1, bytes) or isinstance(item2, bytes):\n cmpVal = locale.strcoll(str(item1), str(item2))\n else:\n cmpVal = cmp(item1, item2)\n\n # If the items are equal, then pick something else to make the sort value unique\n if cmpVal == 0:\n cmpVal = cmp(*self.GetSecondarySortValues(col, key1, key2))\n\n if ascending:\n return cmpVal\n else:\n return -cmpVal",
"def _comparison_function(comp, value=0.0, **kwargs):\n if comp == 'g' or comp == '>':\n func = np.greater\n elif comp == 'ge' or comp == '>=':\n func = np.greater_equal\n elif comp == 'l' or comp == '<':\n func = np.less\n elif comp == 'le' or comp == '<=':\n func = np.less_equal\n elif comp == 'e' or comp == '=' or comp == '==':\n func = np.equal\n elif comp == 'ne' or comp == '!=':\n func = np.not_equal\n else:\n raise ValueError(\"Unrecognized comparison '{}'.\".format(comp))\n\n def comp_func(xx):\n return func(xx, value, **kwargs)\n\n return comp_func",
"def adjustedCompareValue(self, value):\n return value",
"def foo_2(x, y):\n\tif x > y:\n\t\treturn x\n\treturn y",
"def cmp(x, y):\n if x + y > y + x: return 1\n elif x + y == y + x: return 0\n else: return -1",
"def test_get_sort_value_with_after_object(self):\n test_object = self.test.datum_type2\n actual = test_object.get_sort_value(after_object=self.test.datum_type1)\n expected = 10101\n self.assertEqual(expected, actual)",
"def statusCompare (x, y):\n xs = db.status.get(x, 'order')\n ys = db.status.get(y, 'order')\n c = float(xs) - float(ys)\n if c >= 0.0: \n return int(c)\n else:\n return -int(abs(c))",
"def sortValue(self, data):\n storedText = data.get(self.name, '')\n try:\n return repr(GenBoolean(storedText))\n except GenBooleanError:\n return ''",
"def _default_eval_func(a, b):\n emphasis = \"accuracy\"\n a_value = getattr(a, emphasis)\n b_value = getattr(b, emphasis)\n return a_value > b_value",
"def __cmp__(self, other) :\n if self.strength > other.strength:\n return 1;\n elif self.strength == other.strength :\n if self.rank > other.rank :\n return 1;\n elif self.rank == other.rank :\n return 1 if self.kickers > other.kickers else -1 if self.kickers < other.kickers else 0;\n return -1;",
"def best_value(self):\r\n return self._best_value",
"def get_result(mishkaScore: int, chrisScore: int) -> bool:\n if mishkaScore > chrisScore:\n return \"M\"\n if mishkaScore < chrisScore:\n return \"C\"\n return \"D\"",
"def getValue(self):\n if self.left.getValue() >= self.right.getValue():\n return self.left.getValue()\n\n return self.right.getValue()",
"def compare(num1, num2):\n if num1 > num2:\n return num1, num2\n return num2, num1",
"def decide():",
"def compare(self, *args):\n return _ida_hexrays.creturn_t_compare(self, *args)",
"def lt_success_func(target, result):\n if result is None:\n return False\n return result < target",
"def getValue(self):\n r = 1 if self.left.getValue() > self.right.getValue() else 0\n return r",
"def test_get_sort_value_without_after_object(self):\n test_object = self.test.datum_type2\n actual = test_object.get_sort_value()\n expected = 10101\n self.assertEqual(expected, actual)",
"def compare(self, operator, value, **kw):\n\n return operator(self.comparator, value)",
"def assembly_compare(x, y) :\n if x.kinf() < y.kinf() :\n return 1\n elif x.kinf() == y.kinf() :\n return 0\n else : #x.resultType < y.resultType\n return -1",
"def _cmp(x, y):\n if x[1].count > y[1].count:\n return CmpRelation.GREATER\n if x[1].count < y[1].count:\n return CmpRelation.LESS\n if x[1].ptn_length < y[1].ptn_length:\n return CmpRelation.GREATER\n if x[1].ptn_length > y[1].ptn_length:\n return CmpRelation.LESS\n return CmpRelation.EQUAL",
"def comparator(self):\n return self.get_scores()",
"def getValue(self):\n if self.left.getValue() <= self.right.getValue():\n return self.left.getValue()\n\n return self.right.getValue()",
"def __cmp__(self, other):\n \n result = cmp(self.value, other.value)\n if result == 0:\n \"\"\"Values are identical, suits differ. Doesn't affect ranking in\n any way.\"\"\"\n result = cmp(self.suit, other.suit)\n return result",
"def gt_success_func(target, result):\n if result is None:\n return False\n return result > target",
"def getValue(self):\n r = 1 if self.left.getValue() <= self.right.getValue() else 0\n return r",
"def compare(a, b):\n return a - b",
"def getValue(self):\n r = 1 if self.left.getValue() >= self.right.getValue() else 0\n return r",
"def getValue(self):\n r = 1 if self.left.getValue() < self.right.getValue() else 0\n return r",
"def compare(self, comp_els):\n return min(comp_els, key= lambda x: x[1])[0]",
"def compare(self, *args):\n return _ida_hexrays.cwhile_t_compare(self, *args)",
"def comparator_converter(self, val):\r\n return val",
"def _greater_than_op(spec):",
"def cmp(a, b):\n if a is None and b is None:\n return 0\n elif a is None:\n return -1\n elif b is None:\n return 1\n else:\n return (a > b) - (a < b)",
"def _slack_get_value(slack_response, search_value, search_field, return_field, classifier):\n if not slack_response['ok']:\n return False\n for item in slack_response[classifier]:\n if search_field in item and search_value == item[search_field] and return_field in item:\n return item[return_field]",
"def item_comparer(self, value):\n self.item_comparer_value = value",
"def _less_than_op(spec):",
"def compare(self, comp_els):\n return max(comp_els, key=lambda x: x[1])[0]",
"def compare_to(self, other) -> int:\n if self.id == other.id:\n return 0\n if self.status != other.status:\n return -1 if self.status < other.status else 1\n if self.last_played != other.last_played:\n return -1 if self.last_played < other.last_played else 1\n return -1 if self.id < other.id else 1",
"def value(self) -> bool:",
"def compare_entities(e1, e2):\n sp1 = e1.sorting_priority\n sp2 = e2.sorting_priority\n if sp1 > sp2:\n return 1\n elif sp1 == sp2:\n return 0\n else:\n return -1",
"def try_compare(obj, key, comparison, search_value, override_value=\"\"):\n value = override_value if override_value else obj[key]\n try:\n return getattr(value, comparison)(search_value)\n except KeyError:\n return False\n except Exception as e:\n logging.warning('The following exception was ignored in {0}: {1}'.format(try_compare.__name__, e))",
"def compare(first, second):\n for i in data:\n if(i['name'] == first ):\n first_num = i['follower_count']\n if(i['name'] == second):\n second_num = i['follower_count']\n if first_num > second_num:\n return 'a'\n else:\n return 'b'",
"def compare(self, *args):\n return _ida_hexrays.fnumber_t_compare(self, *args)",
"def fn_if(self, value):\n\n condition_name, true_value, false_value = value\n if self.parser.conditions.evaluate(condition_name):\n return true_value\n else:\n return false_value",
"def compare(self, *args):\n return _ida_frame.stkpnt_t_compare(self, *args)",
"def compare(self, *args):\n return _ida_hexrays.cnumber_t_compare(self, *args)",
"def __cmp__(self, other):\n \n result = cmp(self.rank(), other.rank())\n if (result == 0):\n # Compare hand values\n for i in range(len(self.values())):\n result = cmp(self.values()[i], other.values()[i])\n if (result != 0):\n return result\n return result",
"def __cmp__(self, other):\n if options.rank_by.lower() != \"money\":\n \"\"\"flags ▲, money ▲, hints ▼, time ▼\"\"\"\n this, that = len(self.flags), len(other.flags)\n if this == that:\n this, that = self.money, other.money\n if this == that:\n this, that = len(other.hints), len(self.hints)\n if this == that:\n this, that = other.last_scored(), self.last_scored()\n else:\n \"\"\"money ▲, hints ▼, time ▼, flags ▲\"\"\"\n this, that = self.money, other.money\n if this == that:\n this, that = len(other.hints), len(self.hints)\n if this == that:\n this, that = other.last_scored(), self.last_scored()\n if this == that:\n this, that = len(self.flags), len(other.flags)\n if this < that:\n return 1\n elif this == that:\n return 0\n else:\n return -1",
"def ge_success_func(target, result):\n if result is None:\n return False\n return result >= target",
"def le(self, val):\n\t\treturn LessOrEquals(self, val)",
"def compareAUTOR(offense1, offense2):\n \n if (offense1 == offense2):\n return 0\n elif (offense1 > offense2):\n return 1\n else:\n return -1",
"def ge(self, val):\n\t\treturn GreaterOrEquals(self, val)",
"def __lt__(self, rs):\n Number.comparisons += 1\n result = self.data < rs.data\n return result",
"def __lt__(self, value):\n return self.name < value.name",
"def comparator(self) -> typing.Callable[[Vec, Vec, Term], bool]:\n pass",
"def answer_sorter(thing):\r\n try:\r\n return float(thing[0])\r\n except ValueError:\r\n # Put all non-numerical answers first.\r\n return float('-inf')",
"def __value_of(sentiment):\n if sentiment == 'positive': return 1\n if sentiment == 'negative': return -1\n return 0",
"def comparison(op):\n def comp(*args):\n if args:\n item = args[0]\n for o in args[1:]:\n if op(item, o):\n item = o\n else:\n return Boolean(False)\n return Boolean(True)\n else:\n return Boolean(True)\n return comp",
"def GetPriorityValue(self, *args, **kwargs):\n pass"
] | [
"0.6866802",
"0.6862163",
"0.6673221",
"0.63514173",
"0.63514173",
"0.63162124",
"0.6138884",
"0.6054708",
"0.60404193",
"0.5911979",
"0.5881882",
"0.5874233",
"0.58493686",
"0.58137196",
"0.5800126",
"0.57923204",
"0.57919735",
"0.5789459",
"0.57723606",
"0.576029",
"0.57464844",
"0.5740192",
"0.5739131",
"0.57377875",
"0.5727295",
"0.5722804",
"0.572151",
"0.572151",
"0.5721253",
"0.57123834",
"0.56671613",
"0.5662787",
"0.56535935",
"0.564566",
"0.5643461",
"0.56243473",
"0.55913526",
"0.55684245",
"0.55416465",
"0.55376697",
"0.55260545",
"0.5520376",
"0.550396",
"0.5501438",
"0.55007446",
"0.54968375",
"0.5496444",
"0.54888177",
"0.5479773",
"0.5475158",
"0.54647714",
"0.546428",
"0.5462475",
"0.5460215",
"0.5457367",
"0.5456048",
"0.54536116",
"0.54472333",
"0.5445657",
"0.54444236",
"0.54395616",
"0.5425802",
"0.54251575",
"0.54206574",
"0.5419941",
"0.54156464",
"0.5415602",
"0.5401689",
"0.5400704",
"0.5400345",
"0.53997445",
"0.5399354",
"0.53986514",
"0.5389632",
"0.5386925",
"0.5379262",
"0.53642875",
"0.5363486",
"0.5362223",
"0.5340353",
"0.5338446",
"0.5338289",
"0.53378546",
"0.53312",
"0.53285456",
"0.53116953",
"0.53059",
"0.5297315",
"0.529591",
"0.52924097",
"0.5286062",
"0.52838206",
"0.5283629",
"0.5281948",
"0.5263634",
"0.52635086",
"0.52569175",
"0.5256176",
"0.5250123",
"0.5241499",
"0.52405554"
] | 0.0 | -1 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
TextFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.735201",
"0.6754294",
"0.67166066",
"0.67071074",
"0.66780305",
"0.65807486",
"0.6522693",
"0.6522693",
"0.65187657",
"0.6471306",
"0.6269984",
"0.62653935",
"0.6153201",
"0.6090701",
"0.60323846",
"0.60278016",
"0.6011661",
"0.60042846",
"0.59841794",
"0.5941162",
"0.59205276",
"0.5918955",
"0.59121054",
"0.5903962",
"0.5884743",
"0.5876164",
"0.5857109",
"0.5851559",
"0.583173",
"0.58274394",
"0.5816038",
"0.58061635",
"0.5784312",
"0.5755998",
"0.5755998",
"0.57360405",
"0.57051307",
"0.5701552",
"0.5687975",
"0.5650812",
"0.5618766",
"0.561154",
"0.5605911",
"0.56030387",
"0.5602799",
"0.55926436",
"0.5587559",
"0.5571399",
"0.5567558",
"0.55631375",
"0.555545",
"0.5550559",
"0.55490625",
"0.55470836",
"0.55410224",
"0.5519966",
"0.55098814",
"0.5492064",
"0.547102",
"0.5470936",
"0.54692423",
"0.5467515",
"0.54661024",
"0.54518676",
"0.54405665",
"0.5438651",
"0.54003173",
"0.5388153",
"0.5382598",
"0.5375904",
"0.5375076",
"0.53706104",
"0.5359634",
"0.5354708",
"0.5354708",
"0.5331472",
"0.5324531",
"0.53227526",
"0.5316361",
"0.5309617",
"0.5308968",
"0.53067",
"0.5306182",
"0.5299369",
"0.52990687",
"0.5287107",
"0.52791494",
"0.5277907",
"0.5276578",
"0.52742803",
"0.5270845",
"0.52608305",
"0.52524847",
"0.5244876",
"0.5239417",
"0.5234171",
"0.5224983",
"0.5215326",
"0.521457",
"0.5212088",
"0.5203955"
] | 0.0 | -1 |
Called by base init, after class change or format text change | def initFormat(self):
self.html = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initFormat(self):\n pass",
"def init_text(self):\n d = self.declaration\n if d.text:\n self.set_text(d.text)\n if d.text_color:\n self.set_text_color(d.text_color)\n if d.text_alignment:\n self.set_text_alignment(d.text_alignment)\n if d.font_family or d.text_size:\n self.refresh_font()\n if hasattr(d, 'max_lines') and d.max_lines:\n self.set_max_lines(d.max_lines)",
"def initFormat(self):\n self.formatList = self.splitText(self.format)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, text):\n\n self.text = text",
"def __init__(self, text):\n self.text = text",
"def __init__(self, text):\n self.text = text",
"def __init__(self):\n self.text = ''",
"def set_text(self):\n pass",
"def post_init(self):\n\t\tpass",
"def init_widget(self):\n super(UiKitTextView, self).init_widget()\n self.init_text()",
"def __init__(self,\n text: str) -> None:\n\n super().__init__(text)",
"def initFormat(self):\n self.formatList = []",
"def _post_init(self):\n pass",
"def __post_init__(self):\n pass",
"def initWidgets(self):\n self.lambdtext.setText(str(self.lambd))\n self.ptext.setText(str(self.p))",
"def done_adding_strings(self):\n #placeholder in case there's some additional init we need to do.\n pass",
"def done_adding_strings(self):\n #placeholder in case there's some additional init we need to do.\n pass",
"def _init_display(self):\n raise NotImplementedError",
"def __init__(self):\n super(Command, self).__init__()\n self.style.TITLE = self.style.SQL_FIELD\n self.style.STEP = self.style.SQL_COLTYPE\n self.style.ITEM = self.style.HTTP_INFO\n disconnect_objectapp_signals()",
"def __init__(self, font='mediumbold'):\n\tself.set_font(font)",
"def __init__(self):\r\n self.label = \"Bulk Layout Text Replace\"\r\n self.alias = \" Jake's Toolbox Alias Property True\"\r\n self.description = \"\"\r\n self.canRunInBackground = False",
"def __post_init__(self):\n super().__post_init__()",
"def __init__(self):\n super(Command, self).__init__()\n self.style.TITLE = self.style.SQL_FIELD\n self.style.STEP = self.style.SQL_COLTYPE\n self.style.ITEM = self.style.HTTP_INFO\n disconnect_gstudio_signals()",
"def after_parsing(self):",
"def __init__(self, as_text=False, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.as_text = as_text",
"def after_init(self):\n if self.options.format.appended:\n self.error_format = self.options.format.appended[0]",
"def on_origEdit_textChanged(self):\n self.__updatePronounceButtons()\n self.__updateClearButton()\n self.__updateTranslateButton()",
"def after_init(self) -> None:\n if self.options.format.lower() != \"default_notebook\":\n self.error_format = self.options.format\n if not hasattr(self, \"color\"):\n self.color = True",
"def afterInit(self):",
"def post_init(self, msg='hello'):\n print(\"post init ! height=%s, color=%s, msg=%s\" % (self.height, self.color, msg))\n self.non_field_attr = msg",
"def __init__(self, name, time, text):\n pass",
"def init(self):",
"def init(self):",
"def __init__(self,txt=u'',unicodeEncoding='utf-8',verbose=False,tagID=0):\n # __document capture the document level structure\n # for each sentence and then put in the archives when the next sentence\n # is processed\n super(ConTextMarkup,self).__init__(__txt=None,__rawTxt=txt,\n __SCOPEUPDATED=False,__VERBOSE=verbose,\n __tagID=tagID,\n __unicodeEncoding=unicodeEncoding)\n self.__cleanText()",
"def __init__(self):\n\t\t# Setup fonts\n\t\tself.large_font = self._get_font(1,Annotator.THICK)\n\t\tself.large_font_outline = self._get_font(1,Annotator.THICK + Annotator.BORDER)\n\t\t\n\t\tself.small_font = self._get_font(0.5,Annotator.THIN)\n\t\tself.small_font_outline = self._get_font(0.5,Annotator.THIN + Annotator.BORDER)\n\t\t\n\t\t# Text colour\n\t\tself.colour = Annotator.COLOUR_BUSY\n\t\t\n\t\tself.forehead = (0,0,1,1)\n\t\tself.face = (0,0,1,1)",
"def onInit(self):\n pass",
"def _afterInit(self):\n pass",
"def __init__(self, **kwargs):\n # We set it to True so that starting empty lines are\n # not counting as separators\n self.last_line_was_empty = True",
"def _post_init(self) -> None:\n return",
"def _init(self):",
"def update_editor ( self ):\n super( SimpleFontEditor, self ).update_editor()\n set_font( self )",
"def __init__(self, text=\"\", widget=None):\n self._label_text = text\n self._widget = widget\n self._widget.on_change = self._update\n super().__init__(text=f\"{text} {widget.value}\")",
"def initialize(self):",
"def initialize(self):",
"def initialize(self):",
"def initialize(self):",
"def initialize(self): \r\n pass",
"def init_widget(self):",
"def __init__(self):\n ## Global initialization\n self.default_initialization()\n ## Initial function set\n self.selfdriven = False\n self._format_default_functions()\n ## Check descriptormodel\n self._assert_correctness()",
"def __init__(self):\n self.content = \"\"",
"def setInitDefault(self, editText):\n if editText in DateFormat.dateStampStrings:\n self.initDefault = DateFormat.dateStampStrings[0]\n else:\n TextFormat.setInitDefault(self, editText)",
"def initWidgets(self):\n self.loctext.setText(\"{0:g}\".format(self.loc))\n self.scaletext.setText(\"{0:g}\".format(self.scale))",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def initDocTagText(self):\n self.doc, self.tag, self.text = Doc().tagtext()",
"def __init__(\n self,\n type,\n text):\n self.type = type\n self.text = text",
"def _init(self):\n pass",
"def _initialize(self):\n \n self.view.lineEdit_3.setText(\"C,H,N,O,P,S\")\n self.view.spin_hit.setValue(20)\n self.view.lineEdit_2.setValue(10.)\n self.view.checkBox_8.setChecked(True)",
"def format(self):\n ...",
"def init(self) -> None:",
"def update_editor ( self ):\n super( TextFontEditor, self ).update_editor()\n set_font( self )",
"def __init__(self, msg='hello'):\n print(\"post init ! height=%s, color=%s, msg=%s\" % (self.height, self.color, msg))\n self.non_field_attr = msg",
"def __init__(self):\n\t\tprint(\"Class initilised\")",
"def __init__(self, text='', **kwargs):\n Control.__init__(self, text=text, **kwargs)",
"def on_transEdit_textChanged(self):\n self.__updatePronounceButtons()\n self.__updateClearButton()",
"def __init__(self, text, idx):\n self.text = text\n self.idx = idx",
"def __init__(self):\n self.update_state()",
"def set_initial_values(self):\n #Stores each line of the text file in a list\n self.text = []\n \n #Scrolling distance\n self.scroll = 0\n\n #Zooming level (font size) \n self.zoom = 12\n\n #Factor by which is decrement self.zoom\n self.factor = 0\n\n #Number of tabs spaces before a line\n self.indent = 0\n\n #Flag to only set up pango descriptions only once \n self.set_pc = 1\n\n #list of indetation level of all lines\n self.tab_index = []\n\n #Total line count\n self.line_count = 0\n\n #line number of line rendered off top of window \n self.min_text = 0\n #line number of line rendered off bottom of window \n self.max_text = 50\n\n #y position for cairo for the text at the top\n self.min_cairo = 20\n\n #y position for text at bottom\n self.max_cairo = 20\n\n #x positiong for indented text\n self.tab_cairo = 20",
"def __init__(self):\n fmt = \"%(message)s\"\n super().__init__(fmt=fmt)\n\n self.baseline = None\n self.cut = None\n self.manual_push = 0",
"def setInitDefault(self, editText):\n if editText in TimeFormat.timeStampStrings:\n self.initDefault = TimeFormat.timeStampStrings[0]\n else:\n TextFormat.setInitDefault(self, editText)",
"def __init__(self, text):\n self.text = text\n self.letters = [letters[c] for c in self.text]\n self.width = sum(let.width + 1 for let in self.letters)\n self._offset = width\n self.is_done = False",
"def __init__(self, text=None, settings=None, style='General', language='en'):\n\n self._text = None\n self._settings = None\n self._style = None\n self._language = None\n\n self.text = text\n self.settings = settings\n self.style = style\n self.language = language",
"def init(self) -> None:\n self.started = False\n self.lines = []\n self.text = ''\n self.graphics = ''\n self.ids = {}\n self.first_line_added = False\n\n self.used_fonts = set()\n self.current_line_used_fonts = set()\n self.current_height = 0\n self.lines = []\n\n line_width = self.width - (self.indent if self.is_first_line else 0)\n self.current_line = PDFTextLine(\n self.fonts, line_width, self.text_align, self.line_height\n )\n\n self.last_indent = 0\n self.last_state = self.last_factor = self.last_fill = None\n self.last_color = self.last_stroke_width = None\n\n self.y_ = 0",
"def _settext(self, textEntered):\n if textEntered.strip() == '':\n textEntered=self.data['initialtext']\n self.entry.enterText(textEntered)\n else:\n if callable(self.data['callback']): self.data['callback'](textEntered)\n if self.data['autoexit'] and callable(self.data['exit']):\n # NOTE not safe to call here user callback...\n taskMgr.doMethodLater(.5, self.data['exit'], '_ntryxt')",
"def __init__(self, edit: QtWidgets.QTextEdit, out=None, color=None):\n self.edit = edit\n self.out = out\n self.color = color",
"def on_load(self):\n self.__init__()",
"def __init__():",
"def __init__(self) -> None:\n str.__init__(self)",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self._ansi_escape_codes = True",
"def do_init(self):\n\n pass",
"def initialize(self):\n\t\tpass",
"def run_init(self):\n InitEditor(self.root, self)",
"def __init(self):\n print(\"Welkam tu mobail lejen\")",
"def __init__(self, text, tag, start ,end):\n\n self.text = six.text_type(text)\n self.tag = copy.copy(tag)\n self.end = end\n self.start = start"
] | [
"0.7095915",
"0.70883477",
"0.6957401",
"0.6811701",
"0.6811701",
"0.6811701",
"0.6811701",
"0.6811701",
"0.6811701",
"0.6811701",
"0.6811701",
"0.6811701",
"0.6801035",
"0.67764556",
"0.67764556",
"0.6772573",
"0.67218834",
"0.6665987",
"0.6530844",
"0.6495981",
"0.6490198",
"0.6401653",
"0.6355695",
"0.63224435",
"0.627716",
"0.627716",
"0.62600374",
"0.6241324",
"0.6241043",
"0.6223984",
"0.6216441",
"0.6214059",
"0.62072545",
"0.6179023",
"0.61773074",
"0.6165903",
"0.6150355",
"0.61494476",
"0.6145963",
"0.6123563",
"0.6106276",
"0.6106276",
"0.61052555",
"0.6075407",
"0.606871",
"0.60595924",
"0.6050179",
"0.6039118",
"0.6025508",
"0.60182106",
"0.60180503",
"0.5996569",
"0.5996569",
"0.5996569",
"0.5996569",
"0.5993615",
"0.5956698",
"0.59549457",
"0.59410423",
"0.5936671",
"0.5926797",
"0.59250134",
"0.59250134",
"0.59250134",
"0.59250134",
"0.59250134",
"0.59250134",
"0.59250134",
"0.59250134",
"0.5922803",
"0.59159535",
"0.59074825",
"0.59036523",
"0.59019417",
"0.5898051",
"0.58926487",
"0.5887501",
"0.5887218",
"0.58803314",
"0.5877826",
"0.5868464",
"0.58638364",
"0.5862526",
"0.58605254",
"0.5853759",
"0.5833662",
"0.58296865",
"0.5820315",
"0.5815491",
"0.58068454",
"0.579537",
"0.57909584",
"0.57830495",
"0.5776756",
"0.5769101",
"0.5765869",
"0.5761965",
"0.5755533",
"0.57552737"
] | 0.6494592 | 21 |
Return formatted text for this field | def outputText(self, item, titleMode, internal=False):
if self.useFileInfo:
item = globalref.docRef.fileInfoItem
altText = ''
if self.linkAltField:
field = item.nodeFormat().findField(self.linkAltField)
if field:
altText = field.outputText(item, titleMode, internal)
storedText = item.data.get(self.name, '')
if storedText:
return self.formatOutput(storedText, titleMode, altText, internal)
return '' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def formatted(self) -> str:\r\n ...",
"def format(self) -> str:",
"def text(self) -> str:",
"def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d",
"def get_text(self):\n inp = \" \"\n if self.link_id:\n inp += \"LINK \" + self.link_id\n inp += self.status + ' '\n if self.node_id:\n inp += \"NODE \" + self.node_id + ' '\n if self.value:\n inp += self.control_type.name + ' ' + str(self.value) + ' '\n if self.time:\n inp += self.time + ' '\n if self.clock_time:\n inp += self.clock_time + ' '\n # TODO: research correct formatting of time, clock_time options\n return inp",
"def format(self) -> str:\n return self._format",
"def format(self) -> str:\n return self._format",
"def getText(self):\r\n return \"\"",
"def value_as_text(self):\n property_name = \"_%s_as_text\" % self.attribute.type\n return getattr(self, property_name, self.value)",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def getFormattedText(self):\r\n h = \"00\"\r\n m = \"00\"\r\n s = \"00\"\r\n if(self.seconds < 10):\r\n s = \"0\" + str(self.seconds)\r\n else:\r\n s = str(self.seconds)\r\n\r\n if(self.minutes < 10):\r\n m = \"0\" + str(self.minutes)\r\n else:\r\n m = str(self.minutes)\r\n\r\n if(self.hours < 10):\r\n h = \"0\" + str(self.hours)\r\n else:\r\n h = str(self.hours)\r\n\r\n return h + \":\" + m + \":\" + s",
"def get_text(self):\n return self.rule_id + '\\t' + self.rule_text",
"def get_text(self):\n return self.get_property('text')",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def _get_FIELD_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n template = ''\n template += '{:d}' if field.decimals == 0 else '{:.%sf}' % field.decimals\n template += ' ' if field.spaced_display else ''\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def TEXT(number, format_type):\n raise NotImplementedError()",
"def format(self) -> str:\n return pulumi.get(self, \"format\")",
"def text(self) -> str:\n return self.__text",
"def show(self) -> str:\n return f'[{self.font}]{self.text}[{self.font}]' if self.font else self.text",
"def formatName(self):\r\n return self.title.getVal() + \" \" + self.first.getVal() + \" \" + self.last.getVal()",
"def getText(self):\n return(' '.join(map(lambda x:x.text,self.getNested())))",
"def get_text(self) -> str:\n return self.text",
"def text(self):\n return self.__text",
"def getText(self):",
"def get_text(self):\n return self.text",
"def text(self):\n return ''",
"def get_text(self) -> str:\n return self._text",
"def get_formatted_text(self, n_cols):",
"def text(self) -> str:\n return self._impl.get_text()",
"def format_item_display(self, obj):\n return u\"%s - %s\" % (escape(obj.nombre),obj.rfc)",
"def text(self) -> LocalizedString:\n return self._text",
"def as_text(self) -> str:\n txt = ''\n with self._th_lock:\n # purge expired value (reach ttl_s) from values dict\n purge_l = []\n for key, (_value, _timestamp_ms, expire_at) in self._values_d.items():\n if expire_at and time.monotonic() > expire_at:\n purge_l.append(key)\n for rm_key in purge_l:\n self._values_d.pop(rm_key)\n # if any value exists, format an exposition message\n if self._values_d:\n # add a comment line if defined\n if self.comment:\n # apply escapes to comment\n esc_comment = str(self.comment)\n for rep_args in [('\\\\', '\\\\\\\\'), ('\\n', '\\\\n')]:\n esc_comment = esc_comment.replace(*rep_args)\n txt += f'# HELP {self.name} {esc_comment}\\n'\n # add a type line if defined\n if self.type is not MetricType.UNTYPED:\n txt += f'# TYPE {self.name} {self.type.value}\\n'\n # add every \"name{labels} value [timestamp]\" for the metric\n for lbl_id_str, (value, ts, _expire_at) in self._values_d.items():\n if self._type is MetricType.HISTOGRAM:\n txt += self._data2txt_histogram(lbl_id_str, value)\n elif self._type is MetricType.SUMMARY:\n txt += self._data2txt_summary(lbl_id_str, value)\n else:\n txt += self._data2txt_default(lbl_id_str, value, ts)\n return txt",
"def __str__(self):\n txt = \"%s:\\n\" % self.name\n txt += \" Charge: %.4f\\n\" % self.charge\n txt += \" Radius: %.4f\" % self.radius\n return txt",
"def text(self):\n if self.is_root:\n return ''\n elif self.is_comment:\n return self.__value\n elif self.is_flag:\n if self.__value:\n return '[{0}]'.format(self.name)\n else:\n return '!{0}!'.format(self.name)\n else:\n return '[{0}:{1}]'.format(self.name, self.value)",
"def __repr__(self) -> str:\n return f\"{self.text}\"",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def text(self) -> str:\n return self._text",
"def format(self):\n return self._format",
"def get_formatter(self, **kwargs):\n config = dict([\n (attr, getattr(self, attr))\n for attr in [\n \"include_sign\",\n \"group_with_commas\",\n \"num_decimal_places\",\n ]\n ])\n config.update(kwargs)\n return \"\".join([\n \"{\",\n config.get(\"field_name\", \"\"),\n \":\",\n \"+\" if config[\"include_sign\"] else \"\",\n \",\" if config[\"group_with_commas\"] else \"\",\n \".\", str(config[\"num_decimal_places\"]), \"f\",\n \"}\",\n ])",
"def text(self):\n\n if self.status.full_text:\n return self.status.full_text\n elif self.status.text:\n return self.text\n else:\n return MISSING",
"def to_str(self):\n return self.template.format(\n text_color=self.color.to_str(),\n font_type=self.font_type.to_str(),\n font_weight=self.font_weight.to_str(),\n font_size=self.font_size.to_str()\n )",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def text(self):\n return self.name, self.fontfile, self.fontsize",
"def plain_text(self) -> str:\n return pulumi.get(self, \"plain_text\")",
"def _get_FIELD_humanized_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n power = max([i for i in utils.POWERS if value // i > 0 and i > 1])\n value /= power\n template = ''\n template += '{:.%sf}' % field.humanized_decimals\n template += ' ' if field.spaced_display else ''\n template += utils.POWERS[power]\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def format( self ) :\n\n return( self.__format )",
"def __repr__(self) -> str:\r\n\r\n saida = \"Format: \"\r\n x = self.getformat()\r\n for _ in range(len(x)):\r\n saida = f\"{saida}{x[_]}\"\r\n if _ < len(x)-1:\r\n saida += \", \"\r\n saida += \"\\n\"\r\n return saida",
"def text(self):\n return self.label.text()",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title} :\" + s\n\n return s",
"def format_value(text):\n return text.encode('utf8').replace('\\n', ' ').replace('\\r', ' ')",
"def get_text(self):\n logging.getLogger(__name__).info(\"Element text: {}\\nby = {}\\nvalue = {}\".format(\n self.driver.find_element(self.by, self.value).text, self.by, self.value))\n return self.driver.find_element(self.by, self.value).text",
"def get_instance_text(instance):\n values = []\n for fieldname in registry[instance.__class__]:\n values.extend(resolve_field_value(\n [instance], fieldname.split('__')))\n return u' '.join(values)",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n return text",
"def text(self, v=''):\n return str(v)",
"def _to_text(self, value):\n raise NotImplementedError",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def __str__(self):\n return self.fmt.format(*self.args, **self.kwargs)",
"def field_display(obj, field):\n return get_field_value(obj, field)",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n if hasattr(self,'label'):\n return str(self.label.text())\n else:\n return self.key",
"def __str__(self):\n return self.format()",
"def text(self):\n parts = [(\"%s\" if isinstance(p, Insert) else p) for p in self.parts]\n parts = [(\"%%\" if p == \"%\" else p) for p in parts] # escape percent\n return \"\".join(parts)",
"def Text(self):\n return self._text",
"def __str__(self):\n struct_repr = \", \".join([\n \"type: \" + str(self.type),\n \"text: \" + str(self.text)\n ])\n\n return f\"StatusText: [{struct_repr}]\"",
"def GetText(self):\r\n \r\n return self._text",
"def getText(self):\n return self.text",
"def getText(self):\n return self.text",
"def to_text(self, floatformat: str = \".6f\") -> str:\n return self.val.to_text(floatformat)",
"def __str__(self):\n #Format data from default fields\n template = \"{number:4}|{rep:4}|{time:5}{priority:+2}|\" \\\n \"{record_type:8}|{name:17}\"\n default_fields = template.format(**self)\n \n #Format data from custom fields\n custom_field_list = []\n for label in self.custom_labels:\n custom_field_list.append(\"|{:17}:{!s:<5}\".format(label,\n self[label]))\n custom_fields = \"\".join(custom_field_list)\n \n return default_fields + custom_fields",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def __str__(self):\n\t\treturn self.text",
"def outputText(self, item, titleMode, internal=False):\n field = None\n while not field:\n item = item.parent\n if item:\n field = item.nodeFormat().findField(self.name)\n else:\n return ''\n return field.outputText(item, titleMode, internal)",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def text(self):\n # type: () -> str\n return self._text",
"def get_text(self):",
"def text(self):\n return self.full_text",
"def __str__(self):\n return \"%s\\n\" % self.text + \" \" * self.col + \"^\"",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% on line \" + self.line\n return text",
"def _entity_as_text(self):\n return str(self.value)",
"def format(self, record):\n message = record.getMessage()\n asctime = self.formatTime(record, self.datefmt)\n name = yellow(record.name)\n\n s = \"%(timestamp)s %(levelname)s %(name)s \" % {\n \"timestamp\": green(\"%s,%03d\" % (asctime, record.msecs), bold=True),\n \"levelname\": self.LEVELS[record.levelname],\n \"name\": name,\n }\n\n if \"\\n\" in message:\n indent_length = len(re_color_codes.sub(\"\", s))\n message = message.replace(\"\\n\", \"\\n\" + \" \" * indent_length)\n\n s += message\n return s",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n text += \" [\" + self.file_name + \"]\"\n return text",
"def text(self):\n\t\treturn ' '.join([self.write_components[x] for x in self.write_components])"
] | [
"0.75734353",
"0.7379207",
"0.7205578",
"0.68481845",
"0.67844886",
"0.67808527",
"0.67703915",
"0.67703915",
"0.67655444",
"0.6745665",
"0.6687435",
"0.66469747",
"0.6644202",
"0.66413474",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65741307",
"0.6567402",
"0.6558896",
"0.6555393",
"0.655068",
"0.6547239",
"0.6544499",
"0.6535529",
"0.6517592",
"0.6480058",
"0.6460372",
"0.6459885",
"0.64553267",
"0.6446324",
"0.6445358",
"0.64076585",
"0.6392125",
"0.6380471",
"0.6367286",
"0.6361198",
"0.6353135",
"0.6348966",
"0.63427186",
"0.6320017",
"0.6318294",
"0.63155836",
"0.6308729",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.62890583",
"0.62872475",
"0.6284665",
"0.6283615",
"0.62564605",
"0.62539566",
"0.6250457",
"0.6246106",
"0.6245501",
"0.6238378",
"0.62316114",
"0.62306285",
"0.6227439",
"0.6216431",
"0.6214085",
"0.6207841",
"0.6207841",
"0.62025124",
"0.618629",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6184535",
"0.6183745",
"0.6183568",
"0.61735356",
"0.61702335",
"0.61699766",
"0.6169714",
"0.6169714",
"0.6168279",
"0.616314",
"0.6158217",
"0.6158217",
"0.6158217",
"0.6156037",
"0.613794",
"0.6137155",
"0.61364275",
"0.6114419",
"0.61141664",
"0.6103432",
"0.61010504",
"0.6098953",
"0.609143",
"0.60909635",
"0.60876095"
] | 0.0 | -1 |
Return formatted text, properly escaped and with a link reference if not in titleMode | def formatOutput(self, storedText, titleMode, altText='', internal=False):
if titleMode:
return TextFormat.formatOutput(self, storedText, titleMode,
internal)
paths = storedText.split('\n')
results = []
for url in paths:
path = url
if not URLFormat.hasMethodRe.match(path):
path = u'%s%s' % (self.URLMethod, path)
path = u'<a href="%s">%s</a>' % (escape(path, treedoc.escDict),
altText or url)
results.append(TextFormat.formatOutput(self, path, titleMode,
internal))
return u'<br />'.join(results) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n altText = ''\n if self.linkAltField:\n field = item.nodeFormat().findField(self.linkAltField)\n if field:\n altText = field.outputText(item, titleMode, internal)\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, altText, internal)\n return ''",
"def test_link_title(self):\n comment = \"[link](http://foo.com \\\"bar\\\")\"\n comment_md = Markdown().render(comment)\n self.assertEqual(comment_md, '<p><a rel=\"nofollow\" href=\"http://foo.com\" title=\"bar\">link</a></p>')",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def format_url(self, url, text):\r\n return u'<a href=\"%s\">%s</a>' % (escape(url), text)",
"def link(self, link, title, text):\n link = escape_link(link)\n return [MdStyleInstructionLink(link)] + text",
"def visit_title_reference(self, node):\n self.body.append('\\\\emph{\\\\textbf{')",
"def link(self):\n return f\"[{self.numbered_title}]({self.html_url})\"",
"def __html__(self) -> str:\n components = [\n self.attributee_html,\n f'\"{self.linked_title}\"',\n self.date.string if self.date else '',\n ]\n return self.components_to_html(components)",
"def test_link_title_without_no_follow(self):\n comment = \"[link](http://foo.com \\\"bar\\\")\"\n comment_md = Markdown(no_follow=False).render(comment)\n self.assertEqual(comment_md, '<p><a href=\"http://foo.com\" title=\"bar\">link</a></p>')",
"def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode or not internal:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n # add prefix/suffix within the executable path:\n url = TextFormat.formatOutput(self, url, titleMode, internal)\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n results.append(u'<a href=\"%s\">%s</a>' %\n (escape(path, treedoc.escDict), altText or url))\n return u'<br />'.join(results)",
"def content(self, uid, text):\n\n if uid and isinstance(uid, str) and uid.lower().startswith(\"http\"):\n return f\"<a href='{uid}' rel='noopener noreferrer' target='blank'>{text}</a>\"\n\n return text",
"def linkified_description(self):\n links = []\n def linkify(matchobj, links=links):\n if '|' in matchobj.group(1):\n url = matchobj.group(1).split('|')\n link = format_html('<a href=\"{0}\" target=\"_blank\">{1}</a>', url[0], url[1])\n else:\n link = format_html('<a href=\"{0}\" target=\"_blank\">{1}</a>', self.url, matchobj.group(1))\n links.append(link)\n return '{%d}' % (len(links) - 1)\n\n fmt = re.sub(r'\\[\\[([^\\]]+)\\]\\]', linkify, self.description)\n return format_html(fmt, *links)",
"def get_text(downgrade_titles=False):",
"def convert_text_to_rouge_format(text, title=\"dummy title\"):\n sentences = text.split(\"\\n\")\n sent_elems = [\n \"<a name=\\\"{i}\\\">[{i}]</a> <a href=\\\"#{i}\\\" id={i}>\"\n \"{text}</a>\".format(i=i, text=sent)\n for i, sent in enumerate(sentences, start=1) if sent != '']\n html = \"\"\"<html>\n<head>\n<title>{title}</title>\n</head>\n<body bgcolor=\"white\">\n{elems}\n</body>\n</html>\"\"\".format(title=title, elems=\"\\n\".join(sent_elems))\n\n return html",
"def md_link(link_text, link_target):\n return '[%s](%s)' % (md_escape(link_text, characters=']'),\n md_escape(link_target, characters=')'))",
"def formatOutput(self, storedText, titleMode, internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = ['<img src=\"%s\">' % escape(url, treedoc.escDict) for url\n in paths]\n return u'<br />'.join(results)",
"def headline(self):\r\n return '%s%s %s%s' % (BLUE, self.title,\r\n NORMAL, self.link)",
"def link_html(text: str, href: str) -> str:\n return '<a href=\"{}\">{}</a>'.format(href, text)",
"def get_title(text, uuid=None):\n if uuid is not None:\n text += get_provenance_link(uuid)\n title = pn.Row(pn.pane.HTML('<h2>{}</h2>'.format(text)), align='start')\n\n return title",
"def title(text, level=0):\n return '\\n' + text + '\\n' + '=-~_#%^' [level] * len(text) + '\\n\\n'",
"def html_title(title):\n return '<center><h1>%s</h1></center>' % (title)",
"def format_header(self, text: str, anchor: Optional[str] = None) -> str:",
"def print_with_title(title, content, before='', after='', hl='='):\n cont_maxlen = max(len(s) for s in content.split('\\n'))\n hl_len = max(cont_maxlen, len(title))\n print('{}{}\\n{}\\n{}{}'.format(before, title, hl * hl_len, content, after))",
"def format_title(self, data):\n return data",
"def formatted_reference(html):\n converter = html2text.HTML2Text()\n converter.ignore_links = True\n converter.body_width = 0\n\n text = converter.handle(html)\n text = re.sub(' +$', '', text, flags=re.MULTILINE)\n text = re.sub(r'\\n\\n+', '\\n\\n', text, flags=re.MULTILINE)\n return text",
"def PROPER(text):\n return text.title()",
"def link(text, link_func):\n def object_formatter(v, c, m, p):\n \"\"\"Format object view link.\"\"\"\n return Markup('<a href=\"{0}\">{1}</a>'.format(\n link_func(m), text))\n return object_formatter",
"def links_to_text(self):\r\n self.parser.stripTags(self.get_top_node(), 'a')",
"def getStoryTitle(self, source):\n titleStart = source.find('>', source.find('>')+1) + 1\n titleEnd = source.find('</a>')\n title = source[titleStart:titleEnd]\n title = title.lstrip() # Strip trailing whitespace characters.\n return title",
"def editModeHeading(text):\n return u'<p style=\"editModeHeading\">%s</p>' % text",
"def formatOutput(self, storedText, titleMode, internal=False):\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def get_link_description(self):\n desc = super().get_link_description()\n desc['title'] = self.title\n return desc",
"def title(self, string):\n return self.bold(string)",
"def format_tag(self, tag, text):\r\n return u'<a href=\"http://{domain}/hashtag/{tag}\" data-tag=\"{tag}\">#{text}</a>'.format(\r\n **dict(domain=self.domain, tag=urllib.quote(text.encode('utf-8')), text=text))\r\n\r\n #return u'<a href=\"http://%s/hashtag/%s\" data-tag=\"\">%s%s</a>' \\\r\n # % (self.domain, , tag, text)\r",
"def html_title(self, title=None):\r\n if title is None:\r\n return \"<title>PyBossa</title>\"\r\n else:\r\n return \"<title>PyBossa · %s</title>\" % title",
"def gen_title_rst(txt):\n # Just add a few useful directives\n txt = \".. highlight:: cmake\\n\\n\" + txt\n return txt",
"def escape_if_needed(text, options):\n if hasattr(text, '__html__'):\n # Text has escape itself:\n return to_string(text.__html__())\n if need_to_escape(options):\n return escape(to_string(text))\n return to_string(text)",
"def __html__(self) -> str:\n components = [\n self.attributee_html,\n self.linked_title if self.title else 'untitled document',\n self.date.string if self.date else '',\n self.descriptive_phrase,\n f'archived in {self.collection}' if self.collection else '',\n ]\n return self.components_to_html(components)",
"def _get_title_tag(self, item):\n tag = '<{heading}><a href=\"{href}\">{title}</a></{heading}>'\n if self._field_is_visible(\"title\"):\n tile_conf = self.get_tile_configuration()\n title_conf = tile_conf.get(\"title\", None)\n if title_conf:\n heading = title_conf.get(\"htmltag\", \"h2\")\n href = item.absolute_url()\n title = item.Title()\n return tag.format(heading=heading, href=href, title=title)",
"def slack_link(url, text=\"\"):\n if text:\n return \"<%s|%s>\" % (url, text)\n\n else:\n return \"<%s>\" % url",
"def get_title():",
"def get_HTML_box(self, url):\n who = self.getShortAuthor()\n if self.comments is None:\n title = \"\"\n else:\n title = html.escape(self.comments)\n return '<a href=\"%s\" title=\"%s\">%s</a>' % (url,\n title,\n html.escape(who))",
"def object_formatter(v, c, m, p):\n return Markup('<a href=\"{0}\">{1}</a>'.format(\n link_func(m), text))",
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, internal)\n return ''",
"def ref_to_link(txt):\n text = txt.group(1) # because it was a match in a regular expression\n\n thecite, everythingelse = first_bracketed_string(text)\n thecite = thecite[1:-1] # strip curly brackets\n thecite = thecite.replace(\"\\\\\",\"\") # \\href --> href\n\n refs = thecite.split(\",\")\n ans = \"\"\n\n # print \"refs\",refs\n\n for ref in refs:\n ref = ref.strip() # because \\cite{A, B, C,D} can have spaces\n this_link = \"\"\n if ref.startswith(\"href\"):\n the_link = re.sub(r\".*{([^}]+)}{.*\", r\"\\1\", ref)\n click_on = re.sub(r\".*}{([^}]+)}\\s*\", r\"\\1\", ref)\n this_link = '{{ LINK_EXT(\"' + click_on + '\",\"' + the_link + '\") | safe}}'\n elif ref.startswith(\"doi\"):\n ref = ref.replace(\":\",\"\") # could be doi:: or doi: or doi\n the_doi = ref[3:] # remove the \"doi\"\n this_link = '{{ LINK_EXT(\"' + the_doi + '\",\"https://doi.org/' + the_doi + '\")| safe }}'\n elif ref.lower().startswith(\"mr\"):\n ref = ref.replace(\":\",\"\")\n the_mr = ref[2:] # remove the \"MR\"\n this_link = '{{ LINK_EXT(\"' + 'MR:' + the_mr + '\", '\n this_link += '\"http://www.ams.org/mathscinet/search/publdoc.html?pg1=MR&s1='\n this_link += the_mr + '\") | safe}}'\n elif ref.lower().startswith(\"arxiv\"):\n ref = ref.replace(\":\",\"\")\n the_arx = ref[5:] # remove the \"arXiv\"\n this_link = '{{ LINK_EXT(\"' + 'arXiv:' + the_arx + '\", '\n this_link += '\"http://arxiv.org/abs/'\n this_link += the_arx + '\")| safe}}'\n\n\n if this_link:\n if ans:\n ans += \", \"\n ans += this_link\n\n return '[' + ans + ']' + everythingelse",
"def get_url(self, filename, query_para=None, **url_args):\r\n from uliweb.core.html import Tag\r\n \r\n title = url_args.pop('title', filename)\r\n text = url_args.pop('text', title)\r\n query_para = query_para or {}\r\n return str(Tag('a', title, href=self.get_href(filename, **query_para), **url_args))",
"def markdown_item(title, url):\n print('* [{0}]({1})'.format(\n markdown_escape(title),\n markdown_escape(url),\n ))",
"def complete_alt_title(self, obj):\n return str(obj)",
"def generate_title(self, title=None):\n if title is None:\n title = self.header.get('title', self.title)\n\n title = self.generate(title)\n title = title.replace('<p>', '').replace('</p>', '')\n # no trailing newlines\n title = re.sub(r'\\n+', ' ', title).rstrip()\n return title",
"def __str__(self) -> str:\n return textwrap.wrap(self.title, _POST_TITLE_MAX_LENGTH // 4)[0]",
"def link_breaker(text):\n res = ''\n state = 0\n for char in text:\n if state == 0:\n if char == 'h':\n state = 1\n else:\n res += char\n elif state == 1:\n if char == 't':\n state = 2\n else:\n res += 'h' + char\n state = 0\n elif state == 2:\n if char == 't':\n state = 3\n else:\n res += 'ht' + char\n state = 0\n elif state == 3:\n if char == 'p':\n state = 4\n else:\n res += 'htt' + char\n state = 0\n elif state == 4:\n if char == ' ':\n state = 0\n res += 'ext_link '\n return res",
"def book_title(book_text):\n search = re.search(\"Title:(.*)\", book_text)\n title = search.group(1).replace(\"\\r\", \" \").strip()\n return title",
"def helptext(self):\n return \"\"",
"def title(string):\n print(\"{}\\n{}\\n\".format(bold(string), underline(string, \"=\")))",
"def links(self, text):\n\n # For some reason, the part of the regex below that matches the url\n # does not match a trailing parenthesis. It gets caught by tail, and\n # we check later to see if it should be included as part of the url.\n pattern = r'''\n (?P<pre>^|(?<=[\\s>.\\(\\|])|[{[])? # leading text\n \" # opening quote\n (?P<atts>%s) # block attributes\n (?P<text>[^\"]+?) # link text\n \\s? # optional space\n (?:\\((?P<title>[^)]+?)\\)(?=\"))? # optional title\n \": # closing quote, colon\n (?P<url>%s+?) # URL\n (?P<slash>\\/)? # slash\n (?P<post>[^\\w\\/]*?) # trailing text\n (?P<tail>[\\]})]|(?=\\s|$|\\|)) # tail\n ''' % (self.c, self.urlch)\n\n text = re.compile(pattern, re.X | re.U).sub(self.fLink, text)\n\n return text",
"def get_title_repr(self) -> str:\n try:\n return Title[self.title].value\n except (KeyError, ValueError):\n pass",
"def __str__(self):\n return '<a href=\"%s\" class=\"%s\" %s>%s</a>' % (self.url, self.cssclass, self.options, self.text)",
"def fmt(e):\n name = str(e.label.first() if hasattr(e, 'label') and e.label else e)\n if re.match(r'^[a-z]+://', name):\n return link.format(name=name, url=name)\n if hasattr(e, 'label') and e.label:\n name = e.label.first()\n url = name if re.match(r'^[a-z]+://', name) else '#' + name\n return link.format(name=name, url=url)\n elif re.match(r'^[a-z]+://', str(e)):\n return link.format(name=e, url=e)\n else:\n return str(e).replace('owl.', 'owl:')",
"def clean_title_text(title: str, anchor_characters: str | None = None) -> str:\n if anchor_characters is None:\n anchor_characters = ANCHOR_CHARACTERS\n return title.strip(anchor_characters).replace(\"\\xa0\", \" \").strip()",
"def link_to_modal(link_text, index, autoescape=True): # pylint: disable=unused-argument\n link = (\n '<a'\n ' href=\"#!\"'\n ' class=\"text-underline view-course-details-link\"'\n ' id=\"view-course-details-link-{index}\"'\n '>{link_text}</a>'\n ).format(\n index=index,\n link_text=link_text,\n )\n return mark_safe(link)",
"def fix_document(key, value, _format, _meta):\n if key == \"Link\":\n url = value[2][0]\n if url.startswith(\"user-manual\") or url.startswith(\"developers-guide\"):\n # Return the link text\n return value[1]\n # Reformat the text inside block quotes\n elif key == \"BlockQuote\":\n try:\n first_string = value[0][\"c\"][0][\"c\"]\n if first_string == \"[!NOTE]\":\n value[0][\"c\"][0] = Strong([Str(\"Note:\")])\n return BlockQuote(value)\n elif first_string == \"[!INFO]\":\n value[0][\"c\"][0] = Strong([Str(\"Info:\")])\n return BlockQuote(value)\n elif first_string == \"[!TIP]\":\n value[0][\"c\"][0] = Strong([Str(\"Tip:\")])\n return BlockQuote(value)\n elif first_string == \"[!WARNING]\":\n value[0][\"c\"][0] = Strong([Str(\"Warning:\")])\n return BlockQuote(value)\n elif first_string == \"[!ATTENTION]\":\n value[0][\"c\"][0] = Strong([Str(\"Attention:\")])\n return BlockQuote(value)\n except Exception:\n return\n return",
"def html_link(self):\n if self.id:\n unescaped_url = f'/themes/{self.name or \"\"}--{self.id}'\n return mark_safe(f'<a href=\"{self.url_path}\" target=\"_blank\">{unescaped_url}</a>')\n else:\n return 'Pas encore live'",
"def outputText(self, item, titleMode, internal=False):\n field = None\n while not field:\n item = item.parent\n if item:\n field = item.nodeFormat().findField(self.name)\n else:\n return ''\n return field.outputText(item, titleMode, internal)",
"def make_main_title(self, end, end_center=False):\n main_title = r\"\\begin{center}\"\n if self.detector is not None:\n main_title += \"%s \"%self.detector\n if self.selection is not None:\n main_title += \"%s Event Selection \"%self.selection\n main_title += end\n if end_center:\n main_title += r\"\\end{center}\"\n return main_title",
"def emph_text(text):\n\n if use_color():\n return colorama.Style.BRIGHT + text + colorama.Style.RESET_ALL\n else:\n return text",
"def outputText(self, item, titleMode, internal=False):\n for num in range(self.parentLevel):\n item = item.parent\n if not item:\n return ''\n field = item.nodeFormat().findField(self.name)\n if not field:\n return ''\n return field.outputText(item, titleMode, internal)",
"def _inline(line):\n if len(line) == 0:\n return ''\n\n # Regexp of protocols supported in hyperlinks (should be protocols that\n # we can expect web browsers to support)\n protocols = \"https?|ftp|sftp|file|afs|nfs\"\n\n\n # Prepare usual links: prefix every \"www.\" with \"http://\"\n # unless there is a // before\n line = re.sub('(^|\\s|[^\\/])(www\\.)', '\\\\1http://\\\\2', line, re.I);\n\n # replace the @ sign with an HTML entity, if it is used within\n # an url (e.g. for pointers to mailing lists). This way, the\n # @ sign doesn't get mangled in the e-mail markup code\n # below. See bug #2689 on http://gna.org/ for reference.\n line = re.sub(\"([a-z]+://[^<>[:space:]]+)@\", \"\\\\1@\", line, re.I)\n\n # Prepare the markup for normal links, e.g. http://test.org, by\n # surrounding them with braces []\n # (& = begin of html entities, it means a end of string unless\n # it is & which itself is the entity for &)\n line = re.sub('(^|\\s|[^\\[])((' + protocols + '):\\/\\/(&|[^\\s&]+[a-z0-9\\/^])+)',\n '\\\\1[\\\\2]', line, re.I)\n\n # do a markup for mail links, e.g. info@support.org\n # (do not use utils_emails, this does extensive database\n # search on the string\n # and replace addresses in several fashion. Here we just want to make\n # a link). Make sure that 'cvs -d:pserver:anonymous@cvs.sv.gnu.org:/...'\n # is NOT replaced.\n line = re.sub(\"(^|\\s)([a-z0-9_+-.]+@([a-z0-9_+-]+\\.)+[a-z]+)(\\s|$)\",\n '\\\\1' + '<a href=\"mailto:\\\\2\">\\\\2</a>' + '\\\\4', line, re.I)\n\n # Links between items\n # FIXME: it should be i18n, but in a clever way, meaning that everytime\n # a form is submitted with such string, the string get converted in\n # english so we always get the links found without having a regexp\n # including every possible language.\n # Trackers URLs disabled until trackers are actually implemented :)\n #trackers = {\n # \"bugs?\" : \"bugs/?\",\n # \"support|sr\" : \"support/?\",\n # \"tasks?\" : \"task/?\",\n # \"patch\" : \"patch/?\",\n # # In this case, we make the link pointing to support, it wont matter,\n # # the download page is in every tracker and does not check if the tracker\n # # is actually used\n # \"files?\" : \"support/download.php?file_id=\",\n # }\n #for regexp,link in trackers:\n # # Allows only two white space between the string and the numeric id\n # # to avoid having too time consuming regexp. People just have to pay\n # # attention.\n # line = re.sub(\"(^|\\s|\\W)($regexp)\\s{0,2}#([0-9]+)\",\n # '\\1<em><a href=\"' + 'sys_home'\n # + link + '\\\\3\">\\\\2 #\\\\3</a></em>',\n # line, re.I)\n\n # add an internal link for comments\n line = re.sub('(comments?)\\s{0,2}#([0-9]+)',\n '<em><a href=\"#comment\\\\2\">\\\\1 #\\\\2</a></em>',\n line, re.I)\n\n # Add support for named hyperlinks, e.g.\n # [http://savane-forge.org/ Text] -> <a href=\"http://savane-forge.org/\">Text</a>\n line = re.sub(\n # find the opening brace '['\n '\\['\n # followed by the protocol, either http:// or https://\n + '((' + protocols + '):\\/\\/'\n # match any character except whitespace or the closing\n # brace ']' for the actual link\n + '[^\\s\\]]+)'\n # followed by at least one whitespace\n + '\\s+'\n # followed by any character (non-greedy) and the\n # next closing brace ']'\n + '(.+?)\\]',\n '<a href=\"\\\\1\">\\\\3</a>', line)\n\n # Add support for unnamed hyperlinks, e.g.\n # [http://savane-forge.org/] -> <a href=\"http://savane-forge.org/\">http://savane-forge.org/</a> \n line = re.sub(\n # find the opening brace '['\n '\\['\n # followed by the protocol, either http:// or https://\n # (FIXME: which protocol does it makes sense to support, which one\n # should we ignore?)\n + '((' + protocols + '):\\/\\/'\n # match any character except whitespace (non-greedy) for\n # the actual link, followed by the closing brace ']'\n + '[^\\s]+?)\\]',\n '<a href=\"\\\\1\">\\\\1</a>', line)\n\n # *word* -> <strong>word</strong>\n line = re.sub(\n # find an asterisk\n '\\*'\n # then one character (except a space or asterisk)\n + '([^* ]'\n # then (optionally) any character except asterisk\n + '[^*]*?)'\n # then an asterisk\n + '\\*',\n '<strong>\\\\1</strong>', line)\n\n # _word_ -> <em>word</em>\n line = re.sub(\n # allow for the pattern to start at the beginning of a line.\n # if it doesn't start there, the character before the slash\n # must be either whitespace or the closing brace '>', to\n # allow for nested html tags (e.g. <p>_markup_</p>).\n # Additionally, the opening brace may appear.\n # See bug #10571 on http://gna.org/ for reference.\n '(^|\\s+|>|\\()'\n # match the underscore\n + '_'\n # match any character (non-greedy)\n + '(.+?)'\n # match the ending underscore and either end of line or\n # a non-word character\n + '_(\\W|$)',\n '\\\\1<em>\\\\2</em>\\\\3',\n line)\n\n return line",
"def textual(title, ordering_field=None):\n def decorator(func):\n def wraps(self, obj):\n result = func(self, obj)\n return result if result else u'---'\n\n wraps.short_description = title\n wraps.allow_tags = True\n\n if ordering_field:\n wraps.admin_order_field = ordering_field\n\n return wraps\n return decorator",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def get_anchor_tag(self):\n return f\"<a href={self.get_absolute_url()}>{self.display_name}</a>\"",
"def detail_link(db_obj, text=None):\n\n def build_link(obj):\n name = str(obj) if text is None else text\n return _make_link(obj.detail_url(), name)\n\n return mark_safe(', '.join(map(build_link, as_list(db_obj))))",
"def to_markdown(self):\n s = \"[\" + self.label + \"]\"\n if self.is_reflink:\n s += \": \" + self.url\n else:\n s += \"(\" + self.url + \")\"\n return s",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def autoLink(self, text):\n\n pattern = re.compile(r\"\"\"\\b((?:https?://|www\\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}/)(?:[^\\s()<>]+|\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\))+(?:\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\)|[^\\s`!()\\[\\]{};:'\".,<>?«»“”‘’]))\"\"\",\n re.U | re.I)\n return pattern.sub(r'\"$\":\\1', text)",
"def rich(text):\n return full(text, False)",
"def wiki_link(text):\n return wiki_link_pattern.sub(get_link, text)",
"def show_title():\r\n complement = (\r\n '\\n __ ')\r\n title = ('\\n _______ _______________ ____ _______ __ ___ _ _______/ /_ ____ _____ ____ ____ ')\r\n title += ('\\n / ___/ / / / ___/ ___/ _ \\/ __ \\/ ___/ / / / / _ \\| |/_/ ___/ __ \\/ __ `/ __ \\/ __ `/ _ \\ ')\r\n title += ('\\n/ /__/ /_/ / / / / / __/ / / / /__/ /_/ / / __/> </ /__/ / / / /_/ / / / / /_/ / __/ ')\r\n title += ('\\n\\___/\\__,_/_/ /_/ \\___/_/ /_/\\___/\\__, / \\___/_/|_|\\___/_/ /_/\\__,_/_/ /_/\\__, /\\___/ ')\r\n title += ('\\n /____/ /____/ ')\r\n # Add Styles\r\n break_line = ('-' * len(complement) + \"\\n\") * 2\r\n print(\"{}\\n{}\\n{}\\n\".format(break_line, title, break_line))",
"def formatOutput(self, storedText, titleMode, internal=False):\n if storedText not in self.formatList:\n try:\n storedText = GenBoolean(storedText).boolStr(self.format)\n except GenBooleanError:\n storedText = _errorStr\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def group_title(self, group):\n group_title = group.getProperty('title')\n if self.short:\n splitted = group_title.split('(')\n if len(splitted) > 1:\n group_title = group_title.split('(')[-1][:-1]\n return html.escape(group_title)",
"def format_article_list(title, source, link):\n i = 0\n length = 120\n space = \" \"\n article_headline = \"| \" + title + \" - \" + source\n\n if len(article_headline) < length:\n for i in range(length - len(article_headline)):\n article_headline += space\n article_headline += \"|\"\n\n if len(link) < length:\n for i in range(length - len(link)):\n link += space\n link += \"|\"\n\n return [article_headline, link]",
"def SearchableText(self):\n ctool = getToolByName(self, 'portal_cpscalendar')\n if getattr(ctool, 'event_fulltext_index', False):\n return '%s %s' % (self.title, self.description)\n return ''",
"def format_heading(self, level, text):\n underlining = ['=', '-', '~', ][level-1] * len(text)\n return '%s\\n%s\\n\\n' % (text, underlining)",
"def trans(monitext):\n result = ''\n last_line = 'empty'\n\n while monitext:\n # newline character or empty line(s)\n matched = re.match(r'\\n+', monitext, re.M)\n\n if matched:\n result += matched.group()\n if len(matched.group()) > 1:\n last_line = 'empty'\n elif last_line == 'title':\n result += '\\n'\n last_line = 'empty'\n monitext = monitext[matched.end():]\n continue\n\n # code block\n matched = re.match(r'{{{.*?\\n((\\n|.)*?)\\n}}}', monitext, re.M)\n\n if matched:\n body = matched.groups()[0]\n result += '\\n\\t' + '\\n\\t'.join(body.split('\\n'))\n monitext = monitext[matched.end():]\n last_line = 'code'\n continue\n\n # header\n matched = re.match(r'^(=+) (.+) (=+)', monitext)\n\n if matched:\n title = matched.groups()[1]\n level = len(matched.groups()[0])\n\n if last_line != 'empty':\n result += '\\n'\n\n if level < 4:\n underscore = {2 : '=', 3 : '-'}[level] * mbstrlen(title)\n result += title + os.linesep + underscore\n else:\n result += ('#' * level) + \" \" + title\n monitext = monitext[matched.end():]\n\n last_line = 'title'\n\n continue\n\n # link\n matched = re.match(r'(.*)\\[([^\\s]+[ \\t]+)?(.+)\\]', monitext)\n\n if matched:\n pre = matched.groups()[0]\n url = matched.groups()[1]\n if url:\n url = url.strip()\n name = matched.groups()[2]\n\n if url:\n replaced = \"%s[%s](%s)\" % (pre, name, url)\n else:\n replaced = \"%s[%s](%s)\" % (pre, name, name)\n\n monitext = monitext[:matched.start()] + replaced\\\n + monitext[matched.end():]\n\n # important\n monitext = re.sub(r'\\'\\'\\'(.*?)\\'\\'\\'', r'**\\1**', monitext)\n\n # italic\n monitext = re.sub(r'\\'\\'(.*?)\\'\\'', r'_\\1_', monitext)\n\n # list\n matched = re.match(r'^(\\s*)\\* (.*)', monitext)\n\n if matched:\n depth = len(matched.groups()[0])\n body = matched.groups()[1]\n result += (depth - 1) * '\\t' + '* ' + body\n monitext = monitext[matched.end():]\n\n last_line = 'others'\n\n try:\n # Go to the next line\n index = monitext.index('\\n')\n result += monitext[:index]\n monitext = monitext[index:]\n except ValueError:\n result += monitext\n break\n\n return result",
"def title_string(self):\n return ' '.join(self.title).replace(' - ', '')",
"def formatText(s, bold=False, underlined=False, negative=False):\n\n if not FORMATTING_AVAILABLE:\n return s\n\n head = \"\"\n if bold: head += \"\\033[1m\"\n if underlined: head += \"\\033[4m\"\n if negative: head += \"\\033[7m\"\n\n return head + s + \"\\033[0m\"",
"def render_link(url, text=None):\n try:\n url_validator(url)\n return \"<a href='%s'>%s</a>\" % (url, text if text else url)\n except ValidationError:\n return url",
"def format_title(self, title):\n new_title = ''.join(word.lower().strip('!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ ') for word in title)\n return new_title",
"def to_html(self) -> str:\n return f'''\n <a href=\"{self.link}\"> ({self.source_name}, {self.timestamp.strftime('%Y')}) </a>\n '''",
"def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d",
"def insert_link(self, text, href):\n self.insert_text('\\n<a href=\"%s\">%s</a>' % (href, text))",
"def urlLink(self, text=None, url=None, attrs={}):\n if not text:\n text = self.titleOrId()\n text = escape(text)\n if not self.checkRemotePerm(\"View\", self):\n return text\n if not url:\n url = self.getPrimaryUrlPath()\n if len(attrs):\n return '<a href=\"%s\" %s>%s</a>' % (url,\n ' '.join('%s=\"%s\"' % (x,y) for x,y in attrs.items()),\n text)\n else:\n return '<a href=\"%s\">%s</a>' % (url, text)",
"def get_title(self):\n if not hasattr(self, '_title'):\n self._title = 'NO TITLE'\n if self._title:\n title = _(self._title)\n title = title.replace('&', '&') \n title = title.replace('\"', '"')\n return title\n else:\n return u''",
"def _get_title_and_explanation(self):\n title = \"\"\n more_lines = []\n if self.__doc__:\n # Find the first non-empty line in the docstring. If there is\n for line in self.__doc__.split(\"\\n\")[:-1]: # strip off last line, always blank\n line = line.strip()\n if line:\n if not title:\n # We don't have the title set, yet, so we know this is the first line.\n if line.endswith(\".\"):\n # Don't want a period at the end of a title to make it look\n # better.\n title = line[:-1]\n else:\n title = line\n continue\n if not line and not more_lines:\n # We don't need empty lines at the start of the explanation\n continue\n # Add up the lines of the explanation text\n if line.startswith(\"*\"):\n line = f\" {line}\"\n\n more_lines.append(line or \"<br> <br>\") # Empty lines become line break\n return ((title or \"A resource\"), \" \".join(more_lines))",
"def __str__(self):\n return \"{title}\".format(title=self.title)",
"def pretty_title(title):\n output = '-' * 5 + ' ' + title + ' ' + '-' * 5\n return output",
"def resource_link_title(self):\n return self.request.POST.get(\"resource_link_title\", self.resource_link_id)",
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def emphasize(text: str, tablefmt: str | TableFormat, strong: bool = False) -> str:\n # formats a title for a table produced using tabulate,\n # in the formats tabulate understands\n if tablefmt in [\"html\", \"unsafehtml\", html_with_borders_tablefmt]: # type: ignore\n if strong:\n emph_text = f\"<strong>{text}</strong>\"\n else:\n emph_text = f\"<em>{text}</em>\"\n elif tablefmt in [\"latex\", \"latex_raw\", \"latex_booktabs\", \"latex_longtable\"]:\n if strong:\n emph_text = r\"\\textbf{\" + text + r\"}\"\n else:\n emph_text = r\"\\emph{\" + text + r\"}\"\n else: # use the emphasis for tablefmt == \"pipe\" (Markdown)\n star = \"**\" if strong else \"*\"\n emph_text = f\"{star}{text}{star}\"\n return emph_text",
"def get_description(self):\n if self.desc_format == MARKDOWN_FORMAT:\n return markdown.markdown(self.desc, safe_mode='escape') \n elif self.desc_format == TEXT_FORMAT:\n return html.escape(self.desc)",
"def get_description(self):\n if self.desc_format == MARKDOWN_FORMAT:\n return markdown.markdown(self.desc, safe_mode='escape') \n elif self.desc_format == TEXT_FORMAT:\n return html.escape(self.desc)"
] | [
"0.6451654",
"0.6356785",
"0.6355241",
"0.6344087",
"0.622849",
"0.6197949",
"0.61366516",
"0.6077827",
"0.6039847",
"0.603759",
"0.6030842",
"0.6006238",
"0.5959275",
"0.5883406",
"0.58804315",
"0.5844024",
"0.5833735",
"0.5794162",
"0.5784406",
"0.577917",
"0.57081777",
"0.57077414",
"0.5691102",
"0.5687881",
"0.56656635",
"0.56323934",
"0.5615296",
"0.5612757",
"0.5603294",
"0.55980366",
"0.5577484",
"0.5572927",
"0.5568026",
"0.55588114",
"0.55360335",
"0.55354595",
"0.5518344",
"0.5518305",
"0.55145",
"0.55043364",
"0.5492352",
"0.54535097",
"0.5438472",
"0.54317874",
"0.5431516",
"0.5431331",
"0.54149604",
"0.54119086",
"0.53963333",
"0.5393311",
"0.53896004",
"0.53856283",
"0.53768176",
"0.5369308",
"0.5363265",
"0.5357069",
"0.5349087",
"0.53385633",
"0.5336078",
"0.5326782",
"0.5326275",
"0.5315573",
"0.5312289",
"0.53063506",
"0.53002477",
"0.5299849",
"0.5298196",
"0.5287656",
"0.52832556",
"0.52795357",
"0.52774125",
"0.527444",
"0.52728087",
"0.52657944",
"0.52640265",
"0.52565616",
"0.5256406",
"0.524783",
"0.52411276",
"0.5240948",
"0.52384377",
"0.52371687",
"0.52331316",
"0.5232083",
"0.5229335",
"0.5227751",
"0.5226066",
"0.52246463",
"0.52213687",
"0.52157325",
"0.5213509",
"0.5190418",
"0.5188358",
"0.5185208",
"0.5181801",
"0.5177186",
"0.51743656",
"0.5174253",
"0.51669955",
"0.51669955"
] | 0.60614115 | 8 |
Return what we need to write into an XSL file for this type | def xslText(self):
return u'<xsl:for-each select = "./%s">%s<xsl:choose>'\
'<xsl:when test="contains(., \':\')"><a href="{.}">'\
'<xsl:value-of select="."/></a></xsl:when><xsl:otherwise>'\
'<a href="%s{.}"><xsl:value-of select="."/></a>'\
'</xsl:otherwise></xsl:choose>%s</xsl:for-each>' % \
(self.name, xslEscape(self.prefix), self.URLMethod,
xslEscape(self.suffix)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def xslText(self):\n return TextFormat.xslText(self)",
"def convert(self):\n self._convert()\n self._write_docx()",
"def toxml(self) :\n\t\treturn self.doc.toxml()",
"def _ooxml(self):\n # LOG: processing_type property\n self.set_property('processing_type', 'ooxml')\n try:\n doc = officedissector.doc.Document(self.src_path)\n except Exception:\n self.make_dangerous('invalid ooxml file')\n return\n # There are probably other potentially malicious features:\n # fonts, custom props, custom XML\n if doc.is_macro_enabled or len(doc.features.macros) > 0:\n self.make_dangerous('macro')\n if len(doc.features.embedded_controls) > 0:\n self.make_dangerous('activex')\n if len(doc.features.embedded_objects) > 0:\n # Exploited by CVE-2014-4114 (OLE)\n self.make_dangerous('embedded obj')\n if len(doc.features.embedded_packages) > 0:\n self.make_dangerous('embedded pack')",
"def xslText(self):\n return u'<xsl:value-of select=\"%s%s\"/>' % (self.parentLevel * '../',\n self.name)",
"def xslText(self):\n return u'<xsl:value-of select=\"child::*/%s\"/>' % self.name",
"def _write_docx(self):\n with ZipFile(self.out_file, 'w') as f:\n self._write_content_types(f)\n self._write_app(f)\n self._write_core(f)\n self._write_rels(f)\n self._write_document(f)\n self._write_fonts(f)\n self._write_document_rels(f)\n self._write_settings(f)\n self._write_styles(f)",
"def create_output_file(self):\r\n self.output_file = openpyxl.Workbook()",
"def _create_oai_xsl_template():\n oai_xsl_template = OaiXslTemplate()\n oai_xsl_template = _set_oai_xsl_template_fields(oai_xsl_template)\n\n return oai_xsl_template",
"def createXML(whatToCreate):\n\n XMLSerializer = serializers.get_serializer(\"xml\")\n xml_serializer = XMLSerializer()\n if whatToCreate == \"allAccount\":\n path_fullToOutputFile = os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\")\n objectsToSerialize = Account.objects.all()\n else:\n raise ProgrammingError(\n _(\"During XML Export it was not correctly specified which data that has to be exported\"))\n out = open(os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\"), \"w\")\n if objectsToSerialize == '':\n raise NoObjectsToBeSerialzed(_(\"During XML Export it was not correctly specied data has to be exported\"))\n else:\n xml_serializer.serialize(objectsToSerialize, stream=out, indent=3)\n out.close()\n return path_fullToOutputFile\n\n # TODO def importAllAccountsXML(self):",
"def export_to_xml(self, resource_fs):\r\n raise NotImplementedError('Modules must implement export_to_xml to enable xml export')",
"def writeXml(self):\n text = u' type=\"%s\"' % self.typeName\n if self.format:\n text += u' format=\"%s\"' % escape(self.format, treedoc.escDict)\n if self.prefix:\n text += u' prefix=\"%s\"' % escape(self.prefix, treedoc.escDict)\n if self.suffix:\n text += u' suffix=\"%s\"' % escape(self.suffix, treedoc.escDict)\n if self.html:\n text += u' html=\"y\"'\n if self.isRequired:\n text += u' required=\"y\"'\n if self.hidden:\n text += u' hidden=\"y\"'\n if self.numLines > 1:\n text += u' lines=\"%d\"' % self.numLines\n if self.initDefault:\n text += u' init=\"%s\"' % escape(self.initDefault, treedoc.escDict)\n if self.linkAltField:\n text += u' linkalt=\"%s\"' % escape(self.linkAltField,\n treedoc.escDict)\n return text",
"def xslText(self):\n return u'<xsl:value-of select=\"ancestor::*/%s\"/>' % self.name",
"def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def getXml(self):\n return _SALOMERuntime.InputXmlPort_getXml(self)",
"def generateXML(self):\n return self.formatEval(\n self.TEMPLATES[self.attrs['name']]['XML'],\n self.attrs\n )",
"def storeAndReturnXML(self):\n self._storeItems()\n return self.toXML()",
"def get_xml(self):\n return etree.tostring(self.get_etree())",
"def definition_to_xml(self, resource_fs):\r\n raise NotImplementedError(\r\n \"%s does not implement definition_to_xml\" % self.__class__.__name__)",
"def create_gen_xml(self, out_file):\n\n param_list = []\n msg = []\n msg_type = []\n dep_node = []\n for line in self.full_ed_lines:\n param_list.append(line.text())\n dep_pkg = param_list[6].split(', ')\n if dep_pkg[len(dep_pkg) - 1] == '':\n dep_pkg.pop()\n for dep in self.manager.wid.sub_list:\n dep_node.append(dep['msg_type'])\n for dep in self.manager.wid.pub_list:\n dep_node.append(dep['msg_type'])\n for dep in dep_node:\n a, b = dep.split('/')\n msg.append(a)\n msg_type.append(b)\n f = open('../genkernel/templates/package_rosgen.xml')\n o = open(out_file, 'a')\n flag = 0\n while 1:\n line = f.readline()\n if not line: break\n for i in range(6):\n line = line.replace('[{0}]'.format(i), param_list[i])\n line = line.replace('[7]', param_list[7])\n if line.find('[6]') != -1:\n for dep in dep_pkg:\n line_dep = '\\t<depend>{0}</depend>\\n'.format(dep)\n o.write(line_dep)\n flag = 1\n elif line.find('[8]') != -1:\n for dep, tp in zip(msg, msg_type):\n line_dep = '\\t\\t<depend type=\"{1}\">{0}</depend>\\n'.format(dep, tp)\n o.write(line_dep)\n flag = 1\n elif line.find('<subscribers>') != -1:\n o.write('\\t\\t<subscribers>\\n')\n for sub in self.manager.wid.sub_list:\n o.write('\\t\\t\\t<sub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(sub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(sub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(sub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(sub['queue_size']))\n o.write('\\t\\t\\t</sub>\\n')\n o.write('\\t\\t</subscribers>\\n')\n flag = 1\n elif line.find('<publishers>') != -1:\n o.write('\\t\\t<publishers>\\n')\n for pub in self.manager.wid.pub_list:\n o.write('\\t\\t\\t<pub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(pub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(pub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(pub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(pub['queue_size']))\n o.write('\\t\\t\\t</pub>\\n')\n o.write('\\t\\t</publishers>\\n')\n flag = 1\n if flag == 0:\n o.write(line)\n else:\n flag = 0\n o.close()\n f.close()\n self.changed = False",
"def to_xml_file(self, xml_file_path):\n s = self.to_xml()\n with open(xml_file_path, \"w+b\") as f:\n f.write(s)",
"def saveToXml(self) -> org.jdom.Element:\n ...",
"def getXML(self):\n\n def _getElementForMappingEntry(entry, mappingStyle):\n xmlDocTmp = Document()\n element = xmlDocTmp.createElement(mappingStyle)\n for k, v in viewitems(entry):\n # ignore empty, None or compiled regexp items into output\n if not v or (k == \"path-match-expr\"):\n continue\n element.setAttribute(k, str(v))\n return element\n\n xmlDoc = Document()\n root = xmlDoc.createElement(\"storage-mapping\") # root element name\n for mappingStyle, mappings in viewitems(self):\n for mapping in mappings:\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\n root.appendChild(mapElem)\n return root.toprettyxml()",
"def write(self):\n temp_string = minidom.parseString(ET.tostring(self.root)).toprettyxml(encoding=\"UTF-8\")\n with open(self.xml_file, 'w') as f:\n f.write(temp_string)\n # f = open(self.xml_file, \"w\")\n # f.write(temp_string)\n # f.close()",
"def write(self):\n filters = {\n 'MSGUID': lambda x: ('{%s}' % x).upper(),\n 'relslnfile': lambda x: os.path.relpath(x, os.path.dirname(self.FileName))\n }\n context = {\n 'sln': self\n }\n return self.render(self.__jinja_template__, self.FileName, context, filters)",
"def generate(self):\n xml = self.template()\n fp = BytesIO()\n gzip = GzipFile(self.filename, \"wb\", 9, fp)\n if isinstance(xml, str):\n xml = xml.encode(\"utf8\")\n gzip.write(xml)\n gzip.close()\n data = fp.getvalue()\n fp.close()\n return data",
"def to_xml(self) -> str:\n # default name and stuff setup\n element_root, xml_tree = super()._add_basics()\n element_root = element_root.find('elementProp')\n element_root = element_root.find('collectionProp')\n for element in list(element_root):\n try:\n if element.attrib['name'] == 'influxdbUrl':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.influx_db_url:\n elem.text = self.influx_db_url\n elif element.attrib['name'] == 'application':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.application:\n elem.text = self.application\n elif element.attrib['name'] == 'measurement':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.measurement:\n elem.text = self.application\n elif element.attrib['name'] == 'summaryOnly':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value':\n elem.text = str(self.summary_only).lower()\n elif element.attrib['name'] == 'samplersRegex':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.samplers_regexp:\n elem.text = self.samplers_regexp\n elif element.attrib['name'] == 'percentiles':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.percentiles:\n elem.text = self.percentiles\n elif element.attrib['name'] == 'testTitle':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.test_title:\n elem.text = self.test_title\n elif element.attrib['name'] == 'eventTags':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.event_tags:\n elem.text = self.event_tags\n except Exception:\n raise Exception(f'Unable to render xml from {type(self).__class__}')\n return tree_to_str(xml_tree, hashtree=True)",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def getXSLURL(self, output='page'):\n mn_props = getToolByName(self, \"portal_properties\")['metnav_properties']\n output = output.lower().strip()\n if output == 'page':\n return mn_props.getProperty('XSL_PAGE', '')\n if output == 'portlet':\n return mn_props.getProperty('XSL_PORTLET', '')\n if output == 'dict':\n return mn_props.getProperty('XSL_DICT', '')\n if output == 'count':\n return mn_props.getProperty('XSL_COUNT', '')\n if output == 'rss':\n return mn_props.getProperty('XSL_RSS', '')\n if output == 'class_list':\n return mn_props.getProperty('XSL_CLASS_LIST', '')\n if output == 'table':\n return mn_props.getProperty('XSL_TABLE', '')\n if output == 'year_list':\n return mn_props.getProperty('XSL_YEAR_LIST', '')\n raise \"%s is not a valid value for an XSL output\" % output",
"def export_to_xml(self, resource_fs):\r\n\r\n # Set up runtime.export_fs so that it's available through future\r\n # uses of the pure xblock add_xml_to_node api\r\n self.runtime.export_fs = resource_fs\r\n\r\n # Get the definition\r\n xml_object = self.definition_to_xml(resource_fs)\r\n self.clean_metadata_from_xml(xml_object)\r\n\r\n # Set the tag so we get the file path right\r\n xml_object.tag = self.category\r\n\r\n # Add the non-inherited metadata\r\n for attr in sorted(own_metadata(self)):\r\n # don't want e.g. data_dir\r\n if attr not in self.metadata_to_strip and attr not in self.metadata_to_export_to_policy:\r\n val = serialize_field(self._field_data.get(self, attr))\r\n try:\r\n xml_object.set(attr, val)\r\n except Exception:\r\n logging.exception(\r\n u'Failed to serialize metadata attribute %s with value %s in module %s. This could mean data loss!!!',\r\n attr, val, self.url_name\r\n )\r\n\r\n for key, value in self.xml_attributes.items():\r\n if key not in self.metadata_to_strip:\r\n xml_object.set(key, value)\r\n\r\n if self.export_to_file():\r\n # Write the definition to a file\r\n url_path = name_to_pathname(self.url_name)\r\n filepath = self._format_filepath(self.category, url_path)\r\n resource_fs.makedir(os.path.dirname(filepath), recursive=True, allow_recreate=True)\r\n with resource_fs.open(filepath, 'w') as file:\r\n file.write(etree.tostring(xml_object, pretty_print=True, encoding='utf-8'))\r\n\r\n # And return just a pointer with the category and filename.\r\n record_object = etree.Element(self.category)\r\n else:\r\n record_object = xml_object\r\n\r\n record_object.set('url_name', self.url_name)\r\n\r\n # Special case for course pointers:\r\n if self.category == 'course':\r\n # add org and course attributes on the pointer tag\r\n record_object.set('org', self.location.org)\r\n record_object.set('course', self.location.course)\r\n\r\n return etree.tostring(record_object, pretty_print=True, encoding='utf-8')",
"def transform_s3_xsl(**kwargs):\n access_id = kwargs.get(\"access_id\")\n access_secret = kwargs.get(\"access_secret\")\n bucket = kwargs.get(\"bucket\")\n dest_prefix = kwargs.get(\"destination_prefix\")\n source_prefix = kwargs.get(\"source_prefix\")\n if kwargs.get(\"dag\"):\n run_id = kwargs.get(\"dag\").dag_id\n else:\n run_id = \"no-dag-provided\"\n\n saxon = prepare_saxon_engine()\n transformed = etree.Element(\"collection\")\n transformed.attrib[\"dag-id\"] = run_id\n transformed.attrib[\"dag-timestamp\"] = kwargs.get(\"timestamp\", \"no-timestamp-provided\")\n xsl = \"https://raw.github.com/{repo}/{branch}/{filename}\".format(\n repo=kwargs.get(\"xsl_repository\", \"tulibraries/aggregator_mdx\"),\n branch=kwargs.get(\"xsl_branch\", \"main\"),\n filename=kwargs.get(\"xsl_filename\")\n )\n\n for s3_key in process.list_s3_content(bucket, access_id, access_secret, source_prefix):\n logging.info(\"Transforming File %s\", s3_key)\n s3_content = process.get_s3_content(bucket, s3_key, access_id, access_secret)\n s3_xml = etree.fromstring(s3_content)\n for record in s3_xml.iterchildren():\n record_id = record.get(\"airflow-record-id\")\n logging.info(\"Transforming Record %s\", record_id)\n result_str = subprocess.check_output([\"java\", \"-jar\", saxon, \"-xsl:\" + xsl, \"-s:-\"], input=etree.tostring(record, encoding=\"utf-8\"))\n result = etree.fromstring(result_str)\n result.attrib[\"airflow-record-id\"] = record_id\n transformed.append(result)\n filename = s3_key.replace(source_prefix, dest_prefix)\n transformed_xml = etree.tostring(transformed, encoding=\"utf-8\")\n process.generate_s3_object(transformed_xml, bucket, filename, access_id, access_secret)",
"def writeXMLDecl(self):\n return _libsbml.XMLOutputStream_writeXMLDecl(self)",
"def setXSLTMode(self,value):\n self.PDFreactorConfiguration.in1[\"XSLTMode\"] = value",
"def save(self, filename=None):\n f = filename if filename else self.path\n etree.register_namespace('', TEI)\n etree.register_namespace('mith', MITH)\n self.doc.write(f, xml_declaration=True, encoding='utf-8', method='xml')",
"def to_xml(self):\n # lines = super(FileCatNoEmpty, self).cat(filepath)\n structure = super(Point, self).to_xml()\n\n\n coords = GeometryTopologyData.__to_xml_vector__(self.coordinate, self.format)\n # description_str = ''\n # if self.description is not None:\n # description_str = '<Description>%s</Description>' % self.description\n\n return '<Point>%s<Coordinate>%s</Coordinate></Point>' % (structure, coords)",
"def toXML(self):\n return self._xmlpre+\"\\n\".join(map(lambda f:f.toXML(),self._items))+self._xmlpost",
"def write(klass, document, target=None, stylesheet=\"\"):\n writer = LatexWriter(document, target, stylesheet)\n return writer.go()",
"def to_xml(self, file_name=None):\n if file_name:\n xml_file = open(file_name, 'w')\n results = ['<schema name=\"%s\">' % self.name]\n for schema_object in list(self.schema.keys()):\n results.append(self.schema[schema_object].to_xml())\n results.append('</schema>')\n if file_name:\n xml_file.write('\\n'.join(results))\n xml_file.close()\n else:\n return '\\n'.join(results)",
"def write_xosc(self, generated_xml):\n reparsed_xml = minidom.parseString(generated_xml).toprettyxml(indent=\" \")\n xosc_file = open(self._filepath, \"w\")\n xosc_file.write(reparsed_xml)\n xosc_file.close()\n\n msg = QMessageBox()\n if self._warning_message:\n msg.setIcon(QMessageBox.Warning)\n text = f\"Exported OpenSCENARIO file {self._filepath} has warnings!\\n\\n\"\n text += \"\\n\".join(self._warning_message)\n else:\n msg.setIcon(QMessageBox.Information)\n text = f\"Successfully exported OpenSCENARIO file to {self._filepath}\"\n msg.setText(text)\n msg.setWindowTitle(\"OpenSCENARIO Export\")\n msg.setStandardButtons(QMessageBox.Ok)\n msg.exec()",
"def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()",
"def start_serialization(self):\n self.xml = SimplerXMLGenerator(self.stream, self.options.get(\"encoding\", settings.DEFAULT_CHARSET))\n self.xml.startDocument()\n self.xml.startElement(\"xliff\", {\n \"version\": \"1.2\",\n \"xmlns\": \"urn:oasis:names:tc:xliff:document:1.2\",\n \"xmlns:d\": \"https://docs.djangoproject.com/\"\n })",
"def XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\n\n\t#On commence par afficher ce qu'on fait\r\n\tprint \" Build xml file \"\r\n\r\tprint InputsFile\n\t#ouverture du fichier dans lequel on place le source model\n\ttry:\n\t\tfresult = open(OutputFile, 'w')\n\texcept:\n\t\tprint \"Coucou\"\r\n \t#ecriture des premieres lignes invariantes\n\tfresult.write('<?xml version=\"1.0\" ?>')\r\n\tfresult.write(\"<source_library title=\\\"source library\\\">\\n\")\n\r\n \t#ouverture du fichier avec les entrees\r\n\tf = open(InputsFile,\"r\")\r\n\tlines = f.readlines()\r\n\t\r\n \t#Ajout des sources detectees dans le catalogue\n\t#Pour chaque ligne du fichier d'entree\r\n\tfor line in range(len(lines)):\n\t\t#Lire les donnees de la ligne\t\t\r\n\t\tdata = lines[line].split()\r\n\t\tname = data[0]\n\n\t\t#Verification : est on en train de traiter la source que l'on veut etudier ou une autre ?\r\n\t\tif str(name) == Name :\r\n\t\t\tmysource = 1\r\n\t\telse:\r\n\t\t\tmysource = 0\n\n\t\t#recuperation des donnees\r\n\t\tRA = data[1]\r\n\t\tDEC = data[2]\r\n\t\tIntegral = float(data[3])*float(Frac)\r\n\t\tGamma= data[4]\n\n\t\t\r\n\t\ttry:\n\t\t\t#essai de definition des donnees pour un PL avec ExpCut\n\t\t\tPrefactor = float(data[5])*float(Frac)\r\n\t\t\tEnergy = float(data[6])\r\n\t#\t\tPrefactor = Prefactor/pow(Energy/100., float(Gamma)) #Densite de flux calculee a Epivot\r\n\t#\t\tPrefactor = Prefactor*pow(1000./100., float(Gamma)) #We do the calculation with (E/1000.)^Gamma\n\t\t\tvariabilite=float(data[8])\n\n#\t\t\tprint variabilite\n\n\n\n\r\n\t\t\tcut = float(data[7]) # Cut est la variable qui nous permettra de savoir si il faut utiliser un cut off (1) ou une loi de puissance normale (2)\r\n\t\texcept:\r\n\t\t\ttry:\r\n\t\t\t\tcut = float(data[5])\r\n\t\t\texcept:\r\n\t\t\t\tprint \" Wrong size of list \"\r\n\t\t\t\tsys.exit()\r\n \t#Si on considere un ccut off exponentiel pour la source :\r\n\t\tif cut == 1:\n\t\t\t#ecriture du nom de la source consideree\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\r\n\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\r\n\t\t\tspectrum_type = \"PLSuperExpCutoff\"\n\t\t\t#Utilisation de la modelisation PLSuperExpCutoff car plus simple et plus intuitive pour nous et pour la modelisation des pulsars si il faut en modeliser\n\r\n\t\t\t#definition des parametres spectraux a prendre en comtpe et de la chaine de caractere a integrer\r\n\n\n\n\t\t\tif variabilite==0.0 or variabilite==2.0:\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"10000000.0\\\" min=\\\"0.0000001\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\r\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.001\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\n\r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\t\t\telif variabilite==1.0 :\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10000000.0\\\" min=\\\"0.0\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.0001\\\"\"\r\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\n\r\n \r\n\n# <spectrum type=\"PLSuperExpCutoff\">\n# <parameter free=\"1\" max=\"100000\" min=\"0\" name=\"Prefactor\" scale=\"1e-10\" value=\"Prefactor*1e-10\"/>\n# <parameter free=\"1\" max=\"0\" min=\"5\" name=\"Index1\" scale=\"-1\" value=\"valeur du catalogue\"/>\n# <parameter free=\"0\" max=\"20000\" min=\"1.0\" name=\"Scale\" scale=\"1\" value=\"Epivot\"/>\n# <parameter free=\"1\" max=\"300000\" min=\"100\" name=\"Cutoff\" scale=\"1\" value=\"3000\"/>\n# <parameter free=\"0\" max=\"5\" min=\"0\" name=\"Index2\" scale=\"1\" value=\"1.5\"/>\n# </spectrum>\n\n\r\n\t\telse:\n\t\t#Sinon (si on considere une loi de puissance simple)\n\t\t#definition de la chaine de caractere comportant le nom de la source\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\n\t\t\tif mysource == 0:\r\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\n\t\t\telse:\n\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\t\t\t\t\n\n\t\t\t#definition de la chaine de caractere correspondant a la forme de fit que l'on souhaite utiliser (Loi de puissance)\r\n\t\t\tspectrum_type = \"PowerLaw2\"\r\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre Integrale\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\telse:\n\t\t\t#sinon on le libere\r\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\n\n\n\n\n\n\t\t\t#Toujours ce facteur....\r\n\t\t\tIntegral = float(Integral)*1e10\r\n\t\t\tscale = 1e-10\n\n\n\t\n\r\n\t\t\tspectrum_lines += \" name=\\\"Integral\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre gamma\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\telse:\n\t\t\t\t#si c'est pas la source que l'on etudie on le laisse libre\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\n\n\t\t\t#fin de la chaine de parametres sur le modele spectral\r\n\t\t\tspectrum_lines += \" name=\\\"Index\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t \n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"1000.0\\\"/>\\n\"\r\n \r\n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\t\t\telse:\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"100\\\"/>\\n\"\n\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"100000.0\\\" Min =\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\n \t\t#ajout du modele spectral a la liste de parametres \r\n\t\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\t\tresult_line += spectrum_lines\r\n\t\tresult_line += \" </spectrum>\\n\"\n\n\t\t\n\n\t\tif mysource==0 and variabilite!=1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telif mysource==0 and variabilite==1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telse:\n #ajout du modele spatial a la liste de parametres \n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\t\t\n\t\tresult_line += \" </source>\\n\"\r\n\t\tfresult.write(result_line+\"\\n\")\r\n #Ajout du fond diffus galactique\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"gal_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"ConstantValue\"\r\n\r\n\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Value\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n\r\n\tresult_line += \" <spatialModel file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/gll_iem_v02.fit\\\" type=\\\"MapCubeFunction\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"1000.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Normalization\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\r\n \t#Ajout du fond diffus extragalactique\r\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"eg_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"FileFunction\"\r\n\r\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Normalization\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/isotropic_iem_v02.txt\\\" type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n \r\n\tresult_line += \" <spatialModel type=\\\"ConstantValue\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"100.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Value\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\n \t#Fermeture des fichiers \r\n\tf.close() \r\n\tfresult.write(\"\\n</source_library>\\n\")\r\n\tfresult.close()\r\n\treturn",
"def get(self):\n return _SALOMERuntime.OutputXmlPort_get(self)",
"def toXML(self):\n return _libsbml.Layout_toXML(self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def write(self):\r\n for prop in self.prpnames:\r\n elem = SubElement(self._root, prop)\r\n data = self.__getattribute__(prop)\r\n if self.prpnames[prop]['type'] == \"text\":\r\n elem.text = data\r\n elif self.prpnames[prop]['type'] == 'list':\r\n for x in data:\r\n SubElement(elem, 'regel').text = x\r\n elif self.prpnames[prop]['type'] == 'attr':\r\n elem.set(self.prpnames[prop]['naam'], data)\r\n tree = ElementTree(self._root)\r\n tree.write(self._fn)\r\n if not self.exists:\r\n self.exists = True",
"def write(self, file_or_filename):\n etMap = revert(self)\n xmlTree = ET.ElementTree(etMap)\n xmlTree.write(file_or_filename)",
"def save_to_xml(self, xwriter):\r\n\r\n xwriter.WriteStartElement(\"Profile\")\r\n xwriter.WriteAttributeString(\"Name\", self.Name)\r\n xwriter.WriteStartAttribute(\"Version\")\r\n xwriter.WriteValue(self.Version)\r\n xwriter.WriteEndAttribute()\r\n\r\n for var_name in self.__dict__:\r\n var_type = type(getattr(self, var_name))\r\n\r\n if var_type is str and var_name != \"Name\":\r\n self.write_string_to_xml(var_name, xwriter)\r\n\r\n elif var_type is bool:\r\n self.write_bool_to_xml(var_name, xwriter)\r\n\r\n elif var_type is dict:\r\n self.write_dict_to_xml(var_name, xwriter)\r\n\r\n elif var_type is list and var_name != \"ExcludeRules\":\r\n self.write_list_to_xml(var_name, xwriter)\r\n\r\n xwriter.WriteStartElement(\"ExcludeRules\")\r\n xwriter.WriteAttributeString(\"Operator\", self.ExcludeOperator)\r\n xwriter.WriteAttributeString(\"ExcludeMode\", self.ExcludeMode)\r\n for rule in self.ExcludeRules:\r\n if rule:\r\n rule.save_xml(xwriter)\r\n xwriter.WriteEndElement()\r\n \r\n xwriter.WriteEndElement()",
"def xmlWrite(self, xmlWriter, font, value, name, attrs):\n raise NotImplementedError(self)",
"def write_output_file(self, xml_text, xml_file):\n xml_fo = open(xml_file, 'w')\n xml_fo.write(xml_text+'</xml>')\n xml_fo.close()\n return",
"def writeXMLNS(self, *args):\n return _libsbml.ASTBasePlugin_writeXMLNS(self, *args)",
"def _generate_xml(self, body, destn_dir, nodes=True):\n fn = ''.join([random.choice(string.ascii_letters) for _ in range(12)])\n fn += '.xml'\n\n _dir = os.path.dirname(os.path.abspath(__file__))\n _tmpl = 'multi_node.template' if nodes else 'single_node.template'\n _env = Environment(autoescape=False,\n loader=FileSystemLoader(_dir),\n trim_blocks=False)\n\n with open(fn, 'w+') as f:\n o = _env.get_template(_tmpl).render(body)\n f.write(o)\n\n _d = destn_dir + '/' + fn\n self._remote_copy(fn, _d)\n # Remove the XML file created locally\n os.remove(fn)\n\n return _d",
"def dumps(records, xslt_filename=None, **kwargs):\n root = dumps_etree(records=records, xslt_filename=xslt_filename)\n return etree.tostring(\n root,\n pretty_print=True,\n xml_declaration=True,\n encoding='UTF-8',\n **kwargs\n )",
"def xml(self):\n raise NotImplementedError('This api does not return xml')",
"def _writeXML(self,output,outputDictionary):\n if self.dynamic:\n outputInstance = xmlUtils.DynamicXmlElement('MetricPostProcessor', pivotParam=self.pivotParameter)\n else:\n outputInstance = xmlUtils.StaticXmlElement('MetricPostProcessor')\n if self.dynamic:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n for ts, pivotVal in enumerate(self.pivotValues):\n if values.shape[0] == 1:\n outputInstance.addScalar(nodeName, metricName,values[0], pivotVal=pivotVal)\n else:\n outputInstance.addScalar(nodeName, metricName,values[ts], pivotVal=pivotVal)\n else:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n if len(list(values)) == 1:\n outputInstance.addScalar(nodeName, metricName, values[0])\n else:\n self.raiseAnError(IOError, \"Multiple values are returned from metric '\", metricName, \"', this is currently not allowed\")\n return outputInstance",
"def writeXml(self):\n curdir = os.getcwd()\n os.chdir(self.Imagedir)\n allImageLists = [self.sciImlist, self.ctxImlist, self.wgtImlist, self.rmsImlist]\n \n for imlist in allImageLists:\n for im in imlist:\n file = xmlUtil.markupImage(im,dataset=self.obsName)\n \n # Don't write these images as output of this module, which\n # really doesn't have any.\n \n #if file not in self.outputList.keys():\n # self.outputList[file] = [im]\n \n os.chdir(curdir)\n return",
"def docType():\n return (u'<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n u'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 '\n u'Transitional//EN\" '\n u'\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n')",
"def to_xml(self, scene_dir: str) -> Tuple[Et.Element, bool]:\n raise NotImplementedError",
"def save_xml_file():\n global output_on_display, import_lst, column_names, data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = data[0]\n step = len(column_names)\n\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"XML\", \"*.xml\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.xml')\n data = import_lst\n\n if len(data[0]) == step:\n pass\n else:\n data = import_lst[step::]\n\n data2 = list(map(list, zip(*data)))\n\n data3 = {key: value for key, value in zip(column_names, data2)}\n\n column = list(data3.keys())\n\n df = pd.DataFrame(data3, columns=column)\n\n data_dict = df.to_dict(orient=\"records\")\n with open('output.json', \"w+\") as f:\n json.dump(data_dict, f, indent=4)\n\n xml_data = dicttoxml(data_dict).decode()\n with open(save_name, \"w+\") as f:\n f.write(xml_data)\n\n data.clear()\n data2.clear()\n data3.clear()",
"def Write(self):\n f = open(self.project_path, 'wt')\n self.doc.writexml(f,\n encoding='Windows-1252',\n addindent=' ',\n newl='\\n')\n f.close()",
"def write(self, filename, agg_dir):\n super().write(filename)\n\n if self.aggregation:\n agg = self.aggregation\n abs_subdir = os.path.join(agg_dir, agg.sub_dir)\n if not os.path.isdir(abs_subdir):\n os.makedirs(abs_subdir)\n\n agg.xml_element.write(os.path.join(abs_subdir, agg.basename))",
"def to_sbml(self, params):\n files = {}\n _id, cobra_model = self._ws_obj_to_cobra(params['input_ref'])\n files['file_path'] = os.path.join(params['destination_dir'], _id + \".xml\")\n cobra.io.write_sbml_model(cobra_model, files['file_path'])\n\n return _id, files",
"def writeToTempXml(self):\n name = self.fileToProcess.name\n all_tokens = ET.Element(\"tokens\")\n for token in self.tokensTable:\n if token.getType() == KEYWORD:\n keyword = ET.SubElement(all_tokens, \"keyword\")\n keyword.text = ' '+token.getValue()+' '\n elif token.getType() == IDENTIFIER:\n identifier = ET.SubElement(all_tokens, \"identifier\")\n identifier.text = ' '+token.getValue()+' '\n elif token.getType() == SYMBOL:\n symbol = ET.SubElement(all_tokens, \"symbol\")\n symbol.text = ' '+token.getValue()+' '\n elif token.getType() == STRING_CONST:\n stringConstant = ET.SubElement(all_tokens, \"stringConstant\")\n stringConstant.text = ' '+token.getValue()+' '\n elif token.getType() == INT_CONST:\n integerConstant = ET.SubElement(all_tokens, \"integerConstant\")\n integerConstant.text = ' '+token.getValue()+' '\n tree = ET.ElementTree(all_tokens)\n tree.write(name + 'T' + '.xml')",
"def write2file(self, save_to):\n headerstyle = xlwt.easyxf(self.header_style.get_style_string())\n missing_val_style = xlwt.easyxf(\n self.missing_value_style.get_style_string())\n row_styles = [xlwt.easyxf(self.first_style.get_style_string()),\n xlwt.easyxf(self.second_style.get_style_string())]\n\n properties, sections, table = self._build_table()\n\n workbook = xlwt.Workbook()\n sheet = workbook.add_sheet(self.sheet_name)\n\n if os.path.splitext(save_to)[-1] == '':\n save_to += '.xls'\n\n max_col_len = []\n\n if (self.switch):\n\n for i, prop in enumerate([''] + properties):\n sheet.write(0, i, prop, headerstyle)\n max_col_len.append(len(str(prop)))\n\n for row_num, sec in enumerate(sections):\n sheet.write(row_num + 1, 0, sec, headerstyle)\n if len(str(sec)) > max_col_len[0]:\n max_col_len[0] = len(str(sec))\n\n for row_num, row in enumerate(table):\n for col_num, elem in enumerate(row):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n else:\n\n for i, sec in enumerate([''] + sections):\n sheet.write(0, i, sec, headerstyle)\n max_col_len.append(len(str(sec)))\n\n for row_num, prop in enumerate(properties):\n sheet.write(row_num + 1, 0, prop, headerstyle)\n if len(str(prop)) > max_col_len[0]:\n max_col_len[0] = len(str(prop))\n\n for col_num, col in enumerate(table):\n for row_num, elem in enumerate(col):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n # adjust width of he columns\n for col_id, col_len in enumerate(max_col_len):\n sheet.col(col_id).width = (256 * (col_len+1))\n\n workbook.save(save_to)",
"def getXML(self):\n nodes = list(self.nodes(data=True))\n nodes.sort()\n node_string = ''\n for n in nodes:\n attribute_string = ''\n keys = list(n[1].keys())\n keys.sort()\n for k in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(k, n[1][k], k)\n modification_string = ''\n modified_by = self.predecessors(n[0])\n if modified_by:\n for mod in modified_by:\n modification_string += \"\"\"<modified_by>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifyingNode> %s </modifyingNode>\\n\"\"\"%mod.getTagID()\n modification_string += \\\n \"\"\"<modifyingCategory> %s </modifyingCategory>\\n\"\"\"%mod.getCategory()\n modification_string += \"\"\"</modified_by>\\n\"\"\"\n modifies = self.successors(n[0])\n if modifies:\n for modified in modifies:\n modification_string += \"\"\"<modifies>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifiedNode> {0} </modifiedNode>\\n\"\"\".format(modified.getTagID())\n modification_string += \\\n \"\"\"</modifies>\\n\"\"\"\n node_string += \\\n NODE_XML_SKEL.format(attribute_string+\"{0}\".format(n[0].getXML()) +\\\n modification_string)\n edges = list(self.edges(data=True))\n edges.sort()\n edge_string = ''\n for edge in edges:\n keys = list(edge[2].keys())\n keys.sort()\n attribute_string = ''\n for key in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(key, edge[2][key], key)\n edge_string += \"{0}\".format(EDGE_XML_SKEL.format(edge[0].getTagID(),\n edge[1].getTagID(),\n attribute_string))\n\n return CONTEXT_MARKUP_XML_SKEL.format(xmlScrub(self.getRawText()),\n xmlScrub(self.getText()),\n node_string,\n edge_string)",
"def writeXMLNS(self, *args):\n return _libsbml.MultiASTPlugin_writeXMLNS(self, *args)",
"def _write_context_to_file(self, context):\n om.out.debug('[xml_file.flush()] Starting _write_context_to_file()')\n\n template = self._jinja2_env.get_template('root.tpl')\n\n # We use streaming as explained here:\n #\n # http://flask.pocoo.org/docs/0.12/patterns/streaming/\n #\n # To prevent having the whole XML in memory\n # pylint: disable=E1101\n report_stream = template.stream(context)\n report_stream.enable_buffering(3)\n # pylint: enable=E1101\n\n # Write everything to a temp file, this is useful in two cases:\n #\n # * An external tool will always see a valid XML in the output,\n # and not just a partially written XML document.\n #\n # * If w3af is killed in the middle of writing the XML report,\n # the report file will still be valid -- if xml_file.flush() was\n # run successfully at least once\n tempfh = NamedTemporaryFile(delete=False,\n prefix='w3af-xml-output',\n suffix='.xml')\n\n om.out.debug('[xml_file.flush()] write_context_to_file() created'\n ' template.stream and NamedTemporaryFile')\n\n try:\n # Write each report section to the temp file\n for report_section in report_stream:\n tempfh.write(report_section.encode(DEFAULT_ENCODING))\n except Exception:\n # No exception handling is done here, we just raise the exception\n # so that the core can handle it properly\n raise\n else:\n # Close the temp file so all the content is flushed\n tempfh.close()\n\n om.out.debug('[xml_file.flush()] write_context_to_file() starting to'\n ' copy temp file to destination')\n\n # Copy to the real output file\n report_file_name = os.path.expanduser(self._file_name)\n\n cmd = 'cp %s %s' % (tempfh.name, report_file_name)\n subprocess.call(cmd, shell=True)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished copy'\n ' operation.')\n\n stat_info = os.stat(report_file_name)\n om.out.debug('The XML output file size is %s bytes.' % stat_info.st_size)\n\n finally:\n os.remove(tempfh.name)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished')",
"def run_xslt(xml_filename, xsl_filename):\n import subprocess\n from misc.localexec import LocalExec\n from distutils.spawn import find_executable\n\n def seekout_xsltproc():\n XSLTPROC_BIN = 'xsltproc'\n executable = find_executable(XSLTPROC_BIN)\n if executable:\n return os.path.abspath(executable)\n raise SignerError(\"it has not found {} binary\".format(XSLTPROC_BIN))\n\n le = LocalExec(err_mute=True)\n exe = seekout_xsltproc()\n exe_args = [ xsl_filename, xml_filename ]\n\n try:\n return le([exe] + exe_args, cmd_timeout=20, ign_rcs=None)\n except subprocess.CalledProcessError as e:\n msg = \"Command raised exception\\nOutput: \" + str(e.output)\n raise Exception(msg)",
"def to_workbook(self) -> tuple:\n\n # Initialize the bytestream\n f = io.BytesIO()\n wb = xw.Workbook(f, {\"in_memory\": True})\n\n # Open a workbook\n self._book = wb\n self._book.set_properties({\"category\": \"atomica:databook\"})\n self._formats = standard_formats(self._book)\n self._references = {} # Reset the references dict\n\n # Write the contents\n self._write_pops()\n self._write_tdve()\n self._write_interpops()\n self._write_transfers()\n\n # Clean internal variables related to writing the worbkook\n self._book = None\n self._formats = None\n self._references = None\n\n return f, wb",
"def format_xml(self,query_results):\n results=query_results.data\n factory=factory_xml()\n dump=factory.dumps({'data':results})\n print(dump)\n # TODO return output for this\n return \"\"",
"def write_to_xml(dictData, metadata, xmlfile):\n\tfout = codecs.open(xmlfile, 'w', 'utf-8')\n\tfout.write('<?xml version = \"1.0\" encoding = \"UTF-8\" standalone = \"no\" ?>\\n')\n\tfout.write('<?xml-stylesheet type=\"text/xsl\" href=\"maketable.xsl\"?>\\n')\n\tfout.write('<root>\\n')\n\tfout.write('<meta>\\n')\n\tfor key, value in metadata.items():\n\t\tfout.write('<' + key + '>' + value + '</' + key + '>\\n')\n\tfout.write('</meta>\\n')\n\tfout.write('<content>\\n')\n\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dictData:\n\t\txmlline = ''\n\t\txmlline += '<word><headword>' + hw + '</headword><meanings>'\n\t\tfor meaning in meanings:\n\t\t\txmlline += '<m>' + meaning + '</m>'\n\t\txmlline += '</meanings>'\n\t\txmlline += '<verse>'\n\t\tlines = verse.split('<BR>')\n\t\tfor line in lines:\n\t\t\txmlline += '<line>' + line + '</line>'\n\t\txmlline += '</verse>'\n\t\txmlline += '<verseNumber>' + verseNumDetails + '</verseNumber>'\n\t\txmlline += '<pageNumber>' + pageNumDetails + '</pageNumber></word>'\n\t\t# Write in babylon format. <BR><BR> is to separate verses.\n\t\tfout.write(xmlline + '\\n')\n\t\txmlline = ''\n\tfout.write('</content>\\n</root>')\n\tfout.close()\n\n\t# Give some summary to the user\n\tprint('XML file generated. Success!')\n\tprint('{} metadata lines and {} content lines written to XML file.'.format(len(metadata), len(dictData)))",
"def xml(self):\n return self._xml",
"def xml(self):\n return self._xml",
"def writeSBMLToFile(self, *args):\n return _libsbml.SBMLWriter_writeSBMLToFile(self, *args)",
"def _create_xml_report(self, test, xml_obj):\n xml_report_path = os.path.join(test.work_dir,\n self.XML_REPORT_PATH)\n with open(xml_report_path, 'w') as xml_report:\n xml_report.write(etree.tostring(xml_obj, pretty_print=True))",
"def xml2html(self):\n handler = open(self.xml_doc).read()\n soup = BeautifulSoup(handler, 'xml')\n\n fw = open(self.filename_out, 'w')\n\n fw.write(\"<!DOCTYPE html>\" + os.linesep)\n fw.write(\"<html>\" + os.linesep)\n fw.write(\"<head>\" + os.linesep)\n fw.write('<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">' + os.linesep)\n fw.write(\"<link rel=\\\"stylesheet\\\" href=\\\"%s\\\" type=\\\"text/css\\\" />\" % self.stylesheet_name + os.linesep)\n fw.write(\"<title></title>\" + os.linesep)\n fw.write(\"</head>\" + os.linesep)\n fw.write(\"<body>\" + os.linesep)\n\n # Load styles in dictionaries\n for style in soup.find_all(\"style\"):\n style_name = style.get(\"style:name\")\n #print \"style: %s children: %s descendants: %s\" % (str(style_name), str(len(list(style.children))), len(list(style.descendants)))\n for style_child in style.children:\n fs = style_child.get(\"fo:font-style\")\n if fs:\n self.style_fontstyle[style_name] = fs\n fontw = style_child.get(\"fo:font-weight\")\n if fontw:\n self.style_fontweight[style_name] = fontw\n # read alignment\n txta = style_child.get(\"fo:text-align\")\n if txta:\n self.style_textalignment[style_name] = txta\n # !!!\n tu = style_child.get(\"style:text-underline-type\")\n if tu:\n self.style_textunderline[style_name] = \"underlined\"\n # page break\n break_before = style_child.get(\"fo:break-before\")\n if break_before:\n self.style_break_before[style_name] = break_before\n\n\n # Navigate down the document through h and p tags\n #\n for text in soup.find_all(re.compile(\"^h|^p\")):\n\n # From bs4 docs: If a tag has only one child, and that child is a NavigableString, the child is made available as .string:\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"P9\">- Any text here!</text:p>\n #\n # To do:\n #\n # Beware of this case:\n # - <text:p text:style-name=\"P8\">\n # <text:span text:style-name=\"T4\">\n #\n\n # Get the attributes so the styles and the outlines\n text_attrs = dict(text.attrs)\n\n # Get the styles, if any\n try:\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n if text.string:\n t = unicode(text.string)\n if t:\n fw.write(self.outliner(self.stylizer(t, t_style), t_outline_level, t_style).encode('utf-8'))\n\n # e.g. page breaks come as a node with no children whose style contains fo:break-before:\"page\"\n elif len(list(text.children)) == 0:\n fw.write(self.outliner(unicode(\"\"), t_outline_level, t_style).encode('utf-8'))\n\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"Textbody\">\n # jkjksk skjkjkjs dhh\n # <text:s />\n # <text:span text:style-name=\"T3\">Bold</text:span>\n # <text:s />\n # </text:p>\n #\n # else drill down one level\n else:\n buffer = unicode(\"\")\n t = buffer\n u = buffer\n t_outline_level = \"paragraph\"\n t_style = \"\"\n for i in text.children:\n # Get the attributes so the styles\n try:\n text_attrs = dict(i.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n # whenever the element has no style\n # take the parent's one\n try:\n text_attrs = dict(i.parent.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n # if the current tag has only one child, and that child is a NavigableString\n if i.string:\n t = unicode(i.string)\n\n # space\n elif i.name == \"s\":\n t = unicode(\" \")\n\n # else drill down another level\n else:\n t = unicode(\"\")\n for j in i.children:\n if j.string:\n u = unicode(j.string)\n elif j.name == \"s\":\n u = unicode(\" \")\n else:\n u = unicode(\"\")\n if u:\n t = t + self.stylizer(u, t_style)\n\n # build up a unicode string containing the whole paragraph\n if t:\n buffer = buffer + self.stylizer(t, t_style)\n\n # outline the buffered unicode string and write it to the output file\n fw.write(self.outliner(buffer, t_outline_level, t_style).encode('utf-8'))\n\n fw.write(\"</body>\" + os.linesep)\n fw.write(\"</html>\" + os.linesep)\n fw.close()",
"def writexml(file):\n OUTFILE=open(file,\"w\")\n doc = xml.dom.minidom.Document()\n\n # Create the <dec_reg_list> base element\n decl_reg_list = doc.createElement(\"decl_reg_list\")\n doc.appendChild(decl_reg_list)\n\n regname_old=\"\"\n rows.pop(0)\n for row in rows:\n (regdesc,regname,offset,default,regtype,expose_reg,depth,incsz,bitdesc,bitname,loc,bittype)= row\n if regname != regname_old:\n # Create the register element\n register = doc.createElement(\"register\")\n register.setAttribute(\"name\", regname)\n register.setAttribute(\"offset\", offset)\n if default != \"\" : register.setAttribute(\"default\", default)\n register.setAttribute(\"type\", regtype)\n if expose_reg == \"1\": register.setAttribute(\"usr\", expose_reg)\n if depth != \"\": register.setAttribute(\"size\", depth)\n if incsz != \"\": register.setAttribute(\"incsz\", incsz)\n text = doc.createTextNode(regdesc)\n register.appendChild(text)\n decl_reg_list.appendChild(register)\n \n # Create the field element\n if bitname != \"\":\n field = doc.createElement(\"field\")\n field.setAttribute(\"name\", bitname)\n if loc !=\"\": field.setAttribute(\"loc\", addcolon(loc))\n if bittype != \"\": field.setAttribute(\"type\", bittype)\n if bitdesc != \"\":\n text = doc.createTextNode(bitdesc)\n field.appendChild(text)\n register.appendChild(field)\n regname_old = regname\n\n\n # Print our newly created XML\n #print doc.toprettyxml(indent=\" \")\n #OUTFILE.write(doc.saveXML(decl_reg_list))\n OUTFILE.write(doc.toprettyxml(indent=\" \"))\n OUTFILE.close()",
"def write(self, filename):\n \n return self.model.write(filename,xml_declaration=True, encoding='utf-8')",
"def export_to_file(self, filename):\n if len(filename.split(\".\")) == 1:\n filename += \".xml\"\n xmlstring = self._dommodel.toprettyxml(\" \", \"\\n\")\n with open(filename, \"w\") as f:\n f.write(xmlstring)",
"def save_as(self, fname, base = None, indent = '', topns = True, namespaces = {}):\n with codecs.open(fname, \"w\", encoding=\"utf-8\") as outf:\n self.serialize_xml(outf.write, base=base, indent=indent, topns=topns, namespaces=namespaces)",
"def write(self):\n return JavaMLWriter(self)",
"def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez",
"def CreateXMLTransformer() -> TransformerFunc:\n return partial(traverse, transformation_table=XML_AST_transformation_table.copy())",
"def toXMLElement(self):\n property_element = xml.etree.ElementTree.Element('property')\n property_element.set('concept', self.concept_ref)\n\n if self.is_parent:\n property_element.set('isParent', 'true')\n\n return property_element",
"def xmlwrite(self, doc, filename):\n pathname = os.path.join(self.session.session_dir, filename)\n f = open(pathname, \"w\")\n doc.writexml(writer=f, indent=\"\", addindent=\" \", newl=\"\\n\", encoding=\"UTF-8\")\n f.close()",
"def makexmlfunc(healpix,ra,dec,week1,week2,distance):\n\t\n\tif week1!=week2:\n\t\tidentity=\"%06d_%d_%d_w%03d_w%03d\" %(healpix,ra,dec,week1,week2)\n\t\tltcube=\"%s/lat_ltcube_weekly_w%03d_w%03d_p203_v001.fits\" %(cfg.home,week1,week2)\n\t\tspacecraft=\"%s/w%03d_w%03d_newspacecraft.fits\" %(cfg.ispace,week1,week2)\n\telse:\n\t\tidentity=\"%06d_%d_%d_w%03d\" %(healpix,ra,dec,week1)\n\t\tltcube=\"%s/lat_spacecraft_weekly_w%03d_p203_v001_ltcube.fits\" %(cfg.home,week1)\n\t\tspacecraft=\"%s/lat_spacecraft_weekly_w%03d_p202_v001.fits \" %(cfg.ispace,week1)\n\n\tregion_filtered=\"%s_region_filtered_gti.fits\" %(identity)\n\tfermisources=\"%s_fermisources_model.xml\" %(identity)\n\tinputmodel=\"%s_input_model.xml\" %(identity)\n\tfermis=\"%s_fermis.xml\" %identity\n\tresponse=\"P7REP_SOURCE_V15\"\n\tmakexmllog=\"%s_output_makexml.log\" %identity\n\tglobal extendedsource\n\tglobal numberofextendedsources\n\textendedlog=\"%s_number_of_extendedsources.log\" %identity\n\tExtendedList=\"ExtendedList.txt\"\n\tOthersList=\"OthersList.txt\"\n\n\t\n\twith open (makexmllog,'r') as outputFile: #opens the makexmllog file from makesyfunc. This document contains info about the extended sources.\n\t\t\n\t\tfor line in outputFile:\n\t\t\t\n\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\tif line.startswith('Added')==True:\n\t\t\t\t\ta,b=line.split('and ')\t\n\t\t\t\t\tb1,b2,b3=b.split(' ')\n\t\t\t\t\n\t\t\t\t\tnumberofextendedsources=int(b1) #b1 is the number of extended sources\n\toutputFile.close()\n\toutputFile=open(inputmodel, 'w')\n\tprint numberofextendedsources\n\n\tif numberofextendedsources==1: #if there is an extended source\n\t\twith open (makexmllog,'r') as outputFile:\n\t\t\n\t\t\tfor line in outputFile:\n\t\t\t\n\t\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\t\tif line.startswith('Extended')==True:\n\t\t\t\t\t\tprint line\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\tc,d=line.split(' in')\n\t\t\t\t\t\n\t\t\t\t\t\tc1,c2,c3,c4=c.split(' ')\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\textendedsource=str(c3) #extracts the name of the extended source from makexmllog\n\t\n\n\t\t\n\n\n\t\toutputFile.close()\t\n\n\n\t\n\n\t\twith open(\"%s\" %fermisources) as thefile: #opens the xml file that was created from makesyfunc\n\t\t\tfor line in thefile:\n\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==True:\n\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tspecial=str.replace(line,'%s.fits'%extendedsource,'%s/%s.fits' %(cfg.homesy,extendedsource)) \n\t\t\t\t\tprint special #replace with the correct path to the extendedsource(Templates folder)\n\t\t\t\n\t\t\t\t\tspecial1=str.replace(special,'type=\"SpatialMap\"','type=\"SpatialMap\" map_based_integral=\"true\"')\n\t\t\t\t\tprint special1 #instruction from fermi tutorial, you must add map_based...\n\t\t\t\t\toutputFile=open(fermis, 'w') #write to fermis, the original xml with the right path to the extended source\n\t\t\t\t\twith open(\"%s\" %fermisources,'r') as infile:\n\t\t\t\t\t\tfor line in infile:\n\t\t\t\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==False:\n\t\t\t\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\toutputFile.write(special1)\n\t\t\t\t\toutputFile.close()\n\t\t\t\t\t\t\t\t\t\n\n\n\t\t\t\n\t\toutputFile=open(inputmodel, 'w') #final xml file. contains the right path and the source info of \"your\" source.\n\t\twith open(fermis,'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\t\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\t\t\t\n\n\t\toutputFile.close()\n\t\n\t\twith open(\"%s_diffrsp.log\" % (identity), 'w') as outsyputFile: #run diffrsp if you have an extended source.\n\t\t\tsubprocess.call(['%s' %(cfg.pythoncommand),'gtdiffrsp.py', '%s' %(region_filtered),'%s' %(spacecraft), '%s' %inputmodel, '%s' %(response),'%s' %identity ],stdout=outsyputFile)\n\t\t\t\n\t\twith open(ExtendedList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\t\t\t\t\n\tif numberofextendedsources==0: #if there is no extended source\n\t\toutputFile=open('%s' %(inputmodel), 'w') #write to inputmodel, \"your\" source\n\t\twith open('%s' %(fermisources),'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\n\t\t\t\n\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\toutputFile.close()\n\tif numberofextendedsources>1:\n\t\twith open(OthersList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\n\tif numberofextendedsources==1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\\n\\\n \t%s\"%(numberofextendedsources,extendedsource))\n\t\toutsyputFile.close()\n\n\tif numberofextendedsources !=1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\" %(numberofextendedsources))\n\t\toutsyputFile.close()",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml",
"def _toFile(self):\n pass",
"def to_xml(self):\n xml_strings = ['<code_object name=\"%s\">' % self.name]\n xml_strings.append(' <type value=\"%s\" />' % self.object_type)\n xml_strings.append(' <source>')\n for source_line in self.source:\n xml_strings.append(source_line[1])\n xml_strings.append(' </source>')\n xml_strings.append('</code_object>')\n return \"\".join(xml_strings)",
"def toGML(self):\n raise NotImplementedError",
"def xml_path(self):\n return self.__xml_path",
"def addXSLTStyleSheet(self, content, URI):\n if self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] == None:\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] = []\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)\n else:\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)",
"def generate_xml(self, provisioning):\n ET.SubElement(self.root, 'generator').text = __revision__\n ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n return self.provisioning2xml(provisioning)",
"def exportXml ( w, xml ):\n assert str ( type ( xml ) ) == \"<type 'str'>\"\n rawText = xml\n pattern = re.compile (r'[^\\S ]+')\n text = re.sub ( pattern, \"\", rawText )\n reparsed = MD.parseString ( text )\n w.write ( reparsed.toprettyxml ( indent = \"\\t\", encoding = \"UTF-8\" ) )",
"def write(self, filename=None, as_type='json'):\n if not filename:\n filename = self.uri\n self.create_output_dir(filename)\n if as_type == 'json':\n with open(filename, 'w') as outfile:\n outfile.write(self.transform_data(outformat=formats.JSON))\n elif as_type == 'shapefile':\n self.data.to_file(filename)\n else:\n raise NotImplementedError('{} not a valid type'.format(as_type))\n return self.uri"
] | [
"0.6364573",
"0.6153296",
"0.58370924",
"0.583494",
"0.5813206",
"0.5642924",
"0.5630074",
"0.56008315",
"0.5582877",
"0.55446607",
"0.5526882",
"0.5517534",
"0.551431",
"0.55121994",
"0.54558533",
"0.54547614",
"0.54296464",
"0.5400794",
"0.5307159",
"0.5298352",
"0.5290552",
"0.52734584",
"0.52723074",
"0.52351654",
"0.52017146",
"0.5196093",
"0.51834184",
"0.517945",
"0.51748395",
"0.5165714",
"0.515794",
"0.5148383",
"0.51355934",
"0.5133239",
"0.512838",
"0.5100207",
"0.5075658",
"0.50696677",
"0.50607014",
"0.50594354",
"0.50567293",
"0.50563705",
"0.5040579",
"0.5030068",
"0.50231415",
"0.5012452",
"0.50050735",
"0.50026363",
"0.5000305",
"0.49778914",
"0.49736404",
"0.49618572",
"0.49550623",
"0.49395743",
"0.49392092",
"0.48928508",
"0.48891768",
"0.48775566",
"0.48726216",
"0.48667747",
"0.48657677",
"0.48539105",
"0.4847482",
"0.4843755",
"0.48435774",
"0.48308513",
"0.48281708",
"0.48272654",
"0.48203313",
"0.4813469",
"0.4812597",
"0.48092604",
"0.4804398",
"0.48030624",
"0.4800453",
"0.4797909",
"0.4797909",
"0.47747996",
"0.47747874",
"0.47692934",
"0.47640422",
"0.47580427",
"0.47579172",
"0.4755772",
"0.4753217",
"0.47499028",
"0.47497386",
"0.47482222",
"0.47400284",
"0.4735575",
"0.4734286",
"0.47341242",
"0.47245035",
"0.47243568",
"0.4709466",
"0.4702511",
"0.4701057",
"0.4690661",
"0.4682284",
"0.46819466"
] | 0.4823362 | 68 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
URLFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.735201",
"0.6754294",
"0.67166066",
"0.67071074",
"0.66780305",
"0.65807486",
"0.6522693",
"0.6522693",
"0.65187657",
"0.6471306",
"0.6269984",
"0.62653935",
"0.6153201",
"0.6090701",
"0.60323846",
"0.60278016",
"0.6011661",
"0.60042846",
"0.59841794",
"0.5941162",
"0.59205276",
"0.5918955",
"0.59121054",
"0.5903962",
"0.5884743",
"0.5876164",
"0.5857109",
"0.5851559",
"0.583173",
"0.58274394",
"0.5816038",
"0.58061635",
"0.5784312",
"0.5755998",
"0.5755998",
"0.57360405",
"0.57051307",
"0.5701552",
"0.5687975",
"0.5650812",
"0.5618766",
"0.561154",
"0.5605911",
"0.56030387",
"0.5602799",
"0.55926436",
"0.5587559",
"0.5571399",
"0.5567558",
"0.55631375",
"0.555545",
"0.5550559",
"0.55490625",
"0.55470836",
"0.55410224",
"0.5519966",
"0.55098814",
"0.5492064",
"0.547102",
"0.5470936",
"0.54692423",
"0.5467515",
"0.54661024",
"0.54518676",
"0.54405665",
"0.5438651",
"0.54003173",
"0.5388153",
"0.5382598",
"0.5375904",
"0.5375076",
"0.53706104",
"0.5359634",
"0.5354708",
"0.5354708",
"0.5331472",
"0.5324531",
"0.53227526",
"0.5316361",
"0.5309617",
"0.5308968",
"0.53067",
"0.5306182",
"0.5299369",
"0.52990687",
"0.5287107",
"0.52791494",
"0.5277907",
"0.5276578",
"0.52742803",
"0.5270845",
"0.52608305",
"0.52524847",
"0.5244876",
"0.5239417",
"0.5234171",
"0.5224983",
"0.5215326",
"0.521457",
"0.5212088",
"0.5203955"
] | 0.0 | -1 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
URLFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.735201",
"0.6754294",
"0.67166066",
"0.67071074",
"0.66780305",
"0.65807486",
"0.6522693",
"0.6522693",
"0.65187657",
"0.6471306",
"0.6269984",
"0.62653935",
"0.6153201",
"0.6090701",
"0.60323846",
"0.60278016",
"0.6011661",
"0.60042846",
"0.59841794",
"0.5941162",
"0.59205276",
"0.5918955",
"0.59121054",
"0.5903962",
"0.5884743",
"0.5876164",
"0.5857109",
"0.5851559",
"0.583173",
"0.58274394",
"0.5816038",
"0.58061635",
"0.5784312",
"0.5755998",
"0.5755998",
"0.57360405",
"0.57051307",
"0.5701552",
"0.5687975",
"0.5650812",
"0.5618766",
"0.561154",
"0.5605911",
"0.56030387",
"0.5602799",
"0.55926436",
"0.5587559",
"0.5571399",
"0.5567558",
"0.55631375",
"0.555545",
"0.5550559",
"0.55490625",
"0.55470836",
"0.55410224",
"0.5519966",
"0.55098814",
"0.5492064",
"0.547102",
"0.5470936",
"0.54692423",
"0.5467515",
"0.54661024",
"0.54518676",
"0.54405665",
"0.5438651",
"0.54003173",
"0.5388153",
"0.5382598",
"0.5375904",
"0.5375076",
"0.53706104",
"0.5359634",
"0.5354708",
"0.5354708",
"0.5331472",
"0.5324531",
"0.53227526",
"0.5316361",
"0.5309617",
"0.5308968",
"0.53067",
"0.5306182",
"0.5299369",
"0.52990687",
"0.5287107",
"0.52791494",
"0.5277907",
"0.5276578",
"0.52742803",
"0.5270845",
"0.52608305",
"0.52524847",
"0.5244876",
"0.5239417",
"0.5234171",
"0.5224983",
"0.5215326",
"0.521457",
"0.5212088",
"0.5203955"
] | 0.0 | -1 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
URLFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.735201",
"0.6754294",
"0.67166066",
"0.67071074",
"0.66780305",
"0.65807486",
"0.6522693",
"0.6522693",
"0.65187657",
"0.6471306",
"0.6269984",
"0.62653935",
"0.6153201",
"0.6090701",
"0.60323846",
"0.60278016",
"0.6011661",
"0.60042846",
"0.59841794",
"0.5941162",
"0.59205276",
"0.5918955",
"0.59121054",
"0.5903962",
"0.5884743",
"0.5876164",
"0.5857109",
"0.5851559",
"0.583173",
"0.58274394",
"0.5816038",
"0.58061635",
"0.5784312",
"0.5755998",
"0.5755998",
"0.57360405",
"0.57051307",
"0.5701552",
"0.5687975",
"0.5650812",
"0.5618766",
"0.561154",
"0.5605911",
"0.56030387",
"0.5602799",
"0.55926436",
"0.5587559",
"0.5571399",
"0.5567558",
"0.55631375",
"0.555545",
"0.5550559",
"0.55490625",
"0.55470836",
"0.55410224",
"0.5519966",
"0.55098814",
"0.5492064",
"0.547102",
"0.5470936",
"0.54692423",
"0.5467515",
"0.54661024",
"0.54518676",
"0.54405665",
"0.5438651",
"0.54003173",
"0.5388153",
"0.5382598",
"0.5375904",
"0.5375076",
"0.53706104",
"0.5359634",
"0.5354708",
"0.5354708",
"0.5331472",
"0.5324531",
"0.53227526",
"0.5316361",
"0.5309617",
"0.5308968",
"0.53067",
"0.5306182",
"0.5299369",
"0.52990687",
"0.5287107",
"0.52791494",
"0.5277907",
"0.5276578",
"0.52742803",
"0.5270845",
"0.52608305",
"0.52524847",
"0.5244876",
"0.5239417",
"0.5234171",
"0.5224983",
"0.5215326",
"0.521457",
"0.5212088",
"0.5203955"
] | 0.0 | -1 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
URLFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.7352181",
"0.6755271",
"0.671636",
"0.6705414",
"0.66772985",
"0.65812147",
"0.6522757",
"0.6522757",
"0.65198946",
"0.6471234",
"0.6269759",
"0.6264971",
"0.61534846",
"0.6090959",
"0.6031979",
"0.6028283",
"0.6011439",
"0.60043883",
"0.59848917",
"0.5941512",
"0.5920574",
"0.5918451",
"0.5910905",
"0.59036326",
"0.5884433",
"0.58759487",
"0.5858254",
"0.5852437",
"0.58303636",
"0.58272463",
"0.5816296",
"0.5805918",
"0.5782919",
"0.5755556",
"0.5755556",
"0.5735123",
"0.5704928",
"0.57013756",
"0.56892204",
"0.5650952",
"0.5618159",
"0.56113386",
"0.56053746",
"0.5602938",
"0.560288",
"0.5591872",
"0.55867225",
"0.557134",
"0.5566634",
"0.55629444",
"0.55554736",
"0.555135",
"0.55489",
"0.554503",
"0.55412763",
"0.5519735",
"0.5509313",
"0.5491781",
"0.5471008",
"0.54697806",
"0.54690605",
"0.5466586",
"0.5464822",
"0.5450516",
"0.54404145",
"0.54390544",
"0.5399531",
"0.53892744",
"0.53827345",
"0.5376257",
"0.5375342",
"0.53689796",
"0.53596133",
"0.53544545",
"0.53544545",
"0.5329608",
"0.53256017",
"0.53217983",
"0.53168994",
"0.5310465",
"0.53085923",
"0.5306728",
"0.53056",
"0.52991426",
"0.5298824",
"0.52859306",
"0.5278563",
"0.5278401",
"0.5274871",
"0.527454",
"0.52701086",
"0.52603996",
"0.5252269",
"0.5245309",
"0.5239325",
"0.5235285",
"0.5225079",
"0.5214814",
"0.521395",
"0.52127105",
"0.5202487"
] | 0.0 | -1 |
Return formatted text, properly escaped and with a link reference if not in titleMode | def formatOutput(self, storedText, titleMode, altText='', internal=False):
if titleMode or not internal:
return TextFormat.formatOutput(self, storedText, titleMode,
internal)
paths = storedText.split('\n')
results = []
for url in paths:
# add prefix/suffix within the executable path:
url = TextFormat.formatOutput(self, url, titleMode, internal)
path = url
if not URLFormat.hasMethodRe.match(path):
path = u'%s%s' % (self.URLMethod, path)
results.append(u'<a href="%s">%s</a>' %
(escape(path, treedoc.escDict), altText or url))
return u'<br />'.join(results) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n altText = ''\n if self.linkAltField:\n field = item.nodeFormat().findField(self.linkAltField)\n if field:\n altText = field.outputText(item, titleMode, internal)\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, altText, internal)\n return ''",
"def test_link_title(self):\n comment = \"[link](http://foo.com \\\"bar\\\")\"\n comment_md = Markdown().render(comment)\n self.assertEqual(comment_md, '<p><a rel=\"nofollow\" href=\"http://foo.com\" title=\"bar\">link</a></p>')",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def format_url(self, url, text):\r\n return u'<a href=\"%s\">%s</a>' % (escape(url), text)",
"def link(self, link, title, text):\n link = escape_link(link)\n return [MdStyleInstructionLink(link)] + text",
"def visit_title_reference(self, node):\n self.body.append('\\\\emph{\\\\textbf{')",
"def link(self):\n return f\"[{self.numbered_title}]({self.html_url})\"",
"def __html__(self) -> str:\n components = [\n self.attributee_html,\n f'\"{self.linked_title}\"',\n self.date.string if self.date else '',\n ]\n return self.components_to_html(components)",
"def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n path = u'<a href=\"%s\">%s</a>' % (escape(path, treedoc.escDict),\n altText or url)\n results.append(TextFormat.formatOutput(self, path, titleMode,\n internal))\n return u'<br />'.join(results)",
"def test_link_title_without_no_follow(self):\n comment = \"[link](http://foo.com \\\"bar\\\")\"\n comment_md = Markdown(no_follow=False).render(comment)\n self.assertEqual(comment_md, '<p><a href=\"http://foo.com\" title=\"bar\">link</a></p>')",
"def content(self, uid, text):\n\n if uid and isinstance(uid, str) and uid.lower().startswith(\"http\"):\n return f\"<a href='{uid}' rel='noopener noreferrer' target='blank'>{text}</a>\"\n\n return text",
"def linkified_description(self):\n links = []\n def linkify(matchobj, links=links):\n if '|' in matchobj.group(1):\n url = matchobj.group(1).split('|')\n link = format_html('<a href=\"{0}\" target=\"_blank\">{1}</a>', url[0], url[1])\n else:\n link = format_html('<a href=\"{0}\" target=\"_blank\">{1}</a>', self.url, matchobj.group(1))\n links.append(link)\n return '{%d}' % (len(links) - 1)\n\n fmt = re.sub(r'\\[\\[([^\\]]+)\\]\\]', linkify, self.description)\n return format_html(fmt, *links)",
"def get_text(downgrade_titles=False):",
"def convert_text_to_rouge_format(text, title=\"dummy title\"):\n sentences = text.split(\"\\n\")\n sent_elems = [\n \"<a name=\\\"{i}\\\">[{i}]</a> <a href=\\\"#{i}\\\" id={i}>\"\n \"{text}</a>\".format(i=i, text=sent)\n for i, sent in enumerate(sentences, start=1) if sent != '']\n html = \"\"\"<html>\n<head>\n<title>{title}</title>\n</head>\n<body bgcolor=\"white\">\n{elems}\n</body>\n</html>\"\"\".format(title=title, elems=\"\\n\".join(sent_elems))\n\n return html",
"def md_link(link_text, link_target):\n return '[%s](%s)' % (md_escape(link_text, characters=']'),\n md_escape(link_target, characters=')'))",
"def formatOutput(self, storedText, titleMode, internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = ['<img src=\"%s\">' % escape(url, treedoc.escDict) for url\n in paths]\n return u'<br />'.join(results)",
"def headline(self):\r\n return '%s%s %s%s' % (BLUE, self.title,\r\n NORMAL, self.link)",
"def link_html(text: str, href: str) -> str:\n return '<a href=\"{}\">{}</a>'.format(href, text)",
"def get_title(text, uuid=None):\n if uuid is not None:\n text += get_provenance_link(uuid)\n title = pn.Row(pn.pane.HTML('<h2>{}</h2>'.format(text)), align='start')\n\n return title",
"def title(text, level=0):\n return '\\n' + text + '\\n' + '=-~_#%^' [level] * len(text) + '\\n\\n'",
"def format_header(self, text: str, anchor: Optional[str] = None) -> str:",
"def html_title(title):\n return '<center><h1>%s</h1></center>' % (title)",
"def print_with_title(title, content, before='', after='', hl='='):\n cont_maxlen = max(len(s) for s in content.split('\\n'))\n hl_len = max(cont_maxlen, len(title))\n print('{}{}\\n{}\\n{}{}'.format(before, title, hl * hl_len, content, after))",
"def format_title(self, data):\n return data",
"def formatted_reference(html):\n converter = html2text.HTML2Text()\n converter.ignore_links = True\n converter.body_width = 0\n\n text = converter.handle(html)\n text = re.sub(' +$', '', text, flags=re.MULTILINE)\n text = re.sub(r'\\n\\n+', '\\n\\n', text, flags=re.MULTILINE)\n return text",
"def PROPER(text):\n return text.title()",
"def link(text, link_func):\n def object_formatter(v, c, m, p):\n \"\"\"Format object view link.\"\"\"\n return Markup('<a href=\"{0}\">{1}</a>'.format(\n link_func(m), text))\n return object_formatter",
"def links_to_text(self):\r\n self.parser.stripTags(self.get_top_node(), 'a')",
"def getStoryTitle(self, source):\n titleStart = source.find('>', source.find('>')+1) + 1\n titleEnd = source.find('</a>')\n title = source[titleStart:titleEnd]\n title = title.lstrip() # Strip trailing whitespace characters.\n return title",
"def editModeHeading(text):\n return u'<p style=\"editModeHeading\">%s</p>' % text",
"def formatOutput(self, storedText, titleMode, internal=False):\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def get_link_description(self):\n desc = super().get_link_description()\n desc['title'] = self.title\n return desc",
"def title(self, string):\n return self.bold(string)",
"def format_tag(self, tag, text):\r\n return u'<a href=\"http://{domain}/hashtag/{tag}\" data-tag=\"{tag}\">#{text}</a>'.format(\r\n **dict(domain=self.domain, tag=urllib.quote(text.encode('utf-8')), text=text))\r\n\r\n #return u'<a href=\"http://%s/hashtag/%s\" data-tag=\"\">%s%s</a>' \\\r\n # % (self.domain, , tag, text)\r",
"def gen_title_rst(txt):\n # Just add a few useful directives\n txt = \".. highlight:: cmake\\n\\n\" + txt\n return txt",
"def html_title(self, title=None):\r\n if title is None:\r\n return \"<title>PyBossa</title>\"\r\n else:\r\n return \"<title>PyBossa · %s</title>\" % title",
"def escape_if_needed(text, options):\n if hasattr(text, '__html__'):\n # Text has escape itself:\n return to_string(text.__html__())\n if need_to_escape(options):\n return escape(to_string(text))\n return to_string(text)",
"def __html__(self) -> str:\n components = [\n self.attributee_html,\n self.linked_title if self.title else 'untitled document',\n self.date.string if self.date else '',\n self.descriptive_phrase,\n f'archived in {self.collection}' if self.collection else '',\n ]\n return self.components_to_html(components)",
"def _get_title_tag(self, item):\n tag = '<{heading}><a href=\"{href}\">{title}</a></{heading}>'\n if self._field_is_visible(\"title\"):\n tile_conf = self.get_tile_configuration()\n title_conf = tile_conf.get(\"title\", None)\n if title_conf:\n heading = title_conf.get(\"htmltag\", \"h2\")\n href = item.absolute_url()\n title = item.Title()\n return tag.format(heading=heading, href=href, title=title)",
"def slack_link(url, text=\"\"):\n if text:\n return \"<%s|%s>\" % (url, text)\n\n else:\n return \"<%s>\" % url",
"def get_title():",
"def get_HTML_box(self, url):\n who = self.getShortAuthor()\n if self.comments is None:\n title = \"\"\n else:\n title = html.escape(self.comments)\n return '<a href=\"%s\" title=\"%s\">%s</a>' % (url,\n title,\n html.escape(who))",
"def object_formatter(v, c, m, p):\n return Markup('<a href=\"{0}\">{1}</a>'.format(\n link_func(m), text))",
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, internal)\n return ''",
"def ref_to_link(txt):\n text = txt.group(1) # because it was a match in a regular expression\n\n thecite, everythingelse = first_bracketed_string(text)\n thecite = thecite[1:-1] # strip curly brackets\n thecite = thecite.replace(\"\\\\\",\"\") # \\href --> href\n\n refs = thecite.split(\",\")\n ans = \"\"\n\n # print \"refs\",refs\n\n for ref in refs:\n ref = ref.strip() # because \\cite{A, B, C,D} can have spaces\n this_link = \"\"\n if ref.startswith(\"href\"):\n the_link = re.sub(r\".*{([^}]+)}{.*\", r\"\\1\", ref)\n click_on = re.sub(r\".*}{([^}]+)}\\s*\", r\"\\1\", ref)\n this_link = '{{ LINK_EXT(\"' + click_on + '\",\"' + the_link + '\") | safe}}'\n elif ref.startswith(\"doi\"):\n ref = ref.replace(\":\",\"\") # could be doi:: or doi: or doi\n the_doi = ref[3:] # remove the \"doi\"\n this_link = '{{ LINK_EXT(\"' + the_doi + '\",\"https://doi.org/' + the_doi + '\")| safe }}'\n elif ref.lower().startswith(\"mr\"):\n ref = ref.replace(\":\",\"\")\n the_mr = ref[2:] # remove the \"MR\"\n this_link = '{{ LINK_EXT(\"' + 'MR:' + the_mr + '\", '\n this_link += '\"http://www.ams.org/mathscinet/search/publdoc.html?pg1=MR&s1='\n this_link += the_mr + '\") | safe}}'\n elif ref.lower().startswith(\"arxiv\"):\n ref = ref.replace(\":\",\"\")\n the_arx = ref[5:] # remove the \"arXiv\"\n this_link = '{{ LINK_EXT(\"' + 'arXiv:' + the_arx + '\", '\n this_link += '\"http://arxiv.org/abs/'\n this_link += the_arx + '\")| safe}}'\n\n\n if this_link:\n if ans:\n ans += \", \"\n ans += this_link\n\n return '[' + ans + ']' + everythingelse",
"def get_url(self, filename, query_para=None, **url_args):\r\n from uliweb.core.html import Tag\r\n \r\n title = url_args.pop('title', filename)\r\n text = url_args.pop('text', title)\r\n query_para = query_para or {}\r\n return str(Tag('a', title, href=self.get_href(filename, **query_para), **url_args))",
"def markdown_item(title, url):\n print('* [{0}]({1})'.format(\n markdown_escape(title),\n markdown_escape(url),\n ))",
"def complete_alt_title(self, obj):\n return str(obj)",
"def generate_title(self, title=None):\n if title is None:\n title = self.header.get('title', self.title)\n\n title = self.generate(title)\n title = title.replace('<p>', '').replace('</p>', '')\n # no trailing newlines\n title = re.sub(r'\\n+', ' ', title).rstrip()\n return title",
"def __str__(self) -> str:\n return textwrap.wrap(self.title, _POST_TITLE_MAX_LENGTH // 4)[0]",
"def link_breaker(text):\n res = ''\n state = 0\n for char in text:\n if state == 0:\n if char == 'h':\n state = 1\n else:\n res += char\n elif state == 1:\n if char == 't':\n state = 2\n else:\n res += 'h' + char\n state = 0\n elif state == 2:\n if char == 't':\n state = 3\n else:\n res += 'ht' + char\n state = 0\n elif state == 3:\n if char == 'p':\n state = 4\n else:\n res += 'htt' + char\n state = 0\n elif state == 4:\n if char == ' ':\n state = 0\n res += 'ext_link '\n return res",
"def book_title(book_text):\n search = re.search(\"Title:(.*)\", book_text)\n title = search.group(1).replace(\"\\r\", \" \").strip()\n return title",
"def helptext(self):\n return \"\"",
"def title(string):\n print(\"{}\\n{}\\n\".format(bold(string), underline(string, \"=\")))",
"def links(self, text):\n\n # For some reason, the part of the regex below that matches the url\n # does not match a trailing parenthesis. It gets caught by tail, and\n # we check later to see if it should be included as part of the url.\n pattern = r'''\n (?P<pre>^|(?<=[\\s>.\\(\\|])|[{[])? # leading text\n \" # opening quote\n (?P<atts>%s) # block attributes\n (?P<text>[^\"]+?) # link text\n \\s? # optional space\n (?:\\((?P<title>[^)]+?)\\)(?=\"))? # optional title\n \": # closing quote, colon\n (?P<url>%s+?) # URL\n (?P<slash>\\/)? # slash\n (?P<post>[^\\w\\/]*?) # trailing text\n (?P<tail>[\\]})]|(?=\\s|$|\\|)) # tail\n ''' % (self.c, self.urlch)\n\n text = re.compile(pattern, re.X | re.U).sub(self.fLink, text)\n\n return text",
"def get_title_repr(self) -> str:\n try:\n return Title[self.title].value\n except (KeyError, ValueError):\n pass",
"def __str__(self):\n return '<a href=\"%s\" class=\"%s\" %s>%s</a>' % (self.url, self.cssclass, self.options, self.text)",
"def fmt(e):\n name = str(e.label.first() if hasattr(e, 'label') and e.label else e)\n if re.match(r'^[a-z]+://', name):\n return link.format(name=name, url=name)\n if hasattr(e, 'label') and e.label:\n name = e.label.first()\n url = name if re.match(r'^[a-z]+://', name) else '#' + name\n return link.format(name=name, url=url)\n elif re.match(r'^[a-z]+://', str(e)):\n return link.format(name=e, url=e)\n else:\n return str(e).replace('owl.', 'owl:')",
"def clean_title_text(title: str, anchor_characters: str | None = None) -> str:\n if anchor_characters is None:\n anchor_characters = ANCHOR_CHARACTERS\n return title.strip(anchor_characters).replace(\"\\xa0\", \" \").strip()",
"def link_to_modal(link_text, index, autoescape=True): # pylint: disable=unused-argument\n link = (\n '<a'\n ' href=\"#!\"'\n ' class=\"text-underline view-course-details-link\"'\n ' id=\"view-course-details-link-{index}\"'\n '>{link_text}</a>'\n ).format(\n index=index,\n link_text=link_text,\n )\n return mark_safe(link)",
"def fix_document(key, value, _format, _meta):\n if key == \"Link\":\n url = value[2][0]\n if url.startswith(\"user-manual\") or url.startswith(\"developers-guide\"):\n # Return the link text\n return value[1]\n # Reformat the text inside block quotes\n elif key == \"BlockQuote\":\n try:\n first_string = value[0][\"c\"][0][\"c\"]\n if first_string == \"[!NOTE]\":\n value[0][\"c\"][0] = Strong([Str(\"Note:\")])\n return BlockQuote(value)\n elif first_string == \"[!INFO]\":\n value[0][\"c\"][0] = Strong([Str(\"Info:\")])\n return BlockQuote(value)\n elif first_string == \"[!TIP]\":\n value[0][\"c\"][0] = Strong([Str(\"Tip:\")])\n return BlockQuote(value)\n elif first_string == \"[!WARNING]\":\n value[0][\"c\"][0] = Strong([Str(\"Warning:\")])\n return BlockQuote(value)\n elif first_string == \"[!ATTENTION]\":\n value[0][\"c\"][0] = Strong([Str(\"Attention:\")])\n return BlockQuote(value)\n except Exception:\n return\n return",
"def html_link(self):\n if self.id:\n unescaped_url = f'/themes/{self.name or \"\"}--{self.id}'\n return mark_safe(f'<a href=\"{self.url_path}\" target=\"_blank\">{unescaped_url}</a>')\n else:\n return 'Pas encore live'",
"def outputText(self, item, titleMode, internal=False):\n field = None\n while not field:\n item = item.parent\n if item:\n field = item.nodeFormat().findField(self.name)\n else:\n return ''\n return field.outputText(item, titleMode, internal)",
"def make_main_title(self, end, end_center=False):\n main_title = r\"\\begin{center}\"\n if self.detector is not None:\n main_title += \"%s \"%self.detector\n if self.selection is not None:\n main_title += \"%s Event Selection \"%self.selection\n main_title += end\n if end_center:\n main_title += r\"\\end{center}\"\n return main_title",
"def emph_text(text):\n\n if use_color():\n return colorama.Style.BRIGHT + text + colorama.Style.RESET_ALL\n else:\n return text",
"def outputText(self, item, titleMode, internal=False):\n for num in range(self.parentLevel):\n item = item.parent\n if not item:\n return ''\n field = item.nodeFormat().findField(self.name)\n if not field:\n return ''\n return field.outputText(item, titleMode, internal)",
"def _inline(line):\n if len(line) == 0:\n return ''\n\n # Regexp of protocols supported in hyperlinks (should be protocols that\n # we can expect web browsers to support)\n protocols = \"https?|ftp|sftp|file|afs|nfs\"\n\n\n # Prepare usual links: prefix every \"www.\" with \"http://\"\n # unless there is a // before\n line = re.sub('(^|\\s|[^\\/])(www\\.)', '\\\\1http://\\\\2', line, re.I);\n\n # replace the @ sign with an HTML entity, if it is used within\n # an url (e.g. for pointers to mailing lists). This way, the\n # @ sign doesn't get mangled in the e-mail markup code\n # below. See bug #2689 on http://gna.org/ for reference.\n line = re.sub(\"([a-z]+://[^<>[:space:]]+)@\", \"\\\\1@\", line, re.I)\n\n # Prepare the markup for normal links, e.g. http://test.org, by\n # surrounding them with braces []\n # (& = begin of html entities, it means a end of string unless\n # it is & which itself is the entity for &)\n line = re.sub('(^|\\s|[^\\[])((' + protocols + '):\\/\\/(&|[^\\s&]+[a-z0-9\\/^])+)',\n '\\\\1[\\\\2]', line, re.I)\n\n # do a markup for mail links, e.g. info@support.org\n # (do not use utils_emails, this does extensive database\n # search on the string\n # and replace addresses in several fashion. Here we just want to make\n # a link). Make sure that 'cvs -d:pserver:anonymous@cvs.sv.gnu.org:/...'\n # is NOT replaced.\n line = re.sub(\"(^|\\s)([a-z0-9_+-.]+@([a-z0-9_+-]+\\.)+[a-z]+)(\\s|$)\",\n '\\\\1' + '<a href=\"mailto:\\\\2\">\\\\2</a>' + '\\\\4', line, re.I)\n\n # Links between items\n # FIXME: it should be i18n, but in a clever way, meaning that everytime\n # a form is submitted with such string, the string get converted in\n # english so we always get the links found without having a regexp\n # including every possible language.\n # Trackers URLs disabled until trackers are actually implemented :)\n #trackers = {\n # \"bugs?\" : \"bugs/?\",\n # \"support|sr\" : \"support/?\",\n # \"tasks?\" : \"task/?\",\n # \"patch\" : \"patch/?\",\n # # In this case, we make the link pointing to support, it wont matter,\n # # the download page is in every tracker and does not check if the tracker\n # # is actually used\n # \"files?\" : \"support/download.php?file_id=\",\n # }\n #for regexp,link in trackers:\n # # Allows only two white space between the string and the numeric id\n # # to avoid having too time consuming regexp. People just have to pay\n # # attention.\n # line = re.sub(\"(^|\\s|\\W)($regexp)\\s{0,2}#([0-9]+)\",\n # '\\1<em><a href=\"' + 'sys_home'\n # + link + '\\\\3\">\\\\2 #\\\\3</a></em>',\n # line, re.I)\n\n # add an internal link for comments\n line = re.sub('(comments?)\\s{0,2}#([0-9]+)',\n '<em><a href=\"#comment\\\\2\">\\\\1 #\\\\2</a></em>',\n line, re.I)\n\n # Add support for named hyperlinks, e.g.\n # [http://savane-forge.org/ Text] -> <a href=\"http://savane-forge.org/\">Text</a>\n line = re.sub(\n # find the opening brace '['\n '\\['\n # followed by the protocol, either http:// or https://\n + '((' + protocols + '):\\/\\/'\n # match any character except whitespace or the closing\n # brace ']' for the actual link\n + '[^\\s\\]]+)'\n # followed by at least one whitespace\n + '\\s+'\n # followed by any character (non-greedy) and the\n # next closing brace ']'\n + '(.+?)\\]',\n '<a href=\"\\\\1\">\\\\3</a>', line)\n\n # Add support for unnamed hyperlinks, e.g.\n # [http://savane-forge.org/] -> <a href=\"http://savane-forge.org/\">http://savane-forge.org/</a> \n line = re.sub(\n # find the opening brace '['\n '\\['\n # followed by the protocol, either http:// or https://\n # (FIXME: which protocol does it makes sense to support, which one\n # should we ignore?)\n + '((' + protocols + '):\\/\\/'\n # match any character except whitespace (non-greedy) for\n # the actual link, followed by the closing brace ']'\n + '[^\\s]+?)\\]',\n '<a href=\"\\\\1\">\\\\1</a>', line)\n\n # *word* -> <strong>word</strong>\n line = re.sub(\n # find an asterisk\n '\\*'\n # then one character (except a space or asterisk)\n + '([^* ]'\n # then (optionally) any character except asterisk\n + '[^*]*?)'\n # then an asterisk\n + '\\*',\n '<strong>\\\\1</strong>', line)\n\n # _word_ -> <em>word</em>\n line = re.sub(\n # allow for the pattern to start at the beginning of a line.\n # if it doesn't start there, the character before the slash\n # must be either whitespace or the closing brace '>', to\n # allow for nested html tags (e.g. <p>_markup_</p>).\n # Additionally, the opening brace may appear.\n # See bug #10571 on http://gna.org/ for reference.\n '(^|\\s+|>|\\()'\n # match the underscore\n + '_'\n # match any character (non-greedy)\n + '(.+?)'\n # match the ending underscore and either end of line or\n # a non-word character\n + '_(\\W|$)',\n '\\\\1<em>\\\\2</em>\\\\3',\n line)\n\n return line",
"def textual(title, ordering_field=None):\n def decorator(func):\n def wraps(self, obj):\n result = func(self, obj)\n return result if result else u'---'\n\n wraps.short_description = title\n wraps.allow_tags = True\n\n if ordering_field:\n wraps.admin_order_field = ordering_field\n\n return wraps\n return decorator",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def get_anchor_tag(self):\n return f\"<a href={self.get_absolute_url()}>{self.display_name}</a>\"",
"def detail_link(db_obj, text=None):\n\n def build_link(obj):\n name = str(obj) if text is None else text\n return _make_link(obj.detail_url(), name)\n\n return mark_safe(', '.join(map(build_link, as_list(db_obj))))",
"def to_markdown(self):\n s = \"[\" + self.label + \"]\"\n if self.is_reflink:\n s += \": \" + self.url\n else:\n s += \"(\" + self.url + \")\"\n return s",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def rich(text):\n return full(text, False)",
"def autoLink(self, text):\n\n pattern = re.compile(r\"\"\"\\b((?:https?://|www\\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}/)(?:[^\\s()<>]+|\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\))+(?:\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\)|[^\\s`!()\\[\\]{};:'\".,<>?«»“”‘’]))\"\"\",\n re.U | re.I)\n return pattern.sub(r'\"$\":\\1', text)",
"def wiki_link(text):\n return wiki_link_pattern.sub(get_link, text)",
"def show_title():\r\n complement = (\r\n '\\n __ ')\r\n title = ('\\n _______ _______________ ____ _______ __ ___ _ _______/ /_ ____ _____ ____ ____ ')\r\n title += ('\\n / ___/ / / / ___/ ___/ _ \\/ __ \\/ ___/ / / / / _ \\| |/_/ ___/ __ \\/ __ `/ __ \\/ __ `/ _ \\ ')\r\n title += ('\\n/ /__/ /_/ / / / / / __/ / / / /__/ /_/ / / __/> </ /__/ / / / /_/ / / / / /_/ / __/ ')\r\n title += ('\\n\\___/\\__,_/_/ /_/ \\___/_/ /_/\\___/\\__, / \\___/_/|_|\\___/_/ /_/\\__,_/_/ /_/\\__, /\\___/ ')\r\n title += ('\\n /____/ /____/ ')\r\n # Add Styles\r\n break_line = ('-' * len(complement) + \"\\n\") * 2\r\n print(\"{}\\n{}\\n{}\\n\".format(break_line, title, break_line))",
"def formatOutput(self, storedText, titleMode, internal=False):\n if storedText not in self.formatList:\n try:\n storedText = GenBoolean(storedText).boolStr(self.format)\n except GenBooleanError:\n storedText = _errorStr\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def format_article_list(title, source, link):\n i = 0\n length = 120\n space = \" \"\n article_headline = \"| \" + title + \" - \" + source\n\n if len(article_headline) < length:\n for i in range(length - len(article_headline)):\n article_headline += space\n article_headline += \"|\"\n\n if len(link) < length:\n for i in range(length - len(link)):\n link += space\n link += \"|\"\n\n return [article_headline, link]",
"def group_title(self, group):\n group_title = group.getProperty('title')\n if self.short:\n splitted = group_title.split('(')\n if len(splitted) > 1:\n group_title = group_title.split('(')[-1][:-1]\n return html.escape(group_title)",
"def SearchableText(self):\n ctool = getToolByName(self, 'portal_cpscalendar')\n if getattr(ctool, 'event_fulltext_index', False):\n return '%s %s' % (self.title, self.description)\n return ''",
"def format_heading(self, level, text):\n underlining = ['=', '-', '~', ][level-1] * len(text)\n return '%s\\n%s\\n\\n' % (text, underlining)",
"def trans(monitext):\n result = ''\n last_line = 'empty'\n\n while monitext:\n # newline character or empty line(s)\n matched = re.match(r'\\n+', monitext, re.M)\n\n if matched:\n result += matched.group()\n if len(matched.group()) > 1:\n last_line = 'empty'\n elif last_line == 'title':\n result += '\\n'\n last_line = 'empty'\n monitext = monitext[matched.end():]\n continue\n\n # code block\n matched = re.match(r'{{{.*?\\n((\\n|.)*?)\\n}}}', monitext, re.M)\n\n if matched:\n body = matched.groups()[0]\n result += '\\n\\t' + '\\n\\t'.join(body.split('\\n'))\n monitext = monitext[matched.end():]\n last_line = 'code'\n continue\n\n # header\n matched = re.match(r'^(=+) (.+) (=+)', monitext)\n\n if matched:\n title = matched.groups()[1]\n level = len(matched.groups()[0])\n\n if last_line != 'empty':\n result += '\\n'\n\n if level < 4:\n underscore = {2 : '=', 3 : '-'}[level] * mbstrlen(title)\n result += title + os.linesep + underscore\n else:\n result += ('#' * level) + \" \" + title\n monitext = monitext[matched.end():]\n\n last_line = 'title'\n\n continue\n\n # link\n matched = re.match(r'(.*)\\[([^\\s]+[ \\t]+)?(.+)\\]', monitext)\n\n if matched:\n pre = matched.groups()[0]\n url = matched.groups()[1]\n if url:\n url = url.strip()\n name = matched.groups()[2]\n\n if url:\n replaced = \"%s[%s](%s)\" % (pre, name, url)\n else:\n replaced = \"%s[%s](%s)\" % (pre, name, name)\n\n monitext = monitext[:matched.start()] + replaced\\\n + monitext[matched.end():]\n\n # important\n monitext = re.sub(r'\\'\\'\\'(.*?)\\'\\'\\'', r'**\\1**', monitext)\n\n # italic\n monitext = re.sub(r'\\'\\'(.*?)\\'\\'', r'_\\1_', monitext)\n\n # list\n matched = re.match(r'^(\\s*)\\* (.*)', monitext)\n\n if matched:\n depth = len(matched.groups()[0])\n body = matched.groups()[1]\n result += (depth - 1) * '\\t' + '* ' + body\n monitext = monitext[matched.end():]\n\n last_line = 'others'\n\n try:\n # Go to the next line\n index = monitext.index('\\n')\n result += monitext[:index]\n monitext = monitext[index:]\n except ValueError:\n result += monitext\n break\n\n return result",
"def title_string(self):\n return ' '.join(self.title).replace(' - ', '')",
"def formatText(s, bold=False, underlined=False, negative=False):\n\n if not FORMATTING_AVAILABLE:\n return s\n\n head = \"\"\n if bold: head += \"\\033[1m\"\n if underlined: head += \"\\033[4m\"\n if negative: head += \"\\033[7m\"\n\n return head + s + \"\\033[0m\"",
"def render_link(url, text=None):\n try:\n url_validator(url)\n return \"<a href='%s'>%s</a>\" % (url, text if text else url)\n except ValidationError:\n return url",
"def to_html(self) -> str:\n return f'''\n <a href=\"{self.link}\"> ({self.source_name}, {self.timestamp.strftime('%Y')}) </a>\n '''",
"def format_title(self, title):\n new_title = ''.join(word.lower().strip('!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ ') for word in title)\n return new_title",
"def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d",
"def insert_link(self, text, href):\n self.insert_text('\\n<a href=\"%s\">%s</a>' % (href, text))",
"def urlLink(self, text=None, url=None, attrs={}):\n if not text:\n text = self.titleOrId()\n text = escape(text)\n if not self.checkRemotePerm(\"View\", self):\n return text\n if not url:\n url = self.getPrimaryUrlPath()\n if len(attrs):\n return '<a href=\"%s\" %s>%s</a>' % (url,\n ' '.join('%s=\"%s\"' % (x,y) for x,y in attrs.items()),\n text)\n else:\n return '<a href=\"%s\">%s</a>' % (url, text)",
"def get_title(self):\n if not hasattr(self, '_title'):\n self._title = 'NO TITLE'\n if self._title:\n title = _(self._title)\n title = title.replace('&', '&') \n title = title.replace('\"', '"')\n return title\n else:\n return u''",
"def _get_title_and_explanation(self):\n title = \"\"\n more_lines = []\n if self.__doc__:\n # Find the first non-empty line in the docstring. If there is\n for line in self.__doc__.split(\"\\n\")[:-1]: # strip off last line, always blank\n line = line.strip()\n if line:\n if not title:\n # We don't have the title set, yet, so we know this is the first line.\n if line.endswith(\".\"):\n # Don't want a period at the end of a title to make it look\n # better.\n title = line[:-1]\n else:\n title = line\n continue\n if not line and not more_lines:\n # We don't need empty lines at the start of the explanation\n continue\n # Add up the lines of the explanation text\n if line.startswith(\"*\"):\n line = f\" {line}\"\n\n more_lines.append(line or \"<br> <br>\") # Empty lines become line break\n return ((title or \"A resource\"), \" \".join(more_lines))",
"def __str__(self):\n return \"{title}\".format(title=self.title)",
"def pretty_title(title):\n output = '-' * 5 + ' ' + title + ' ' + '-' * 5\n return output",
"def resource_link_title(self):\n return self.request.POST.get(\"resource_link_title\", self.resource_link_id)",
"def emphasize(text: str, tablefmt: str | TableFormat, strong: bool = False) -> str:\n # formats a title for a table produced using tabulate,\n # in the formats tabulate understands\n if tablefmt in [\"html\", \"unsafehtml\", html_with_borders_tablefmt]: # type: ignore\n if strong:\n emph_text = f\"<strong>{text}</strong>\"\n else:\n emph_text = f\"<em>{text}</em>\"\n elif tablefmt in [\"latex\", \"latex_raw\", \"latex_booktabs\", \"latex_longtable\"]:\n if strong:\n emph_text = r\"\\textbf{\" + text + r\"}\"\n else:\n emph_text = r\"\\emph{\" + text + r\"}\"\n else: # use the emphasis for tablefmt == \"pipe\" (Markdown)\n star = \"**\" if strong else \"*\"\n emph_text = f\"{star}{text}{star}\"\n return emph_text",
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def get_description(self):\n if self.desc_format == MARKDOWN_FORMAT:\n return markdown.markdown(self.desc, safe_mode='escape') \n elif self.desc_format == TEXT_FORMAT:\n return html.escape(self.desc)",
"def get_description(self):\n if self.desc_format == MARKDOWN_FORMAT:\n return markdown.markdown(self.desc, safe_mode='escape') \n elif self.desc_format == TEXT_FORMAT:\n return html.escape(self.desc)"
] | [
"0.64514065",
"0.63557965",
"0.6355717",
"0.6343572",
"0.62287307",
"0.61965793",
"0.61361015",
"0.607787",
"0.60609573",
"0.6039025",
"0.6030655",
"0.6005965",
"0.5958118",
"0.58831125",
"0.58806616",
"0.5844087",
"0.58333874",
"0.57946926",
"0.5783884",
"0.5778737",
"0.5708155",
"0.570722",
"0.5690316",
"0.5686931",
"0.56657106",
"0.56319034",
"0.56158215",
"0.56112933",
"0.56021833",
"0.5599236",
"0.55779445",
"0.557192",
"0.5567705",
"0.5559234",
"0.5534607",
"0.5534489",
"0.5519088",
"0.5518533",
"0.5514139",
"0.5503787",
"0.54908186",
"0.54537076",
"0.5438624",
"0.54317766",
"0.5431367",
"0.5430955",
"0.5413405",
"0.54110694",
"0.5394671",
"0.5392792",
"0.5389448",
"0.53845847",
"0.53762853",
"0.5368646",
"0.53625906",
"0.53557366",
"0.5349189",
"0.53384775",
"0.5334956",
"0.5326954",
"0.5326493",
"0.5314855",
"0.5312116",
"0.53063875",
"0.53002894",
"0.52995116",
"0.5298734",
"0.5286379",
"0.52842665",
"0.5279148",
"0.5276866",
"0.527438",
"0.52725375",
"0.52655274",
"0.52643824",
"0.5256281",
"0.525541",
"0.5248382",
"0.52405214",
"0.5240462",
"0.5238292",
"0.5237669",
"0.52318746",
"0.523092",
"0.52298206",
"0.522806",
"0.5224595",
"0.52231133",
"0.5220982",
"0.5215635",
"0.5213028",
"0.51894736",
"0.51880026",
"0.51844007",
"0.5180201",
"0.51770085",
"0.5174444",
"0.5174003",
"0.5166579",
"0.5166579"
] | 0.6036914 | 10 |
Return what we need to write into an XSL file for this type | def xslText(self):
return TextFormat.xslText(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def convert(self):\n self._convert()\n self._write_docx()",
"def toxml(self) :\n\t\treturn self.doc.toxml()",
"def _ooxml(self):\n # LOG: processing_type property\n self.set_property('processing_type', 'ooxml')\n try:\n doc = officedissector.doc.Document(self.src_path)\n except Exception:\n self.make_dangerous('invalid ooxml file')\n return\n # There are probably other potentially malicious features:\n # fonts, custom props, custom XML\n if doc.is_macro_enabled or len(doc.features.macros) > 0:\n self.make_dangerous('macro')\n if len(doc.features.embedded_controls) > 0:\n self.make_dangerous('activex')\n if len(doc.features.embedded_objects) > 0:\n # Exploited by CVE-2014-4114 (OLE)\n self.make_dangerous('embedded obj')\n if len(doc.features.embedded_packages) > 0:\n self.make_dangerous('embedded pack')",
"def xslText(self):\n return u'<xsl:value-of select=\"%s%s\"/>' % (self.parentLevel * '../',\n self.name)",
"def xslText(self):\n return u'<xsl:value-of select=\"child::*/%s\"/>' % self.name",
"def _write_docx(self):\n with ZipFile(self.out_file, 'w') as f:\n self._write_content_types(f)\n self._write_app(f)\n self._write_core(f)\n self._write_rels(f)\n self._write_document(f)\n self._write_fonts(f)\n self._write_document_rels(f)\n self._write_settings(f)\n self._write_styles(f)",
"def create_output_file(self):\r\n self.output_file = openpyxl.Workbook()",
"def _create_oai_xsl_template():\n oai_xsl_template = OaiXslTemplate()\n oai_xsl_template = _set_oai_xsl_template_fields(oai_xsl_template)\n\n return oai_xsl_template",
"def createXML(whatToCreate):\n\n XMLSerializer = serializers.get_serializer(\"xml\")\n xml_serializer = XMLSerializer()\n if whatToCreate == \"allAccount\":\n path_fullToOutputFile = os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\")\n objectsToSerialize = Account.objects.all()\n else:\n raise ProgrammingError(\n _(\"During XML Export it was not correctly specified which data that has to be exported\"))\n out = open(os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\"), \"w\")\n if objectsToSerialize == '':\n raise NoObjectsToBeSerialzed(_(\"During XML Export it was not correctly specied data has to be exported\"))\n else:\n xml_serializer.serialize(objectsToSerialize, stream=out, indent=3)\n out.close()\n return path_fullToOutputFile\n\n # TODO def importAllAccountsXML(self):",
"def export_to_xml(self, resource_fs):\r\n raise NotImplementedError('Modules must implement export_to_xml to enable xml export')",
"def writeXml(self):\n text = u' type=\"%s\"' % self.typeName\n if self.format:\n text += u' format=\"%s\"' % escape(self.format, treedoc.escDict)\n if self.prefix:\n text += u' prefix=\"%s\"' % escape(self.prefix, treedoc.escDict)\n if self.suffix:\n text += u' suffix=\"%s\"' % escape(self.suffix, treedoc.escDict)\n if self.html:\n text += u' html=\"y\"'\n if self.isRequired:\n text += u' required=\"y\"'\n if self.hidden:\n text += u' hidden=\"y\"'\n if self.numLines > 1:\n text += u' lines=\"%d\"' % self.numLines\n if self.initDefault:\n text += u' init=\"%s\"' % escape(self.initDefault, treedoc.escDict)\n if self.linkAltField:\n text += u' linkalt=\"%s\"' % escape(self.linkAltField,\n treedoc.escDict)\n return text",
"def xslText(self):\n return u'<xsl:value-of select=\"ancestor::*/%s\"/>' % self.name",
"def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def getXml(self):\n return _SALOMERuntime.InputXmlPort_getXml(self)",
"def generateXML(self):\n return self.formatEval(\n self.TEMPLATES[self.attrs['name']]['XML'],\n self.attrs\n )",
"def storeAndReturnXML(self):\n self._storeItems()\n return self.toXML()",
"def get_xml(self):\n return etree.tostring(self.get_etree())",
"def definition_to_xml(self, resource_fs):\r\n raise NotImplementedError(\r\n \"%s does not implement definition_to_xml\" % self.__class__.__name__)",
"def create_gen_xml(self, out_file):\n\n param_list = []\n msg = []\n msg_type = []\n dep_node = []\n for line in self.full_ed_lines:\n param_list.append(line.text())\n dep_pkg = param_list[6].split(', ')\n if dep_pkg[len(dep_pkg) - 1] == '':\n dep_pkg.pop()\n for dep in self.manager.wid.sub_list:\n dep_node.append(dep['msg_type'])\n for dep in self.manager.wid.pub_list:\n dep_node.append(dep['msg_type'])\n for dep in dep_node:\n a, b = dep.split('/')\n msg.append(a)\n msg_type.append(b)\n f = open('../genkernel/templates/package_rosgen.xml')\n o = open(out_file, 'a')\n flag = 0\n while 1:\n line = f.readline()\n if not line: break\n for i in range(6):\n line = line.replace('[{0}]'.format(i), param_list[i])\n line = line.replace('[7]', param_list[7])\n if line.find('[6]') != -1:\n for dep in dep_pkg:\n line_dep = '\\t<depend>{0}</depend>\\n'.format(dep)\n o.write(line_dep)\n flag = 1\n elif line.find('[8]') != -1:\n for dep, tp in zip(msg, msg_type):\n line_dep = '\\t\\t<depend type=\"{1}\">{0}</depend>\\n'.format(dep, tp)\n o.write(line_dep)\n flag = 1\n elif line.find('<subscribers>') != -1:\n o.write('\\t\\t<subscribers>\\n')\n for sub in self.manager.wid.sub_list:\n o.write('\\t\\t\\t<sub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(sub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(sub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(sub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(sub['queue_size']))\n o.write('\\t\\t\\t</sub>\\n')\n o.write('\\t\\t</subscribers>\\n')\n flag = 1\n elif line.find('<publishers>') != -1:\n o.write('\\t\\t<publishers>\\n')\n for pub in self.manager.wid.pub_list:\n o.write('\\t\\t\\t<pub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(pub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(pub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(pub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(pub['queue_size']))\n o.write('\\t\\t\\t</pub>\\n')\n o.write('\\t\\t</publishers>\\n')\n flag = 1\n if flag == 0:\n o.write(line)\n else:\n flag = 0\n o.close()\n f.close()\n self.changed = False",
"def to_xml_file(self, xml_file_path):\n s = self.to_xml()\n with open(xml_file_path, \"w+b\") as f:\n f.write(s)",
"def saveToXml(self) -> org.jdom.Element:\n ...",
"def getXML(self):\n\n def _getElementForMappingEntry(entry, mappingStyle):\n xmlDocTmp = Document()\n element = xmlDocTmp.createElement(mappingStyle)\n for k, v in viewitems(entry):\n # ignore empty, None or compiled regexp items into output\n if not v or (k == \"path-match-expr\"):\n continue\n element.setAttribute(k, str(v))\n return element\n\n xmlDoc = Document()\n root = xmlDoc.createElement(\"storage-mapping\") # root element name\n for mappingStyle, mappings in viewitems(self):\n for mapping in mappings:\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\n root.appendChild(mapElem)\n return root.toprettyxml()",
"def write(self):\n temp_string = minidom.parseString(ET.tostring(self.root)).toprettyxml(encoding=\"UTF-8\")\n with open(self.xml_file, 'w') as f:\n f.write(temp_string)\n # f = open(self.xml_file, \"w\")\n # f.write(temp_string)\n # f.close()",
"def write(self):\n filters = {\n 'MSGUID': lambda x: ('{%s}' % x).upper(),\n 'relslnfile': lambda x: os.path.relpath(x, os.path.dirname(self.FileName))\n }\n context = {\n 'sln': self\n }\n return self.render(self.__jinja_template__, self.FileName, context, filters)",
"def generate(self):\n xml = self.template()\n fp = BytesIO()\n gzip = GzipFile(self.filename, \"wb\", 9, fp)\n if isinstance(xml, str):\n xml = xml.encode(\"utf8\")\n gzip.write(xml)\n gzip.close()\n data = fp.getvalue()\n fp.close()\n return data",
"def to_xml(self) -> str:\n # default name and stuff setup\n element_root, xml_tree = super()._add_basics()\n element_root = element_root.find('elementProp')\n element_root = element_root.find('collectionProp')\n for element in list(element_root):\n try:\n if element.attrib['name'] == 'influxdbUrl':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.influx_db_url:\n elem.text = self.influx_db_url\n elif element.attrib['name'] == 'application':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.application:\n elem.text = self.application\n elif element.attrib['name'] == 'measurement':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.measurement:\n elem.text = self.application\n elif element.attrib['name'] == 'summaryOnly':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value':\n elem.text = str(self.summary_only).lower()\n elif element.attrib['name'] == 'samplersRegex':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.samplers_regexp:\n elem.text = self.samplers_regexp\n elif element.attrib['name'] == 'percentiles':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.percentiles:\n elem.text = self.percentiles\n elif element.attrib['name'] == 'testTitle':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.test_title:\n elem.text = self.test_title\n elif element.attrib['name'] == 'eventTags':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.event_tags:\n elem.text = self.event_tags\n except Exception:\n raise Exception(f'Unable to render xml from {type(self).__class__}')\n return tree_to_str(xml_tree, hashtree=True)",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def getXSLURL(self, output='page'):\n mn_props = getToolByName(self, \"portal_properties\")['metnav_properties']\n output = output.lower().strip()\n if output == 'page':\n return mn_props.getProperty('XSL_PAGE', '')\n if output == 'portlet':\n return mn_props.getProperty('XSL_PORTLET', '')\n if output == 'dict':\n return mn_props.getProperty('XSL_DICT', '')\n if output == 'count':\n return mn_props.getProperty('XSL_COUNT', '')\n if output == 'rss':\n return mn_props.getProperty('XSL_RSS', '')\n if output == 'class_list':\n return mn_props.getProperty('XSL_CLASS_LIST', '')\n if output == 'table':\n return mn_props.getProperty('XSL_TABLE', '')\n if output == 'year_list':\n return mn_props.getProperty('XSL_YEAR_LIST', '')\n raise \"%s is not a valid value for an XSL output\" % output",
"def transform_s3_xsl(**kwargs):\n access_id = kwargs.get(\"access_id\")\n access_secret = kwargs.get(\"access_secret\")\n bucket = kwargs.get(\"bucket\")\n dest_prefix = kwargs.get(\"destination_prefix\")\n source_prefix = kwargs.get(\"source_prefix\")\n if kwargs.get(\"dag\"):\n run_id = kwargs.get(\"dag\").dag_id\n else:\n run_id = \"no-dag-provided\"\n\n saxon = prepare_saxon_engine()\n transformed = etree.Element(\"collection\")\n transformed.attrib[\"dag-id\"] = run_id\n transformed.attrib[\"dag-timestamp\"] = kwargs.get(\"timestamp\", \"no-timestamp-provided\")\n xsl = \"https://raw.github.com/{repo}/{branch}/{filename}\".format(\n repo=kwargs.get(\"xsl_repository\", \"tulibraries/aggregator_mdx\"),\n branch=kwargs.get(\"xsl_branch\", \"main\"),\n filename=kwargs.get(\"xsl_filename\")\n )\n\n for s3_key in process.list_s3_content(bucket, access_id, access_secret, source_prefix):\n logging.info(\"Transforming File %s\", s3_key)\n s3_content = process.get_s3_content(bucket, s3_key, access_id, access_secret)\n s3_xml = etree.fromstring(s3_content)\n for record in s3_xml.iterchildren():\n record_id = record.get(\"airflow-record-id\")\n logging.info(\"Transforming Record %s\", record_id)\n result_str = subprocess.check_output([\"java\", \"-jar\", saxon, \"-xsl:\" + xsl, \"-s:-\"], input=etree.tostring(record, encoding=\"utf-8\"))\n result = etree.fromstring(result_str)\n result.attrib[\"airflow-record-id\"] = record_id\n transformed.append(result)\n filename = s3_key.replace(source_prefix, dest_prefix)\n transformed_xml = etree.tostring(transformed, encoding=\"utf-8\")\n process.generate_s3_object(transformed_xml, bucket, filename, access_id, access_secret)",
"def export_to_xml(self, resource_fs):\r\n\r\n # Set up runtime.export_fs so that it's available through future\r\n # uses of the pure xblock add_xml_to_node api\r\n self.runtime.export_fs = resource_fs\r\n\r\n # Get the definition\r\n xml_object = self.definition_to_xml(resource_fs)\r\n self.clean_metadata_from_xml(xml_object)\r\n\r\n # Set the tag so we get the file path right\r\n xml_object.tag = self.category\r\n\r\n # Add the non-inherited metadata\r\n for attr in sorted(own_metadata(self)):\r\n # don't want e.g. data_dir\r\n if attr not in self.metadata_to_strip and attr not in self.metadata_to_export_to_policy:\r\n val = serialize_field(self._field_data.get(self, attr))\r\n try:\r\n xml_object.set(attr, val)\r\n except Exception:\r\n logging.exception(\r\n u'Failed to serialize metadata attribute %s with value %s in module %s. This could mean data loss!!!',\r\n attr, val, self.url_name\r\n )\r\n\r\n for key, value in self.xml_attributes.items():\r\n if key not in self.metadata_to_strip:\r\n xml_object.set(key, value)\r\n\r\n if self.export_to_file():\r\n # Write the definition to a file\r\n url_path = name_to_pathname(self.url_name)\r\n filepath = self._format_filepath(self.category, url_path)\r\n resource_fs.makedir(os.path.dirname(filepath), recursive=True, allow_recreate=True)\r\n with resource_fs.open(filepath, 'w') as file:\r\n file.write(etree.tostring(xml_object, pretty_print=True, encoding='utf-8'))\r\n\r\n # And return just a pointer with the category and filename.\r\n record_object = etree.Element(self.category)\r\n else:\r\n record_object = xml_object\r\n\r\n record_object.set('url_name', self.url_name)\r\n\r\n # Special case for course pointers:\r\n if self.category == 'course':\r\n # add org and course attributes on the pointer tag\r\n record_object.set('org', self.location.org)\r\n record_object.set('course', self.location.course)\r\n\r\n return etree.tostring(record_object, pretty_print=True, encoding='utf-8')",
"def writeXMLDecl(self):\n return _libsbml.XMLOutputStream_writeXMLDecl(self)",
"def setXSLTMode(self,value):\n self.PDFreactorConfiguration.in1[\"XSLTMode\"] = value",
"def save(self, filename=None):\n f = filename if filename else self.path\n etree.register_namespace('', TEI)\n etree.register_namespace('mith', MITH)\n self.doc.write(f, xml_declaration=True, encoding='utf-8', method='xml')",
"def toXML(self):\n return self._xmlpre+\"\\n\".join(map(lambda f:f.toXML(),self._items))+self._xmlpost",
"def to_xml(self):\n # lines = super(FileCatNoEmpty, self).cat(filepath)\n structure = super(Point, self).to_xml()\n\n\n coords = GeometryTopologyData.__to_xml_vector__(self.coordinate, self.format)\n # description_str = ''\n # if self.description is not None:\n # description_str = '<Description>%s</Description>' % self.description\n\n return '<Point>%s<Coordinate>%s</Coordinate></Point>' % (structure, coords)",
"def write(klass, document, target=None, stylesheet=\"\"):\n writer = LatexWriter(document, target, stylesheet)\n return writer.go()",
"def to_xml(self, file_name=None):\n if file_name:\n xml_file = open(file_name, 'w')\n results = ['<schema name=\"%s\">' % self.name]\n for schema_object in list(self.schema.keys()):\n results.append(self.schema[schema_object].to_xml())\n results.append('</schema>')\n if file_name:\n xml_file.write('\\n'.join(results))\n xml_file.close()\n else:\n return '\\n'.join(results)",
"def write_xosc(self, generated_xml):\n reparsed_xml = minidom.parseString(generated_xml).toprettyxml(indent=\" \")\n xosc_file = open(self._filepath, \"w\")\n xosc_file.write(reparsed_xml)\n xosc_file.close()\n\n msg = QMessageBox()\n if self._warning_message:\n msg.setIcon(QMessageBox.Warning)\n text = f\"Exported OpenSCENARIO file {self._filepath} has warnings!\\n\\n\"\n text += \"\\n\".join(self._warning_message)\n else:\n msg.setIcon(QMessageBox.Information)\n text = f\"Successfully exported OpenSCENARIO file to {self._filepath}\"\n msg.setText(text)\n msg.setWindowTitle(\"OpenSCENARIO Export\")\n msg.setStandardButtons(QMessageBox.Ok)\n msg.exec()",
"def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()",
"def start_serialization(self):\n self.xml = SimplerXMLGenerator(self.stream, self.options.get(\"encoding\", settings.DEFAULT_CHARSET))\n self.xml.startDocument()\n self.xml.startElement(\"xliff\", {\n \"version\": \"1.2\",\n \"xmlns\": \"urn:oasis:names:tc:xliff:document:1.2\",\n \"xmlns:d\": \"https://docs.djangoproject.com/\"\n })",
"def XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\n\n\t#On commence par afficher ce qu'on fait\r\n\tprint \" Build xml file \"\r\n\r\tprint InputsFile\n\t#ouverture du fichier dans lequel on place le source model\n\ttry:\n\t\tfresult = open(OutputFile, 'w')\n\texcept:\n\t\tprint \"Coucou\"\r\n \t#ecriture des premieres lignes invariantes\n\tfresult.write('<?xml version=\"1.0\" ?>')\r\n\tfresult.write(\"<source_library title=\\\"source library\\\">\\n\")\n\r\n \t#ouverture du fichier avec les entrees\r\n\tf = open(InputsFile,\"r\")\r\n\tlines = f.readlines()\r\n\t\r\n \t#Ajout des sources detectees dans le catalogue\n\t#Pour chaque ligne du fichier d'entree\r\n\tfor line in range(len(lines)):\n\t\t#Lire les donnees de la ligne\t\t\r\n\t\tdata = lines[line].split()\r\n\t\tname = data[0]\n\n\t\t#Verification : est on en train de traiter la source que l'on veut etudier ou une autre ?\r\n\t\tif str(name) == Name :\r\n\t\t\tmysource = 1\r\n\t\telse:\r\n\t\t\tmysource = 0\n\n\t\t#recuperation des donnees\r\n\t\tRA = data[1]\r\n\t\tDEC = data[2]\r\n\t\tIntegral = float(data[3])*float(Frac)\r\n\t\tGamma= data[4]\n\n\t\t\r\n\t\ttry:\n\t\t\t#essai de definition des donnees pour un PL avec ExpCut\n\t\t\tPrefactor = float(data[5])*float(Frac)\r\n\t\t\tEnergy = float(data[6])\r\n\t#\t\tPrefactor = Prefactor/pow(Energy/100., float(Gamma)) #Densite de flux calculee a Epivot\r\n\t#\t\tPrefactor = Prefactor*pow(1000./100., float(Gamma)) #We do the calculation with (E/1000.)^Gamma\n\t\t\tvariabilite=float(data[8])\n\n#\t\t\tprint variabilite\n\n\n\n\r\n\t\t\tcut = float(data[7]) # Cut est la variable qui nous permettra de savoir si il faut utiliser un cut off (1) ou une loi de puissance normale (2)\r\n\t\texcept:\r\n\t\t\ttry:\r\n\t\t\t\tcut = float(data[5])\r\n\t\t\texcept:\r\n\t\t\t\tprint \" Wrong size of list \"\r\n\t\t\t\tsys.exit()\r\n \t#Si on considere un ccut off exponentiel pour la source :\r\n\t\tif cut == 1:\n\t\t\t#ecriture du nom de la source consideree\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\r\n\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\r\n\t\t\tspectrum_type = \"PLSuperExpCutoff\"\n\t\t\t#Utilisation de la modelisation PLSuperExpCutoff car plus simple et plus intuitive pour nous et pour la modelisation des pulsars si il faut en modeliser\n\r\n\t\t\t#definition des parametres spectraux a prendre en comtpe et de la chaine de caractere a integrer\r\n\n\n\n\t\t\tif variabilite==0.0 or variabilite==2.0:\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"10000000.0\\\" min=\\\"0.0000001\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\r\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.001\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\n\r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\t\t\telif variabilite==1.0 :\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10000000.0\\\" min=\\\"0.0\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.0001\\\"\"\r\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\n\r\n \r\n\n# <spectrum type=\"PLSuperExpCutoff\">\n# <parameter free=\"1\" max=\"100000\" min=\"0\" name=\"Prefactor\" scale=\"1e-10\" value=\"Prefactor*1e-10\"/>\n# <parameter free=\"1\" max=\"0\" min=\"5\" name=\"Index1\" scale=\"-1\" value=\"valeur du catalogue\"/>\n# <parameter free=\"0\" max=\"20000\" min=\"1.0\" name=\"Scale\" scale=\"1\" value=\"Epivot\"/>\n# <parameter free=\"1\" max=\"300000\" min=\"100\" name=\"Cutoff\" scale=\"1\" value=\"3000\"/>\n# <parameter free=\"0\" max=\"5\" min=\"0\" name=\"Index2\" scale=\"1\" value=\"1.5\"/>\n# </spectrum>\n\n\r\n\t\telse:\n\t\t#Sinon (si on considere une loi de puissance simple)\n\t\t#definition de la chaine de caractere comportant le nom de la source\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\n\t\t\tif mysource == 0:\r\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\n\t\t\telse:\n\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\t\t\t\t\n\n\t\t\t#definition de la chaine de caractere correspondant a la forme de fit que l'on souhaite utiliser (Loi de puissance)\r\n\t\t\tspectrum_type = \"PowerLaw2\"\r\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre Integrale\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\telse:\n\t\t\t#sinon on le libere\r\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\n\n\n\n\n\n\t\t\t#Toujours ce facteur....\r\n\t\t\tIntegral = float(Integral)*1e10\r\n\t\t\tscale = 1e-10\n\n\n\t\n\r\n\t\t\tspectrum_lines += \" name=\\\"Integral\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre gamma\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\telse:\n\t\t\t\t#si c'est pas la source que l'on etudie on le laisse libre\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\n\n\t\t\t#fin de la chaine de parametres sur le modele spectral\r\n\t\t\tspectrum_lines += \" name=\\\"Index\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t \n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"1000.0\\\"/>\\n\"\r\n \r\n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\t\t\telse:\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"100\\\"/>\\n\"\n\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"100000.0\\\" Min =\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\n \t\t#ajout du modele spectral a la liste de parametres \r\n\t\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\t\tresult_line += spectrum_lines\r\n\t\tresult_line += \" </spectrum>\\n\"\n\n\t\t\n\n\t\tif mysource==0 and variabilite!=1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telif mysource==0 and variabilite==1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telse:\n #ajout du modele spatial a la liste de parametres \n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\t\t\n\t\tresult_line += \" </source>\\n\"\r\n\t\tfresult.write(result_line+\"\\n\")\r\n #Ajout du fond diffus galactique\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"gal_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"ConstantValue\"\r\n\r\n\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Value\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n\r\n\tresult_line += \" <spatialModel file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/gll_iem_v02.fit\\\" type=\\\"MapCubeFunction\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"1000.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Normalization\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\r\n \t#Ajout du fond diffus extragalactique\r\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"eg_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"FileFunction\"\r\n\r\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Normalization\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/isotropic_iem_v02.txt\\\" type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n \r\n\tresult_line += \" <spatialModel type=\\\"ConstantValue\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"100.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Value\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\n \t#Fermeture des fichiers \r\n\tf.close() \r\n\tfresult.write(\"\\n</source_library>\\n\")\r\n\tfresult.close()\r\n\treturn",
"def get(self):\n return _SALOMERuntime.OutputXmlPort_get(self)",
"def toXML(self):\n return _libsbml.Layout_toXML(self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def write(self):\r\n for prop in self.prpnames:\r\n elem = SubElement(self._root, prop)\r\n data = self.__getattribute__(prop)\r\n if self.prpnames[prop]['type'] == \"text\":\r\n elem.text = data\r\n elif self.prpnames[prop]['type'] == 'list':\r\n for x in data:\r\n SubElement(elem, 'regel').text = x\r\n elif self.prpnames[prop]['type'] == 'attr':\r\n elem.set(self.prpnames[prop]['naam'], data)\r\n tree = ElementTree(self._root)\r\n tree.write(self._fn)\r\n if not self.exists:\r\n self.exists = True",
"def write(self, file_or_filename):\n etMap = revert(self)\n xmlTree = ET.ElementTree(etMap)\n xmlTree.write(file_or_filename)",
"def save_to_xml(self, xwriter):\r\n\r\n xwriter.WriteStartElement(\"Profile\")\r\n xwriter.WriteAttributeString(\"Name\", self.Name)\r\n xwriter.WriteStartAttribute(\"Version\")\r\n xwriter.WriteValue(self.Version)\r\n xwriter.WriteEndAttribute()\r\n\r\n for var_name in self.__dict__:\r\n var_type = type(getattr(self, var_name))\r\n\r\n if var_type is str and var_name != \"Name\":\r\n self.write_string_to_xml(var_name, xwriter)\r\n\r\n elif var_type is bool:\r\n self.write_bool_to_xml(var_name, xwriter)\r\n\r\n elif var_type is dict:\r\n self.write_dict_to_xml(var_name, xwriter)\r\n\r\n elif var_type is list and var_name != \"ExcludeRules\":\r\n self.write_list_to_xml(var_name, xwriter)\r\n\r\n xwriter.WriteStartElement(\"ExcludeRules\")\r\n xwriter.WriteAttributeString(\"Operator\", self.ExcludeOperator)\r\n xwriter.WriteAttributeString(\"ExcludeMode\", self.ExcludeMode)\r\n for rule in self.ExcludeRules:\r\n if rule:\r\n rule.save_xml(xwriter)\r\n xwriter.WriteEndElement()\r\n \r\n xwriter.WriteEndElement()",
"def xmlWrite(self, xmlWriter, font, value, name, attrs):\n raise NotImplementedError(self)",
"def writeXMLNS(self, *args):\n return _libsbml.ASTBasePlugin_writeXMLNS(self, *args)",
"def write_output_file(self, xml_text, xml_file):\n xml_fo = open(xml_file, 'w')\n xml_fo.write(xml_text+'</xml>')\n xml_fo.close()\n return",
"def _generate_xml(self, body, destn_dir, nodes=True):\n fn = ''.join([random.choice(string.ascii_letters) for _ in range(12)])\n fn += '.xml'\n\n _dir = os.path.dirname(os.path.abspath(__file__))\n _tmpl = 'multi_node.template' if nodes else 'single_node.template'\n _env = Environment(autoescape=False,\n loader=FileSystemLoader(_dir),\n trim_blocks=False)\n\n with open(fn, 'w+') as f:\n o = _env.get_template(_tmpl).render(body)\n f.write(o)\n\n _d = destn_dir + '/' + fn\n self._remote_copy(fn, _d)\n # Remove the XML file created locally\n os.remove(fn)\n\n return _d",
"def dumps(records, xslt_filename=None, **kwargs):\n root = dumps_etree(records=records, xslt_filename=xslt_filename)\n return etree.tostring(\n root,\n pretty_print=True,\n xml_declaration=True,\n encoding='UTF-8',\n **kwargs\n )",
"def xml(self):\n raise NotImplementedError('This api does not return xml')",
"def _writeXML(self,output,outputDictionary):\n if self.dynamic:\n outputInstance = xmlUtils.DynamicXmlElement('MetricPostProcessor', pivotParam=self.pivotParameter)\n else:\n outputInstance = xmlUtils.StaticXmlElement('MetricPostProcessor')\n if self.dynamic:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n for ts, pivotVal in enumerate(self.pivotValues):\n if values.shape[0] == 1:\n outputInstance.addScalar(nodeName, metricName,values[0], pivotVal=pivotVal)\n else:\n outputInstance.addScalar(nodeName, metricName,values[ts], pivotVal=pivotVal)\n else:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n if len(list(values)) == 1:\n outputInstance.addScalar(nodeName, metricName, values[0])\n else:\n self.raiseAnError(IOError, \"Multiple values are returned from metric '\", metricName, \"', this is currently not allowed\")\n return outputInstance",
"def writeXml(self):\n curdir = os.getcwd()\n os.chdir(self.Imagedir)\n allImageLists = [self.sciImlist, self.ctxImlist, self.wgtImlist, self.rmsImlist]\n \n for imlist in allImageLists:\n for im in imlist:\n file = xmlUtil.markupImage(im,dataset=self.obsName)\n \n # Don't write these images as output of this module, which\n # really doesn't have any.\n \n #if file not in self.outputList.keys():\n # self.outputList[file] = [im]\n \n os.chdir(curdir)\n return",
"def docType():\n return (u'<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n u'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 '\n u'Transitional//EN\" '\n u'\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n')",
"def to_xml(self, scene_dir: str) -> Tuple[Et.Element, bool]:\n raise NotImplementedError",
"def save_xml_file():\n global output_on_display, import_lst, column_names, data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = data[0]\n step = len(column_names)\n\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"XML\", \"*.xml\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.xml')\n data = import_lst\n\n if len(data[0]) == step:\n pass\n else:\n data = import_lst[step::]\n\n data2 = list(map(list, zip(*data)))\n\n data3 = {key: value for key, value in zip(column_names, data2)}\n\n column = list(data3.keys())\n\n df = pd.DataFrame(data3, columns=column)\n\n data_dict = df.to_dict(orient=\"records\")\n with open('output.json', \"w+\") as f:\n json.dump(data_dict, f, indent=4)\n\n xml_data = dicttoxml(data_dict).decode()\n with open(save_name, \"w+\") as f:\n f.write(xml_data)\n\n data.clear()\n data2.clear()\n data3.clear()",
"def Write(self):\n f = open(self.project_path, 'wt')\n self.doc.writexml(f,\n encoding='Windows-1252',\n addindent=' ',\n newl='\\n')\n f.close()",
"def write(self, filename, agg_dir):\n super().write(filename)\n\n if self.aggregation:\n agg = self.aggregation\n abs_subdir = os.path.join(agg_dir, agg.sub_dir)\n if not os.path.isdir(abs_subdir):\n os.makedirs(abs_subdir)\n\n agg.xml_element.write(os.path.join(abs_subdir, agg.basename))",
"def to_sbml(self, params):\n files = {}\n _id, cobra_model = self._ws_obj_to_cobra(params['input_ref'])\n files['file_path'] = os.path.join(params['destination_dir'], _id + \".xml\")\n cobra.io.write_sbml_model(cobra_model, files['file_path'])\n\n return _id, files",
"def write2file(self, save_to):\n headerstyle = xlwt.easyxf(self.header_style.get_style_string())\n missing_val_style = xlwt.easyxf(\n self.missing_value_style.get_style_string())\n row_styles = [xlwt.easyxf(self.first_style.get_style_string()),\n xlwt.easyxf(self.second_style.get_style_string())]\n\n properties, sections, table = self._build_table()\n\n workbook = xlwt.Workbook()\n sheet = workbook.add_sheet(self.sheet_name)\n\n if os.path.splitext(save_to)[-1] == '':\n save_to += '.xls'\n\n max_col_len = []\n\n if (self.switch):\n\n for i, prop in enumerate([''] + properties):\n sheet.write(0, i, prop, headerstyle)\n max_col_len.append(len(str(prop)))\n\n for row_num, sec in enumerate(sections):\n sheet.write(row_num + 1, 0, sec, headerstyle)\n if len(str(sec)) > max_col_len[0]:\n max_col_len[0] = len(str(sec))\n\n for row_num, row in enumerate(table):\n for col_num, elem in enumerate(row):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n else:\n\n for i, sec in enumerate([''] + sections):\n sheet.write(0, i, sec, headerstyle)\n max_col_len.append(len(str(sec)))\n\n for row_num, prop in enumerate(properties):\n sheet.write(row_num + 1, 0, prop, headerstyle)\n if len(str(prop)) > max_col_len[0]:\n max_col_len[0] = len(str(prop))\n\n for col_num, col in enumerate(table):\n for row_num, elem in enumerate(col):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n # adjust width of he columns\n for col_id, col_len in enumerate(max_col_len):\n sheet.col(col_id).width = (256 * (col_len+1))\n\n workbook.save(save_to)",
"def writeToTempXml(self):\n name = self.fileToProcess.name\n all_tokens = ET.Element(\"tokens\")\n for token in self.tokensTable:\n if token.getType() == KEYWORD:\n keyword = ET.SubElement(all_tokens, \"keyword\")\n keyword.text = ' '+token.getValue()+' '\n elif token.getType() == IDENTIFIER:\n identifier = ET.SubElement(all_tokens, \"identifier\")\n identifier.text = ' '+token.getValue()+' '\n elif token.getType() == SYMBOL:\n symbol = ET.SubElement(all_tokens, \"symbol\")\n symbol.text = ' '+token.getValue()+' '\n elif token.getType() == STRING_CONST:\n stringConstant = ET.SubElement(all_tokens, \"stringConstant\")\n stringConstant.text = ' '+token.getValue()+' '\n elif token.getType() == INT_CONST:\n integerConstant = ET.SubElement(all_tokens, \"integerConstant\")\n integerConstant.text = ' '+token.getValue()+' '\n tree = ET.ElementTree(all_tokens)\n tree.write(name + 'T' + '.xml')",
"def xslText(self):\n return u'<xsl:for-each select = \"./%s\">%s<xsl:choose>'\\\n '<xsl:when test=\"contains(., \\':\\')\"><a href=\"{.}\">'\\\n '<xsl:value-of select=\".\"/></a></xsl:when><xsl:otherwise>'\\\n '<a href=\"%s{.}\"><xsl:value-of select=\".\"/></a>'\\\n '</xsl:otherwise></xsl:choose>%s</xsl:for-each>' % \\\n (self.name, xslEscape(self.prefix), self.URLMethod,\n xslEscape(self.suffix))",
"def getXML(self):\n nodes = list(self.nodes(data=True))\n nodes.sort()\n node_string = ''\n for n in nodes:\n attribute_string = ''\n keys = list(n[1].keys())\n keys.sort()\n for k in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(k, n[1][k], k)\n modification_string = ''\n modified_by = self.predecessors(n[0])\n if modified_by:\n for mod in modified_by:\n modification_string += \"\"\"<modified_by>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifyingNode> %s </modifyingNode>\\n\"\"\"%mod.getTagID()\n modification_string += \\\n \"\"\"<modifyingCategory> %s </modifyingCategory>\\n\"\"\"%mod.getCategory()\n modification_string += \"\"\"</modified_by>\\n\"\"\"\n modifies = self.successors(n[0])\n if modifies:\n for modified in modifies:\n modification_string += \"\"\"<modifies>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifiedNode> {0} </modifiedNode>\\n\"\"\".format(modified.getTagID())\n modification_string += \\\n \"\"\"</modifies>\\n\"\"\"\n node_string += \\\n NODE_XML_SKEL.format(attribute_string+\"{0}\".format(n[0].getXML()) +\\\n modification_string)\n edges = list(self.edges(data=True))\n edges.sort()\n edge_string = ''\n for edge in edges:\n keys = list(edge[2].keys())\n keys.sort()\n attribute_string = ''\n for key in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(key, edge[2][key], key)\n edge_string += \"{0}\".format(EDGE_XML_SKEL.format(edge[0].getTagID(),\n edge[1].getTagID(),\n attribute_string))\n\n return CONTEXT_MARKUP_XML_SKEL.format(xmlScrub(self.getRawText()),\n xmlScrub(self.getText()),\n node_string,\n edge_string)",
"def writeXMLNS(self, *args):\n return _libsbml.MultiASTPlugin_writeXMLNS(self, *args)",
"def run_xslt(xml_filename, xsl_filename):\n import subprocess\n from misc.localexec import LocalExec\n from distutils.spawn import find_executable\n\n def seekout_xsltproc():\n XSLTPROC_BIN = 'xsltproc'\n executable = find_executable(XSLTPROC_BIN)\n if executable:\n return os.path.abspath(executable)\n raise SignerError(\"it has not found {} binary\".format(XSLTPROC_BIN))\n\n le = LocalExec(err_mute=True)\n exe = seekout_xsltproc()\n exe_args = [ xsl_filename, xml_filename ]\n\n try:\n return le([exe] + exe_args, cmd_timeout=20, ign_rcs=None)\n except subprocess.CalledProcessError as e:\n msg = \"Command raised exception\\nOutput: \" + str(e.output)\n raise Exception(msg)",
"def _write_context_to_file(self, context):\n om.out.debug('[xml_file.flush()] Starting _write_context_to_file()')\n\n template = self._jinja2_env.get_template('root.tpl')\n\n # We use streaming as explained here:\n #\n # http://flask.pocoo.org/docs/0.12/patterns/streaming/\n #\n # To prevent having the whole XML in memory\n # pylint: disable=E1101\n report_stream = template.stream(context)\n report_stream.enable_buffering(3)\n # pylint: enable=E1101\n\n # Write everything to a temp file, this is useful in two cases:\n #\n # * An external tool will always see a valid XML in the output,\n # and not just a partially written XML document.\n #\n # * If w3af is killed in the middle of writing the XML report,\n # the report file will still be valid -- if xml_file.flush() was\n # run successfully at least once\n tempfh = NamedTemporaryFile(delete=False,\n prefix='w3af-xml-output',\n suffix='.xml')\n\n om.out.debug('[xml_file.flush()] write_context_to_file() created'\n ' template.stream and NamedTemporaryFile')\n\n try:\n # Write each report section to the temp file\n for report_section in report_stream:\n tempfh.write(report_section.encode(DEFAULT_ENCODING))\n except Exception:\n # No exception handling is done here, we just raise the exception\n # so that the core can handle it properly\n raise\n else:\n # Close the temp file so all the content is flushed\n tempfh.close()\n\n om.out.debug('[xml_file.flush()] write_context_to_file() starting to'\n ' copy temp file to destination')\n\n # Copy to the real output file\n report_file_name = os.path.expanduser(self._file_name)\n\n cmd = 'cp %s %s' % (tempfh.name, report_file_name)\n subprocess.call(cmd, shell=True)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished copy'\n ' operation.')\n\n stat_info = os.stat(report_file_name)\n om.out.debug('The XML output file size is %s bytes.' % stat_info.st_size)\n\n finally:\n os.remove(tempfh.name)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished')",
"def to_workbook(self) -> tuple:\n\n # Initialize the bytestream\n f = io.BytesIO()\n wb = xw.Workbook(f, {\"in_memory\": True})\n\n # Open a workbook\n self._book = wb\n self._book.set_properties({\"category\": \"atomica:databook\"})\n self._formats = standard_formats(self._book)\n self._references = {} # Reset the references dict\n\n # Write the contents\n self._write_pops()\n self._write_tdve()\n self._write_interpops()\n self._write_transfers()\n\n # Clean internal variables related to writing the worbkook\n self._book = None\n self._formats = None\n self._references = None\n\n return f, wb",
"def format_xml(self,query_results):\n results=query_results.data\n factory=factory_xml()\n dump=factory.dumps({'data':results})\n print(dump)\n # TODO return output for this\n return \"\"",
"def write_to_xml(dictData, metadata, xmlfile):\n\tfout = codecs.open(xmlfile, 'w', 'utf-8')\n\tfout.write('<?xml version = \"1.0\" encoding = \"UTF-8\" standalone = \"no\" ?>\\n')\n\tfout.write('<?xml-stylesheet type=\"text/xsl\" href=\"maketable.xsl\"?>\\n')\n\tfout.write('<root>\\n')\n\tfout.write('<meta>\\n')\n\tfor key, value in metadata.items():\n\t\tfout.write('<' + key + '>' + value + '</' + key + '>\\n')\n\tfout.write('</meta>\\n')\n\tfout.write('<content>\\n')\n\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dictData:\n\t\txmlline = ''\n\t\txmlline += '<word><headword>' + hw + '</headword><meanings>'\n\t\tfor meaning in meanings:\n\t\t\txmlline += '<m>' + meaning + '</m>'\n\t\txmlline += '</meanings>'\n\t\txmlline += '<verse>'\n\t\tlines = verse.split('<BR>')\n\t\tfor line in lines:\n\t\t\txmlline += '<line>' + line + '</line>'\n\t\txmlline += '</verse>'\n\t\txmlline += '<verseNumber>' + verseNumDetails + '</verseNumber>'\n\t\txmlline += '<pageNumber>' + pageNumDetails + '</pageNumber></word>'\n\t\t# Write in babylon format. <BR><BR> is to separate verses.\n\t\tfout.write(xmlline + '\\n')\n\t\txmlline = ''\n\tfout.write('</content>\\n</root>')\n\tfout.close()\n\n\t# Give some summary to the user\n\tprint('XML file generated. Success!')\n\tprint('{} metadata lines and {} content lines written to XML file.'.format(len(metadata), len(dictData)))",
"def xml(self):\n return self._xml",
"def xml(self):\n return self._xml",
"def writeSBMLToFile(self, *args):\n return _libsbml.SBMLWriter_writeSBMLToFile(self, *args)",
"def _create_xml_report(self, test, xml_obj):\n xml_report_path = os.path.join(test.work_dir,\n self.XML_REPORT_PATH)\n with open(xml_report_path, 'w') as xml_report:\n xml_report.write(etree.tostring(xml_obj, pretty_print=True))",
"def xml2html(self):\n handler = open(self.xml_doc).read()\n soup = BeautifulSoup(handler, 'xml')\n\n fw = open(self.filename_out, 'w')\n\n fw.write(\"<!DOCTYPE html>\" + os.linesep)\n fw.write(\"<html>\" + os.linesep)\n fw.write(\"<head>\" + os.linesep)\n fw.write('<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">' + os.linesep)\n fw.write(\"<link rel=\\\"stylesheet\\\" href=\\\"%s\\\" type=\\\"text/css\\\" />\" % self.stylesheet_name + os.linesep)\n fw.write(\"<title></title>\" + os.linesep)\n fw.write(\"</head>\" + os.linesep)\n fw.write(\"<body>\" + os.linesep)\n\n # Load styles in dictionaries\n for style in soup.find_all(\"style\"):\n style_name = style.get(\"style:name\")\n #print \"style: %s children: %s descendants: %s\" % (str(style_name), str(len(list(style.children))), len(list(style.descendants)))\n for style_child in style.children:\n fs = style_child.get(\"fo:font-style\")\n if fs:\n self.style_fontstyle[style_name] = fs\n fontw = style_child.get(\"fo:font-weight\")\n if fontw:\n self.style_fontweight[style_name] = fontw\n # read alignment\n txta = style_child.get(\"fo:text-align\")\n if txta:\n self.style_textalignment[style_name] = txta\n # !!!\n tu = style_child.get(\"style:text-underline-type\")\n if tu:\n self.style_textunderline[style_name] = \"underlined\"\n # page break\n break_before = style_child.get(\"fo:break-before\")\n if break_before:\n self.style_break_before[style_name] = break_before\n\n\n # Navigate down the document through h and p tags\n #\n for text in soup.find_all(re.compile(\"^h|^p\")):\n\n # From bs4 docs: If a tag has only one child, and that child is a NavigableString, the child is made available as .string:\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"P9\">- Any text here!</text:p>\n #\n # To do:\n #\n # Beware of this case:\n # - <text:p text:style-name=\"P8\">\n # <text:span text:style-name=\"T4\">\n #\n\n # Get the attributes so the styles and the outlines\n text_attrs = dict(text.attrs)\n\n # Get the styles, if any\n try:\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n if text.string:\n t = unicode(text.string)\n if t:\n fw.write(self.outliner(self.stylizer(t, t_style), t_outline_level, t_style).encode('utf-8'))\n\n # e.g. page breaks come as a node with no children whose style contains fo:break-before:\"page\"\n elif len(list(text.children)) == 0:\n fw.write(self.outliner(unicode(\"\"), t_outline_level, t_style).encode('utf-8'))\n\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"Textbody\">\n # jkjksk skjkjkjs dhh\n # <text:s />\n # <text:span text:style-name=\"T3\">Bold</text:span>\n # <text:s />\n # </text:p>\n #\n # else drill down one level\n else:\n buffer = unicode(\"\")\n t = buffer\n u = buffer\n t_outline_level = \"paragraph\"\n t_style = \"\"\n for i in text.children:\n # Get the attributes so the styles\n try:\n text_attrs = dict(i.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n # whenever the element has no style\n # take the parent's one\n try:\n text_attrs = dict(i.parent.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n # if the current tag has only one child, and that child is a NavigableString\n if i.string:\n t = unicode(i.string)\n\n # space\n elif i.name == \"s\":\n t = unicode(\" \")\n\n # else drill down another level\n else:\n t = unicode(\"\")\n for j in i.children:\n if j.string:\n u = unicode(j.string)\n elif j.name == \"s\":\n u = unicode(\" \")\n else:\n u = unicode(\"\")\n if u:\n t = t + self.stylizer(u, t_style)\n\n # build up a unicode string containing the whole paragraph\n if t:\n buffer = buffer + self.stylizer(t, t_style)\n\n # outline the buffered unicode string and write it to the output file\n fw.write(self.outliner(buffer, t_outline_level, t_style).encode('utf-8'))\n\n fw.write(\"</body>\" + os.linesep)\n fw.write(\"</html>\" + os.linesep)\n fw.close()",
"def writexml(file):\n OUTFILE=open(file,\"w\")\n doc = xml.dom.minidom.Document()\n\n # Create the <dec_reg_list> base element\n decl_reg_list = doc.createElement(\"decl_reg_list\")\n doc.appendChild(decl_reg_list)\n\n regname_old=\"\"\n rows.pop(0)\n for row in rows:\n (regdesc,regname,offset,default,regtype,expose_reg,depth,incsz,bitdesc,bitname,loc,bittype)= row\n if regname != regname_old:\n # Create the register element\n register = doc.createElement(\"register\")\n register.setAttribute(\"name\", regname)\n register.setAttribute(\"offset\", offset)\n if default != \"\" : register.setAttribute(\"default\", default)\n register.setAttribute(\"type\", regtype)\n if expose_reg == \"1\": register.setAttribute(\"usr\", expose_reg)\n if depth != \"\": register.setAttribute(\"size\", depth)\n if incsz != \"\": register.setAttribute(\"incsz\", incsz)\n text = doc.createTextNode(regdesc)\n register.appendChild(text)\n decl_reg_list.appendChild(register)\n \n # Create the field element\n if bitname != \"\":\n field = doc.createElement(\"field\")\n field.setAttribute(\"name\", bitname)\n if loc !=\"\": field.setAttribute(\"loc\", addcolon(loc))\n if bittype != \"\": field.setAttribute(\"type\", bittype)\n if bitdesc != \"\":\n text = doc.createTextNode(bitdesc)\n field.appendChild(text)\n register.appendChild(field)\n regname_old = regname\n\n\n # Print our newly created XML\n #print doc.toprettyxml(indent=\" \")\n #OUTFILE.write(doc.saveXML(decl_reg_list))\n OUTFILE.write(doc.toprettyxml(indent=\" \"))\n OUTFILE.close()",
"def export_to_file(self, filename):\n if len(filename.split(\".\")) == 1:\n filename += \".xml\"\n xmlstring = self._dommodel.toprettyxml(\" \", \"\\n\")\n with open(filename, \"w\") as f:\n f.write(xmlstring)",
"def write(self, filename):\n \n return self.model.write(filename,xml_declaration=True, encoding='utf-8')",
"def save_as(self, fname, base = None, indent = '', topns = True, namespaces = {}):\n with codecs.open(fname, \"w\", encoding=\"utf-8\") as outf:\n self.serialize_xml(outf.write, base=base, indent=indent, topns=topns, namespaces=namespaces)",
"def write(self):\n return JavaMLWriter(self)",
"def CreateXMLTransformer() -> TransformerFunc:\n return partial(traverse, transformation_table=XML_AST_transformation_table.copy())",
"def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez",
"def toXMLElement(self):\n property_element = xml.etree.ElementTree.Element('property')\n property_element.set('concept', self.concept_ref)\n\n if self.is_parent:\n property_element.set('isParent', 'true')\n\n return property_element",
"def xmlwrite(self, doc, filename):\n pathname = os.path.join(self.session.session_dir, filename)\n f = open(pathname, \"w\")\n doc.writexml(writer=f, indent=\"\", addindent=\" \", newl=\"\\n\", encoding=\"UTF-8\")\n f.close()",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def makexmlfunc(healpix,ra,dec,week1,week2,distance):\n\t\n\tif week1!=week2:\n\t\tidentity=\"%06d_%d_%d_w%03d_w%03d\" %(healpix,ra,dec,week1,week2)\n\t\tltcube=\"%s/lat_ltcube_weekly_w%03d_w%03d_p203_v001.fits\" %(cfg.home,week1,week2)\n\t\tspacecraft=\"%s/w%03d_w%03d_newspacecraft.fits\" %(cfg.ispace,week1,week2)\n\telse:\n\t\tidentity=\"%06d_%d_%d_w%03d\" %(healpix,ra,dec,week1)\n\t\tltcube=\"%s/lat_spacecraft_weekly_w%03d_p203_v001_ltcube.fits\" %(cfg.home,week1)\n\t\tspacecraft=\"%s/lat_spacecraft_weekly_w%03d_p202_v001.fits \" %(cfg.ispace,week1)\n\n\tregion_filtered=\"%s_region_filtered_gti.fits\" %(identity)\n\tfermisources=\"%s_fermisources_model.xml\" %(identity)\n\tinputmodel=\"%s_input_model.xml\" %(identity)\n\tfermis=\"%s_fermis.xml\" %identity\n\tresponse=\"P7REP_SOURCE_V15\"\n\tmakexmllog=\"%s_output_makexml.log\" %identity\n\tglobal extendedsource\n\tglobal numberofextendedsources\n\textendedlog=\"%s_number_of_extendedsources.log\" %identity\n\tExtendedList=\"ExtendedList.txt\"\n\tOthersList=\"OthersList.txt\"\n\n\t\n\twith open (makexmllog,'r') as outputFile: #opens the makexmllog file from makesyfunc. This document contains info about the extended sources.\n\t\t\n\t\tfor line in outputFile:\n\t\t\t\n\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\tif line.startswith('Added')==True:\n\t\t\t\t\ta,b=line.split('and ')\t\n\t\t\t\t\tb1,b2,b3=b.split(' ')\n\t\t\t\t\n\t\t\t\t\tnumberofextendedsources=int(b1) #b1 is the number of extended sources\n\toutputFile.close()\n\toutputFile=open(inputmodel, 'w')\n\tprint numberofextendedsources\n\n\tif numberofextendedsources==1: #if there is an extended source\n\t\twith open (makexmllog,'r') as outputFile:\n\t\t\n\t\t\tfor line in outputFile:\n\t\t\t\n\t\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\t\tif line.startswith('Extended')==True:\n\t\t\t\t\t\tprint line\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\tc,d=line.split(' in')\n\t\t\t\t\t\n\t\t\t\t\t\tc1,c2,c3,c4=c.split(' ')\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\textendedsource=str(c3) #extracts the name of the extended source from makexmllog\n\t\n\n\t\t\n\n\n\t\toutputFile.close()\t\n\n\n\t\n\n\t\twith open(\"%s\" %fermisources) as thefile: #opens the xml file that was created from makesyfunc\n\t\t\tfor line in thefile:\n\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==True:\n\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tspecial=str.replace(line,'%s.fits'%extendedsource,'%s/%s.fits' %(cfg.homesy,extendedsource)) \n\t\t\t\t\tprint special #replace with the correct path to the extendedsource(Templates folder)\n\t\t\t\n\t\t\t\t\tspecial1=str.replace(special,'type=\"SpatialMap\"','type=\"SpatialMap\" map_based_integral=\"true\"')\n\t\t\t\t\tprint special1 #instruction from fermi tutorial, you must add map_based...\n\t\t\t\t\toutputFile=open(fermis, 'w') #write to fermis, the original xml with the right path to the extended source\n\t\t\t\t\twith open(\"%s\" %fermisources,'r') as infile:\n\t\t\t\t\t\tfor line in infile:\n\t\t\t\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==False:\n\t\t\t\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\toutputFile.write(special1)\n\t\t\t\t\toutputFile.close()\n\t\t\t\t\t\t\t\t\t\n\n\n\t\t\t\n\t\toutputFile=open(inputmodel, 'w') #final xml file. contains the right path and the source info of \"your\" source.\n\t\twith open(fermis,'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\t\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\t\t\t\n\n\t\toutputFile.close()\n\t\n\t\twith open(\"%s_diffrsp.log\" % (identity), 'w') as outsyputFile: #run diffrsp if you have an extended source.\n\t\t\tsubprocess.call(['%s' %(cfg.pythoncommand),'gtdiffrsp.py', '%s' %(region_filtered),'%s' %(spacecraft), '%s' %inputmodel, '%s' %(response),'%s' %identity ],stdout=outsyputFile)\n\t\t\t\n\t\twith open(ExtendedList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\t\t\t\t\n\tif numberofextendedsources==0: #if there is no extended source\n\t\toutputFile=open('%s' %(inputmodel), 'w') #write to inputmodel, \"your\" source\n\t\twith open('%s' %(fermisources),'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\n\t\t\t\n\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\toutputFile.close()\n\tif numberofextendedsources>1:\n\t\twith open(OthersList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\n\tif numberofextendedsources==1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\\n\\\n \t%s\"%(numberofextendedsources,extendedsource))\n\t\toutsyputFile.close()\n\n\tif numberofextendedsources !=1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\" %(numberofextendedsources))\n\t\toutsyputFile.close()",
"def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml",
"def to_xml(self):\n xml_strings = ['<code_object name=\"%s\">' % self.name]\n xml_strings.append(' <type value=\"%s\" />' % self.object_type)\n xml_strings.append(' <source>')\n for source_line in self.source:\n xml_strings.append(source_line[1])\n xml_strings.append(' </source>')\n xml_strings.append('</code_object>')\n return \"\".join(xml_strings)",
"def _toFile(self):\n pass",
"def toGML(self):\n raise NotImplementedError",
"def addXSLTStyleSheet(self, content, URI):\n if self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] == None:\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] = []\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)\n else:\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)",
"def xml_path(self):\n return self.__xml_path",
"def generate_xml(self, provisioning):\n ET.SubElement(self.root, 'generator').text = __revision__\n ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n return self.provisioning2xml(provisioning)",
"def exportXml ( w, xml ):\n assert str ( type ( xml ) ) == \"<type 'str'>\"\n rawText = xml\n pattern = re.compile (r'[^\\S ]+')\n text = re.sub ( pattern, \"\", rawText )\n reparsed = MD.parseString ( text )\n w.write ( reparsed.toprettyxml ( indent = \"\\t\", encoding = \"UTF-8\" ) )",
"def toSBML(self):\n errors = self.document.checkConsistency()\n if errors > 0:\n for i in range(errors):\n print(\n self.document.getError(i).getSeverityAsString(),\n \": \",\n self.document.getError(i).getMessage(),\n )\n\n return libsbml.writeSBMLToString(self.document)"
] | [
"0.6366979",
"0.61544836",
"0.58340883",
"0.5812942",
"0.5640789",
"0.5632317",
"0.5603479",
"0.55815554",
"0.55431604",
"0.55276537",
"0.55154866",
"0.5513102",
"0.5510308",
"0.5458654",
"0.5451725",
"0.54285127",
"0.54037434",
"0.5307067",
"0.5298246",
"0.52886873",
"0.5272622",
"0.5271472",
"0.5232884",
"0.5201279",
"0.519453",
"0.5182671",
"0.5179153",
"0.5172932",
"0.5163209",
"0.5156673",
"0.5148088",
"0.51359093",
"0.5132218",
"0.51303387",
"0.5100232",
"0.50764483",
"0.5070601",
"0.5059149",
"0.50582504",
"0.5056313",
"0.5056309",
"0.5039356",
"0.5028861",
"0.5021943",
"0.5010669",
"0.50036734",
"0.5003039",
"0.49999213",
"0.49748772",
"0.49723393",
"0.49578944",
"0.49532372",
"0.49395603",
"0.4939085",
"0.48923746",
"0.48899695",
"0.48740843",
"0.48715433",
"0.48646557",
"0.48638257",
"0.4852056",
"0.4846309",
"0.48436296",
"0.48433435",
"0.48293883",
"0.4826439",
"0.48262388",
"0.4825601",
"0.48202866",
"0.48137426",
"0.48124427",
"0.4811109",
"0.48028645",
"0.48027924",
"0.47998756",
"0.4795888",
"0.4795888",
"0.47758362",
"0.4772382",
"0.4770035",
"0.4762882",
"0.47570086",
"0.47569758",
"0.4756163",
"0.4751184",
"0.4751131",
"0.47475907",
"0.4746994",
"0.47402462",
"0.47337463",
"0.47337046",
"0.47332537",
"0.47212258",
"0.4720437",
"0.47086617",
"0.47031793",
"0.4701611",
"0.46895015",
"0.46818498",
"0.46814537"
] | 0.5839131 | 2 |
Any format, prefix, suffix, html info in attrs dict | def __init__(self, name, attrs={}):
TextFormat.__init__(self, name, attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html_attrs(attrs):\n html = \"\"\n for a in attrs.items():\n if a[1]:\n html = html + \"%s=\\\"%s\\\" \"%(a)\n return html",
"def attr(*attrs: ATTRIBUTE) -> str:\n return PyHTML.attr(*attrs)",
"def attrs(context):\n result = \"\"\n for key, value in context.flatten().items():\n if key not in [\"True\", \"False\", \"None\", \"content\", \"element\"]:\n if \"hx_\" in key:\n key = key.replace(\"_\", \"-\")\n result += f' {key}=\"{value}\"'\n return mark_safe(result)",
"def __get_attr_format (self, attrs):\r\n format = { \r\n 'editor': None,\r\n 'min': None,\r\n 'max': None,\r\n 'step': None,\r\n 'subtype': None,\r\n 'flags': None,\r\n 'enums': None\r\n }\r\n\r\n for attr in attrs: \r\n attr_type = attr[\"type\"]\r\n if \"editor\" == attr_type:\r\n format['editor'] = attr[\"value\"] \r\n if \"min\" == attr_type:\r\n format['min'] = attr[\"value\"] \r\n if \"max\" == attr_type:\r\n format['max'] = attr[\"value\"] \r\n if \"default\" == attr_type:\r\n format['default'] = attr[\"value\"] \r\n if \"step\" == attr_type:\r\n format['step'] = attr[\"value\"]\r\n if \"subtype\" == attr_type:\r\n format['subtype'] = attr[\"value\"]\r\n if \"flags\" == attr_type:\r\n format['flags'] = attr['value']\r\n if \"enums\" == attr_type:\r\n format['enums'] = attr['value']\r\n\r\n return format",
"def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):\n\n # Merge the attr dict and kw dict into a single attributes\n # dictionary (rewriting any attribute names, extracting\n # namespaces, and merging some values like css classes).\n attributes = {} # dict of key=(namespace,name): value=attribute_value\n if attr:\n for a, v in attr.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n if kw:\n for a, v in kw.items():\n a_ns, a_name = rewrite_attribute_name(a)\n extend_attribute_dictionary(attributes, a_ns, a_name, v)\n\n # Add title attribute if missing, but it has an alt.\n if ('html', 'alt') in attributes and ('html', 'title') not in attributes:\n attributes[('html', 'title')] = attributes[('html', 'alt')]\n\n # Force both lang and xml:lang to be present and identical if\n # either exists. The lang takes precedence over xml:lang if\n # both exist.\n #if ('html', 'lang') in attributes:\n # attributes[('xml', 'lang')] = attributes[('html', 'lang')]\n #elif ('xml', 'lang') in attributes:\n # attributes[('html', 'lang')] = attributes[('xml', 'lang')]\n\n # Check all the HTML attributes to see if they are known and\n # allowed. Ignore attributes if in non-HTML namespaces.\n if allowed_attrs:\n for name in [key[1] for key in attributes if key[0] == 'html']:\n if name in _common_attributes or name in allowed_attrs:\n pass\n elif name.startswith('on'):\n pass # Too many event handlers to enumerate, just let them all pass.\n else:\n # Unknown or unallowed attribute.\n err = 'Illegal HTML attribute \"%s\" passed to formatter' % name\n raise ValueError(err)\n\n # Finally, format them all as a single string.\n if attributes:\n # Construct a formatted string containing all attributes\n # with their values escaped. Any html:* namespace\n # attributes drop the namespace prefix. We build this by\n # separating the attributes into three categories:\n #\n # * Those without any namespace (should only be xmlns attributes)\n # * Those in the HTML namespace (we drop the html: prefix for these)\n # * Those in any other non-HTML namespace, including xml:\n\n xmlnslist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if not k[0]]\n htmllist = ['%s=\"%s\"' % (k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] == 'html']\n otherlist = ['%s:%s=\"%s\"' % (k[0], k[1], wikiutil.escape(v, 1))\n for k, v in attributes.items() if k[0] and k[0] != 'html']\n\n # Join all these lists together in a space-separated string. Also\n # prefix the whole thing with a space too.\n htmllist.sort()\n otherlist.sort()\n all = [''] + xmlnslist + htmllist + otherlist\n return ' '.join(all)\n return ''",
"def get_format_attrs(self, name, field, alt_field_info={}):\n # important_props = ('initial', 'autofocus', 'widget')\n if name in alt_field_info:\n field = deepcopy(field)\n for prop, value in alt_field_info[name].items():\n setattr(field, prop, value)\n initial = field.initial\n initial = initial() if callable(initial) else initial\n attrs, result = {}, []\n if initial and not isinstance(field.widget, Textarea):\n attrs['value'] = str(initial)\n data_val = self.form.data.get(get_html_name(self.form, name), None)\n if data_val not in ('', None):\n attrs['value'] = data_val\n attrs.update(field.widget_attrs(field.widget))\n result = ''.join(f'{key}=\"{val}\" ' for key, val in attrs.items())\n if getattr(field, 'autofocus', None):\n result += 'autofocus '\n if issubclass(self.form.__class__, FormOverrideMixIn):\n # TODO: Expand for actual output when using FormOverrideMixIn, or a sub-class of it.\n result += '%(attrs)s' # content '%(attrs)s'\n else:\n result = '%(attrs)s' + result # '%(attrs)s' content\n return result",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def flatatt(attrs):\n return u''.join([u' %s=\"%s\"' % (k.replace('_', '-'), conditional_escape(v)) for k, v in attrs.items()])",
"def render_attr(key, value, attr_format='{key}=\"{value}\"'):\n\n if not key or ' ' in key:\n raise InvalidAttribute('Invalid name \"{}\"'.format(key))\n\n if value:\n if type(value) is RawNode:\n value = str(value)\n else:\n value = html.escape(str(value))\n\n return attr_format.format(key=key, value=value)\n\n return key",
"def make_attrs(self, mixed):\n if isinstance(mixed, dict):\n return ''.join('%s=\"%s\" ' % (k, v) for k, v in mixed.items())\n return str(mixed)",
"def gen_tag_attrs(self, *a, **kw):\n return gen_tag_attrs(self, *a, **kw)",
"def attributes(self):\n _attrs = [\"label\"]\n if self.attrs:\n _attrs.append(\"attrs\")\n return _attrs",
"def back_to_tag(tag, attrs):\n sol = '<' + tag\n for (prop, val) in attrs:\n sol += ' ' + prop + '=\"' + val + '\"'\n sol += '>'\n return sol",
"def add_attrs(value, arg):\n try:\n # Split list on comma\n kv_pairs = arg.split(\",\")\n except ValueError:\n raise template.TemplateSyntaxError(\n \"add_attrs requires as an argument a string in the format 'key:value, key1:value1, key2:value2...'\"\n )\n\n\n # Create dictionary\n html_attrs = dict()\n\n # Clean items and add attribute pairs to dictionary\n for item in kv_pairs:\n item = item.strip()\n k, v = item.split(\":\")\n html_attrs.update({k.strip():v.strip()})\n\n return value.as_widget(attrs=html_attrs)",
"def _wrap_attr(attr):\n return '={0},'.format(attr)",
"def string_for_attrs(attrs):\n if not attrs: return ''\n return ''.join(' %s=\"%s\"' % (attr, value) for attr, value in attrs)",
"def attr(*attrs: ATTRIBUTE) -> str:\n formatted = []\n for attr_ in attrs:\n if isinstance(attr_, str):\n formatted.append(attr_)\n elif isinstance(attr_, tuple) and len(attr_) == 2:\n formatted.append(f'{attr_[0]}=\"{attr_[1]}\"')\n else:\n raise ValueError(f\"Bad attribute: {attr_}\")\n return \" \".join(formatted)",
"def attrs(self):\n return self.size, self.propSuffix, self.specified",
"def attrs(**kwds):\n\n def decorate(f):\n for k in kwds:\n setattr(f, k, kwds[k])\n return f\n\n return decorate",
"def dot_node_attrs(self):\n\n lbl_name = '%s' % self.format_name(True, True, 24)\n lbl_acc = '<font point-size=\"8.0\">%s</font>' % self.format_id()\n label = self.node_label_fmt % (self.url(), self.name,\n lbl_name, lbl_acc)\n\n node_attrs = {'label': label}\n return node_attrs",
"def attrs(*attributes):\n return ';'.join([ str(i) for i in attributes ])",
"def ATTRIBUTE():\n return \"author\", \"title\", \"publisher\", \"shelf\", \"category\", \"subject\"",
"def getAttributeInfoDictionary(attr, format=None):\n format = format or _getDocFormat(attr)\n return {'name': attr.getName(),\n 'doc': renderText(attr.getDoc() or '', format=format)}",
"def attrsToString(self, attrs):\n string = \"\"\n # for every attribut\n for attr in attrs:\n # converts its name and value to string and adds this to string\n string += \" {}=\\\"{}\\\"\".format(attr[0], attr[1])\n # no exception!\n print(\"Das Attribut ist zu lang!\") if len(attr) > 2 else None\n return string",
"def format_attr(attr: str) -> str:\r\n prefix = query_params[Toml.REMOVE_PREFIX]\r\n suffix = query_params[Toml.REMOVE_SUFFIX]\r\n prefix_len = len(prefix)\r\n suffix_len = len(suffix)\r\n stripped = attr.strip()\r\n if stripped[:prefix_len] == prefix:\r\n stripped = stripped[prefix_len:]\r\n if stripped[-suffix_len:] == suffix:\r\n stripped = stripped[:-suffix_len]\r\n return constcase(stripped).replace('__', '_')",
"def handleAttributes(text, parent):\r\n def attributeCallback(match):\r\n parent.set(match.group(1), match.group(2).replace('\\n', ' '))\r\n return ATTR_RE.sub(attributeCallback, text)",
"def _attrs(self, element, attrs):\n for attr, val in list(attrs.items()):\n element.setAttribute(attr, val)\n return element",
"def date_attrs(name):\n attrs = battrs(name)\n attrs.update({'class': 'form-control datepicker'})\n return attrs",
"def _get_attribute_dic(self, attrs):\n attr_dic = {}\n for attr_pair in attrs:\n attr_dic[attr_pair[0]] = attr_pair[1]\n return attr_dic",
"def extract_attrs(attr_string):\n attributes = {}\n for name, val in FIND_ATTRS.findall(attr_string):\n val = (\n val.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\""\", '\"')\n .replace(\"&\", \"&\")\n )\n attributes[name] = val\n return attributes",
"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs",
"def get_attrs(foreground, background, style):\n return foreground + (background << 4) + style",
"def process_attrs(attrs):\n if attrs.getLength() == 0:\n return {}\n tmp_dict = {}\n for name in attrs.getNames():\n tmp_dict[name] = attrs.getValue(name)\n return tmp_dict",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def parse_tag_attrs(self, *a, **kw):\n return parse_tag_attrs(*a, **kw)",
"def extend_attribute_dictionary(attributedict, ns, name, value):\n\n key = ns, name\n if value is None:\n if key in attributedict:\n del attributedict[key]\n else:\n if ns == 'html' and key in attributedict:\n if name == 'class':\n # CSS classes are appended by space-separated list\n value = attributedict[key] + ' ' + value\n elif name == 'style':\n # CSS styles are appended by semicolon-separated rules list\n value = attributedict[key] + '; ' + value\n elif name in _html_attribute_boolflags:\n # All attributes must have a value. According to XHTML those\n # traditionally used as flags should have their value set to\n # the same as the attribute name.\n value = name\n attributedict[key] = value",
"def _attribs(self, name=None, description=None):\n a = {}\n if name:\n a['name'] = name\n if description:\n a['description'] = description\n return a",
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def addattrs(field, my_attrs):\n my_attrs = my_attrs.split(',')\n my_attrs = dict([attr.split('=') for attr in my_attrs])\n return field.as_widget(attrs=my_attrs)",
"def attrs(xml):\r\n return lxml.html.fromstring(xml).attrib",
"def parse_tag_attrs(tag_str, options_d=None, font_d=None, case=\"\", **kwargs):\n attr_b = kwargs.pop(\"attr\", \"\")\n auto_b = kwargs.pop(\"auto\", False)\n font_d = kwargs.pop(\"font_d\", font_d or {})\n options_d = kwargs.pop(\"options_d\", options_d or {})\n case = kwargs.pop(\"case\", case)\n widget = kwargs.pop(\"widget\", None)\n text_w = kwargs.pop(text_s, None)\n bad_opts = []\n # INTs: height repeatdelay repeatinterval underline width; size fun fov\n for keyval in split_attrs(tag_str):\n if \"=\" in keyval:\n key, val = keyval.split(\"=\")\n val = unquote(val)\n elif keyval:\n key, val = keyval, None\n else:\n continue\n key = key.lower()\n key2, key3, key4 = key[:2], key[:3], key[:4]\n lowval = val.lower() if val else val\n key = unalias(key)\n kalias = alias(key)\n if val == \"None\": # in ('False', 'None') #\n pass\n elif key3 in (\n bg_s,\n background_s[:3],\n fg_s,\n foreground_s[:3],\n ) or kalias in (bg_s, fg_s):\n options_d.update(**{key: val})\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n options_d.update(**{key: val})\n if auto_b and compound_s not in options_d:\n options_d.update(compound=tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],) or kalias == bd_s:\n options_d.update(borderwidth=val)\n elif key4 in (command_s[:4], compound_s[:4],) or kalias in (\n command_as,\n compound_as,\n ):\n options_d.update(**{key: val})\n elif (\n key2 in (height_s[:2], width_s[:2])\n or key3 in (repeatdelay_s[:3], repeatinterval_s[:3])\n or kalias\n in (height_as, width_as, repeatdelay_as, repeatinterval_as)\n ):\n options_d.update(**{key: int(val)})\n elif (\n key2 in (cursor_s[:2],)\n or key3 == font_s[:3]\n or kalias in (cursor_as, font_as)\n ):\n options_d.update(**{key: val})\n elif key2 in (\"r\", relief_s[:2],) or kalias == relief_as:\n options_d.update(relief=val)\n if auto_b and borderwidth_s not in options_d and val != tk.FLAT:\n options_d.update(borderwidth=str(1))\n elif key2 == underline_s[:2] or kalias == underline_as:\n options_d.update(underline=-1 if val is None else int(val))\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ) or kalias in (selectbackground_as, selectforeground_as):\n options_d.update(**{key: val})\n # special for fonts\n elif key2 in (family_s[:2],) or kalias == family_as:\n font_d[family_s] = val\n elif key2 in (size_s[:2],) or kalias == size_as:\n try:\n font_d[size_s] = int(val)\n except ValueError:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: ERROR Setting Font Size to %r\" % val,\n Raise=True,\n )\n elif key3 in (bold_as, tk_font.BOLD[:3]) or kalias == bold_as:\n font_d[weight_s] = (\n tk_font.BOLD\n if str(val) not in (\"0\", \"False\",)\n else tk_font.NORMAL\n )\n elif key2 in (weight_s[:2],) or kalias == weight_as:\n font_d[weight_s] = val\n elif key2 in (italic_as, tk_font.ITALIC[:2]) or kalias == italic_as:\n font_d[slant_s] = (\n tk_font.ITALIC\n if str(val) not in (\"0\", \"False\",)\n else tk_font.ROMAN\n )\n elif key2 in (slant_s[:2],) or kalias == slant_as:\n font_d[slant_s] = val\n elif (\n key3 in (funderline_as, funderline_s[:3])\n or kalias == funderline_as\n ):\n font_d[underline_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n elif (\n key3 in (foverstrike_as, foverstrike_s[:3])\n or kalias == foverstrike_as\n ):\n font_d[overstrike_s] = 1 if str(val) not in (\"0\", \"False\",) else 0\n # special \"case\" implementation\n elif key3 in (case_s[:3],) or kalias == case_as:\n for s in (upper_s, capitalize_s, lower_s, title_s, swapcase_s):\n if s.startswith(lowval):\n case = s if s != capitalize_s else upper_s\n break\n elif (\n key2 == upper_s[:2]\n or key3 in (capitalize_s[:3],)\n or kalias in (upper_as, capitalize_as)\n ):\n if str(val) not in (\"0\", \"False\",):\n case = upper_s\n elif key2 in (lower_s[:2],) or kalias == lower_as:\n if str(val) not in (\"0\", \"False\",):\n case = lower_s\n elif key2 == title_s[:2] or kalias == title_as:\n if str(val) not in (\"0\", \"False\",):\n case = title_s\n elif key2 == swapcase_s[:2] or kalias == swapcase_as:\n if str(val) not in (\"0\", \"False\",):\n case = swapcase_s\n elif key in ():\n bad_opts.append((key, val))\n else:\n options_d.update(**{key: val})\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n if attr_b:\n return (\n case\n if attr_b == case_s\n else options_d.get(attr_b, font_d.get(attr_b))\n )\n return options_d, font_d, case",
"def gen_tag_attrs(widget=None, options_d=None, font=None, case=None, **kwargs):\n auto_b = kwargs.get(\"auto\", False)\n case = kwargs.get(case_s, case)\n extend_b = kwargs.get(\"extend\", False)\n font = kwargs.pop(\"font\", font or {})\n index_i = kwargs.pop(\"index\", None)\n kmode_s = kwargs.get(\"kmode\", \"\") # a=alias, o=options, ''=unchanged\n options_d = kwargs.pop(\"options\", options_d or {})\n pare_b = kwargs.get(\"pare\", True)\n widget = kwargs.pop(\"widget\", widget)\n text_w = kwargs.get(text_s, None)\n recurse_b = kwargs.pop(\"recurse\", widget and isinstance(widget, TTWidget))\n fmt_s = \"\"\n font_d = {}\n w_font_d, w_options_d = {}, {}\n if index_i is not None and widget is None:\n raise Exception(\"Cannot set 'index' when 'widget' is None\")\n if widget: # and isinstance(widget, TTWidget): #\n excludes_t = () if widget.emulation_b else ()\n w_options_d = {\n k: v[-1]\n for k, v in widget.config().items()\n if len(v) == 5 and str(v[-1]) != str(v[-2]) and k not in excludes_t\n }\n try:\n w_options_d[case_s] = widget.case\n except AttributeError:\n pass\n w_font = widget.cget(font_s) # w_options_d.pop(font_s, None)\n w_font_d = get_font_dict(w_font) if w_font else {}\n if pare_b and w_font_d:\n def_w_font = widget.config(font_s)[-2]\n def_w_font_d = get_font_dict(def_w_font)\n w_font_d = pare_dict(w_font_d, def_w_font_d)\n if font:\n if isinstance(font, str):\n try:\n font = tk_font.nametofont(font)\n except tk.TclError:\n pass\n elif type(font) in (list, tuple):\n font = tk_font.Font(font=font)\n if isinstance(font, tk_font.Font):\n font = font.actual()\n if isinstance(font, dict):\n font_d = font\n if case: # is not None:\n options_d = _merge_dicts(options_d, dict(case=case))\n d = _merge_dicts(\n w_options_d,\n convert_font_dict_to_ttoptions_dict(w_font_d),\n options_d,\n convert_font_dict_to_ttoptions_dict(font_d),\n kwargs,\n )\n bad_opts = []\n for key, val in d.items():\n key = key.lower()\n if key in (\"auto\", \"extend\", \"kmode\", \"pare\",): # text_s, ): #\n continue\n key2, key3, key4 = key[:2], key[:3], key[:4]\n kalias = alias(key)\n koption = unalias(key)\n if kmode_s:\n if kmode_s[0] == \"a\": # alias\n keyout = kalias\n kfunc = alias\n auto_cpd, auto_bd = compound_as, bd_s\n elif kmode_s[0] == \"o\": # option\n keyout = koption\n kfunc = unalias\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n else:\n keyout = key\n kfunc = str\n auto_cpd, auto_bd = compound_s, borderwidth_s # bd_s #\n if val:\n val = quote(val)\n if (\n key3 in (bg_s, background_s[:3], fg_s, foreground_s[:3])\n or key2 == underline_s[:2]\n or kalias in (bg_s, fg_s, underline_as)\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (bitmap_s[:2], image_s[:2],) or kalias in (\n bitmap_as,\n image_as,\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_cpd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_cpd, tk.CENTER)\n elif key3 in (bd_s, borderwidth_s[:3],):\n if \"%s=%s \" % (auto_bd, 1) in fmt_s:\n if val != 1:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_bd, 1), \"%s=%s \" % (keyout, val)\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key4 in (compound_s[:4],) or kalias == compound_as:\n if \"%s=%s \" % (auto_cpd, tk.CENTER) in fmt_s:\n if val != tk.CENTER:\n fmt_s = fmt_s.replace(\n \"%s=%s \" % (auto_cpd, tk.CENTER),\n \"%s=%s \" % (keyout, val),\n )\n else:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == cursor_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key3 == font_s[:3]:\n fmt_s += \"%s=%s \" % (keyout, get_named_font(val))\n elif key2 in (relief_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n if auto_b and \"%s=\" % auto_bd not in fmt_s:\n fmt_s += \"%s=%s \" % (auto_bd, 1)\n # special for TTListbox\n elif key[:7] in (\n sbg_s,\n selectbackground_s[:7],\n sbd_s,\n selectborderwidth_s[:7],\n sfg_s,\n selectforeground_s[:7],\n ):\n fmt_s += \"%s=%s \" % (keyout, val)\n # special for fonts\n elif key2 in (family_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (size_s[:2],):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key2 in (weight_s[:2],):\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.BOLD),\n 1\n if isinstance(val, str) and val.lower() == tk_font.BOLD\n else 0,\n )\n elif key2 == slant_s[:2]:\n fmt_s += \"%s=%d \" % (\n kfunc(tk_font.ITALIC),\n 1\n if isinstance(val, str) and val.lower() == tk_font.ITALIC\n else 0,\n )\n elif key3 in (funderline_as, funderline_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(funderline_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n elif key3 in (foverstrike_as, foverstrike_s[:3]):\n fmt_s += \"%s=%d \" % (\n kfunc(foverstrike_s),\n 1 if str(val) in (\"1\", \"True\") else 0,\n )\n # special \"case\" implementation\n elif key3 == case_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(case_s), val)\n elif key2 == upper_s[:2] or key3 == capitalize_s[:3]:\n fmt_s += \"%s=%s \" % (kfunc(upper_s), val)\n elif key2 in (lower_s[:2], title_s[:2], swapcase_s[:2]):\n fmt_s += \"%s=%s \" % (keyout, val)\n elif key in ():\n bad_opts.append((key, val))\n elif key in (text_s, text_as):\n if extend_b or widget:\n fmt_s += \"%s=%s \" % (keyout, val)\n else:\n # bad_opts.append((key, val))\n fmt_s += \"%s=%s \" % (keyout, val)\n if bad_opts:\n _print_out(\n widget,\n text_w,\n \"EXCEPTION: UNEXPECTED TAG ATTRS: %r\" % bad_opts,\n Raise=True,\n )\n fmt = fmt_s.strip()\n if widget and isinstance(widget, TTWidget) and recurse_b:\n fmt = [\n fmt,\n ]\n for _, gathering in widget._get_kids(items=True):\n child = gathering[\"label\"]\n case = gathering.get(case_s, \"\")\n kid_options = {\n k: v[-1]\n for k, v in child.config().items()\n if len(v) == 5\n and str(v[-1]) != str(v[-2])\n and (k, v[-1]) not in w_options_d.items()\n and not (k in label_override_d and str(v[-1]) == \"0\")\n } #\n cf = kid_options.pop(font_s, None)\n cdf = child.config(font_s)[-2]\n if cf != cdf:\n c_font_d = pare_dict(get_font_dict(cf), get_font_dict(cdf))\n else:\n c_font_d = {}\n if case:\n kid_options.update(case=case)\n fmt.append(\n gen_tag_attrs(options=kid_options, font=c_font_d, **kwargs)\n )\n return fmt if index_i is None else fmt[index_i]",
"def format_attributes(attributes):\n return ';'.join([k + '=' + v for k, v in attributes.items()])",
"def handle_meta(self, tag, attrs):\n ad = {}\n for tup in attrs:\n ad[tup[0]] = tup[1]\n if 'name' in ad.keys() \\\n and 'keywords' == ad['name'] \\\n and 'content' in ad.keys():\n self.filetype = ad['content']\n if 'name' in ad.keys() \\\n and 'description' == ad['name']:\n self.description = 'present'\n if 'charset' in ad.keys():\n self.charset = 'present'",
"def add_attributes(self, attrs):\n self.attrs.add_container(attrs)",
"def set_attrs(dict, elem, attrs):\n for attr in attrs:\n if attr in elem.keys():\n dict[attr] = elem.get(attr)",
"def __init__(self, attrs: Dict[str, Any]) -> None:\n self.attrs = attrs",
"def prepare_node_attrs(self):",
"def get_attribute_data(self, attrs):\n return {\n 'id': attrs['data-id'],\n }",
"def get_attrs(self):\n req_attrv = self._ptr.contents.attrv\n attrs = {}\n if bool(req_attrv):\n i = 0\n while 1:\n s = bytestostr(req_attrv[i])\n i += 1\n if s == None:\n break\n try:\n k, v = s.split(\"=\", 1)\n attrs[k] = v\n except:\n pass\n return attrs",
"def attkey_to_SVG_attribs(self,k):\n atts= k.split('@')\n o= ''\n acodes= {'C':'stroke','W':'stroke-width','S':'stroke-dasharray','O':'stroke-opacity'}\n for a in atts:\n if a[0] in acodes:\n o+= '%s=\"%s\" ' % (acodes[a[0]],a[1:])\n# elif a[0] == 'S': # Maybe do something special like this.\n# o+= 'stroke-dasharray=\"%\" ' % a[1:]\n return o",
"def add_attributes(self, attrs):\n self.attrs.add_attributes(attrs)",
"def fix_attributes(string):\n defs = re.compile('<dl class=\"attribute\">(?P<descrip>.*?)</dl>',flags=re.DOTALL)\n name = re.compile('<code class=\"descclassname\">(?P<name>[^<]*)</code>')\n prefix = ''\n remain = string\n \n match = defs.search(remain)\n while match:\n prefix += remain[:match.start(1)]\n prefsub = ''\n remnsub = remain[match.start(1):match.end(1)]\n descrip = name.search(remnsub)\n if descrip:\n prefix += remnsub[:descrip.start()]\n prefix += remnsub[descrip.end():]\n prefix += remain[match.end(1):match.end(0)]\n else:\n prefix += remain[match.start(1):match.end(0)]\n remain = remain[match.end(0):]\n match = defs.search(remain)\n return prefix+remain",
"def a_attr_dict (self) :\n return dict (href = self.abs_href)",
"def attributes(table,attrs): \n if isinstance(table,Table):\n table.html_attributes = attrs\n return table",
"def read_attribs(self):\n\n attribs = {}\n while self.index < self.length:\n self.ignore_whitespaces()\n if self.xtext[self.index] == '>':\n break\n name = self.read_until('=')\n self.index += 1\n self.read_until('\"')\n self.index += 1\n value = self.read_until('\"')\n self.index += 1\n\n attribs[name] = value\n\n return attribs",
"def extensible_attributes():\n return 'extensibleattributedef?'",
"def transform_attributes(attrs):\n transformed = {}\n for key, value in attrs.items():\n if key in [\"raw_message\", \"text\"]:\n transformed[\"raw_content\"] = value\n elif key in [\"diaspora_handle\", \"sender_handle\", \"author\"]:\n transformed[\"handle\"] = value\n elif key == \"recipient_handle\":\n transformed[\"target_handle\"] = value\n elif key == \"parent_guid\":\n transformed[\"target_guid\"] = value\n elif key == \"first_name\":\n transformed[\"name\"] = value\n elif key == \"image_url\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"large\"] = value\n elif key == \"image_url_small\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"small\"] = value\n elif key == \"image_url_medium\":\n if \"image_urls\" not in transformed:\n transformed[\"image_urls\"] = {}\n transformed[\"image_urls\"][\"medium\"] = value\n elif key == \"tag_string\":\n transformed[\"tag_list\"] = value.replace(\"#\", \"\").split(\" \")\n elif key == \"bio\":\n transformed[\"raw_content\"] = value\n elif key == \"searchable\":\n transformed[\"public\"] = True if value == \"true\" else False\n elif key == \"target_type\":\n transformed[\"entity_type\"] = DiasporaRetraction.entity_type_from_remote(value)\n elif key == \"remote_photo_path\":\n transformed[\"remote_path\"] = value\n elif key == \"remote_photo_name\":\n transformed[\"remote_name\"] = value\n elif key == \"status_message_guid\":\n transformed[\"linked_guid\"] = value\n transformed[\"linked_type\"] = \"Post\"\n elif key in BOOLEAN_KEYS:\n transformed[key] = True if value == \"true\" else False\n elif key in DATETIME_KEYS:\n try:\n # New style timestamps since in protocol 0.1.6\n transformed[key] = datetime.strptime(value, \"%Y-%m-%dT%H:%M:%SZ\")\n except ValueError:\n # Legacy style timestamps\n transformed[key] = datetime.strptime(value, \"%Y-%m-%d %H:%M:%S %Z\")\n elif key in INTEGER_KEYS:\n transformed[key] = int(value)\n else:\n transformed[key] = value or \"\"\n return transformed",
"def tag(func):\n @functools.wraps(func)\n def wrapper(**kwargs):\n\n name = func.__name__\n\n if kwargs:\n \n try:\n\n check_text = kwargs['text']\n del kwargs['text']\n \n \n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n open('index.html', 'a+').write(f\"{check_text}\")\n open('index.html', 'a+').write(f\"</{name}>\")\n\n except KeyError:\n\n kwargs = {\n k.replace(\"__\", \"\").replace(\"_\", \"-\"): v for k, v in kwargs.items()\n }\n\n all_attr = f\"<{name} \", *(f' {key}=\"{value}\"' for key, value in kwargs.items()), \">\"\n open('index.html', 'a+').write(f\"\\n{join_attr(all_attr)}\")\n\n else:\n\n open('index.html', 'a+').write(f\"\\n<{name}>\")\n\n\n func(**kwargs)\n \n return wrapper",
"def getAttrsDict(attrs):\r\n attrsDict = json.loads(re.sub('/\\\"(?!(,\\s\"|}))','\\\\\"',attrs).replace(\"\\t\",\" \").replace(\"\\n\",\" \")) if len(attrs)>0 else {}\r\n return attrsDict",
"def parse_tag_attrs(\n self, tags_str, options_d=None, font_d=None, case=\"\", **kwargs\n ):\n return parse_tag_attrs(\n tags_str,\n options_d,\n font_d,\n case,\n widget=self,\n text=getattr(self, \"debug_text\", None),\n **kwargs\n )",
"def _get_annotation_data_attr(self, index, el):\r\n\r\n data_attrs = {}\r\n attrs_map = {\r\n 'body': 'data-comment-body',\r\n 'title': 'data-comment-title',\r\n 'problem': 'data-problem-id'\r\n }\r\n\r\n for xml_key in attrs_map.keys():\r\n if xml_key in el.attrib:\r\n value = el.get(xml_key, '')\r\n html_key = attrs_map[xml_key]\r\n data_attrs[html_key] = {'value': value, '_delete': xml_key}\r\n\r\n return data_attrs",
"def get_attributes(self) -> Dict[str, str]:\n pass",
"def transform(attrs: dict) -> dict:\n\n pass",
"def get_html_element_attributes(self):\n html_element_attributes = {\n 'class': self.css_classes or False, # Fall back to false to avoid class=\"\"\n }\n if self.should_render_as_link():\n html_element_attributes['href'] = self.url\n return html_element_attributes",
"def create_descr(self, attr_name):",
"def _checkTableAttr(self, attrs, prefix):\n if not attrs:\n return {}\n\n result = {}\n s = [] # we collect synthesized style in s\n for key, val in attrs.items():\n # Ignore keys that don't start with prefix\n if prefix and key[:len(prefix)] != prefix:\n continue\n key = key[len(prefix):]\n val = val.strip('\"')\n # remove invalid attrs from dict and synthesize style\n if key == 'width':\n s.append(\"width: %s\" % val)\n elif key == 'height':\n s.append(\"height: %s\" % val)\n elif key == 'bgcolor':\n s.append(\"background-color: %s\" % val)\n elif key == 'align':\n s.append(\"text-align: %s\" % val)\n elif key == 'valign':\n s.append(\"vertical-align: %s\" % val)\n # Ignore unknown keys\n if key not in self._allowed_table_attrs[prefix]:\n continue\n result[key] = val\n st = result.get('style', '').split(';')\n st = '; '.join(st + s)\n st = st.strip(';')\n st = st.strip()\n if not st:\n try:\n del result['style'] # avoid empty style attr\n except:\n pass\n else:\n result['style'] = st\n #logging.debug(\"_checkTableAttr returns %r\" % result)\n return result",
"def set_attrs(self, username, attrs):\n pass",
"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\r\n prettyPrint=False, indentLevel=0):\r\n\r\n encodedName = self.toEncoding(self.name, encoding)\r\n\r\n attrs = []\r\n if self.attrs:\r\n for key, val in self.attrs:\r\n fmt = '%s=\"%s\"'\r\n if isString(val):\r\n if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\r\n val = self.substituteEncoding(val, encoding)\r\n\r\n # The attribute value either:\r\n #\r\n # * Contains no embedded double quotes or single quotes.\r\n # No problem: we enclose it in double quotes.\r\n # * Contains embedded single quotes. No problem:\r\n # double quotes work here too.\r\n # * Contains embedded double quotes. No problem:\r\n # we enclose it in single quotes.\r\n # * Embeds both single _and_ double quotes. This\r\n # can't happen naturally, but it can happen if\r\n # you modify an attribute value after parsing\r\n # the document. Now we have a bit of a\r\n # problem. We solve it by enclosing the\r\n # attribute in single quotes, and escaping any\r\n # embedded single quotes to XML entities.\r\n if '\"' in val:\r\n fmt = \"%s='%s'\"\r\n if \"'\" in val:\r\n # TODO: replace with apos when\r\n # appropriate.\r\n val = val.replace(\"'\", \"&squot;\")\r\n\r\n # Now we're okay w/r/t quotes. But the attribute\r\n # value might also contain angle brackets, or\r\n # ampersands that aren't part of entities. We need\r\n # to escape those to XML entities too.\r\n val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\r\n\r\n attrs.append(fmt % (self.toEncoding(key, encoding),\r\n self.toEncoding(val, encoding)))\r\n close = ''\r\n closeTag = ''\r\n if self.isSelfClosing:\r\n close = ' /'\r\n else:\r\n closeTag = '</%s>' % encodedName\r\n\r\n indentTag, indentContents = 0, 0\r\n if prettyPrint:\r\n indentTag = indentLevel\r\n space = (' ' * (indentTag-1))\r\n indentContents = indentTag + 1\r\n contents = self.renderContents(encoding, prettyPrint, indentContents)\r\n if self.hidden:\r\n s = contents\r\n else:\r\n s = []\r\n attributeString = ''\r\n if attrs:\r\n attributeString = ' ' + ' '.join(attrs)\r\n if prettyPrint:\r\n s.append(space)\r\n s.append('<%s%s%s>' % (encodedName, attributeString, close))\r\n if prettyPrint:\r\n s.append(\"\\n\")\r\n s.append(contents)\r\n if prettyPrint and contents and contents[-1] != \"\\n\":\r\n s.append(\"\\n\")\r\n if prettyPrint and closeTag:\r\n s.append(space)\r\n s.append(closeTag)\r\n if prettyPrint and closeTag and self.nextSibling:\r\n s.append(\"\\n\")\r\n s = ''.join(s)\r\n return s",
"def attributes(self):\n _attrs = [\"type\", \"name\", \"value\"]\n if self.confidence is not None:\n _attrs.append(\"confidence\")\n if self.constant:\n _attrs.append(\"constant\")\n if self.tags:\n _attrs.append(\"tags\")\n\n return _attrs",
"def Attribute(name, value=None):\r\n if value:\r\n return '{}=\"{}\"'.format(name, value)\r\n else:\r\n return ''",
"def convert_attributes(cls, attrs):\n return {}",
"def get_switched_form_field_attrs(self, prefix, input_type, name):\n attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}\n attributes['data-' + prefix + 'field-' + input_type] = name\n return attributes",
"def AttributeString(self) -> str:",
"def AttributeString(self) -> str:",
"def proc_attr(inp):\n dic = {}\n for att in inp.attrs.keys():\n if getattr(inp.attrs[att], \"dtype\", None) is None:\n dic[att] = inp.attrs[att]\n elif inp.attrs[att].dtype.char == 'S':\n dic[att] = [\n x.strip() for x in inp.attrs[att].tostring().decode('ascii').split(',')\n ]\n else:\n dic[att] = (\n inp.attrs[att][0]\n if isinstance(inp.attrs[att],np.ndarray) and\n inp.attrs[att].size==1\n else inp.attrs[att]\n )\n return dic\n pass",
"def add_attr(self, section_name: str, attr_name: str, value: str) -> None:\n pass",
"def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }",
"def widget_attrs(self, widget):\n\n attrs = super(RelateField, self).widget_attrs(widget)\n\n attrs.update({'content_type': self.content_types})\n\n return attrs",
"def attributes(doc, header, renderer=Attribute, item_class=DefinitionItem):\n items = doc.extract_items(item_class)\n lines = []\n renderer = renderer()\n for item in items:\n renderer.item = item\n lines += renderer.to_rst()\n lines.append('')\n return lines",
"def info_from_entry(self, entry):\n info = super().info_from_entry(entry)\n info[ATTR_NAME] = info[ATTR_PROPERTIES]['Name'].replace('\\xa0', ' ')\n return info",
"def img(self, **kwargs):\n attrs = ''\n for item in kwargs.items():\n if not item[0] in IMGATTRS:\n raise AttributeError, 'Invalid img tag attribute: %s'%item[0]\n attrs += '%s=\"%s\" '%item\n return '<img src=\"%s\" %s>'%(str(self),attrs)",
"def gen_tag_attrs(self, *a, **kw):\n if kw.get(\"widget\", sentinel) is not None:\n raise Exception(\n \"TTToolTip.gen_tag_attrs(): 'widget' keyword must be set\"\n \" to None\"\n )\n return gen_tag_attrs(None, *a, **kw)",
"def init_attrs(self):\n raise NotImplementedError",
"def _arg_attr(identifier, attr1, attr2):\n return attr1 if identifier.startswith('t') else attr2",
"def _get_var_attrs(var):\n\n generic_dict = {'instrument': '', 'valid_range': (-1e+35,1e+35),\n 'missing_value': -9999, 'height': '',\n 'standard_name': '', 'group_name': '',\n 'serial_number': ''}\n\n generic_dict.update(attrs_dict[var])\n return generic_dict",
"def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}",
"def _style_to_basic_html_attributes(self, element, style_content,\n force=False):\n if style_content.count('}') and \\\n style_content.count('{') == style_content.count('{'):\n style_content = style_content.split('}')[0][1:]\n\n attributes = {}\n for rule in style_content.split(';'):\n split = rule.split(':')\n if len(split) != 2:\n continue\n key = split[0].strip()\n value = split[1]\n\n if key == 'text-align':\n attributes['align'] = value.strip()\n elif key == 'background-color':\n attributes['bgcolor'] = value.strip()\n elif key == 'width' or key == 'height':\n value = value.strip()\n if value.endswith('px'):\n value = value[:-2]\n attributes[key] = value\n\n for key, value in list(attributes.items()):\n if key in element.attrib and not force or key in self.disable_basic_attributes:\n # already set, don't dare to overwrite\n continue\n element.attrib[key] = value",
"def attrs_to_dict(self, attrs):\n return {k: v for k, v in attrs}",
"def domAttributesToString( node ):\n strOut = \"node has %d attribute(s):\\n\" % node.attributes.length;\n for i in range(node.attributes.length):\n attr = node.attributes.item(i);\n strOut += \"- %s:'%s'\\n\" % (attr.name, attr.value );\n return strOut;",
"def dict_with_attrs2(*args):\n class CustomDict(object):\n __slots__ = args\n __dict__ = {}\n\n def __init__(self, *args, **kwargs):\n super(CustomDict, self).__init__()\n if args:\n self.__dict__.update(*args)\n\n for k, v in kwargs.iteritems():\n setattr(self, k, v)\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, val):\n self.__dict__[key] = val\n\n def __delitem__(self, key):\n del self.__dict__[key]\n\n def __getattr__(self, name):\n return self.__dict__[name]\n\n return CustomDict",
"def attributes(self):\n attrs_ = [\"name\", \"type\"]\n if self.exclusive:\n attrs_.append(\"exclusive\")\n if self.default is not None:\n attrs_.append(\"default\")\n\n return attrs_",
"def replace_tag_attributes(code_attrs, tag, tag_attrs):\n\n new_attrs = code_attrs.copy()\n for key, value in tag_attrs.items():\n if key in new_attrs:\n new_attrs[key] = new_attrs[key].replace(tag, value)\n\n return new_attrs",
"def _iterattrs(self, handle=\"\"):\n if not handle:\n handle = self.handle\n attr = gv.firstattr(handle)\n while gv.ok(attr):\n yield gv.nameof(attr), decode_page(gv.getv(handle, attr))\n attr = gv.nextattr(handle, attr)",
"def as_html(self):\n return mark_safe(\" \".join([\n self.attribute_template % (k, escape(v if not callable(v) else v()))\n for k, v in six.iteritems(self) if not v in EMPTY_VALUES]))",
"def strpatt(self, name):\n return name.replace(\"att.\", \"\")",
"def format_link(attrs: Dict[tuple, str], new: bool = False):\n try:\n p = urlparse(attrs[(None, 'href')])\n except KeyError:\n # no href, probably an anchor\n return attrs\n\n if not any([p.scheme, p.netloc, p.path]) and p.fragment:\n # the link isn't going anywhere, probably a fragment link\n return attrs\n\n c = urlparse(settings.SITE_URL)\n if p.netloc != c.netloc:\n # link is external - secure and mark\n attrs[(None, 'target')] = '_blank'\n attrs[(None, 'class')] = attrs.get((None, 'class'), '') + ' external'\n attrs[(None, 'rel')] = 'nofollow noopener noreferrer'\n\n return attrs",
"def extractAttrs(obj, justLabel=False, dictName=''):\n return extractAttrsCore(obj, {}, justLabel, dictName)",
"def parseAttrs(self,attrs,date_type):\n\tattrs=copy.copy(attrs) #make sure we don't change user/group attributes\n \tattr_holders=self.getAttrHolders(attrs)\n\tmap(lambda x:x.setDateType(date_type),attr_holders)\n\tmap(lambda x:attrs.update(x.getParsedDic()),attr_holders)\n\treturn attrs",
"def add_attributes(self, attrs):\n for attr in attrs:\n self.add_attribute(attr)",
"def _parse_attr(self, attr_proto):\n attrs = {}\n for a in attr_proto:\n for f in ['f', 'i', 's']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['floats', 'ints', 'strings']:\n if list(getattr(a, f)):\n assert a.name not in attrs, \"Only one type of attr is allowed\"\n attrs[a.name] = tuple(getattr(a, f))\n for f in ['t', 'g']:\n if a.HasField(f):\n attrs[a.name] = getattr(a, f)\n for f in ['tensors', 'graphs']:\n if list(getattr(a, f)):\n raise NotImplementedError(\"Filed {} is not supported in mxnet.\".format(f))\n if a.name not in attrs:\n raise ValueError(\"Cannot parse attribute: \\n{}\\n.\".format(a))\n return attrs"
] | [
"0.735201",
"0.6754294",
"0.67166066",
"0.67071074",
"0.66780305",
"0.65807486",
"0.6522693",
"0.6522693",
"0.65187657",
"0.6471306",
"0.6269984",
"0.62653935",
"0.6153201",
"0.6090701",
"0.60323846",
"0.60278016",
"0.6011661",
"0.60042846",
"0.59841794",
"0.5941162",
"0.59205276",
"0.5918955",
"0.59121054",
"0.5903962",
"0.5884743",
"0.5876164",
"0.5857109",
"0.5851559",
"0.583173",
"0.58274394",
"0.5816038",
"0.58061635",
"0.5784312",
"0.5755998",
"0.5755998",
"0.57360405",
"0.57051307",
"0.5701552",
"0.5687975",
"0.5650812",
"0.5618766",
"0.561154",
"0.5605911",
"0.56030387",
"0.5602799",
"0.55926436",
"0.5587559",
"0.5571399",
"0.5567558",
"0.55631375",
"0.555545",
"0.5550559",
"0.55490625",
"0.55470836",
"0.55410224",
"0.5519966",
"0.55098814",
"0.5492064",
"0.547102",
"0.5470936",
"0.54692423",
"0.5467515",
"0.54661024",
"0.54518676",
"0.54405665",
"0.5438651",
"0.54003173",
"0.5388153",
"0.5382598",
"0.5375904",
"0.5375076",
"0.53706104",
"0.5359634",
"0.5354708",
"0.5354708",
"0.5331472",
"0.5324531",
"0.53227526",
"0.5316361",
"0.5309617",
"0.5308968",
"0.53067",
"0.5306182",
"0.5299369",
"0.52990687",
"0.5287107",
"0.52791494",
"0.5277907",
"0.5276578",
"0.52742803",
"0.5270845",
"0.52608305",
"0.52524847",
"0.5244876",
"0.5239417",
"0.5234171",
"0.5224983",
"0.5215326",
"0.521457",
"0.5212088",
"0.5203955"
] | 0.0 | -1 |
Called by base init, after class change or format text change | def initFormat(self):
self.html = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initFormat(self):\n pass",
"def init_text(self):\n d = self.declaration\n if d.text:\n self.set_text(d.text)\n if d.text_color:\n self.set_text_color(d.text_color)\n if d.text_alignment:\n self.set_text_alignment(d.text_alignment)\n if d.font_family or d.text_size:\n self.refresh_font()\n if hasattr(d, 'max_lines') and d.max_lines:\n self.set_max_lines(d.max_lines)",
"def initFormat(self):\n self.formatList = self.splitText(self.format)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, name, attrs={}):\n TextFormat.__init__(self, name, attrs)",
"def __init__(self, text):\n\n self.text = text",
"def __init__(self, text):\n self.text = text",
"def __init__(self, text):\n self.text = text",
"def __init__(self):\n self.text = ''",
"def set_text(self):\n pass",
"def post_init(self):\n\t\tpass",
"def init_widget(self):\n super(UiKitTextView, self).init_widget()\n self.init_text()",
"def __init__(self,\n text: str) -> None:\n\n super().__init__(text)",
"def initFormat(self):\n self.formatList = []",
"def _post_init(self):\n pass",
"def __post_init__(self):\n pass",
"def initWidgets(self):\n self.lambdtext.setText(str(self.lambd))\n self.ptext.setText(str(self.p))",
"def done_adding_strings(self):\n #placeholder in case there's some additional init we need to do.\n pass",
"def done_adding_strings(self):\n #placeholder in case there's some additional init we need to do.\n pass",
"def _init_display(self):\n raise NotImplementedError",
"def __init__(self):\n super(Command, self).__init__()\n self.style.TITLE = self.style.SQL_FIELD\n self.style.STEP = self.style.SQL_COLTYPE\n self.style.ITEM = self.style.HTTP_INFO\n disconnect_objectapp_signals()",
"def __init__(self, font='mediumbold'):\n\tself.set_font(font)",
"def __init__(self):\r\n self.label = \"Bulk Layout Text Replace\"\r\n self.alias = \" Jake's Toolbox Alias Property True\"\r\n self.description = \"\"\r\n self.canRunInBackground = False",
"def __post_init__(self):\n super().__post_init__()",
"def __init__(self):\n super(Command, self).__init__()\n self.style.TITLE = self.style.SQL_FIELD\n self.style.STEP = self.style.SQL_COLTYPE\n self.style.ITEM = self.style.HTTP_INFO\n disconnect_gstudio_signals()",
"def after_parsing(self):",
"def __init__(self, as_text=False, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.as_text = as_text",
"def after_init(self):\n if self.options.format.appended:\n self.error_format = self.options.format.appended[0]",
"def on_origEdit_textChanged(self):\n self.__updatePronounceButtons()\n self.__updateClearButton()\n self.__updateTranslateButton()",
"def after_init(self) -> None:\n if self.options.format.lower() != \"default_notebook\":\n self.error_format = self.options.format\n if not hasattr(self, \"color\"):\n self.color = True",
"def afterInit(self):",
"def post_init(self, msg='hello'):\n print(\"post init ! height=%s, color=%s, msg=%s\" % (self.height, self.color, msg))\n self.non_field_attr = msg",
"def __init__(self, name, time, text):\n pass",
"def init(self):",
"def init(self):",
"def __init__(self,txt=u'',unicodeEncoding='utf-8',verbose=False,tagID=0):\n # __document capture the document level structure\n # for each sentence and then put in the archives when the next sentence\n # is processed\n super(ConTextMarkup,self).__init__(__txt=None,__rawTxt=txt,\n __SCOPEUPDATED=False,__VERBOSE=verbose,\n __tagID=tagID,\n __unicodeEncoding=unicodeEncoding)\n self.__cleanText()",
"def __init__(self):\n\t\t# Setup fonts\n\t\tself.large_font = self._get_font(1,Annotator.THICK)\n\t\tself.large_font_outline = self._get_font(1,Annotator.THICK + Annotator.BORDER)\n\t\t\n\t\tself.small_font = self._get_font(0.5,Annotator.THIN)\n\t\tself.small_font_outline = self._get_font(0.5,Annotator.THIN + Annotator.BORDER)\n\t\t\n\t\t# Text colour\n\t\tself.colour = Annotator.COLOUR_BUSY\n\t\t\n\t\tself.forehead = (0,0,1,1)\n\t\tself.face = (0,0,1,1)",
"def onInit(self):\n pass",
"def _afterInit(self):\n pass",
"def __init__(self, **kwargs):\n # We set it to True so that starting empty lines are\n # not counting as separators\n self.last_line_was_empty = True",
"def _post_init(self) -> None:\n return",
"def _init(self):",
"def update_editor ( self ):\n super( SimpleFontEditor, self ).update_editor()\n set_font( self )",
"def __init__(self, text=\"\", widget=None):\n self._label_text = text\n self._widget = widget\n self._widget.on_change = self._update\n super().__init__(text=f\"{text} {widget.value}\")",
"def initialize(self):",
"def initialize(self):",
"def initialize(self):",
"def initialize(self):",
"def initialize(self): \r\n pass",
"def init_widget(self):",
"def __init__(self):\n ## Global initialization\n self.default_initialization()\n ## Initial function set\n self.selfdriven = False\n self._format_default_functions()\n ## Check descriptormodel\n self._assert_correctness()",
"def __init__(self):\n self.content = \"\"",
"def setInitDefault(self, editText):\n if editText in DateFormat.dateStampStrings:\n self.initDefault = DateFormat.dateStampStrings[0]\n else:\n TextFormat.setInitDefault(self, editText)",
"def initWidgets(self):\n self.loctext.setText(\"{0:g}\".format(self.loc))\n self.scaletext.setText(\"{0:g}\".format(self.scale))",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def initDocTagText(self):\n self.doc, self.tag, self.text = Doc().tagtext()",
"def __init__(\n self,\n type,\n text):\n self.type = type\n self.text = text",
"def _init(self):\n pass",
"def format(self):\n ...",
"def _initialize(self):\n \n self.view.lineEdit_3.setText(\"C,H,N,O,P,S\")\n self.view.spin_hit.setValue(20)\n self.view.lineEdit_2.setValue(10.)\n self.view.checkBox_8.setChecked(True)",
"def init(self) -> None:",
"def update_editor ( self ):\n super( TextFontEditor, self ).update_editor()\n set_font( self )",
"def __init__(self):\n\t\tprint(\"Class initilised\")",
"def __init__(self, msg='hello'):\n print(\"post init ! height=%s, color=%s, msg=%s\" % (self.height, self.color, msg))\n self.non_field_attr = msg",
"def __init__(self, text='', **kwargs):\n Control.__init__(self, text=text, **kwargs)",
"def on_transEdit_textChanged(self):\n self.__updatePronounceButtons()\n self.__updateClearButton()",
"def __init__(self, text, idx):\n self.text = text\n self.idx = idx",
"def __init__(self):\n self.update_state()",
"def __init__(self):\n fmt = \"%(message)s\"\n super().__init__(fmt=fmt)\n\n self.baseline = None\n self.cut = None\n self.manual_push = 0",
"def set_initial_values(self):\n #Stores each line of the text file in a list\n self.text = []\n \n #Scrolling distance\n self.scroll = 0\n\n #Zooming level (font size) \n self.zoom = 12\n\n #Factor by which is decrement self.zoom\n self.factor = 0\n\n #Number of tabs spaces before a line\n self.indent = 0\n\n #Flag to only set up pango descriptions only once \n self.set_pc = 1\n\n #list of indetation level of all lines\n self.tab_index = []\n\n #Total line count\n self.line_count = 0\n\n #line number of line rendered off top of window \n self.min_text = 0\n #line number of line rendered off bottom of window \n self.max_text = 50\n\n #y position for cairo for the text at the top\n self.min_cairo = 20\n\n #y position for text at bottom\n self.max_cairo = 20\n\n #x positiong for indented text\n self.tab_cairo = 20",
"def setInitDefault(self, editText):\n if editText in TimeFormat.timeStampStrings:\n self.initDefault = TimeFormat.timeStampStrings[0]\n else:\n TextFormat.setInitDefault(self, editText)",
"def __init__(self, text):\n self.text = text\n self.letters = [letters[c] for c in self.text]\n self.width = sum(let.width + 1 for let in self.letters)\n self._offset = width\n self.is_done = False",
"def __init__(self, text=None, settings=None, style='General', language='en'):\n\n self._text = None\n self._settings = None\n self._style = None\n self._language = None\n\n self.text = text\n self.settings = settings\n self.style = style\n self.language = language",
"def init(self) -> None:\n self.started = False\n self.lines = []\n self.text = ''\n self.graphics = ''\n self.ids = {}\n self.first_line_added = False\n\n self.used_fonts = set()\n self.current_line_used_fonts = set()\n self.current_height = 0\n self.lines = []\n\n line_width = self.width - (self.indent if self.is_first_line else 0)\n self.current_line = PDFTextLine(\n self.fonts, line_width, self.text_align, self.line_height\n )\n\n self.last_indent = 0\n self.last_state = self.last_factor = self.last_fill = None\n self.last_color = self.last_stroke_width = None\n\n self.y_ = 0",
"def _settext(self, textEntered):\n if textEntered.strip() == '':\n textEntered=self.data['initialtext']\n self.entry.enterText(textEntered)\n else:\n if callable(self.data['callback']): self.data['callback'](textEntered)\n if self.data['autoexit'] and callable(self.data['exit']):\n # NOTE not safe to call here user callback...\n taskMgr.doMethodLater(.5, self.data['exit'], '_ntryxt')",
"def __init__(self, edit: QtWidgets.QTextEdit, out=None, color=None):\n self.edit = edit\n self.out = out\n self.color = color",
"def on_load(self):\n self.__init__()",
"def __init__():",
"def __init__(self) -> None:\n str.__init__(self)",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self._ansi_escape_codes = True",
"def do_init(self):\n\n pass",
"def initialize(self):\n\t\tpass",
"def run_init(self):\n InitEditor(self.root, self)",
"def __init(self):\n print(\"Welkam tu mobail lejen\")",
"def __init__(self, text, tag, start ,end):\n\n self.text = six.text_type(text)\n self.tag = copy.copy(tag)\n self.end = end\n self.start = start"
] | [
"0.70964426",
"0.708642",
"0.6957156",
"0.6810953",
"0.6810953",
"0.6810953",
"0.6810953",
"0.6810953",
"0.6810953",
"0.6810953",
"0.6810953",
"0.6810953",
"0.6798828",
"0.6774329",
"0.6774329",
"0.67712367",
"0.6720732",
"0.6666233",
"0.65283895",
"0.6494219",
"0.64904994",
"0.64020336",
"0.6355993",
"0.6320434",
"0.6276883",
"0.6276883",
"0.62600636",
"0.62418175",
"0.62400895",
"0.6223964",
"0.6216688",
"0.62143534",
"0.6208083",
"0.6178298",
"0.61782044",
"0.61652267",
"0.6151157",
"0.6149334",
"0.61458564",
"0.6122538",
"0.61055773",
"0.61055773",
"0.6104455",
"0.6074942",
"0.6068098",
"0.60598797",
"0.60502535",
"0.6039496",
"0.6024996",
"0.60174793",
"0.6016273",
"0.59962815",
"0.59962815",
"0.59962815",
"0.59962815",
"0.5993154",
"0.59551775",
"0.595426",
"0.594104",
"0.5935818",
"0.5925663",
"0.5924169",
"0.5924169",
"0.5924169",
"0.5924169",
"0.5924169",
"0.5924169",
"0.5924169",
"0.5924169",
"0.5921958",
"0.5914238",
"0.5906936",
"0.5904956",
"0.5902255",
"0.58971685",
"0.58919376",
"0.5887856",
"0.58875364",
"0.5877437",
"0.58771914",
"0.586628",
"0.5863211",
"0.5861637",
"0.58615106",
"0.585278",
"0.58316183",
"0.5827398",
"0.5818838",
"0.58136094",
"0.5805725",
"0.57952",
"0.57908547",
"0.5782942",
"0.57769126",
"0.5768054",
"0.5765498",
"0.57595664",
"0.57557875",
"0.5754619"
] | 0.6495605 | 19 |
Return formatted text, properly escaped and with a link to the picture if not in titleMode | def formatOutput(self, storedText, titleMode, internal=False):
if titleMode:
return TextFormat.formatOutput(self, storedText, titleMode,
internal)
paths = storedText.split('\n')
results = ['<img src="%s">' % escape(url, treedoc.escDict) for url
in paths]
return u'<br />'.join(results) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image(self, src, title, text):\n src = escape_link(src)\n text = escape(text, quote=True)\n if title:\n title = escape(title, quote=True)\n html = '<img src=\"%s\" alt=\"%s\" title=\"%s\"' % (src, text, title)\n else:\n html = '<img src=\"%s\" alt=\"%s\"' % (src, text)\n if self.options.get('use_xhtml'):\n return '%s />' % html\n return '%s>' % html",
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n altText = ''\n if self.linkAltField:\n field = item.nodeFormat().findField(self.linkAltField)\n if field:\n altText = field.outputText(item, titleMode, internal)\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, altText, internal)\n return ''",
"def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode or not internal:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n # add prefix/suffix within the executable path:\n url = TextFormat.formatOutput(self, url, titleMode, internal)\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n results.append(u'<a href=\"%s\">%s</a>' %\n (escape(path, treedoc.escDict), altText or url))\n return u'<br />'.join(results)",
"def formatOutput(self, storedText, titleMode, altText='', internal=False):\n if titleMode:\n return TextFormat.formatOutput(self, storedText, titleMode,\n internal)\n paths = storedText.split('\\n')\n results = []\n for url in paths:\n path = url\n if not URLFormat.hasMethodRe.match(path):\n path = u'%s%s' % (self.URLMethod, path)\n path = u'<a href=\"%s\">%s</a>' % (escape(path, treedoc.escDict),\n altText or url)\n results.append(TextFormat.formatOutput(self, path, titleMode,\n internal))\n return u'<br />'.join(results)",
"def title(text, level=0):\n return '\\n' + text + '\\n' + '=-~_#%^' [level] * len(text) + '\\n\\n'",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def get_text(downgrade_titles=False):",
"def image(self, text):\n pattern = re.compile(r\"\"\"\n (?:[\\[{])? # pre\n \\! # opening !\n (\\<|\\=|\\>)? # optional alignment atts\n (%s) # optional style,class atts\n (?:\\. )? # optional dot-space\n ([^\\s(!]+) # presume this is the src\n \\s? # optional space\n (?:\\(([^\\)]+)\\))? # optional title\n \\! # closing\n (?::(\\S+))? # optional href\n (?:[\\]}]|(?=\\s|$)) # lookahead: space or end of string\n \"\"\" % self.c, re.U | re.X)\n return pattern.sub(self.fImage, text)",
"def image(self, link, title, alt):\n if not link.startswith(('http://', 'https://')):\n source_dir = os.path.dirname(self.source_path)\n link = os.path.abspath(os.path.join(source_dir, link))\n return '<img src=\"%s\" title=\"%s\" alt=\"%s\" />' % (link, title, alt)",
"def html_title(title):\n return '<center><h1>%s</h1></center>' % (title)",
"def image_preview(self):\r\n h = '<img src=\"%s\" alt=\"%s\"/>' % (self.image_resized_url, self.title)\r\n return mark_safe(h)",
"def get_title(text, uuid=None):\n if uuid is not None:\n text += get_provenance_link(uuid)\n title = pn.Row(pn.pane.HTML('<h2>{}</h2>'.format(text)), align='start')\n\n return title",
"def addTitle(text):\n\treturn OnscreenText(text=text, style=1, fg=(1,1,1,1), \\\n\t\tpos=(1.3,-0.95), align=TextNode.ARight, scale = .07)",
"def __str__(self):\n t = Template(\n \"\"\"\n <h4>$title</h4>\n $imgs\n $footnotes\n <hr/>\"\"\")\n # Return result.\n return t.substitute({\n \"title\": self.title,\n \"imgs\": self.render_images(),\n \"footnotes\": self.render_footnotes()\n })",
"def get_title():",
"def format_url(self, url, text):\r\n return u'<a href=\"%s\">%s</a>' % (escape(url), text)",
"def linkified_description(self):\n links = []\n def linkify(matchobj, links=links):\n if '|' in matchobj.group(1):\n url = matchobj.group(1).split('|')\n link = format_html('<a href=\"{0}\" target=\"_blank\">{1}</a>', url[0], url[1])\n else:\n link = format_html('<a href=\"{0}\" target=\"_blank\">{1}</a>', self.url, matchobj.group(1))\n links.append(link)\n return '{%d}' % (len(links) - 1)\n\n fmt = re.sub(r'\\[\\[([^\\]]+)\\]\\]', linkify, self.description)\n return format_html(fmt, *links)",
"def make_main_title(self, end, end_center=False):\n main_title = r\"\\begin{center}\"\n if self.detector is not None:\n main_title += \"%s \"%self.detector\n if self.selection is not None:\n main_title += \"%s Event Selection \"%self.selection\n main_title += end\n if end_center:\n main_title += r\"\\end{center}\"\n return main_title",
"def markdown_item(title, url):\n print('* [{0}]({1})'.format(\n markdown_escape(title),\n markdown_escape(url),\n ))",
"def show_title():\r\n complement = (\r\n '\\n __ ')\r\n title = ('\\n _______ _______________ ____ _______ __ ___ _ _______/ /_ ____ _____ ____ ____ ')\r\n title += ('\\n / ___/ / / / ___/ ___/ _ \\/ __ \\/ ___/ / / / / _ \\| |/_/ ___/ __ \\/ __ `/ __ \\/ __ `/ _ \\ ')\r\n title += ('\\n/ /__/ /_/ / / / / / __/ / / / /__/ /_/ / / __/> </ /__/ / / / /_/ / / / / /_/ / __/ ')\r\n title += ('\\n\\___/\\__,_/_/ /_/ \\___/_/ /_/\\___/\\__, / \\___/_/|_|\\___/_/ /_/\\__,_/_/ /_/\\__, /\\___/ ')\r\n title += ('\\n /____/ /____/ ')\r\n # Add Styles\r\n break_line = ('-' * len(complement) + \"\\n\") * 2\r\n print(\"{}\\n{}\\n{}\\n\".format(break_line, title, break_line))",
"def _get_title_tag(self, item):\n tag = '<{heading}><a href=\"{href}\">{title}</a></{heading}>'\n if self._field_is_visible(\"title\"):\n tile_conf = self.get_tile_configuration()\n title_conf = tile_conf.get(\"title\", None)\n if title_conf:\n heading = title_conf.get(\"htmltag\", \"h2\")\n href = item.absolute_url()\n title = item.Title()\n return tag.format(heading=heading, href=href, title=title)",
"def add_title(text):\n return OnscreenText(text=text, style=1, pos=(-0.1, 0.09), scale=.08,\n parent=base.a2dBottomRight, align=TextNode.ARight,\n fg=(1, 1, 1, 1), shadow=(0, 0, 0, 1))",
"def complete_alt_title(self, obj):\n return str(obj)",
"def outputText(self, item, titleMode, internal=False):\n if self.useFileInfo:\n item = globalref.docRef.fileInfoItem\n storedText = item.data.get(self.name, '')\n if storedText:\n return self.formatOutput(storedText, titleMode, internal)\n return ''",
"def prep_title(self):\n self.title_image = self.font.render(self.title, True, self.text_color,\n self.ctl_settings.panel_bg_color)\n self.title_image_rect = self.title_image.get_rect()\n self.title_image_rect.centerx = self.rect.centerx\n self.title_image_rect.bottom = self.rect.top - 1",
"def helptext(self):\n return \"\"\"\n <b>A</b> to start the aperture or set the value<br/>\n <b>S</b> to select an existing aperture<br/>\n <b>C</b> to clear the selection<br/>\n <b>F</b> to find a peak close to the cursor<br/>\n <b>[</b> to edit the left edge of selected or closest<br/>\n <b>]</b> to edit the right edge of selected or closest<br/>\n <b>L</b> to edit the location of selected or closest<br/>\n <b>D</b> to delete the selected or closest aperture\n \"\"\"",
"def editModeHeading(text):\n return u'<p style=\"editModeHeading\">%s</p>' % text",
"def title_draw():\n nonlocal width\n widthTitle = len(self.str_title)\n if widthTitle > width:\n self.str_title = self.str_title[0:width-5] + '...'\n widthTitle = len(self.str_title)\n h_len = widthTitle + self.l_padding + self.r_padding\n top = ''.join(['┌'] + ['─' * h_len] + ['┐']) + '\\n'\n result = top + \\\n '│' + \\\n ' ' * self.l_padding + \\\n self.str_title + \\\n ' ' * self.r_padding + \\\n '│' + self.str_shadow + '\\n'\n offset = 2 + self.l_padding + len(self.str_title) + self.r_padding\n return result, offset",
"def _get_title_text(self):\n return Text(\n self,\n self.settings.font_bold_filename,\n 96,\n self.settings.font_color,\n 'zuckbot',\n {'center': self.screen_rect.center},\n 0,\n -50,\n )",
"def convert_text_to_rouge_format(text, title=\"dummy title\"):\n sentences = text.split(\"\\n\")\n sent_elems = [\n \"<a name=\\\"{i}\\\">[{i}]</a> <a href=\\\"#{i}\\\" id={i}>\"\n \"{text}</a>\".format(i=i, text=sent)\n for i, sent in enumerate(sentences, start=1) if sent != '']\n html = \"\"\"<html>\n<head>\n<title>{title}</title>\n</head>\n<body bgcolor=\"white\">\n{elems}\n</body>\n</html>\"\"\".format(title=title, elems=\"\\n\".join(sent_elems))\n\n return html",
"def content(self, uid, text):\n\n if uid and isinstance(uid, str) and uid.lower().startswith(\"http\"):\n return f\"<a href='{uid}' rel='noopener noreferrer' target='blank'>{text}</a>\"\n\n return text",
"def format_title(self, data):\n return data",
"def get_alt(self, obj):\n return obj.Description() or obj.Title()",
"def info(level):\n if level == 'basic':\n string = _(\"Basic markup\")\n text = _(\"Only basic text tags are available in this input field.\")\n elif level == 'rich':\n string = _(\"Rich markup\")\n text = _(\"Rich and basic text tags are available in this input field.\") \n elif level == 'full':\n string = _(\"Full markup\")\n text = _(\"Every tags are available in this input field.\") \n elif level == 'none':\n string = _(\"No markup\")\n text = _(\"No tags are available in this input field.\") \n\n if level != 'none':\n text = text + \" \" + _(\"Check the markup reminder in related documentation for a description of these tags.\")\n\n return '<span class=\"help\" title=' + quoteattr(text) \\\n + '><img src=\"' + settings.STATIC_MEDIA_URL \\\n + 'images/savane/common/misc.default/edit.png' \\\n + ' border=\"0\" class=\"icon\" alt=\"\" />' \\\n + string + '</span>'",
"def link(self, link, title, text):\n link = escape_link(link)\n return [MdStyleInstructionLink(link)] + text",
"def avatar_preview(self):\r\n h = '<img src=\"%s\" alt=\"%s\"/>' % (self.image_avatar_url, self.title)\r\n return mark_safe(h)",
"def create_image_caption_pairs(self):",
"def escape_if_needed(text, options):\n if hasattr(text, '__html__'):\n # Text has escape itself:\n return to_string(text.__html__())\n if need_to_escape(options):\n return escape(to_string(text))\n return to_string(text)",
"def headline(self):\r\n return '%s%s %s%s' % (BLUE, self.title,\r\n NORMAL, self.link)",
"def get_HTML_box(self, url):\n who = self.getShortAuthor()\n if self.comments is None:\n title = \"\"\n else:\n title = html.escape(self.comments)\n return '<a href=\"%s\" title=\"%s\">%s</a>' % (url,\n title,\n html.escape(who))",
"def helptext(self):\n return \"\"",
"def test_link_title(self):\n comment = \"[link](http://foo.com \\\"bar\\\")\"\n comment_md = Markdown().render(comment)\n self.assertEqual(comment_md, '<p><a rel=\"nofollow\" href=\"http://foo.com\" title=\"bar\">link</a></p>')",
"def insertSymbol(name, image, title, string, text ='', num=0):\n onclick = \"insertSymbol('%s', '%s', %d);\" % (name, string, num)\n html = u'<a onclick=\"%s\" ' % onclick\n html += u'title=\"%s\">' % title\n html += text\n if image <> \"\":\n html += u'<img alt=\"%s\" src=\"%s\"/>' % ('symbol', image)\n html += u'</a>\\n' \n return html",
"def title(self, string):\n return self.bold(string)",
"def add_text(img, text, type):\n assert type in ['title', 'caption']\n txt = PIL.Image.new('RGBA', img.size, (255,255,255,0))\n d = PIL.ImageDraw.Draw(txt)\n\n if type == 'caption':\n size = 10\n else:\n size = 25\n\n try:\n fnt = PIL.ImageFont.truetype('FreeSans.ttf', size=size)\n except IOError:\n fnt = PIL.ImageFont.load_default()\n\n font_size = fnt.getsize(text)\n\n if type == 'caption':\n tupper = txt.height - font_size[1] - 20\n tleft = 10\n elif type == 'title':\n tupper = 10\n tleft = (img.width / 2) - (font_size[0] / 2)\n\n d.text((tleft, tupper), text, font=fnt, fill=(255, 255, 255, 255))\n img = PIL.Image.alpha_composite(img, txt)\n\n return(img)",
"def get_description(self):\n if self.desc_format == MARKDOWN_FORMAT:\n return markdown.markdown(self.desc, safe_mode='escape') \n elif self.desc_format == TEXT_FORMAT:\n return html.escape(self.desc)",
"def get_description(self):\n if self.desc_format == MARKDOWN_FORMAT:\n return markdown.markdown(self.desc, safe_mode='escape') \n elif self.desc_format == TEXT_FORMAT:\n return html.escape(self.desc)",
"def render_seal(img, text):\n return None",
"def print_with_title(title, content, before='', after='', hl='='):\n cont_maxlen = max(len(s) for s in content.split('\\n'))\n hl_len = max(cont_maxlen, len(title))\n print('{}{}\\n{}\\n{}{}'.format(before, title, hl * hl_len, content, after))",
"def __html__(self) -> str:\n components = [\n self.attributee_html,\n f'\"{self.linked_title}\"',\n self.date.string if self.date else '',\n ]\n return self.components_to_html(components)",
"def PROPER(text):\n return text.title()",
"def generate_title(self, title=None):\n if title is None:\n title = self.header.get('title', self.title)\n\n title = self.generate(title)\n title = title.replace('<p>', '').replace('</p>', '')\n # no trailing newlines\n title = re.sub(r'\\n+', ' ', title).rstrip()\n return title",
"def get_link_description(self):\n desc = super().get_link_description()\n desc['title'] = self.title\n return desc",
"def link(self):\n return f\"[{self.numbered_title}]({self.html_url})\"",
"def emph_text(text):\n\n if use_color():\n return colorama.Style.BRIGHT + text + colorama.Style.RESET_ALL\n else:\n return text",
"def _prettyfilename(self):\n return self.title",
"def rich(text):\n return full(text, False)",
"def html_title(self, title=None):\r\n if title is None:\r\n return \"<title>PyBossa</title>\"\r\n else:\r\n return \"<title>PyBossa · %s</title>\" % title",
"def gen_title_rst(txt):\n # Just add a few useful directives\n txt = \".. highlight:: cmake\\n\\n\" + txt\n return txt",
"def _make_tex_figure(self, filename, caption, position=\"hb\", clearpage=True):\r\n\r\n if clearpage:\r\n clrpage = \" \\\\clearpage\\n\"\r\n else:\r\n clrpage = \"\\n\"\r\n figurestring = r\"\"\"\r\n \\begin{figure}[%s] %% FIGURE\r\n \\centering\r\n \\includegraphics[scale=1.00]{%s}\r\n \\caption{%s}\r\n \\end{figure}%s\"\"\" % (\r\n position,\r\n filename,\r\n caption,\r\n clrpage,\r\n )\r\n return figurestring",
"def markdown_render_conditional(text, rich_text):\n if rich_text:\n return render_markdown(text)\n else:\n return escape(text)",
"def book_title(book_text):\n search = re.search(\"Title:(.*)\", book_text)\n title = search.group(1).replace(\"\\r\", \" \").strip()\n return title",
"def get_full_text(self, item):\n photoset_content = self.db.plugin_photoset_content(\n item_id=item.unique_id)\n output = self.response.render(\n 'plugin_photoset/full_text.txt',\n dict(photoset_content=photoset_content, item=item))\n return unicode(output.decode('utf-8'))",
"def printable(title, subtitle=None, resp=None):\n title = getfirst(title)\n subtitle = getfirst(subtitle)\n resp = getfirst(resp)\n if subtitle:\n title += \" : \" + subtitle\n if resp:\n title += \" / \" + resp\n return title",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def formatOutput(self, storedText, titleMode, internal=False):\n return TextFormat.formatOutput(self, storedText, titleMode, internal)",
"def image_preview(self):\r\n h = '<img src=\"%s\" alt=\"Campaign badge\"/>' % self.image.url\r\n return mark_safe(h)",
"def get_text(self) -> str:\n return (\n self.raw_data.get(\"text\") or\n self.raw_data.get(\"caption\") or\n \"\"\n )",
"def __str__(self) -> str:\n return textwrap.wrap(self.title, _POST_TITLE_MAX_LENGTH // 4)[0]",
"def process_image_url(value, field):\n if field.width:\n if not value:\n return u\"无\"\n return mark_safe(\"\"\"\n <a href=\"{0}\" target=\"_blank\"><img src=\"{0}\" width=\"{1}\" a>\n \"\"\".format(absolute_media_path(value), field.width))\n # only show url address.\n elif value:\n shorten_value = ''\n if len(value) > 20:\n shorten_value = value[0:12] + \"...\"\n return mark_safe(\"\"\"\n <a href=\"{0}\" target=\"_blank\" title=\"{0}\" >{1}</a>\n \"\"\".format(absolute_media_path(value), shorten_value if shorten_value else value))\n else:\n return \"\"",
"def render_text(self):\n if self.text_type == 1:\n return markdown.markdown(self.text)\n else:\n return self.text",
"def print_title(title):\n print \"\\n\"+\"#\"*32+\"\\n# \"+title+\"\\n\"+\"#\"*32+\"\\n\"",
"def get_url(self, filename, query_para=None, **url_args):\r\n from uliweb.core.html import Tag\r\n \r\n title = url_args.pop('title', filename)\r\n text = url_args.pop('text', title)\r\n query_para = query_para or {}\r\n return str(Tag('a', title, href=self.get_href(filename, **query_para), **url_args))",
"def video_feplay(title, hash):\n return '' + title + hash",
"def subtitle(string):\n print(\"{}\\n{}\\n\".format(bold(string), underline(string, \"-\")))",
"def title_content(label=\"A title\"):\n return {'label':label}",
"def title(string):\n print(\"{}\\n{}\\n\".format(bold(string), underline(string, \"=\")))",
"def slack_link(url, text=\"\"):\n if text:\n return \"<%s|%s>\" % (url, text)\n\n else:\n return \"<%s>\" % url",
"def getTitle(pan: str) -> str:\n src = open(pan).read()\n lines = src.split(\"\\n\")\n if len(lines)==0: return \"\"\n t = mark.render(lines[0].strip(\" #\"))\n if t.startswith(\"<p>\"): t = t[3:]\n if t.endswith(\"</p>\"): t = t[:-4]\n return t",
"def no_img(texto):\n return sub_no_img.sub(\"\", texto)",
"def pretty_title(title):\n output = '-' * 5 + ' ' + title + ' ' + '-' * 5\n return output",
"def item_link(self, obj):\n if obj.item is None:\n return '\\N{EM DASH}'\n\n return format_html(\n '<a href=\"{}\">{}</a>',\n reverse('admin:mediaplatform_mediaitem_change', args=(obj.item.pk,)),\n obj.item.title if obj.item.title != '' else '[Untitled]'\n )",
"def visit_title_reference(self, node):\n self.body.append('\\\\emph{\\\\textbf{')",
"def get_title_repr(self) -> str:\n try:\n return Title[self.title].value\n except (KeyError, ValueError):\n pass",
"def build_hover_text(labels):\n\ttext = str()\n\tfor k, v in labels.items():\n\t\tif v is not None:\n\t\t\ttext += '{k}: {v}<br>'.format(k=k, v=str(v))\n\n\treturn text.strip('<br>')",
"def format_tag(self, tag, text):\r\n return u'<a href=\"http://{domain}/hashtag/{tag}\" data-tag=\"{tag}\">#{text}</a>'.format(\r\n **dict(domain=self.domain, tag=urllib.quote(text.encode('utf-8')), text=text))\r\n\r\n #return u'<a href=\"http://%s/hashtag/%s\" data-tag=\"\">%s%s</a>' \\\r\n # % (self.domain, , tag, text)\r",
"def media_series_title(self):\n if lgtv[\"pairingKey\"] == 0:\n return \"Pin not set\"\n if self._currentSourceNumber == \"0\":\n return (\"{0} - CH{1:d} - {2}\").format(self._currentSourceName, self._currentChannelNumber, self._currentChannelName)\n else:\n return \"\"",
"def _create_hover_text(self, res, df, pinfo):\n\n xcolname, ycolname = pinfo[\"xcolname\"], pinfo[\"ycolname\"]\n _LOG.debug(\"Preparing hover text for '%s vs %s'\", xcolname, ycolname)\n\n # The loop below creates the following objects.\n # o colnames - names of the columns to include to the hover text.\n # o fmts - the hover text format.\n colnames = []\n fmts = []\n for colname in self._hov_colnames[res.reportid]:\n if colname not in df:\n continue\n if colname in (xcolname, ycolname):\n # The X and Y datapoint values will be added automatically.\n continue\n\n defs = res.defs.info[colname]\n fmt = f\"{colname}: {{\"\n if defs[\"type\"] == \"float\":\n fmt += \":.2f\"\n fmt += \"}\"\n unit = defs.get(\"short_unit\")\n if unit and unit not in colname:\n fmt += f\"{unit}\"\n\n colnames.append(colname)\n fmts.append(fmt)\n\n text = []\n fmt = \"<br>\".join(fmts)\n\n for row in df[colnames].itertuples(index=False):\n text.append(fmt.format(*row))\n\n return text",
"def get_text(self):\n txt = self.lang.tool.image_to_string(\n self.image,\n lang=self.lang,\n builder=pyocr.builders.TextBuilder()\n )\n return txt",
"def markdown(self):\n return db[self.basic_image_id]",
"def _display_metadata_text(self, filename, metadata, options):\n INDENT = \" \"*4\n\n show_all = \"all\" in options\n options = string_to_list(options)\n line0 = f\"{filename}\"\n if \"version\" in options or show_all:\n if metadata.version:\n line0 += f\" v{metadata.version}\"\n else:\n line0 += \" missing 'version'\"\n if \"pylith_version\" in options or show_all:\n if metadata.pylith_version:\n line0 += \"; requires PyLith \" + \" and \".join(metadata.pylith_version)\n else:\n line0 += \"; missing 'pylith_version'\"\n\n lines = []\n if \"description\" in options or show_all:\n if metadata.description:\n lines += [metadata.description]\n else:\n lines += [\"missing 'description'\"]\n if \"authors\" in options or show_all:\n if metadata.authors:\n lines += [\"Authors: \" + \", \".join(metadata.authors)]\n else:\n lines += [\"missing 'authors'\"]\n if \"keywords\" in options or show_all:\n if metadata.keywords:\n lines += [\"Keywords: \" + \", \".join(metadata.keywords)]\n else:\n lines += [\"missing 'keywords'\"]\n if \"features\" in options or show_all:\n if metadata.features:\n features = textwrap.fill(\", \".join(metadata.features), width=120)\n lines += [\"Features:\"] + textwrap.indent(features, INDENT).split(\"\\n\")\n else:\n lines += [\"missing 'features'\"]\n if \"arguments\" in options or show_all:\n if metadata.arguments:\n lines += [\"pylith \" + \" \".join(metadata.arguments)]\n else:\n lines += [\"missing 'arguments'\"]\n print(line0)\n if len(lines):\n print(textwrap.indent(\"\\n\".join(lines), INDENT))",
"def htmlText(text, attr='', escapeText=False):\n return '<div%s>%s</div>\\n' % (sep(attr),escape(text) if escapeText else text)",
"def text_for_posting(self) -> str:\n return self.text or self.publication.text",
"def test_link_title_without_no_follow(self):\n comment = \"[link](http://foo.com \\\"bar\\\")\"\n comment_md = Markdown(no_follow=False).render(comment)\n self.assertEqual(comment_md, '<p><a href=\"http://foo.com\" title=\"bar\">link</a></p>')",
"def build_heading(win, readonly=False):\n typetext = TYPETXT[win.parent().albumtype]\n actname = win.parent().albumdata['artist']\n album = win.parent().albumdata['titel']\n if not actname or not album:\n text = f'Opvoeren nieuw {typetext}'\n else:\n wintext = win.heading.text()\n newtext = ''\n for text in ('tracks', 'opnames'):\n if wintext == text:\n newtext = f': {wintext}'\n break\n if wintext.endswith(text):\n newtext = f': {text}'\n break\n text = 'G' if readonly else 'Wijzigen g'\n text = f'{text}egevens van {typetext} {actname} - {album}{newtext}'\n return text",
"def no_underline_and_no_description(): # noqa: D416",
"def format_article_list(title, source, link):\n i = 0\n length = 120\n space = \" \"\n article_headline = \"| \" + title + \" - \" + source\n\n if len(article_headline) < length:\n for i in range(length - len(article_headline)):\n article_headline += space\n article_headline += \"|\"\n\n if len(link) < length:\n for i in range(length - len(link)):\n link += space\n link += \"|\"\n\n return [article_headline, link]",
"def print_wrapper(string, item):\n imgtype = item['imgtype']\n objectname = item['object'].strip().lower()\n\n if imgtype=='cal' and objectname=='bias':\n # bias images, use dim (2)\n return '\\033[2m'+string.replace('\\033[0m', '')+'\\033[0m'\n\n elif imgtype=='sci':\n # sci images, use highlights (1)\n return '\\033[1m'+string.replace('\\033[0m', '')+'\\033[0m'\n\n elif imgtype=='cal':\n if objectname == 'thar':\n # arc lamp, use light yellow (93)\n return '\\033[93m'+string.replace('\\033[0m', '')+'\\033[0m'\n else:\n return string\n #elif (item['fiber_A'], item['fiber_B']) in [('ThAr', ''),\n # ('', 'ThAr'),\n # ('ThAr', 'ThAr')]:\n # # arc lamp, use light yellow (93)\n # return '\\033[93m'+string.replace('\\033[0m', '')+'\\033[0m'\n #else:\n # return string\n else:\n return string",
"def messageInHTML(aMessageTitle, aMessage):\n return \"\"\"<html>\n <head>\n <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n <title>WebFilter</title>\n </head>\n <body> <h2>%s</h2> <br>%s </body>\n </html>\n \"\"\" %(aMessageTitle, aMessage)",
"def __html__(self) -> str:\n components = [\n self.attributee_html,\n self.linked_title if self.title else 'untitled document',\n self.date.string if self.date else '',\n self.descriptive_phrase,\n f'archived in {self.collection}' if self.collection else '',\n ]\n return self.components_to_html(components)"
] | [
"0.625808",
"0.6189183",
"0.59681433",
"0.59475166",
"0.5911793",
"0.58762133",
"0.5813121",
"0.5810856",
"0.5802654",
"0.58000255",
"0.5753115",
"0.57340395",
"0.572571",
"0.5709024",
"0.5676528",
"0.567329",
"0.5668774",
"0.5666511",
"0.56526905",
"0.56396496",
"0.56106",
"0.55729854",
"0.5569004",
"0.5564576",
"0.55612147",
"0.55445063",
"0.5542113",
"0.5535897",
"0.5534921",
"0.55348563",
"0.5518011",
"0.5516213",
"0.55103534",
"0.548996",
"0.54851186",
"0.5477209",
"0.5471373",
"0.5466729",
"0.5435327",
"0.54259956",
"0.54245293",
"0.5412244",
"0.54061836",
"0.5401962",
"0.5400233",
"0.5398099",
"0.5398099",
"0.53890973",
"0.53761685",
"0.53716993",
"0.5356628",
"0.5333753",
"0.53290546",
"0.5328561",
"0.53163624",
"0.53162897",
"0.5309067",
"0.5308236",
"0.5301254",
"0.5295949",
"0.52857393",
"0.5284143",
"0.52841157",
"0.5276677",
"0.5274072",
"0.52734685",
"0.5269802",
"0.5262191",
"0.52613044",
"0.5239489",
"0.5238178",
"0.52378994",
"0.5217159",
"0.5216892",
"0.5208516",
"0.5200256",
"0.5188667",
"0.5181361",
"0.51759154",
"0.5175523",
"0.5171047",
"0.5170544",
"0.5167582",
"0.5163989",
"0.51636857",
"0.51631224",
"0.51521355",
"0.515086",
"0.5150767",
"0.5146073",
"0.51426774",
"0.51408416",
"0.512666",
"0.5120898",
"0.51192963",
"0.5114424",
"0.5112148",
"0.51085997",
"0.5102619",
"0.5098287"
] | 0.68930674 | 0 |
Return name enclosed with { } separators | def sepName(self, englishOnly=False):
name = englishOnly and self.enName or self.name
return u'{*%s%s*}' % (self.parentLevel * '*', name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_name():\n def _extract_name(quoted_name):\n return e.String(quoted_name.subexpression.name)\n yield (\"(λ &[name] . str)\", _extract_name)",
"def _extract_name(line: str) -> str:\n tokens = line[19:-2].split(\" {\")\n name = tokens[0]\n return name",
"def format_name_string(x: str) -> str:\n # get rid of [#] when present\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n if \"var.\" in x.lower():\n p = x.lower().find(\"var.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \" var \" in x.lower(): # need the spaces around var, because some names have the letters var in them\n p = x.lower().find(\" var \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \"subsp.\" in x.lower():\n p = x.lower().find(\"subsp.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" forme \" in x.lower():\n p = x.lower().find(\" forme \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" f. \" in x.lower():\n p = x.lower().find(\" f. \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+3] + \" <em class=\\\"species\\\">\" + x[p+3:] + \"</em>\"\n else:\n return \"<em class=\\\"species\\\">\" + x + \"</em>\"",
"def format_name(self) -> str:\n decl = self.declaration\n name, _, _ = decl.partition(\"(\")\n return name",
"def format_name(self) -> str:\n decl = self.declaration\n name, _ = decl.split(\"(\", 1)\n return name",
"def split_name(fullname):",
"def format_name(field_name):\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()",
"def get_name() -> str:",
"def clean_name(x: str) -> str:\n x = x.replace(\", var.\", \" var.\")\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n return x",
"def get_name():",
"def format_name(self) -> str:\n return self.name",
"def get_name():\n\n return character['Name']",
"def _process_name(name):\n\n # Unescape HTML entities\n name = unescape(name)\n\n # Remove bracketed stuff on the end\n name = NG_RE.sub('', name).strip() # Nomenclature groups\n name = END_RE.sub('', name).strip(', ') # Words\n name = RATIO_RE.sub('', name).strip(', ') # Ratios\n\n # Remove stuff off start\n name = START_RE.sub('', name).strip()\n\n # Remove balanced start and end brackets if none in between\n name = BRACKET_RE.sub('\\g<1>', name)\n\n # Un-invert CAS style names\n comps = name.split(', ')\n if len(comps) == 2:\n if comps[1].endswith('-'):\n name = comps[0]\n name = '%s%s' % (comps[1], name)\n elif len(comps) > 2:\n name = comps[0]\n for i in range(1, len(comps)):\n if comps[i].endswith('-'):\n name = '%s%s' % (comps[i], name)\n else:\n name = '%s %s' % (name, comps[i])\n return name",
"def get_name(header, splitchar=\"_\", items=2):\n if splitchar:\n return \"_\".join(header.split(splitchar)[:items]).lstrip(\">\")\n else:\n return header.lstrip(\">\")",
"def name_parser(string):\n return string.replace('\\n', ' ')",
"def full_name(self) -> str:\n # return self.separator.join(map(lambda x: x.name, self.path()))\n return self.separator.join(map(lambda x: x.tagged_name, self.path()))",
"def named_back_reference(name:str) -> str:\n # TODO error handling \n return f\"\\\\k<{name}>\"",
"def printname(bruce):",
"def CleanName(self,name):\n name2 = \"\"\n for c in name:\n if c == \"(\":\n break\n else: name2+=c\n\n return name2.strip(\"\\n\")",
"def fmt(competitor_name: str) -> str:\n name = competitor_name.replace(\"_a\", r\" $\\alpha$ \")\n name = name.replace(\"_b\", r\" $\\beta$ \")\n return name",
"def _get_name(self):\n return '%s: %s-%s' % (\n self.fcs_number,\n self.parameter_type,\n self.parameter_value_type)",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def Name(self) -> str:",
"def Name(self) -> str:",
"def Name(self) -> str:",
"def Name(self) -> str:",
"def name(self):\n\n return self._name.replace(\"[]\", \"\")",
"def _var_name_sub(self, sprintf, quote=False):\n q = ''\n if quote:\n q = \"'\"\n name_list = map(lambda x: q + self.cdict[x][0] + q, sprintf[\"vars\"] )\n return sprintf[\"text\"] % tuple(name_list)",
"def get_qname(uri, name):\n if not uri or not name or name[0] in ('{', '.', '/', '['):\n return name\n else:\n return '{%s}%s' % (uri, name)",
"def format_name(self):\n\t\tself.full_name = self.first + \" \" + self.last",
"def get_name() -> str:\n pass",
"def fullname(self, name):\n f, l = name.split(' ')\n self.first = f\n self.last = l",
"def print_name(name):\r\n\r\n\r\n return name + \"-apple\"",
"def fullNameFor( self, name ):\n if name in self.named: return name\n if name[-3:] == '...':\n best= [ n for n in self.named.keys()\n if n.startswith( name[:-3] ) ]\n if len(best) > 1:\n raise Error(\"Ambiguous abbreviation {!r}, matches {!r}\".format( name, list(sorted(best)) ) )\n elif len(best) == 1: \n return best[0]\n return name",
"def visit_name(self, node, children):\n name = ''.join(children)\n return name",
"def _get_name(name):\n if \"::\" in name:\n return name.split(\"::\")[1]\n return name",
"def _get_name(name):\n if \"::\" in name:\n return name.split(\"::\")[1]\n return name",
"def get_name(self):\n return '.'.join(self.name)",
"def _username_from_name(self, name):\r\n return name.replace(' ', '_')",
"def getName():",
"def getName():",
"def getName():",
"def getName():",
"def getName():",
"def getName():",
"def regular_edge_name(name: str) -> str:\n regular = \"\"\n for char in name:\n if char.isalpha() or char.isdigit():\n regular = f\"{regular}{char}\"\n else:\n regular = f\"{regular}_\"\n if not regular[0].isalpha():\n regular = f\"auto_legalized__{regular}\"\n return regular",
"def nice_name():\n\n pass",
"def name(self):\n if self.current != b'/':\n self.on_parser_error(\"Name token expected\")\n token = b''\n self.next()\n while self.is_regular:\n if self.current == b'#':\n self.next()\n code = b''\n for i in range(2):\n if not self.is_hex_digit:\n break\n code += self.next()\n if len(code) == 2:\n # must be exactly 2 characters\n token += chr(int(code.decode(DEFAULT_ENCODING), 16)).encode(DEFAULT_ENCODING)\n else:\n # leave as is\n token += b'#' + code\n else:\n token += self.next()\n if not self.empty_names_allowed and not token:\n self.on_parser_error(\"Empty /Name found\")\n\n return Name(token.decode(DEFAULT_ENCODING))",
"def get_name(internal: str):\n if '__' in internal:\n return ': '.join(get_name(s) for s in internal.split('__'))\n *path, name = internal.split('::')\n current = config.utils.names\n look_in = [current]\n try:\n for k in path:\n current = current[k]\n look_in.append(current)\n except KeyError:\n # noinspection PyUnboundLocalVariable\n logging.warning('invalid namespace {!r} of {!r}'.format(k, internal))\n look_in.reverse()\n for ns in look_in:\n try:\n val = ns[name]\n if isinstance(val, str):\n return val\n elif isinstance(val, dict):\n return val['*this*']\n else:\n raise TypeError('{!r} is neither dict nor str'.format(val))\n except KeyError:\n pass\n logging.warning('Name \"{}\" was not found in the namefile'.format('::'.join(path+[name])))\n return '::'.join(path+[name])",
"def print_name(nome, sobrenome):\r\n return nome + \" \" + sobrenome",
"def variable_string(self, name):\n return \"$(\" + name + \")\"",
"def asName(self, name):\r\n\t\tnewName = \"\"\r\n\t\ttoHigher = False\r\n\t\tfor char in name:\r\n\t\t\tif char in \"_-\":\r\n\t\t\t\ttoHigher = True\r\n\t\t\telse:\r\n\t\t\t\tif toHigher:\r\n\t\t\t\t\tnewName = newName + char.upper()\r\n\t\t\t\telse:\r\n\t\t\t\t\tnewName = newName + char\r\n\t\t\t\ttoHigher = False\r\n\t\treturn newName",
"def name() -> str:\n pass",
"def name(self):\n return \"%s %s\" % (self.first_name, self.last_name)",
"def name(self):\n return f\"{self._name.replace('_', ' ')}\".title()",
"def get_name(self):\r\n return ('%s %s' % ( self.first_name, self.last_name ))",
"def _name(self):\n return self.arguments[0].split('(')[0]",
"def name(self) -> str: # pragma: no cover",
"def fullname(self, name):\n\n first, last = name.split(' ')\n self.first = first\n self.last = last",
"def format_name(self) -> str:\n return self.declaration",
"def _make_name(self, name=None):\n\n if name:\n new_name = name.split(\"/\")[-1].split(\".png\")[0]\n if new_name.startswith((\"AWS-\", \"Amazon-\")):\n new_name = new_name.split(\"-\", 1)[1]\n # Replace non-alphanumeric with underscores (1:1 mapping)\n new_name = re.sub(r'\\W+', '_', new_name)\n return new_name",
"def _name(self):\n return self._arguments[0].split('(')[0]",
"def name(self):\n\t\tname = self.__class__.__name__.replace('Block', '')\n\t\tname = INITIAL_CAPS.sub(r'\\1 \\2', name)\n\t\treturn CAMEL_CASE.sub(r'\\1 \\2', name)",
"def TransformNames(self) -> _n_2_t_0[str]:",
"def generate_name(self, name):\n return \"{}/{}.{}\".format(self.name, self._layer_counter, name)",
"def get_python_name(cls, name):\n first_cap_re = re.compile(\"(.)([A-Z](?!s([A-Z])*)[a-z]+)\")\n all_cap_re = re.compile(\"([a-z0-9])([A-Z])\")\n\n s1 = first_cap_re.sub(r\"\\1_\\2\", Utils._clean_name(name))\n return all_cap_re.sub(r\"\\1_\\2\", s1).lower()",
"def get_singlet_name(orig_name):\n return \"singlet_{}\".format(orig_name)",
"def initialled_name(obj):\n initials = ''.join([name[0] for name in obj.first_names.split(' ')])\n return \"{}, {}\".format(obj.last_names, initials)",
"def name_formatting(name: str) -> str:\n \n first_name = name.rstrip()[name.find(',') + 2 : ]\n last_name = name[ : name.find(',')]\n return first_name + ' ' + last_name",
"def Escape(name):\n return re.sub(r'[^\\w#-]', '_', name)",
"def char_name(character_object, verbose_where=False, watch_list=None):\n watch_list = watch_list or []\n cname = character_object.name\n if character_object in watch_list:\n cname += \"{c*{n\"\n if character_object.player_ob and character_object.player_ob.db.lookingforrp:\n cname += \"|R+|n\"\n if not verbose_where:\n return cname\n if character_object.db.room_title:\n cname += \"{w(%s){n\" % character_object.db.room_title\n return cname",
"def standard_name_remapper(orig_name):\n # Remove any trailing parentheses.\n # TODO(tjann): to check if this is safe.\n paren_start = orig_name.find(\"(\")\n if paren_start != -1:\n orig_name = orig_name[:paren_start]\n\n # Removes separating words.\n orig_name = orig_name.replace(\",\", \" \")\n orig_name = orig_name.replace(\"-\", \" \")\n orig_name = orig_name.replace(\"and \", \"\")\n return \"\".join([word.capitalize() for word in orig_name.split()])",
"def test_names(self):\n obj = dotnet.DotNetNamespace({\"id\": \"Foo.Bar\"}, jinja_env=None, app=None)\n self.assertEqual(obj.name, \"Foo.Bar\")\n self.assertEqual(obj.short_name, \"Bar\")\n\n obj = dotnet.DotNetNamespace(\n {\"id\": \"Foo.Bar.Something`1\"}, jinja_env=None, app=None\n )\n self.assertEqual(obj.name, \"Foo.Bar.Something`1\")\n self.assertEqual(obj.short_name, \"Something`1\")",
"def safe_name(self, name):\n\n output = \"\"\n for char in name:\n if char not in '\\\\/<>:\"|?*':\n output += char\n\n return output",
"def get_name(self):\n return \"%s %s\" % (\n self.first_name,\n self.last_name\n )",
"def name_format(name):\n lst_name, fst_name = name.split(',')\n return ' '.join((fst_name, lst_name))",
"def safe_formal_name(name):\n return re.sub(r\"\\s+\", \" \", re.sub(r'[!/\\\\:<>\"\\?\\*\\|]', \"\", name)).strip()",
"def getName(self):\n return \"\"",
"def get_name_from_item(item, separators=None):\n separators = separators or [',', ';', ':']\n indexes = []\n for sep in separators:\n index = item.find(sep)\n indexes.append(index if index != -1 else len(item))\n \n name = item[:min(indexes)]\n return name",
"def name(self):\n return self.raw.get(\"name\")",
"def name(self):\n # easy enough\n return \"{0.first} {0.last}\".format(self)",
"def name(self) -> str:\n\t\treturn self._raw_result['name']",
"def success_new_brass(name):\n return 'Nom de brasserie %s' % name + ' a bien ete ajoute'",
"def get_ig_name ( base_name ) :\n return base_name + '-GW'",
"def get_name(self):\n if self.name != None: return self.name\n else: return self.get_name_from_items(self.items.values())",
"def get_name(self) -> str:\n pass",
"def render_name(name_att_list):\n res = ['']\n for k, v in name_att_list:\n v = dn_escape(v)\n res.append(\"%s=%s\" % (k, v))\n res.append('')\n return '/'.join(res)",
"def ending_cutter(name: str):\n if name.endswith('ID') and re.match(r'^(?=\\w+[A-Z])(?=\\w+[a-z])\\w+$', name):\n return name[:-2]\n return name",
"def _expanded_id(name: str, sep: str = '_') -> str:\n return sep.join([el.lower()\n for el in re.split(r'([A-Z]+[^A-Z]*)', name)\n if el])",
"def get_name(self):\n name = ''\n # name contains all adjacent alphanumeric symbol\n while self.current_character.isalnum():\n name += self.current_character\n self.current_character = self.file.read(1)\n self.file.seek(self.file.tell() - 1, 0)\n character = self.file.read(1)\n if character.isalnum():\n pass\n else:\n self.file.seek(self.file.tell() - 1, 0)\n return name",
"def latex_name(name):\r\n name = name + '_' #protects against .split('_') failing\r\n if name.startswith('['): #format leading [] as concentration\r\n head, tail = name[1:].rsplit(']', 1)\r\n head = r'[\\ce{%s}]' % head\r\n else:\r\n if '[' in name: # turn internal [] into marked-up subscripts\r\n before, inside, after = re.match(r'([^[]+)\\[(.*)\\]([^]]*)', name).groups() # separates bracketed material\r\n name = r'%s_\\ce{%s}_%s' % (before, inside, after)\r\n head, tail = name.split('_', 1)\r\n if len(head) > 1: # special cases like v12 (=> v_12) and roman multiple letter symbol\r\n if re.match(r'^.[0-9]+$', head): # single character following by integer, i.e. v0\r\n head, tail = name[0], name[1:]\r\n else:\r\n head = r'\\mathrm{%s}' % head\r\n subscripts = re.findall(r'(\\\\ce{.*}|[^_]+)_', tail) # tail.split('_') but ignoring underscore within chem mark-up\r\n if subscripts:\r\n return head + r'_{\\mathrm{' + ','.join(subscripts) + '}}'\r\n return head",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*#%s*}' % (name)",
"def _get_pretty_name(name):\n pretty = ''\n if name.countryName:\n pretty += '/C=' + name.countryName\n if name.stateOrProvinceName:\n pretty += '/ST=' + name.stateOrProvinceName\n if name.localityName:\n pretty += '/L=' + name.localityName\n if name.organizationName:\n pretty += '/O=' + name.organizationName\n if name.organizationalUnitName:\n pretty += '/OU=' + name.organizationalUnitName\n if name.commonName:\n pretty += '/CN=' + name.commonName\n if name.emailAddress:\n pretty += '/email=' + name.emailAddress\n return pretty",
"def _to_jsonc_name(member_name):\n\n characters = []\n uppercase_next = False\n for character in member_name:\n if character == '_':\n uppercase_next = True\n elif uppercase_next:\n characters.append(character.upper())\n uppercase_next = False\n else:\n characters.append(character)\n return ''.join(characters)",
"def get_full_name(self):\n full_name = '{0} {1} {2}'.format(self.last_name, self.first_name, self.patronymic)\n return full_name.strip()",
"def make_python_name(self, name):\n # FIXME see cindex.SpellingCache\n for k, v in [('<', '_'), ('>', '_'), ('::', '__'), (',', ''), (' ', ''),\n (\"$\", \"DOLLAR\"), (\".\", \"DOT\"), (\"@\", \"_\"), (\":\", \"_\"),\n ('-', '_')]:\n if k in name: # template\n name = name.replace(k, v)\n # FIXME: test case ? I want this func to be neutral on C valid\n # names.\n if name.startswith(\"__\"):\n return \"_X\" + name\n if len(name) == 0:\n pass\n elif name[0] in \"01234567879\":\n return \"_\" + name\n return name",
"def full_name(name: str, *, prefix: str = DEFAULT_METRIC_NAME_PREFIX) -> str:\n return f\"{prefix}{DEFAULT_METRIC_NAME_DELIMITER}{name}\""
] | [
"0.70919734",
"0.69829744",
"0.68450254",
"0.67303866",
"0.6666624",
"0.66044873",
"0.65953267",
"0.65891093",
"0.65593725",
"0.623893",
"0.6218805",
"0.61895317",
"0.61869186",
"0.6163495",
"0.6100971",
"0.6099947",
"0.6092239",
"0.607046",
"0.60489154",
"0.6042493",
"0.60297483",
"0.60196704",
"0.60196704",
"0.60196704",
"0.60196704",
"0.60196704",
"0.59820706",
"0.59820706",
"0.59820706",
"0.59820706",
"0.59723836",
"0.59584624",
"0.5956047",
"0.59497714",
"0.59392816",
"0.5907609",
"0.5902328",
"0.59006584",
"0.58909464",
"0.58905774",
"0.58905774",
"0.5884643",
"0.58812624",
"0.5867738",
"0.5867738",
"0.5867738",
"0.5867738",
"0.5867738",
"0.5867738",
"0.5864715",
"0.58419174",
"0.5839502",
"0.58261853",
"0.58222836",
"0.58205885",
"0.5819315",
"0.58178324",
"0.5814598",
"0.5814492",
"0.5814424",
"0.5808165",
"0.58064514",
"0.57872814",
"0.5781584",
"0.57787645",
"0.5773482",
"0.5773379",
"0.5740995",
"0.5739245",
"0.5738703",
"0.572095",
"0.57185394",
"0.57167095",
"0.57137495",
"0.57006043",
"0.56991506",
"0.5696045",
"0.5695825",
"0.56944555",
"0.5692191",
"0.5691018",
"0.568776",
"0.5687329",
"0.56866896",
"0.5682151",
"0.5680882",
"0.56742495",
"0.5673338",
"0.5663452",
"0.5658749",
"0.5653632",
"0.5653553",
"0.5652143",
"0.56519014",
"0.5640885",
"0.56357235",
"0.5633493",
"0.56246877",
"0.56161076",
"0.5609878",
"0.5606493"
] | 0.0 | -1 |
Return formatted text for this field | def outputText(self, item, titleMode, internal=False):
for num in range(self.parentLevel):
item = item.parent
if not item:
return ''
field = item.nodeFormat().findField(self.name)
if not field:
return ''
return field.outputText(item, titleMode, internal) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def formatted(self) -> str:\r\n ...",
"def format(self) -> str:",
"def text(self) -> str:",
"def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d",
"def get_text(self):\n inp = \" \"\n if self.link_id:\n inp += \"LINK \" + self.link_id\n inp += self.status + ' '\n if self.node_id:\n inp += \"NODE \" + self.node_id + ' '\n if self.value:\n inp += self.control_type.name + ' ' + str(self.value) + ' '\n if self.time:\n inp += self.time + ' '\n if self.clock_time:\n inp += self.clock_time + ' '\n # TODO: research correct formatting of time, clock_time options\n return inp",
"def format(self) -> str:\n return self._format",
"def format(self) -> str:\n return self._format",
"def getText(self):\r\n return \"\"",
"def value_as_text(self):\n property_name = \"_%s_as_text\" % self.attribute.type\n return getattr(self, property_name, self.value)",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def getFormattedText(self):\r\n h = \"00\"\r\n m = \"00\"\r\n s = \"00\"\r\n if(self.seconds < 10):\r\n s = \"0\" + str(self.seconds)\r\n else:\r\n s = str(self.seconds)\r\n\r\n if(self.minutes < 10):\r\n m = \"0\" + str(self.minutes)\r\n else:\r\n m = str(self.minutes)\r\n\r\n if(self.hours < 10):\r\n h = \"0\" + str(self.hours)\r\n else:\r\n h = str(self.hours)\r\n\r\n return h + \":\" + m + \":\" + s",
"def get_text(self):\n return self.rule_id + '\\t' + self.rule_text",
"def get_text(self):\n return self.get_property('text')",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def _get_FIELD_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n template = ''\n template += '{:d}' if field.decimals == 0 else '{:.%sf}' % field.decimals\n template += ' ' if field.spaced_display else ''\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def TEXT(number, format_type):\n raise NotImplementedError()",
"def format(self) -> str:\n return pulumi.get(self, \"format\")",
"def text(self) -> str:\n return self.__text",
"def show(self) -> str:\n return f'[{self.font}]{self.text}[{self.font}]' if self.font else self.text",
"def formatName(self):\r\n return self.title.getVal() + \" \" + self.first.getVal() + \" \" + self.last.getVal()",
"def getText(self):\n return(' '.join(map(lambda x:x.text,self.getNested())))",
"def get_text(self) -> str:\n return self.text",
"def text(self):\n return self.__text",
"def getText(self):",
"def get_text(self):\n return self.text",
"def text(self):\n return ''",
"def get_text(self) -> str:\n return self._text",
"def get_formatted_text(self, n_cols):",
"def text(self) -> str:\n return self._impl.get_text()",
"def format_item_display(self, obj):\n return u\"%s - %s\" % (escape(obj.nombre),obj.rfc)",
"def text(self) -> LocalizedString:\n return self._text",
"def as_text(self) -> str:\n txt = ''\n with self._th_lock:\n # purge expired value (reach ttl_s) from values dict\n purge_l = []\n for key, (_value, _timestamp_ms, expire_at) in self._values_d.items():\n if expire_at and time.monotonic() > expire_at:\n purge_l.append(key)\n for rm_key in purge_l:\n self._values_d.pop(rm_key)\n # if any value exists, format an exposition message\n if self._values_d:\n # add a comment line if defined\n if self.comment:\n # apply escapes to comment\n esc_comment = str(self.comment)\n for rep_args in [('\\\\', '\\\\\\\\'), ('\\n', '\\\\n')]:\n esc_comment = esc_comment.replace(*rep_args)\n txt += f'# HELP {self.name} {esc_comment}\\n'\n # add a type line if defined\n if self.type is not MetricType.UNTYPED:\n txt += f'# TYPE {self.name} {self.type.value}\\n'\n # add every \"name{labels} value [timestamp]\" for the metric\n for lbl_id_str, (value, ts, _expire_at) in self._values_d.items():\n if self._type is MetricType.HISTOGRAM:\n txt += self._data2txt_histogram(lbl_id_str, value)\n elif self._type is MetricType.SUMMARY:\n txt += self._data2txt_summary(lbl_id_str, value)\n else:\n txt += self._data2txt_default(lbl_id_str, value, ts)\n return txt",
"def __str__(self):\n txt = \"%s:\\n\" % self.name\n txt += \" Charge: %.4f\\n\" % self.charge\n txt += \" Radius: %.4f\" % self.radius\n return txt",
"def text(self):\n if self.is_root:\n return ''\n elif self.is_comment:\n return self.__value\n elif self.is_flag:\n if self.__value:\n return '[{0}]'.format(self.name)\n else:\n return '!{0}!'.format(self.name)\n else:\n return '[{0}:{1}]'.format(self.name, self.value)",
"def __repr__(self) -> str:\n return f\"{self.text}\"",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def text(self) -> str:\n return self._text",
"def format(self):\n return self._format",
"def get_formatter(self, **kwargs):\n config = dict([\n (attr, getattr(self, attr))\n for attr in [\n \"include_sign\",\n \"group_with_commas\",\n \"num_decimal_places\",\n ]\n ])\n config.update(kwargs)\n return \"\".join([\n \"{\",\n config.get(\"field_name\", \"\"),\n \":\",\n \"+\" if config[\"include_sign\"] else \"\",\n \",\" if config[\"group_with_commas\"] else \"\",\n \".\", str(config[\"num_decimal_places\"]), \"f\",\n \"}\",\n ])",
"def text(self):\n\n if self.status.full_text:\n return self.status.full_text\n elif self.status.text:\n return self.text\n else:\n return MISSING",
"def to_str(self):\n return self.template.format(\n text_color=self.color.to_str(),\n font_type=self.font_type.to_str(),\n font_weight=self.font_weight.to_str(),\n font_size=self.font_size.to_str()\n )",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def text(self):\n return self.name, self.fontfile, self.fontsize",
"def plain_text(self) -> str:\n return pulumi.get(self, \"plain_text\")",
"def _get_FIELD_humanized_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n power = max([i for i in utils.POWERS if value // i > 0 and i > 1])\n value /= power\n template = ''\n template += '{:.%sf}' % field.humanized_decimals\n template += ' ' if field.spaced_display else ''\n template += utils.POWERS[power]\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def format( self ) :\n\n return( self.__format )",
"def __repr__(self) -> str:\r\n\r\n saida = \"Format: \"\r\n x = self.getformat()\r\n for _ in range(len(x)):\r\n saida = f\"{saida}{x[_]}\"\r\n if _ < len(x)-1:\r\n saida += \", \"\r\n saida += \"\\n\"\r\n return saida",
"def text(self):\n return self.label.text()",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title} :\" + s\n\n return s",
"def format_value(text):\n return text.encode('utf8').replace('\\n', ' ').replace('\\r', ' ')",
"def get_text(self):\n logging.getLogger(__name__).info(\"Element text: {}\\nby = {}\\nvalue = {}\".format(\n self.driver.find_element(self.by, self.value).text, self.by, self.value))\n return self.driver.find_element(self.by, self.value).text",
"def get_instance_text(instance):\n values = []\n for fieldname in registry[instance.__class__]:\n values.extend(resolve_field_value(\n [instance], fieldname.split('__')))\n return u' '.join(values)",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n return text",
"def text(self, v=''):\n return str(v)",
"def _to_text(self, value):\n raise NotImplementedError",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def __str__(self):\n return self.fmt.format(*self.args, **self.kwargs)",
"def field_display(obj, field):\n return get_field_value(obj, field)",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n if hasattr(self,'label'):\n return str(self.label.text())\n else:\n return self.key",
"def __str__(self):\n return self.format()",
"def text(self):\n parts = [(\"%s\" if isinstance(p, Insert) else p) for p in self.parts]\n parts = [(\"%%\" if p == \"%\" else p) for p in parts] # escape percent\n return \"\".join(parts)",
"def Text(self):\n return self._text",
"def __str__(self):\n struct_repr = \", \".join([\n \"type: \" + str(self.type),\n \"text: \" + str(self.text)\n ])\n\n return f\"StatusText: [{struct_repr}]\"",
"def GetText(self):\r\n \r\n return self._text",
"def getText(self):\n return self.text",
"def getText(self):\n return self.text",
"def to_text(self, floatformat: str = \".6f\") -> str:\n return self.val.to_text(floatformat)",
"def __str__(self):\n #Format data from default fields\n template = \"{number:4}|{rep:4}|{time:5}{priority:+2}|\" \\\n \"{record_type:8}|{name:17}\"\n default_fields = template.format(**self)\n \n #Format data from custom fields\n custom_field_list = []\n for label in self.custom_labels:\n custom_field_list.append(\"|{:17}:{!s:<5}\".format(label,\n self[label]))\n custom_fields = \"\".join(custom_field_list)\n \n return default_fields + custom_fields",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def __str__(self):\n\t\treturn self.text",
"def outputText(self, item, titleMode, internal=False):\n field = None\n while not field:\n item = item.parent\n if item:\n field = item.nodeFormat().findField(self.name)\n else:\n return ''\n return field.outputText(item, titleMode, internal)",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def text(self):\n # type: () -> str\n return self._text",
"def get_text(self):",
"def text(self):\n return self.full_text",
"def __str__(self):\n return \"%s\\n\" % self.text + \" \" * self.col + \"^\"",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% on line \" + self.line\n return text",
"def _entity_as_text(self):\n return str(self.value)",
"def format(self, record):\n message = record.getMessage()\n asctime = self.formatTime(record, self.datefmt)\n name = yellow(record.name)\n\n s = \"%(timestamp)s %(levelname)s %(name)s \" % {\n \"timestamp\": green(\"%s,%03d\" % (asctime, record.msecs), bold=True),\n \"levelname\": self.LEVELS[record.levelname],\n \"name\": name,\n }\n\n if \"\\n\" in message:\n indent_length = len(re_color_codes.sub(\"\", s))\n message = message.replace(\"\\n\", \"\\n\" + \" \" * indent_length)\n\n s += message\n return s",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n text += \" [\" + self.file_name + \"]\"\n return text",
"def text(self):\n\t\treturn ' '.join([self.write_components[x] for x in self.write_components])"
] | [
"0.75734353",
"0.7379207",
"0.7205578",
"0.68481845",
"0.67844886",
"0.67808527",
"0.67703915",
"0.67703915",
"0.67655444",
"0.6745665",
"0.6687435",
"0.66469747",
"0.6644202",
"0.66413474",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65741307",
"0.6567402",
"0.6558896",
"0.6555393",
"0.655068",
"0.6547239",
"0.6544499",
"0.6535529",
"0.6517592",
"0.6480058",
"0.6460372",
"0.6459885",
"0.64553267",
"0.6446324",
"0.6445358",
"0.64076585",
"0.6392125",
"0.6380471",
"0.6367286",
"0.6361198",
"0.6353135",
"0.6348966",
"0.63427186",
"0.6320017",
"0.6318294",
"0.63155836",
"0.6308729",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.62890583",
"0.62872475",
"0.6284665",
"0.6283615",
"0.62564605",
"0.62539566",
"0.6250457",
"0.6246106",
"0.6245501",
"0.6238378",
"0.62316114",
"0.62306285",
"0.6227439",
"0.6216431",
"0.6214085",
"0.6207841",
"0.6207841",
"0.62025124",
"0.618629",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6184535",
"0.6183745",
"0.6183568",
"0.61735356",
"0.61702335",
"0.61699766",
"0.6169714",
"0.6169714",
"0.6168279",
"0.616314",
"0.6158217",
"0.6158217",
"0.6158217",
"0.6156037",
"0.613794",
"0.6137155",
"0.61364275",
"0.6114419",
"0.61141664",
"0.6103432",
"0.61010504",
"0.6098953",
"0.609143",
"0.60909635",
"0.60876095"
] | 0.0 | -1 |
Return what we need to write into an XSL file for this type | def xslText(self):
return u'<xsl:value-of select="%s%s"/>' % (self.parentLevel * '../',
self.name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def xslText(self):\n return TextFormat.xslText(self)",
"def convert(self):\n self._convert()\n self._write_docx()",
"def toxml(self) :\n\t\treturn self.doc.toxml()",
"def _ooxml(self):\n # LOG: processing_type property\n self.set_property('processing_type', 'ooxml')\n try:\n doc = officedissector.doc.Document(self.src_path)\n except Exception:\n self.make_dangerous('invalid ooxml file')\n return\n # There are probably other potentially malicious features:\n # fonts, custom props, custom XML\n if doc.is_macro_enabled or len(doc.features.macros) > 0:\n self.make_dangerous('macro')\n if len(doc.features.embedded_controls) > 0:\n self.make_dangerous('activex')\n if len(doc.features.embedded_objects) > 0:\n # Exploited by CVE-2014-4114 (OLE)\n self.make_dangerous('embedded obj')\n if len(doc.features.embedded_packages) > 0:\n self.make_dangerous('embedded pack')",
"def xslText(self):\n return u'<xsl:value-of select=\"child::*/%s\"/>' % self.name",
"def _write_docx(self):\n with ZipFile(self.out_file, 'w') as f:\n self._write_content_types(f)\n self._write_app(f)\n self._write_core(f)\n self._write_rels(f)\n self._write_document(f)\n self._write_fonts(f)\n self._write_document_rels(f)\n self._write_settings(f)\n self._write_styles(f)",
"def create_output_file(self):\r\n self.output_file = openpyxl.Workbook()",
"def _create_oai_xsl_template():\n oai_xsl_template = OaiXslTemplate()\n oai_xsl_template = _set_oai_xsl_template_fields(oai_xsl_template)\n\n return oai_xsl_template",
"def createXML(whatToCreate):\n\n XMLSerializer = serializers.get_serializer(\"xml\")\n xml_serializer = XMLSerializer()\n if whatToCreate == \"allAccount\":\n path_fullToOutputFile = os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\")\n objectsToSerialize = Account.objects.all()\n else:\n raise ProgrammingError(\n _(\"During XML Export it was not correctly specified which data that has to be exported\"))\n out = open(os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\"), \"w\")\n if objectsToSerialize == '':\n raise NoObjectsToBeSerialzed(_(\"During XML Export it was not correctly specied data has to be exported\"))\n else:\n xml_serializer.serialize(objectsToSerialize, stream=out, indent=3)\n out.close()\n return path_fullToOutputFile\n\n # TODO def importAllAccountsXML(self):",
"def export_to_xml(self, resource_fs):\r\n raise NotImplementedError('Modules must implement export_to_xml to enable xml export')",
"def writeXml(self):\n text = u' type=\"%s\"' % self.typeName\n if self.format:\n text += u' format=\"%s\"' % escape(self.format, treedoc.escDict)\n if self.prefix:\n text += u' prefix=\"%s\"' % escape(self.prefix, treedoc.escDict)\n if self.suffix:\n text += u' suffix=\"%s\"' % escape(self.suffix, treedoc.escDict)\n if self.html:\n text += u' html=\"y\"'\n if self.isRequired:\n text += u' required=\"y\"'\n if self.hidden:\n text += u' hidden=\"y\"'\n if self.numLines > 1:\n text += u' lines=\"%d\"' % self.numLines\n if self.initDefault:\n text += u' init=\"%s\"' % escape(self.initDefault, treedoc.escDict)\n if self.linkAltField:\n text += u' linkalt=\"%s\"' % escape(self.linkAltField,\n treedoc.escDict)\n return text",
"def xslText(self):\n return u'<xsl:value-of select=\"ancestor::*/%s\"/>' % self.name",
"def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def getXml(self):\n return _SALOMERuntime.InputXmlPort_getXml(self)",
"def generateXML(self):\n return self.formatEval(\n self.TEMPLATES[self.attrs['name']]['XML'],\n self.attrs\n )",
"def storeAndReturnXML(self):\n self._storeItems()\n return self.toXML()",
"def get_xml(self):\n return etree.tostring(self.get_etree())",
"def definition_to_xml(self, resource_fs):\r\n raise NotImplementedError(\r\n \"%s does not implement definition_to_xml\" % self.__class__.__name__)",
"def create_gen_xml(self, out_file):\n\n param_list = []\n msg = []\n msg_type = []\n dep_node = []\n for line in self.full_ed_lines:\n param_list.append(line.text())\n dep_pkg = param_list[6].split(', ')\n if dep_pkg[len(dep_pkg) - 1] == '':\n dep_pkg.pop()\n for dep in self.manager.wid.sub_list:\n dep_node.append(dep['msg_type'])\n for dep in self.manager.wid.pub_list:\n dep_node.append(dep['msg_type'])\n for dep in dep_node:\n a, b = dep.split('/')\n msg.append(a)\n msg_type.append(b)\n f = open('../genkernel/templates/package_rosgen.xml')\n o = open(out_file, 'a')\n flag = 0\n while 1:\n line = f.readline()\n if not line: break\n for i in range(6):\n line = line.replace('[{0}]'.format(i), param_list[i])\n line = line.replace('[7]', param_list[7])\n if line.find('[6]') != -1:\n for dep in dep_pkg:\n line_dep = '\\t<depend>{0}</depend>\\n'.format(dep)\n o.write(line_dep)\n flag = 1\n elif line.find('[8]') != -1:\n for dep, tp in zip(msg, msg_type):\n line_dep = '\\t\\t<depend type=\"{1}\">{0}</depend>\\n'.format(dep, tp)\n o.write(line_dep)\n flag = 1\n elif line.find('<subscribers>') != -1:\n o.write('\\t\\t<subscribers>\\n')\n for sub in self.manager.wid.sub_list:\n o.write('\\t\\t\\t<sub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(sub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(sub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(sub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(sub['queue_size']))\n o.write('\\t\\t\\t</sub>\\n')\n o.write('\\t\\t</subscribers>\\n')\n flag = 1\n elif line.find('<publishers>') != -1:\n o.write('\\t\\t<publishers>\\n')\n for pub in self.manager.wid.pub_list:\n o.write('\\t\\t\\t<pub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(pub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(pub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(pub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(pub['queue_size']))\n o.write('\\t\\t\\t</pub>\\n')\n o.write('\\t\\t</publishers>\\n')\n flag = 1\n if flag == 0:\n o.write(line)\n else:\n flag = 0\n o.close()\n f.close()\n self.changed = False",
"def to_xml_file(self, xml_file_path):\n s = self.to_xml()\n with open(xml_file_path, \"w+b\") as f:\n f.write(s)",
"def saveToXml(self) -> org.jdom.Element:\n ...",
"def getXML(self):\n\n def _getElementForMappingEntry(entry, mappingStyle):\n xmlDocTmp = Document()\n element = xmlDocTmp.createElement(mappingStyle)\n for k, v in viewitems(entry):\n # ignore empty, None or compiled regexp items into output\n if not v or (k == \"path-match-expr\"):\n continue\n element.setAttribute(k, str(v))\n return element\n\n xmlDoc = Document()\n root = xmlDoc.createElement(\"storage-mapping\") # root element name\n for mappingStyle, mappings in viewitems(self):\n for mapping in mappings:\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\n root.appendChild(mapElem)\n return root.toprettyxml()",
"def write(self):\n temp_string = minidom.parseString(ET.tostring(self.root)).toprettyxml(encoding=\"UTF-8\")\n with open(self.xml_file, 'w') as f:\n f.write(temp_string)\n # f = open(self.xml_file, \"w\")\n # f.write(temp_string)\n # f.close()",
"def write(self):\n filters = {\n 'MSGUID': lambda x: ('{%s}' % x).upper(),\n 'relslnfile': lambda x: os.path.relpath(x, os.path.dirname(self.FileName))\n }\n context = {\n 'sln': self\n }\n return self.render(self.__jinja_template__, self.FileName, context, filters)",
"def generate(self):\n xml = self.template()\n fp = BytesIO()\n gzip = GzipFile(self.filename, \"wb\", 9, fp)\n if isinstance(xml, str):\n xml = xml.encode(\"utf8\")\n gzip.write(xml)\n gzip.close()\n data = fp.getvalue()\n fp.close()\n return data",
"def to_xml(self) -> str:\n # default name and stuff setup\n element_root, xml_tree = super()._add_basics()\n element_root = element_root.find('elementProp')\n element_root = element_root.find('collectionProp')\n for element in list(element_root):\n try:\n if element.attrib['name'] == 'influxdbUrl':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.influx_db_url:\n elem.text = self.influx_db_url\n elif element.attrib['name'] == 'application':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.application:\n elem.text = self.application\n elif element.attrib['name'] == 'measurement':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.measurement:\n elem.text = self.application\n elif element.attrib['name'] == 'summaryOnly':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value':\n elem.text = str(self.summary_only).lower()\n elif element.attrib['name'] == 'samplersRegex':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.samplers_regexp:\n elem.text = self.samplers_regexp\n elif element.attrib['name'] == 'percentiles':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.percentiles:\n elem.text = self.percentiles\n elif element.attrib['name'] == 'testTitle':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.test_title:\n elem.text = self.test_title\n elif element.attrib['name'] == 'eventTags':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.event_tags:\n elem.text = self.event_tags\n except Exception:\n raise Exception(f'Unable to render xml from {type(self).__class__}')\n return tree_to_str(xml_tree, hashtree=True)",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def getXSLURL(self, output='page'):\n mn_props = getToolByName(self, \"portal_properties\")['metnav_properties']\n output = output.lower().strip()\n if output == 'page':\n return mn_props.getProperty('XSL_PAGE', '')\n if output == 'portlet':\n return mn_props.getProperty('XSL_PORTLET', '')\n if output == 'dict':\n return mn_props.getProperty('XSL_DICT', '')\n if output == 'count':\n return mn_props.getProperty('XSL_COUNT', '')\n if output == 'rss':\n return mn_props.getProperty('XSL_RSS', '')\n if output == 'class_list':\n return mn_props.getProperty('XSL_CLASS_LIST', '')\n if output == 'table':\n return mn_props.getProperty('XSL_TABLE', '')\n if output == 'year_list':\n return mn_props.getProperty('XSL_YEAR_LIST', '')\n raise \"%s is not a valid value for an XSL output\" % output",
"def transform_s3_xsl(**kwargs):\n access_id = kwargs.get(\"access_id\")\n access_secret = kwargs.get(\"access_secret\")\n bucket = kwargs.get(\"bucket\")\n dest_prefix = kwargs.get(\"destination_prefix\")\n source_prefix = kwargs.get(\"source_prefix\")\n if kwargs.get(\"dag\"):\n run_id = kwargs.get(\"dag\").dag_id\n else:\n run_id = \"no-dag-provided\"\n\n saxon = prepare_saxon_engine()\n transformed = etree.Element(\"collection\")\n transformed.attrib[\"dag-id\"] = run_id\n transformed.attrib[\"dag-timestamp\"] = kwargs.get(\"timestamp\", \"no-timestamp-provided\")\n xsl = \"https://raw.github.com/{repo}/{branch}/{filename}\".format(\n repo=kwargs.get(\"xsl_repository\", \"tulibraries/aggregator_mdx\"),\n branch=kwargs.get(\"xsl_branch\", \"main\"),\n filename=kwargs.get(\"xsl_filename\")\n )\n\n for s3_key in process.list_s3_content(bucket, access_id, access_secret, source_prefix):\n logging.info(\"Transforming File %s\", s3_key)\n s3_content = process.get_s3_content(bucket, s3_key, access_id, access_secret)\n s3_xml = etree.fromstring(s3_content)\n for record in s3_xml.iterchildren():\n record_id = record.get(\"airflow-record-id\")\n logging.info(\"Transforming Record %s\", record_id)\n result_str = subprocess.check_output([\"java\", \"-jar\", saxon, \"-xsl:\" + xsl, \"-s:-\"], input=etree.tostring(record, encoding=\"utf-8\"))\n result = etree.fromstring(result_str)\n result.attrib[\"airflow-record-id\"] = record_id\n transformed.append(result)\n filename = s3_key.replace(source_prefix, dest_prefix)\n transformed_xml = etree.tostring(transformed, encoding=\"utf-8\")\n process.generate_s3_object(transformed_xml, bucket, filename, access_id, access_secret)",
"def export_to_xml(self, resource_fs):\r\n\r\n # Set up runtime.export_fs so that it's available through future\r\n # uses of the pure xblock add_xml_to_node api\r\n self.runtime.export_fs = resource_fs\r\n\r\n # Get the definition\r\n xml_object = self.definition_to_xml(resource_fs)\r\n self.clean_metadata_from_xml(xml_object)\r\n\r\n # Set the tag so we get the file path right\r\n xml_object.tag = self.category\r\n\r\n # Add the non-inherited metadata\r\n for attr in sorted(own_metadata(self)):\r\n # don't want e.g. data_dir\r\n if attr not in self.metadata_to_strip and attr not in self.metadata_to_export_to_policy:\r\n val = serialize_field(self._field_data.get(self, attr))\r\n try:\r\n xml_object.set(attr, val)\r\n except Exception:\r\n logging.exception(\r\n u'Failed to serialize metadata attribute %s with value %s in module %s. This could mean data loss!!!',\r\n attr, val, self.url_name\r\n )\r\n\r\n for key, value in self.xml_attributes.items():\r\n if key not in self.metadata_to_strip:\r\n xml_object.set(key, value)\r\n\r\n if self.export_to_file():\r\n # Write the definition to a file\r\n url_path = name_to_pathname(self.url_name)\r\n filepath = self._format_filepath(self.category, url_path)\r\n resource_fs.makedir(os.path.dirname(filepath), recursive=True, allow_recreate=True)\r\n with resource_fs.open(filepath, 'w') as file:\r\n file.write(etree.tostring(xml_object, pretty_print=True, encoding='utf-8'))\r\n\r\n # And return just a pointer with the category and filename.\r\n record_object = etree.Element(self.category)\r\n else:\r\n record_object = xml_object\r\n\r\n record_object.set('url_name', self.url_name)\r\n\r\n # Special case for course pointers:\r\n if self.category == 'course':\r\n # add org and course attributes on the pointer tag\r\n record_object.set('org', self.location.org)\r\n record_object.set('course', self.location.course)\r\n\r\n return etree.tostring(record_object, pretty_print=True, encoding='utf-8')",
"def writeXMLDecl(self):\n return _libsbml.XMLOutputStream_writeXMLDecl(self)",
"def setXSLTMode(self,value):\n self.PDFreactorConfiguration.in1[\"XSLTMode\"] = value",
"def save(self, filename=None):\n f = filename if filename else self.path\n etree.register_namespace('', TEI)\n etree.register_namespace('mith', MITH)\n self.doc.write(f, xml_declaration=True, encoding='utf-8', method='xml')",
"def toXML(self):\n return self._xmlpre+\"\\n\".join(map(lambda f:f.toXML(),self._items))+self._xmlpost",
"def to_xml(self):\n # lines = super(FileCatNoEmpty, self).cat(filepath)\n structure = super(Point, self).to_xml()\n\n\n coords = GeometryTopologyData.__to_xml_vector__(self.coordinate, self.format)\n # description_str = ''\n # if self.description is not None:\n # description_str = '<Description>%s</Description>' % self.description\n\n return '<Point>%s<Coordinate>%s</Coordinate></Point>' % (structure, coords)",
"def write(klass, document, target=None, stylesheet=\"\"):\n writer = LatexWriter(document, target, stylesheet)\n return writer.go()",
"def to_xml(self, file_name=None):\n if file_name:\n xml_file = open(file_name, 'w')\n results = ['<schema name=\"%s\">' % self.name]\n for schema_object in list(self.schema.keys()):\n results.append(self.schema[schema_object].to_xml())\n results.append('</schema>')\n if file_name:\n xml_file.write('\\n'.join(results))\n xml_file.close()\n else:\n return '\\n'.join(results)",
"def write_xosc(self, generated_xml):\n reparsed_xml = minidom.parseString(generated_xml).toprettyxml(indent=\" \")\n xosc_file = open(self._filepath, \"w\")\n xosc_file.write(reparsed_xml)\n xosc_file.close()\n\n msg = QMessageBox()\n if self._warning_message:\n msg.setIcon(QMessageBox.Warning)\n text = f\"Exported OpenSCENARIO file {self._filepath} has warnings!\\n\\n\"\n text += \"\\n\".join(self._warning_message)\n else:\n msg.setIcon(QMessageBox.Information)\n text = f\"Successfully exported OpenSCENARIO file to {self._filepath}\"\n msg.setText(text)\n msg.setWindowTitle(\"OpenSCENARIO Export\")\n msg.setStandardButtons(QMessageBox.Ok)\n msg.exec()",
"def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()",
"def start_serialization(self):\n self.xml = SimplerXMLGenerator(self.stream, self.options.get(\"encoding\", settings.DEFAULT_CHARSET))\n self.xml.startDocument()\n self.xml.startElement(\"xliff\", {\n \"version\": \"1.2\",\n \"xmlns\": \"urn:oasis:names:tc:xliff:document:1.2\",\n \"xmlns:d\": \"https://docs.djangoproject.com/\"\n })",
"def XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\n\n\t#On commence par afficher ce qu'on fait\r\n\tprint \" Build xml file \"\r\n\r\tprint InputsFile\n\t#ouverture du fichier dans lequel on place le source model\n\ttry:\n\t\tfresult = open(OutputFile, 'w')\n\texcept:\n\t\tprint \"Coucou\"\r\n \t#ecriture des premieres lignes invariantes\n\tfresult.write('<?xml version=\"1.0\" ?>')\r\n\tfresult.write(\"<source_library title=\\\"source library\\\">\\n\")\n\r\n \t#ouverture du fichier avec les entrees\r\n\tf = open(InputsFile,\"r\")\r\n\tlines = f.readlines()\r\n\t\r\n \t#Ajout des sources detectees dans le catalogue\n\t#Pour chaque ligne du fichier d'entree\r\n\tfor line in range(len(lines)):\n\t\t#Lire les donnees de la ligne\t\t\r\n\t\tdata = lines[line].split()\r\n\t\tname = data[0]\n\n\t\t#Verification : est on en train de traiter la source que l'on veut etudier ou une autre ?\r\n\t\tif str(name) == Name :\r\n\t\t\tmysource = 1\r\n\t\telse:\r\n\t\t\tmysource = 0\n\n\t\t#recuperation des donnees\r\n\t\tRA = data[1]\r\n\t\tDEC = data[2]\r\n\t\tIntegral = float(data[3])*float(Frac)\r\n\t\tGamma= data[4]\n\n\t\t\r\n\t\ttry:\n\t\t\t#essai de definition des donnees pour un PL avec ExpCut\n\t\t\tPrefactor = float(data[5])*float(Frac)\r\n\t\t\tEnergy = float(data[6])\r\n\t#\t\tPrefactor = Prefactor/pow(Energy/100., float(Gamma)) #Densite de flux calculee a Epivot\r\n\t#\t\tPrefactor = Prefactor*pow(1000./100., float(Gamma)) #We do the calculation with (E/1000.)^Gamma\n\t\t\tvariabilite=float(data[8])\n\n#\t\t\tprint variabilite\n\n\n\n\r\n\t\t\tcut = float(data[7]) # Cut est la variable qui nous permettra de savoir si il faut utiliser un cut off (1) ou une loi de puissance normale (2)\r\n\t\texcept:\r\n\t\t\ttry:\r\n\t\t\t\tcut = float(data[5])\r\n\t\t\texcept:\r\n\t\t\t\tprint \" Wrong size of list \"\r\n\t\t\t\tsys.exit()\r\n \t#Si on considere un ccut off exponentiel pour la source :\r\n\t\tif cut == 1:\n\t\t\t#ecriture du nom de la source consideree\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\r\n\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\r\n\t\t\tspectrum_type = \"PLSuperExpCutoff\"\n\t\t\t#Utilisation de la modelisation PLSuperExpCutoff car plus simple et plus intuitive pour nous et pour la modelisation des pulsars si il faut en modeliser\n\r\n\t\t\t#definition des parametres spectraux a prendre en comtpe et de la chaine de caractere a integrer\r\n\n\n\n\t\t\tif variabilite==0.0 or variabilite==2.0:\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"10000000.0\\\" min=\\\"0.0000001\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\r\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.001\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\n\r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\t\t\telif variabilite==1.0 :\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10000000.0\\\" min=\\\"0.0\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.0001\\\"\"\r\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\n\r\n \r\n\n# <spectrum type=\"PLSuperExpCutoff\">\n# <parameter free=\"1\" max=\"100000\" min=\"0\" name=\"Prefactor\" scale=\"1e-10\" value=\"Prefactor*1e-10\"/>\n# <parameter free=\"1\" max=\"0\" min=\"5\" name=\"Index1\" scale=\"-1\" value=\"valeur du catalogue\"/>\n# <parameter free=\"0\" max=\"20000\" min=\"1.0\" name=\"Scale\" scale=\"1\" value=\"Epivot\"/>\n# <parameter free=\"1\" max=\"300000\" min=\"100\" name=\"Cutoff\" scale=\"1\" value=\"3000\"/>\n# <parameter free=\"0\" max=\"5\" min=\"0\" name=\"Index2\" scale=\"1\" value=\"1.5\"/>\n# </spectrum>\n\n\r\n\t\telse:\n\t\t#Sinon (si on considere une loi de puissance simple)\n\t\t#definition de la chaine de caractere comportant le nom de la source\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\n\t\t\tif mysource == 0:\r\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\n\t\t\telse:\n\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\t\t\t\t\n\n\t\t\t#definition de la chaine de caractere correspondant a la forme de fit que l'on souhaite utiliser (Loi de puissance)\r\n\t\t\tspectrum_type = \"PowerLaw2\"\r\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre Integrale\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\telse:\n\t\t\t#sinon on le libere\r\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\n\n\n\n\n\n\t\t\t#Toujours ce facteur....\r\n\t\t\tIntegral = float(Integral)*1e10\r\n\t\t\tscale = 1e-10\n\n\n\t\n\r\n\t\t\tspectrum_lines += \" name=\\\"Integral\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre gamma\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\telse:\n\t\t\t\t#si c'est pas la source que l'on etudie on le laisse libre\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\n\n\t\t\t#fin de la chaine de parametres sur le modele spectral\r\n\t\t\tspectrum_lines += \" name=\\\"Index\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t \n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"1000.0\\\"/>\\n\"\r\n \r\n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\t\t\telse:\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"100\\\"/>\\n\"\n\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"100000.0\\\" Min =\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\n \t\t#ajout du modele spectral a la liste de parametres \r\n\t\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\t\tresult_line += spectrum_lines\r\n\t\tresult_line += \" </spectrum>\\n\"\n\n\t\t\n\n\t\tif mysource==0 and variabilite!=1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telif mysource==0 and variabilite==1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telse:\n #ajout du modele spatial a la liste de parametres \n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\t\t\n\t\tresult_line += \" </source>\\n\"\r\n\t\tfresult.write(result_line+\"\\n\")\r\n #Ajout du fond diffus galactique\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"gal_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"ConstantValue\"\r\n\r\n\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Value\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n\r\n\tresult_line += \" <spatialModel file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/gll_iem_v02.fit\\\" type=\\\"MapCubeFunction\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"1000.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Normalization\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\r\n \t#Ajout du fond diffus extragalactique\r\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"eg_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"FileFunction\"\r\n\r\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Normalization\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/isotropic_iem_v02.txt\\\" type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n \r\n\tresult_line += \" <spatialModel type=\\\"ConstantValue\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"100.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Value\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\n \t#Fermeture des fichiers \r\n\tf.close() \r\n\tfresult.write(\"\\n</source_library>\\n\")\r\n\tfresult.close()\r\n\treturn",
"def get(self):\n return _SALOMERuntime.OutputXmlPort_get(self)",
"def toXML(self):\n return _libsbml.Layout_toXML(self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def write(self):\r\n for prop in self.prpnames:\r\n elem = SubElement(self._root, prop)\r\n data = self.__getattribute__(prop)\r\n if self.prpnames[prop]['type'] == \"text\":\r\n elem.text = data\r\n elif self.prpnames[prop]['type'] == 'list':\r\n for x in data:\r\n SubElement(elem, 'regel').text = x\r\n elif self.prpnames[prop]['type'] == 'attr':\r\n elem.set(self.prpnames[prop]['naam'], data)\r\n tree = ElementTree(self._root)\r\n tree.write(self._fn)\r\n if not self.exists:\r\n self.exists = True",
"def write(self, file_or_filename):\n etMap = revert(self)\n xmlTree = ET.ElementTree(etMap)\n xmlTree.write(file_or_filename)",
"def save_to_xml(self, xwriter):\r\n\r\n xwriter.WriteStartElement(\"Profile\")\r\n xwriter.WriteAttributeString(\"Name\", self.Name)\r\n xwriter.WriteStartAttribute(\"Version\")\r\n xwriter.WriteValue(self.Version)\r\n xwriter.WriteEndAttribute()\r\n\r\n for var_name in self.__dict__:\r\n var_type = type(getattr(self, var_name))\r\n\r\n if var_type is str and var_name != \"Name\":\r\n self.write_string_to_xml(var_name, xwriter)\r\n\r\n elif var_type is bool:\r\n self.write_bool_to_xml(var_name, xwriter)\r\n\r\n elif var_type is dict:\r\n self.write_dict_to_xml(var_name, xwriter)\r\n\r\n elif var_type is list and var_name != \"ExcludeRules\":\r\n self.write_list_to_xml(var_name, xwriter)\r\n\r\n xwriter.WriteStartElement(\"ExcludeRules\")\r\n xwriter.WriteAttributeString(\"Operator\", self.ExcludeOperator)\r\n xwriter.WriteAttributeString(\"ExcludeMode\", self.ExcludeMode)\r\n for rule in self.ExcludeRules:\r\n if rule:\r\n rule.save_xml(xwriter)\r\n xwriter.WriteEndElement()\r\n \r\n xwriter.WriteEndElement()",
"def xmlWrite(self, xmlWriter, font, value, name, attrs):\n raise NotImplementedError(self)",
"def writeXMLNS(self, *args):\n return _libsbml.ASTBasePlugin_writeXMLNS(self, *args)",
"def write_output_file(self, xml_text, xml_file):\n xml_fo = open(xml_file, 'w')\n xml_fo.write(xml_text+'</xml>')\n xml_fo.close()\n return",
"def _generate_xml(self, body, destn_dir, nodes=True):\n fn = ''.join([random.choice(string.ascii_letters) for _ in range(12)])\n fn += '.xml'\n\n _dir = os.path.dirname(os.path.abspath(__file__))\n _tmpl = 'multi_node.template' if nodes else 'single_node.template'\n _env = Environment(autoescape=False,\n loader=FileSystemLoader(_dir),\n trim_blocks=False)\n\n with open(fn, 'w+') as f:\n o = _env.get_template(_tmpl).render(body)\n f.write(o)\n\n _d = destn_dir + '/' + fn\n self._remote_copy(fn, _d)\n # Remove the XML file created locally\n os.remove(fn)\n\n return _d",
"def dumps(records, xslt_filename=None, **kwargs):\n root = dumps_etree(records=records, xslt_filename=xslt_filename)\n return etree.tostring(\n root,\n pretty_print=True,\n xml_declaration=True,\n encoding='UTF-8',\n **kwargs\n )",
"def xml(self):\n raise NotImplementedError('This api does not return xml')",
"def _writeXML(self,output,outputDictionary):\n if self.dynamic:\n outputInstance = xmlUtils.DynamicXmlElement('MetricPostProcessor', pivotParam=self.pivotParameter)\n else:\n outputInstance = xmlUtils.StaticXmlElement('MetricPostProcessor')\n if self.dynamic:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n for ts, pivotVal in enumerate(self.pivotValues):\n if values.shape[0] == 1:\n outputInstance.addScalar(nodeName, metricName,values[0], pivotVal=pivotVal)\n else:\n outputInstance.addScalar(nodeName, metricName,values[ts], pivotVal=pivotVal)\n else:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n if len(list(values)) == 1:\n outputInstance.addScalar(nodeName, metricName, values[0])\n else:\n self.raiseAnError(IOError, \"Multiple values are returned from metric '\", metricName, \"', this is currently not allowed\")\n return outputInstance",
"def writeXml(self):\n curdir = os.getcwd()\n os.chdir(self.Imagedir)\n allImageLists = [self.sciImlist, self.ctxImlist, self.wgtImlist, self.rmsImlist]\n \n for imlist in allImageLists:\n for im in imlist:\n file = xmlUtil.markupImage(im,dataset=self.obsName)\n \n # Don't write these images as output of this module, which\n # really doesn't have any.\n \n #if file not in self.outputList.keys():\n # self.outputList[file] = [im]\n \n os.chdir(curdir)\n return",
"def docType():\n return (u'<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n u'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 '\n u'Transitional//EN\" '\n u'\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n')",
"def to_xml(self, scene_dir: str) -> Tuple[Et.Element, bool]:\n raise NotImplementedError",
"def save_xml_file():\n global output_on_display, import_lst, column_names, data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = data[0]\n step = len(column_names)\n\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"XML\", \"*.xml\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.xml')\n data = import_lst\n\n if len(data[0]) == step:\n pass\n else:\n data = import_lst[step::]\n\n data2 = list(map(list, zip(*data)))\n\n data3 = {key: value for key, value in zip(column_names, data2)}\n\n column = list(data3.keys())\n\n df = pd.DataFrame(data3, columns=column)\n\n data_dict = df.to_dict(orient=\"records\")\n with open('output.json', \"w+\") as f:\n json.dump(data_dict, f, indent=4)\n\n xml_data = dicttoxml(data_dict).decode()\n with open(save_name, \"w+\") as f:\n f.write(xml_data)\n\n data.clear()\n data2.clear()\n data3.clear()",
"def Write(self):\n f = open(self.project_path, 'wt')\n self.doc.writexml(f,\n encoding='Windows-1252',\n addindent=' ',\n newl='\\n')\n f.close()",
"def write(self, filename, agg_dir):\n super().write(filename)\n\n if self.aggregation:\n agg = self.aggregation\n abs_subdir = os.path.join(agg_dir, agg.sub_dir)\n if not os.path.isdir(abs_subdir):\n os.makedirs(abs_subdir)\n\n agg.xml_element.write(os.path.join(abs_subdir, agg.basename))",
"def to_sbml(self, params):\n files = {}\n _id, cobra_model = self._ws_obj_to_cobra(params['input_ref'])\n files['file_path'] = os.path.join(params['destination_dir'], _id + \".xml\")\n cobra.io.write_sbml_model(cobra_model, files['file_path'])\n\n return _id, files",
"def write2file(self, save_to):\n headerstyle = xlwt.easyxf(self.header_style.get_style_string())\n missing_val_style = xlwt.easyxf(\n self.missing_value_style.get_style_string())\n row_styles = [xlwt.easyxf(self.first_style.get_style_string()),\n xlwt.easyxf(self.second_style.get_style_string())]\n\n properties, sections, table = self._build_table()\n\n workbook = xlwt.Workbook()\n sheet = workbook.add_sheet(self.sheet_name)\n\n if os.path.splitext(save_to)[-1] == '':\n save_to += '.xls'\n\n max_col_len = []\n\n if (self.switch):\n\n for i, prop in enumerate([''] + properties):\n sheet.write(0, i, prop, headerstyle)\n max_col_len.append(len(str(prop)))\n\n for row_num, sec in enumerate(sections):\n sheet.write(row_num + 1, 0, sec, headerstyle)\n if len(str(sec)) > max_col_len[0]:\n max_col_len[0] = len(str(sec))\n\n for row_num, row in enumerate(table):\n for col_num, elem in enumerate(row):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n else:\n\n for i, sec in enumerate([''] + sections):\n sheet.write(0, i, sec, headerstyle)\n max_col_len.append(len(str(sec)))\n\n for row_num, prop in enumerate(properties):\n sheet.write(row_num + 1, 0, prop, headerstyle)\n if len(str(prop)) > max_col_len[0]:\n max_col_len[0] = len(str(prop))\n\n for col_num, col in enumerate(table):\n for row_num, elem in enumerate(col):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n # adjust width of he columns\n for col_id, col_len in enumerate(max_col_len):\n sheet.col(col_id).width = (256 * (col_len+1))\n\n workbook.save(save_to)",
"def writeToTempXml(self):\n name = self.fileToProcess.name\n all_tokens = ET.Element(\"tokens\")\n for token in self.tokensTable:\n if token.getType() == KEYWORD:\n keyword = ET.SubElement(all_tokens, \"keyword\")\n keyword.text = ' '+token.getValue()+' '\n elif token.getType() == IDENTIFIER:\n identifier = ET.SubElement(all_tokens, \"identifier\")\n identifier.text = ' '+token.getValue()+' '\n elif token.getType() == SYMBOL:\n symbol = ET.SubElement(all_tokens, \"symbol\")\n symbol.text = ' '+token.getValue()+' '\n elif token.getType() == STRING_CONST:\n stringConstant = ET.SubElement(all_tokens, \"stringConstant\")\n stringConstant.text = ' '+token.getValue()+' '\n elif token.getType() == INT_CONST:\n integerConstant = ET.SubElement(all_tokens, \"integerConstant\")\n integerConstant.text = ' '+token.getValue()+' '\n tree = ET.ElementTree(all_tokens)\n tree.write(name + 'T' + '.xml')",
"def xslText(self):\n return u'<xsl:for-each select = \"./%s\">%s<xsl:choose>'\\\n '<xsl:when test=\"contains(., \\':\\')\"><a href=\"{.}\">'\\\n '<xsl:value-of select=\".\"/></a></xsl:when><xsl:otherwise>'\\\n '<a href=\"%s{.}\"><xsl:value-of select=\".\"/></a>'\\\n '</xsl:otherwise></xsl:choose>%s</xsl:for-each>' % \\\n (self.name, xslEscape(self.prefix), self.URLMethod,\n xslEscape(self.suffix))",
"def getXML(self):\n nodes = list(self.nodes(data=True))\n nodes.sort()\n node_string = ''\n for n in nodes:\n attribute_string = ''\n keys = list(n[1].keys())\n keys.sort()\n for k in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(k, n[1][k], k)\n modification_string = ''\n modified_by = self.predecessors(n[0])\n if modified_by:\n for mod in modified_by:\n modification_string += \"\"\"<modified_by>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifyingNode> %s </modifyingNode>\\n\"\"\"%mod.getTagID()\n modification_string += \\\n \"\"\"<modifyingCategory> %s </modifyingCategory>\\n\"\"\"%mod.getCategory()\n modification_string += \"\"\"</modified_by>\\n\"\"\"\n modifies = self.successors(n[0])\n if modifies:\n for modified in modifies:\n modification_string += \"\"\"<modifies>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifiedNode> {0} </modifiedNode>\\n\"\"\".format(modified.getTagID())\n modification_string += \\\n \"\"\"</modifies>\\n\"\"\"\n node_string += \\\n NODE_XML_SKEL.format(attribute_string+\"{0}\".format(n[0].getXML()) +\\\n modification_string)\n edges = list(self.edges(data=True))\n edges.sort()\n edge_string = ''\n for edge in edges:\n keys = list(edge[2].keys())\n keys.sort()\n attribute_string = ''\n for key in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(key, edge[2][key], key)\n edge_string += \"{0}\".format(EDGE_XML_SKEL.format(edge[0].getTagID(),\n edge[1].getTagID(),\n attribute_string))\n\n return CONTEXT_MARKUP_XML_SKEL.format(xmlScrub(self.getRawText()),\n xmlScrub(self.getText()),\n node_string,\n edge_string)",
"def writeXMLNS(self, *args):\n return _libsbml.MultiASTPlugin_writeXMLNS(self, *args)",
"def run_xslt(xml_filename, xsl_filename):\n import subprocess\n from misc.localexec import LocalExec\n from distutils.spawn import find_executable\n\n def seekout_xsltproc():\n XSLTPROC_BIN = 'xsltproc'\n executable = find_executable(XSLTPROC_BIN)\n if executable:\n return os.path.abspath(executable)\n raise SignerError(\"it has not found {} binary\".format(XSLTPROC_BIN))\n\n le = LocalExec(err_mute=True)\n exe = seekout_xsltproc()\n exe_args = [ xsl_filename, xml_filename ]\n\n try:\n return le([exe] + exe_args, cmd_timeout=20, ign_rcs=None)\n except subprocess.CalledProcessError as e:\n msg = \"Command raised exception\\nOutput: \" + str(e.output)\n raise Exception(msg)",
"def _write_context_to_file(self, context):\n om.out.debug('[xml_file.flush()] Starting _write_context_to_file()')\n\n template = self._jinja2_env.get_template('root.tpl')\n\n # We use streaming as explained here:\n #\n # http://flask.pocoo.org/docs/0.12/patterns/streaming/\n #\n # To prevent having the whole XML in memory\n # pylint: disable=E1101\n report_stream = template.stream(context)\n report_stream.enable_buffering(3)\n # pylint: enable=E1101\n\n # Write everything to a temp file, this is useful in two cases:\n #\n # * An external tool will always see a valid XML in the output,\n # and not just a partially written XML document.\n #\n # * If w3af is killed in the middle of writing the XML report,\n # the report file will still be valid -- if xml_file.flush() was\n # run successfully at least once\n tempfh = NamedTemporaryFile(delete=False,\n prefix='w3af-xml-output',\n suffix='.xml')\n\n om.out.debug('[xml_file.flush()] write_context_to_file() created'\n ' template.stream and NamedTemporaryFile')\n\n try:\n # Write each report section to the temp file\n for report_section in report_stream:\n tempfh.write(report_section.encode(DEFAULT_ENCODING))\n except Exception:\n # No exception handling is done here, we just raise the exception\n # so that the core can handle it properly\n raise\n else:\n # Close the temp file so all the content is flushed\n tempfh.close()\n\n om.out.debug('[xml_file.flush()] write_context_to_file() starting to'\n ' copy temp file to destination')\n\n # Copy to the real output file\n report_file_name = os.path.expanduser(self._file_name)\n\n cmd = 'cp %s %s' % (tempfh.name, report_file_name)\n subprocess.call(cmd, shell=True)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished copy'\n ' operation.')\n\n stat_info = os.stat(report_file_name)\n om.out.debug('The XML output file size is %s bytes.' % stat_info.st_size)\n\n finally:\n os.remove(tempfh.name)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished')",
"def to_workbook(self) -> tuple:\n\n # Initialize the bytestream\n f = io.BytesIO()\n wb = xw.Workbook(f, {\"in_memory\": True})\n\n # Open a workbook\n self._book = wb\n self._book.set_properties({\"category\": \"atomica:databook\"})\n self._formats = standard_formats(self._book)\n self._references = {} # Reset the references dict\n\n # Write the contents\n self._write_pops()\n self._write_tdve()\n self._write_interpops()\n self._write_transfers()\n\n # Clean internal variables related to writing the worbkook\n self._book = None\n self._formats = None\n self._references = None\n\n return f, wb",
"def format_xml(self,query_results):\n results=query_results.data\n factory=factory_xml()\n dump=factory.dumps({'data':results})\n print(dump)\n # TODO return output for this\n return \"\"",
"def write_to_xml(dictData, metadata, xmlfile):\n\tfout = codecs.open(xmlfile, 'w', 'utf-8')\n\tfout.write('<?xml version = \"1.0\" encoding = \"UTF-8\" standalone = \"no\" ?>\\n')\n\tfout.write('<?xml-stylesheet type=\"text/xsl\" href=\"maketable.xsl\"?>\\n')\n\tfout.write('<root>\\n')\n\tfout.write('<meta>\\n')\n\tfor key, value in metadata.items():\n\t\tfout.write('<' + key + '>' + value + '</' + key + '>\\n')\n\tfout.write('</meta>\\n')\n\tfout.write('<content>\\n')\n\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dictData:\n\t\txmlline = ''\n\t\txmlline += '<word><headword>' + hw + '</headword><meanings>'\n\t\tfor meaning in meanings:\n\t\t\txmlline += '<m>' + meaning + '</m>'\n\t\txmlline += '</meanings>'\n\t\txmlline += '<verse>'\n\t\tlines = verse.split('<BR>')\n\t\tfor line in lines:\n\t\t\txmlline += '<line>' + line + '</line>'\n\t\txmlline += '</verse>'\n\t\txmlline += '<verseNumber>' + verseNumDetails + '</verseNumber>'\n\t\txmlline += '<pageNumber>' + pageNumDetails + '</pageNumber></word>'\n\t\t# Write in babylon format. <BR><BR> is to separate verses.\n\t\tfout.write(xmlline + '\\n')\n\t\txmlline = ''\n\tfout.write('</content>\\n</root>')\n\tfout.close()\n\n\t# Give some summary to the user\n\tprint('XML file generated. Success!')\n\tprint('{} metadata lines and {} content lines written to XML file.'.format(len(metadata), len(dictData)))",
"def xml(self):\n return self._xml",
"def xml(self):\n return self._xml",
"def writeSBMLToFile(self, *args):\n return _libsbml.SBMLWriter_writeSBMLToFile(self, *args)",
"def _create_xml_report(self, test, xml_obj):\n xml_report_path = os.path.join(test.work_dir,\n self.XML_REPORT_PATH)\n with open(xml_report_path, 'w') as xml_report:\n xml_report.write(etree.tostring(xml_obj, pretty_print=True))",
"def xml2html(self):\n handler = open(self.xml_doc).read()\n soup = BeautifulSoup(handler, 'xml')\n\n fw = open(self.filename_out, 'w')\n\n fw.write(\"<!DOCTYPE html>\" + os.linesep)\n fw.write(\"<html>\" + os.linesep)\n fw.write(\"<head>\" + os.linesep)\n fw.write('<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">' + os.linesep)\n fw.write(\"<link rel=\\\"stylesheet\\\" href=\\\"%s\\\" type=\\\"text/css\\\" />\" % self.stylesheet_name + os.linesep)\n fw.write(\"<title></title>\" + os.linesep)\n fw.write(\"</head>\" + os.linesep)\n fw.write(\"<body>\" + os.linesep)\n\n # Load styles in dictionaries\n for style in soup.find_all(\"style\"):\n style_name = style.get(\"style:name\")\n #print \"style: %s children: %s descendants: %s\" % (str(style_name), str(len(list(style.children))), len(list(style.descendants)))\n for style_child in style.children:\n fs = style_child.get(\"fo:font-style\")\n if fs:\n self.style_fontstyle[style_name] = fs\n fontw = style_child.get(\"fo:font-weight\")\n if fontw:\n self.style_fontweight[style_name] = fontw\n # read alignment\n txta = style_child.get(\"fo:text-align\")\n if txta:\n self.style_textalignment[style_name] = txta\n # !!!\n tu = style_child.get(\"style:text-underline-type\")\n if tu:\n self.style_textunderline[style_name] = \"underlined\"\n # page break\n break_before = style_child.get(\"fo:break-before\")\n if break_before:\n self.style_break_before[style_name] = break_before\n\n\n # Navigate down the document through h and p tags\n #\n for text in soup.find_all(re.compile(\"^h|^p\")):\n\n # From bs4 docs: If a tag has only one child, and that child is a NavigableString, the child is made available as .string:\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"P9\">- Any text here!</text:p>\n #\n # To do:\n #\n # Beware of this case:\n # - <text:p text:style-name=\"P8\">\n # <text:span text:style-name=\"T4\">\n #\n\n # Get the attributes so the styles and the outlines\n text_attrs = dict(text.attrs)\n\n # Get the styles, if any\n try:\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n if text.string:\n t = unicode(text.string)\n if t:\n fw.write(self.outliner(self.stylizer(t, t_style), t_outline_level, t_style).encode('utf-8'))\n\n # e.g. page breaks come as a node with no children whose style contains fo:break-before:\"page\"\n elif len(list(text.children)) == 0:\n fw.write(self.outliner(unicode(\"\"), t_outline_level, t_style).encode('utf-8'))\n\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"Textbody\">\n # jkjksk skjkjkjs dhh\n # <text:s />\n # <text:span text:style-name=\"T3\">Bold</text:span>\n # <text:s />\n # </text:p>\n #\n # else drill down one level\n else:\n buffer = unicode(\"\")\n t = buffer\n u = buffer\n t_outline_level = \"paragraph\"\n t_style = \"\"\n for i in text.children:\n # Get the attributes so the styles\n try:\n text_attrs = dict(i.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n # whenever the element has no style\n # take the parent's one\n try:\n text_attrs = dict(i.parent.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n # if the current tag has only one child, and that child is a NavigableString\n if i.string:\n t = unicode(i.string)\n\n # space\n elif i.name == \"s\":\n t = unicode(\" \")\n\n # else drill down another level\n else:\n t = unicode(\"\")\n for j in i.children:\n if j.string:\n u = unicode(j.string)\n elif j.name == \"s\":\n u = unicode(\" \")\n else:\n u = unicode(\"\")\n if u:\n t = t + self.stylizer(u, t_style)\n\n # build up a unicode string containing the whole paragraph\n if t:\n buffer = buffer + self.stylizer(t, t_style)\n\n # outline the buffered unicode string and write it to the output file\n fw.write(self.outliner(buffer, t_outline_level, t_style).encode('utf-8'))\n\n fw.write(\"</body>\" + os.linesep)\n fw.write(\"</html>\" + os.linesep)\n fw.close()",
"def writexml(file):\n OUTFILE=open(file,\"w\")\n doc = xml.dom.minidom.Document()\n\n # Create the <dec_reg_list> base element\n decl_reg_list = doc.createElement(\"decl_reg_list\")\n doc.appendChild(decl_reg_list)\n\n regname_old=\"\"\n rows.pop(0)\n for row in rows:\n (regdesc,regname,offset,default,regtype,expose_reg,depth,incsz,bitdesc,bitname,loc,bittype)= row\n if regname != regname_old:\n # Create the register element\n register = doc.createElement(\"register\")\n register.setAttribute(\"name\", regname)\n register.setAttribute(\"offset\", offset)\n if default != \"\" : register.setAttribute(\"default\", default)\n register.setAttribute(\"type\", regtype)\n if expose_reg == \"1\": register.setAttribute(\"usr\", expose_reg)\n if depth != \"\": register.setAttribute(\"size\", depth)\n if incsz != \"\": register.setAttribute(\"incsz\", incsz)\n text = doc.createTextNode(regdesc)\n register.appendChild(text)\n decl_reg_list.appendChild(register)\n \n # Create the field element\n if bitname != \"\":\n field = doc.createElement(\"field\")\n field.setAttribute(\"name\", bitname)\n if loc !=\"\": field.setAttribute(\"loc\", addcolon(loc))\n if bittype != \"\": field.setAttribute(\"type\", bittype)\n if bitdesc != \"\":\n text = doc.createTextNode(bitdesc)\n field.appendChild(text)\n register.appendChild(field)\n regname_old = regname\n\n\n # Print our newly created XML\n #print doc.toprettyxml(indent=\" \")\n #OUTFILE.write(doc.saveXML(decl_reg_list))\n OUTFILE.write(doc.toprettyxml(indent=\" \"))\n OUTFILE.close()",
"def export_to_file(self, filename):\n if len(filename.split(\".\")) == 1:\n filename += \".xml\"\n xmlstring = self._dommodel.toprettyxml(\" \", \"\\n\")\n with open(filename, \"w\") as f:\n f.write(xmlstring)",
"def write(self, filename):\n \n return self.model.write(filename,xml_declaration=True, encoding='utf-8')",
"def save_as(self, fname, base = None, indent = '', topns = True, namespaces = {}):\n with codecs.open(fname, \"w\", encoding=\"utf-8\") as outf:\n self.serialize_xml(outf.write, base=base, indent=indent, topns=topns, namespaces=namespaces)",
"def write(self):\n return JavaMLWriter(self)",
"def CreateXMLTransformer() -> TransformerFunc:\n return partial(traverse, transformation_table=XML_AST_transformation_table.copy())",
"def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez",
"def toXMLElement(self):\n property_element = xml.etree.ElementTree.Element('property')\n property_element.set('concept', self.concept_ref)\n\n if self.is_parent:\n property_element.set('isParent', 'true')\n\n return property_element",
"def xmlwrite(self, doc, filename):\n pathname = os.path.join(self.session.session_dir, filename)\n f = open(pathname, \"w\")\n doc.writexml(writer=f, indent=\"\", addindent=\" \", newl=\"\\n\", encoding=\"UTF-8\")\n f.close()",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def makexmlfunc(healpix,ra,dec,week1,week2,distance):\n\t\n\tif week1!=week2:\n\t\tidentity=\"%06d_%d_%d_w%03d_w%03d\" %(healpix,ra,dec,week1,week2)\n\t\tltcube=\"%s/lat_ltcube_weekly_w%03d_w%03d_p203_v001.fits\" %(cfg.home,week1,week2)\n\t\tspacecraft=\"%s/w%03d_w%03d_newspacecraft.fits\" %(cfg.ispace,week1,week2)\n\telse:\n\t\tidentity=\"%06d_%d_%d_w%03d\" %(healpix,ra,dec,week1)\n\t\tltcube=\"%s/lat_spacecraft_weekly_w%03d_p203_v001_ltcube.fits\" %(cfg.home,week1)\n\t\tspacecraft=\"%s/lat_spacecraft_weekly_w%03d_p202_v001.fits \" %(cfg.ispace,week1)\n\n\tregion_filtered=\"%s_region_filtered_gti.fits\" %(identity)\n\tfermisources=\"%s_fermisources_model.xml\" %(identity)\n\tinputmodel=\"%s_input_model.xml\" %(identity)\n\tfermis=\"%s_fermis.xml\" %identity\n\tresponse=\"P7REP_SOURCE_V15\"\n\tmakexmllog=\"%s_output_makexml.log\" %identity\n\tglobal extendedsource\n\tglobal numberofextendedsources\n\textendedlog=\"%s_number_of_extendedsources.log\" %identity\n\tExtendedList=\"ExtendedList.txt\"\n\tOthersList=\"OthersList.txt\"\n\n\t\n\twith open (makexmllog,'r') as outputFile: #opens the makexmllog file from makesyfunc. This document contains info about the extended sources.\n\t\t\n\t\tfor line in outputFile:\n\t\t\t\n\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\tif line.startswith('Added')==True:\n\t\t\t\t\ta,b=line.split('and ')\t\n\t\t\t\t\tb1,b2,b3=b.split(' ')\n\t\t\t\t\n\t\t\t\t\tnumberofextendedsources=int(b1) #b1 is the number of extended sources\n\toutputFile.close()\n\toutputFile=open(inputmodel, 'w')\n\tprint numberofextendedsources\n\n\tif numberofextendedsources==1: #if there is an extended source\n\t\twith open (makexmllog,'r') as outputFile:\n\t\t\n\t\t\tfor line in outputFile:\n\t\t\t\n\t\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\t\tif line.startswith('Extended')==True:\n\t\t\t\t\t\tprint line\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\tc,d=line.split(' in')\n\t\t\t\t\t\n\t\t\t\t\t\tc1,c2,c3,c4=c.split(' ')\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\textendedsource=str(c3) #extracts the name of the extended source from makexmllog\n\t\n\n\t\t\n\n\n\t\toutputFile.close()\t\n\n\n\t\n\n\t\twith open(\"%s\" %fermisources) as thefile: #opens the xml file that was created from makesyfunc\n\t\t\tfor line in thefile:\n\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==True:\n\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tspecial=str.replace(line,'%s.fits'%extendedsource,'%s/%s.fits' %(cfg.homesy,extendedsource)) \n\t\t\t\t\tprint special #replace with the correct path to the extendedsource(Templates folder)\n\t\t\t\n\t\t\t\t\tspecial1=str.replace(special,'type=\"SpatialMap\"','type=\"SpatialMap\" map_based_integral=\"true\"')\n\t\t\t\t\tprint special1 #instruction from fermi tutorial, you must add map_based...\n\t\t\t\t\toutputFile=open(fermis, 'w') #write to fermis, the original xml with the right path to the extended source\n\t\t\t\t\twith open(\"%s\" %fermisources,'r') as infile:\n\t\t\t\t\t\tfor line in infile:\n\t\t\t\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==False:\n\t\t\t\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\toutputFile.write(special1)\n\t\t\t\t\toutputFile.close()\n\t\t\t\t\t\t\t\t\t\n\n\n\t\t\t\n\t\toutputFile=open(inputmodel, 'w') #final xml file. contains the right path and the source info of \"your\" source.\n\t\twith open(fermis,'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\t\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\t\t\t\n\n\t\toutputFile.close()\n\t\n\t\twith open(\"%s_diffrsp.log\" % (identity), 'w') as outsyputFile: #run diffrsp if you have an extended source.\n\t\t\tsubprocess.call(['%s' %(cfg.pythoncommand),'gtdiffrsp.py', '%s' %(region_filtered),'%s' %(spacecraft), '%s' %inputmodel, '%s' %(response),'%s' %identity ],stdout=outsyputFile)\n\t\t\t\n\t\twith open(ExtendedList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\t\t\t\t\n\tif numberofextendedsources==0: #if there is no extended source\n\t\toutputFile=open('%s' %(inputmodel), 'w') #write to inputmodel, \"your\" source\n\t\twith open('%s' %(fermisources),'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\n\t\t\t\n\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\toutputFile.close()\n\tif numberofextendedsources>1:\n\t\twith open(OthersList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\n\tif numberofextendedsources==1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\\n\\\n \t%s\"%(numberofextendedsources,extendedsource))\n\t\toutsyputFile.close()\n\n\tif numberofextendedsources !=1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\" %(numberofextendedsources))\n\t\toutsyputFile.close()",
"def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml",
"def to_xml(self):\n xml_strings = ['<code_object name=\"%s\">' % self.name]\n xml_strings.append(' <type value=\"%s\" />' % self.object_type)\n xml_strings.append(' <source>')\n for source_line in self.source:\n xml_strings.append(source_line[1])\n xml_strings.append(' </source>')\n xml_strings.append('</code_object>')\n return \"\".join(xml_strings)",
"def _toFile(self):\n pass",
"def toGML(self):\n raise NotImplementedError",
"def addXSLTStyleSheet(self, content, URI):\n if self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] == None:\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] = []\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)\n else:\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)",
"def xml_path(self):\n return self.__xml_path",
"def generate_xml(self, provisioning):\n ET.SubElement(self.root, 'generator').text = __revision__\n ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n return self.provisioning2xml(provisioning)",
"def exportXml ( w, xml ):\n assert str ( type ( xml ) ) == \"<type 'str'>\"\n rawText = xml\n pattern = re.compile (r'[^\\S ]+')\n text = re.sub ( pattern, \"\", rawText )\n reparsed = MD.parseString ( text )\n w.write ( reparsed.toprettyxml ( indent = \"\\t\", encoding = \"UTF-8\" ) )",
"def toSBML(self):\n errors = self.document.checkConsistency()\n if errors > 0:\n for i in range(errors):\n print(\n self.document.getError(i).getSeverityAsString(),\n \": \",\n self.document.getError(i).getMessage(),\n )\n\n return libsbml.writeSBMLToString(self.document)"
] | [
"0.6366979",
"0.61544836",
"0.5839131",
"0.58340883",
"0.5812942",
"0.5640789",
"0.5603479",
"0.55815554",
"0.55431604",
"0.55276537",
"0.55154866",
"0.5513102",
"0.5510308",
"0.5458654",
"0.5451725",
"0.54285127",
"0.54037434",
"0.5307067",
"0.5298246",
"0.52886873",
"0.5272622",
"0.5271472",
"0.5232884",
"0.5201279",
"0.519453",
"0.5182671",
"0.5179153",
"0.5172932",
"0.5163209",
"0.5156673",
"0.5148088",
"0.51359093",
"0.5132218",
"0.51303387",
"0.5100232",
"0.50764483",
"0.5070601",
"0.5059149",
"0.50582504",
"0.5056313",
"0.5056309",
"0.5039356",
"0.5028861",
"0.5021943",
"0.5010669",
"0.50036734",
"0.5003039",
"0.49999213",
"0.49748772",
"0.49723393",
"0.49578944",
"0.49532372",
"0.49395603",
"0.4939085",
"0.48923746",
"0.48899695",
"0.48740843",
"0.48715433",
"0.48646557",
"0.48638257",
"0.4852056",
"0.4846309",
"0.48436296",
"0.48433435",
"0.48293883",
"0.4826439",
"0.48262388",
"0.4825601",
"0.48202866",
"0.48137426",
"0.48124427",
"0.4811109",
"0.48028645",
"0.48027924",
"0.47998756",
"0.4795888",
"0.4795888",
"0.47758362",
"0.4772382",
"0.4770035",
"0.4762882",
"0.47570086",
"0.47569758",
"0.4756163",
"0.4751184",
"0.4751131",
"0.47475907",
"0.4746994",
"0.47402462",
"0.47337463",
"0.47337046",
"0.47332537",
"0.47212258",
"0.4720437",
"0.47086617",
"0.47031793",
"0.4701611",
"0.46895015",
"0.46818498",
"0.46814537"
] | 0.5632317 | 6 |
Return XSL file test for data existance | def xslTestText(self):
return u'normalize-space(%s%s)' % (self.parentLevel * '../', self.name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def test_01_FindXml(self):",
"def test_input_output(self, filename):\n with open(sample_xml(filename), \"rb\") as xml_file:\n xml_output_expected = xml_file.read()\n root, doctype_dict = xmlio.parse(sample_xml(filename), return_doctype_dict=True)\n self.assertEqual(xmlio.output(root, None, doctype_dict), xml_output_expected)",
"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 test_check_if_output_file_exists():\n input_file = os.path.join(os.getcwd(), 'tests', 'input_test_file.docx')\n output_file = os.path.join(os.getcwd(), 'tests', 'output_test_file.txt')\n\n questions_parser = QuestionsParser()\n questions_parser.main(argv=['-i', input_file, '-o', output_file])\n assert os.path.exists(output_file)\n os.unlink(output_file)",
"def test_hasLocation(self):\n cases = [\n (self.test_eac + \"NE00601.xml\", False),\n (self.test_eac + \"NE00100.xml\", True),\n (self.test_eac + \"NE00201.xml\", True),\n (self.test_eac + \"NE01302.xml\", True),\n (self.test_eac + \"NE01101.xml\", False),\n (self.test_eac + \"NE00916.xml\", False),\n (self.test_eac + \"NE00201.xml\", True),\n ]\n for case in cases:\n source, expected = case\n doc = EacCpf.EacCpf(source,'http://www.example.com')\n self.assertNotEqual(doc, None)\n result = doc.hasLocation()\n self.assertNotEqual(result, None)\n self.assertEqual(result, expected)",
"def test_xml_files_with_missing_info():\n\n # Test when k is missing from constant type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/k_const.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when b is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/b_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_mod_arr.xml\"\n parser = XMLParser(xml_filename)",
"def test_does_validate_valid_xml_file(self):\n xml_file = join(\n getcwd(), 'testdata', 'newstest2019-defr-src-ts.de.FIXED.xml'\n )\n doc = valitest.ValidatableTestSet(xml_file)\n self.assertEqual(doc.setid, \"newstest2019\")\n self.assertEqual(doc.srclang, \"any\")",
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def testFilesExist(self):\n \n for year in range(2007,2013):\n self.assertTrue(os.path.exists(\"./IncomeHistogram_\"+ str(year)+\".pdf\"), \"A histogram didn't save to output.\")\n self.assertTrue(os.path.exists(\"./LogIncomeHistogram_\"+ str(year)+\".pdf\"), \"A histogram didn't save to output.\")\n self.assertTrue(os.path.exists(\"./IncomeBoxplot(log)_\"+ str(year)+\".pdf\"), \"A boxplot didn't save to output.\") \n self.assertTrue(os.path.exists(\"./results.txt\"), \"Results file doesn't exist.\")",
"def test_defaultFile(self):\n found = cesmEnvLib.checkFile(\"./test_checkXMLvar.py\", \"read\")\n self.assertTrue(found)",
"def test_xml_file(self):\n response = client.result(False, 'xml', 'unittest', file = 'test_file.csv')\n root = ET.fromstring(response)\n first_name = root[0][0][0].text\n self.assertEqual(first_name,'John', 'Should print John')\n nationality = '<nationality>' in response\n self.assertFalse(nationality, 'Nationality should not be present')",
"def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n # sprint(PrettyFormatAny.form(self.m_root_xml, 'A3-01-A - Entire Xml'))\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n # print(PrettyFormatAny.form(self.m_xml.controller_sect, 'A3-01-B - All Controllers Xml'))\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')\n # print(PrettyFormatAny.form(self.m_xml.controller, 'A3-01-C - First Controller Xml'))",
"def check_for_data():\n if not (os.path.exists(ep.get_test_data_path()) or os.path.exists(ep.get_dbn_weight_path())):\n return False\n return True",
"def test_case18(self):\n\n result = self.graph1.studentExists(\"student1\")\n\n self.assertTrue(result)",
"def test_getExistDates(self):\n cases = [\n (self.test_eac + \"NE01201.xml\",\"1858-01-01T00:00:00Z\",\"1935-08-21T00:00:00Z\"),\n (self.test_eac + \"NE00300.xml\",\"1960-01-01T00:00:00Z\",\"1977-12-31T00:00:00Z\"),\n (self.test_eac + \"NE01500.xml\",\"1981-01-01T00:00:00Z\",\"1981-12-31T00:00:00Z\")\n ]\n for case in cases:\n source, expected_from_date, expected_to_date = case\n doc = EacCpf.EacCpf(source, 'http://www.example.com')\n self.assertNotEqual(doc, None)\n fromDate, toDate = doc.getExistDates()\n self.assertEqual(fromDate, expected_from_date)\n self.assertEqual(toDate, expected_to_date)",
"def test_case17(self):\n\n result = self.graph1.studentExists(\"student5\")\n\n self.assertFalse(result)",
"def _check_deprecated_data_xml_node(self):\n xml_files = self.filter_files_ext('xml')\n self.msg_args = []\n for xml_file in xml_files:\n doc = self.parse_xml(os.path.join(self.module_path, xml_file))\n odoo_nodes = doc.xpath(\"/odoo\") \\\n if not isinstance(doc, string_types) else []\n children, data_node = ((odoo_nodes[0].getchildren(),\n odoo_nodes[0].findall('data'))\n if odoo_nodes else ([], []))\n if len(children) == 1 and len(data_node) == 1:\n lineno = odoo_nodes[0].sourceline\n self.msg_args.append((\"%s:%s\" % (xml_file, lineno)))\n if self.msg_args:\n return False\n return True",
"def test_getData(self):\n cases = [\n self.test_eac + 'NE01201.xml',\n self.test_eac + 'NE00201.xml',\n self.test_eac + 'NE00300.xml',\n self.test_eac + 'NE00500.xml',\n ]\n for case in cases:\n doc = EacCpf.EacCpf(case, 'http://www.example.com/metadata.xml', 'http://www.example.com/presentation.html')\n self.assertNotEqual(doc, None)\n result = doc.getData()\n self.assertNotEqual(result, None)\n self.assertGreater(len(result), 0)",
"def _CheckFileExistsWithData(self, logs, graph):\n self.assertTrue(graph in logs, 'File %s was not output.' % graph)\n self.assertTrue(logs[graph], 'File %s did not contain data.' % graph)",
"def checkAllFilesGenerated(self):\n root = get_exhale_root(self)\n containmentFolder = self.getAbsContainmentFolder()\n for node in root.all_nodes:\n if node.kind in [\"enumvalue\", \"group\"]:\n continue\n gen_file_path = os.path.join(containmentFolder, node.file_name)\n self.assertTrue(\n os.path.isfile(gen_file_path),\n \"File for {kind} node with refid=[{refid}] not generated to [{gen_file_path}]!\".format(\n kind=node.kind, refid=node.refid, gen_file_path=gen_file_path\n )\n )",
"def test_assemble_xml_file_A1(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write_blank(\"A1\", None)\n\n worksheet.write_blank(\"C2\", None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def resultExist(probName,algoName,fitName,inst,s,c,n,k,q,w,m,t,e):\n if probName == 'NKQ':\n nameOfF = './result/'+probName+'-'+algoName+'-F'+fitName+'-M'+m+'-I'+str(inst)+'-S'+str(s)+'-W'+str(w)+'-N'+str(n)+'-K'+str(k)+'-C'+str(c)+'-Q'+str(q)+'-T'+str(t)+'-E'+str(e)+'.txt'\n elif probName == 'NK' or probName == 'NonNK':\n nameOfF = './result/'+probName+'-'+algoName+'-F'+fitName+'-C'+str(c)+'-I'+str(inst)+'-S'+str(s)+'-W'+str(w)+'-N'+str(n)+'-K'+str(k)+'-E'+str(e)+'.txt'\n\n if os.path.isfile(nameOfF)==True:\n print nameOfF, 'exists!!!'\n return os.path.isfile(nameOfF)",
"def test_exists_false(self):\n self.assertFalse(Sample.exists('Not_a_Sample', self.sample_template))",
"def test_non_regression(self):\n main(\"Source_mobile.xml\", [[\"engine\", \"A320.xml\", \"A320.csv\"]], \"Resultat.xml\", gui=False)\n compare_xml_results(\"Resultat.xml\", \"Reference.xml\", self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'parameter_estimation':\n check = True\n self.assertTrue(check)",
"def test_ifFileExists():\n for name in config.toTest:\n testConfig = dynamicallyLoadModule(name)\n if \"file\" in testConfig.config and \"file_locations\" in testConfig.config:\n print \"File In Location: \"+ testConfig.config[\"name\"]\n yield assertionFunctions.checkIfFileExistsInPossibleLocations, testConfig.config\n elif \"file\" in testConfig.config:\n print \"File: \"+ testConfig.config[\"name\"]\n yield assertionFunctions.checkIfFileExists, testConfig.config",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'Time-Course':\n check = True\n self.assertTrue(check)",
"def test_exists_false(self):\n self.assertFalse(PrepSample.exists('Not_a_Sample', self.prep_template))",
"def test_exists_true(self):\n self.assertTrue(SampleTemplate.exists(self.test_study.id))",
"def test_exists_false(self):\n self.assertFalse(SampleTemplate.exists(self.new_study.id))",
"def test_xml_exist(xml_parser):\n\n assert xml_parser.get_dict()",
"def are_evaluations_created(path, number_of_evaluations):\n evaluation_ids = []\n try:\n with open(\"%s%sevaluations\" % (path, os.sep)) as evaluations_file:\n for line in evaluations_file:\n evaluation = line.strip()\n try:\n evaluation_id = bigml.api.get_evaluation_id(evaluation)\n evaluation_ids.append(evaluation_id)\n except ValueError:\n return False, evaluation_ids\n if len(evaluation_ids) == number_of_evaluations:\n return True, evaluation_ids\n else:\n return False, evaluation_ids\n except IOError:\n return False, evaluation_ids",
"def validate(file_in) :\n\tname = str(file_in.name)\n\tif name[-4:] != \".xml\" and name[-4:] != \".XML\" :\n\t\treturn False\n\txsd = open('wcdb/WorldCrises.xsd.xml', 'r')\n\txmlFile = open('wcdb/temp.xml', 'w')\n\txmlFile.write(file_in.read())\n\txmlFile = open('wcdb/temp.xml', 'r')\n\ttry:\n\t\tpsvi = pyxsval.parseAndValidate(\"wcdb/temp.xml\",\n\t\t\t\"wcdb/WorldCrises.xsd.xml\", xmlIfClass=pyxsval.XMLIF_ELEMENTTREE)\n\t\ttree = psvi.getTree()\n\texcept pyxsval.XsvalError, e:\n\t\treturn 'Validation aborted. ' + str(e)\n\texcept GenXmlIfError, e:\n\t\treturn 'Parsing aborted. ' + str(e)\n\texcept Exception as e:\n\t\t# catch all\n\t\treturn 'Exception. ' + str(e)\n\t#handle invalid case\n\treturn tree",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def example_xml_file43():\n return load_xml('datacite-v4.3-full-example.xml')",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def _check_file_exists_helper(self, report_path, filename):\n\n if not check_data_exists(report_path, [filename]):\n raise AssertionError(\n \"{} does not exist in location {}\".format(\n filename, report_path\n )\n )",
"def _check_xml_syntax_error(self):\n self.msg_args = []\n for xml_file in self.filter_files_ext('xml', relpath=True):\n result = self.parse_xml(os.path.join(self.module_path, xml_file))\n if isinstance(result, string_types):\n self.msg_args.append((\n xml_file, result.strip('\\n').replace('\\n', '|')))\n if self.msg_args:\n return False\n return True",
"def verified_excel_file(store, institute_list, temp_excel_dir):\n document_lines = []\n written_files = 0\n today = datetime.datetime.now().strftime('%Y-%m-%d')\n LOG.info('Creating verified variant document..')\n\n for cust in institute_list:\n verif_vars = store.verified(institute_id=cust)\n LOG.info('Found {} verified variants for customer {}'.format(len(verif_vars), cust))\n\n if not verif_vars:\n continue\n unique_callers = set()\n for var_type, var_callers in CALLERS.items():\n for caller in var_callers:\n unique_callers.add(caller.get('id'))\n cust_verified = export_verified_variants(verif_vars, unique_callers)\n\n document_name = '.'.join([cust, '_verified_variants', today]) + '.xlsx'\n workbook = Workbook(os.path.join(temp_excel_dir,document_name))\n Report_Sheet = workbook.add_worksheet()\n\n # Write the column header\n row = 0\n for col,field in enumerate(VERIFIED_VARIANTS_HEADER + list(unique_callers)):\n Report_Sheet.write(row,col,field)\n\n # Write variant lines, after header (start at line 1)\n for row, line in enumerate(cust_verified,1): # each line becomes a row in the document\n for col, field in enumerate(line): # each field in line becomes a cell\n Report_Sheet.write(row,col,field)\n workbook.close()\n\n if os.path.exists(os.path.join(temp_excel_dir,document_name)):\n written_files += 1\n\n return written_files",
"def datafileexist(filename):\n filePath = os.path.join(pathtofolder(), \"datas\", filename)\n fileFormat = '.csv'\n return os.path.exists(f'{filePath+fileFormat}')",
"def _valid_rootnode_file(self, xml_filepath: str) -> bool:\n\t\troot_name: str = get_xml_file(xml_filepath).tag\n\t\t# Iterate over RootNodes\n\t\tfor rootnode in self.root_nodes:\n\t\t\t# Check is filenames are identical\n\t\t\tif root_name == rootnode.name:\n\t\t\t\trootnode.subfiles.add(xml_filepath)\n\t\t\t\t# Return False, match is found\n\t\t\t\treturn False\n\n\t\t# Return True if no match found.\n\t\treturn True",
"def test_get_workflow_definition_xml(self):\n pass",
"def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')",
"def test_validate_invalid(self):\r\n self.assertEqual(get_tree_and_validate(self.invalid_xml, open(self.SCHEMA, 'r').read()), 0)",
"def test_schema_exists(self):\n return exclusions.open()",
"def example_xml_file41():\n return load_xml('datacite-v4.1-full-example.xml')",
"def test_generate_report():\n # Calling helper function to create data\n data = helper_create_data()\n cat_vars = ['C1', 'C2', 'C3', 'C4']\n num_vars = ['N1', 'N2', 'N3']\n\n # Positive test case: Checking whether the function runs properly or not\n assert eda.generate_report(data, cat_vars, num_vars), \\\n \"Expected True but False returned\"\n\n # Negative test case: Checking whether the function returns False\n # fr wrong output\n assert not eda.generate_report(data, cat_vars, \"String Input\"), \\\n \"Expected False but True returned\"",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'profile_likelihood':\n check = True\n self.assertTrue(check)",
"def test_xml_direct(self): \n response = client.result(True, 'xml', 'unittest', test_data = self.test_data)\n root = ET.fromstring(response)\n first_name = root[0][0][0].text\n self.assertEqual(first_name,'John', 'Should print John')\n nationality = '<nationality>' in response\n self.assertFalse(nationality, 'Nationality should not be present')",
"def check_xshear_output(self):\n lens_nchunk=self['lens_conf']['nchunk']\n tilenames=scat.get_tilenames(self['source_conf']['scat_table'])\n\n ntile=len(tilenames)\n for lens_chunk in xrange(lens_nchunk):\n print(\" checking chunk: %d/%d\" % (lens_chunk+1, lens_nchunk))\n for i,tilename in enumerate(tilenames):\n # first check if this source catalog exists\n if self._scat_exists(tilename):\n job=XShearWQJob(self['run'],\n lens_chunk,\n tilename)\n info=job.get_info()\n if not os.path.exists(info['output_file']):\n print(\"missing output:\",info['output_file'])",
"def test_assemble_xml_file(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n worksheet.str_table = SharedStringTable()\n worksheet.select()\n cell_format1 = Format({\"xf_index\": 1})\n cell_format2 = Format({\"xf_index\": 2})\n\n worksheet.merge_range(\"B3:C3\", \"Foo\", cell_format1)\n worksheet.merge_range(\"A2:D2\", \"\", cell_format2)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"A2:D3\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"1:4\">\n <c r=\"A2\" s=\"2\"/>\n <c r=\"B2\" s=\"2\"/>\n <c r=\"C2\" s=\"2\"/>\n <c r=\"D2\" s=\"2\"/>\n </row>\n <row r=\"3\" spans=\"1:4\">\n <c r=\"B3\" s=\"1\" t=\"s\">\n <v>0</v>\n </c>\n <c r=\"C3\" s=\"1\"/>\n </row>\n </sheetData>\n <mergeCells count=\"2\">\n <mergeCell ref=\"B3:C3\"/>\n <mergeCell ref=\"A2:D2\"/>\n </mergeCells>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def xslTestText(self):\n return u'normalize-space(ancestor::*/%s)' % self.name",
"def test_exist(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n MetadataTemplate.exists(self.study)",
"def missing_results(self):\n self.calc_progress()\n\n def no_result_exists(x):\n return not os.path.isfile(\n os.path.join(self.location, \"results\", RSLT_NM.format(x))\n )\n\n return tuple(filter(no_result_exists, range(1, self.num_batches + 1)))",
"def ruleset_create_success_hr():\n with open(\n os.path.join(TEST_DATA_DIRECTORY, \"create_ruleset_success_hr.md\")\n ) as file:\n f = file.read()\n return f",
"def test_validation_no_schema(self):\n TT = TEITransformer(scenario='drama')\n tei_path = \"tests/test_user_schema/tei.xml\"\n TT.load_tei(tei_path)\n with self.assertRaises(ValueError):\n TT.transform(output_format=\"html\")",
"def example_xml_file42():\n return load_xml('datacite-v4.2-full-example.xml')",
"def xslTestText(self):\n return u'normalize-space(child::*/%s)' % self.name",
"def validate_file(self):\n print \"\\n******\"\n print \" Done creating file. Validation messages follow.\"\n missing_nodes = {'group': [], 'dataset': []}\n custom_nodes = {'group': [], 'dataset': []}\n for ns in self.id_lookups:\n for id in self.id_lookups[ns]:\n for path in self.id_lookups[ns][id]:\n qty = self.id_lookups[ns][id][path]['qty']\n type = self.id_lookups[ns][id][path]['type']\n count = len(self.id_lookups[ns][id][path]['created'])\n if qty in ('!', '+') and count == 0:\n missing_nodes[type].append(\"%s:%s/%s\" % (ns, path, id))\n for path, node_list in self.all_nodes.iteritems():\n for root_node in node_list:\n self.validate_nodes(root_node, missing_nodes, custom_nodes)\n self.report_problems(missing_nodes, \"missing\")\n self.report_problems(custom_nodes, \"custom\")\n if self.custom_attributes:\n count = len(self.custom_attributes)\n print \"%i nodes with custom attributes\" % len(self.custom_attributes)\n if count > 20:\n print \"Only first 20 shown;\"\n names = self.custom_attributes.keys()[0:min(20, count)]\n nlist = []\n for name in names:\n nlist.append(name+ \"->\" +str(self.custom_attributes[name]))\n print nlist\n else:\n print \"No custom attributes. Good.\"",
"def generate_expected_file(self, expected_file, xml_name):\n\t\tlogging.info('Gerando arquivo de documentos esperados')\n\t\tcontent = self.read_xml(xml_name)\n\n\t\twith open(expected_file, 'w', newline='') as csvfile:\n\t\t\tfieldnames = ['QueryNumber', 'DocNumber', 'DocVotes']\n\t\t\twriter = csv.DictWriter(csvfile, fieldnames=fieldnames)\n\n\t\t\twriter.writeheader()\n\t\t\tfor index in range(0, len(content['QueryNumber'])):\n\t\t\t\tcount_results = 0\n\t\t\t\tlogging.info('Escrevendo documentos da consulta '+str(index+1)+'/'+str(len(content['QueryNumber'])))\n\t\t\t\tfor result in content['Records'][index]:\n\t\t\t\t\twriter.writerow({'QueryNumber': content['QueryNumber'][index], 'DocNumber': result[0], \n\t\t\t\t\t\t\t\t\t 'DocVotes': result[1]})\n\t\t\t\t\tcount_results += 1\n\t\t\t\t\tif count_results == int(content['Results'][index]): break",
"def example_xml_file():\n return load_xml('datacite-v3.1-full-example.xml')",
"def test_predicate1(self):\n xpb = XPathBuilder()\n xp = xpb.action.source[xpb.attr('project') == 'bar']\n exp = '/action/source[@project = \"bar\"]'\n self.assertEqual(xp.tostring(), exp)",
"def test_xml_safety_flag(self):\r\n\r\n self._setstaff_login()\r\n response = self._add_edx4edx()\r\n self.assertIn('GIT_IMPORT_WITH_XMLMODULESTORE', response.content)\r\n\r\n def_ms = modulestore()\r\n course = def_ms.courses.get('{0}/edx4edx_lite'.format(\r\n os.path.abspath(settings.DATA_DIR)), None)\r\n self.assertIsNone(course)",
"def test_incomplete_xml(self):\n self.__opener.contents = '<Report></Report>>'\n self.assertEqual(-1, self.__uft.failed_tests('url'))",
"def check_data():\n check_docs(\"Training\")\n check_docs(\"dev\")\n check_docs(\"Test\")",
"def is_good_enough_xml(self, resp):\n content_type = resp.headers['Content-Type'].lower()\n \n return (resp.status_code == 200 \n and content_type is not None \n and content_type.find('xml') > -1)",
"def test_XmlDump_compare_single(self):\n self._compare_variants(False)",
"def sniff( self, filename ):\n\n f = open( filename, \"r\" )\n firstlines = \"\".join( f.readlines(5) )\n f.close()\n\n if \"phyloxml\" in firstlines:\n return True\n return False",
"def _run_test_and_get_xml(self, flag):\n\n xml_fhandle, xml_fname = tempfile.mkstemp()\n os.close(xml_fhandle)\n\n try:\n binary = self._get_helper()\n args = [binary, flag, '--xml_output_file=%s' % xml_fname]\n ret = subprocess.call(args)\n self.assertEqual(ret, 0)\n\n xml = ElementTree.parse(xml_fname).getroot()\n finally:\n os.remove(xml_fname)\n\n return xml",
"def load_data_from_xsl(file_name):\n\tnlp_data = pd.read_excel(file_name, sheet_name=0, header=0, usecols=[1, 2, 3],\n\t converters={'bug_id': str, 'summary': str, 'description': str})\n\tnlp_data.fillna(' ', inplace=True)\n\n\t# nlp_data['description'] = nlp_data['description'].map(lambda x: clean_str(x+''))\n\n\treturn nlp_data",
"def test_predicate2(self):\n xpb = XPathBuilder()\n xp = xpb.action.source.where(xpb.attr('project').equals('bar'))\n exp = '/action/source[@project = \"bar\"]'\n self.assertEqual(xp.tostring(), exp)",
"def verifyFileExists(self, fileDir, fileName):\n # check that file exists\n fpath = fileDir.child(fileName)\n self.assertTrue(fpath.exists())\n\n # check that the output files have some content\n fcontents = fpath.getContent()\n self.assertTrue(len(fcontents) > 0)\n\n # check that the html files are at least html-ish\n # this is not a terribly rigorous check\n if fpath.path.endswith(\".html\"):\n self.assertIn(b\"<body\", fcontents)",
"def evaluate(self, xml_gold_path, xml_output_path):\n\n # Go through all files in xml_gold_path directory\n for file in os.listdir(xml_gold_path):\n\n # Set path to file\n file = xml_gold_path+file\n\n # Open files only, ignore subdirectories\n if os.path.isfile(file) and file.lower().endswith('.xml'):\n\n # Open xml files\n chapter_input_gold = open(file, 'r', encoding='utf8')\n chapter_input_test = open(xml_output_path+os.path.split(file)[-1], 'r', encoding='utf8')\n\n # Check if filenams are the same\n chapter_input_gold_name = os.path.split(chapter_input_gold.name)[-1]\n chapter_input_test_name = os.path.split(chapter_input_test.name)[-1]\n\n if chapter_input_gold_name == chapter_input_test_name:\n\n # Console log\n chapter_input_gold_name = chapter_input_gold.name\n chapter_input_test_name = chapter_input_test.name\n #print('Calculating score for: ' + chapter_input_gold_name + ' and: ' + chapter_input_test_name)\n\n # Process xml input file with BeautifulSoup\n chapter_input_gold = BeautifulSoup(chapter_input_gold, 'xml')\n chapter_input_test = BeautifulSoup(chapter_input_test, 'xml')\n\n # Empty variables for collecting Target scores\n target_precision_scores = 0\n target_recall_scores = 0\n target_f1_scores = 0\n target_jaccard_scores = 0\n\n # Empty variables for collecting Focus scores\n focus_precision_scores = 0\n focus_recall_scores = 0\n focus_f1_scores = 0\n focus_jaccard_scores = 0\n\n # Empty variables for collecting Negated scores\n negated_precision_scores = 0\n negated_recall_scores = 0\n negated_f1_scores = 0\n negated_jaccard_scores = 0\n\n # Empty variables for collecting Scope scores\n scope_precision_scores = 0\n scope_recall_scores = 0\n scope_f1_scores = 0\n scope_jaccard_scores = 0\n\n # Count sentences and frames\n sentence_count = 0\n gold_frames_count = 0\n test_frames_count = 0\n\n scope_gold_frames_count = 0\n #scope_test_frames_count = 0\n\n # Find all Gold and Test Sentences\n sentences_gold = chapter_input_gold.find_all('s')\n sentences_test = chapter_input_test.find_all('s')\n\n #targets_gold = chapter_input_gold.find_all('target')\n #targets_test = chapter_input_test.find_all('target')\n\n scope_gold_frames = chapter_input_gold.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_frames_count = len(scope_gold_frames)\n\n scope_test_frames = chapter_input_test.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_frames_count = len(scope_test_frames)\n\n # Exit if number of sentences != between Gold and Test files\n if len(sentences_gold) != len(sentences_test):\n raise SystemExit(print('Number of sentences between Gold and Test files does not match.\\nGold:',\n len(sentences_gold), 'Test:', len(sentences_test)))\n\n # Zip Gold and Test Sentences\n for s_gold, s_test in zip(sentences_gold, sentences_test):\n\n sentence_count = sentence_count + 1\n\n gold_frames = s_gold.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n test_frames = s_test.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n\n gold_frames_count = gold_frames_count + len(gold_frames)\n test_frames_count = test_frames_count + len(test_frames)\n\n for item in zip(gold_frames, test_frames):\n\n #print('\\n=========')\n #print('\\nFrame:', item[0].get('id'))\n\n target_gold_list = []\n target_test_list = []\n\n focus_gold_list = []\n focus_test_list = []\n\n negated_gold_list = []\n negated_test_list = []\n\n scope_gold_list = []\n scope_test_list = []\n\n # Flatten a nested list of fenodes\n def flatten(nested_list):\n \"\"\" Flatten a nested list of fenodes \"\"\"\n t_l = []\n for i in nested_list:\n if not isinstance(i, list):\n t_l.append(i)\n else:\n t_l.extend(flatten(i))\n return t_l\n\n # Target\n if item[0].find('target'):\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n\n try:\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n except:\n target_test_word = ''\n\n elif item[1].find('target'):\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n\n try:\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n except:\n target_gold_word = ''\n\n target_gold_list.append(target_gold_word)\n target_test_list.append(target_test_word)\n\n # Sort lists\n sorted_target_gold_list = sorted(flatten(target_gold_list))\n sorted_target_test_list = sorted(flatten(target_test_list))\n\n #print('\\nTarget [Gold]:', sorted_target_gold_list)\n #print('Target [Test]:', sorted_target_test_list)\n\n\n # Focus\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except:\n focus_gold_word = ''\n if item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n else:\n focus_test_word = ''\n\n elif item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n try:\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except AttributeError:\n focus_gold_word = ''\n else:\n focus_gold_word = ''\n\n focus_gold_list.append(focus_gold_word)\n focus_test_list.append(focus_test_word)\n\n # Sort lists\n sorted_focus_gold_list = sorted(flatten(focus_gold_list))\n sorted_focus_test_list = sorted(flatten(focus_test_list))\n\n #print('\\nFocus [Gold]:', sorted_focus_gold_list)\n #print('Focus [Test]:', sorted_focus_test_list)\n\n\n # Negated\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n if item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n else:\n negated_test_word = ''\n\n elif item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n else:\n negated_gold_word = ''\n else:\n negated_test_word = ''\n negated_gold_word = ''\n\n negated_gold_list.append(negated_gold_word)\n negated_test_list.append(negated_test_word)\n\n # Sort lists\n sorted_negated_gold_list = sorted(flatten(negated_gold_list))\n sorted_negated_test_list = sorted(flatten(negated_test_list))\n\n #print('\\nNegated [Gold]:', sorted_negated_gold_list)\n #print('Negated [Test]:', sorted_negated_test_list)\n\n\n # Resolve Terminals if Scope on a complex graph\n def resolve_non_terminals(idref):\n \"\"\" This function resolves a complex gold graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_gold.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_gold.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_gold.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_gold.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n def resolve_non_terminals_test(idref):\n \"\"\" This function resolves a complex test graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_test.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_test.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_test.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_test.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n # Scope\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[0].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n\n if item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n elif s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n scope_test_list.append('')\n\n elif item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n if s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n pass\n\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n else:\n scope_gold_list.append('')\n\n # Sort lists\n sorted_scope_gold_list = sorted(flatten(scope_gold_list))\n sorted_scope_test_list = sorted(flatten(scope_test_list))\n\n #print('\\nScope [Gold]:', sorted_scope_gold_list)\n #print('Scope [Test]:', sorted_scope_test_list)\n\n # If lists are same length, check if items are same\n if len(sorted_scope_gold_list) == len(sorted_scope_test_list):\n sorted_scope_test_list_intersection = set(sorted_scope_gold_list).intersection(sorted_scope_test_list)\n sorted_scope_test_list_intersection = list(sorted_scope_test_list_intersection)\n if len(sorted_scope_test_list_intersection) < len(sorted_scope_test_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_test_list_intersection)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list_intersection.append('')\n empty_element = empty_element + 1\n \n sorted_scope_test_list = sorted_scope_test_list_intersection\n\n # If lists are different lengths, add empty elements\n elif len(sorted_scope_gold_list) > len(sorted_scope_test_list):\n difference = len(sorted_scope_gold_list) - len(sorted_scope_test_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list.append('')\n empty_element = empty_element + 1\n\n elif len(sorted_scope_test_list) > len(sorted_scope_gold_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_gold_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_gold_list.append('')\n empty_element = empty_element + 1\n\n\n # Align items in the lists for sklearn, set 1 for matched items, else set 0\n sorted_target_gold_list_normalized = [1 if element in sorted_target_gold_list and not element == \"\" else 0 for element in sorted_target_gold_list]\n sorted_target_test_list_normalized = [1 if element in sorted_target_gold_list else 0 for element in sorted_target_test_list]\n\n sorted_focus_gold_list_normalized = [1 if element in sorted_focus_gold_list and not element == \"\" else 0 for element in sorted_focus_gold_list]\n sorted_focus_test_list_normalized = [1 if element in sorted_focus_gold_list else 0 for element in sorted_focus_test_list]\n\n sorted_negated_gold_list_normalized = [1 if element in sorted_negated_gold_list and not element == \"\" else 0 for element in sorted_negated_gold_list]\n sorted_negated_test_list_normalized = [1 if element in sorted_negated_gold_list else 0 for element in sorted_negated_test_list]\n\n sorted_scope_gold_list_normalized = [1 if element in sorted_scope_gold_list and not element == \"\" else 0 for element in sorted_scope_gold_list]\n sorted_scope_test_list_normalized = [1 if element in sorted_scope_gold_list else 1 if not element == \"\" else 0 for element in sorted_scope_test_list]\n\n #print(sorted_scope_gold_list_normalized)\n #print(sorted_scope_test_list_normalized)\n\n\n # Sklearn calculations\n #target_precision_scores = target_precision_scores + precision_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_recall_scores = target_recall_scores + recall_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n target_f1_scores = target_f1_scores + f1_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_jaccard_scores = target_jaccard_scores + jaccard_similarity_score(sorted_target_gold_list, sorted_target_test_list)\n\n #focus_precision_scores = focus_precision_scores + precision_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_recall_scores = focus_recall_scores + recall_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n focus_f1_scores = focus_f1_scores + f1_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_jaccard_scores = focus_jaccard_scores + jaccard_similarity_score(sorted_focus_gold_list, sorted_focus_test_list)\n\n #negated_precision_scores = negated_precision_scores + precision_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_recall_scores = negated_recall_scores + recall_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n negated_f1_scores = negated_f1_scores + f1_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_jaccard_scores = negated_jaccard_scores + jaccard_similarity_score(sorted_negated_gold_list, sorted_negated_test_list)\n\n scope_precision_scores = scope_precision_scores + precision_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_recall_scores = scope_recall_scores + recall_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_f1_scores = scope_f1_scores + f1_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_jaccard_scores = scope_jaccard_scores + jaccard_similarity_score(sorted_scope_gold_list, sorted_scope_test_list)\n\n\n print('\\n=============================')\n print('====== EVALUATION for:', chapter_input_test_name, '======')\n print('Total Sentences:', sentence_count,\n '\\nNegation Gold frames:', gold_frames_count,\n '\\nNegation Test frames:', test_frames_count, '\\n')\n\n print('----- CUEWORDS -----')\n #print('Precision:\\t', target_precision_scores / gold_frames_count)\n #print('Recall:\\t', target_recall_scores / gold_frames_count)\n print('F1 score:\\t', target_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', target_jaccard_scores / gold_frames_count)\n\n print('\\n----- FOCUS -----')\n #print('Precision:\\t', focus_precision_scores / gold_frames_count)\n #print('Recall:\\t', focus_recall_scores / gold_frames_count)\n print('F1 score:\\t', focus_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', focus_jaccard_scores / gold_frames_count)\n\n print('\\n----- NEGATED -----')\n #print('Precision:\\t', negated_precision_scores / gold_frames_count)\n #print('Recall:\\t', negated_recall_scores / gold_frames_count)\n print('F1 score:\\t', negated_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', negated_jaccard_scores / gold_frames_count)\n\n print('\\n----- SCOPE -----\\nScope Gold frames:', scope_gold_frames_count, '\\nScope Test frames:', scope_test_frames_count, '\\n')\n print('Precision:\\t', scope_precision_scores / scope_test_frames_count)\n print('Recall:\\t', scope_recall_scores / scope_test_frames_count)\n print('F1 score:\\t', scope_f1_scores / scope_test_frames_count)\n print('Jaccard similarity:\\t', scope_jaccard_scores / scope_test_frames_count)\n\n print('Done!')",
"def is_failed(doc_dict):\n\n results_xml = os.listdir(os.path.join(config.TOC_OCR_RESULTS, doc_dict['name']))\n \n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Results directory contents for {os.path.join(config.TOC_OCR_RESULTS,doc_dict['name'])}:\")\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): {results_xml}\")\n\n if len(results_xml) == 0:\n raise IOError(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} ERROR (OCR): Result XML files not found in {os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'])}...\")\n\n for item in results_xml:\n # open XML file and parse it as an ordered dict\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Found result file: {item}\")\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Opening result file {os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'], item)}...\")\n with open(os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'], item), mode='rb') as f:\n xml = xmltodict.parse(xml_input=f)\n # print(\"OCR XML: \", xml)\n\n # find XmlResult in the ordered dictionary created by parsing XML file\n result_generator = utility.find_item_in_response(data=xml, key='@IsFailed')\n\n # find IsFailed property in XmlResult ordered dict\n for found_value in result_generator:\n # is_failed_generator = utility.find_item_in_response(data=result, key='@IsFailed')\n #\n # # check the value of IsFailed property\n # for found_value in is_failed_generator:\n # print(\"IS FAILED: \", found_value)\n if found_value == 'true':\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): TRUE RESULT FOUND VALUE: {found_value}\")\n return True\n else:\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR ): FALSE RESULT FOUND VALUE: {found_value}\")\n return False",
"def test_install_set_existing(self):\n expected = copy.deepcopy(test_xdata)\n expected.find(\"Text\").text = \"Changed content\"\n self._install([lxml.etree.Element(\"Set\", path=\"Test/Text/#text\",\n value=\"Changed content\")],\n expected)",
"def test_load():\n t = PandasTransformer()\n os.makedirs(target_dir, exist_ok=True)\n t.parse(os.path.join(resource_dir, \"x1n.csv\"))\n t.parse(os.path.join(resource_dir, \"x1e.csv\"))\n t.report()\n t.save(os.path.join(target_dir, 'x1copy'))\n # w = GraphMLTransformer(t.graph)\n # w.save(os.path.join(target_dir, \"x1n.graphml\"))",
"def test_write(self):\n cases = {\n self.test_eac + \"NE00401.xml\": True,\n self.test_eac + \"NE01501.xml\": False,\n self.test_eac + \"NE01302.xml\": True,\n }\n metadata_url = 'http://www.example.com/metadata.xml'\n presentation_url = 'http://www.example.com/presentation.html'\n for case in cases:\n doc = EacCpf.EacCpf(case, metadata_url, presentation_url)\n self.assertNotEqual(doc, None)\n path = doc.write(self.temp)\n self.assertEquals(os.path.exists(path), True)\n # read the file and try to extract the attributes\n try:\n tree = etree.parse(path)\n ns = {\n EacCpf.DOC_KEY: EacCpf.DOC_NS,\n EacCpf.ESRC_KEY: EacCpf.ESRC_NS,\n }\n # get the url to the metadata file\n metadata = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":metadata\", namespaces=ns)\n self.assertNotEqual(metadata, None)\n self.assertEqual(metadata[0], metadata_url)\n # get the url to the presentation file\n presentation = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":presentation\", namespaces=ns)\n self.assertNotEqual(presentation, None)\n self.assertEqual(presentation[0], presentation_url)\n # get the url to the source file\n source = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":source\", namespaces=ns)\n self.assertNotEqual(source, None)\n self.assertEqual(source[0], case)\n except:\n msg = \"Failed to complete parsing of {0}\".format(case)\n self.log.error(msg, exc_info=True)\n self.fail(msg)",
"def recipe12_8():\n from xml.parsers.xmlproc import utils, xmlval, xmldtd\n def validate_xml_file(xml_filename, app=None, dtd_filename=None):\n # build validating parser object with appropriate error handler\n parser=xmlval.Validator()\n parser.set_error_handler(utils.ErrorPrinter(parser))\n if dtd_filename is None:\n # DTD fiel specified, laod and set it as the DTD to use\n dtd=xmldtd.load_dtd(dtd_filename)\n parser.val.dtd = parser.dtd = parser.ent = dtd\n if app is not None:\n # Application processing requested, set application object\n parser.set_application(app)\n # everything being set correctly, finally perform the parsing\n parser.parse_resource(xml_filename) \n # if XML data is in a string s, use instead\n # parser.feed(s)\n # parser.close(s)",
"def test_missing_shx(self):\n path = os.path.join(BASE_DIR, \"tests\", \"fixtures\", \"missing_shx.zip\")\n zip_file = zipfile.ZipFile(path)\n\n with self.assertRaises(MissingFiles) as context:\n get_shapefile(zip_file)\n the_exception = context.exception\n self.assertEqual(MISSING_FILE, the_exception.message)",
"def data_available(dataset_name=None):\r\n for file_list in data_resources[dataset_name]['files']:\r\n for file in file_list:\r\n if not os.path.exists(os.path.join(data_path, dataset_name, file)):\r\n return False\r\n return True",
"def test_exists_false(self):\n self.assertFalse(PrepTemplate.exists(2))",
"def create_xml_regression(lfiles, lsbj, foxml):\n\n impl = xml.dom.minidom.getDOMImplementation()\n doc = impl.createDocument(None, \"some_tag\", None)\n top_element = doc.documentElement\n\n e = doc.createElement('subject')\n e.setAttribute('id', 'case')\n\n for i, fn in enumerate(lfiles):\n v = doc.createElement('visit')\n v.setAttribute('id', \"subj{}\".format(i))\n\n f = doc.createElement('filename')\n f.setAttribute('object_id', \"face\")\n t = doc.createTextNode(fn)\n f.appendChild(t)\n\n a = doc.createElement('age')\n x = doc.createTextNode(str(lsbj[i][\"age\"]))\n a.appendChild(x)\n\n\n v.appendChild(f)\n v.appendChild(a)\n e.appendChild(v)\n\n top_element.appendChild(e)\n\n with open(foxml, \"w\") as fo:\n fo.write(doc.toprettyxml())",
"def xslTestText(self):\n return u'normalize-space(./%s)' % self.name",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def isExist(data):\n return True/False",
"def test_output_exists():\n global out_dir, cor_dir\n assert(path.exists(path.join(out_dir, 'oshea_similarity.json')))",
"def test_resourcesXML(self):\n fileName = self.mktemp()\n fp = FilePath(fileName)\n fp.setContent(oldResourcesFormat)\n upgradeResourcesXML(fp)\n self.assertEquals(fp.getContent(), newResourcesFormat)",
"def test_generate_sample_sheet(self):\n pass",
"def test_negative_file_and_xml(self):\n xml_object = ET.parse(self.xmlfile)\n with self.assertRaises((IOError, OSError)):\n glymur.jp2box.XMLBox(filename=self.xmlfile, xml=xml_object)",
"def example_xml43(example_xml_file41):\n return etree.fromstring(example_xml_file43.encode('utf-8'))",
"def test_duplicate_standard_name(self):\n # Setup test\n infilename = os.path.join(_SAMPLE_FILES_DIR, \"reg_good_simple.xml\")\n filename = os.path.join(_TMP_DIR, \"reg_duplicate_standard_name.xml\")\n out_source_name = \"physics_types_duplicate_standard_name\"\n out_source = os.path.join(_TMP_DIR, out_source_name + '.F90')\n out_meta = os.path.join(_TMP_DIR, out_source_name + '.meta')\n remove_files([out_source, out_meta])\n tree, root = read_xml_file(infilename)\n # Change output filename\n for obj in root:\n oname = obj.get('name')\n if (obj.tag == 'file') and (oname == 'physics_types_simple'):\n obj.set('name', out_source_name)\n new_var = ET.SubElement(obj, \"variable\")\n new_var.set(\"local_name\", \"french_fries\")\n new_var.set(\"standard_name\", \"latitude\")\n new_var.set(\"units\", \"radians\")\n new_var.set(\"type\", \"real\")\n new_var.set(\"kind\", \"kind_phys\")\n dims_elem = ET.SubElement(new_var, \"dimensions\")\n dims_elem.text = 'horizontal_dimension'\n break\n # End if\n # End for\n tree.write(filename)\n\n # Run test\n with self.assertRaises(ValueError) as verr:\n _ = gen_registry(filename, 'eul', {}, _TMP_DIR, 2,\n _SRC_MOD_DIR, _CAM_ROOT,\n loglevel=logging.ERROR,\n error_on_no_validate=True)\n # End with\n # Check exception message\n emsg = \"duplicate variable standard_name, 'latitude' from \"\n emsg += \"'french_fries' in 'physics_types_duplicate_standard_name'\"\n emsg += \", already defined with local_name, 'latitude'\"\n self.assertEqual(emsg, str(verr.exception))\n # Make sure no output files were created\n self.assertFalse(os.path.exists(out_meta))\n self.assertFalse(os.path.exists(out_source))",
"def check_file_exist(self):\n return False",
"def test_read_file():\n z = XPIManager(get_path('xpi/install_rdf_only.xpi'))\n assert z.read('install.rdf') is not None",
"def test_predicate4(self):\n xpb = XPathBuilder()\n xp = xpb.foo.bar.where(xpb.attr('name').not_equals('abc'))\n xp = xp.where(xpb.attr('x').equals('foo'))\n exp = '/foo/bar[@name != \"abc\"][@x = \"foo\"]'\n self.assertEqual(xp.tostring(), exp)",
"def test_verify_unzip(self):\n assert os.path.exists(\n os.path.join(\n settings.MEDIA_ROOT,\n \"indices\",\n \"test-index\",\n \"data\",\n \"sample.txt\"\n )\n )",
"def test_exists_true(self):\n self.assertTrue(Sample.exists(self.sample_id, self.sample_template))",
"def test_xmloutput_view(self):\n print 'Running %s ...' % getName()\n \n self.sequenceListingFixture.create_sequence_instance(self.sequenceListing)\n \n response = self.client.get(reverse('sequencelistings:xmloutput', args=[self.sequenceListing.pk, ]))\n self.assertEqual(response.status_code, 200)\n# test that the page returns expected html contents\n# self.assertContains(response, '%s.xml' % self.sequenceListing.fileName)\n self.assertContains(response, self.sequenceListing.fileName)",
"def _need_generate(paths):\r\n if not os.path.exists(paths.generated_dir):\r\n return True\r\n\r\n if not os.path.exists(paths.index_file):\r\n return True\r\n\r\n # Use the index file to determine if regeneration is necessary\r\n with open(paths.index_file, 'r',newline='\\n') as index_file:\r\n indexed = [item for item in\r\n index_file.read().split('\\n') if len(item) != 0 and\r\n not item.startswith(\"#\")]\r\n return indexed != paths.resource_files"
] | [
"0.5755427",
"0.5572019",
"0.5549192",
"0.5519365",
"0.5482828",
"0.5464173",
"0.5427079",
"0.54160964",
"0.536601",
"0.5338898",
"0.52344614",
"0.5227911",
"0.51953274",
"0.5182521",
"0.51584786",
"0.51524824",
"0.51514745",
"0.51503146",
"0.511027",
"0.5074203",
"0.5046354",
"0.503389",
"0.50189185",
"0.501048",
"0.50082016",
"0.50032926",
"0.4969945",
"0.4964399",
"0.49625763",
"0.49601397",
"0.49531683",
"0.4920993",
"0.49191195",
"0.49034697",
"0.4864428",
"0.4853922",
"0.48519278",
"0.48500398",
"0.48478904",
"0.48434386",
"0.48360553",
"0.483164",
"0.48283836",
"0.48276672",
"0.4826746",
"0.48221388",
"0.4820197",
"0.4818247",
"0.48045155",
"0.48015872",
"0.4796322",
"0.47905782",
"0.47900566",
"0.47882983",
"0.47780943",
"0.47775993",
"0.4774293",
"0.47632882",
"0.47608277",
"0.47599152",
"0.47550705",
"0.47497493",
"0.4741375",
"0.4734563",
"0.47324103",
"0.47287878",
"0.47215125",
"0.47187984",
"0.4716064",
"0.47110233",
"0.4711012",
"0.4706559",
"0.47056934",
"0.47030586",
"0.47023386",
"0.4697539",
"0.46970925",
"0.46966684",
"0.46914452",
"0.46881047",
"0.46803975",
"0.46758932",
"0.46708822",
"0.46706775",
"0.4667462",
"0.46658367",
"0.46618056",
"0.46566275",
"0.4652985",
"0.46504042",
"0.4645476",
"0.46431816",
"0.463976",
"0.46339816",
"0.46335384",
"0.4632274",
"0.46320617",
"0.4631103",
"0.46305624",
"0.46282983",
"0.46265066"
] | 0.0 | -1 |
Return name enclosed with {? } separators | def sepName(self, englishOnly=False):
name = englishOnly and self.enName or self.name
return u'{*?%s*}' % (name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_qname(uri, name):\n if not uri or not name or name[0] in ('{', '.', '/', '['):\n return name\n else:\n return '{%s}%s' % (uri, name)",
"def extract_name():\n def _extract_name(quoted_name):\n return e.String(quoted_name.subexpression.name)\n yield (\"(λ &[name] . str)\", _extract_name)",
"def safe_name(self, name):\n\n output = \"\"\n for char in name:\n if char not in '\\\\/<>:\"|?*':\n output += char\n\n return output",
"def safe_formal_name(name):\n return re.sub(r\"\\s+\", \" \", re.sub(r'[!/\\\\:<>\"\\?\\*\\|]', \"\", name)).strip()",
"def non_local_name(self, name):\n if \"!\" in name:\n return name[:name.find(\"!\")+1]\n else:\n return name",
"def named_back_reference(name:str) -> str:\n # TODO error handling \n return f\"\\\\k<{name}>\"",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*&%s*}' % (name)",
"def format_name(self) -> str:\n decl = self.declaration\n name, _ = decl.split(\"(\", 1)\n return name",
"def render_name(name_att_list):\n res = ['']\n for k, v in name_att_list:\n v = dn_escape(v)\n res.append(\"%s=%s\" % (k, v))\n res.append('')\n return '/'.join(res)",
"def format_name_string(x: str) -> str:\n # get rid of [#] when present\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n if \"var.\" in x.lower():\n p = x.lower().find(\"var.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \" var \" in x.lower(): # need the spaces around var, because some names have the letters var in them\n p = x.lower().find(\" var \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \"subsp.\" in x.lower():\n p = x.lower().find(\"subsp.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" forme \" in x.lower():\n p = x.lower().find(\" forme \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" f. \" in x.lower():\n p = x.lower().find(\" f. \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+3] + \" <em class=\\\"species\\\">\" + x[p+3:] + \"</em>\"\n else:\n return \"<em class=\\\"species\\\">\" + x + \"</em>\"",
"def format_name(self) -> str:\n decl = self.declaration\n name, _, _ = decl.partition(\"(\")\n return name",
"def Escape(name):\n return re.sub(r'[^\\w#-]', '_', name)",
"def _process_name(name):\n\n # Unescape HTML entities\n name = unescape(name)\n\n # Remove bracketed stuff on the end\n name = NG_RE.sub('', name).strip() # Nomenclature groups\n name = END_RE.sub('', name).strip(', ') # Words\n name = RATIO_RE.sub('', name).strip(', ') # Ratios\n\n # Remove stuff off start\n name = START_RE.sub('', name).strip()\n\n # Remove balanced start and end brackets if none in between\n name = BRACKET_RE.sub('\\g<1>', name)\n\n # Un-invert CAS style names\n comps = name.split(', ')\n if len(comps) == 2:\n if comps[1].endswith('-'):\n name = comps[0]\n name = '%s%s' % (comps[1], name)\n elif len(comps) > 2:\n name = comps[0]\n for i in range(1, len(comps)):\n if comps[i].endswith('-'):\n name = '%s%s' % (comps[i], name)\n else:\n name = '%s %s' % (name, comps[i])\n return name",
"def split_name(fullname):",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n if not self.useFileInfo:\n return u'{*%s*}' % name\n return u'{*!%s*}' % name",
"def compile_name(self, name):\n S = [s.strip().lower() for s in name.split('|')]\n assert all(S)\n \n S = [set(x.strip().lower() for x in s.split('&')) for s in S]\n assert all(all(x) for x in S)\n \n return S",
"def generate(self, name):\n if not '?' in self._pattern and not '[' in self._pattern:\n try:\n return self._pattern.replace('*', '{}').format(name)\n except IndexError:\n # multiple *\n pass\n return ''",
"def get_name() -> str:",
"def CleanName(self,name):\n name2 = \"\"\n for c in name:\n if c == \"(\":\n break\n else: name2+=c\n\n return name2.strip(\"\\n\")",
"def latex_name(name):\r\n name = name + '_' #protects against .split('_') failing\r\n if name.startswith('['): #format leading [] as concentration\r\n head, tail = name[1:].rsplit(']', 1)\r\n head = r'[\\ce{%s}]' % head\r\n else:\r\n if '[' in name: # turn internal [] into marked-up subscripts\r\n before, inside, after = re.match(r'([^[]+)\\[(.*)\\]([^]]*)', name).groups() # separates bracketed material\r\n name = r'%s_\\ce{%s}_%s' % (before, inside, after)\r\n head, tail = name.split('_', 1)\r\n if len(head) > 1: # special cases like v12 (=> v_12) and roman multiple letter symbol\r\n if re.match(r'^.[0-9]+$', head): # single character following by integer, i.e. v0\r\n head, tail = name[0], name[1:]\r\n else:\r\n head = r'\\mathrm{%s}' % head\r\n subscripts = re.findall(r'(\\\\ce{.*}|[^_]+)_', tail) # tail.split('_') but ignoring underscore within chem mark-up\r\n if subscripts:\r\n return head + r'_{\\mathrm{' + ','.join(subscripts) + '}}'\r\n return head",
"def fmt(competitor_name: str) -> str:\n name = competitor_name.replace(\"_a\", r\" $\\alpha$ \")\n name = name.replace(\"_b\", r\" $\\beta$ \")\n return name",
"def _format_question_break(self, name):\n header = '-' * 80 + '\\n'\n buffer_length = int((80 - int(len(name))) / 2) \n header += ' ' * buffer_length + name + ' ' * buffer_length + '\\n'\n header += '-' * 80 + '\\n'\n\n return header",
"def format_name(field_name):\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()",
"def _var_name_sub(self, sprintf, quote=False):\n q = ''\n if quote:\n q = \"'\"\n name_list = map(lambda x: q + self.cdict[x][0] + q, sprintf[\"vars\"] )\n return sprintf[\"text\"] % tuple(name_list)",
"def __str__(self) -> str:\n return f'?{self.name}'",
"def format_alias_name(self, name):\n result = strip_punctuation(name)\n result = WHITESPACE_REGEX.sub(' ', result)\n return result",
"def get_name(header, splitchar=\"_\", items=2):\n if splitchar:\n return \"_\".join(header.split(splitchar)[:items]).lstrip(\">\")\n else:\n return header.lstrip(\">\")",
"def clean_name(x: str) -> str:\n x = x.replace(\", var.\", \" var.\")\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n return x",
"def format_name(self) -> str:\n decl = self.declaration\n\n # variables which are declared and assigned at the same location will\n # include the assignment in the clange declaration, so strip it out for\n # documentation.\n name, _, _ = decl.partition(\"=\")\n return name",
"def name(self) -> StringFilter:\n return self.__name",
"def adjust_name_for_printing(name):\n if name is not None:\n name2 = name\n name = name.replace(\" \", \"_\").replace(\".\", \"_\").replace(\"-\", \"_m_\")\n name = name.replace(\"+\", \"_p_\").replace(\"!\", \"_I_\")\n name = name.replace(\"**\", \"_xx_\").replace(\"*\", \"_x_\")\n name = name.replace(\"/\", \"_l_\").replace(\"@\", '_at_')\n name = name.replace(\"(\", \"_of_\").replace(\")\", \"\")\n if re.match(r'^[a-zA-Z_][a-zA-Z0-9-_]*$', name) is None:\n raise NameError(\"name {} converted to {} cannot be further converted to valid python variable name!\".format(name2, name))\n return name\n return ''",
"def format_name(self) -> str:\n return self.declaration",
"def __sanitize(name):\n if name[-1] == \"/\":\n return name[:-1]\n return name",
"def fname(self):\n buff = []\n for c in self.name:\n if c in latex_symbol_map:\n buff.append(\"$_{}$\".format(latex_symbol_map[c]))\n else:\n buff.append(c)\n return ''.join(buff)",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*#%s*}' % (name)",
"def _get_pretty_name(name):\n pretty = ''\n if name.countryName:\n pretty += '/C=' + name.countryName\n if name.stateOrProvinceName:\n pretty += '/ST=' + name.stateOrProvinceName\n if name.localityName:\n pretty += '/L=' + name.localityName\n if name.organizationName:\n pretty += '/O=' + name.organizationName\n if name.organizationalUnitName:\n pretty += '/OU=' + name.organizationalUnitName\n if name.commonName:\n pretty += '/CN=' + name.commonName\n if name.emailAddress:\n pretty += '/email=' + name.emailAddress\n return pretty",
"def _extract_name(line: str) -> str:\n tokens = line[19:-2].split(\" {\")\n name = tokens[0]\n return name",
"def name(self):\n return self._name or ' & '.join(s.name for s in self.suites)",
"def success_new_brass(name):\n return 'Nom de brasserie %s' % name + ' a bien ete ajoute'",
"def print_name(nome, sobrenome):\r\n return nome + \" \" + sobrenome",
"def mark(name: str) -> str:\n return f'<mark name=\"{name}\"/>'",
"def filter_name(self, name):\n return self.form.set_value(\"generating station search\", name)",
"def variable_string(self, name):\n return \"$(\" + name + \")\"",
"def visit_name(self, node, children):\n name = ''.join(children)\n return name",
"def fullname(self, name):\n f, l = name.split(' ')\n self.first = f\n self.last = l",
"def get_name():",
"def ending_cutter(name: str):\n if name.endswith('ID') and re.match(r'^(?=\\w+[A-Z])(?=\\w+[a-z])\\w+$', name):\n return name[:-2]\n return name",
"def get_full_name(self):\n full_name = '{0} {1} {2}'.format(self.last_name, self.first_name, self.patronymic)\n return full_name.strip()",
"def full_name(self) -> str:\n # return self.separator.join(map(lambda x: x.name, self.path()))\n return self.separator.join(map(lambda x: x.tagged_name, self.path()))",
"def capture(*args:List[str], name:Union[str,None]=None) -> str:\n name = f\"?<{name}>\" if name is not None else \"\"\n return f'({name}{\"\".join(args)})'",
"def format_name(self):\n\t\tself.full_name = self.first + \" \" + self.last",
"def name_parser(string):\n return string.replace('\\n', ' ')",
"def clean_specific_name(x: str) -> str:\n\n # this is a list of terms that are not actual species names or specific names that have never been part of\n # a fiddler genus\n skip_list = (\"sp.\",\n \"spp.\",\n \"var.\",\n \"nov.\",\n \"a\",\n \"ete\",\n \"panema\",\n \"pagurus\",\n \"quadratus\",\n \"albidus\",\n \"vociferans\",\n \"raniformis\",\n \"nigra\",\n \"albicans\",\n \"arenarius\",\n \"raninus\",\n \"serratus\",\n \"cordimana\",\n \"spec.\",\n \"complex\",\n \"5\",\n \"6\",\n \"1\",\n \"afruca\",\n \"gelasimus\")\n\n if (\" \" not in x) or (\"(\" in x):\n return \"\"\n else:\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n y = x.split(\" \")\n x = y[len(y)-1].lower()\n if (x in skip_list) or (\"gruppe\" in x) or (\"group\" in x) or (\"complex\" in x):\n return \"\"\n else:\n return x.lower()",
"def quote_name(self, name):\n name = re.sub('-', '', name)\n if name.startswith('\"') and name.endswith('\"'):\n return name\n return '\"%s\"' % (name,)",
"def FilterName(namefilter, safechar='P', reserved_names=None):\n # remove non accepted characters\n for c in r' -[]/\\;,><&*:%=+@!#^|?^':\n namefilter = namefilter.replace(c, '')\n\n # remove non english characters\n char_list = (c for c in namefilter if 0 < ord(c) < 127)\n namefilter = ''.join(char_list)\n\n # Make sure we have a non empty string\n if len(namefilter) <= 0:\n namefilter = safechar\n\n # Make sure we don't start with a number\n if namefilter[0].isdigit():\n print(namefilter)\n namefilter = safechar + namefilter\n\n # Make sure we are not using a reserved name\n if reserved_names is not None:\n while namefilter.lower() in reserved_names:\n namefilter = safechar + namefilter\n\n # Add the name to reserved names\n reserved_names.append(namefilter)\n\n return namefilter",
"def _get_name(self):\n name_string = '%s_%s' % (\n self.parameter_type,\n self.parameter_value_type)\n if self.paneltemplateparametermarker_set.count() > 0:\n marker_string = \"_\".join(sorted([m.marker.marker_abbreviation for m in self.paneltemplateparametermarker_set.all()]))\n name_string += '_' + marker_string\n if self.fluorochrome:\n name_string += '_' + self.fluorochrome.fluorochrome_abbreviation\n return name_string",
"def _get_name(self):\n return '%s: %s-%s' % (\n self.fcs_number,\n self.parameter_type,\n self.parameter_value_type)",
"def name(self):\n\n return self._name.replace(\"[]\", \"\")",
"def get_name(self):\n name = ''\n # name contains all adjacent alphanumeric symbol\n while self.current_character.isalnum():\n name += self.current_character\n self.current_character = self.file.read(1)\n self.file.seek(self.file.tell() - 1, 0)\n character = self.file.read(1)\n if character.isalnum():\n pass\n else:\n self.file.seek(self.file.tell() - 1, 0)\n return name",
"def getName(self):\n return \"\"",
"def normalize_pipeline_name(name=''):\n normalized_name = name\n for bad in '\\\\/?%#':\n normalized_name = normalized_name.replace(bad, '_')\n return normalized_name",
"def match_specific_name(name: str, specific_names: list) -> str:\n c = clean_specific_name(name)\n if c == \"\":\n return c\n else:\n y = \"\"\n for x in specific_names:\n matchlist = x.variations.split(\";\")\n if c in matchlist:\n y = x.name\n return y",
"def get_html_name(form, name):\n return form.add_prefix(name)",
"def _get_name(self, name, scopes=None, include_cond=True):\n if scopes is None:\n scopes = self._scopes\n\n scope_strings = []\n for scope in scopes:\n if self._is_name_scope(scope):\n scope_strings.append(scope)\n elif self._is_conditional_scope(scope) and include_cond:\n parent_name = scope['parent_name']\n parent_values = scope['parent_values']\n scope_string = '{name}={vals}'.format(\n name=parent_name,\n vals=','.join([str(val) for val in parent_values]))\n scope_strings.append(scope_string)\n return '/'.join(scope_strings + [name])",
"def get_name(self):\n return self._pattern",
"def get_name(descr: str) -> str:\n return descr.split()[0]",
"def _expanded_id(name: str, sep: str = '_') -> str:\n return sep.join([el.lower()\n for el in re.split(r'([A-Z]+[^A-Z]*)', name)\n if el])",
"def encode_name(param):\n sname = param\n # replace all kind of unwanted chars in a python dictname.\n sname = sname.strip()\n for ch in ['/', ' + ', ' ', '#', '&', '-', ',', '+', ]:\n if ch in sname:\n sname = sname.replace(ch, \"_\")\n\n # replace brackets\n for ch in ['(', ')']:\n if ch in sname:\n sname = sname.replace(ch, \"\")\n\n # replace the numbers 2 and 10 with the text representation\n if '10' in sname:\n sname = sname.replace('10', 'TEN')\n\n if '2' in sname:\n sname = sname.replace('2', 'TWO')\n return sname.upper()",
"def format_name(f_name, l_name): #docstring (documentation)\n if f_name == \"\" or l_name == \"\":\n return \"You didn't provide valid inputs.\"\n formated_f_name = f_name.title()\n formated_l_name = l_name.title()\n return f\"Result: {formated_f_name} {formated_l_name}\"",
"def fullname(self, name):\n\n first, last = name.split(' ')\n self.first = first\n self.last = last",
"def clean_name(name):\n return \",\".join(name.split(\",\")[:1])",
"def clean_name(name):\n return \",\".join(name.split(\",\")[:1])",
"def simplifyOutName(name):\n return \"HLTNav_\" + name.replace(\"HLTNav_\", \"\").replace(\"Trig\", \"\").replace(\"Alg\", \"\")",
"def format_name(self) -> str:\n return self.name",
"def get_name_link_html(self):\n url_text = \"{{% url 'trait_browser:source:studies:pk:detail' pk={} %}} \".format(self.pk)\n return URL_HTML.format(url=url_text, name=self.i_study_name)",
"def quote_name(self, name):\n if name.startswith(self.left_sql_quote) and name.endswith(self.right_sql_quote):\n return name # Quoting once is enough.\n return '%s%s%s' % (self.left_sql_quote, name, self.right_sql_quote)",
"def get_name(self):\r\n return ('%s %s' % ( self.first_name, self.last_name ))",
"def name_format(name):\n lst_name, fst_name = name.split(',')\n return ' '.join((fst_name, lst_name))",
"def legal_variable_name(name):\n var_name = name.replace(' ', '_')\n for char in r'''[]{}\\/^%$#@!+-<>?|'\"=~`,.;:''':\n if char in var_name:\n var_name = var_name.replace(char, '')\n for char in var_name:\n if ord(char) > 127: # remove non-ascii characters\n var_name = var_name.replace(char, '')\n return var_name",
"def get_field(fieldname):\n m = re.search(\"(^|\\\\n)%s\\\\s(.*?)\\n\" % fieldname, s, re.I)\n if not m:\n return None\n else:\n return Unquote(m.group(2))",
"def encode_name_components(self, name: Name):\n first_quot = False\n new_component = \"\"\n for component in name.components:\n if '\"' in str(component):\n if first_quot is True:\n new_component += str(component)\n first_quot = False\n else:\n first_quot = True\n if first_quot:\n new_component += str(component)\n new_component = new_component.replace(\"'b'\", \"/\").replace(\"b'\", \"\")[:-1]\n if \"=\" not in new_component and '\"' in new_component:\n new_component = new_component.replace('\"', \"\")\n start_of_component = 0\n for i in range(0, len(name.components)):\n if \"_(\" in str(name.components[i]):\n start_of_component = i\n comp_list_len = len(name.components)\n for i in range(start_of_component, comp_list_len - 2):\n name.components.pop(len(name.components) - 2)\n name.components[-2] = new_component.encode(\"ascii\")\n return name",
"def satname(rocketsatname):\n \n # split the rocket and satellite name at the bullet\n names = rocketsatname.split('•')\n \n # remove spaces around satellite name\n namefull = names[1].strip()\n \n # return the satellite's name\n return namefull",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def test_expanded_name( self ):\n\t\tself.doBasicTest(\n\t\t\t'''s := something +\n\t\t\t>something< := r\n\t\t\tr := [ab]\n\t\t\tv := [c]\n\t\t\t''',\n\t\t\t's',\n\t\t\t'abammmab',\n\t\t\t(1,[\n\t\t\t\t('r',0,1, NullResult),\n\t\t\t\t('r',1,2, NullResult),\n\t\t\t\t('r',2,3, NullResult),\n\t\t\t],3)\n\t\t)",
"def name(self):\n return \"%s %s\" % (self.first_name, self.last_name)",
"def cFormal(self):\n if not self.type:\n return self.name # special case for '...'\n else:\n arr = self.array or ''\n pointers = self.pointers or ''\n return \"%s %s%s%s\" % (self.type, pointers, self.name, arr)",
"def printname(bruce):",
"def get_query_parameter(self,original_name: Optional[str] = None) -> str:\n if not original_name:\n raise TypeError(\"original_name cannot be null.\")\n if original_name == \"count\":\n return \"%24count\"\n if original_name == \"expand\":\n return \"%24expand\"\n if original_name == \"filter\":\n return \"%24filter\"\n if original_name == \"orderby\":\n return \"%24orderby\"\n if original_name == \"search\":\n return \"%24search\"\n if original_name == \"select\":\n return \"%24select\"\n if original_name == \"skip\":\n return \"%24skip\"\n if original_name == \"top\":\n return \"%24top\"\n return original_name",
"def get_query_parameter(self,original_name: Optional[str] = None) -> str:\n if not original_name:\n raise TypeError(\"original_name cannot be null.\")\n if original_name == \"count\":\n return \"%24count\"\n if original_name == \"expand\":\n return \"%24expand\"\n if original_name == \"filter\":\n return \"%24filter\"\n if original_name == \"orderby\":\n return \"%24orderby\"\n if original_name == \"search\":\n return \"%24search\"\n if original_name == \"select\":\n return \"%24select\"\n if original_name == \"skip\":\n return \"%24skip\"\n if original_name == \"top\":\n return \"%24top\"\n return original_name",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*%s%s*}' % (self.parentLevel * '*', name)",
"def name(self):\n return str(self._options.hydraulic.pattern) if self._options.hydraulic.pattern is not None else ''",
"def get_full_name(self):\r\n full_name = '%s' % (self.name)\r\n return full_name.strip()",
"def name_value(self) -> global___Expression.NameValue:",
"def use_name(self):\n projection = proj.get_projection(self.conf.projections, self.spec)\n if not projection:\n projection = self.conf.default_projections[\"all\"]\n\n name = self.spec.format(projection)\n # Not everybody is working on linux...\n parts = name.split(\"/\")\n name = os.path.join(*parts)\n # Add optional suffixes based on constraints\n path_elements = [name] + self.conf.suffixes\n return \"-\".join(path_elements)",
"def get_rep_name(self, name):\n return \"r{0}\".format(name)",
"def get_full_name(self):\n if self.patronymic_name:\n return '{} {} {}'.format(\n self.first_name,\n self.patronymic_name,\n self.last_name,\n )\n\n return '{} {}'.format(\n self.first_name,\n self.last_name,\n )"
] | [
"0.61448735",
"0.61404973",
"0.5836852",
"0.5794541",
"0.57860225",
"0.57392246",
"0.5660936",
"0.56530035",
"0.5644217",
"0.55994993",
"0.55715615",
"0.55315167",
"0.55184275",
"0.54926336",
"0.5441188",
"0.5408375",
"0.5391947",
"0.53832364",
"0.5359637",
"0.5346842",
"0.53380084",
"0.5330564",
"0.53142434",
"0.52700996",
"0.524386",
"0.5241395",
"0.5233396",
"0.5231413",
"0.52298325",
"0.5229409",
"0.52205145",
"0.5205116",
"0.51899874",
"0.5175646",
"0.5159675",
"0.5157742",
"0.5152366",
"0.5143119",
"0.5132167",
"0.51301634",
"0.51278013",
"0.5103898",
"0.5086814",
"0.5084781",
"0.50829315",
"0.5073549",
"0.5044718",
"0.5029175",
"0.50255185",
"0.50253445",
"0.5024888",
"0.50179005",
"0.5001062",
"0.49965125",
"0.4993822",
"0.49925566",
"0.4990841",
"0.49782714",
"0.49752626",
"0.49584284",
"0.49572417",
"0.4957172",
"0.49540657",
"0.49521312",
"0.49429262",
"0.49422178",
"0.49277678",
"0.49253523",
"0.4921725",
"0.4921004",
"0.49199083",
"0.49199083",
"0.49191892",
"0.49006087",
"0.48929736",
"0.4892349",
"0.48865047",
"0.48834217",
"0.48830917",
"0.4882462",
"0.48709264",
"0.4869607",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48587474",
"0.48578084",
"0.48543957",
"0.4853977",
"0.48533097",
"0.48533097",
"0.4851776",
"0.48514396",
"0.48460093",
"0.48432255",
"0.48307502",
"0.48286083",
"0.4824451"
] | 0.54990566 | 13 |
Return formatted text for this field | def outputText(self, item, titleMode, internal=False):
field = None
while not field:
item = item.parent
if item:
field = item.nodeFormat().findField(self.name)
else:
return ''
return field.outputText(item, titleMode, internal) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def formatted(self) -> str:\r\n ...",
"def format(self) -> str:",
"def text(self) -> str:",
"def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d",
"def get_text(self):\n inp = \" \"\n if self.link_id:\n inp += \"LINK \" + self.link_id\n inp += self.status + ' '\n if self.node_id:\n inp += \"NODE \" + self.node_id + ' '\n if self.value:\n inp += self.control_type.name + ' ' + str(self.value) + ' '\n if self.time:\n inp += self.time + ' '\n if self.clock_time:\n inp += self.clock_time + ' '\n # TODO: research correct formatting of time, clock_time options\n return inp",
"def format(self) -> str:\n return self._format",
"def format(self) -> str:\n return self._format",
"def getText(self):\r\n return \"\"",
"def value_as_text(self):\n property_name = \"_%s_as_text\" % self.attribute.type\n return getattr(self, property_name, self.value)",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def getFormattedText(self):\r\n h = \"00\"\r\n m = \"00\"\r\n s = \"00\"\r\n if(self.seconds < 10):\r\n s = \"0\" + str(self.seconds)\r\n else:\r\n s = str(self.seconds)\r\n\r\n if(self.minutes < 10):\r\n m = \"0\" + str(self.minutes)\r\n else:\r\n m = str(self.minutes)\r\n\r\n if(self.hours < 10):\r\n h = \"0\" + str(self.hours)\r\n else:\r\n h = str(self.hours)\r\n\r\n return h + \":\" + m + \":\" + s",
"def get_text(self):\n return self.rule_id + '\\t' + self.rule_text",
"def get_text(self):\n return self.get_property('text')",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def _get_FIELD_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n template = ''\n template += '{:d}' if field.decimals == 0 else '{:.%sf}' % field.decimals\n template += ' ' if field.spaced_display else ''\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def TEXT(number, format_type):\n raise NotImplementedError()",
"def format(self) -> str:\n return pulumi.get(self, \"format\")",
"def text(self) -> str:\n return self.__text",
"def show(self) -> str:\n return f'[{self.font}]{self.text}[{self.font}]' if self.font else self.text",
"def formatName(self):\r\n return self.title.getVal() + \" \" + self.first.getVal() + \" \" + self.last.getVal()",
"def getText(self):\n return(' '.join(map(lambda x:x.text,self.getNested())))",
"def get_text(self) -> str:\n return self.text",
"def text(self):\n return self.__text",
"def getText(self):",
"def get_text(self):\n return self.text",
"def text(self):\n return ''",
"def get_text(self) -> str:\n return self._text",
"def get_formatted_text(self, n_cols):",
"def text(self) -> str:\n return self._impl.get_text()",
"def format_item_display(self, obj):\n return u\"%s - %s\" % (escape(obj.nombre),obj.rfc)",
"def text(self) -> LocalizedString:\n return self._text",
"def as_text(self) -> str:\n txt = ''\n with self._th_lock:\n # purge expired value (reach ttl_s) from values dict\n purge_l = []\n for key, (_value, _timestamp_ms, expire_at) in self._values_d.items():\n if expire_at and time.monotonic() > expire_at:\n purge_l.append(key)\n for rm_key in purge_l:\n self._values_d.pop(rm_key)\n # if any value exists, format an exposition message\n if self._values_d:\n # add a comment line if defined\n if self.comment:\n # apply escapes to comment\n esc_comment = str(self.comment)\n for rep_args in [('\\\\', '\\\\\\\\'), ('\\n', '\\\\n')]:\n esc_comment = esc_comment.replace(*rep_args)\n txt += f'# HELP {self.name} {esc_comment}\\n'\n # add a type line if defined\n if self.type is not MetricType.UNTYPED:\n txt += f'# TYPE {self.name} {self.type.value}\\n'\n # add every \"name{labels} value [timestamp]\" for the metric\n for lbl_id_str, (value, ts, _expire_at) in self._values_d.items():\n if self._type is MetricType.HISTOGRAM:\n txt += self._data2txt_histogram(lbl_id_str, value)\n elif self._type is MetricType.SUMMARY:\n txt += self._data2txt_summary(lbl_id_str, value)\n else:\n txt += self._data2txt_default(lbl_id_str, value, ts)\n return txt",
"def __str__(self):\n txt = \"%s:\\n\" % self.name\n txt += \" Charge: %.4f\\n\" % self.charge\n txt += \" Radius: %.4f\" % self.radius\n return txt",
"def text(self):\n if self.is_root:\n return ''\n elif self.is_comment:\n return self.__value\n elif self.is_flag:\n if self.__value:\n return '[{0}]'.format(self.name)\n else:\n return '!{0}!'.format(self.name)\n else:\n return '[{0}:{1}]'.format(self.name, self.value)",
"def __repr__(self) -> str:\n return f\"{self.text}\"",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def text(self) -> str:\n return self._text",
"def format(self):\n return self._format",
"def get_formatter(self, **kwargs):\n config = dict([\n (attr, getattr(self, attr))\n for attr in [\n \"include_sign\",\n \"group_with_commas\",\n \"num_decimal_places\",\n ]\n ])\n config.update(kwargs)\n return \"\".join([\n \"{\",\n config.get(\"field_name\", \"\"),\n \":\",\n \"+\" if config[\"include_sign\"] else \"\",\n \",\" if config[\"group_with_commas\"] else \"\",\n \".\", str(config[\"num_decimal_places\"]), \"f\",\n \"}\",\n ])",
"def text(self):\n\n if self.status.full_text:\n return self.status.full_text\n elif self.status.text:\n return self.text\n else:\n return MISSING",
"def to_str(self):\n return self.template.format(\n text_color=self.color.to_str(),\n font_type=self.font_type.to_str(),\n font_weight=self.font_weight.to_str(),\n font_size=self.font_size.to_str()\n )",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def text(self):\n return self.name, self.fontfile, self.fontsize",
"def plain_text(self) -> str:\n return pulumi.get(self, \"plain_text\")",
"def _get_FIELD_humanized_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n power = max([i for i in utils.POWERS if value // i > 0 and i > 1])\n value /= power\n template = ''\n template += '{:.%sf}' % field.humanized_decimals\n template += ' ' if field.spaced_display else ''\n template += utils.POWERS[power]\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def format( self ) :\n\n return( self.__format )",
"def __repr__(self) -> str:\r\n\r\n saida = \"Format: \"\r\n x = self.getformat()\r\n for _ in range(len(x)):\r\n saida = f\"{saida}{x[_]}\"\r\n if _ < len(x)-1:\r\n saida += \", \"\r\n saida += \"\\n\"\r\n return saida",
"def text(self):\n return self.label.text()",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title} :\" + s\n\n return s",
"def format_value(text):\n return text.encode('utf8').replace('\\n', ' ').replace('\\r', ' ')",
"def get_text(self):\n logging.getLogger(__name__).info(\"Element text: {}\\nby = {}\\nvalue = {}\".format(\n self.driver.find_element(self.by, self.value).text, self.by, self.value))\n return self.driver.find_element(self.by, self.value).text",
"def get_instance_text(instance):\n values = []\n for fieldname in registry[instance.__class__]:\n values.extend(resolve_field_value(\n [instance], fieldname.split('__')))\n return u' '.join(values)",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n return text",
"def text(self, v=''):\n return str(v)",
"def _to_text(self, value):\n raise NotImplementedError",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def __str__(self):\n return self.fmt.format(*self.args, **self.kwargs)",
"def field_display(obj, field):\n return get_field_value(obj, field)",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n if hasattr(self,'label'):\n return str(self.label.text())\n else:\n return self.key",
"def __str__(self):\n return self.format()",
"def text(self):\n parts = [(\"%s\" if isinstance(p, Insert) else p) for p in self.parts]\n parts = [(\"%%\" if p == \"%\" else p) for p in parts] # escape percent\n return \"\".join(parts)",
"def Text(self):\n return self._text",
"def __str__(self):\n struct_repr = \", \".join([\n \"type: \" + str(self.type),\n \"text: \" + str(self.text)\n ])\n\n return f\"StatusText: [{struct_repr}]\"",
"def GetText(self):\r\n \r\n return self._text",
"def getText(self):\n return self.text",
"def getText(self):\n return self.text",
"def to_text(self, floatformat: str = \".6f\") -> str:\n return self.val.to_text(floatformat)",
"def __str__(self):\n #Format data from default fields\n template = \"{number:4}|{rep:4}|{time:5}{priority:+2}|\" \\\n \"{record_type:8}|{name:17}\"\n default_fields = template.format(**self)\n \n #Format data from custom fields\n custom_field_list = []\n for label in self.custom_labels:\n custom_field_list.append(\"|{:17}:{!s:<5}\".format(label,\n self[label]))\n custom_fields = \"\".join(custom_field_list)\n \n return default_fields + custom_fields",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def __str__(self):\n\t\treturn self.text",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def text(self):\n # type: () -> str\n return self._text",
"def get_text(self):",
"def text(self):\n return self.full_text",
"def __str__(self):\n return \"%s\\n\" % self.text + \" \" * self.col + \"^\"",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% on line \" + self.line\n return text",
"def _entity_as_text(self):\n return str(self.value)",
"def format(self, record):\n message = record.getMessage()\n asctime = self.formatTime(record, self.datefmt)\n name = yellow(record.name)\n\n s = \"%(timestamp)s %(levelname)s %(name)s \" % {\n \"timestamp\": green(\"%s,%03d\" % (asctime, record.msecs), bold=True),\n \"levelname\": self.LEVELS[record.levelname],\n \"name\": name,\n }\n\n if \"\\n\" in message:\n indent_length = len(re_color_codes.sub(\"\", s))\n message = message.replace(\"\\n\", \"\\n\" + \" \" * indent_length)\n\n s += message\n return s",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n text += \" [\" + self.file_name + \"]\"\n return text",
"def text(self):\n\t\treturn ' '.join([self.write_components[x] for x in self.write_components])"
] | [
"0.75734353",
"0.7379207",
"0.7205578",
"0.68481845",
"0.67844886",
"0.67808527",
"0.67703915",
"0.67703915",
"0.67655444",
"0.6745665",
"0.6687435",
"0.66469747",
"0.6644202",
"0.66413474",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65741307",
"0.6567402",
"0.6558896",
"0.6555393",
"0.655068",
"0.6547239",
"0.6544499",
"0.6535529",
"0.6517592",
"0.6480058",
"0.6460372",
"0.6459885",
"0.64553267",
"0.6446324",
"0.6445358",
"0.64076585",
"0.6392125",
"0.6380471",
"0.6367286",
"0.6361198",
"0.6353135",
"0.6348966",
"0.63427186",
"0.6320017",
"0.6318294",
"0.63155836",
"0.6308729",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.62890583",
"0.62872475",
"0.6284665",
"0.6283615",
"0.62564605",
"0.62539566",
"0.6250457",
"0.6246106",
"0.6245501",
"0.6238378",
"0.62316114",
"0.62306285",
"0.6227439",
"0.6216431",
"0.6214085",
"0.6207841",
"0.6207841",
"0.62025124",
"0.618629",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6184535",
"0.6183745",
"0.6183568",
"0.61735356",
"0.61702335",
"0.61699766",
"0.6169714",
"0.6169714",
"0.6168279",
"0.616314",
"0.6158217",
"0.6158217",
"0.6158217",
"0.6156037",
"0.6137155",
"0.61364275",
"0.6114419",
"0.61141664",
"0.6103432",
"0.61010504",
"0.6098953",
"0.609143",
"0.60909635",
"0.60876095"
] | 0.613794 | 90 |
Return what we need to write into an XSL file for this type | def xslText(self):
return u'<xsl:value-of select="ancestor::*/%s"/>' % self.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def xslText(self):\n return TextFormat.xslText(self)",
"def convert(self):\n self._convert()\n self._write_docx()",
"def toxml(self) :\n\t\treturn self.doc.toxml()",
"def _ooxml(self):\n # LOG: processing_type property\n self.set_property('processing_type', 'ooxml')\n try:\n doc = officedissector.doc.Document(self.src_path)\n except Exception:\n self.make_dangerous('invalid ooxml file')\n return\n # There are probably other potentially malicious features:\n # fonts, custom props, custom XML\n if doc.is_macro_enabled or len(doc.features.macros) > 0:\n self.make_dangerous('macro')\n if len(doc.features.embedded_controls) > 0:\n self.make_dangerous('activex')\n if len(doc.features.embedded_objects) > 0:\n # Exploited by CVE-2014-4114 (OLE)\n self.make_dangerous('embedded obj')\n if len(doc.features.embedded_packages) > 0:\n self.make_dangerous('embedded pack')",
"def xslText(self):\n return u'<xsl:value-of select=\"%s%s\"/>' % (self.parentLevel * '../',\n self.name)",
"def xslText(self):\n return u'<xsl:value-of select=\"child::*/%s\"/>' % self.name",
"def _write_docx(self):\n with ZipFile(self.out_file, 'w') as f:\n self._write_content_types(f)\n self._write_app(f)\n self._write_core(f)\n self._write_rels(f)\n self._write_document(f)\n self._write_fonts(f)\n self._write_document_rels(f)\n self._write_settings(f)\n self._write_styles(f)",
"def create_output_file(self):\r\n self.output_file = openpyxl.Workbook()",
"def _create_oai_xsl_template():\n oai_xsl_template = OaiXslTemplate()\n oai_xsl_template = _set_oai_xsl_template_fields(oai_xsl_template)\n\n return oai_xsl_template",
"def createXML(whatToCreate):\n\n XMLSerializer = serializers.get_serializer(\"xml\")\n xml_serializer = XMLSerializer()\n if whatToCreate == \"allAccount\":\n path_fullToOutputFile = os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\")\n objectsToSerialize = Account.objects.all()\n else:\n raise ProgrammingError(\n _(\"During XML Export it was not correctly specified which data that has to be exported\"))\n out = open(os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\"), \"w\")\n if objectsToSerialize == '':\n raise NoObjectsToBeSerialzed(_(\"During XML Export it was not correctly specied data has to be exported\"))\n else:\n xml_serializer.serialize(objectsToSerialize, stream=out, indent=3)\n out.close()\n return path_fullToOutputFile\n\n # TODO def importAllAccountsXML(self):",
"def export_to_xml(self, resource_fs):\r\n raise NotImplementedError('Modules must implement export_to_xml to enable xml export')",
"def writeXml(self):\n text = u' type=\"%s\"' % self.typeName\n if self.format:\n text += u' format=\"%s\"' % escape(self.format, treedoc.escDict)\n if self.prefix:\n text += u' prefix=\"%s\"' % escape(self.prefix, treedoc.escDict)\n if self.suffix:\n text += u' suffix=\"%s\"' % escape(self.suffix, treedoc.escDict)\n if self.html:\n text += u' html=\"y\"'\n if self.isRequired:\n text += u' required=\"y\"'\n if self.hidden:\n text += u' hidden=\"y\"'\n if self.numLines > 1:\n text += u' lines=\"%d\"' % self.numLines\n if self.initDefault:\n text += u' init=\"%s\"' % escape(self.initDefault, treedoc.escDict)\n if self.linkAltField:\n text += u' linkalt=\"%s\"' % escape(self.linkAltField,\n treedoc.escDict)\n return text",
"def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def getXml(self):\n return _SALOMERuntime.InputXmlPort_getXml(self)",
"def generateXML(self):\n return self.formatEval(\n self.TEMPLATES[self.attrs['name']]['XML'],\n self.attrs\n )",
"def storeAndReturnXML(self):\n self._storeItems()\n return self.toXML()",
"def get_xml(self):\n return etree.tostring(self.get_etree())",
"def definition_to_xml(self, resource_fs):\r\n raise NotImplementedError(\r\n \"%s does not implement definition_to_xml\" % self.__class__.__name__)",
"def create_gen_xml(self, out_file):\n\n param_list = []\n msg = []\n msg_type = []\n dep_node = []\n for line in self.full_ed_lines:\n param_list.append(line.text())\n dep_pkg = param_list[6].split(', ')\n if dep_pkg[len(dep_pkg) - 1] == '':\n dep_pkg.pop()\n for dep in self.manager.wid.sub_list:\n dep_node.append(dep['msg_type'])\n for dep in self.manager.wid.pub_list:\n dep_node.append(dep['msg_type'])\n for dep in dep_node:\n a, b = dep.split('/')\n msg.append(a)\n msg_type.append(b)\n f = open('../genkernel/templates/package_rosgen.xml')\n o = open(out_file, 'a')\n flag = 0\n while 1:\n line = f.readline()\n if not line: break\n for i in range(6):\n line = line.replace('[{0}]'.format(i), param_list[i])\n line = line.replace('[7]', param_list[7])\n if line.find('[6]') != -1:\n for dep in dep_pkg:\n line_dep = '\\t<depend>{0}</depend>\\n'.format(dep)\n o.write(line_dep)\n flag = 1\n elif line.find('[8]') != -1:\n for dep, tp in zip(msg, msg_type):\n line_dep = '\\t\\t<depend type=\"{1}\">{0}</depend>\\n'.format(dep, tp)\n o.write(line_dep)\n flag = 1\n elif line.find('<subscribers>') != -1:\n o.write('\\t\\t<subscribers>\\n')\n for sub in self.manager.wid.sub_list:\n o.write('\\t\\t\\t<sub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(sub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(sub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(sub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(sub['queue_size']))\n o.write('\\t\\t\\t</sub>\\n')\n o.write('\\t\\t</subscribers>\\n')\n flag = 1\n elif line.find('<publishers>') != -1:\n o.write('\\t\\t<publishers>\\n')\n for pub in self.manager.wid.pub_list:\n o.write('\\t\\t\\t<pub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(pub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(pub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(pub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(pub['queue_size']))\n o.write('\\t\\t\\t</pub>\\n')\n o.write('\\t\\t</publishers>\\n')\n flag = 1\n if flag == 0:\n o.write(line)\n else:\n flag = 0\n o.close()\n f.close()\n self.changed = False",
"def to_xml_file(self, xml_file_path):\n s = self.to_xml()\n with open(xml_file_path, \"w+b\") as f:\n f.write(s)",
"def saveToXml(self) -> org.jdom.Element:\n ...",
"def getXML(self):\n\n def _getElementForMappingEntry(entry, mappingStyle):\n xmlDocTmp = Document()\n element = xmlDocTmp.createElement(mappingStyle)\n for k, v in viewitems(entry):\n # ignore empty, None or compiled regexp items into output\n if not v or (k == \"path-match-expr\"):\n continue\n element.setAttribute(k, str(v))\n return element\n\n xmlDoc = Document()\n root = xmlDoc.createElement(\"storage-mapping\") # root element name\n for mappingStyle, mappings in viewitems(self):\n for mapping in mappings:\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\n root.appendChild(mapElem)\n return root.toprettyxml()",
"def write(self):\n temp_string = minidom.parseString(ET.tostring(self.root)).toprettyxml(encoding=\"UTF-8\")\n with open(self.xml_file, 'w') as f:\n f.write(temp_string)\n # f = open(self.xml_file, \"w\")\n # f.write(temp_string)\n # f.close()",
"def write(self):\n filters = {\n 'MSGUID': lambda x: ('{%s}' % x).upper(),\n 'relslnfile': lambda x: os.path.relpath(x, os.path.dirname(self.FileName))\n }\n context = {\n 'sln': self\n }\n return self.render(self.__jinja_template__, self.FileName, context, filters)",
"def generate(self):\n xml = self.template()\n fp = BytesIO()\n gzip = GzipFile(self.filename, \"wb\", 9, fp)\n if isinstance(xml, str):\n xml = xml.encode(\"utf8\")\n gzip.write(xml)\n gzip.close()\n data = fp.getvalue()\n fp.close()\n return data",
"def to_xml(self) -> str:\n # default name and stuff setup\n element_root, xml_tree = super()._add_basics()\n element_root = element_root.find('elementProp')\n element_root = element_root.find('collectionProp')\n for element in list(element_root):\n try:\n if element.attrib['name'] == 'influxdbUrl':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.influx_db_url:\n elem.text = self.influx_db_url\n elif element.attrib['name'] == 'application':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.application:\n elem.text = self.application\n elif element.attrib['name'] == 'measurement':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.measurement:\n elem.text = self.application\n elif element.attrib['name'] == 'summaryOnly':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value':\n elem.text = str(self.summary_only).lower()\n elif element.attrib['name'] == 'samplersRegex':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.samplers_regexp:\n elem.text = self.samplers_regexp\n elif element.attrib['name'] == 'percentiles':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.percentiles:\n elem.text = self.percentiles\n elif element.attrib['name'] == 'testTitle':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.test_title:\n elem.text = self.test_title\n elif element.attrib['name'] == 'eventTags':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.event_tags:\n elem.text = self.event_tags\n except Exception:\n raise Exception(f'Unable to render xml from {type(self).__class__}')\n return tree_to_str(xml_tree, hashtree=True)",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def getXSLURL(self, output='page'):\n mn_props = getToolByName(self, \"portal_properties\")['metnav_properties']\n output = output.lower().strip()\n if output == 'page':\n return mn_props.getProperty('XSL_PAGE', '')\n if output == 'portlet':\n return mn_props.getProperty('XSL_PORTLET', '')\n if output == 'dict':\n return mn_props.getProperty('XSL_DICT', '')\n if output == 'count':\n return mn_props.getProperty('XSL_COUNT', '')\n if output == 'rss':\n return mn_props.getProperty('XSL_RSS', '')\n if output == 'class_list':\n return mn_props.getProperty('XSL_CLASS_LIST', '')\n if output == 'table':\n return mn_props.getProperty('XSL_TABLE', '')\n if output == 'year_list':\n return mn_props.getProperty('XSL_YEAR_LIST', '')\n raise \"%s is not a valid value for an XSL output\" % output",
"def transform_s3_xsl(**kwargs):\n access_id = kwargs.get(\"access_id\")\n access_secret = kwargs.get(\"access_secret\")\n bucket = kwargs.get(\"bucket\")\n dest_prefix = kwargs.get(\"destination_prefix\")\n source_prefix = kwargs.get(\"source_prefix\")\n if kwargs.get(\"dag\"):\n run_id = kwargs.get(\"dag\").dag_id\n else:\n run_id = \"no-dag-provided\"\n\n saxon = prepare_saxon_engine()\n transformed = etree.Element(\"collection\")\n transformed.attrib[\"dag-id\"] = run_id\n transformed.attrib[\"dag-timestamp\"] = kwargs.get(\"timestamp\", \"no-timestamp-provided\")\n xsl = \"https://raw.github.com/{repo}/{branch}/{filename}\".format(\n repo=kwargs.get(\"xsl_repository\", \"tulibraries/aggregator_mdx\"),\n branch=kwargs.get(\"xsl_branch\", \"main\"),\n filename=kwargs.get(\"xsl_filename\")\n )\n\n for s3_key in process.list_s3_content(bucket, access_id, access_secret, source_prefix):\n logging.info(\"Transforming File %s\", s3_key)\n s3_content = process.get_s3_content(bucket, s3_key, access_id, access_secret)\n s3_xml = etree.fromstring(s3_content)\n for record in s3_xml.iterchildren():\n record_id = record.get(\"airflow-record-id\")\n logging.info(\"Transforming Record %s\", record_id)\n result_str = subprocess.check_output([\"java\", \"-jar\", saxon, \"-xsl:\" + xsl, \"-s:-\"], input=etree.tostring(record, encoding=\"utf-8\"))\n result = etree.fromstring(result_str)\n result.attrib[\"airflow-record-id\"] = record_id\n transformed.append(result)\n filename = s3_key.replace(source_prefix, dest_prefix)\n transformed_xml = etree.tostring(transformed, encoding=\"utf-8\")\n process.generate_s3_object(transformed_xml, bucket, filename, access_id, access_secret)",
"def export_to_xml(self, resource_fs):\r\n\r\n # Set up runtime.export_fs so that it's available through future\r\n # uses of the pure xblock add_xml_to_node api\r\n self.runtime.export_fs = resource_fs\r\n\r\n # Get the definition\r\n xml_object = self.definition_to_xml(resource_fs)\r\n self.clean_metadata_from_xml(xml_object)\r\n\r\n # Set the tag so we get the file path right\r\n xml_object.tag = self.category\r\n\r\n # Add the non-inherited metadata\r\n for attr in sorted(own_metadata(self)):\r\n # don't want e.g. data_dir\r\n if attr not in self.metadata_to_strip and attr not in self.metadata_to_export_to_policy:\r\n val = serialize_field(self._field_data.get(self, attr))\r\n try:\r\n xml_object.set(attr, val)\r\n except Exception:\r\n logging.exception(\r\n u'Failed to serialize metadata attribute %s with value %s in module %s. This could mean data loss!!!',\r\n attr, val, self.url_name\r\n )\r\n\r\n for key, value in self.xml_attributes.items():\r\n if key not in self.metadata_to_strip:\r\n xml_object.set(key, value)\r\n\r\n if self.export_to_file():\r\n # Write the definition to a file\r\n url_path = name_to_pathname(self.url_name)\r\n filepath = self._format_filepath(self.category, url_path)\r\n resource_fs.makedir(os.path.dirname(filepath), recursive=True, allow_recreate=True)\r\n with resource_fs.open(filepath, 'w') as file:\r\n file.write(etree.tostring(xml_object, pretty_print=True, encoding='utf-8'))\r\n\r\n # And return just a pointer with the category and filename.\r\n record_object = etree.Element(self.category)\r\n else:\r\n record_object = xml_object\r\n\r\n record_object.set('url_name', self.url_name)\r\n\r\n # Special case for course pointers:\r\n if self.category == 'course':\r\n # add org and course attributes on the pointer tag\r\n record_object.set('org', self.location.org)\r\n record_object.set('course', self.location.course)\r\n\r\n return etree.tostring(record_object, pretty_print=True, encoding='utf-8')",
"def writeXMLDecl(self):\n return _libsbml.XMLOutputStream_writeXMLDecl(self)",
"def setXSLTMode(self,value):\n self.PDFreactorConfiguration.in1[\"XSLTMode\"] = value",
"def save(self, filename=None):\n f = filename if filename else self.path\n etree.register_namespace('', TEI)\n etree.register_namespace('mith', MITH)\n self.doc.write(f, xml_declaration=True, encoding='utf-8', method='xml')",
"def toXML(self):\n return self._xmlpre+\"\\n\".join(map(lambda f:f.toXML(),self._items))+self._xmlpost",
"def to_xml(self):\n # lines = super(FileCatNoEmpty, self).cat(filepath)\n structure = super(Point, self).to_xml()\n\n\n coords = GeometryTopologyData.__to_xml_vector__(self.coordinate, self.format)\n # description_str = ''\n # if self.description is not None:\n # description_str = '<Description>%s</Description>' % self.description\n\n return '<Point>%s<Coordinate>%s</Coordinate></Point>' % (structure, coords)",
"def write(klass, document, target=None, stylesheet=\"\"):\n writer = LatexWriter(document, target, stylesheet)\n return writer.go()",
"def to_xml(self, file_name=None):\n if file_name:\n xml_file = open(file_name, 'w')\n results = ['<schema name=\"%s\">' % self.name]\n for schema_object in list(self.schema.keys()):\n results.append(self.schema[schema_object].to_xml())\n results.append('</schema>')\n if file_name:\n xml_file.write('\\n'.join(results))\n xml_file.close()\n else:\n return '\\n'.join(results)",
"def write_xosc(self, generated_xml):\n reparsed_xml = minidom.parseString(generated_xml).toprettyxml(indent=\" \")\n xosc_file = open(self._filepath, \"w\")\n xosc_file.write(reparsed_xml)\n xosc_file.close()\n\n msg = QMessageBox()\n if self._warning_message:\n msg.setIcon(QMessageBox.Warning)\n text = f\"Exported OpenSCENARIO file {self._filepath} has warnings!\\n\\n\"\n text += \"\\n\".join(self._warning_message)\n else:\n msg.setIcon(QMessageBox.Information)\n text = f\"Successfully exported OpenSCENARIO file to {self._filepath}\"\n msg.setText(text)\n msg.setWindowTitle(\"OpenSCENARIO Export\")\n msg.setStandardButtons(QMessageBox.Ok)\n msg.exec()",
"def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()",
"def start_serialization(self):\n self.xml = SimplerXMLGenerator(self.stream, self.options.get(\"encoding\", settings.DEFAULT_CHARSET))\n self.xml.startDocument()\n self.xml.startElement(\"xliff\", {\n \"version\": \"1.2\",\n \"xmlns\": \"urn:oasis:names:tc:xliff:document:1.2\",\n \"xmlns:d\": \"https://docs.djangoproject.com/\"\n })",
"def XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\n\n\t#On commence par afficher ce qu'on fait\r\n\tprint \" Build xml file \"\r\n\r\tprint InputsFile\n\t#ouverture du fichier dans lequel on place le source model\n\ttry:\n\t\tfresult = open(OutputFile, 'w')\n\texcept:\n\t\tprint \"Coucou\"\r\n \t#ecriture des premieres lignes invariantes\n\tfresult.write('<?xml version=\"1.0\" ?>')\r\n\tfresult.write(\"<source_library title=\\\"source library\\\">\\n\")\n\r\n \t#ouverture du fichier avec les entrees\r\n\tf = open(InputsFile,\"r\")\r\n\tlines = f.readlines()\r\n\t\r\n \t#Ajout des sources detectees dans le catalogue\n\t#Pour chaque ligne du fichier d'entree\r\n\tfor line in range(len(lines)):\n\t\t#Lire les donnees de la ligne\t\t\r\n\t\tdata = lines[line].split()\r\n\t\tname = data[0]\n\n\t\t#Verification : est on en train de traiter la source que l'on veut etudier ou une autre ?\r\n\t\tif str(name) == Name :\r\n\t\t\tmysource = 1\r\n\t\telse:\r\n\t\t\tmysource = 0\n\n\t\t#recuperation des donnees\r\n\t\tRA = data[1]\r\n\t\tDEC = data[2]\r\n\t\tIntegral = float(data[3])*float(Frac)\r\n\t\tGamma= data[4]\n\n\t\t\r\n\t\ttry:\n\t\t\t#essai de definition des donnees pour un PL avec ExpCut\n\t\t\tPrefactor = float(data[5])*float(Frac)\r\n\t\t\tEnergy = float(data[6])\r\n\t#\t\tPrefactor = Prefactor/pow(Energy/100., float(Gamma)) #Densite de flux calculee a Epivot\r\n\t#\t\tPrefactor = Prefactor*pow(1000./100., float(Gamma)) #We do the calculation with (E/1000.)^Gamma\n\t\t\tvariabilite=float(data[8])\n\n#\t\t\tprint variabilite\n\n\n\n\r\n\t\t\tcut = float(data[7]) # Cut est la variable qui nous permettra de savoir si il faut utiliser un cut off (1) ou une loi de puissance normale (2)\r\n\t\texcept:\r\n\t\t\ttry:\r\n\t\t\t\tcut = float(data[5])\r\n\t\t\texcept:\r\n\t\t\t\tprint \" Wrong size of list \"\r\n\t\t\t\tsys.exit()\r\n \t#Si on considere un ccut off exponentiel pour la source :\r\n\t\tif cut == 1:\n\t\t\t#ecriture du nom de la source consideree\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\r\n\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\r\n\t\t\tspectrum_type = \"PLSuperExpCutoff\"\n\t\t\t#Utilisation de la modelisation PLSuperExpCutoff car plus simple et plus intuitive pour nous et pour la modelisation des pulsars si il faut en modeliser\n\r\n\t\t\t#definition des parametres spectraux a prendre en comtpe et de la chaine de caractere a integrer\r\n\n\n\n\t\t\tif variabilite==0.0 or variabilite==2.0:\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"10000000.0\\\" min=\\\"0.0000001\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\r\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.001\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\n\r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\t\t\telif variabilite==1.0 :\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10000000.0\\\" min=\\\"0.0\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.0001\\\"\"\r\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\n\r\n \r\n\n# <spectrum type=\"PLSuperExpCutoff\">\n# <parameter free=\"1\" max=\"100000\" min=\"0\" name=\"Prefactor\" scale=\"1e-10\" value=\"Prefactor*1e-10\"/>\n# <parameter free=\"1\" max=\"0\" min=\"5\" name=\"Index1\" scale=\"-1\" value=\"valeur du catalogue\"/>\n# <parameter free=\"0\" max=\"20000\" min=\"1.0\" name=\"Scale\" scale=\"1\" value=\"Epivot\"/>\n# <parameter free=\"1\" max=\"300000\" min=\"100\" name=\"Cutoff\" scale=\"1\" value=\"3000\"/>\n# <parameter free=\"0\" max=\"5\" min=\"0\" name=\"Index2\" scale=\"1\" value=\"1.5\"/>\n# </spectrum>\n\n\r\n\t\telse:\n\t\t#Sinon (si on considere une loi de puissance simple)\n\t\t#definition de la chaine de caractere comportant le nom de la source\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\n\t\t\tif mysource == 0:\r\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\n\t\t\telse:\n\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\t\t\t\t\n\n\t\t\t#definition de la chaine de caractere correspondant a la forme de fit que l'on souhaite utiliser (Loi de puissance)\r\n\t\t\tspectrum_type = \"PowerLaw2\"\r\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre Integrale\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\telse:\n\t\t\t#sinon on le libere\r\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\n\n\n\n\n\n\t\t\t#Toujours ce facteur....\r\n\t\t\tIntegral = float(Integral)*1e10\r\n\t\t\tscale = 1e-10\n\n\n\t\n\r\n\t\t\tspectrum_lines += \" name=\\\"Integral\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre gamma\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\telse:\n\t\t\t\t#si c'est pas la source que l'on etudie on le laisse libre\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\n\n\t\t\t#fin de la chaine de parametres sur le modele spectral\r\n\t\t\tspectrum_lines += \" name=\\\"Index\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t \n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"1000.0\\\"/>\\n\"\r\n \r\n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\t\t\telse:\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"100\\\"/>\\n\"\n\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"100000.0\\\" Min =\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\n \t\t#ajout du modele spectral a la liste de parametres \r\n\t\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\t\tresult_line += spectrum_lines\r\n\t\tresult_line += \" </spectrum>\\n\"\n\n\t\t\n\n\t\tif mysource==0 and variabilite!=1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telif mysource==0 and variabilite==1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telse:\n #ajout du modele spatial a la liste de parametres \n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\t\t\n\t\tresult_line += \" </source>\\n\"\r\n\t\tfresult.write(result_line+\"\\n\")\r\n #Ajout du fond diffus galactique\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"gal_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"ConstantValue\"\r\n\r\n\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Value\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n\r\n\tresult_line += \" <spatialModel file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/gll_iem_v02.fit\\\" type=\\\"MapCubeFunction\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"1000.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Normalization\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\r\n \t#Ajout du fond diffus extragalactique\r\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"eg_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"FileFunction\"\r\n\r\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Normalization\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/isotropic_iem_v02.txt\\\" type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n \r\n\tresult_line += \" <spatialModel type=\\\"ConstantValue\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"100.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Value\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\n \t#Fermeture des fichiers \r\n\tf.close() \r\n\tfresult.write(\"\\n</source_library>\\n\")\r\n\tfresult.close()\r\n\treturn",
"def get(self):\n return _SALOMERuntime.OutputXmlPort_get(self)",
"def toXML(self):\n return _libsbml.Layout_toXML(self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def write(self):\r\n for prop in self.prpnames:\r\n elem = SubElement(self._root, prop)\r\n data = self.__getattribute__(prop)\r\n if self.prpnames[prop]['type'] == \"text\":\r\n elem.text = data\r\n elif self.prpnames[prop]['type'] == 'list':\r\n for x in data:\r\n SubElement(elem, 'regel').text = x\r\n elif self.prpnames[prop]['type'] == 'attr':\r\n elem.set(self.prpnames[prop]['naam'], data)\r\n tree = ElementTree(self._root)\r\n tree.write(self._fn)\r\n if not self.exists:\r\n self.exists = True",
"def write(self, file_or_filename):\n etMap = revert(self)\n xmlTree = ET.ElementTree(etMap)\n xmlTree.write(file_or_filename)",
"def save_to_xml(self, xwriter):\r\n\r\n xwriter.WriteStartElement(\"Profile\")\r\n xwriter.WriteAttributeString(\"Name\", self.Name)\r\n xwriter.WriteStartAttribute(\"Version\")\r\n xwriter.WriteValue(self.Version)\r\n xwriter.WriteEndAttribute()\r\n\r\n for var_name in self.__dict__:\r\n var_type = type(getattr(self, var_name))\r\n\r\n if var_type is str and var_name != \"Name\":\r\n self.write_string_to_xml(var_name, xwriter)\r\n\r\n elif var_type is bool:\r\n self.write_bool_to_xml(var_name, xwriter)\r\n\r\n elif var_type is dict:\r\n self.write_dict_to_xml(var_name, xwriter)\r\n\r\n elif var_type is list and var_name != \"ExcludeRules\":\r\n self.write_list_to_xml(var_name, xwriter)\r\n\r\n xwriter.WriteStartElement(\"ExcludeRules\")\r\n xwriter.WriteAttributeString(\"Operator\", self.ExcludeOperator)\r\n xwriter.WriteAttributeString(\"ExcludeMode\", self.ExcludeMode)\r\n for rule in self.ExcludeRules:\r\n if rule:\r\n rule.save_xml(xwriter)\r\n xwriter.WriteEndElement()\r\n \r\n xwriter.WriteEndElement()",
"def xmlWrite(self, xmlWriter, font, value, name, attrs):\n raise NotImplementedError(self)",
"def writeXMLNS(self, *args):\n return _libsbml.ASTBasePlugin_writeXMLNS(self, *args)",
"def write_output_file(self, xml_text, xml_file):\n xml_fo = open(xml_file, 'w')\n xml_fo.write(xml_text+'</xml>')\n xml_fo.close()\n return",
"def _generate_xml(self, body, destn_dir, nodes=True):\n fn = ''.join([random.choice(string.ascii_letters) for _ in range(12)])\n fn += '.xml'\n\n _dir = os.path.dirname(os.path.abspath(__file__))\n _tmpl = 'multi_node.template' if nodes else 'single_node.template'\n _env = Environment(autoescape=False,\n loader=FileSystemLoader(_dir),\n trim_blocks=False)\n\n with open(fn, 'w+') as f:\n o = _env.get_template(_tmpl).render(body)\n f.write(o)\n\n _d = destn_dir + '/' + fn\n self._remote_copy(fn, _d)\n # Remove the XML file created locally\n os.remove(fn)\n\n return _d",
"def dumps(records, xslt_filename=None, **kwargs):\n root = dumps_etree(records=records, xslt_filename=xslt_filename)\n return etree.tostring(\n root,\n pretty_print=True,\n xml_declaration=True,\n encoding='UTF-8',\n **kwargs\n )",
"def xml(self):\n raise NotImplementedError('This api does not return xml')",
"def _writeXML(self,output,outputDictionary):\n if self.dynamic:\n outputInstance = xmlUtils.DynamicXmlElement('MetricPostProcessor', pivotParam=self.pivotParameter)\n else:\n outputInstance = xmlUtils.StaticXmlElement('MetricPostProcessor')\n if self.dynamic:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n for ts, pivotVal in enumerate(self.pivotValues):\n if values.shape[0] == 1:\n outputInstance.addScalar(nodeName, metricName,values[0], pivotVal=pivotVal)\n else:\n outputInstance.addScalar(nodeName, metricName,values[ts], pivotVal=pivotVal)\n else:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n if len(list(values)) == 1:\n outputInstance.addScalar(nodeName, metricName, values[0])\n else:\n self.raiseAnError(IOError, \"Multiple values are returned from metric '\", metricName, \"', this is currently not allowed\")\n return outputInstance",
"def writeXml(self):\n curdir = os.getcwd()\n os.chdir(self.Imagedir)\n allImageLists = [self.sciImlist, self.ctxImlist, self.wgtImlist, self.rmsImlist]\n \n for imlist in allImageLists:\n for im in imlist:\n file = xmlUtil.markupImage(im,dataset=self.obsName)\n \n # Don't write these images as output of this module, which\n # really doesn't have any.\n \n #if file not in self.outputList.keys():\n # self.outputList[file] = [im]\n \n os.chdir(curdir)\n return",
"def docType():\n return (u'<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n u'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 '\n u'Transitional//EN\" '\n u'\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n')",
"def to_xml(self, scene_dir: str) -> Tuple[Et.Element, bool]:\n raise NotImplementedError",
"def save_xml_file():\n global output_on_display, import_lst, column_names, data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = data[0]\n step = len(column_names)\n\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"XML\", \"*.xml\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.xml')\n data = import_lst\n\n if len(data[0]) == step:\n pass\n else:\n data = import_lst[step::]\n\n data2 = list(map(list, zip(*data)))\n\n data3 = {key: value for key, value in zip(column_names, data2)}\n\n column = list(data3.keys())\n\n df = pd.DataFrame(data3, columns=column)\n\n data_dict = df.to_dict(orient=\"records\")\n with open('output.json', \"w+\") as f:\n json.dump(data_dict, f, indent=4)\n\n xml_data = dicttoxml(data_dict).decode()\n with open(save_name, \"w+\") as f:\n f.write(xml_data)\n\n data.clear()\n data2.clear()\n data3.clear()",
"def Write(self):\n f = open(self.project_path, 'wt')\n self.doc.writexml(f,\n encoding='Windows-1252',\n addindent=' ',\n newl='\\n')\n f.close()",
"def write(self, filename, agg_dir):\n super().write(filename)\n\n if self.aggregation:\n agg = self.aggregation\n abs_subdir = os.path.join(agg_dir, agg.sub_dir)\n if not os.path.isdir(abs_subdir):\n os.makedirs(abs_subdir)\n\n agg.xml_element.write(os.path.join(abs_subdir, agg.basename))",
"def to_sbml(self, params):\n files = {}\n _id, cobra_model = self._ws_obj_to_cobra(params['input_ref'])\n files['file_path'] = os.path.join(params['destination_dir'], _id + \".xml\")\n cobra.io.write_sbml_model(cobra_model, files['file_path'])\n\n return _id, files",
"def write2file(self, save_to):\n headerstyle = xlwt.easyxf(self.header_style.get_style_string())\n missing_val_style = xlwt.easyxf(\n self.missing_value_style.get_style_string())\n row_styles = [xlwt.easyxf(self.first_style.get_style_string()),\n xlwt.easyxf(self.second_style.get_style_string())]\n\n properties, sections, table = self._build_table()\n\n workbook = xlwt.Workbook()\n sheet = workbook.add_sheet(self.sheet_name)\n\n if os.path.splitext(save_to)[-1] == '':\n save_to += '.xls'\n\n max_col_len = []\n\n if (self.switch):\n\n for i, prop in enumerate([''] + properties):\n sheet.write(0, i, prop, headerstyle)\n max_col_len.append(len(str(prop)))\n\n for row_num, sec in enumerate(sections):\n sheet.write(row_num + 1, 0, sec, headerstyle)\n if len(str(sec)) > max_col_len[0]:\n max_col_len[0] = len(str(sec))\n\n for row_num, row in enumerate(table):\n for col_num, elem in enumerate(row):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n else:\n\n for i, sec in enumerate([''] + sections):\n sheet.write(0, i, sec, headerstyle)\n max_col_len.append(len(str(sec)))\n\n for row_num, prop in enumerate(properties):\n sheet.write(row_num + 1, 0, prop, headerstyle)\n if len(str(prop)) > max_col_len[0]:\n max_col_len[0] = len(str(prop))\n\n for col_num, col in enumerate(table):\n for row_num, elem in enumerate(col):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n # adjust width of he columns\n for col_id, col_len in enumerate(max_col_len):\n sheet.col(col_id).width = (256 * (col_len+1))\n\n workbook.save(save_to)",
"def writeToTempXml(self):\n name = self.fileToProcess.name\n all_tokens = ET.Element(\"tokens\")\n for token in self.tokensTable:\n if token.getType() == KEYWORD:\n keyword = ET.SubElement(all_tokens, \"keyword\")\n keyword.text = ' '+token.getValue()+' '\n elif token.getType() == IDENTIFIER:\n identifier = ET.SubElement(all_tokens, \"identifier\")\n identifier.text = ' '+token.getValue()+' '\n elif token.getType() == SYMBOL:\n symbol = ET.SubElement(all_tokens, \"symbol\")\n symbol.text = ' '+token.getValue()+' '\n elif token.getType() == STRING_CONST:\n stringConstant = ET.SubElement(all_tokens, \"stringConstant\")\n stringConstant.text = ' '+token.getValue()+' '\n elif token.getType() == INT_CONST:\n integerConstant = ET.SubElement(all_tokens, \"integerConstant\")\n integerConstant.text = ' '+token.getValue()+' '\n tree = ET.ElementTree(all_tokens)\n tree.write(name + 'T' + '.xml')",
"def xslText(self):\n return u'<xsl:for-each select = \"./%s\">%s<xsl:choose>'\\\n '<xsl:when test=\"contains(., \\':\\')\"><a href=\"{.}\">'\\\n '<xsl:value-of select=\".\"/></a></xsl:when><xsl:otherwise>'\\\n '<a href=\"%s{.}\"><xsl:value-of select=\".\"/></a>'\\\n '</xsl:otherwise></xsl:choose>%s</xsl:for-each>' % \\\n (self.name, xslEscape(self.prefix), self.URLMethod,\n xslEscape(self.suffix))",
"def getXML(self):\n nodes = list(self.nodes(data=True))\n nodes.sort()\n node_string = ''\n for n in nodes:\n attribute_string = ''\n keys = list(n[1].keys())\n keys.sort()\n for k in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(k, n[1][k], k)\n modification_string = ''\n modified_by = self.predecessors(n[0])\n if modified_by:\n for mod in modified_by:\n modification_string += \"\"\"<modified_by>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifyingNode> %s </modifyingNode>\\n\"\"\"%mod.getTagID()\n modification_string += \\\n \"\"\"<modifyingCategory> %s </modifyingCategory>\\n\"\"\"%mod.getCategory()\n modification_string += \"\"\"</modified_by>\\n\"\"\"\n modifies = self.successors(n[0])\n if modifies:\n for modified in modifies:\n modification_string += \"\"\"<modifies>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifiedNode> {0} </modifiedNode>\\n\"\"\".format(modified.getTagID())\n modification_string += \\\n \"\"\"</modifies>\\n\"\"\"\n node_string += \\\n NODE_XML_SKEL.format(attribute_string+\"{0}\".format(n[0].getXML()) +\\\n modification_string)\n edges = list(self.edges(data=True))\n edges.sort()\n edge_string = ''\n for edge in edges:\n keys = list(edge[2].keys())\n keys.sort()\n attribute_string = ''\n for key in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(key, edge[2][key], key)\n edge_string += \"{0}\".format(EDGE_XML_SKEL.format(edge[0].getTagID(),\n edge[1].getTagID(),\n attribute_string))\n\n return CONTEXT_MARKUP_XML_SKEL.format(xmlScrub(self.getRawText()),\n xmlScrub(self.getText()),\n node_string,\n edge_string)",
"def writeXMLNS(self, *args):\n return _libsbml.MultiASTPlugin_writeXMLNS(self, *args)",
"def run_xslt(xml_filename, xsl_filename):\n import subprocess\n from misc.localexec import LocalExec\n from distutils.spawn import find_executable\n\n def seekout_xsltproc():\n XSLTPROC_BIN = 'xsltproc'\n executable = find_executable(XSLTPROC_BIN)\n if executable:\n return os.path.abspath(executable)\n raise SignerError(\"it has not found {} binary\".format(XSLTPROC_BIN))\n\n le = LocalExec(err_mute=True)\n exe = seekout_xsltproc()\n exe_args = [ xsl_filename, xml_filename ]\n\n try:\n return le([exe] + exe_args, cmd_timeout=20, ign_rcs=None)\n except subprocess.CalledProcessError as e:\n msg = \"Command raised exception\\nOutput: \" + str(e.output)\n raise Exception(msg)",
"def _write_context_to_file(self, context):\n om.out.debug('[xml_file.flush()] Starting _write_context_to_file()')\n\n template = self._jinja2_env.get_template('root.tpl')\n\n # We use streaming as explained here:\n #\n # http://flask.pocoo.org/docs/0.12/patterns/streaming/\n #\n # To prevent having the whole XML in memory\n # pylint: disable=E1101\n report_stream = template.stream(context)\n report_stream.enable_buffering(3)\n # pylint: enable=E1101\n\n # Write everything to a temp file, this is useful in two cases:\n #\n # * An external tool will always see a valid XML in the output,\n # and not just a partially written XML document.\n #\n # * If w3af is killed in the middle of writing the XML report,\n # the report file will still be valid -- if xml_file.flush() was\n # run successfully at least once\n tempfh = NamedTemporaryFile(delete=False,\n prefix='w3af-xml-output',\n suffix='.xml')\n\n om.out.debug('[xml_file.flush()] write_context_to_file() created'\n ' template.stream and NamedTemporaryFile')\n\n try:\n # Write each report section to the temp file\n for report_section in report_stream:\n tempfh.write(report_section.encode(DEFAULT_ENCODING))\n except Exception:\n # No exception handling is done here, we just raise the exception\n # so that the core can handle it properly\n raise\n else:\n # Close the temp file so all the content is flushed\n tempfh.close()\n\n om.out.debug('[xml_file.flush()] write_context_to_file() starting to'\n ' copy temp file to destination')\n\n # Copy to the real output file\n report_file_name = os.path.expanduser(self._file_name)\n\n cmd = 'cp %s %s' % (tempfh.name, report_file_name)\n subprocess.call(cmd, shell=True)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished copy'\n ' operation.')\n\n stat_info = os.stat(report_file_name)\n om.out.debug('The XML output file size is %s bytes.' % stat_info.st_size)\n\n finally:\n os.remove(tempfh.name)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished')",
"def to_workbook(self) -> tuple:\n\n # Initialize the bytestream\n f = io.BytesIO()\n wb = xw.Workbook(f, {\"in_memory\": True})\n\n # Open a workbook\n self._book = wb\n self._book.set_properties({\"category\": \"atomica:databook\"})\n self._formats = standard_formats(self._book)\n self._references = {} # Reset the references dict\n\n # Write the contents\n self._write_pops()\n self._write_tdve()\n self._write_interpops()\n self._write_transfers()\n\n # Clean internal variables related to writing the worbkook\n self._book = None\n self._formats = None\n self._references = None\n\n return f, wb",
"def format_xml(self,query_results):\n results=query_results.data\n factory=factory_xml()\n dump=factory.dumps({'data':results})\n print(dump)\n # TODO return output for this\n return \"\"",
"def write_to_xml(dictData, metadata, xmlfile):\n\tfout = codecs.open(xmlfile, 'w', 'utf-8')\n\tfout.write('<?xml version = \"1.0\" encoding = \"UTF-8\" standalone = \"no\" ?>\\n')\n\tfout.write('<?xml-stylesheet type=\"text/xsl\" href=\"maketable.xsl\"?>\\n')\n\tfout.write('<root>\\n')\n\tfout.write('<meta>\\n')\n\tfor key, value in metadata.items():\n\t\tfout.write('<' + key + '>' + value + '</' + key + '>\\n')\n\tfout.write('</meta>\\n')\n\tfout.write('<content>\\n')\n\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dictData:\n\t\txmlline = ''\n\t\txmlline += '<word><headword>' + hw + '</headword><meanings>'\n\t\tfor meaning in meanings:\n\t\t\txmlline += '<m>' + meaning + '</m>'\n\t\txmlline += '</meanings>'\n\t\txmlline += '<verse>'\n\t\tlines = verse.split('<BR>')\n\t\tfor line in lines:\n\t\t\txmlline += '<line>' + line + '</line>'\n\t\txmlline += '</verse>'\n\t\txmlline += '<verseNumber>' + verseNumDetails + '</verseNumber>'\n\t\txmlline += '<pageNumber>' + pageNumDetails + '</pageNumber></word>'\n\t\t# Write in babylon format. <BR><BR> is to separate verses.\n\t\tfout.write(xmlline + '\\n')\n\t\txmlline = ''\n\tfout.write('</content>\\n</root>')\n\tfout.close()\n\n\t# Give some summary to the user\n\tprint('XML file generated. Success!')\n\tprint('{} metadata lines and {} content lines written to XML file.'.format(len(metadata), len(dictData)))",
"def xml(self):\n return self._xml",
"def xml(self):\n return self._xml",
"def writeSBMLToFile(self, *args):\n return _libsbml.SBMLWriter_writeSBMLToFile(self, *args)",
"def _create_xml_report(self, test, xml_obj):\n xml_report_path = os.path.join(test.work_dir,\n self.XML_REPORT_PATH)\n with open(xml_report_path, 'w') as xml_report:\n xml_report.write(etree.tostring(xml_obj, pretty_print=True))",
"def xml2html(self):\n handler = open(self.xml_doc).read()\n soup = BeautifulSoup(handler, 'xml')\n\n fw = open(self.filename_out, 'w')\n\n fw.write(\"<!DOCTYPE html>\" + os.linesep)\n fw.write(\"<html>\" + os.linesep)\n fw.write(\"<head>\" + os.linesep)\n fw.write('<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">' + os.linesep)\n fw.write(\"<link rel=\\\"stylesheet\\\" href=\\\"%s\\\" type=\\\"text/css\\\" />\" % self.stylesheet_name + os.linesep)\n fw.write(\"<title></title>\" + os.linesep)\n fw.write(\"</head>\" + os.linesep)\n fw.write(\"<body>\" + os.linesep)\n\n # Load styles in dictionaries\n for style in soup.find_all(\"style\"):\n style_name = style.get(\"style:name\")\n #print \"style: %s children: %s descendants: %s\" % (str(style_name), str(len(list(style.children))), len(list(style.descendants)))\n for style_child in style.children:\n fs = style_child.get(\"fo:font-style\")\n if fs:\n self.style_fontstyle[style_name] = fs\n fontw = style_child.get(\"fo:font-weight\")\n if fontw:\n self.style_fontweight[style_name] = fontw\n # read alignment\n txta = style_child.get(\"fo:text-align\")\n if txta:\n self.style_textalignment[style_name] = txta\n # !!!\n tu = style_child.get(\"style:text-underline-type\")\n if tu:\n self.style_textunderline[style_name] = \"underlined\"\n # page break\n break_before = style_child.get(\"fo:break-before\")\n if break_before:\n self.style_break_before[style_name] = break_before\n\n\n # Navigate down the document through h and p tags\n #\n for text in soup.find_all(re.compile(\"^h|^p\")):\n\n # From bs4 docs: If a tag has only one child, and that child is a NavigableString, the child is made available as .string:\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"P9\">- Any text here!</text:p>\n #\n # To do:\n #\n # Beware of this case:\n # - <text:p text:style-name=\"P8\">\n # <text:span text:style-name=\"T4\">\n #\n\n # Get the attributes so the styles and the outlines\n text_attrs = dict(text.attrs)\n\n # Get the styles, if any\n try:\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n if text.string:\n t = unicode(text.string)\n if t:\n fw.write(self.outliner(self.stylizer(t, t_style), t_outline_level, t_style).encode('utf-8'))\n\n # e.g. page breaks come as a node with no children whose style contains fo:break-before:\"page\"\n elif len(list(text.children)) == 0:\n fw.write(self.outliner(unicode(\"\"), t_outline_level, t_style).encode('utf-8'))\n\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"Textbody\">\n # jkjksk skjkjkjs dhh\n # <text:s />\n # <text:span text:style-name=\"T3\">Bold</text:span>\n # <text:s />\n # </text:p>\n #\n # else drill down one level\n else:\n buffer = unicode(\"\")\n t = buffer\n u = buffer\n t_outline_level = \"paragraph\"\n t_style = \"\"\n for i in text.children:\n # Get the attributes so the styles\n try:\n text_attrs = dict(i.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n # whenever the element has no style\n # take the parent's one\n try:\n text_attrs = dict(i.parent.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n # if the current tag has only one child, and that child is a NavigableString\n if i.string:\n t = unicode(i.string)\n\n # space\n elif i.name == \"s\":\n t = unicode(\" \")\n\n # else drill down another level\n else:\n t = unicode(\"\")\n for j in i.children:\n if j.string:\n u = unicode(j.string)\n elif j.name == \"s\":\n u = unicode(\" \")\n else:\n u = unicode(\"\")\n if u:\n t = t + self.stylizer(u, t_style)\n\n # build up a unicode string containing the whole paragraph\n if t:\n buffer = buffer + self.stylizer(t, t_style)\n\n # outline the buffered unicode string and write it to the output file\n fw.write(self.outliner(buffer, t_outline_level, t_style).encode('utf-8'))\n\n fw.write(\"</body>\" + os.linesep)\n fw.write(\"</html>\" + os.linesep)\n fw.close()",
"def writexml(file):\n OUTFILE=open(file,\"w\")\n doc = xml.dom.minidom.Document()\n\n # Create the <dec_reg_list> base element\n decl_reg_list = doc.createElement(\"decl_reg_list\")\n doc.appendChild(decl_reg_list)\n\n regname_old=\"\"\n rows.pop(0)\n for row in rows:\n (regdesc,regname,offset,default,regtype,expose_reg,depth,incsz,bitdesc,bitname,loc,bittype)= row\n if regname != regname_old:\n # Create the register element\n register = doc.createElement(\"register\")\n register.setAttribute(\"name\", regname)\n register.setAttribute(\"offset\", offset)\n if default != \"\" : register.setAttribute(\"default\", default)\n register.setAttribute(\"type\", regtype)\n if expose_reg == \"1\": register.setAttribute(\"usr\", expose_reg)\n if depth != \"\": register.setAttribute(\"size\", depth)\n if incsz != \"\": register.setAttribute(\"incsz\", incsz)\n text = doc.createTextNode(regdesc)\n register.appendChild(text)\n decl_reg_list.appendChild(register)\n \n # Create the field element\n if bitname != \"\":\n field = doc.createElement(\"field\")\n field.setAttribute(\"name\", bitname)\n if loc !=\"\": field.setAttribute(\"loc\", addcolon(loc))\n if bittype != \"\": field.setAttribute(\"type\", bittype)\n if bitdesc != \"\":\n text = doc.createTextNode(bitdesc)\n field.appendChild(text)\n register.appendChild(field)\n regname_old = regname\n\n\n # Print our newly created XML\n #print doc.toprettyxml(indent=\" \")\n #OUTFILE.write(doc.saveXML(decl_reg_list))\n OUTFILE.write(doc.toprettyxml(indent=\" \"))\n OUTFILE.close()",
"def export_to_file(self, filename):\n if len(filename.split(\".\")) == 1:\n filename += \".xml\"\n xmlstring = self._dommodel.toprettyxml(\" \", \"\\n\")\n with open(filename, \"w\") as f:\n f.write(xmlstring)",
"def write(self, filename):\n \n return self.model.write(filename,xml_declaration=True, encoding='utf-8')",
"def save_as(self, fname, base = None, indent = '', topns = True, namespaces = {}):\n with codecs.open(fname, \"w\", encoding=\"utf-8\") as outf:\n self.serialize_xml(outf.write, base=base, indent=indent, topns=topns, namespaces=namespaces)",
"def write(self):\n return JavaMLWriter(self)",
"def CreateXMLTransformer() -> TransformerFunc:\n return partial(traverse, transformation_table=XML_AST_transformation_table.copy())",
"def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez",
"def toXMLElement(self):\n property_element = xml.etree.ElementTree.Element('property')\n property_element.set('concept', self.concept_ref)\n\n if self.is_parent:\n property_element.set('isParent', 'true')\n\n return property_element",
"def xmlwrite(self, doc, filename):\n pathname = os.path.join(self.session.session_dir, filename)\n f = open(pathname, \"w\")\n doc.writexml(writer=f, indent=\"\", addindent=\" \", newl=\"\\n\", encoding=\"UTF-8\")\n f.close()",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def makexmlfunc(healpix,ra,dec,week1,week2,distance):\n\t\n\tif week1!=week2:\n\t\tidentity=\"%06d_%d_%d_w%03d_w%03d\" %(healpix,ra,dec,week1,week2)\n\t\tltcube=\"%s/lat_ltcube_weekly_w%03d_w%03d_p203_v001.fits\" %(cfg.home,week1,week2)\n\t\tspacecraft=\"%s/w%03d_w%03d_newspacecraft.fits\" %(cfg.ispace,week1,week2)\n\telse:\n\t\tidentity=\"%06d_%d_%d_w%03d\" %(healpix,ra,dec,week1)\n\t\tltcube=\"%s/lat_spacecraft_weekly_w%03d_p203_v001_ltcube.fits\" %(cfg.home,week1)\n\t\tspacecraft=\"%s/lat_spacecraft_weekly_w%03d_p202_v001.fits \" %(cfg.ispace,week1)\n\n\tregion_filtered=\"%s_region_filtered_gti.fits\" %(identity)\n\tfermisources=\"%s_fermisources_model.xml\" %(identity)\n\tinputmodel=\"%s_input_model.xml\" %(identity)\n\tfermis=\"%s_fermis.xml\" %identity\n\tresponse=\"P7REP_SOURCE_V15\"\n\tmakexmllog=\"%s_output_makexml.log\" %identity\n\tglobal extendedsource\n\tglobal numberofextendedsources\n\textendedlog=\"%s_number_of_extendedsources.log\" %identity\n\tExtendedList=\"ExtendedList.txt\"\n\tOthersList=\"OthersList.txt\"\n\n\t\n\twith open (makexmllog,'r') as outputFile: #opens the makexmllog file from makesyfunc. This document contains info about the extended sources.\n\t\t\n\t\tfor line in outputFile:\n\t\t\t\n\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\tif line.startswith('Added')==True:\n\t\t\t\t\ta,b=line.split('and ')\t\n\t\t\t\t\tb1,b2,b3=b.split(' ')\n\t\t\t\t\n\t\t\t\t\tnumberofextendedsources=int(b1) #b1 is the number of extended sources\n\toutputFile.close()\n\toutputFile=open(inputmodel, 'w')\n\tprint numberofextendedsources\n\n\tif numberofextendedsources==1: #if there is an extended source\n\t\twith open (makexmllog,'r') as outputFile:\n\t\t\n\t\t\tfor line in outputFile:\n\t\t\t\n\t\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\t\tif line.startswith('Extended')==True:\n\t\t\t\t\t\tprint line\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\tc,d=line.split(' in')\n\t\t\t\t\t\n\t\t\t\t\t\tc1,c2,c3,c4=c.split(' ')\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\textendedsource=str(c3) #extracts the name of the extended source from makexmllog\n\t\n\n\t\t\n\n\n\t\toutputFile.close()\t\n\n\n\t\n\n\t\twith open(\"%s\" %fermisources) as thefile: #opens the xml file that was created from makesyfunc\n\t\t\tfor line in thefile:\n\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==True:\n\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tspecial=str.replace(line,'%s.fits'%extendedsource,'%s/%s.fits' %(cfg.homesy,extendedsource)) \n\t\t\t\t\tprint special #replace with the correct path to the extendedsource(Templates folder)\n\t\t\t\n\t\t\t\t\tspecial1=str.replace(special,'type=\"SpatialMap\"','type=\"SpatialMap\" map_based_integral=\"true\"')\n\t\t\t\t\tprint special1 #instruction from fermi tutorial, you must add map_based...\n\t\t\t\t\toutputFile=open(fermis, 'w') #write to fermis, the original xml with the right path to the extended source\n\t\t\t\t\twith open(\"%s\" %fermisources,'r') as infile:\n\t\t\t\t\t\tfor line in infile:\n\t\t\t\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==False:\n\t\t\t\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\toutputFile.write(special1)\n\t\t\t\t\toutputFile.close()\n\t\t\t\t\t\t\t\t\t\n\n\n\t\t\t\n\t\toutputFile=open(inputmodel, 'w') #final xml file. contains the right path and the source info of \"your\" source.\n\t\twith open(fermis,'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\t\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\t\t\t\n\n\t\toutputFile.close()\n\t\n\t\twith open(\"%s_diffrsp.log\" % (identity), 'w') as outsyputFile: #run diffrsp if you have an extended source.\n\t\t\tsubprocess.call(['%s' %(cfg.pythoncommand),'gtdiffrsp.py', '%s' %(region_filtered),'%s' %(spacecraft), '%s' %inputmodel, '%s' %(response),'%s' %identity ],stdout=outsyputFile)\n\t\t\t\n\t\twith open(ExtendedList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\t\t\t\t\n\tif numberofextendedsources==0: #if there is no extended source\n\t\toutputFile=open('%s' %(inputmodel), 'w') #write to inputmodel, \"your\" source\n\t\twith open('%s' %(fermisources),'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\n\t\t\t\n\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\toutputFile.close()\n\tif numberofextendedsources>1:\n\t\twith open(OthersList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\n\tif numberofextendedsources==1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\\n\\\n \t%s\"%(numberofextendedsources,extendedsource))\n\t\toutsyputFile.close()\n\n\tif numberofextendedsources !=1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\" %(numberofextendedsources))\n\t\toutsyputFile.close()",
"def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml",
"def to_xml(self):\n xml_strings = ['<code_object name=\"%s\">' % self.name]\n xml_strings.append(' <type value=\"%s\" />' % self.object_type)\n xml_strings.append(' <source>')\n for source_line in self.source:\n xml_strings.append(source_line[1])\n xml_strings.append(' </source>')\n xml_strings.append('</code_object>')\n return \"\".join(xml_strings)",
"def _toFile(self):\n pass",
"def toGML(self):\n raise NotImplementedError",
"def addXSLTStyleSheet(self, content, URI):\n if self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] == None:\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] = []\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)\n else:\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)",
"def xml_path(self):\n return self.__xml_path",
"def generate_xml(self, provisioning):\n ET.SubElement(self.root, 'generator').text = __revision__\n ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n return self.provisioning2xml(provisioning)",
"def exportXml ( w, xml ):\n assert str ( type ( xml ) ) == \"<type 'str'>\"\n rawText = xml\n pattern = re.compile (r'[^\\S ]+')\n text = re.sub ( pattern, \"\", rawText )\n reparsed = MD.parseString ( text )\n w.write ( reparsed.toprettyxml ( indent = \"\\t\", encoding = \"UTF-8\" ) )",
"def toSBML(self):\n errors = self.document.checkConsistency()\n if errors > 0:\n for i in range(errors):\n print(\n self.document.getError(i).getSeverityAsString(),\n \": \",\n self.document.getError(i).getMessage(),\n )\n\n return libsbml.writeSBMLToString(self.document)"
] | [
"0.6366979",
"0.61544836",
"0.5839131",
"0.58340883",
"0.5812942",
"0.5640789",
"0.5632317",
"0.5603479",
"0.55815554",
"0.55431604",
"0.55276537",
"0.55154866",
"0.5513102",
"0.5510308",
"0.5451725",
"0.54285127",
"0.54037434",
"0.5307067",
"0.5298246",
"0.52886873",
"0.5272622",
"0.5271472",
"0.5232884",
"0.5201279",
"0.519453",
"0.5182671",
"0.5179153",
"0.5172932",
"0.5163209",
"0.5156673",
"0.5148088",
"0.51359093",
"0.5132218",
"0.51303387",
"0.5100232",
"0.50764483",
"0.5070601",
"0.5059149",
"0.50582504",
"0.5056313",
"0.5056309",
"0.5039356",
"0.5028861",
"0.5021943",
"0.5010669",
"0.50036734",
"0.5003039",
"0.49999213",
"0.49748772",
"0.49723393",
"0.49578944",
"0.49532372",
"0.49395603",
"0.4939085",
"0.48923746",
"0.48899695",
"0.48740843",
"0.48715433",
"0.48646557",
"0.48638257",
"0.4852056",
"0.4846309",
"0.48436296",
"0.48433435",
"0.48293883",
"0.4826439",
"0.48262388",
"0.4825601",
"0.48202866",
"0.48137426",
"0.48124427",
"0.4811109",
"0.48028645",
"0.48027924",
"0.47998756",
"0.4795888",
"0.4795888",
"0.47758362",
"0.4772382",
"0.4770035",
"0.4762882",
"0.47570086",
"0.47569758",
"0.4756163",
"0.4751184",
"0.4751131",
"0.47475907",
"0.4746994",
"0.47402462",
"0.47337463",
"0.47337046",
"0.47332537",
"0.47212258",
"0.4720437",
"0.47086617",
"0.47031793",
"0.4701611",
"0.46895015",
"0.46818498",
"0.46814537"
] | 0.5458654 | 14 |
Return XSL file test for data existance | def xslTestText(self):
return u'normalize-space(ancestor::*/%s)' % self.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def test_01_FindXml(self):",
"def test_input_output(self, filename):\n with open(sample_xml(filename), \"rb\") as xml_file:\n xml_output_expected = xml_file.read()\n root, doctype_dict = xmlio.parse(sample_xml(filename), return_doctype_dict=True)\n self.assertEqual(xmlio.output(root, None, doctype_dict), xml_output_expected)",
"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 test_check_if_output_file_exists():\n input_file = os.path.join(os.getcwd(), 'tests', 'input_test_file.docx')\n output_file = os.path.join(os.getcwd(), 'tests', 'output_test_file.txt')\n\n questions_parser = QuestionsParser()\n questions_parser.main(argv=['-i', input_file, '-o', output_file])\n assert os.path.exists(output_file)\n os.unlink(output_file)",
"def test_hasLocation(self):\n cases = [\n (self.test_eac + \"NE00601.xml\", False),\n (self.test_eac + \"NE00100.xml\", True),\n (self.test_eac + \"NE00201.xml\", True),\n (self.test_eac + \"NE01302.xml\", True),\n (self.test_eac + \"NE01101.xml\", False),\n (self.test_eac + \"NE00916.xml\", False),\n (self.test_eac + \"NE00201.xml\", True),\n ]\n for case in cases:\n source, expected = case\n doc = EacCpf.EacCpf(source,'http://www.example.com')\n self.assertNotEqual(doc, None)\n result = doc.hasLocation()\n self.assertNotEqual(result, None)\n self.assertEqual(result, expected)",
"def test_xml_files_with_missing_info():\n\n # Test when k is missing from constant type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/k_const.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when b is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/b_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_mod_arr.xml\"\n parser = XMLParser(xml_filename)",
"def test_does_validate_valid_xml_file(self):\n xml_file = join(\n getcwd(), 'testdata', 'newstest2019-defr-src-ts.de.FIXED.xml'\n )\n doc = valitest.ValidatableTestSet(xml_file)\n self.assertEqual(doc.setid, \"newstest2019\")\n self.assertEqual(doc.srclang, \"any\")",
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def testFilesExist(self):\n \n for year in range(2007,2013):\n self.assertTrue(os.path.exists(\"./IncomeHistogram_\"+ str(year)+\".pdf\"), \"A histogram didn't save to output.\")\n self.assertTrue(os.path.exists(\"./LogIncomeHistogram_\"+ str(year)+\".pdf\"), \"A histogram didn't save to output.\")\n self.assertTrue(os.path.exists(\"./IncomeBoxplot(log)_\"+ str(year)+\".pdf\"), \"A boxplot didn't save to output.\") \n self.assertTrue(os.path.exists(\"./results.txt\"), \"Results file doesn't exist.\")",
"def test_defaultFile(self):\n found = cesmEnvLib.checkFile(\"./test_checkXMLvar.py\", \"read\")\n self.assertTrue(found)",
"def test_xml_file(self):\n response = client.result(False, 'xml', 'unittest', file = 'test_file.csv')\n root = ET.fromstring(response)\n first_name = root[0][0][0].text\n self.assertEqual(first_name,'John', 'Should print John')\n nationality = '<nationality>' in response\n self.assertFalse(nationality, 'Nationality should not be present')",
"def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n # sprint(PrettyFormatAny.form(self.m_root_xml, 'A3-01-A - Entire Xml'))\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n # print(PrettyFormatAny.form(self.m_xml.controller_sect, 'A3-01-B - All Controllers Xml'))\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')\n # print(PrettyFormatAny.form(self.m_xml.controller, 'A3-01-C - First Controller Xml'))",
"def check_for_data():\n if not (os.path.exists(ep.get_test_data_path()) or os.path.exists(ep.get_dbn_weight_path())):\n return False\n return True",
"def test_case18(self):\n\n result = self.graph1.studentExists(\"student1\")\n\n self.assertTrue(result)",
"def test_getExistDates(self):\n cases = [\n (self.test_eac + \"NE01201.xml\",\"1858-01-01T00:00:00Z\",\"1935-08-21T00:00:00Z\"),\n (self.test_eac + \"NE00300.xml\",\"1960-01-01T00:00:00Z\",\"1977-12-31T00:00:00Z\"),\n (self.test_eac + \"NE01500.xml\",\"1981-01-01T00:00:00Z\",\"1981-12-31T00:00:00Z\")\n ]\n for case in cases:\n source, expected_from_date, expected_to_date = case\n doc = EacCpf.EacCpf(source, 'http://www.example.com')\n self.assertNotEqual(doc, None)\n fromDate, toDate = doc.getExistDates()\n self.assertEqual(fromDate, expected_from_date)\n self.assertEqual(toDate, expected_to_date)",
"def test_case17(self):\n\n result = self.graph1.studentExists(\"student5\")\n\n self.assertFalse(result)",
"def _check_deprecated_data_xml_node(self):\n xml_files = self.filter_files_ext('xml')\n self.msg_args = []\n for xml_file in xml_files:\n doc = self.parse_xml(os.path.join(self.module_path, xml_file))\n odoo_nodes = doc.xpath(\"/odoo\") \\\n if not isinstance(doc, string_types) else []\n children, data_node = ((odoo_nodes[0].getchildren(),\n odoo_nodes[0].findall('data'))\n if odoo_nodes else ([], []))\n if len(children) == 1 and len(data_node) == 1:\n lineno = odoo_nodes[0].sourceline\n self.msg_args.append((\"%s:%s\" % (xml_file, lineno)))\n if self.msg_args:\n return False\n return True",
"def test_getData(self):\n cases = [\n self.test_eac + 'NE01201.xml',\n self.test_eac + 'NE00201.xml',\n self.test_eac + 'NE00300.xml',\n self.test_eac + 'NE00500.xml',\n ]\n for case in cases:\n doc = EacCpf.EacCpf(case, 'http://www.example.com/metadata.xml', 'http://www.example.com/presentation.html')\n self.assertNotEqual(doc, None)\n result = doc.getData()\n self.assertNotEqual(result, None)\n self.assertGreater(len(result), 0)",
"def _CheckFileExistsWithData(self, logs, graph):\n self.assertTrue(graph in logs, 'File %s was not output.' % graph)\n self.assertTrue(logs[graph], 'File %s did not contain data.' % graph)",
"def checkAllFilesGenerated(self):\n root = get_exhale_root(self)\n containmentFolder = self.getAbsContainmentFolder()\n for node in root.all_nodes:\n if node.kind in [\"enumvalue\", \"group\"]:\n continue\n gen_file_path = os.path.join(containmentFolder, node.file_name)\n self.assertTrue(\n os.path.isfile(gen_file_path),\n \"File for {kind} node with refid=[{refid}] not generated to [{gen_file_path}]!\".format(\n kind=node.kind, refid=node.refid, gen_file_path=gen_file_path\n )\n )",
"def test_assemble_xml_file_A1(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write_blank(\"A1\", None)\n\n worksheet.write_blank(\"C2\", None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def resultExist(probName,algoName,fitName,inst,s,c,n,k,q,w,m,t,e):\n if probName == 'NKQ':\n nameOfF = './result/'+probName+'-'+algoName+'-F'+fitName+'-M'+m+'-I'+str(inst)+'-S'+str(s)+'-W'+str(w)+'-N'+str(n)+'-K'+str(k)+'-C'+str(c)+'-Q'+str(q)+'-T'+str(t)+'-E'+str(e)+'.txt'\n elif probName == 'NK' or probName == 'NonNK':\n nameOfF = './result/'+probName+'-'+algoName+'-F'+fitName+'-C'+str(c)+'-I'+str(inst)+'-S'+str(s)+'-W'+str(w)+'-N'+str(n)+'-K'+str(k)+'-E'+str(e)+'.txt'\n\n if os.path.isfile(nameOfF)==True:\n print nameOfF, 'exists!!!'\n return os.path.isfile(nameOfF)",
"def test_exists_false(self):\n self.assertFalse(Sample.exists('Not_a_Sample', self.sample_template))",
"def test_non_regression(self):\n main(\"Source_mobile.xml\", [[\"engine\", \"A320.xml\", \"A320.csv\"]], \"Resultat.xml\", gui=False)\n compare_xml_results(\"Resultat.xml\", \"Reference.xml\", self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'parameter_estimation':\n check = True\n self.assertTrue(check)",
"def test_ifFileExists():\n for name in config.toTest:\n testConfig = dynamicallyLoadModule(name)\n if \"file\" in testConfig.config and \"file_locations\" in testConfig.config:\n print \"File In Location: \"+ testConfig.config[\"name\"]\n yield assertionFunctions.checkIfFileExistsInPossibleLocations, testConfig.config\n elif \"file\" in testConfig.config:\n print \"File: \"+ testConfig.config[\"name\"]\n yield assertionFunctions.checkIfFileExists, testConfig.config",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'Time-Course':\n check = True\n self.assertTrue(check)",
"def test_exists_false(self):\n self.assertFalse(PrepSample.exists('Not_a_Sample', self.prep_template))",
"def test_exists_true(self):\n self.assertTrue(SampleTemplate.exists(self.test_study.id))",
"def test_exists_false(self):\n self.assertFalse(SampleTemplate.exists(self.new_study.id))",
"def test_xml_exist(xml_parser):\n\n assert xml_parser.get_dict()",
"def are_evaluations_created(path, number_of_evaluations):\n evaluation_ids = []\n try:\n with open(\"%s%sevaluations\" % (path, os.sep)) as evaluations_file:\n for line in evaluations_file:\n evaluation = line.strip()\n try:\n evaluation_id = bigml.api.get_evaluation_id(evaluation)\n evaluation_ids.append(evaluation_id)\n except ValueError:\n return False, evaluation_ids\n if len(evaluation_ids) == number_of_evaluations:\n return True, evaluation_ids\n else:\n return False, evaluation_ids\n except IOError:\n return False, evaluation_ids",
"def validate(file_in) :\n\tname = str(file_in.name)\n\tif name[-4:] != \".xml\" and name[-4:] != \".XML\" :\n\t\treturn False\n\txsd = open('wcdb/WorldCrises.xsd.xml', 'r')\n\txmlFile = open('wcdb/temp.xml', 'w')\n\txmlFile.write(file_in.read())\n\txmlFile = open('wcdb/temp.xml', 'r')\n\ttry:\n\t\tpsvi = pyxsval.parseAndValidate(\"wcdb/temp.xml\",\n\t\t\t\"wcdb/WorldCrises.xsd.xml\", xmlIfClass=pyxsval.XMLIF_ELEMENTTREE)\n\t\ttree = psvi.getTree()\n\texcept pyxsval.XsvalError, e:\n\t\treturn 'Validation aborted. ' + str(e)\n\texcept GenXmlIfError, e:\n\t\treturn 'Parsing aborted. ' + str(e)\n\texcept Exception as e:\n\t\t# catch all\n\t\treturn 'Exception. ' + str(e)\n\t#handle invalid case\n\treturn tree",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def example_xml_file43():\n return load_xml('datacite-v4.3-full-example.xml')",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def _check_file_exists_helper(self, report_path, filename):\n\n if not check_data_exists(report_path, [filename]):\n raise AssertionError(\n \"{} does not exist in location {}\".format(\n filename, report_path\n )\n )",
"def _check_xml_syntax_error(self):\n self.msg_args = []\n for xml_file in self.filter_files_ext('xml', relpath=True):\n result = self.parse_xml(os.path.join(self.module_path, xml_file))\n if isinstance(result, string_types):\n self.msg_args.append((\n xml_file, result.strip('\\n').replace('\\n', '|')))\n if self.msg_args:\n return False\n return True",
"def verified_excel_file(store, institute_list, temp_excel_dir):\n document_lines = []\n written_files = 0\n today = datetime.datetime.now().strftime('%Y-%m-%d')\n LOG.info('Creating verified variant document..')\n\n for cust in institute_list:\n verif_vars = store.verified(institute_id=cust)\n LOG.info('Found {} verified variants for customer {}'.format(len(verif_vars), cust))\n\n if not verif_vars:\n continue\n unique_callers = set()\n for var_type, var_callers in CALLERS.items():\n for caller in var_callers:\n unique_callers.add(caller.get('id'))\n cust_verified = export_verified_variants(verif_vars, unique_callers)\n\n document_name = '.'.join([cust, '_verified_variants', today]) + '.xlsx'\n workbook = Workbook(os.path.join(temp_excel_dir,document_name))\n Report_Sheet = workbook.add_worksheet()\n\n # Write the column header\n row = 0\n for col,field in enumerate(VERIFIED_VARIANTS_HEADER + list(unique_callers)):\n Report_Sheet.write(row,col,field)\n\n # Write variant lines, after header (start at line 1)\n for row, line in enumerate(cust_verified,1): # each line becomes a row in the document\n for col, field in enumerate(line): # each field in line becomes a cell\n Report_Sheet.write(row,col,field)\n workbook.close()\n\n if os.path.exists(os.path.join(temp_excel_dir,document_name)):\n written_files += 1\n\n return written_files",
"def datafileexist(filename):\n filePath = os.path.join(pathtofolder(), \"datas\", filename)\n fileFormat = '.csv'\n return os.path.exists(f'{filePath+fileFormat}')",
"def _valid_rootnode_file(self, xml_filepath: str) -> bool:\n\t\troot_name: str = get_xml_file(xml_filepath).tag\n\t\t# Iterate over RootNodes\n\t\tfor rootnode in self.root_nodes:\n\t\t\t# Check is filenames are identical\n\t\t\tif root_name == rootnode.name:\n\t\t\t\trootnode.subfiles.add(xml_filepath)\n\t\t\t\t# Return False, match is found\n\t\t\t\treturn False\n\n\t\t# Return True if no match found.\n\t\treturn True",
"def test_get_workflow_definition_xml(self):\n pass",
"def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')",
"def test_validate_invalid(self):\r\n self.assertEqual(get_tree_and_validate(self.invalid_xml, open(self.SCHEMA, 'r').read()), 0)",
"def test_schema_exists(self):\n return exclusions.open()",
"def example_xml_file41():\n return load_xml('datacite-v4.1-full-example.xml')",
"def test_generate_report():\n # Calling helper function to create data\n data = helper_create_data()\n cat_vars = ['C1', 'C2', 'C3', 'C4']\n num_vars = ['N1', 'N2', 'N3']\n\n # Positive test case: Checking whether the function runs properly or not\n assert eda.generate_report(data, cat_vars, num_vars), \\\n \"Expected True but False returned\"\n\n # Negative test case: Checking whether the function returns False\n # fr wrong output\n assert not eda.generate_report(data, cat_vars, \"String Input\"), \\\n \"Expected False but True returned\"",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'profile_likelihood':\n check = True\n self.assertTrue(check)",
"def test_xml_direct(self): \n response = client.result(True, 'xml', 'unittest', test_data = self.test_data)\n root = ET.fromstring(response)\n first_name = root[0][0][0].text\n self.assertEqual(first_name,'John', 'Should print John')\n nationality = '<nationality>' in response\n self.assertFalse(nationality, 'Nationality should not be present')",
"def check_xshear_output(self):\n lens_nchunk=self['lens_conf']['nchunk']\n tilenames=scat.get_tilenames(self['source_conf']['scat_table'])\n\n ntile=len(tilenames)\n for lens_chunk in xrange(lens_nchunk):\n print(\" checking chunk: %d/%d\" % (lens_chunk+1, lens_nchunk))\n for i,tilename in enumerate(tilenames):\n # first check if this source catalog exists\n if self._scat_exists(tilename):\n job=XShearWQJob(self['run'],\n lens_chunk,\n tilename)\n info=job.get_info()\n if not os.path.exists(info['output_file']):\n print(\"missing output:\",info['output_file'])",
"def test_assemble_xml_file(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n worksheet.str_table = SharedStringTable()\n worksheet.select()\n cell_format1 = Format({\"xf_index\": 1})\n cell_format2 = Format({\"xf_index\": 2})\n\n worksheet.merge_range(\"B3:C3\", \"Foo\", cell_format1)\n worksheet.merge_range(\"A2:D2\", \"\", cell_format2)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"A2:D3\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"1:4\">\n <c r=\"A2\" s=\"2\"/>\n <c r=\"B2\" s=\"2\"/>\n <c r=\"C2\" s=\"2\"/>\n <c r=\"D2\" s=\"2\"/>\n </row>\n <row r=\"3\" spans=\"1:4\">\n <c r=\"B3\" s=\"1\" t=\"s\">\n <v>0</v>\n </c>\n <c r=\"C3\" s=\"1\"/>\n </row>\n </sheetData>\n <mergeCells count=\"2\">\n <mergeCell ref=\"B3:C3\"/>\n <mergeCell ref=\"A2:D2\"/>\n </mergeCells>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def test_exist(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n MetadataTemplate.exists(self.study)",
"def missing_results(self):\n self.calc_progress()\n\n def no_result_exists(x):\n return not os.path.isfile(\n os.path.join(self.location, \"results\", RSLT_NM.format(x))\n )\n\n return tuple(filter(no_result_exists, range(1, self.num_batches + 1)))",
"def ruleset_create_success_hr():\n with open(\n os.path.join(TEST_DATA_DIRECTORY, \"create_ruleset_success_hr.md\")\n ) as file:\n f = file.read()\n return f",
"def test_validation_no_schema(self):\n TT = TEITransformer(scenario='drama')\n tei_path = \"tests/test_user_schema/tei.xml\"\n TT.load_tei(tei_path)\n with self.assertRaises(ValueError):\n TT.transform(output_format=\"html\")",
"def example_xml_file42():\n return load_xml('datacite-v4.2-full-example.xml')",
"def xslTestText(self):\n return u'normalize-space(child::*/%s)' % self.name",
"def validate_file(self):\n print \"\\n******\"\n print \" Done creating file. Validation messages follow.\"\n missing_nodes = {'group': [], 'dataset': []}\n custom_nodes = {'group': [], 'dataset': []}\n for ns in self.id_lookups:\n for id in self.id_lookups[ns]:\n for path in self.id_lookups[ns][id]:\n qty = self.id_lookups[ns][id][path]['qty']\n type = self.id_lookups[ns][id][path]['type']\n count = len(self.id_lookups[ns][id][path]['created'])\n if qty in ('!', '+') and count == 0:\n missing_nodes[type].append(\"%s:%s/%s\" % (ns, path, id))\n for path, node_list in self.all_nodes.iteritems():\n for root_node in node_list:\n self.validate_nodes(root_node, missing_nodes, custom_nodes)\n self.report_problems(missing_nodes, \"missing\")\n self.report_problems(custom_nodes, \"custom\")\n if self.custom_attributes:\n count = len(self.custom_attributes)\n print \"%i nodes with custom attributes\" % len(self.custom_attributes)\n if count > 20:\n print \"Only first 20 shown;\"\n names = self.custom_attributes.keys()[0:min(20, count)]\n nlist = []\n for name in names:\n nlist.append(name+ \"->\" +str(self.custom_attributes[name]))\n print nlist\n else:\n print \"No custom attributes. Good.\"",
"def generate_expected_file(self, expected_file, xml_name):\n\t\tlogging.info('Gerando arquivo de documentos esperados')\n\t\tcontent = self.read_xml(xml_name)\n\n\t\twith open(expected_file, 'w', newline='') as csvfile:\n\t\t\tfieldnames = ['QueryNumber', 'DocNumber', 'DocVotes']\n\t\t\twriter = csv.DictWriter(csvfile, fieldnames=fieldnames)\n\n\t\t\twriter.writeheader()\n\t\t\tfor index in range(0, len(content['QueryNumber'])):\n\t\t\t\tcount_results = 0\n\t\t\t\tlogging.info('Escrevendo documentos da consulta '+str(index+1)+'/'+str(len(content['QueryNumber'])))\n\t\t\t\tfor result in content['Records'][index]:\n\t\t\t\t\twriter.writerow({'QueryNumber': content['QueryNumber'][index], 'DocNumber': result[0], \n\t\t\t\t\t\t\t\t\t 'DocVotes': result[1]})\n\t\t\t\t\tcount_results += 1\n\t\t\t\t\tif count_results == int(content['Results'][index]): break",
"def example_xml_file():\n return load_xml('datacite-v3.1-full-example.xml')",
"def test_predicate1(self):\n xpb = XPathBuilder()\n xp = xpb.action.source[xpb.attr('project') == 'bar']\n exp = '/action/source[@project = \"bar\"]'\n self.assertEqual(xp.tostring(), exp)",
"def test_xml_safety_flag(self):\r\n\r\n self._setstaff_login()\r\n response = self._add_edx4edx()\r\n self.assertIn('GIT_IMPORT_WITH_XMLMODULESTORE', response.content)\r\n\r\n def_ms = modulestore()\r\n course = def_ms.courses.get('{0}/edx4edx_lite'.format(\r\n os.path.abspath(settings.DATA_DIR)), None)\r\n self.assertIsNone(course)",
"def test_incomplete_xml(self):\n self.__opener.contents = '<Report></Report>>'\n self.assertEqual(-1, self.__uft.failed_tests('url'))",
"def check_data():\n check_docs(\"Training\")\n check_docs(\"dev\")\n check_docs(\"Test\")",
"def is_good_enough_xml(self, resp):\n content_type = resp.headers['Content-Type'].lower()\n \n return (resp.status_code == 200 \n and content_type is not None \n and content_type.find('xml') > -1)",
"def test_XmlDump_compare_single(self):\n self._compare_variants(False)",
"def sniff( self, filename ):\n\n f = open( filename, \"r\" )\n firstlines = \"\".join( f.readlines(5) )\n f.close()\n\n if \"phyloxml\" in firstlines:\n return True\n return False",
"def _run_test_and_get_xml(self, flag):\n\n xml_fhandle, xml_fname = tempfile.mkstemp()\n os.close(xml_fhandle)\n\n try:\n binary = self._get_helper()\n args = [binary, flag, '--xml_output_file=%s' % xml_fname]\n ret = subprocess.call(args)\n self.assertEqual(ret, 0)\n\n xml = ElementTree.parse(xml_fname).getroot()\n finally:\n os.remove(xml_fname)\n\n return xml",
"def load_data_from_xsl(file_name):\n\tnlp_data = pd.read_excel(file_name, sheet_name=0, header=0, usecols=[1, 2, 3],\n\t converters={'bug_id': str, 'summary': str, 'description': str})\n\tnlp_data.fillna(' ', inplace=True)\n\n\t# nlp_data['description'] = nlp_data['description'].map(lambda x: clean_str(x+''))\n\n\treturn nlp_data",
"def test_predicate2(self):\n xpb = XPathBuilder()\n xp = xpb.action.source.where(xpb.attr('project').equals('bar'))\n exp = '/action/source[@project = \"bar\"]'\n self.assertEqual(xp.tostring(), exp)",
"def verifyFileExists(self, fileDir, fileName):\n # check that file exists\n fpath = fileDir.child(fileName)\n self.assertTrue(fpath.exists())\n\n # check that the output files have some content\n fcontents = fpath.getContent()\n self.assertTrue(len(fcontents) > 0)\n\n # check that the html files are at least html-ish\n # this is not a terribly rigorous check\n if fpath.path.endswith(\".html\"):\n self.assertIn(b\"<body\", fcontents)",
"def evaluate(self, xml_gold_path, xml_output_path):\n\n # Go through all files in xml_gold_path directory\n for file in os.listdir(xml_gold_path):\n\n # Set path to file\n file = xml_gold_path+file\n\n # Open files only, ignore subdirectories\n if os.path.isfile(file) and file.lower().endswith('.xml'):\n\n # Open xml files\n chapter_input_gold = open(file, 'r', encoding='utf8')\n chapter_input_test = open(xml_output_path+os.path.split(file)[-1], 'r', encoding='utf8')\n\n # Check if filenams are the same\n chapter_input_gold_name = os.path.split(chapter_input_gold.name)[-1]\n chapter_input_test_name = os.path.split(chapter_input_test.name)[-1]\n\n if chapter_input_gold_name == chapter_input_test_name:\n\n # Console log\n chapter_input_gold_name = chapter_input_gold.name\n chapter_input_test_name = chapter_input_test.name\n #print('Calculating score for: ' + chapter_input_gold_name + ' and: ' + chapter_input_test_name)\n\n # Process xml input file with BeautifulSoup\n chapter_input_gold = BeautifulSoup(chapter_input_gold, 'xml')\n chapter_input_test = BeautifulSoup(chapter_input_test, 'xml')\n\n # Empty variables for collecting Target scores\n target_precision_scores = 0\n target_recall_scores = 0\n target_f1_scores = 0\n target_jaccard_scores = 0\n\n # Empty variables for collecting Focus scores\n focus_precision_scores = 0\n focus_recall_scores = 0\n focus_f1_scores = 0\n focus_jaccard_scores = 0\n\n # Empty variables for collecting Negated scores\n negated_precision_scores = 0\n negated_recall_scores = 0\n negated_f1_scores = 0\n negated_jaccard_scores = 0\n\n # Empty variables for collecting Scope scores\n scope_precision_scores = 0\n scope_recall_scores = 0\n scope_f1_scores = 0\n scope_jaccard_scores = 0\n\n # Count sentences and frames\n sentence_count = 0\n gold_frames_count = 0\n test_frames_count = 0\n\n scope_gold_frames_count = 0\n #scope_test_frames_count = 0\n\n # Find all Gold and Test Sentences\n sentences_gold = chapter_input_gold.find_all('s')\n sentences_test = chapter_input_test.find_all('s')\n\n #targets_gold = chapter_input_gold.find_all('target')\n #targets_test = chapter_input_test.find_all('target')\n\n scope_gold_frames = chapter_input_gold.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_frames_count = len(scope_gold_frames)\n\n scope_test_frames = chapter_input_test.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_frames_count = len(scope_test_frames)\n\n # Exit if number of sentences != between Gold and Test files\n if len(sentences_gold) != len(sentences_test):\n raise SystemExit(print('Number of sentences between Gold and Test files does not match.\\nGold:',\n len(sentences_gold), 'Test:', len(sentences_test)))\n\n # Zip Gold and Test Sentences\n for s_gold, s_test in zip(sentences_gold, sentences_test):\n\n sentence_count = sentence_count + 1\n\n gold_frames = s_gold.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n test_frames = s_test.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n\n gold_frames_count = gold_frames_count + len(gold_frames)\n test_frames_count = test_frames_count + len(test_frames)\n\n for item in zip(gold_frames, test_frames):\n\n #print('\\n=========')\n #print('\\nFrame:', item[0].get('id'))\n\n target_gold_list = []\n target_test_list = []\n\n focus_gold_list = []\n focus_test_list = []\n\n negated_gold_list = []\n negated_test_list = []\n\n scope_gold_list = []\n scope_test_list = []\n\n # Flatten a nested list of fenodes\n def flatten(nested_list):\n \"\"\" Flatten a nested list of fenodes \"\"\"\n t_l = []\n for i in nested_list:\n if not isinstance(i, list):\n t_l.append(i)\n else:\n t_l.extend(flatten(i))\n return t_l\n\n # Target\n if item[0].find('target'):\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n\n try:\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n except:\n target_test_word = ''\n\n elif item[1].find('target'):\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n\n try:\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n except:\n target_gold_word = ''\n\n target_gold_list.append(target_gold_word)\n target_test_list.append(target_test_word)\n\n # Sort lists\n sorted_target_gold_list = sorted(flatten(target_gold_list))\n sorted_target_test_list = sorted(flatten(target_test_list))\n\n #print('\\nTarget [Gold]:', sorted_target_gold_list)\n #print('Target [Test]:', sorted_target_test_list)\n\n\n # Focus\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except:\n focus_gold_word = ''\n if item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n else:\n focus_test_word = ''\n\n elif item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n try:\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except AttributeError:\n focus_gold_word = ''\n else:\n focus_gold_word = ''\n\n focus_gold_list.append(focus_gold_word)\n focus_test_list.append(focus_test_word)\n\n # Sort lists\n sorted_focus_gold_list = sorted(flatten(focus_gold_list))\n sorted_focus_test_list = sorted(flatten(focus_test_list))\n\n #print('\\nFocus [Gold]:', sorted_focus_gold_list)\n #print('Focus [Test]:', sorted_focus_test_list)\n\n\n # Negated\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n if item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n else:\n negated_test_word = ''\n\n elif item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n else:\n negated_gold_word = ''\n else:\n negated_test_word = ''\n negated_gold_word = ''\n\n negated_gold_list.append(negated_gold_word)\n negated_test_list.append(negated_test_word)\n\n # Sort lists\n sorted_negated_gold_list = sorted(flatten(negated_gold_list))\n sorted_negated_test_list = sorted(flatten(negated_test_list))\n\n #print('\\nNegated [Gold]:', sorted_negated_gold_list)\n #print('Negated [Test]:', sorted_negated_test_list)\n\n\n # Resolve Terminals if Scope on a complex graph\n def resolve_non_terminals(idref):\n \"\"\" This function resolves a complex gold graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_gold.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_gold.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_gold.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_gold.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n def resolve_non_terminals_test(idref):\n \"\"\" This function resolves a complex test graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_test.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_test.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_test.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_test.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n # Scope\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[0].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n\n if item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n elif s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n scope_test_list.append('')\n\n elif item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n if s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n pass\n\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n else:\n scope_gold_list.append('')\n\n # Sort lists\n sorted_scope_gold_list = sorted(flatten(scope_gold_list))\n sorted_scope_test_list = sorted(flatten(scope_test_list))\n\n #print('\\nScope [Gold]:', sorted_scope_gold_list)\n #print('Scope [Test]:', sorted_scope_test_list)\n\n # If lists are same length, check if items are same\n if len(sorted_scope_gold_list) == len(sorted_scope_test_list):\n sorted_scope_test_list_intersection = set(sorted_scope_gold_list).intersection(sorted_scope_test_list)\n sorted_scope_test_list_intersection = list(sorted_scope_test_list_intersection)\n if len(sorted_scope_test_list_intersection) < len(sorted_scope_test_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_test_list_intersection)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list_intersection.append('')\n empty_element = empty_element + 1\n \n sorted_scope_test_list = sorted_scope_test_list_intersection\n\n # If lists are different lengths, add empty elements\n elif len(sorted_scope_gold_list) > len(sorted_scope_test_list):\n difference = len(sorted_scope_gold_list) - len(sorted_scope_test_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list.append('')\n empty_element = empty_element + 1\n\n elif len(sorted_scope_test_list) > len(sorted_scope_gold_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_gold_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_gold_list.append('')\n empty_element = empty_element + 1\n\n\n # Align items in the lists for sklearn, set 1 for matched items, else set 0\n sorted_target_gold_list_normalized = [1 if element in sorted_target_gold_list and not element == \"\" else 0 for element in sorted_target_gold_list]\n sorted_target_test_list_normalized = [1 if element in sorted_target_gold_list else 0 for element in sorted_target_test_list]\n\n sorted_focus_gold_list_normalized = [1 if element in sorted_focus_gold_list and not element == \"\" else 0 for element in sorted_focus_gold_list]\n sorted_focus_test_list_normalized = [1 if element in sorted_focus_gold_list else 0 for element in sorted_focus_test_list]\n\n sorted_negated_gold_list_normalized = [1 if element in sorted_negated_gold_list and not element == \"\" else 0 for element in sorted_negated_gold_list]\n sorted_negated_test_list_normalized = [1 if element in sorted_negated_gold_list else 0 for element in sorted_negated_test_list]\n\n sorted_scope_gold_list_normalized = [1 if element in sorted_scope_gold_list and not element == \"\" else 0 for element in sorted_scope_gold_list]\n sorted_scope_test_list_normalized = [1 if element in sorted_scope_gold_list else 1 if not element == \"\" else 0 for element in sorted_scope_test_list]\n\n #print(sorted_scope_gold_list_normalized)\n #print(sorted_scope_test_list_normalized)\n\n\n # Sklearn calculations\n #target_precision_scores = target_precision_scores + precision_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_recall_scores = target_recall_scores + recall_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n target_f1_scores = target_f1_scores + f1_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_jaccard_scores = target_jaccard_scores + jaccard_similarity_score(sorted_target_gold_list, sorted_target_test_list)\n\n #focus_precision_scores = focus_precision_scores + precision_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_recall_scores = focus_recall_scores + recall_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n focus_f1_scores = focus_f1_scores + f1_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_jaccard_scores = focus_jaccard_scores + jaccard_similarity_score(sorted_focus_gold_list, sorted_focus_test_list)\n\n #negated_precision_scores = negated_precision_scores + precision_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_recall_scores = negated_recall_scores + recall_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n negated_f1_scores = negated_f1_scores + f1_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_jaccard_scores = negated_jaccard_scores + jaccard_similarity_score(sorted_negated_gold_list, sorted_negated_test_list)\n\n scope_precision_scores = scope_precision_scores + precision_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_recall_scores = scope_recall_scores + recall_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_f1_scores = scope_f1_scores + f1_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_jaccard_scores = scope_jaccard_scores + jaccard_similarity_score(sorted_scope_gold_list, sorted_scope_test_list)\n\n\n print('\\n=============================')\n print('====== EVALUATION for:', chapter_input_test_name, '======')\n print('Total Sentences:', sentence_count,\n '\\nNegation Gold frames:', gold_frames_count,\n '\\nNegation Test frames:', test_frames_count, '\\n')\n\n print('----- CUEWORDS -----')\n #print('Precision:\\t', target_precision_scores / gold_frames_count)\n #print('Recall:\\t', target_recall_scores / gold_frames_count)\n print('F1 score:\\t', target_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', target_jaccard_scores / gold_frames_count)\n\n print('\\n----- FOCUS -----')\n #print('Precision:\\t', focus_precision_scores / gold_frames_count)\n #print('Recall:\\t', focus_recall_scores / gold_frames_count)\n print('F1 score:\\t', focus_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', focus_jaccard_scores / gold_frames_count)\n\n print('\\n----- NEGATED -----')\n #print('Precision:\\t', negated_precision_scores / gold_frames_count)\n #print('Recall:\\t', negated_recall_scores / gold_frames_count)\n print('F1 score:\\t', negated_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', negated_jaccard_scores / gold_frames_count)\n\n print('\\n----- SCOPE -----\\nScope Gold frames:', scope_gold_frames_count, '\\nScope Test frames:', scope_test_frames_count, '\\n')\n print('Precision:\\t', scope_precision_scores / scope_test_frames_count)\n print('Recall:\\t', scope_recall_scores / scope_test_frames_count)\n print('F1 score:\\t', scope_f1_scores / scope_test_frames_count)\n print('Jaccard similarity:\\t', scope_jaccard_scores / scope_test_frames_count)\n\n print('Done!')",
"def is_failed(doc_dict):\n\n results_xml = os.listdir(os.path.join(config.TOC_OCR_RESULTS, doc_dict['name']))\n \n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Results directory contents for {os.path.join(config.TOC_OCR_RESULTS,doc_dict['name'])}:\")\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): {results_xml}\")\n\n if len(results_xml) == 0:\n raise IOError(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} ERROR (OCR): Result XML files not found in {os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'])}...\")\n\n for item in results_xml:\n # open XML file and parse it as an ordered dict\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Found result file: {item}\")\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Opening result file {os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'], item)}...\")\n with open(os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'], item), mode='rb') as f:\n xml = xmltodict.parse(xml_input=f)\n # print(\"OCR XML: \", xml)\n\n # find XmlResult in the ordered dictionary created by parsing XML file\n result_generator = utility.find_item_in_response(data=xml, key='@IsFailed')\n\n # find IsFailed property in XmlResult ordered dict\n for found_value in result_generator:\n # is_failed_generator = utility.find_item_in_response(data=result, key='@IsFailed')\n #\n # # check the value of IsFailed property\n # for found_value in is_failed_generator:\n # print(\"IS FAILED: \", found_value)\n if found_value == 'true':\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): TRUE RESULT FOUND VALUE: {found_value}\")\n return True\n else:\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR ): FALSE RESULT FOUND VALUE: {found_value}\")\n return False",
"def test_install_set_existing(self):\n expected = copy.deepcopy(test_xdata)\n expected.find(\"Text\").text = \"Changed content\"\n self._install([lxml.etree.Element(\"Set\", path=\"Test/Text/#text\",\n value=\"Changed content\")],\n expected)",
"def test_load():\n t = PandasTransformer()\n os.makedirs(target_dir, exist_ok=True)\n t.parse(os.path.join(resource_dir, \"x1n.csv\"))\n t.parse(os.path.join(resource_dir, \"x1e.csv\"))\n t.report()\n t.save(os.path.join(target_dir, 'x1copy'))\n # w = GraphMLTransformer(t.graph)\n # w.save(os.path.join(target_dir, \"x1n.graphml\"))",
"def test_write(self):\n cases = {\n self.test_eac + \"NE00401.xml\": True,\n self.test_eac + \"NE01501.xml\": False,\n self.test_eac + \"NE01302.xml\": True,\n }\n metadata_url = 'http://www.example.com/metadata.xml'\n presentation_url = 'http://www.example.com/presentation.html'\n for case in cases:\n doc = EacCpf.EacCpf(case, metadata_url, presentation_url)\n self.assertNotEqual(doc, None)\n path = doc.write(self.temp)\n self.assertEquals(os.path.exists(path), True)\n # read the file and try to extract the attributes\n try:\n tree = etree.parse(path)\n ns = {\n EacCpf.DOC_KEY: EacCpf.DOC_NS,\n EacCpf.ESRC_KEY: EacCpf.ESRC_NS,\n }\n # get the url to the metadata file\n metadata = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":metadata\", namespaces=ns)\n self.assertNotEqual(metadata, None)\n self.assertEqual(metadata[0], metadata_url)\n # get the url to the presentation file\n presentation = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":presentation\", namespaces=ns)\n self.assertNotEqual(presentation, None)\n self.assertEqual(presentation[0], presentation_url)\n # get the url to the source file\n source = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":source\", namespaces=ns)\n self.assertNotEqual(source, None)\n self.assertEqual(source[0], case)\n except:\n msg = \"Failed to complete parsing of {0}\".format(case)\n self.log.error(msg, exc_info=True)\n self.fail(msg)",
"def recipe12_8():\n from xml.parsers.xmlproc import utils, xmlval, xmldtd\n def validate_xml_file(xml_filename, app=None, dtd_filename=None):\n # build validating parser object with appropriate error handler\n parser=xmlval.Validator()\n parser.set_error_handler(utils.ErrorPrinter(parser))\n if dtd_filename is None:\n # DTD fiel specified, laod and set it as the DTD to use\n dtd=xmldtd.load_dtd(dtd_filename)\n parser.val.dtd = parser.dtd = parser.ent = dtd\n if app is not None:\n # Application processing requested, set application object\n parser.set_application(app)\n # everything being set correctly, finally perform the parsing\n parser.parse_resource(xml_filename) \n # if XML data is in a string s, use instead\n # parser.feed(s)\n # parser.close(s)",
"def test_missing_shx(self):\n path = os.path.join(BASE_DIR, \"tests\", \"fixtures\", \"missing_shx.zip\")\n zip_file = zipfile.ZipFile(path)\n\n with self.assertRaises(MissingFiles) as context:\n get_shapefile(zip_file)\n the_exception = context.exception\n self.assertEqual(MISSING_FILE, the_exception.message)",
"def data_available(dataset_name=None):\r\n for file_list in data_resources[dataset_name]['files']:\r\n for file in file_list:\r\n if not os.path.exists(os.path.join(data_path, dataset_name, file)):\r\n return False\r\n return True",
"def test_exists_false(self):\n self.assertFalse(PrepTemplate.exists(2))",
"def create_xml_regression(lfiles, lsbj, foxml):\n\n impl = xml.dom.minidom.getDOMImplementation()\n doc = impl.createDocument(None, \"some_tag\", None)\n top_element = doc.documentElement\n\n e = doc.createElement('subject')\n e.setAttribute('id', 'case')\n\n for i, fn in enumerate(lfiles):\n v = doc.createElement('visit')\n v.setAttribute('id', \"subj{}\".format(i))\n\n f = doc.createElement('filename')\n f.setAttribute('object_id', \"face\")\n t = doc.createTextNode(fn)\n f.appendChild(t)\n\n a = doc.createElement('age')\n x = doc.createTextNode(str(lsbj[i][\"age\"]))\n a.appendChild(x)\n\n\n v.appendChild(f)\n v.appendChild(a)\n e.appendChild(v)\n\n top_element.appendChild(e)\n\n with open(foxml, \"w\") as fo:\n fo.write(doc.toprettyxml())",
"def xslTestText(self):\n return u'normalize-space(./%s)' % self.name",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def isExist(data):\n return True/False",
"def test_output_exists():\n global out_dir, cor_dir\n assert(path.exists(path.join(out_dir, 'oshea_similarity.json')))",
"def test_resourcesXML(self):\n fileName = self.mktemp()\n fp = FilePath(fileName)\n fp.setContent(oldResourcesFormat)\n upgradeResourcesXML(fp)\n self.assertEquals(fp.getContent(), newResourcesFormat)",
"def test_generate_sample_sheet(self):\n pass",
"def test_negative_file_and_xml(self):\n xml_object = ET.parse(self.xmlfile)\n with self.assertRaises((IOError, OSError)):\n glymur.jp2box.XMLBox(filename=self.xmlfile, xml=xml_object)",
"def example_xml43(example_xml_file41):\n return etree.fromstring(example_xml_file43.encode('utf-8'))",
"def test_duplicate_standard_name(self):\n # Setup test\n infilename = os.path.join(_SAMPLE_FILES_DIR, \"reg_good_simple.xml\")\n filename = os.path.join(_TMP_DIR, \"reg_duplicate_standard_name.xml\")\n out_source_name = \"physics_types_duplicate_standard_name\"\n out_source = os.path.join(_TMP_DIR, out_source_name + '.F90')\n out_meta = os.path.join(_TMP_DIR, out_source_name + '.meta')\n remove_files([out_source, out_meta])\n tree, root = read_xml_file(infilename)\n # Change output filename\n for obj in root:\n oname = obj.get('name')\n if (obj.tag == 'file') and (oname == 'physics_types_simple'):\n obj.set('name', out_source_name)\n new_var = ET.SubElement(obj, \"variable\")\n new_var.set(\"local_name\", \"french_fries\")\n new_var.set(\"standard_name\", \"latitude\")\n new_var.set(\"units\", \"radians\")\n new_var.set(\"type\", \"real\")\n new_var.set(\"kind\", \"kind_phys\")\n dims_elem = ET.SubElement(new_var, \"dimensions\")\n dims_elem.text = 'horizontal_dimension'\n break\n # End if\n # End for\n tree.write(filename)\n\n # Run test\n with self.assertRaises(ValueError) as verr:\n _ = gen_registry(filename, 'eul', {}, _TMP_DIR, 2,\n _SRC_MOD_DIR, _CAM_ROOT,\n loglevel=logging.ERROR,\n error_on_no_validate=True)\n # End with\n # Check exception message\n emsg = \"duplicate variable standard_name, 'latitude' from \"\n emsg += \"'french_fries' in 'physics_types_duplicate_standard_name'\"\n emsg += \", already defined with local_name, 'latitude'\"\n self.assertEqual(emsg, str(verr.exception))\n # Make sure no output files were created\n self.assertFalse(os.path.exists(out_meta))\n self.assertFalse(os.path.exists(out_source))",
"def check_file_exist(self):\n return False",
"def test_read_file():\n z = XPIManager(get_path('xpi/install_rdf_only.xpi'))\n assert z.read('install.rdf') is not None",
"def test_predicate4(self):\n xpb = XPathBuilder()\n xp = xpb.foo.bar.where(xpb.attr('name').not_equals('abc'))\n xp = xp.where(xpb.attr('x').equals('foo'))\n exp = '/foo/bar[@name != \"abc\"][@x = \"foo\"]'\n self.assertEqual(xp.tostring(), exp)",
"def test_verify_unzip(self):\n assert os.path.exists(\n os.path.join(\n settings.MEDIA_ROOT,\n \"indices\",\n \"test-index\",\n \"data\",\n \"sample.txt\"\n )\n )",
"def test_exists_true(self):\n self.assertTrue(Sample.exists(self.sample_id, self.sample_template))",
"def test_xmloutput_view(self):\n print 'Running %s ...' % getName()\n \n self.sequenceListingFixture.create_sequence_instance(self.sequenceListing)\n \n response = self.client.get(reverse('sequencelistings:xmloutput', args=[self.sequenceListing.pk, ]))\n self.assertEqual(response.status_code, 200)\n# test that the page returns expected html contents\n# self.assertContains(response, '%s.xml' % self.sequenceListing.fileName)\n self.assertContains(response, self.sequenceListing.fileName)",
"def _need_generate(paths):\r\n if not os.path.exists(paths.generated_dir):\r\n return True\r\n\r\n if not os.path.exists(paths.index_file):\r\n return True\r\n\r\n # Use the index file to determine if regeneration is necessary\r\n with open(paths.index_file, 'r',newline='\\n') as index_file:\r\n indexed = [item for item in\r\n index_file.read().split('\\n') if len(item) != 0 and\r\n not item.startswith(\"#\")]\r\n return indexed != paths.resource_files"
] | [
"0.5755427",
"0.5572019",
"0.5549192",
"0.5519365",
"0.5482828",
"0.5464173",
"0.5427079",
"0.54160964",
"0.536601",
"0.5338898",
"0.52344614",
"0.5227911",
"0.51953274",
"0.5182521",
"0.51584786",
"0.51524824",
"0.51514745",
"0.51503146",
"0.511027",
"0.5074203",
"0.5046354",
"0.503389",
"0.50189185",
"0.501048",
"0.50082016",
"0.50032926",
"0.4969945",
"0.4964399",
"0.49625763",
"0.49601397",
"0.49531683",
"0.4920993",
"0.49191195",
"0.49034697",
"0.4864428",
"0.4853922",
"0.48519278",
"0.48500398",
"0.48478904",
"0.48434386",
"0.48360553",
"0.483164",
"0.48283836",
"0.48276672",
"0.4826746",
"0.48221388",
"0.4820197",
"0.4818247",
"0.48045155",
"0.48015872",
"0.4796322",
"0.47905782",
"0.47900566",
"0.47882983",
"0.47775993",
"0.4774293",
"0.47632882",
"0.47608277",
"0.47599152",
"0.47550705",
"0.47497493",
"0.4741375",
"0.4734563",
"0.47324103",
"0.47287878",
"0.47215125",
"0.47187984",
"0.4716064",
"0.47110233",
"0.4711012",
"0.4706559",
"0.47056934",
"0.47030586",
"0.47023386",
"0.4697539",
"0.46970925",
"0.46966684",
"0.46914452",
"0.46881047",
"0.46803975",
"0.46758932",
"0.46708822",
"0.46706775",
"0.4667462",
"0.46658367",
"0.46618056",
"0.46566275",
"0.4652985",
"0.46504042",
"0.4645476",
"0.46431816",
"0.463976",
"0.46339816",
"0.46335384",
"0.4632274",
"0.46320617",
"0.4631103",
"0.46305624",
"0.46282983",
"0.46265066"
] | 0.47780943 | 54 |
Return name enclosed with {? } separators | def sepName(self, englishOnly=False):
name = englishOnly and self.enName or self.name
return u'{*&%s*}' % (name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_qname(uri, name):\n if not uri or not name or name[0] in ('{', '.', '/', '['):\n return name\n else:\n return '{%s}%s' % (uri, name)",
"def extract_name():\n def _extract_name(quoted_name):\n return e.String(quoted_name.subexpression.name)\n yield (\"(λ &[name] . str)\", _extract_name)",
"def safe_name(self, name):\n\n output = \"\"\n for char in name:\n if char not in '\\\\/<>:\"|?*':\n output += char\n\n return output",
"def safe_formal_name(name):\n return re.sub(r\"\\s+\", \" \", re.sub(r'[!/\\\\:<>\"\\?\\*\\|]', \"\", name)).strip()",
"def non_local_name(self, name):\n if \"!\" in name:\n return name[:name.find(\"!\")+1]\n else:\n return name",
"def named_back_reference(name:str) -> str:\n # TODO error handling \n return f\"\\\\k<{name}>\"",
"def format_name(self) -> str:\n decl = self.declaration\n name, _ = decl.split(\"(\", 1)\n return name",
"def render_name(name_att_list):\n res = ['']\n for k, v in name_att_list:\n v = dn_escape(v)\n res.append(\"%s=%s\" % (k, v))\n res.append('')\n return '/'.join(res)",
"def format_name_string(x: str) -> str:\n # get rid of [#] when present\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n if \"var.\" in x.lower():\n p = x.lower().find(\"var.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \" var \" in x.lower(): # need the spaces around var, because some names have the letters var in them\n p = x.lower().find(\" var \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \"subsp.\" in x.lower():\n p = x.lower().find(\"subsp.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" forme \" in x.lower():\n p = x.lower().find(\" forme \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" f. \" in x.lower():\n p = x.lower().find(\" f. \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+3] + \" <em class=\\\"species\\\">\" + x[p+3:] + \"</em>\"\n else:\n return \"<em class=\\\"species\\\">\" + x + \"</em>\"",
"def format_name(self) -> str:\n decl = self.declaration\n name, _, _ = decl.partition(\"(\")\n return name",
"def Escape(name):\n return re.sub(r'[^\\w#-]', '_', name)",
"def _process_name(name):\n\n # Unescape HTML entities\n name = unescape(name)\n\n # Remove bracketed stuff on the end\n name = NG_RE.sub('', name).strip() # Nomenclature groups\n name = END_RE.sub('', name).strip(', ') # Words\n name = RATIO_RE.sub('', name).strip(', ') # Ratios\n\n # Remove stuff off start\n name = START_RE.sub('', name).strip()\n\n # Remove balanced start and end brackets if none in between\n name = BRACKET_RE.sub('\\g<1>', name)\n\n # Un-invert CAS style names\n comps = name.split(', ')\n if len(comps) == 2:\n if comps[1].endswith('-'):\n name = comps[0]\n name = '%s%s' % (comps[1], name)\n elif len(comps) > 2:\n name = comps[0]\n for i in range(1, len(comps)):\n if comps[i].endswith('-'):\n name = '%s%s' % (comps[i], name)\n else:\n name = '%s %s' % (name, comps[i])\n return name",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*?%s*}' % (name)",
"def split_name(fullname):",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n if not self.useFileInfo:\n return u'{*%s*}' % name\n return u'{*!%s*}' % name",
"def compile_name(self, name):\n S = [s.strip().lower() for s in name.split('|')]\n assert all(S)\n \n S = [set(x.strip().lower() for x in s.split('&')) for s in S]\n assert all(all(x) for x in S)\n \n return S",
"def generate(self, name):\n if not '?' in self._pattern and not '[' in self._pattern:\n try:\n return self._pattern.replace('*', '{}').format(name)\n except IndexError:\n # multiple *\n pass\n return ''",
"def get_name() -> str:",
"def CleanName(self,name):\n name2 = \"\"\n for c in name:\n if c == \"(\":\n break\n else: name2+=c\n\n return name2.strip(\"\\n\")",
"def latex_name(name):\r\n name = name + '_' #protects against .split('_') failing\r\n if name.startswith('['): #format leading [] as concentration\r\n head, tail = name[1:].rsplit(']', 1)\r\n head = r'[\\ce{%s}]' % head\r\n else:\r\n if '[' in name: # turn internal [] into marked-up subscripts\r\n before, inside, after = re.match(r'([^[]+)\\[(.*)\\]([^]]*)', name).groups() # separates bracketed material\r\n name = r'%s_\\ce{%s}_%s' % (before, inside, after)\r\n head, tail = name.split('_', 1)\r\n if len(head) > 1: # special cases like v12 (=> v_12) and roman multiple letter symbol\r\n if re.match(r'^.[0-9]+$', head): # single character following by integer, i.e. v0\r\n head, tail = name[0], name[1:]\r\n else:\r\n head = r'\\mathrm{%s}' % head\r\n subscripts = re.findall(r'(\\\\ce{.*}|[^_]+)_', tail) # tail.split('_') but ignoring underscore within chem mark-up\r\n if subscripts:\r\n return head + r'_{\\mathrm{' + ','.join(subscripts) + '}}'\r\n return head",
"def fmt(competitor_name: str) -> str:\n name = competitor_name.replace(\"_a\", r\" $\\alpha$ \")\n name = name.replace(\"_b\", r\" $\\beta$ \")\n return name",
"def _format_question_break(self, name):\n header = '-' * 80 + '\\n'\n buffer_length = int((80 - int(len(name))) / 2) \n header += ' ' * buffer_length + name + ' ' * buffer_length + '\\n'\n header += '-' * 80 + '\\n'\n\n return header",
"def format_name(field_name):\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()",
"def _var_name_sub(self, sprintf, quote=False):\n q = ''\n if quote:\n q = \"'\"\n name_list = map(lambda x: q + self.cdict[x][0] + q, sprintf[\"vars\"] )\n return sprintf[\"text\"] % tuple(name_list)",
"def __str__(self) -> str:\n return f'?{self.name}'",
"def format_alias_name(self, name):\n result = strip_punctuation(name)\n result = WHITESPACE_REGEX.sub(' ', result)\n return result",
"def get_name(header, splitchar=\"_\", items=2):\n if splitchar:\n return \"_\".join(header.split(splitchar)[:items]).lstrip(\">\")\n else:\n return header.lstrip(\">\")",
"def clean_name(x: str) -> str:\n x = x.replace(\", var.\", \" var.\")\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n return x",
"def format_name(self) -> str:\n decl = self.declaration\n\n # variables which are declared and assigned at the same location will\n # include the assignment in the clange declaration, so strip it out for\n # documentation.\n name, _, _ = decl.partition(\"=\")\n return name",
"def name(self) -> StringFilter:\n return self.__name",
"def adjust_name_for_printing(name):\n if name is not None:\n name2 = name\n name = name.replace(\" \", \"_\").replace(\".\", \"_\").replace(\"-\", \"_m_\")\n name = name.replace(\"+\", \"_p_\").replace(\"!\", \"_I_\")\n name = name.replace(\"**\", \"_xx_\").replace(\"*\", \"_x_\")\n name = name.replace(\"/\", \"_l_\").replace(\"@\", '_at_')\n name = name.replace(\"(\", \"_of_\").replace(\")\", \"\")\n if re.match(r'^[a-zA-Z_][a-zA-Z0-9-_]*$', name) is None:\n raise NameError(\"name {} converted to {} cannot be further converted to valid python variable name!\".format(name2, name))\n return name\n return ''",
"def format_name(self) -> str:\n return self.declaration",
"def __sanitize(name):\n if name[-1] == \"/\":\n return name[:-1]\n return name",
"def fname(self):\n buff = []\n for c in self.name:\n if c in latex_symbol_map:\n buff.append(\"$_{}$\".format(latex_symbol_map[c]))\n else:\n buff.append(c)\n return ''.join(buff)",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*#%s*}' % (name)",
"def _get_pretty_name(name):\n pretty = ''\n if name.countryName:\n pretty += '/C=' + name.countryName\n if name.stateOrProvinceName:\n pretty += '/ST=' + name.stateOrProvinceName\n if name.localityName:\n pretty += '/L=' + name.localityName\n if name.organizationName:\n pretty += '/O=' + name.organizationName\n if name.organizationalUnitName:\n pretty += '/OU=' + name.organizationalUnitName\n if name.commonName:\n pretty += '/CN=' + name.commonName\n if name.emailAddress:\n pretty += '/email=' + name.emailAddress\n return pretty",
"def _extract_name(line: str) -> str:\n tokens = line[19:-2].split(\" {\")\n name = tokens[0]\n return name",
"def name(self):\n return self._name or ' & '.join(s.name for s in self.suites)",
"def success_new_brass(name):\n return 'Nom de brasserie %s' % name + ' a bien ete ajoute'",
"def print_name(nome, sobrenome):\r\n return nome + \" \" + sobrenome",
"def mark(name: str) -> str:\n return f'<mark name=\"{name}\"/>'",
"def filter_name(self, name):\n return self.form.set_value(\"generating station search\", name)",
"def variable_string(self, name):\n return \"$(\" + name + \")\"",
"def visit_name(self, node, children):\n name = ''.join(children)\n return name",
"def fullname(self, name):\n f, l = name.split(' ')\n self.first = f\n self.last = l",
"def get_name():",
"def ending_cutter(name: str):\n if name.endswith('ID') and re.match(r'^(?=\\w+[A-Z])(?=\\w+[a-z])\\w+$', name):\n return name[:-2]\n return name",
"def get_full_name(self):\n full_name = '{0} {1} {2}'.format(self.last_name, self.first_name, self.patronymic)\n return full_name.strip()",
"def full_name(self) -> str:\n # return self.separator.join(map(lambda x: x.name, self.path()))\n return self.separator.join(map(lambda x: x.tagged_name, self.path()))",
"def capture(*args:List[str], name:Union[str,None]=None) -> str:\n name = f\"?<{name}>\" if name is not None else \"\"\n return f'({name}{\"\".join(args)})'",
"def format_name(self):\n\t\tself.full_name = self.first + \" \" + self.last",
"def name_parser(string):\n return string.replace('\\n', ' ')",
"def clean_specific_name(x: str) -> str:\n\n # this is a list of terms that are not actual species names or specific names that have never been part of\n # a fiddler genus\n skip_list = (\"sp.\",\n \"spp.\",\n \"var.\",\n \"nov.\",\n \"a\",\n \"ete\",\n \"panema\",\n \"pagurus\",\n \"quadratus\",\n \"albidus\",\n \"vociferans\",\n \"raniformis\",\n \"nigra\",\n \"albicans\",\n \"arenarius\",\n \"raninus\",\n \"serratus\",\n \"cordimana\",\n \"spec.\",\n \"complex\",\n \"5\",\n \"6\",\n \"1\",\n \"afruca\",\n \"gelasimus\")\n\n if (\" \" not in x) or (\"(\" in x):\n return \"\"\n else:\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n y = x.split(\" \")\n x = y[len(y)-1].lower()\n if (x in skip_list) or (\"gruppe\" in x) or (\"group\" in x) or (\"complex\" in x):\n return \"\"\n else:\n return x.lower()",
"def quote_name(self, name):\n name = re.sub('-', '', name)\n if name.startswith('\"') and name.endswith('\"'):\n return name\n return '\"%s\"' % (name,)",
"def FilterName(namefilter, safechar='P', reserved_names=None):\n # remove non accepted characters\n for c in r' -[]/\\;,><&*:%=+@!#^|?^':\n namefilter = namefilter.replace(c, '')\n\n # remove non english characters\n char_list = (c for c in namefilter if 0 < ord(c) < 127)\n namefilter = ''.join(char_list)\n\n # Make sure we have a non empty string\n if len(namefilter) <= 0:\n namefilter = safechar\n\n # Make sure we don't start with a number\n if namefilter[0].isdigit():\n print(namefilter)\n namefilter = safechar + namefilter\n\n # Make sure we are not using a reserved name\n if reserved_names is not None:\n while namefilter.lower() in reserved_names:\n namefilter = safechar + namefilter\n\n # Add the name to reserved names\n reserved_names.append(namefilter)\n\n return namefilter",
"def _get_name(self):\n name_string = '%s_%s' % (\n self.parameter_type,\n self.parameter_value_type)\n if self.paneltemplateparametermarker_set.count() > 0:\n marker_string = \"_\".join(sorted([m.marker.marker_abbreviation for m in self.paneltemplateparametermarker_set.all()]))\n name_string += '_' + marker_string\n if self.fluorochrome:\n name_string += '_' + self.fluorochrome.fluorochrome_abbreviation\n return name_string",
"def _get_name(self):\n return '%s: %s-%s' % (\n self.fcs_number,\n self.parameter_type,\n self.parameter_value_type)",
"def name(self):\n\n return self._name.replace(\"[]\", \"\")",
"def get_name(self):\n name = ''\n # name contains all adjacent alphanumeric symbol\n while self.current_character.isalnum():\n name += self.current_character\n self.current_character = self.file.read(1)\n self.file.seek(self.file.tell() - 1, 0)\n character = self.file.read(1)\n if character.isalnum():\n pass\n else:\n self.file.seek(self.file.tell() - 1, 0)\n return name",
"def getName(self):\n return \"\"",
"def normalize_pipeline_name(name=''):\n normalized_name = name\n for bad in '\\\\/?%#':\n normalized_name = normalized_name.replace(bad, '_')\n return normalized_name",
"def match_specific_name(name: str, specific_names: list) -> str:\n c = clean_specific_name(name)\n if c == \"\":\n return c\n else:\n y = \"\"\n for x in specific_names:\n matchlist = x.variations.split(\";\")\n if c in matchlist:\n y = x.name\n return y",
"def get_html_name(form, name):\n return form.add_prefix(name)",
"def _get_name(self, name, scopes=None, include_cond=True):\n if scopes is None:\n scopes = self._scopes\n\n scope_strings = []\n for scope in scopes:\n if self._is_name_scope(scope):\n scope_strings.append(scope)\n elif self._is_conditional_scope(scope) and include_cond:\n parent_name = scope['parent_name']\n parent_values = scope['parent_values']\n scope_string = '{name}={vals}'.format(\n name=parent_name,\n vals=','.join([str(val) for val in parent_values]))\n scope_strings.append(scope_string)\n return '/'.join(scope_strings + [name])",
"def get_name(self):\n return self._pattern",
"def get_name(descr: str) -> str:\n return descr.split()[0]",
"def _expanded_id(name: str, sep: str = '_') -> str:\n return sep.join([el.lower()\n for el in re.split(r'([A-Z]+[^A-Z]*)', name)\n if el])",
"def encode_name(param):\n sname = param\n # replace all kind of unwanted chars in a python dictname.\n sname = sname.strip()\n for ch in ['/', ' + ', ' ', '#', '&', '-', ',', '+', ]:\n if ch in sname:\n sname = sname.replace(ch, \"_\")\n\n # replace brackets\n for ch in ['(', ')']:\n if ch in sname:\n sname = sname.replace(ch, \"\")\n\n # replace the numbers 2 and 10 with the text representation\n if '10' in sname:\n sname = sname.replace('10', 'TEN')\n\n if '2' in sname:\n sname = sname.replace('2', 'TWO')\n return sname.upper()",
"def format_name(f_name, l_name): #docstring (documentation)\n if f_name == \"\" or l_name == \"\":\n return \"You didn't provide valid inputs.\"\n formated_f_name = f_name.title()\n formated_l_name = l_name.title()\n return f\"Result: {formated_f_name} {formated_l_name}\"",
"def fullname(self, name):\n\n first, last = name.split(' ')\n self.first = first\n self.last = last",
"def clean_name(name):\n return \",\".join(name.split(\",\")[:1])",
"def clean_name(name):\n return \",\".join(name.split(\",\")[:1])",
"def simplifyOutName(name):\n return \"HLTNav_\" + name.replace(\"HLTNav_\", \"\").replace(\"Trig\", \"\").replace(\"Alg\", \"\")",
"def format_name(self) -> str:\n return self.name",
"def get_name_link_html(self):\n url_text = \"{{% url 'trait_browser:source:studies:pk:detail' pk={} %}} \".format(self.pk)\n return URL_HTML.format(url=url_text, name=self.i_study_name)",
"def quote_name(self, name):\n if name.startswith(self.left_sql_quote) and name.endswith(self.right_sql_quote):\n return name # Quoting once is enough.\n return '%s%s%s' % (self.left_sql_quote, name, self.right_sql_quote)",
"def get_name(self):\r\n return ('%s %s' % ( self.first_name, self.last_name ))",
"def name_format(name):\n lst_name, fst_name = name.split(',')\n return ' '.join((fst_name, lst_name))",
"def legal_variable_name(name):\n var_name = name.replace(' ', '_')\n for char in r'''[]{}\\/^%$#@!+-<>?|'\"=~`,.;:''':\n if char in var_name:\n var_name = var_name.replace(char, '')\n for char in var_name:\n if ord(char) > 127: # remove non-ascii characters\n var_name = var_name.replace(char, '')\n return var_name",
"def get_field(fieldname):\n m = re.search(\"(^|\\\\n)%s\\\\s(.*?)\\n\" % fieldname, s, re.I)\n if not m:\n return None\n else:\n return Unquote(m.group(2))",
"def encode_name_components(self, name: Name):\n first_quot = False\n new_component = \"\"\n for component in name.components:\n if '\"' in str(component):\n if first_quot is True:\n new_component += str(component)\n first_quot = False\n else:\n first_quot = True\n if first_quot:\n new_component += str(component)\n new_component = new_component.replace(\"'b'\", \"/\").replace(\"b'\", \"\")[:-1]\n if \"=\" not in new_component and '\"' in new_component:\n new_component = new_component.replace('\"', \"\")\n start_of_component = 0\n for i in range(0, len(name.components)):\n if \"_(\" in str(name.components[i]):\n start_of_component = i\n comp_list_len = len(name.components)\n for i in range(start_of_component, comp_list_len - 2):\n name.components.pop(len(name.components) - 2)\n name.components[-2] = new_component.encode(\"ascii\")\n return name",
"def satname(rocketsatname):\n \n # split the rocket and satellite name at the bullet\n names = rocketsatname.split('•')\n \n # remove spaces around satellite name\n namefull = names[1].strip()\n \n # return the satellite's name\n return namefull",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def test_expanded_name( self ):\n\t\tself.doBasicTest(\n\t\t\t'''s := something +\n\t\t\t>something< := r\n\t\t\tr := [ab]\n\t\t\tv := [c]\n\t\t\t''',\n\t\t\t's',\n\t\t\t'abammmab',\n\t\t\t(1,[\n\t\t\t\t('r',0,1, NullResult),\n\t\t\t\t('r',1,2, NullResult),\n\t\t\t\t('r',2,3, NullResult),\n\t\t\t],3)\n\t\t)",
"def name(self):\n return \"%s %s\" % (self.first_name, self.last_name)",
"def cFormal(self):\n if not self.type:\n return self.name # special case for '...'\n else:\n arr = self.array or ''\n pointers = self.pointers or ''\n return \"%s %s%s%s\" % (self.type, pointers, self.name, arr)",
"def printname(bruce):",
"def get_query_parameter(self,original_name: Optional[str] = None) -> str:\n if not original_name:\n raise TypeError(\"original_name cannot be null.\")\n if original_name == \"count\":\n return \"%24count\"\n if original_name == \"expand\":\n return \"%24expand\"\n if original_name == \"filter\":\n return \"%24filter\"\n if original_name == \"orderby\":\n return \"%24orderby\"\n if original_name == \"search\":\n return \"%24search\"\n if original_name == \"select\":\n return \"%24select\"\n if original_name == \"skip\":\n return \"%24skip\"\n if original_name == \"top\":\n return \"%24top\"\n return original_name",
"def get_query_parameter(self,original_name: Optional[str] = None) -> str:\n if not original_name:\n raise TypeError(\"original_name cannot be null.\")\n if original_name == \"count\":\n return \"%24count\"\n if original_name == \"expand\":\n return \"%24expand\"\n if original_name == \"filter\":\n return \"%24filter\"\n if original_name == \"orderby\":\n return \"%24orderby\"\n if original_name == \"search\":\n return \"%24search\"\n if original_name == \"select\":\n return \"%24select\"\n if original_name == \"skip\":\n return \"%24skip\"\n if original_name == \"top\":\n return \"%24top\"\n return original_name",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*%s%s*}' % (self.parentLevel * '*', name)",
"def name(self):\n return str(self._options.hydraulic.pattern) if self._options.hydraulic.pattern is not None else ''",
"def get_full_name(self):\r\n full_name = '%s' % (self.name)\r\n return full_name.strip()",
"def name_value(self) -> global___Expression.NameValue:",
"def use_name(self):\n projection = proj.get_projection(self.conf.projections, self.spec)\n if not projection:\n projection = self.conf.default_projections[\"all\"]\n\n name = self.spec.format(projection)\n # Not everybody is working on linux...\n parts = name.split(\"/\")\n name = os.path.join(*parts)\n # Add optional suffixes based on constraints\n path_elements = [name] + self.conf.suffixes\n return \"-\".join(path_elements)",
"def get_rep_name(self, name):\n return \"r{0}\".format(name)",
"def get_full_name(self):\n if self.patronymic_name:\n return '{} {} {}'.format(\n self.first_name,\n self.patronymic_name,\n self.last_name,\n )\n\n return '{} {}'.format(\n self.first_name,\n self.last_name,\n )"
] | [
"0.61448735",
"0.61404973",
"0.5836852",
"0.5794541",
"0.57860225",
"0.57392246",
"0.56530035",
"0.5644217",
"0.55994993",
"0.55715615",
"0.55315167",
"0.55184275",
"0.54990566",
"0.54926336",
"0.5441188",
"0.5408375",
"0.5391947",
"0.53832364",
"0.5359637",
"0.5346842",
"0.53380084",
"0.5330564",
"0.53142434",
"0.52700996",
"0.524386",
"0.5241395",
"0.5233396",
"0.5231413",
"0.52298325",
"0.5229409",
"0.52205145",
"0.5205116",
"0.51899874",
"0.5175646",
"0.5159675",
"0.5157742",
"0.5152366",
"0.5143119",
"0.5132167",
"0.51301634",
"0.51278013",
"0.5103898",
"0.5086814",
"0.5084781",
"0.50829315",
"0.5073549",
"0.5044718",
"0.5029175",
"0.50255185",
"0.50253445",
"0.5024888",
"0.50179005",
"0.5001062",
"0.49965125",
"0.4993822",
"0.49925566",
"0.4990841",
"0.49782714",
"0.49752626",
"0.49584284",
"0.49572417",
"0.4957172",
"0.49540657",
"0.49521312",
"0.49429262",
"0.49422178",
"0.49277678",
"0.49253523",
"0.4921725",
"0.4921004",
"0.49199083",
"0.49199083",
"0.49191892",
"0.49006087",
"0.48929736",
"0.4892349",
"0.48865047",
"0.48834217",
"0.48830917",
"0.4882462",
"0.48709264",
"0.4869607",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48587474",
"0.48578084",
"0.48543957",
"0.4853977",
"0.48533097",
"0.48533097",
"0.4851776",
"0.48514396",
"0.48460093",
"0.48432255",
"0.48307502",
"0.48286083",
"0.4824451"
] | 0.5660936 | 6 |
Return formatted text for this field | def outputText(self, item, titleMode, internal=False):
result = []
for child in item.childList:
field = child.nodeFormat().findField(self.name)
if field:
text = field.outputText(child, titleMode, internal)
if text:
result.append(text)
return globalref.docRef.childFieldSep.join(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def formatted(self) -> str:\r\n ...",
"def format(self) -> str:",
"def text(self) -> str:",
"def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d",
"def get_text(self):\n inp = \" \"\n if self.link_id:\n inp += \"LINK \" + self.link_id\n inp += self.status + ' '\n if self.node_id:\n inp += \"NODE \" + self.node_id + ' '\n if self.value:\n inp += self.control_type.name + ' ' + str(self.value) + ' '\n if self.time:\n inp += self.time + ' '\n if self.clock_time:\n inp += self.clock_time + ' '\n # TODO: research correct formatting of time, clock_time options\n return inp",
"def format(self) -> str:\n return self._format",
"def format(self) -> str:\n return self._format",
"def getText(self):\r\n return \"\"",
"def value_as_text(self):\n property_name = \"_%s_as_text\" % self.attribute.type\n return getattr(self, property_name, self.value)",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def getFormattedText(self):\r\n h = \"00\"\r\n m = \"00\"\r\n s = \"00\"\r\n if(self.seconds < 10):\r\n s = \"0\" + str(self.seconds)\r\n else:\r\n s = str(self.seconds)\r\n\r\n if(self.minutes < 10):\r\n m = \"0\" + str(self.minutes)\r\n else:\r\n m = str(self.minutes)\r\n\r\n if(self.hours < 10):\r\n h = \"0\" + str(self.hours)\r\n else:\r\n h = str(self.hours)\r\n\r\n return h + \":\" + m + \":\" + s",
"def get_text(self):\n return self.rule_id + '\\t' + self.rule_text",
"def get_text(self):\n return self.get_property('text')",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def _get_FIELD_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n template = ''\n template += '{:d}' if field.decimals == 0 else '{:.%sf}' % field.decimals\n template += ' ' if field.spaced_display else ''\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def TEXT(number, format_type):\n raise NotImplementedError()",
"def format(self) -> str:\n return pulumi.get(self, \"format\")",
"def text(self) -> str:\n return self.__text",
"def show(self) -> str:\n return f'[{self.font}]{self.text}[{self.font}]' if self.font else self.text",
"def formatName(self):\r\n return self.title.getVal() + \" \" + self.first.getVal() + \" \" + self.last.getVal()",
"def getText(self):\n return(' '.join(map(lambda x:x.text,self.getNested())))",
"def get_text(self) -> str:\n return self.text",
"def text(self):\n return self.__text",
"def getText(self):",
"def get_text(self):\n return self.text",
"def text(self):\n return ''",
"def get_text(self) -> str:\n return self._text",
"def get_formatted_text(self, n_cols):",
"def text(self) -> str:\n return self._impl.get_text()",
"def format_item_display(self, obj):\n return u\"%s - %s\" % (escape(obj.nombre),obj.rfc)",
"def text(self) -> LocalizedString:\n return self._text",
"def as_text(self) -> str:\n txt = ''\n with self._th_lock:\n # purge expired value (reach ttl_s) from values dict\n purge_l = []\n for key, (_value, _timestamp_ms, expire_at) in self._values_d.items():\n if expire_at and time.monotonic() > expire_at:\n purge_l.append(key)\n for rm_key in purge_l:\n self._values_d.pop(rm_key)\n # if any value exists, format an exposition message\n if self._values_d:\n # add a comment line if defined\n if self.comment:\n # apply escapes to comment\n esc_comment = str(self.comment)\n for rep_args in [('\\\\', '\\\\\\\\'), ('\\n', '\\\\n')]:\n esc_comment = esc_comment.replace(*rep_args)\n txt += f'# HELP {self.name} {esc_comment}\\n'\n # add a type line if defined\n if self.type is not MetricType.UNTYPED:\n txt += f'# TYPE {self.name} {self.type.value}\\n'\n # add every \"name{labels} value [timestamp]\" for the metric\n for lbl_id_str, (value, ts, _expire_at) in self._values_d.items():\n if self._type is MetricType.HISTOGRAM:\n txt += self._data2txt_histogram(lbl_id_str, value)\n elif self._type is MetricType.SUMMARY:\n txt += self._data2txt_summary(lbl_id_str, value)\n else:\n txt += self._data2txt_default(lbl_id_str, value, ts)\n return txt",
"def __str__(self):\n txt = \"%s:\\n\" % self.name\n txt += \" Charge: %.4f\\n\" % self.charge\n txt += \" Radius: %.4f\" % self.radius\n return txt",
"def text(self):\n if self.is_root:\n return ''\n elif self.is_comment:\n return self.__value\n elif self.is_flag:\n if self.__value:\n return '[{0}]'.format(self.name)\n else:\n return '!{0}!'.format(self.name)\n else:\n return '[{0}:{1}]'.format(self.name, self.value)",
"def __repr__(self) -> str:\n return f\"{self.text}\"",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def text(self) -> str:\n return self._text",
"def format(self):\n return self._format",
"def get_formatter(self, **kwargs):\n config = dict([\n (attr, getattr(self, attr))\n for attr in [\n \"include_sign\",\n \"group_with_commas\",\n \"num_decimal_places\",\n ]\n ])\n config.update(kwargs)\n return \"\".join([\n \"{\",\n config.get(\"field_name\", \"\"),\n \":\",\n \"+\" if config[\"include_sign\"] else \"\",\n \",\" if config[\"group_with_commas\"] else \"\",\n \".\", str(config[\"num_decimal_places\"]), \"f\",\n \"}\",\n ])",
"def text(self):\n\n if self.status.full_text:\n return self.status.full_text\n elif self.status.text:\n return self.text\n else:\n return MISSING",
"def to_str(self):\n return self.template.format(\n text_color=self.color.to_str(),\n font_type=self.font_type.to_str(),\n font_weight=self.font_weight.to_str(),\n font_size=self.font_size.to_str()\n )",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def text(self):\n return self.name, self.fontfile, self.fontsize",
"def plain_text(self) -> str:\n return pulumi.get(self, \"plain_text\")",
"def _get_FIELD_humanized_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n power = max([i for i in utils.POWERS if value // i > 0 and i > 1])\n value /= power\n template = ''\n template += '{:.%sf}' % field.humanized_decimals\n template += ' ' if field.spaced_display else ''\n template += utils.POWERS[power]\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def format( self ) :\n\n return( self.__format )",
"def __repr__(self) -> str:\r\n\r\n saida = \"Format: \"\r\n x = self.getformat()\r\n for _ in range(len(x)):\r\n saida = f\"{saida}{x[_]}\"\r\n if _ < len(x)-1:\r\n saida += \", \"\r\n saida += \"\\n\"\r\n return saida",
"def text(self):\n return self.label.text()",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title} :\" + s\n\n return s",
"def format_value(text):\n return text.encode('utf8').replace('\\n', ' ').replace('\\r', ' ')",
"def get_text(self):\n logging.getLogger(__name__).info(\"Element text: {}\\nby = {}\\nvalue = {}\".format(\n self.driver.find_element(self.by, self.value).text, self.by, self.value))\n return self.driver.find_element(self.by, self.value).text",
"def get_instance_text(instance):\n values = []\n for fieldname in registry[instance.__class__]:\n values.extend(resolve_field_value(\n [instance], fieldname.split('__')))\n return u' '.join(values)",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n return text",
"def text(self, v=''):\n return str(v)",
"def _to_text(self, value):\n raise NotImplementedError",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def __str__(self):\n return self.fmt.format(*self.args, **self.kwargs)",
"def field_display(obj, field):\n return get_field_value(obj, field)",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n if hasattr(self,'label'):\n return str(self.label.text())\n else:\n return self.key",
"def __str__(self):\n return self.format()",
"def text(self):\n parts = [(\"%s\" if isinstance(p, Insert) else p) for p in self.parts]\n parts = [(\"%%\" if p == \"%\" else p) for p in parts] # escape percent\n return \"\".join(parts)",
"def Text(self):\n return self._text",
"def __str__(self):\n struct_repr = \", \".join([\n \"type: \" + str(self.type),\n \"text: \" + str(self.text)\n ])\n\n return f\"StatusText: [{struct_repr}]\"",
"def GetText(self):\r\n \r\n return self._text",
"def getText(self):\n return self.text",
"def getText(self):\n return self.text",
"def to_text(self, floatformat: str = \".6f\") -> str:\n return self.val.to_text(floatformat)",
"def __str__(self):\n #Format data from default fields\n template = \"{number:4}|{rep:4}|{time:5}{priority:+2}|\" \\\n \"{record_type:8}|{name:17}\"\n default_fields = template.format(**self)\n \n #Format data from custom fields\n custom_field_list = []\n for label in self.custom_labels:\n custom_field_list.append(\"|{:17}:{!s:<5}\".format(label,\n self[label]))\n custom_fields = \"\".join(custom_field_list)\n \n return default_fields + custom_fields",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def __str__(self):\n\t\treturn self.text",
"def outputText(self, item, titleMode, internal=False):\n field = None\n while not field:\n item = item.parent\n if item:\n field = item.nodeFormat().findField(self.name)\n else:\n return ''\n return field.outputText(item, titleMode, internal)",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def text(self):\n # type: () -> str\n return self._text",
"def get_text(self):",
"def text(self):\n return self.full_text",
"def __str__(self):\n return \"%s\\n\" % self.text + \" \" * self.col + \"^\"",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% on line \" + self.line\n return text",
"def _entity_as_text(self):\n return str(self.value)",
"def format(self, record):\n message = record.getMessage()\n asctime = self.formatTime(record, self.datefmt)\n name = yellow(record.name)\n\n s = \"%(timestamp)s %(levelname)s %(name)s \" % {\n \"timestamp\": green(\"%s,%03d\" % (asctime, record.msecs), bold=True),\n \"levelname\": self.LEVELS[record.levelname],\n \"name\": name,\n }\n\n if \"\\n\" in message:\n indent_length = len(re_color_codes.sub(\"\", s))\n message = message.replace(\"\\n\", \"\\n\" + \" \" * indent_length)\n\n s += message\n return s",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n text += \" [\" + self.file_name + \"]\"\n return text",
"def text(self):\n\t\treturn ' '.join([self.write_components[x] for x in self.write_components])"
] | [
"0.75734353",
"0.7379207",
"0.7205578",
"0.68481845",
"0.67844886",
"0.67808527",
"0.67703915",
"0.67703915",
"0.67655444",
"0.6745665",
"0.6687435",
"0.66469747",
"0.6644202",
"0.66413474",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65741307",
"0.6567402",
"0.6558896",
"0.6555393",
"0.655068",
"0.6547239",
"0.6544499",
"0.6535529",
"0.6517592",
"0.6480058",
"0.6460372",
"0.6459885",
"0.64553267",
"0.6446324",
"0.6445358",
"0.64076585",
"0.6392125",
"0.6380471",
"0.6367286",
"0.6361198",
"0.6353135",
"0.6348966",
"0.63427186",
"0.6320017",
"0.6318294",
"0.63155836",
"0.6308729",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.62890583",
"0.62872475",
"0.6284665",
"0.6283615",
"0.62564605",
"0.62539566",
"0.6250457",
"0.6246106",
"0.6245501",
"0.6238378",
"0.62316114",
"0.62306285",
"0.6227439",
"0.6216431",
"0.6214085",
"0.6207841",
"0.6207841",
"0.62025124",
"0.618629",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6184535",
"0.6183745",
"0.6183568",
"0.61735356",
"0.61702335",
"0.61699766",
"0.6169714",
"0.6169714",
"0.6168279",
"0.616314",
"0.6158217",
"0.6158217",
"0.6158217",
"0.6156037",
"0.613794",
"0.6137155",
"0.61364275",
"0.6114419",
"0.61141664",
"0.6103432",
"0.61010504",
"0.6098953",
"0.609143",
"0.60909635",
"0.60876095"
] | 0.0 | -1 |
Return what we need to write into an XSL file for this type | def xslText(self):
return u'<xsl:value-of select="child::*/%s"/>' % self.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def xslText(self):\n return TextFormat.xslText(self)",
"def convert(self):\n self._convert()\n self._write_docx()",
"def toxml(self) :\n\t\treturn self.doc.toxml()",
"def _ooxml(self):\n # LOG: processing_type property\n self.set_property('processing_type', 'ooxml')\n try:\n doc = officedissector.doc.Document(self.src_path)\n except Exception:\n self.make_dangerous('invalid ooxml file')\n return\n # There are probably other potentially malicious features:\n # fonts, custom props, custom XML\n if doc.is_macro_enabled or len(doc.features.macros) > 0:\n self.make_dangerous('macro')\n if len(doc.features.embedded_controls) > 0:\n self.make_dangerous('activex')\n if len(doc.features.embedded_objects) > 0:\n # Exploited by CVE-2014-4114 (OLE)\n self.make_dangerous('embedded obj')\n if len(doc.features.embedded_packages) > 0:\n self.make_dangerous('embedded pack')",
"def xslText(self):\n return u'<xsl:value-of select=\"%s%s\"/>' % (self.parentLevel * '../',\n self.name)",
"def _write_docx(self):\n with ZipFile(self.out_file, 'w') as f:\n self._write_content_types(f)\n self._write_app(f)\n self._write_core(f)\n self._write_rels(f)\n self._write_document(f)\n self._write_fonts(f)\n self._write_document_rels(f)\n self._write_settings(f)\n self._write_styles(f)",
"def create_output_file(self):\r\n self.output_file = openpyxl.Workbook()",
"def _create_oai_xsl_template():\n oai_xsl_template = OaiXslTemplate()\n oai_xsl_template = _set_oai_xsl_template_fields(oai_xsl_template)\n\n return oai_xsl_template",
"def createXML(whatToCreate):\n\n XMLSerializer = serializers.get_serializer(\"xml\")\n xml_serializer = XMLSerializer()\n if whatToCreate == \"allAccount\":\n path_fullToOutputFile = os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\")\n objectsToSerialize = Account.objects.all()\n else:\n raise ProgrammingError(\n _(\"During XML Export it was not correctly specified which data that has to be exported\"))\n out = open(os.path.join(settings.PDF_OUTPUT_ROOT, \"accounts.xml\"), \"w\")\n if objectsToSerialize == '':\n raise NoObjectsToBeSerialzed(_(\"During XML Export it was not correctly specied data has to be exported\"))\n else:\n xml_serializer.serialize(objectsToSerialize, stream=out, indent=3)\n out.close()\n return path_fullToOutputFile\n\n # TODO def importAllAccountsXML(self):",
"def export_to_xml(self, resource_fs):\r\n raise NotImplementedError('Modules must implement export_to_xml to enable xml export')",
"def writeXml(self):\n text = u' type=\"%s\"' % self.typeName\n if self.format:\n text += u' format=\"%s\"' % escape(self.format, treedoc.escDict)\n if self.prefix:\n text += u' prefix=\"%s\"' % escape(self.prefix, treedoc.escDict)\n if self.suffix:\n text += u' suffix=\"%s\"' % escape(self.suffix, treedoc.escDict)\n if self.html:\n text += u' html=\"y\"'\n if self.isRequired:\n text += u' required=\"y\"'\n if self.hidden:\n text += u' hidden=\"y\"'\n if self.numLines > 1:\n text += u' lines=\"%d\"' % self.numLines\n if self.initDefault:\n text += u' init=\"%s\"' % escape(self.initDefault, treedoc.escDict)\n if self.linkAltField:\n text += u' linkalt=\"%s\"' % escape(self.linkAltField,\n treedoc.escDict)\n return text",
"def xslText(self):\n return u'<xsl:value-of select=\"ancestor::*/%s\"/>' % self.name",
"def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def getXml(self):\n return _SALOMERuntime.InputXmlPort_getXml(self)",
"def generateXML(self):\n return self.formatEval(\n self.TEMPLATES[self.attrs['name']]['XML'],\n self.attrs\n )",
"def storeAndReturnXML(self):\n self._storeItems()\n return self.toXML()",
"def get_xml(self):\n return etree.tostring(self.get_etree())",
"def definition_to_xml(self, resource_fs):\r\n raise NotImplementedError(\r\n \"%s does not implement definition_to_xml\" % self.__class__.__name__)",
"def create_gen_xml(self, out_file):\n\n param_list = []\n msg = []\n msg_type = []\n dep_node = []\n for line in self.full_ed_lines:\n param_list.append(line.text())\n dep_pkg = param_list[6].split(', ')\n if dep_pkg[len(dep_pkg) - 1] == '':\n dep_pkg.pop()\n for dep in self.manager.wid.sub_list:\n dep_node.append(dep['msg_type'])\n for dep in self.manager.wid.pub_list:\n dep_node.append(dep['msg_type'])\n for dep in dep_node:\n a, b = dep.split('/')\n msg.append(a)\n msg_type.append(b)\n f = open('../genkernel/templates/package_rosgen.xml')\n o = open(out_file, 'a')\n flag = 0\n while 1:\n line = f.readline()\n if not line: break\n for i in range(6):\n line = line.replace('[{0}]'.format(i), param_list[i])\n line = line.replace('[7]', param_list[7])\n if line.find('[6]') != -1:\n for dep in dep_pkg:\n line_dep = '\\t<depend>{0}</depend>\\n'.format(dep)\n o.write(line_dep)\n flag = 1\n elif line.find('[8]') != -1:\n for dep, tp in zip(msg, msg_type):\n line_dep = '\\t\\t<depend type=\"{1}\">{0}</depend>\\n'.format(dep, tp)\n o.write(line_dep)\n flag = 1\n elif line.find('<subscribers>') != -1:\n o.write('\\t\\t<subscribers>\\n')\n for sub in self.manager.wid.sub_list:\n o.write('\\t\\t\\t<sub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(sub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(sub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(sub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(sub['queue_size']))\n o.write('\\t\\t\\t</sub>\\n')\n o.write('\\t\\t</subscribers>\\n')\n flag = 1\n elif line.find('<publishers>') != -1:\n o.write('\\t\\t<publishers>\\n')\n for pub in self.manager.wid.pub_list:\n o.write('\\t\\t\\t<pub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(pub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(pub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(pub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(pub['queue_size']))\n o.write('\\t\\t\\t</pub>\\n')\n o.write('\\t\\t</publishers>\\n')\n flag = 1\n if flag == 0:\n o.write(line)\n else:\n flag = 0\n o.close()\n f.close()\n self.changed = False",
"def to_xml_file(self, xml_file_path):\n s = self.to_xml()\n with open(xml_file_path, \"w+b\") as f:\n f.write(s)",
"def saveToXml(self) -> org.jdom.Element:\n ...",
"def getXML(self):\n\n def _getElementForMappingEntry(entry, mappingStyle):\n xmlDocTmp = Document()\n element = xmlDocTmp.createElement(mappingStyle)\n for k, v in viewitems(entry):\n # ignore empty, None or compiled regexp items into output\n if not v or (k == \"path-match-expr\"):\n continue\n element.setAttribute(k, str(v))\n return element\n\n xmlDoc = Document()\n root = xmlDoc.createElement(\"storage-mapping\") # root element name\n for mappingStyle, mappings in viewitems(self):\n for mapping in mappings:\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\n root.appendChild(mapElem)\n return root.toprettyxml()",
"def write(self):\n temp_string = minidom.parseString(ET.tostring(self.root)).toprettyxml(encoding=\"UTF-8\")\n with open(self.xml_file, 'w') as f:\n f.write(temp_string)\n # f = open(self.xml_file, \"w\")\n # f.write(temp_string)\n # f.close()",
"def write(self):\n filters = {\n 'MSGUID': lambda x: ('{%s}' % x).upper(),\n 'relslnfile': lambda x: os.path.relpath(x, os.path.dirname(self.FileName))\n }\n context = {\n 'sln': self\n }\n return self.render(self.__jinja_template__, self.FileName, context, filters)",
"def generate(self):\n xml = self.template()\n fp = BytesIO()\n gzip = GzipFile(self.filename, \"wb\", 9, fp)\n if isinstance(xml, str):\n xml = xml.encode(\"utf8\")\n gzip.write(xml)\n gzip.close()\n data = fp.getvalue()\n fp.close()\n return data",
"def to_xml(self) -> str:\n # default name and stuff setup\n element_root, xml_tree = super()._add_basics()\n element_root = element_root.find('elementProp')\n element_root = element_root.find('collectionProp')\n for element in list(element_root):\n try:\n if element.attrib['name'] == 'influxdbUrl':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.influx_db_url:\n elem.text = self.influx_db_url\n elif element.attrib['name'] == 'application':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.application:\n elem.text = self.application\n elif element.attrib['name'] == 'measurement':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.measurement:\n elem.text = self.application\n elif element.attrib['name'] == 'summaryOnly':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value':\n elem.text = str(self.summary_only).lower()\n elif element.attrib['name'] == 'samplersRegex':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.samplers_regexp:\n elem.text = self.samplers_regexp\n elif element.attrib['name'] == 'percentiles':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.percentiles:\n elem.text = self.percentiles\n elif element.attrib['name'] == 'testTitle':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.test_title:\n elem.text = self.test_title\n elif element.attrib['name'] == 'eventTags':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.event_tags:\n elem.text = self.event_tags\n except Exception:\n raise Exception(f'Unable to render xml from {type(self).__class__}')\n return tree_to_str(xml_tree, hashtree=True)",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def getXSLURL(self, output='page'):\n mn_props = getToolByName(self, \"portal_properties\")['metnav_properties']\n output = output.lower().strip()\n if output == 'page':\n return mn_props.getProperty('XSL_PAGE', '')\n if output == 'portlet':\n return mn_props.getProperty('XSL_PORTLET', '')\n if output == 'dict':\n return mn_props.getProperty('XSL_DICT', '')\n if output == 'count':\n return mn_props.getProperty('XSL_COUNT', '')\n if output == 'rss':\n return mn_props.getProperty('XSL_RSS', '')\n if output == 'class_list':\n return mn_props.getProperty('XSL_CLASS_LIST', '')\n if output == 'table':\n return mn_props.getProperty('XSL_TABLE', '')\n if output == 'year_list':\n return mn_props.getProperty('XSL_YEAR_LIST', '')\n raise \"%s is not a valid value for an XSL output\" % output",
"def transform_s3_xsl(**kwargs):\n access_id = kwargs.get(\"access_id\")\n access_secret = kwargs.get(\"access_secret\")\n bucket = kwargs.get(\"bucket\")\n dest_prefix = kwargs.get(\"destination_prefix\")\n source_prefix = kwargs.get(\"source_prefix\")\n if kwargs.get(\"dag\"):\n run_id = kwargs.get(\"dag\").dag_id\n else:\n run_id = \"no-dag-provided\"\n\n saxon = prepare_saxon_engine()\n transformed = etree.Element(\"collection\")\n transformed.attrib[\"dag-id\"] = run_id\n transformed.attrib[\"dag-timestamp\"] = kwargs.get(\"timestamp\", \"no-timestamp-provided\")\n xsl = \"https://raw.github.com/{repo}/{branch}/{filename}\".format(\n repo=kwargs.get(\"xsl_repository\", \"tulibraries/aggregator_mdx\"),\n branch=kwargs.get(\"xsl_branch\", \"main\"),\n filename=kwargs.get(\"xsl_filename\")\n )\n\n for s3_key in process.list_s3_content(bucket, access_id, access_secret, source_prefix):\n logging.info(\"Transforming File %s\", s3_key)\n s3_content = process.get_s3_content(bucket, s3_key, access_id, access_secret)\n s3_xml = etree.fromstring(s3_content)\n for record in s3_xml.iterchildren():\n record_id = record.get(\"airflow-record-id\")\n logging.info(\"Transforming Record %s\", record_id)\n result_str = subprocess.check_output([\"java\", \"-jar\", saxon, \"-xsl:\" + xsl, \"-s:-\"], input=etree.tostring(record, encoding=\"utf-8\"))\n result = etree.fromstring(result_str)\n result.attrib[\"airflow-record-id\"] = record_id\n transformed.append(result)\n filename = s3_key.replace(source_prefix, dest_prefix)\n transformed_xml = etree.tostring(transformed, encoding=\"utf-8\")\n process.generate_s3_object(transformed_xml, bucket, filename, access_id, access_secret)",
"def export_to_xml(self, resource_fs):\r\n\r\n # Set up runtime.export_fs so that it's available through future\r\n # uses of the pure xblock add_xml_to_node api\r\n self.runtime.export_fs = resource_fs\r\n\r\n # Get the definition\r\n xml_object = self.definition_to_xml(resource_fs)\r\n self.clean_metadata_from_xml(xml_object)\r\n\r\n # Set the tag so we get the file path right\r\n xml_object.tag = self.category\r\n\r\n # Add the non-inherited metadata\r\n for attr in sorted(own_metadata(self)):\r\n # don't want e.g. data_dir\r\n if attr not in self.metadata_to_strip and attr not in self.metadata_to_export_to_policy:\r\n val = serialize_field(self._field_data.get(self, attr))\r\n try:\r\n xml_object.set(attr, val)\r\n except Exception:\r\n logging.exception(\r\n u'Failed to serialize metadata attribute %s with value %s in module %s. This could mean data loss!!!',\r\n attr, val, self.url_name\r\n )\r\n\r\n for key, value in self.xml_attributes.items():\r\n if key not in self.metadata_to_strip:\r\n xml_object.set(key, value)\r\n\r\n if self.export_to_file():\r\n # Write the definition to a file\r\n url_path = name_to_pathname(self.url_name)\r\n filepath = self._format_filepath(self.category, url_path)\r\n resource_fs.makedir(os.path.dirname(filepath), recursive=True, allow_recreate=True)\r\n with resource_fs.open(filepath, 'w') as file:\r\n file.write(etree.tostring(xml_object, pretty_print=True, encoding='utf-8'))\r\n\r\n # And return just a pointer with the category and filename.\r\n record_object = etree.Element(self.category)\r\n else:\r\n record_object = xml_object\r\n\r\n record_object.set('url_name', self.url_name)\r\n\r\n # Special case for course pointers:\r\n if self.category == 'course':\r\n # add org and course attributes on the pointer tag\r\n record_object.set('org', self.location.org)\r\n record_object.set('course', self.location.course)\r\n\r\n return etree.tostring(record_object, pretty_print=True, encoding='utf-8')",
"def writeXMLDecl(self):\n return _libsbml.XMLOutputStream_writeXMLDecl(self)",
"def setXSLTMode(self,value):\n self.PDFreactorConfiguration.in1[\"XSLTMode\"] = value",
"def save(self, filename=None):\n f = filename if filename else self.path\n etree.register_namespace('', TEI)\n etree.register_namespace('mith', MITH)\n self.doc.write(f, xml_declaration=True, encoding='utf-8', method='xml')",
"def toXML(self):\n return self._xmlpre+\"\\n\".join(map(lambda f:f.toXML(),self._items))+self._xmlpost",
"def to_xml(self):\n # lines = super(FileCatNoEmpty, self).cat(filepath)\n structure = super(Point, self).to_xml()\n\n\n coords = GeometryTopologyData.__to_xml_vector__(self.coordinate, self.format)\n # description_str = ''\n # if self.description is not None:\n # description_str = '<Description>%s</Description>' % self.description\n\n return '<Point>%s<Coordinate>%s</Coordinate></Point>' % (structure, coords)",
"def write(klass, document, target=None, stylesheet=\"\"):\n writer = LatexWriter(document, target, stylesheet)\n return writer.go()",
"def to_xml(self, file_name=None):\n if file_name:\n xml_file = open(file_name, 'w')\n results = ['<schema name=\"%s\">' % self.name]\n for schema_object in list(self.schema.keys()):\n results.append(self.schema[schema_object].to_xml())\n results.append('</schema>')\n if file_name:\n xml_file.write('\\n'.join(results))\n xml_file.close()\n else:\n return '\\n'.join(results)",
"def write_xosc(self, generated_xml):\n reparsed_xml = minidom.parseString(generated_xml).toprettyxml(indent=\" \")\n xosc_file = open(self._filepath, \"w\")\n xosc_file.write(reparsed_xml)\n xosc_file.close()\n\n msg = QMessageBox()\n if self._warning_message:\n msg.setIcon(QMessageBox.Warning)\n text = f\"Exported OpenSCENARIO file {self._filepath} has warnings!\\n\\n\"\n text += \"\\n\".join(self._warning_message)\n else:\n msg.setIcon(QMessageBox.Information)\n text = f\"Successfully exported OpenSCENARIO file to {self._filepath}\"\n msg.setText(text)\n msg.setWindowTitle(\"OpenSCENARIO Export\")\n msg.setStandardButtons(QMessageBox.Ok)\n msg.exec()",
"def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()",
"def start_serialization(self):\n self.xml = SimplerXMLGenerator(self.stream, self.options.get(\"encoding\", settings.DEFAULT_CHARSET))\n self.xml.startDocument()\n self.xml.startElement(\"xliff\", {\n \"version\": \"1.2\",\n \"xmlns\": \"urn:oasis:names:tc:xliff:document:1.2\",\n \"xmlns:d\": \"https://docs.djangoproject.com/\"\n })",
"def XML_EC_PL(Name, InputsFile, OutputFile, emin,emax):\n\n\t#On commence par afficher ce qu'on fait\r\n\tprint \" Build xml file \"\r\n\r\tprint InputsFile\n\t#ouverture du fichier dans lequel on place le source model\n\ttry:\n\t\tfresult = open(OutputFile, 'w')\n\texcept:\n\t\tprint \"Coucou\"\r\n \t#ecriture des premieres lignes invariantes\n\tfresult.write('<?xml version=\"1.0\" ?>')\r\n\tfresult.write(\"<source_library title=\\\"source library\\\">\\n\")\n\r\n \t#ouverture du fichier avec les entrees\r\n\tf = open(InputsFile,\"r\")\r\n\tlines = f.readlines()\r\n\t\r\n \t#Ajout des sources detectees dans le catalogue\n\t#Pour chaque ligne du fichier d'entree\r\n\tfor line in range(len(lines)):\n\t\t#Lire les donnees de la ligne\t\t\r\n\t\tdata = lines[line].split()\r\n\t\tname = data[0]\n\n\t\t#Verification : est on en train de traiter la source que l'on veut etudier ou une autre ?\r\n\t\tif str(name) == Name :\r\n\t\t\tmysource = 1\r\n\t\telse:\r\n\t\t\tmysource = 0\n\n\t\t#recuperation des donnees\r\n\t\tRA = data[1]\r\n\t\tDEC = data[2]\r\n\t\tIntegral = float(data[3])*float(Frac)\r\n\t\tGamma= data[4]\n\n\t\t\r\n\t\ttry:\n\t\t\t#essai de definition des donnees pour un PL avec ExpCut\n\t\t\tPrefactor = float(data[5])*float(Frac)\r\n\t\t\tEnergy = float(data[6])\r\n\t#\t\tPrefactor = Prefactor/pow(Energy/100., float(Gamma)) #Densite de flux calculee a Epivot\r\n\t#\t\tPrefactor = Prefactor*pow(1000./100., float(Gamma)) #We do the calculation with (E/1000.)^Gamma\n\t\t\tvariabilite=float(data[8])\n\n#\t\t\tprint variabilite\n\n\n\n\r\n\t\t\tcut = float(data[7]) # Cut est la variable qui nous permettra de savoir si il faut utiliser un cut off (1) ou une loi de puissance normale (2)\r\n\t\texcept:\r\n\t\t\ttry:\r\n\t\t\t\tcut = float(data[5])\r\n\t\t\texcept:\r\n\t\t\t\tprint \" Wrong size of list \"\r\n\t\t\t\tsys.exit()\r\n \t#Si on considere un ccut off exponentiel pour la source :\r\n\t\tif cut == 1:\n\t\t\t#ecriture du nom de la source consideree\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\r\n\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\r\n\t\t\tspectrum_type = \"PLSuperExpCutoff\"\n\t\t\t#Utilisation de la modelisation PLSuperExpCutoff car plus simple et plus intuitive pour nous et pour la modelisation des pulsars si il faut en modeliser\n\r\n\t\t\t#definition des parametres spectraux a prendre en comtpe et de la chaine de caractere a integrer\r\n\n\n\n\t\t\tif variabilite==0.0 or variabilite==2.0:\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"10000000.0\\\" min=\\\"0.0000001\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\r\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.001\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\n\r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\t\t\telif variabilite==1.0 :\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10000000.0\\\" min=\\\"0.0\\\"\"\n\n\t\t\t\t#d'ou vient ce 1e-12\r\n\t\t\t\tIntegral = float(Prefactor)*1.0e10\r\n\t\t\t\tscale = 1.0e-10\n\n\t\t\t\tspectrum_lines += \" name=\\\"Prefactor\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index1\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"20000.0\\\" min=\\\"1.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Scale\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Energy)+\"\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"100.0\\\" min=\\\"0.0001\\\"\"\r\t\t\t\tspectrum_lines += \" name=\\\"Cutoff\\\" scale=\\\"1000.0\\\" value=\\\"30.0\\\"/>\\n\"\r\n \r\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\t\tspectrum_lines += \" name=\\\"Index2\\\" scale=\\\"1.0\\\" value=\\\"1.0\\\"/>\\n\"\n\n\r\n \r\n\n# <spectrum type=\"PLSuperExpCutoff\">\n# <parameter free=\"1\" max=\"100000\" min=\"0\" name=\"Prefactor\" scale=\"1e-10\" value=\"Prefactor*1e-10\"/>\n# <parameter free=\"1\" max=\"0\" min=\"5\" name=\"Index1\" scale=\"-1\" value=\"valeur du catalogue\"/>\n# <parameter free=\"0\" max=\"20000\" min=\"1.0\" name=\"Scale\" scale=\"1\" value=\"Epivot\"/>\n# <parameter free=\"1\" max=\"300000\" min=\"100\" name=\"Cutoff\" scale=\"1\" value=\"3000\"/>\n# <parameter free=\"0\" max=\"5\" min=\"0\" name=\"Index2\" scale=\"1\" value=\"1.5\"/>\n# </spectrum>\n\n\r\n\t\telse:\n\t\t#Sinon (si on considere une loi de puissance simple)\n\t\t#definition de la chaine de caractere comportant le nom de la source\r\n\t\t\tresult_line=\" <source \"\r\n\t\t\tresult_line += \"name=\\\"\"+name+\"\\\"\"\n\t\t\tif mysource == 0:\r\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\n\t\t\telse:\n\t\t\t\tresult_line += \" type=\\\"PointSource\\\">\\n\"\t\t\t\t\n\n\t\t\t#definition de la chaine de caractere correspondant a la forme de fit que l'on souhaite utiliser (Loi de puissance)\r\n\t\t\tspectrum_type = \"PowerLaw2\"\r\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre Integrale\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\r\n\t\t\telse:\n\t\t\t#sinon on le libere\r\n\t\t\t\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"1000000.0\\\" min=\\\"0.0\\\"\"\n\n\n\n\n\n\t\t\t#Toujours ce facteur....\r\n\t\t\tIntegral = float(Integral)*1e10\r\n\t\t\tscale = 1e-10\n\n\n\t\n\r\n\t\t\tspectrum_lines += \" name=\\\"Integral\\\" scale=\\\"\"+str(scale)+\"\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Integral)+\"\\\" />\\n\"\n\r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t\t\t\t#si ce n'est pas la source que l'on etudie on fige le parametre gamma\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\r\n\t\t\telse:\n\t\t\t\t#si c'est pas la source que l'on etudie on le laisse libre\r\n\t\t \t\tspectrum_lines += \" <parameter free=\\\"1\\\" max=\\\"5.0\\\" min=\\\"0.\\\"\"\n\n\t\t\t#fin de la chaine de parametres sur le modele spectral\r\n\t\t\tspectrum_lines += \" name=\\\"Index\\\" scale=\\\"-1.0\\\" value=\\\"\"\r\n\t\t\tspectrum_lines += str(Gamma)+\"\\\"/>\\n\"\r\n \r\n\t\t\tif mysource == 0 and variabilite!=1.0:\n\t \n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"1000.0\\\"/>\\n\"\r\n \r\n\t\t\t spectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"1000000.0\\\" min=\\\"20.0\\\"\"\r\n\t\t\t spectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\t\t\telse:\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"200000.0\\\" min=\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"LowerLimit\\\" scale=\\\"1.0\\\" value=\\\"100\\\"/>\\n\"\n\n\t\t\t\tspectrum_lines += \" <parameter free=\\\"0\\\" max=\\\"100000.0\\\" Min =\\\"20.0\\\"\"\n\t\t\t\tspectrum_lines += \" name=\\\"UpperLimit\\\" scale=\\\"1.0\\\" value=\\\"100000.0\\\"/>\\n\"\n\n \t\t#ajout du modele spectral a la liste de parametres \r\n\t\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\t\tresult_line += spectrum_lines\r\n\t\tresult_line += \" </spectrum>\\n\"\n\n\t\t\n\n\t\tif mysource==0 and variabilite!=1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telif mysource==0 and variabilite==1.0:\n \t\t\t#ajout du modele spatial a la liste de parametres \r\n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\r\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\r\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\r\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\telse:\n #ajout du modele spatial a la liste de parametres \n\t\t\tresult_line += \" <spatialModel type=\\\"SkyDirFunction\\\">\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"360\\\" min=\\\"-360\\\"\"\n\t\t\tresult_line += \" name=\\\"RA\\\" scale=\\\"1\\\" value=\\\"\"+RA+\"\\\"/>\\n\"\n\t\t\tresult_line += \" <parameter free=\\\"1\\\" max=\\\"90\\\" min=\\\"-90\\\"\"\n\t\t\tresult_line += \" name=\\\"DEC\\\" scale=\\\"1\\\" value=\\\"\"+DEC+\"\\\"/>\\n\"\n\t\t\tresult_line += \" </spatialModel>\\n\"\n\t\t\t\n\t\tresult_line += \" </source>\\n\"\r\n\t\tfresult.write(result_line+\"\\n\")\r\n #Ajout du fond diffus galactique\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"gal_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"ConstantValue\"\r\n\r\n\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Value\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n\r\n\tresult_line += \" <spatialModel file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/gll_iem_v02.fit\\\" type=\\\"MapCubeFunction\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"1000.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Normalization\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\r\n \t#Ajout du fond diffus extragalactique\r\n\tresult_line=\" <source \"\r\n\tresult_line += \"name=\\\"eg_v02\\\"\"\r\n\tresult_line += \" type=\\\"DiffuseSource\\\">\\n\"\r\n\tspectrum_type = \"FileFunction\"\r\n\r\tspectrum_lines = \" <parameter free=\\\"1\\\" max=\\\"10.0\\\" min=\\\"0\\\"\"\r\n\tspectrum_lines += \" name=\\\"Normalization\\\" scale=\\\"1.0\\\" value=\\\"\"+str(Frac)+\"\\\" />\\n\"\r\n\r\n\tresult_line += \" <spectrum file=\\\"/nfs/farm/g/glast/u31/marianne/VelaX/July09_Pointed/isotropic_iem_v02.txt\\\" type=\\\"\"+spectrum_type+\"\\\">\\n\"\r\n\tresult_line += spectrum_lines\r\n\tresult_line += \" </spectrum>\\n\"\r\n \r\n\tresult_line += \" <spatialModel type=\\\"ConstantValue\\\">\\n\"\r\n\tresult_line += \" <parameter free=\\\"0\\\" max=\\\"100.0\\\" min=\\\"0.0\\\"\"\r\n\tresult_line += \" name=\\\"Value\\\" scale=\\\"1\\\" value=\\\"1.0\\\"/>\\n\"\r\n\tresult_line += \" </spatialModel>\\n\"\r\n\tresult_line += \" </source>\\n\"\r\n\tfresult.write(result_line+\"\\n\")\r\n\n \t#Fermeture des fichiers \r\n\tf.close() \r\n\tfresult.write(\"\\n</source_library>\\n\")\r\n\tfresult.close()\r\n\treturn",
"def get(self):\n return _SALOMERuntime.OutputXmlPort_get(self)",
"def toXML(self):\n return _libsbml.Layout_toXML(self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def write(self):\r\n for prop in self.prpnames:\r\n elem = SubElement(self._root, prop)\r\n data = self.__getattribute__(prop)\r\n if self.prpnames[prop]['type'] == \"text\":\r\n elem.text = data\r\n elif self.prpnames[prop]['type'] == 'list':\r\n for x in data:\r\n SubElement(elem, 'regel').text = x\r\n elif self.prpnames[prop]['type'] == 'attr':\r\n elem.set(self.prpnames[prop]['naam'], data)\r\n tree = ElementTree(self._root)\r\n tree.write(self._fn)\r\n if not self.exists:\r\n self.exists = True",
"def write(self, file_or_filename):\n etMap = revert(self)\n xmlTree = ET.ElementTree(etMap)\n xmlTree.write(file_or_filename)",
"def save_to_xml(self, xwriter):\r\n\r\n xwriter.WriteStartElement(\"Profile\")\r\n xwriter.WriteAttributeString(\"Name\", self.Name)\r\n xwriter.WriteStartAttribute(\"Version\")\r\n xwriter.WriteValue(self.Version)\r\n xwriter.WriteEndAttribute()\r\n\r\n for var_name in self.__dict__:\r\n var_type = type(getattr(self, var_name))\r\n\r\n if var_type is str and var_name != \"Name\":\r\n self.write_string_to_xml(var_name, xwriter)\r\n\r\n elif var_type is bool:\r\n self.write_bool_to_xml(var_name, xwriter)\r\n\r\n elif var_type is dict:\r\n self.write_dict_to_xml(var_name, xwriter)\r\n\r\n elif var_type is list and var_name != \"ExcludeRules\":\r\n self.write_list_to_xml(var_name, xwriter)\r\n\r\n xwriter.WriteStartElement(\"ExcludeRules\")\r\n xwriter.WriteAttributeString(\"Operator\", self.ExcludeOperator)\r\n xwriter.WriteAttributeString(\"ExcludeMode\", self.ExcludeMode)\r\n for rule in self.ExcludeRules:\r\n if rule:\r\n rule.save_xml(xwriter)\r\n xwriter.WriteEndElement()\r\n \r\n xwriter.WriteEndElement()",
"def xmlWrite(self, xmlWriter, font, value, name, attrs):\n raise NotImplementedError(self)",
"def writeXMLNS(self, *args):\n return _libsbml.ASTBasePlugin_writeXMLNS(self, *args)",
"def write_output_file(self, xml_text, xml_file):\n xml_fo = open(xml_file, 'w')\n xml_fo.write(xml_text+'</xml>')\n xml_fo.close()\n return",
"def _generate_xml(self, body, destn_dir, nodes=True):\n fn = ''.join([random.choice(string.ascii_letters) for _ in range(12)])\n fn += '.xml'\n\n _dir = os.path.dirname(os.path.abspath(__file__))\n _tmpl = 'multi_node.template' if nodes else 'single_node.template'\n _env = Environment(autoescape=False,\n loader=FileSystemLoader(_dir),\n trim_blocks=False)\n\n with open(fn, 'w+') as f:\n o = _env.get_template(_tmpl).render(body)\n f.write(o)\n\n _d = destn_dir + '/' + fn\n self._remote_copy(fn, _d)\n # Remove the XML file created locally\n os.remove(fn)\n\n return _d",
"def dumps(records, xslt_filename=None, **kwargs):\n root = dumps_etree(records=records, xslt_filename=xslt_filename)\n return etree.tostring(\n root,\n pretty_print=True,\n xml_declaration=True,\n encoding='UTF-8',\n **kwargs\n )",
"def xml(self):\n raise NotImplementedError('This api does not return xml')",
"def _writeXML(self,output,outputDictionary):\n if self.dynamic:\n outputInstance = xmlUtils.DynamicXmlElement('MetricPostProcessor', pivotParam=self.pivotParameter)\n else:\n outputInstance = xmlUtils.StaticXmlElement('MetricPostProcessor')\n if self.dynamic:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n for ts, pivotVal in enumerate(self.pivotValues):\n if values.shape[0] == 1:\n outputInstance.addScalar(nodeName, metricName,values[0], pivotVal=pivotVal)\n else:\n outputInstance.addScalar(nodeName, metricName,values[ts], pivotVal=pivotVal)\n else:\n for key, values in outputDictionary.items():\n assert(\"|\" in key)\n metricName, nodeName = key.split('|')\n if len(list(values)) == 1:\n outputInstance.addScalar(nodeName, metricName, values[0])\n else:\n self.raiseAnError(IOError, \"Multiple values are returned from metric '\", metricName, \"', this is currently not allowed\")\n return outputInstance",
"def writeXml(self):\n curdir = os.getcwd()\n os.chdir(self.Imagedir)\n allImageLists = [self.sciImlist, self.ctxImlist, self.wgtImlist, self.rmsImlist]\n \n for imlist in allImageLists:\n for im in imlist:\n file = xmlUtil.markupImage(im,dataset=self.obsName)\n \n # Don't write these images as output of this module, which\n # really doesn't have any.\n \n #if file not in self.outputList.keys():\n # self.outputList[file] = [im]\n \n os.chdir(curdir)\n return",
"def docType():\n return (u'<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n u'<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 '\n u'Transitional//EN\" '\n u'\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\\n')",
"def to_xml(self, scene_dir: str) -> Tuple[Et.Element, bool]:\n raise NotImplementedError",
"def save_xml_file():\n global output_on_display, import_lst, column_names, data\n if data_base == '':\n mistake_load_table()\n else:\n column_names = data[0]\n step = len(column_names)\n\n save_name = asksaveasfilename(title=\"Select file\", filetypes=((\"XML\", \"*.xml\"), (\"all files\", \"*.*\")),\n confirmoverwrite=True, defaultextension='.xml')\n data = import_lst\n\n if len(data[0]) == step:\n pass\n else:\n data = import_lst[step::]\n\n data2 = list(map(list, zip(*data)))\n\n data3 = {key: value for key, value in zip(column_names, data2)}\n\n column = list(data3.keys())\n\n df = pd.DataFrame(data3, columns=column)\n\n data_dict = df.to_dict(orient=\"records\")\n with open('output.json', \"w+\") as f:\n json.dump(data_dict, f, indent=4)\n\n xml_data = dicttoxml(data_dict).decode()\n with open(save_name, \"w+\") as f:\n f.write(xml_data)\n\n data.clear()\n data2.clear()\n data3.clear()",
"def Write(self):\n f = open(self.project_path, 'wt')\n self.doc.writexml(f,\n encoding='Windows-1252',\n addindent=' ',\n newl='\\n')\n f.close()",
"def write(self, filename, agg_dir):\n super().write(filename)\n\n if self.aggregation:\n agg = self.aggregation\n abs_subdir = os.path.join(agg_dir, agg.sub_dir)\n if not os.path.isdir(abs_subdir):\n os.makedirs(abs_subdir)\n\n agg.xml_element.write(os.path.join(abs_subdir, agg.basename))",
"def to_sbml(self, params):\n files = {}\n _id, cobra_model = self._ws_obj_to_cobra(params['input_ref'])\n files['file_path'] = os.path.join(params['destination_dir'], _id + \".xml\")\n cobra.io.write_sbml_model(cobra_model, files['file_path'])\n\n return _id, files",
"def write2file(self, save_to):\n headerstyle = xlwt.easyxf(self.header_style.get_style_string())\n missing_val_style = xlwt.easyxf(\n self.missing_value_style.get_style_string())\n row_styles = [xlwt.easyxf(self.first_style.get_style_string()),\n xlwt.easyxf(self.second_style.get_style_string())]\n\n properties, sections, table = self._build_table()\n\n workbook = xlwt.Workbook()\n sheet = workbook.add_sheet(self.sheet_name)\n\n if os.path.splitext(save_to)[-1] == '':\n save_to += '.xls'\n\n max_col_len = []\n\n if (self.switch):\n\n for i, prop in enumerate([''] + properties):\n sheet.write(0, i, prop, headerstyle)\n max_col_len.append(len(str(prop)))\n\n for row_num, sec in enumerate(sections):\n sheet.write(row_num + 1, 0, sec, headerstyle)\n if len(str(sec)) > max_col_len[0]:\n max_col_len[0] = len(str(sec))\n\n for row_num, row in enumerate(table):\n for col_num, elem in enumerate(row):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n else:\n\n for i, sec in enumerate([''] + sections):\n sheet.write(0, i, sec, headerstyle)\n max_col_len.append(len(str(sec)))\n\n for row_num, prop in enumerate(properties):\n sheet.write(row_num + 1, 0, prop, headerstyle)\n if len(str(prop)) > max_col_len[0]:\n max_col_len[0] = len(str(prop))\n\n for col_num, col in enumerate(table):\n for row_num, elem in enumerate(col):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n # adjust width of he columns\n for col_id, col_len in enumerate(max_col_len):\n sheet.col(col_id).width = (256 * (col_len+1))\n\n workbook.save(save_to)",
"def writeToTempXml(self):\n name = self.fileToProcess.name\n all_tokens = ET.Element(\"tokens\")\n for token in self.tokensTable:\n if token.getType() == KEYWORD:\n keyword = ET.SubElement(all_tokens, \"keyword\")\n keyword.text = ' '+token.getValue()+' '\n elif token.getType() == IDENTIFIER:\n identifier = ET.SubElement(all_tokens, \"identifier\")\n identifier.text = ' '+token.getValue()+' '\n elif token.getType() == SYMBOL:\n symbol = ET.SubElement(all_tokens, \"symbol\")\n symbol.text = ' '+token.getValue()+' '\n elif token.getType() == STRING_CONST:\n stringConstant = ET.SubElement(all_tokens, \"stringConstant\")\n stringConstant.text = ' '+token.getValue()+' '\n elif token.getType() == INT_CONST:\n integerConstant = ET.SubElement(all_tokens, \"integerConstant\")\n integerConstant.text = ' '+token.getValue()+' '\n tree = ET.ElementTree(all_tokens)\n tree.write(name + 'T' + '.xml')",
"def xslText(self):\n return u'<xsl:for-each select = \"./%s\">%s<xsl:choose>'\\\n '<xsl:when test=\"contains(., \\':\\')\"><a href=\"{.}\">'\\\n '<xsl:value-of select=\".\"/></a></xsl:when><xsl:otherwise>'\\\n '<a href=\"%s{.}\"><xsl:value-of select=\".\"/></a>'\\\n '</xsl:otherwise></xsl:choose>%s</xsl:for-each>' % \\\n (self.name, xslEscape(self.prefix), self.URLMethod,\n xslEscape(self.suffix))",
"def getXML(self):\n nodes = list(self.nodes(data=True))\n nodes.sort()\n node_string = ''\n for n in nodes:\n attribute_string = ''\n keys = list(n[1].keys())\n keys.sort()\n for k in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(k, n[1][k], k)\n modification_string = ''\n modified_by = self.predecessors(n[0])\n if modified_by:\n for mod in modified_by:\n modification_string += \"\"\"<modified_by>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifyingNode> %s </modifyingNode>\\n\"\"\"%mod.getTagID()\n modification_string += \\\n \"\"\"<modifyingCategory> %s </modifyingCategory>\\n\"\"\"%mod.getCategory()\n modification_string += \"\"\"</modified_by>\\n\"\"\"\n modifies = self.successors(n[0])\n if modifies:\n for modified in modifies:\n modification_string += \"\"\"<modifies>\\n\"\"\"\n modification_string += \\\n \"\"\"<modifiedNode> {0} </modifiedNode>\\n\"\"\".format(modified.getTagID())\n modification_string += \\\n \"\"\"</modifies>\\n\"\"\"\n node_string += \\\n NODE_XML_SKEL.format(attribute_string+\"{0}\".format(n[0].getXML()) +\\\n modification_string)\n edges = list(self.edges(data=True))\n edges.sort()\n edge_string = ''\n for edge in edges:\n keys = list(edge[2].keys())\n keys.sort()\n attribute_string = ''\n for key in keys:\n attribute_string += \"\"\"<{0}> {1} </{2}>\\n\"\"\".format(key, edge[2][key], key)\n edge_string += \"{0}\".format(EDGE_XML_SKEL.format(edge[0].getTagID(),\n edge[1].getTagID(),\n attribute_string))\n\n return CONTEXT_MARKUP_XML_SKEL.format(xmlScrub(self.getRawText()),\n xmlScrub(self.getText()),\n node_string,\n edge_string)",
"def writeXMLNS(self, *args):\n return _libsbml.MultiASTPlugin_writeXMLNS(self, *args)",
"def run_xslt(xml_filename, xsl_filename):\n import subprocess\n from misc.localexec import LocalExec\n from distutils.spawn import find_executable\n\n def seekout_xsltproc():\n XSLTPROC_BIN = 'xsltproc'\n executable = find_executable(XSLTPROC_BIN)\n if executable:\n return os.path.abspath(executable)\n raise SignerError(\"it has not found {} binary\".format(XSLTPROC_BIN))\n\n le = LocalExec(err_mute=True)\n exe = seekout_xsltproc()\n exe_args = [ xsl_filename, xml_filename ]\n\n try:\n return le([exe] + exe_args, cmd_timeout=20, ign_rcs=None)\n except subprocess.CalledProcessError as e:\n msg = \"Command raised exception\\nOutput: \" + str(e.output)\n raise Exception(msg)",
"def _write_context_to_file(self, context):\n om.out.debug('[xml_file.flush()] Starting _write_context_to_file()')\n\n template = self._jinja2_env.get_template('root.tpl')\n\n # We use streaming as explained here:\n #\n # http://flask.pocoo.org/docs/0.12/patterns/streaming/\n #\n # To prevent having the whole XML in memory\n # pylint: disable=E1101\n report_stream = template.stream(context)\n report_stream.enable_buffering(3)\n # pylint: enable=E1101\n\n # Write everything to a temp file, this is useful in two cases:\n #\n # * An external tool will always see a valid XML in the output,\n # and not just a partially written XML document.\n #\n # * If w3af is killed in the middle of writing the XML report,\n # the report file will still be valid -- if xml_file.flush() was\n # run successfully at least once\n tempfh = NamedTemporaryFile(delete=False,\n prefix='w3af-xml-output',\n suffix='.xml')\n\n om.out.debug('[xml_file.flush()] write_context_to_file() created'\n ' template.stream and NamedTemporaryFile')\n\n try:\n # Write each report section to the temp file\n for report_section in report_stream:\n tempfh.write(report_section.encode(DEFAULT_ENCODING))\n except Exception:\n # No exception handling is done here, we just raise the exception\n # so that the core can handle it properly\n raise\n else:\n # Close the temp file so all the content is flushed\n tempfh.close()\n\n om.out.debug('[xml_file.flush()] write_context_to_file() starting to'\n ' copy temp file to destination')\n\n # Copy to the real output file\n report_file_name = os.path.expanduser(self._file_name)\n\n cmd = 'cp %s %s' % (tempfh.name, report_file_name)\n subprocess.call(cmd, shell=True)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished copy'\n ' operation.')\n\n stat_info = os.stat(report_file_name)\n om.out.debug('The XML output file size is %s bytes.' % stat_info.st_size)\n\n finally:\n os.remove(tempfh.name)\n\n om.out.debug('[xml_file.flush()] write_context_to_file() finished')",
"def to_workbook(self) -> tuple:\n\n # Initialize the bytestream\n f = io.BytesIO()\n wb = xw.Workbook(f, {\"in_memory\": True})\n\n # Open a workbook\n self._book = wb\n self._book.set_properties({\"category\": \"atomica:databook\"})\n self._formats = standard_formats(self._book)\n self._references = {} # Reset the references dict\n\n # Write the contents\n self._write_pops()\n self._write_tdve()\n self._write_interpops()\n self._write_transfers()\n\n # Clean internal variables related to writing the worbkook\n self._book = None\n self._formats = None\n self._references = None\n\n return f, wb",
"def format_xml(self,query_results):\n results=query_results.data\n factory=factory_xml()\n dump=factory.dumps({'data':results})\n print(dump)\n # TODO return output for this\n return \"\"",
"def write_to_xml(dictData, metadata, xmlfile):\n\tfout = codecs.open(xmlfile, 'w', 'utf-8')\n\tfout.write('<?xml version = \"1.0\" encoding = \"UTF-8\" standalone = \"no\" ?>\\n')\n\tfout.write('<?xml-stylesheet type=\"text/xsl\" href=\"maketable.xsl\"?>\\n')\n\tfout.write('<root>\\n')\n\tfout.write('<meta>\\n')\n\tfor key, value in metadata.items():\n\t\tfout.write('<' + key + '>' + value + '</' + key + '>\\n')\n\tfout.write('</meta>\\n')\n\tfout.write('<content>\\n')\n\tfor (hw, meanings, verse, verseNumDetails, pageNumDetails) in dictData:\n\t\txmlline = ''\n\t\txmlline += '<word><headword>' + hw + '</headword><meanings>'\n\t\tfor meaning in meanings:\n\t\t\txmlline += '<m>' + meaning + '</m>'\n\t\txmlline += '</meanings>'\n\t\txmlline += '<verse>'\n\t\tlines = verse.split('<BR>')\n\t\tfor line in lines:\n\t\t\txmlline += '<line>' + line + '</line>'\n\t\txmlline += '</verse>'\n\t\txmlline += '<verseNumber>' + verseNumDetails + '</verseNumber>'\n\t\txmlline += '<pageNumber>' + pageNumDetails + '</pageNumber></word>'\n\t\t# Write in babylon format. <BR><BR> is to separate verses.\n\t\tfout.write(xmlline + '\\n')\n\t\txmlline = ''\n\tfout.write('</content>\\n</root>')\n\tfout.close()\n\n\t# Give some summary to the user\n\tprint('XML file generated. Success!')\n\tprint('{} metadata lines and {} content lines written to XML file.'.format(len(metadata), len(dictData)))",
"def xml(self):\n return self._xml",
"def xml(self):\n return self._xml",
"def writeSBMLToFile(self, *args):\n return _libsbml.SBMLWriter_writeSBMLToFile(self, *args)",
"def _create_xml_report(self, test, xml_obj):\n xml_report_path = os.path.join(test.work_dir,\n self.XML_REPORT_PATH)\n with open(xml_report_path, 'w') as xml_report:\n xml_report.write(etree.tostring(xml_obj, pretty_print=True))",
"def xml2html(self):\n handler = open(self.xml_doc).read()\n soup = BeautifulSoup(handler, 'xml')\n\n fw = open(self.filename_out, 'w')\n\n fw.write(\"<!DOCTYPE html>\" + os.linesep)\n fw.write(\"<html>\" + os.linesep)\n fw.write(\"<head>\" + os.linesep)\n fw.write('<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">' + os.linesep)\n fw.write(\"<link rel=\\\"stylesheet\\\" href=\\\"%s\\\" type=\\\"text/css\\\" />\" % self.stylesheet_name + os.linesep)\n fw.write(\"<title></title>\" + os.linesep)\n fw.write(\"</head>\" + os.linesep)\n fw.write(\"<body>\" + os.linesep)\n\n # Load styles in dictionaries\n for style in soup.find_all(\"style\"):\n style_name = style.get(\"style:name\")\n #print \"style: %s children: %s descendants: %s\" % (str(style_name), str(len(list(style.children))), len(list(style.descendants)))\n for style_child in style.children:\n fs = style_child.get(\"fo:font-style\")\n if fs:\n self.style_fontstyle[style_name] = fs\n fontw = style_child.get(\"fo:font-weight\")\n if fontw:\n self.style_fontweight[style_name] = fontw\n # read alignment\n txta = style_child.get(\"fo:text-align\")\n if txta:\n self.style_textalignment[style_name] = txta\n # !!!\n tu = style_child.get(\"style:text-underline-type\")\n if tu:\n self.style_textunderline[style_name] = \"underlined\"\n # page break\n break_before = style_child.get(\"fo:break-before\")\n if break_before:\n self.style_break_before[style_name] = break_before\n\n\n # Navigate down the document through h and p tags\n #\n for text in soup.find_all(re.compile(\"^h|^p\")):\n\n # From bs4 docs: If a tag has only one child, and that child is a NavigableString, the child is made available as .string:\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"P9\">- Any text here!</text:p>\n #\n # To do:\n #\n # Beware of this case:\n # - <text:p text:style-name=\"P8\">\n # <text:span text:style-name=\"T4\">\n #\n\n # Get the attributes so the styles and the outlines\n text_attrs = dict(text.attrs)\n\n # Get the styles, if any\n try:\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n if text.string:\n t = unicode(text.string)\n if t:\n fw.write(self.outliner(self.stylizer(t, t_style), t_outline_level, t_style).encode('utf-8'))\n\n # e.g. page breaks come as a node with no children whose style contains fo:break-before:\"page\"\n elif len(list(text.children)) == 0:\n fw.write(self.outliner(unicode(\"\"), t_outline_level, t_style).encode('utf-8'))\n\n # This covers the following case (e.g.):\n #\n # <text:p text:style-name=\"Textbody\">\n # jkjksk skjkjkjs dhh\n # <text:s />\n # <text:span text:style-name=\"T3\">Bold</text:span>\n # <text:s />\n # </text:p>\n #\n # else drill down one level\n else:\n buffer = unicode(\"\")\n t = buffer\n u = buffer\n t_outline_level = \"paragraph\"\n t_style = \"\"\n for i in text.children:\n # Get the attributes so the styles\n try:\n text_attrs = dict(i.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n # whenever the element has no style\n # take the parent's one\n try:\n text_attrs = dict(i.parent.attrs)\n t_style = text_attrs[\"text:style-name\"]\n except:\n t_style = \"nostyle\"\n\n # Get the outline-levels, if any\n try:\n t_outline_level = text_attrs[\"text:outline-level\"]\n except:\n t_outline_level = \"paragraph\"\n\n # if the current tag has only one child, and that child is a NavigableString\n if i.string:\n t = unicode(i.string)\n\n # space\n elif i.name == \"s\":\n t = unicode(\" \")\n\n # else drill down another level\n else:\n t = unicode(\"\")\n for j in i.children:\n if j.string:\n u = unicode(j.string)\n elif j.name == \"s\":\n u = unicode(\" \")\n else:\n u = unicode(\"\")\n if u:\n t = t + self.stylizer(u, t_style)\n\n # build up a unicode string containing the whole paragraph\n if t:\n buffer = buffer + self.stylizer(t, t_style)\n\n # outline the buffered unicode string and write it to the output file\n fw.write(self.outliner(buffer, t_outline_level, t_style).encode('utf-8'))\n\n fw.write(\"</body>\" + os.linesep)\n fw.write(\"</html>\" + os.linesep)\n fw.close()",
"def writexml(file):\n OUTFILE=open(file,\"w\")\n doc = xml.dom.minidom.Document()\n\n # Create the <dec_reg_list> base element\n decl_reg_list = doc.createElement(\"decl_reg_list\")\n doc.appendChild(decl_reg_list)\n\n regname_old=\"\"\n rows.pop(0)\n for row in rows:\n (regdesc,regname,offset,default,regtype,expose_reg,depth,incsz,bitdesc,bitname,loc,bittype)= row\n if regname != regname_old:\n # Create the register element\n register = doc.createElement(\"register\")\n register.setAttribute(\"name\", regname)\n register.setAttribute(\"offset\", offset)\n if default != \"\" : register.setAttribute(\"default\", default)\n register.setAttribute(\"type\", regtype)\n if expose_reg == \"1\": register.setAttribute(\"usr\", expose_reg)\n if depth != \"\": register.setAttribute(\"size\", depth)\n if incsz != \"\": register.setAttribute(\"incsz\", incsz)\n text = doc.createTextNode(regdesc)\n register.appendChild(text)\n decl_reg_list.appendChild(register)\n \n # Create the field element\n if bitname != \"\":\n field = doc.createElement(\"field\")\n field.setAttribute(\"name\", bitname)\n if loc !=\"\": field.setAttribute(\"loc\", addcolon(loc))\n if bittype != \"\": field.setAttribute(\"type\", bittype)\n if bitdesc != \"\":\n text = doc.createTextNode(bitdesc)\n field.appendChild(text)\n register.appendChild(field)\n regname_old = regname\n\n\n # Print our newly created XML\n #print doc.toprettyxml(indent=\" \")\n #OUTFILE.write(doc.saveXML(decl_reg_list))\n OUTFILE.write(doc.toprettyxml(indent=\" \"))\n OUTFILE.close()",
"def export_to_file(self, filename):\n if len(filename.split(\".\")) == 1:\n filename += \".xml\"\n xmlstring = self._dommodel.toprettyxml(\" \", \"\\n\")\n with open(filename, \"w\") as f:\n f.write(xmlstring)",
"def write(self, filename):\n \n return self.model.write(filename,xml_declaration=True, encoding='utf-8')",
"def save_as(self, fname, base = None, indent = '', topns = True, namespaces = {}):\n with codecs.open(fname, \"w\", encoding=\"utf-8\") as outf:\n self.serialize_xml(outf.write, base=base, indent=indent, topns=topns, namespaces=namespaces)",
"def write(self):\n return JavaMLWriter(self)",
"def CreateXMLTransformer() -> TransformerFunc:\n return partial(traverse, transformation_table=XML_AST_transformation_table.copy())",
"def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez",
"def toXMLElement(self):\n property_element = xml.etree.ElementTree.Element('property')\n property_element.set('concept', self.concept_ref)\n\n if self.is_parent:\n property_element.set('isParent', 'true')\n\n return property_element",
"def xmlwrite(self, doc, filename):\n pathname = os.path.join(self.session.session_dir, filename)\n f = open(pathname, \"w\")\n doc.writexml(writer=f, indent=\"\", addindent=\" \", newl=\"\\n\", encoding=\"UTF-8\")\n f.close()",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def makexmlfunc(healpix,ra,dec,week1,week2,distance):\n\t\n\tif week1!=week2:\n\t\tidentity=\"%06d_%d_%d_w%03d_w%03d\" %(healpix,ra,dec,week1,week2)\n\t\tltcube=\"%s/lat_ltcube_weekly_w%03d_w%03d_p203_v001.fits\" %(cfg.home,week1,week2)\n\t\tspacecraft=\"%s/w%03d_w%03d_newspacecraft.fits\" %(cfg.ispace,week1,week2)\n\telse:\n\t\tidentity=\"%06d_%d_%d_w%03d\" %(healpix,ra,dec,week1)\n\t\tltcube=\"%s/lat_spacecraft_weekly_w%03d_p203_v001_ltcube.fits\" %(cfg.home,week1)\n\t\tspacecraft=\"%s/lat_spacecraft_weekly_w%03d_p202_v001.fits \" %(cfg.ispace,week1)\n\n\tregion_filtered=\"%s_region_filtered_gti.fits\" %(identity)\n\tfermisources=\"%s_fermisources_model.xml\" %(identity)\n\tinputmodel=\"%s_input_model.xml\" %(identity)\n\tfermis=\"%s_fermis.xml\" %identity\n\tresponse=\"P7REP_SOURCE_V15\"\n\tmakexmllog=\"%s_output_makexml.log\" %identity\n\tglobal extendedsource\n\tglobal numberofextendedsources\n\textendedlog=\"%s_number_of_extendedsources.log\" %identity\n\tExtendedList=\"ExtendedList.txt\"\n\tOthersList=\"OthersList.txt\"\n\n\t\n\twith open (makexmllog,'r') as outputFile: #opens the makexmllog file from makesyfunc. This document contains info about the extended sources.\n\t\t\n\t\tfor line in outputFile:\n\t\t\t\n\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\tif line.startswith('Added')==True:\n\t\t\t\t\ta,b=line.split('and ')\t\n\t\t\t\t\tb1,b2,b3=b.split(' ')\n\t\t\t\t\n\t\t\t\t\tnumberofextendedsources=int(b1) #b1 is the number of extended sources\n\toutputFile.close()\n\toutputFile=open(inputmodel, 'w')\n\tprint numberofextendedsources\n\n\tif numberofextendedsources==1: #if there is an extended source\n\t\twith open (makexmllog,'r') as outputFile:\n\t\t\n\t\t\tfor line in outputFile:\n\t\t\t\n\t\t\t\twith open (makexmllog,'r') as File:\n\t\t\t\t\tif line.startswith('Extended')==True:\n\t\t\t\t\t\tprint line\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\tc,d=line.split(' in')\n\t\t\t\t\t\n\t\t\t\t\t\tc1,c2,c3,c4=c.split(' ')\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\textendedsource=str(c3) #extracts the name of the extended source from makexmllog\n\t\n\n\t\t\n\n\n\t\toutputFile.close()\t\n\n\n\t\n\n\t\twith open(\"%s\" %fermisources) as thefile: #opens the xml file that was created from makesyfunc\n\t\t\tfor line in thefile:\n\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==True:\n\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tspecial=str.replace(line,'%s.fits'%extendedsource,'%s/%s.fits' %(cfg.homesy,extendedsource)) \n\t\t\t\t\tprint special #replace with the correct path to the extendedsource(Templates folder)\n\t\t\t\n\t\t\t\t\tspecial1=str.replace(special,'type=\"SpatialMap\"','type=\"SpatialMap\" map_based_integral=\"true\"')\n\t\t\t\t\tprint special1 #instruction from fermi tutorial, you must add map_based...\n\t\t\t\t\toutputFile=open(fermis, 'w') #write to fermis, the original xml with the right path to the extended source\n\t\t\t\t\twith open(\"%s\" %fermisources,'r') as infile:\n\t\t\t\t\t\tfor line in infile:\n\t\t\t\t\t\t\tif line.startswith('\t<spatialModel file=\"%s.fits\"' %(extendedsource))==False:\n\t\t\t\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\toutputFile.write(special1)\n\t\t\t\t\toutputFile.close()\n\t\t\t\t\t\t\t\t\t\n\n\n\t\t\t\n\t\toutputFile=open(inputmodel, 'w') #final xml file. contains the right path and the source info of \"your\" source.\n\t\twith open(fermis,'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\t\t\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\t\t\t\n\n\t\toutputFile.close()\n\t\n\t\twith open(\"%s_diffrsp.log\" % (identity), 'w') as outsyputFile: #run diffrsp if you have an extended source.\n\t\t\tsubprocess.call(['%s' %(cfg.pythoncommand),'gtdiffrsp.py', '%s' %(region_filtered),'%s' %(spacecraft), '%s' %inputmodel, '%s' %(response),'%s' %identity ],stdout=outsyputFile)\n\t\t\t\n\t\twith open(ExtendedList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\t\t\t\t\n\tif numberofextendedsources==0: #if there is no extended source\n\t\toutputFile=open('%s' %(inputmodel), 'w') #write to inputmodel, \"your\" source\n\t\twith open('%s' %(fermisources),'r') as infile:\n\t\t\tfor line in infile:\n\t\t\t\tif line.startswith('</source_library>')==False:\n\t\t\t\t\toutputFile.write(line)\n\t\t\t\t\t\n\t\t\t\n\n\t\toutputFile.write('\\n\\\n\t\t\t<!-- My sources -->\\n\\\n\t\t\t<source name=\"%f_%f\" type=\"PointSource\">\\n\\\n\t\t\t<spectrum type=\"PowerLaw\">\\n\\\n\t\t\t<parameter free=\"1\" max=\"1000.0\" min=\"0.001\" name=\"Prefactor\" scale=\"1e-09\" value=\"10\"/>\\n\\\n\t\t\t<parameter free=\"1\" max=\"-1.0\" min=\"-5.0\" name=\"Index\" scale=\"1.0\" value=\"-2.1\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"2000.0\" min=\"30.0\" name=\"Scale\" scale=\"1.0\" value=\"100.0\"/>\\n\\\n\t\t\t</spectrum>\\n\\\n\t\t\t<spatialModel type=\"SkyDirFunction\">\\n\\\n\t\t\t<parameter free=\"0\" max=\"360\" min=\"-360\" name=\"RA\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t<parameter free=\"0\" max=\"90\" min=\"-90\" name=\"DEC\" scale=\"1.0\" value=\"%f\"/>\\n\\\n\t\t\t</spatialModel>\\n\\\n\t\t\t</source>\\n\\\n\t\t\t</source_library>\\n' % (ra,dec,ra,dec))\n\n\t\toutputFile.close()\n\tif numberofextendedsources>1:\n\t\twith open(OthersList,\"a+\") as outsyFile:\n\t\t\toutsyFile.write(\"%d %f %f %d %d %f\\n\" %(healpix,ra,dec,week1,week2,distance))\n\t\n\tif numberofextendedsources==1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\\n\\\n \t%s\"%(numberofextendedsources,extendedsource))\n\t\toutsyputFile.close()\n\n\tif numberofextendedsources !=1:\n\t\toutsyputFile=open(extendedlog,'w') #write the number of extended sources and name in a file\n\t\toutsyputFile.write(\"%s\" %(numberofextendedsources))\n\t\toutsyputFile.close()",
"def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml",
"def to_xml(self):\n xml_strings = ['<code_object name=\"%s\">' % self.name]\n xml_strings.append(' <type value=\"%s\" />' % self.object_type)\n xml_strings.append(' <source>')\n for source_line in self.source:\n xml_strings.append(source_line[1])\n xml_strings.append(' </source>')\n xml_strings.append('</code_object>')\n return \"\".join(xml_strings)",
"def _toFile(self):\n pass",
"def toGML(self):\n raise NotImplementedError",
"def addXSLTStyleSheet(self, content, URI):\n if self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] == None:\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"] = []\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)\n else:\n stylesArray = {'content':content, 'URI':URI}\n self.PDFreactorConfiguration.in1[\"XSLTStyleSheets\"].append(stylesArray)",
"def xml_path(self):\n return self.__xml_path",
"def generate_xml(self, provisioning):\n ET.SubElement(self.root, 'generator').text = __revision__\n ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n return self.provisioning2xml(provisioning)",
"def exportXml ( w, xml ):\n assert str ( type ( xml ) ) == \"<type 'str'>\"\n rawText = xml\n pattern = re.compile (r'[^\\S ]+')\n text = re.sub ( pattern, \"\", rawText )\n reparsed = MD.parseString ( text )\n w.write ( reparsed.toprettyxml ( indent = \"\\t\", encoding = \"UTF-8\" ) )",
"def toSBML(self):\n errors = self.document.checkConsistency()\n if errors > 0:\n for i in range(errors):\n print(\n self.document.getError(i).getSeverityAsString(),\n \": \",\n self.document.getError(i).getMessage(),\n )\n\n return libsbml.writeSBMLToString(self.document)"
] | [
"0.6366979",
"0.61544836",
"0.5839131",
"0.58340883",
"0.5812942",
"0.5640789",
"0.5632317",
"0.55815554",
"0.55431604",
"0.55276537",
"0.55154866",
"0.5513102",
"0.5510308",
"0.5458654",
"0.5451725",
"0.54285127",
"0.54037434",
"0.5307067",
"0.5298246",
"0.52886873",
"0.5272622",
"0.5271472",
"0.5232884",
"0.5201279",
"0.519453",
"0.5182671",
"0.5179153",
"0.5172932",
"0.5163209",
"0.5156673",
"0.5148088",
"0.51359093",
"0.5132218",
"0.51303387",
"0.5100232",
"0.50764483",
"0.5070601",
"0.5059149",
"0.50582504",
"0.5056313",
"0.5056309",
"0.5039356",
"0.5028861",
"0.5021943",
"0.5010669",
"0.50036734",
"0.5003039",
"0.49999213",
"0.49748772",
"0.49723393",
"0.49578944",
"0.49532372",
"0.49395603",
"0.4939085",
"0.48923746",
"0.48899695",
"0.48740843",
"0.48715433",
"0.48646557",
"0.48638257",
"0.4852056",
"0.4846309",
"0.48436296",
"0.48433435",
"0.48293883",
"0.4826439",
"0.48262388",
"0.4825601",
"0.48202866",
"0.48137426",
"0.48124427",
"0.4811109",
"0.48028645",
"0.48027924",
"0.47998756",
"0.4795888",
"0.4795888",
"0.47758362",
"0.4772382",
"0.4770035",
"0.4762882",
"0.47570086",
"0.47569758",
"0.4756163",
"0.4751184",
"0.4751131",
"0.47475907",
"0.4746994",
"0.47402462",
"0.47337463",
"0.47337046",
"0.47332537",
"0.47212258",
"0.4720437",
"0.47086617",
"0.47031793",
"0.4701611",
"0.46895015",
"0.46818498",
"0.46814537"
] | 0.5603479 | 7 |
Return XSL file test for data existance | def xslTestText(self):
return u'normalize-space(child::*/%s)' % self.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self):\n try:\n f = StringIO.StringIO(self.content)\n dom = XTree.parse(f)\n xslt = XTree.parse(self.stylesheet)\n transform = XTree.XSLT(xslt)\n newdom = transform(dom)\n except IOError:\n print \"Xml or Xsl file not found!\"\n return False\n return XTree.tostring(newdom, pretty_print=True)",
"def test_01_FindXml(self):",
"def test_input_output(self, filename):\n with open(sample_xml(filename), \"rb\") as xml_file:\n xml_output_expected = xml_file.read()\n root, doctype_dict = xmlio.parse(sample_xml(filename), return_doctype_dict=True)\n self.assertEqual(xmlio.output(root, None, doctype_dict), xml_output_expected)",
"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 test_check_if_output_file_exists():\n input_file = os.path.join(os.getcwd(), 'tests', 'input_test_file.docx')\n output_file = os.path.join(os.getcwd(), 'tests', 'output_test_file.txt')\n\n questions_parser = QuestionsParser()\n questions_parser.main(argv=['-i', input_file, '-o', output_file])\n assert os.path.exists(output_file)\n os.unlink(output_file)",
"def test_hasLocation(self):\n cases = [\n (self.test_eac + \"NE00601.xml\", False),\n (self.test_eac + \"NE00100.xml\", True),\n (self.test_eac + \"NE00201.xml\", True),\n (self.test_eac + \"NE01302.xml\", True),\n (self.test_eac + \"NE01101.xml\", False),\n (self.test_eac + \"NE00916.xml\", False),\n (self.test_eac + \"NE00201.xml\", True),\n ]\n for case in cases:\n source, expected = case\n doc = EacCpf.EacCpf(source,'http://www.example.com')\n self.assertNotEqual(doc, None)\n result = doc.hasLocation()\n self.assertNotEqual(result, None)\n self.assertEqual(result, expected)",
"def test_xml_files_with_missing_info():\n\n # Test when k is missing from constant type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/k_const.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when A is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/A_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when b is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/b_mod_arr.xml\"\n parser = XMLParser(xml_filename)\n\n # Test when E is missing from modified Arrhenius type reaction\n with pytest.raises(ValueError):\n xml_filename = \"tests/test_xml_files/E_mod_arr.xml\"\n parser = XMLParser(xml_filename)",
"def test_does_validate_valid_xml_file(self):\n xml_file = join(\n getcwd(), 'testdata', 'newstest2019-defr-src-ts.de.FIXED.xml'\n )\n doc = valitest.ValidatableTestSet(xml_file)\n self.assertEqual(doc.setid, \"newstest2019\")\n self.assertEqual(doc.srclang, \"any\")",
"def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)",
"def testFilesExist(self):\n \n for year in range(2007,2013):\n self.assertTrue(os.path.exists(\"./IncomeHistogram_\"+ str(year)+\".pdf\"), \"A histogram didn't save to output.\")\n self.assertTrue(os.path.exists(\"./LogIncomeHistogram_\"+ str(year)+\".pdf\"), \"A histogram didn't save to output.\")\n self.assertTrue(os.path.exists(\"./IncomeBoxplot(log)_\"+ str(year)+\".pdf\"), \"A boxplot didn't save to output.\") \n self.assertTrue(os.path.exists(\"./results.txt\"), \"Results file doesn't exist.\")",
"def test_defaultFile(self):\n found = cesmEnvLib.checkFile(\"./test_checkXMLvar.py\", \"read\")\n self.assertTrue(found)",
"def test_xml_file(self):\n response = client.result(False, 'xml', 'unittest', file = 'test_file.csv')\n root = ET.fromstring(response)\n first_name = root[0][0][0].text\n self.assertEqual(first_name,'John', 'Should print John')\n nationality = '<nationality>' in response\n self.assertFalse(nationality, 'Nationality should not be present')",
"def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n # sprint(PrettyFormatAny.form(self.m_root_xml, 'A3-01-A - Entire Xml'))\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n # print(PrettyFormatAny.form(self.m_xml.controller_sect, 'A3-01-B - All Controllers Xml'))\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')\n # print(PrettyFormatAny.form(self.m_xml.controller, 'A3-01-C - First Controller Xml'))",
"def check_for_data():\n if not (os.path.exists(ep.get_test_data_path()) or os.path.exists(ep.get_dbn_weight_path())):\n return False\n return True",
"def test_case18(self):\n\n result = self.graph1.studentExists(\"student1\")\n\n self.assertTrue(result)",
"def test_getExistDates(self):\n cases = [\n (self.test_eac + \"NE01201.xml\",\"1858-01-01T00:00:00Z\",\"1935-08-21T00:00:00Z\"),\n (self.test_eac + \"NE00300.xml\",\"1960-01-01T00:00:00Z\",\"1977-12-31T00:00:00Z\"),\n (self.test_eac + \"NE01500.xml\",\"1981-01-01T00:00:00Z\",\"1981-12-31T00:00:00Z\")\n ]\n for case in cases:\n source, expected_from_date, expected_to_date = case\n doc = EacCpf.EacCpf(source, 'http://www.example.com')\n self.assertNotEqual(doc, None)\n fromDate, toDate = doc.getExistDates()\n self.assertEqual(fromDate, expected_from_date)\n self.assertEqual(toDate, expected_to_date)",
"def test_case17(self):\n\n result = self.graph1.studentExists(\"student5\")\n\n self.assertFalse(result)",
"def _check_deprecated_data_xml_node(self):\n xml_files = self.filter_files_ext('xml')\n self.msg_args = []\n for xml_file in xml_files:\n doc = self.parse_xml(os.path.join(self.module_path, xml_file))\n odoo_nodes = doc.xpath(\"/odoo\") \\\n if not isinstance(doc, string_types) else []\n children, data_node = ((odoo_nodes[0].getchildren(),\n odoo_nodes[0].findall('data'))\n if odoo_nodes else ([], []))\n if len(children) == 1 and len(data_node) == 1:\n lineno = odoo_nodes[0].sourceline\n self.msg_args.append((\"%s:%s\" % (xml_file, lineno)))\n if self.msg_args:\n return False\n return True",
"def test_getData(self):\n cases = [\n self.test_eac + 'NE01201.xml',\n self.test_eac + 'NE00201.xml',\n self.test_eac + 'NE00300.xml',\n self.test_eac + 'NE00500.xml',\n ]\n for case in cases:\n doc = EacCpf.EacCpf(case, 'http://www.example.com/metadata.xml', 'http://www.example.com/presentation.html')\n self.assertNotEqual(doc, None)\n result = doc.getData()\n self.assertNotEqual(result, None)\n self.assertGreater(len(result), 0)",
"def _CheckFileExistsWithData(self, logs, graph):\n self.assertTrue(graph in logs, 'File %s was not output.' % graph)\n self.assertTrue(logs[graph], 'File %s did not contain data.' % graph)",
"def checkAllFilesGenerated(self):\n root = get_exhale_root(self)\n containmentFolder = self.getAbsContainmentFolder()\n for node in root.all_nodes:\n if node.kind in [\"enumvalue\", \"group\"]:\n continue\n gen_file_path = os.path.join(containmentFolder, node.file_name)\n self.assertTrue(\n os.path.isfile(gen_file_path),\n \"File for {kind} node with refid=[{refid}] not generated to [{gen_file_path}]!\".format(\n kind=node.kind, refid=node.refid, gen_file_path=gen_file_path\n )\n )",
"def test_assemble_xml_file_A1(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write_blank(\"A1\", None)\n\n worksheet.write_blank(\"C2\", None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def resultExist(probName,algoName,fitName,inst,s,c,n,k,q,w,m,t,e):\n if probName == 'NKQ':\n nameOfF = './result/'+probName+'-'+algoName+'-F'+fitName+'-M'+m+'-I'+str(inst)+'-S'+str(s)+'-W'+str(w)+'-N'+str(n)+'-K'+str(k)+'-C'+str(c)+'-Q'+str(q)+'-T'+str(t)+'-E'+str(e)+'.txt'\n elif probName == 'NK' or probName == 'NonNK':\n nameOfF = './result/'+probName+'-'+algoName+'-F'+fitName+'-C'+str(c)+'-I'+str(inst)+'-S'+str(s)+'-W'+str(w)+'-N'+str(n)+'-K'+str(k)+'-E'+str(e)+'.txt'\n\n if os.path.isfile(nameOfF)==True:\n print nameOfF, 'exists!!!'\n return os.path.isfile(nameOfF)",
"def test_exists_false(self):\n self.assertFalse(Sample.exists('Not_a_Sample', self.sample_template))",
"def test_non_regression(self):\n main(\"Source_mobile.xml\", [[\"engine\", \"A320.xml\", \"A320.csv\"]], \"Resultat.xml\", gui=False)\n compare_xml_results(\"Resultat.xml\", \"Reference.xml\", self)",
"def main():\n\n parser = argparse.ArgumentParser(description='NetXML to XSLX')\n parser.add_argument(\n 'input', nargs='+',\n help='One or more netxml files, space separated.'\n )\n parser.add_argument(\n '-o', '--output', metavar='output', default='netxml.xlsx',\n help='Output file path. Defaults to \"./netxml.xslx\" if left blank.'\n )\n parser.add_argument(\n '-d', '--dir', action='store_true', default=False,\n help=(\n 'Use when supplying a directory of netxml files instead of direct '\n 'file references.'\n )\n )\n args = parser.parse_args()\n\n out_path = Path(args.output).resolve()\n if out_path.is_file():\n print(f'{out_path} already exists. Quitting...')\n return\n\n input_paths = []\n for i in args.input:\n try:\n input_path = Path(i).resolve()\n except Exception as e:\n print(\n f'Could not resolve the file path for {i}. It will be skipped'\n )\n if args.dir and input_path.is_dir():\n netxml_glob = input_path.glob('*.netxml')\n for path in netxml_glob:\n input_paths.append(path)\n elif not input_path.is_file():\n thing = 'directory' if args.dir else 'file'\n print(f'{i} is not a {thing}. Skipping...')\n continue\n else:\n input_paths.append(input_path)\n # Create the in-memory Excel Workbook\n wb = Workbook()\n networks_sheet = wb.active\n networks_sheet.title = 'Wireless Networks'\n # Add the title row for the networks WorkSheet\n networks_sheet.append(\n [\n 'BSSID', 'ESSID', 'Hidden', 'Channel', 'Signal Strength', 'Open',\n 'WEP', 'WPA', 'WPA2', 'WPS', 'Auth', 'TKIP', 'AES', 'Manufacturer',\n 'No. Clients', 'Latitude', 'Longitude'\n ]\n )\n clients_sheet = wb.create_sheet(title='Clients')\n # Add the title row for the clients WorkSheet\n clients_sheet.append(\n ['MAC', 'Manufacturer', 'Signal Strength', 'BSSID', 'ESSID']\n )\n networks_list = []\n clients_list = []\n for input_path in input_paths:\n _parse_netxml(input_path, networks_list, clients_list)\n # Ensure no duplicates end up in the spreadsheets.\n unique_networks = set(networks_list)\n unique_clients = set(clients_list)\n\n # Add the results of all files to the spreadsheets\n for row in unique_networks:\n networks_sheet.append(row)\n\n # Add total row\n for row in unique_clients:\n clients_sheet.append(row)\n # Turn the resulting tables in to Excel \"Tables\"\n _create_table(networks_sheet, 'Networks')\n _create_table(clients_sheet, 'Clients')\n # Create totals WorkSheet\n totals_sheet = wb.create_sheet(title='Totals')\n _populate_totals(totals_sheet, networks_sheet)\n _create_table(totals_sheet, 'Totals')\n\n wb.save(str(out_path))",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'parameter_estimation':\n check = True\n self.assertTrue(check)",
"def test_ifFileExists():\n for name in config.toTest:\n testConfig = dynamicallyLoadModule(name)\n if \"file\" in testConfig.config and \"file_locations\" in testConfig.config:\n print \"File In Location: \"+ testConfig.config[\"name\"]\n yield assertionFunctions.checkIfFileExistsInPossibleLocations, testConfig.config\n elif \"file\" in testConfig.config:\n print \"File: \"+ testConfig.config[\"name\"]\n yield assertionFunctions.checkIfFileExists, testConfig.config",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'Time-Course':\n check = True\n self.assertTrue(check)",
"def test_exists_false(self):\n self.assertFalse(PrepSample.exists('Not_a_Sample', self.prep_template))",
"def test_exists_true(self):\n self.assertTrue(SampleTemplate.exists(self.test_study.id))",
"def test_exists_false(self):\n self.assertFalse(SampleTemplate.exists(self.new_study.id))",
"def test_xml_exist(xml_parser):\n\n assert xml_parser.get_dict()",
"def are_evaluations_created(path, number_of_evaluations):\n evaluation_ids = []\n try:\n with open(\"%s%sevaluations\" % (path, os.sep)) as evaluations_file:\n for line in evaluations_file:\n evaluation = line.strip()\n try:\n evaluation_id = bigml.api.get_evaluation_id(evaluation)\n evaluation_ids.append(evaluation_id)\n except ValueError:\n return False, evaluation_ids\n if len(evaluation_ids) == number_of_evaluations:\n return True, evaluation_ids\n else:\n return False, evaluation_ids\n except IOError:\n return False, evaluation_ids",
"def validate(file_in) :\n\tname = str(file_in.name)\n\tif name[-4:] != \".xml\" and name[-4:] != \".XML\" :\n\t\treturn False\n\txsd = open('wcdb/WorldCrises.xsd.xml', 'r')\n\txmlFile = open('wcdb/temp.xml', 'w')\n\txmlFile.write(file_in.read())\n\txmlFile = open('wcdb/temp.xml', 'r')\n\ttry:\n\t\tpsvi = pyxsval.parseAndValidate(\"wcdb/temp.xml\",\n\t\t\t\"wcdb/WorldCrises.xsd.xml\", xmlIfClass=pyxsval.XMLIF_ELEMENTTREE)\n\t\ttree = psvi.getTree()\n\texcept pyxsval.XsvalError, e:\n\t\treturn 'Validation aborted. ' + str(e)\n\texcept GenXmlIfError, e:\n\t\treturn 'Parsing aborted. ' + str(e)\n\texcept Exception as e:\n\t\t# catch all\n\t\treturn 'Exception. ' + str(e)\n\t#handle invalid case\n\treturn tree",
"def xslText(self):\n return u'<xsl:if test=\"normalize-space(./%s)\">%s'\\\n '<xsl:value-of select=\"./%s\"/>%s</xsl:if>' % \\\n (self.name, xslEscape(self.prefix), self.name,\n xslEscape(self.suffix))",
"def test_assemble_xml_file_write(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write(0, 0, None)\n\n worksheet.write(1, 2, None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def example_xml_file43():\n return load_xml('datacite-v4.3-full-example.xml')",
"def _get_eps_xml(self):\n format_path = os.path.join(os.path.dirname(__file__), \"formats\")\n\n # loop through files where filename starts with \"eps_ascat\".\n for filename in fnmatch.filter(os.listdir(format_path), \"eps_ascat*\"):\n doc = etree.parse(os.path.join(format_path, filename))\n file_extension = doc.xpath(\"//file-extensions\")[0].getchildren()[0]\n\n format_version = doc.xpath(\"//format-version\")\n for elem in format_version:\n major = elem.getchildren()[0]\n minor = elem.getchildren()[1]\n\n # return the xml file matching the metadata of the datafile.\n if major.text == self.mphr[\"FORMAT_MAJOR_VERSION\"] and \\\n minor.text == self.mphr[\"FORMAT_MINOR_VERSION\"] and \\\n self.mphr[\n \"PROCESSING_LEVEL\"] in file_extension.text and \\\n self.mphr[\"PRODUCT_TYPE\"] in file_extension.text:\n return os.path.join(format_path, filename)",
"def _check_file_exists_helper(self, report_path, filename):\n\n if not check_data_exists(report_path, [filename]):\n raise AssertionError(\n \"{} does not exist in location {}\".format(\n filename, report_path\n )\n )",
"def _check_xml_syntax_error(self):\n self.msg_args = []\n for xml_file in self.filter_files_ext('xml', relpath=True):\n result = self.parse_xml(os.path.join(self.module_path, xml_file))\n if isinstance(result, string_types):\n self.msg_args.append((\n xml_file, result.strip('\\n').replace('\\n', '|')))\n if self.msg_args:\n return False\n return True",
"def verified_excel_file(store, institute_list, temp_excel_dir):\n document_lines = []\n written_files = 0\n today = datetime.datetime.now().strftime('%Y-%m-%d')\n LOG.info('Creating verified variant document..')\n\n for cust in institute_list:\n verif_vars = store.verified(institute_id=cust)\n LOG.info('Found {} verified variants for customer {}'.format(len(verif_vars), cust))\n\n if not verif_vars:\n continue\n unique_callers = set()\n for var_type, var_callers in CALLERS.items():\n for caller in var_callers:\n unique_callers.add(caller.get('id'))\n cust_verified = export_verified_variants(verif_vars, unique_callers)\n\n document_name = '.'.join([cust, '_verified_variants', today]) + '.xlsx'\n workbook = Workbook(os.path.join(temp_excel_dir,document_name))\n Report_Sheet = workbook.add_worksheet()\n\n # Write the column header\n row = 0\n for col,field in enumerate(VERIFIED_VARIANTS_HEADER + list(unique_callers)):\n Report_Sheet.write(row,col,field)\n\n # Write variant lines, after header (start at line 1)\n for row, line in enumerate(cust_verified,1): # each line becomes a row in the document\n for col, field in enumerate(line): # each field in line becomes a cell\n Report_Sheet.write(row,col,field)\n workbook.close()\n\n if os.path.exists(os.path.join(temp_excel_dir,document_name)):\n written_files += 1\n\n return written_files",
"def datafileexist(filename):\n filePath = os.path.join(pathtofolder(), \"datas\", filename)\n fileFormat = '.csv'\n return os.path.exists(f'{filePath+fileFormat}')",
"def _valid_rootnode_file(self, xml_filepath: str) -> bool:\n\t\troot_name: str = get_xml_file(xml_filepath).tag\n\t\t# Iterate over RootNodes\n\t\tfor rootnode in self.root_nodes:\n\t\t\t# Check is filenames are identical\n\t\t\tif root_name == rootnode.name:\n\t\t\t\trootnode.subfiles.add(xml_filepath)\n\t\t\t\t# Return False, match is found\n\t\t\t\treturn False\n\n\t\t# Return True if no match found.\n\t\treturn True",
"def test_get_workflow_definition_xml(self):\n pass",
"def test_01_FindXml(self):\n self.assertEqual(self.m_xml.root.tag, TESTING_PYHOUSE)\n self.assertEqual(self.m_xml.controller_sect.tag, 'ControllerSection', 'XML - No Controllers section')\n self.assertEqual(self.m_xml.controller.tag, 'Controller', 'XML - No Controller section')",
"def test_validate_invalid(self):\r\n self.assertEqual(get_tree_and_validate(self.invalid_xml, open(self.SCHEMA, 'r').read()), 0)",
"def test_schema_exists(self):\n return exclusions.open()",
"def example_xml_file41():\n return load_xml('datacite-v4.1-full-example.xml')",
"def test_generate_report():\n # Calling helper function to create data\n data = helper_create_data()\n cat_vars = ['C1', 'C2', 'C3', 'C4']\n num_vars = ['N1', 'N2', 'N3']\n\n # Positive test case: Checking whether the function runs properly or not\n assert eda.generate_report(data, cat_vars, num_vars), \\\n \"Expected True but False returned\"\n\n # Negative test case: Checking whether the function returns False\n # fr wrong output\n assert not eda.generate_report(data, cat_vars, \"String Input\"), \\\n \"Expected False but True returned\"",
"def test_report_definition(self):\n self.model = self.scan.model\n self.model.save()\n new_model = pycotools3.tasks.CopasiMLParser(self.copasi_file).xml\n reports = new_model.find('{http://www.copasi.org/static/schema}ListOfReports')\n check = False\n for report in reports:\n if report.attrib['name'] == 'profile_likelihood':\n check = True\n self.assertTrue(check)",
"def test_xml_direct(self): \n response = client.result(True, 'xml', 'unittest', test_data = self.test_data)\n root = ET.fromstring(response)\n first_name = root[0][0][0].text\n self.assertEqual(first_name,'John', 'Should print John')\n nationality = '<nationality>' in response\n self.assertFalse(nationality, 'Nationality should not be present')",
"def check_xshear_output(self):\n lens_nchunk=self['lens_conf']['nchunk']\n tilenames=scat.get_tilenames(self['source_conf']['scat_table'])\n\n ntile=len(tilenames)\n for lens_chunk in xrange(lens_nchunk):\n print(\" checking chunk: %d/%d\" % (lens_chunk+1, lens_nchunk))\n for i,tilename in enumerate(tilenames):\n # first check if this source catalog exists\n if self._scat_exists(tilename):\n job=XShearWQJob(self['run'],\n lens_chunk,\n tilename)\n info=job.get_info()\n if not os.path.exists(info['output_file']):\n print(\"missing output:\",info['output_file'])",
"def test_assemble_xml_file(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n worksheet.str_table = SharedStringTable()\n worksheet.select()\n cell_format1 = Format({\"xf_index\": 1})\n cell_format2 = Format({\"xf_index\": 2})\n\n worksheet.merge_range(\"B3:C3\", \"Foo\", cell_format1)\n worksheet.merge_range(\"A2:D2\", \"\", cell_format2)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"A2:D3\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"1:4\">\n <c r=\"A2\" s=\"2\"/>\n <c r=\"B2\" s=\"2\"/>\n <c r=\"C2\" s=\"2\"/>\n <c r=\"D2\" s=\"2\"/>\n </row>\n <row r=\"3\" spans=\"1:4\">\n <c r=\"B3\" s=\"1\" t=\"s\">\n <v>0</v>\n </c>\n <c r=\"C3\" s=\"1\"/>\n </row>\n </sheetData>\n <mergeCells count=\"2\">\n <mergeCell ref=\"B3:C3\"/>\n <mergeCell ref=\"A2:D2\"/>\n </mergeCells>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)",
"def xslTestText(self):\n return u'normalize-space(ancestor::*/%s)' % self.name",
"def test_exist(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n MetadataTemplate.exists(self.study)",
"def missing_results(self):\n self.calc_progress()\n\n def no_result_exists(x):\n return not os.path.isfile(\n os.path.join(self.location, \"results\", RSLT_NM.format(x))\n )\n\n return tuple(filter(no_result_exists, range(1, self.num_batches + 1)))",
"def ruleset_create_success_hr():\n with open(\n os.path.join(TEST_DATA_DIRECTORY, \"create_ruleset_success_hr.md\")\n ) as file:\n f = file.read()\n return f",
"def test_validation_no_schema(self):\n TT = TEITransformer(scenario='drama')\n tei_path = \"tests/test_user_schema/tei.xml\"\n TT.load_tei(tei_path)\n with self.assertRaises(ValueError):\n TT.transform(output_format=\"html\")",
"def example_xml_file42():\n return load_xml('datacite-v4.2-full-example.xml')",
"def validate_file(self):\n print \"\\n******\"\n print \" Done creating file. Validation messages follow.\"\n missing_nodes = {'group': [], 'dataset': []}\n custom_nodes = {'group': [], 'dataset': []}\n for ns in self.id_lookups:\n for id in self.id_lookups[ns]:\n for path in self.id_lookups[ns][id]:\n qty = self.id_lookups[ns][id][path]['qty']\n type = self.id_lookups[ns][id][path]['type']\n count = len(self.id_lookups[ns][id][path]['created'])\n if qty in ('!', '+') and count == 0:\n missing_nodes[type].append(\"%s:%s/%s\" % (ns, path, id))\n for path, node_list in self.all_nodes.iteritems():\n for root_node in node_list:\n self.validate_nodes(root_node, missing_nodes, custom_nodes)\n self.report_problems(missing_nodes, \"missing\")\n self.report_problems(custom_nodes, \"custom\")\n if self.custom_attributes:\n count = len(self.custom_attributes)\n print \"%i nodes with custom attributes\" % len(self.custom_attributes)\n if count > 20:\n print \"Only first 20 shown;\"\n names = self.custom_attributes.keys()[0:min(20, count)]\n nlist = []\n for name in names:\n nlist.append(name+ \"->\" +str(self.custom_attributes[name]))\n print nlist\n else:\n print \"No custom attributes. Good.\"",
"def generate_expected_file(self, expected_file, xml_name):\n\t\tlogging.info('Gerando arquivo de documentos esperados')\n\t\tcontent = self.read_xml(xml_name)\n\n\t\twith open(expected_file, 'w', newline='') as csvfile:\n\t\t\tfieldnames = ['QueryNumber', 'DocNumber', 'DocVotes']\n\t\t\twriter = csv.DictWriter(csvfile, fieldnames=fieldnames)\n\n\t\t\twriter.writeheader()\n\t\t\tfor index in range(0, len(content['QueryNumber'])):\n\t\t\t\tcount_results = 0\n\t\t\t\tlogging.info('Escrevendo documentos da consulta '+str(index+1)+'/'+str(len(content['QueryNumber'])))\n\t\t\t\tfor result in content['Records'][index]:\n\t\t\t\t\twriter.writerow({'QueryNumber': content['QueryNumber'][index], 'DocNumber': result[0], \n\t\t\t\t\t\t\t\t\t 'DocVotes': result[1]})\n\t\t\t\t\tcount_results += 1\n\t\t\t\t\tif count_results == int(content['Results'][index]): break",
"def example_xml_file():\n return load_xml('datacite-v3.1-full-example.xml')",
"def test_predicate1(self):\n xpb = XPathBuilder()\n xp = xpb.action.source[xpb.attr('project') == 'bar']\n exp = '/action/source[@project = \"bar\"]'\n self.assertEqual(xp.tostring(), exp)",
"def test_xml_safety_flag(self):\r\n\r\n self._setstaff_login()\r\n response = self._add_edx4edx()\r\n self.assertIn('GIT_IMPORT_WITH_XMLMODULESTORE', response.content)\r\n\r\n def_ms = modulestore()\r\n course = def_ms.courses.get('{0}/edx4edx_lite'.format(\r\n os.path.abspath(settings.DATA_DIR)), None)\r\n self.assertIsNone(course)",
"def test_incomplete_xml(self):\n self.__opener.contents = '<Report></Report>>'\n self.assertEqual(-1, self.__uft.failed_tests('url'))",
"def check_data():\n check_docs(\"Training\")\n check_docs(\"dev\")\n check_docs(\"Test\")",
"def is_good_enough_xml(self, resp):\n content_type = resp.headers['Content-Type'].lower()\n \n return (resp.status_code == 200 \n and content_type is not None \n and content_type.find('xml') > -1)",
"def test_XmlDump_compare_single(self):\n self._compare_variants(False)",
"def sniff( self, filename ):\n\n f = open( filename, \"r\" )\n firstlines = \"\".join( f.readlines(5) )\n f.close()\n\n if \"phyloxml\" in firstlines:\n return True\n return False",
"def _run_test_and_get_xml(self, flag):\n\n xml_fhandle, xml_fname = tempfile.mkstemp()\n os.close(xml_fhandle)\n\n try:\n binary = self._get_helper()\n args = [binary, flag, '--xml_output_file=%s' % xml_fname]\n ret = subprocess.call(args)\n self.assertEqual(ret, 0)\n\n xml = ElementTree.parse(xml_fname).getroot()\n finally:\n os.remove(xml_fname)\n\n return xml",
"def load_data_from_xsl(file_name):\n\tnlp_data = pd.read_excel(file_name, sheet_name=0, header=0, usecols=[1, 2, 3],\n\t converters={'bug_id': str, 'summary': str, 'description': str})\n\tnlp_data.fillna(' ', inplace=True)\n\n\t# nlp_data['description'] = nlp_data['description'].map(lambda x: clean_str(x+''))\n\n\treturn nlp_data",
"def test_predicate2(self):\n xpb = XPathBuilder()\n xp = xpb.action.source.where(xpb.attr('project').equals('bar'))\n exp = '/action/source[@project = \"bar\"]'\n self.assertEqual(xp.tostring(), exp)",
"def verifyFileExists(self, fileDir, fileName):\n # check that file exists\n fpath = fileDir.child(fileName)\n self.assertTrue(fpath.exists())\n\n # check that the output files have some content\n fcontents = fpath.getContent()\n self.assertTrue(len(fcontents) > 0)\n\n # check that the html files are at least html-ish\n # this is not a terribly rigorous check\n if fpath.path.endswith(\".html\"):\n self.assertIn(b\"<body\", fcontents)",
"def evaluate(self, xml_gold_path, xml_output_path):\n\n # Go through all files in xml_gold_path directory\n for file in os.listdir(xml_gold_path):\n\n # Set path to file\n file = xml_gold_path+file\n\n # Open files only, ignore subdirectories\n if os.path.isfile(file) and file.lower().endswith('.xml'):\n\n # Open xml files\n chapter_input_gold = open(file, 'r', encoding='utf8')\n chapter_input_test = open(xml_output_path+os.path.split(file)[-1], 'r', encoding='utf8')\n\n # Check if filenams are the same\n chapter_input_gold_name = os.path.split(chapter_input_gold.name)[-1]\n chapter_input_test_name = os.path.split(chapter_input_test.name)[-1]\n\n if chapter_input_gold_name == chapter_input_test_name:\n\n # Console log\n chapter_input_gold_name = chapter_input_gold.name\n chapter_input_test_name = chapter_input_test.name\n #print('Calculating score for: ' + chapter_input_gold_name + ' and: ' + chapter_input_test_name)\n\n # Process xml input file with BeautifulSoup\n chapter_input_gold = BeautifulSoup(chapter_input_gold, 'xml')\n chapter_input_test = BeautifulSoup(chapter_input_test, 'xml')\n\n # Empty variables for collecting Target scores\n target_precision_scores = 0\n target_recall_scores = 0\n target_f1_scores = 0\n target_jaccard_scores = 0\n\n # Empty variables for collecting Focus scores\n focus_precision_scores = 0\n focus_recall_scores = 0\n focus_f1_scores = 0\n focus_jaccard_scores = 0\n\n # Empty variables for collecting Negated scores\n negated_precision_scores = 0\n negated_recall_scores = 0\n negated_f1_scores = 0\n negated_jaccard_scores = 0\n\n # Empty variables for collecting Scope scores\n scope_precision_scores = 0\n scope_recall_scores = 0\n scope_f1_scores = 0\n scope_jaccard_scores = 0\n\n # Count sentences and frames\n sentence_count = 0\n gold_frames_count = 0\n test_frames_count = 0\n\n scope_gold_frames_count = 0\n #scope_test_frames_count = 0\n\n # Find all Gold and Test Sentences\n sentences_gold = chapter_input_gold.find_all('s')\n sentences_test = chapter_input_test.find_all('s')\n\n #targets_gold = chapter_input_gold.find_all('target')\n #targets_test = chapter_input_test.find_all('target')\n\n scope_gold_frames = chapter_input_gold.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_frames_count = len(scope_gold_frames)\n\n scope_test_frames = chapter_input_test.find_all('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_frames_count = len(scope_test_frames)\n\n # Exit if number of sentences != between Gold and Test files\n if len(sentences_gold) != len(sentences_test):\n raise SystemExit(print('Number of sentences between Gold and Test files does not match.\\nGold:',\n len(sentences_gold), 'Test:', len(sentences_test)))\n\n # Zip Gold and Test Sentences\n for s_gold, s_test in zip(sentences_gold, sentences_test):\n\n sentence_count = sentence_count + 1\n\n gold_frames = s_gold.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n test_frames = s_test.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n\n gold_frames_count = gold_frames_count + len(gold_frames)\n test_frames_count = test_frames_count + len(test_frames)\n\n for item in zip(gold_frames, test_frames):\n\n #print('\\n=========')\n #print('\\nFrame:', item[0].get('id'))\n\n target_gold_list = []\n target_test_list = []\n\n focus_gold_list = []\n focus_test_list = []\n\n negated_gold_list = []\n negated_test_list = []\n\n scope_gold_list = []\n scope_test_list = []\n\n # Flatten a nested list of fenodes\n def flatten(nested_list):\n \"\"\" Flatten a nested list of fenodes \"\"\"\n t_l = []\n for i in nested_list:\n if not isinstance(i, list):\n t_l.append(i)\n else:\n t_l.extend(flatten(i))\n return t_l\n\n # Target\n if item[0].find('target'):\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n\n try:\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n except:\n target_test_word = ''\n\n elif item[1].find('target'):\n target_test = item[1].find('target')\n target_test_fenode__id = target_test.find('fenode').get('idref')\n target_test_word = s_test.find(id=target_test_fenode__id).get('word').lower()\n\n try:\n target_gold = item[0].find('target')\n target_gold_fenode_id = target_gold.find('fenode').get('idref')\n target_gold_word = s_gold.find(id=target_gold_fenode_id).get('word').lower()\n except:\n target_gold_word = ''\n\n target_gold_list.append(target_gold_word)\n target_test_list.append(target_test_word)\n\n # Sort lists\n sorted_target_gold_list = sorted(flatten(target_gold_list))\n sorted_target_test_list = sorted(flatten(target_test_list))\n\n #print('\\nTarget [Gold]:', sorted_target_gold_list)\n #print('Target [Test]:', sorted_target_test_list)\n\n\n # Focus\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except:\n focus_gold_word = ''\n if item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n else:\n focus_test_word = ''\n\n elif item[1].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_test = item[1].find('fe', {'name' : FOCUS_TAG_NAME})\n try:\n focus_test_fenode_id = focus_test.find('fenode').get('idref')\n focus_test_word = s_test.find(id=focus_test_fenode_id).get('word').lower()\n except:\n focus_test_word = ''\n if item[0].find('fe', {'name' : FOCUS_TAG_NAME}):\n focus_gold = item[0].find('fe', {'name' : FOCUS_TAG_NAME})\n focus_gold_fenode_id = focus_gold.find('fenode').get('idref')\n try:\n focus_gold_word = s_gold.find(id=focus_gold_fenode_id).get('word').lower()\n except AttributeError:\n focus_gold_word = ''\n else:\n focus_gold_word = ''\n\n focus_gold_list.append(focus_gold_word)\n focus_test_list.append(focus_test_word)\n\n # Sort lists\n sorted_focus_gold_list = sorted(flatten(focus_gold_list))\n sorted_focus_test_list = sorted(flatten(focus_test_list))\n\n #print('\\nFocus [Gold]:', sorted_focus_gold_list)\n #print('Focus [Test]:', sorted_focus_test_list)\n\n\n # Negated\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n if item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n else:\n negated_test_word = ''\n\n elif item[1].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_test = item[1].find('fe', {'name' : NEGATED_TAG_NAME})\n try:\n negated_test_fenode_id = negated_test.find('fenode').get('idref')\n negated_test_word = s_test.find(id=negated_test_fenode_id).get('word').lower()\n except:\n negated_test_word = ''\n if item[0].find('fe', {'name' : NEGATED_TAG_NAME}):\n negated_gold = item[0].find('fe', {'name' : NEGATED_TAG_NAME})\n negated_gold_fenode_id = negated_gold.find('fenode').get('idref')\n try:\n negated_gold_word = s_gold.find(id=negated_gold_fenode_id).get('word').lower()\n except AttributeError:\n negated_gold_word = ''\n else:\n negated_gold_word = ''\n else:\n negated_test_word = ''\n negated_gold_word = ''\n\n negated_gold_list.append(negated_gold_word)\n negated_test_list.append(negated_test_word)\n\n # Sort lists\n sorted_negated_gold_list = sorted(flatten(negated_gold_list))\n sorted_negated_test_list = sorted(flatten(negated_test_list))\n\n #print('\\nNegated [Gold]:', sorted_negated_gold_list)\n #print('Negated [Test]:', sorted_negated_test_list)\n\n\n # Resolve Terminals if Scope on a complex graph\n def resolve_non_terminals(idref):\n \"\"\" This function resolves a complex gold graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_gold.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_gold.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_gold.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_gold.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n def resolve_non_terminals_test(idref):\n \"\"\" This function resolves a complex test graph to\n a simple flat list of tokens.\n \"\"\"\n nonterminal = s_test.find(id=idref)\n edges = nonterminal.find_all('edge')\n edge_words = []\n for edge in edges:\n e_id = edge.get('idref')\n if s_test.find(id=e_id).get('word') is not None:\n try:\n edge_word = s_test.find(id=e_id).get('word').lower()\n edge_words.append(edge_word)\n except:\n pass\n if s_test.find(id=e_id).get('word') is None:\n edge_words.append(resolve_non_terminals(e_id))\n\n return edge_words\n\n # Scope\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[0].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n\n if item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n elif s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n scope_test_list.append('')\n\n elif item[1].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_test = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_test_fenodes = scope_test.find_all('fenode')\n for s_t in scope_test_fenodes:\n s_id = s_t.get('idref')\n if s_test.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_test.find(id=s_id).get('word').lower()\n scope_test_list.append(scope_word)\n except:\n pass\n if s_test.find(id=s_id).get('word') is None:\n scope_test_list.append(resolve_non_terminals_test(s_id))\n else:\n pass\n\n if item[0].find('fe', {'name' : SCOPE_TAG_NAME}):\n scope_gold = item[1].find('fe', {'name' : SCOPE_TAG_NAME})\n scope_gold_fenodes = scope_gold.find_all('fenode')\n for s_g in scope_gold_fenodes:\n s_id = s_g.get('idref')\n if s_gold.find(id=s_id).get('word') is not None:\n try:\n scope_word = s_gold.find(id=s_id).get('word').lower()\n scope_gold_list.append(scope_word)\n except:\n pass\n if s_gold.find(id=s_id).get('word') is None:\n scope_gold_list.append(resolve_non_terminals(s_id))\n else:\n pass\n else:\n scope_gold_list.append('')\n\n # Sort lists\n sorted_scope_gold_list = sorted(flatten(scope_gold_list))\n sorted_scope_test_list = sorted(flatten(scope_test_list))\n\n #print('\\nScope [Gold]:', sorted_scope_gold_list)\n #print('Scope [Test]:', sorted_scope_test_list)\n\n # If lists are same length, check if items are same\n if len(sorted_scope_gold_list) == len(sorted_scope_test_list):\n sorted_scope_test_list_intersection = set(sorted_scope_gold_list).intersection(sorted_scope_test_list)\n sorted_scope_test_list_intersection = list(sorted_scope_test_list_intersection)\n if len(sorted_scope_test_list_intersection) < len(sorted_scope_test_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_test_list_intersection)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list_intersection.append('')\n empty_element = empty_element + 1\n \n sorted_scope_test_list = sorted_scope_test_list_intersection\n\n # If lists are different lengths, add empty elements\n elif len(sorted_scope_gold_list) > len(sorted_scope_test_list):\n difference = len(sorted_scope_gold_list) - len(sorted_scope_test_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_test_list.append('')\n empty_element = empty_element + 1\n\n elif len(sorted_scope_test_list) > len(sorted_scope_gold_list):\n difference = len(sorted_scope_test_list) - len(sorted_scope_gold_list)\n empty_element = 0\n\n while empty_element < difference:\n sorted_scope_gold_list.append('')\n empty_element = empty_element + 1\n\n\n # Align items in the lists for sklearn, set 1 for matched items, else set 0\n sorted_target_gold_list_normalized = [1 if element in sorted_target_gold_list and not element == \"\" else 0 for element in sorted_target_gold_list]\n sorted_target_test_list_normalized = [1 if element in sorted_target_gold_list else 0 for element in sorted_target_test_list]\n\n sorted_focus_gold_list_normalized = [1 if element in sorted_focus_gold_list and not element == \"\" else 0 for element in sorted_focus_gold_list]\n sorted_focus_test_list_normalized = [1 if element in sorted_focus_gold_list else 0 for element in sorted_focus_test_list]\n\n sorted_negated_gold_list_normalized = [1 if element in sorted_negated_gold_list and not element == \"\" else 0 for element in sorted_negated_gold_list]\n sorted_negated_test_list_normalized = [1 if element in sorted_negated_gold_list else 0 for element in sorted_negated_test_list]\n\n sorted_scope_gold_list_normalized = [1 if element in sorted_scope_gold_list and not element == \"\" else 0 for element in sorted_scope_gold_list]\n sorted_scope_test_list_normalized = [1 if element in sorted_scope_gold_list else 1 if not element == \"\" else 0 for element in sorted_scope_test_list]\n\n #print(sorted_scope_gold_list_normalized)\n #print(sorted_scope_test_list_normalized)\n\n\n # Sklearn calculations\n #target_precision_scores = target_precision_scores + precision_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_recall_scores = target_recall_scores + recall_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n target_f1_scores = target_f1_scores + f1_score(sorted_target_gold_list_normalized, sorted_target_test_list_normalized, average='weighted')\n #target_jaccard_scores = target_jaccard_scores + jaccard_similarity_score(sorted_target_gold_list, sorted_target_test_list)\n\n #focus_precision_scores = focus_precision_scores + precision_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_recall_scores = focus_recall_scores + recall_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n focus_f1_scores = focus_f1_scores + f1_score(sorted_focus_gold_list_normalized, sorted_focus_test_list_normalized, average='weighted')\n #focus_jaccard_scores = focus_jaccard_scores + jaccard_similarity_score(sorted_focus_gold_list, sorted_focus_test_list)\n\n #negated_precision_scores = negated_precision_scores + precision_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_recall_scores = negated_recall_scores + recall_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n negated_f1_scores = negated_f1_scores + f1_score(sorted_negated_gold_list_normalized, sorted_negated_test_list_normalized, average='weighted')\n #negated_jaccard_scores = negated_jaccard_scores + jaccard_similarity_score(sorted_negated_gold_list, sorted_negated_test_list)\n\n scope_precision_scores = scope_precision_scores + precision_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_recall_scores = scope_recall_scores + recall_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_f1_scores = scope_f1_scores + f1_score(sorted_scope_gold_list_normalized, sorted_scope_test_list_normalized, average='weighted')\n scope_jaccard_scores = scope_jaccard_scores + jaccard_similarity_score(sorted_scope_gold_list, sorted_scope_test_list)\n\n\n print('\\n=============================')\n print('====== EVALUATION for:', chapter_input_test_name, '======')\n print('Total Sentences:', sentence_count,\n '\\nNegation Gold frames:', gold_frames_count,\n '\\nNegation Test frames:', test_frames_count, '\\n')\n\n print('----- CUEWORDS -----')\n #print('Precision:\\t', target_precision_scores / gold_frames_count)\n #print('Recall:\\t', target_recall_scores / gold_frames_count)\n print('F1 score:\\t', target_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', target_jaccard_scores / gold_frames_count)\n\n print('\\n----- FOCUS -----')\n #print('Precision:\\t', focus_precision_scores / gold_frames_count)\n #print('Recall:\\t', focus_recall_scores / gold_frames_count)\n print('F1 score:\\t', focus_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', focus_jaccard_scores / gold_frames_count)\n\n print('\\n----- NEGATED -----')\n #print('Precision:\\t', negated_precision_scores / gold_frames_count)\n #print('Recall:\\t', negated_recall_scores / gold_frames_count)\n print('F1 score:\\t', negated_f1_scores / gold_frames_count)\n #print('Jaccard similarity:\\t', negated_jaccard_scores / gold_frames_count)\n\n print('\\n----- SCOPE -----\\nScope Gold frames:', scope_gold_frames_count, '\\nScope Test frames:', scope_test_frames_count, '\\n')\n print('Precision:\\t', scope_precision_scores / scope_test_frames_count)\n print('Recall:\\t', scope_recall_scores / scope_test_frames_count)\n print('F1 score:\\t', scope_f1_scores / scope_test_frames_count)\n print('Jaccard similarity:\\t', scope_jaccard_scores / scope_test_frames_count)\n\n print('Done!')",
"def is_failed(doc_dict):\n\n results_xml = os.listdir(os.path.join(config.TOC_OCR_RESULTS, doc_dict['name']))\n \n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Results directory contents for {os.path.join(config.TOC_OCR_RESULTS,doc_dict['name'])}:\")\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): {results_xml}\")\n\n if len(results_xml) == 0:\n raise IOError(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} ERROR (OCR): Result XML files not found in {os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'])}...\")\n\n for item in results_xml:\n # open XML file and parse it as an ordered dict\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Found result file: {item}\")\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): Opening result file {os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'], item)}...\")\n with open(os.path.join(config.TOC_OCR_RESULTS, doc_dict['name'], item), mode='rb') as f:\n xml = xmltodict.parse(xml_input=f)\n # print(\"OCR XML: \", xml)\n\n # find XmlResult in the ordered dictionary created by parsing XML file\n result_generator = utility.find_item_in_response(data=xml, key='@IsFailed')\n\n # find IsFailed property in XmlResult ordered dict\n for found_value in result_generator:\n # is_failed_generator = utility.find_item_in_response(data=result, key='@IsFailed')\n #\n # # check the value of IsFailed property\n # for found_value in is_failed_generator:\n # print(\"IS FAILED: \", found_value)\n if found_value == 'true':\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR): TRUE RESULT FOUND VALUE: {found_value}\")\n return True\n else:\n print(f\"{format(datetime.now(), '%Y-%m-%d %H:%M:%S')} INFO (OCR ): FALSE RESULT FOUND VALUE: {found_value}\")\n return False",
"def test_install_set_existing(self):\n expected = copy.deepcopy(test_xdata)\n expected.find(\"Text\").text = \"Changed content\"\n self._install([lxml.etree.Element(\"Set\", path=\"Test/Text/#text\",\n value=\"Changed content\")],\n expected)",
"def test_load():\n t = PandasTransformer()\n os.makedirs(target_dir, exist_ok=True)\n t.parse(os.path.join(resource_dir, \"x1n.csv\"))\n t.parse(os.path.join(resource_dir, \"x1e.csv\"))\n t.report()\n t.save(os.path.join(target_dir, 'x1copy'))\n # w = GraphMLTransformer(t.graph)\n # w.save(os.path.join(target_dir, \"x1n.graphml\"))",
"def test_write(self):\n cases = {\n self.test_eac + \"NE00401.xml\": True,\n self.test_eac + \"NE01501.xml\": False,\n self.test_eac + \"NE01302.xml\": True,\n }\n metadata_url = 'http://www.example.com/metadata.xml'\n presentation_url = 'http://www.example.com/presentation.html'\n for case in cases:\n doc = EacCpf.EacCpf(case, metadata_url, presentation_url)\n self.assertNotEqual(doc, None)\n path = doc.write(self.temp)\n self.assertEquals(os.path.exists(path), True)\n # read the file and try to extract the attributes\n try:\n tree = etree.parse(path)\n ns = {\n EacCpf.DOC_KEY: EacCpf.DOC_NS,\n EacCpf.ESRC_KEY: EacCpf.ESRC_NS,\n }\n # get the url to the metadata file\n metadata = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":metadata\", namespaces=ns)\n self.assertNotEqual(metadata, None)\n self.assertEqual(metadata[0], metadata_url)\n # get the url to the presentation file\n presentation = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":presentation\", namespaces=ns)\n self.assertNotEqual(presentation, None)\n self.assertEqual(presentation[0], presentation_url)\n # get the url to the source file\n source = tree.xpath(\"//doc:eac-cpf/@\" + EacCpf.ESRC_KEY + \":source\", namespaces=ns)\n self.assertNotEqual(source, None)\n self.assertEqual(source[0], case)\n except:\n msg = \"Failed to complete parsing of {0}\".format(case)\n self.log.error(msg, exc_info=True)\n self.fail(msg)",
"def recipe12_8():\n from xml.parsers.xmlproc import utils, xmlval, xmldtd\n def validate_xml_file(xml_filename, app=None, dtd_filename=None):\n # build validating parser object with appropriate error handler\n parser=xmlval.Validator()\n parser.set_error_handler(utils.ErrorPrinter(parser))\n if dtd_filename is None:\n # DTD fiel specified, laod and set it as the DTD to use\n dtd=xmldtd.load_dtd(dtd_filename)\n parser.val.dtd = parser.dtd = parser.ent = dtd\n if app is not None:\n # Application processing requested, set application object\n parser.set_application(app)\n # everything being set correctly, finally perform the parsing\n parser.parse_resource(xml_filename) \n # if XML data is in a string s, use instead\n # parser.feed(s)\n # parser.close(s)",
"def test_missing_shx(self):\n path = os.path.join(BASE_DIR, \"tests\", \"fixtures\", \"missing_shx.zip\")\n zip_file = zipfile.ZipFile(path)\n\n with self.assertRaises(MissingFiles) as context:\n get_shapefile(zip_file)\n the_exception = context.exception\n self.assertEqual(MISSING_FILE, the_exception.message)",
"def data_available(dataset_name=None):\r\n for file_list in data_resources[dataset_name]['files']:\r\n for file in file_list:\r\n if not os.path.exists(os.path.join(data_path, dataset_name, file)):\r\n return False\r\n return True",
"def test_exists_false(self):\n self.assertFalse(PrepTemplate.exists(2))",
"def create_xml_regression(lfiles, lsbj, foxml):\n\n impl = xml.dom.minidom.getDOMImplementation()\n doc = impl.createDocument(None, \"some_tag\", None)\n top_element = doc.documentElement\n\n e = doc.createElement('subject')\n e.setAttribute('id', 'case')\n\n for i, fn in enumerate(lfiles):\n v = doc.createElement('visit')\n v.setAttribute('id', \"subj{}\".format(i))\n\n f = doc.createElement('filename')\n f.setAttribute('object_id', \"face\")\n t = doc.createTextNode(fn)\n f.appendChild(t)\n\n a = doc.createElement('age')\n x = doc.createTextNode(str(lsbj[i][\"age\"]))\n a.appendChild(x)\n\n\n v.appendChild(f)\n v.appendChild(a)\n e.appendChild(v)\n\n top_element.appendChild(e)\n\n with open(foxml, \"w\") as fo:\n fo.write(doc.toprettyxml())",
"def xslTestText(self):\n return u'normalize-space(./%s)' % self.name",
"def _set_path_to_xml(self):\n\n self._path_to_xml = Path(__file__).parent / Path(XML_TABLE_PATH.format(self._instrument,\n self._original_file_type))\n\n if not self._path_to_xml.exists():\n raise ValueError(INVALID_FILE_TYPE_ERROR.format(self._original_file_type, self._instrument))",
"def isExist(data):\n return True/False",
"def test_output_exists():\n global out_dir, cor_dir\n assert(path.exists(path.join(out_dir, 'oshea_similarity.json')))",
"def test_resourcesXML(self):\n fileName = self.mktemp()\n fp = FilePath(fileName)\n fp.setContent(oldResourcesFormat)\n upgradeResourcesXML(fp)\n self.assertEquals(fp.getContent(), newResourcesFormat)",
"def test_generate_sample_sheet(self):\n pass",
"def test_negative_file_and_xml(self):\n xml_object = ET.parse(self.xmlfile)\n with self.assertRaises((IOError, OSError)):\n glymur.jp2box.XMLBox(filename=self.xmlfile, xml=xml_object)",
"def example_xml43(example_xml_file41):\n return etree.fromstring(example_xml_file43.encode('utf-8'))",
"def test_duplicate_standard_name(self):\n # Setup test\n infilename = os.path.join(_SAMPLE_FILES_DIR, \"reg_good_simple.xml\")\n filename = os.path.join(_TMP_DIR, \"reg_duplicate_standard_name.xml\")\n out_source_name = \"physics_types_duplicate_standard_name\"\n out_source = os.path.join(_TMP_DIR, out_source_name + '.F90')\n out_meta = os.path.join(_TMP_DIR, out_source_name + '.meta')\n remove_files([out_source, out_meta])\n tree, root = read_xml_file(infilename)\n # Change output filename\n for obj in root:\n oname = obj.get('name')\n if (obj.tag == 'file') and (oname == 'physics_types_simple'):\n obj.set('name', out_source_name)\n new_var = ET.SubElement(obj, \"variable\")\n new_var.set(\"local_name\", \"french_fries\")\n new_var.set(\"standard_name\", \"latitude\")\n new_var.set(\"units\", \"radians\")\n new_var.set(\"type\", \"real\")\n new_var.set(\"kind\", \"kind_phys\")\n dims_elem = ET.SubElement(new_var, \"dimensions\")\n dims_elem.text = 'horizontal_dimension'\n break\n # End if\n # End for\n tree.write(filename)\n\n # Run test\n with self.assertRaises(ValueError) as verr:\n _ = gen_registry(filename, 'eul', {}, _TMP_DIR, 2,\n _SRC_MOD_DIR, _CAM_ROOT,\n loglevel=logging.ERROR,\n error_on_no_validate=True)\n # End with\n # Check exception message\n emsg = \"duplicate variable standard_name, 'latitude' from \"\n emsg += \"'french_fries' in 'physics_types_duplicate_standard_name'\"\n emsg += \", already defined with local_name, 'latitude'\"\n self.assertEqual(emsg, str(verr.exception))\n # Make sure no output files were created\n self.assertFalse(os.path.exists(out_meta))\n self.assertFalse(os.path.exists(out_source))",
"def check_file_exist(self):\n return False",
"def test_read_file():\n z = XPIManager(get_path('xpi/install_rdf_only.xpi'))\n assert z.read('install.rdf') is not None",
"def test_predicate4(self):\n xpb = XPathBuilder()\n xp = xpb.foo.bar.where(xpb.attr('name').not_equals('abc'))\n xp = xp.where(xpb.attr('x').equals('foo'))\n exp = '/foo/bar[@name != \"abc\"][@x = \"foo\"]'\n self.assertEqual(xp.tostring(), exp)",
"def test_verify_unzip(self):\n assert os.path.exists(\n os.path.join(\n settings.MEDIA_ROOT,\n \"indices\",\n \"test-index\",\n \"data\",\n \"sample.txt\"\n )\n )",
"def test_exists_true(self):\n self.assertTrue(Sample.exists(self.sample_id, self.sample_template))",
"def test_xmloutput_view(self):\n print 'Running %s ...' % getName()\n \n self.sequenceListingFixture.create_sequence_instance(self.sequenceListing)\n \n response = self.client.get(reverse('sequencelistings:xmloutput', args=[self.sequenceListing.pk, ]))\n self.assertEqual(response.status_code, 200)\n# test that the page returns expected html contents\n# self.assertContains(response, '%s.xml' % self.sequenceListing.fileName)\n self.assertContains(response, self.sequenceListing.fileName)",
"def _need_generate(paths):\r\n if not os.path.exists(paths.generated_dir):\r\n return True\r\n\r\n if not os.path.exists(paths.index_file):\r\n return True\r\n\r\n # Use the index file to determine if regeneration is necessary\r\n with open(paths.index_file, 'r',newline='\\n') as index_file:\r\n indexed = [item for item in\r\n index_file.read().split('\\n') if len(item) != 0 and\r\n not item.startswith(\"#\")]\r\n return indexed != paths.resource_files"
] | [
"0.5755427",
"0.5572019",
"0.5549192",
"0.5519365",
"0.5482828",
"0.5464173",
"0.5427079",
"0.54160964",
"0.536601",
"0.5338898",
"0.52344614",
"0.5227911",
"0.51953274",
"0.5182521",
"0.51584786",
"0.51524824",
"0.51514745",
"0.51503146",
"0.511027",
"0.5074203",
"0.5046354",
"0.503389",
"0.50189185",
"0.501048",
"0.50082016",
"0.50032926",
"0.4969945",
"0.4964399",
"0.49625763",
"0.49601397",
"0.49531683",
"0.4920993",
"0.49191195",
"0.49034697",
"0.4864428",
"0.4853922",
"0.48519278",
"0.48500398",
"0.48478904",
"0.48434386",
"0.48360553",
"0.483164",
"0.48283836",
"0.48276672",
"0.4826746",
"0.48221388",
"0.4820197",
"0.4818247",
"0.48045155",
"0.48015872",
"0.4796322",
"0.47905782",
"0.47900566",
"0.47882983",
"0.47780943",
"0.47775993",
"0.4774293",
"0.47632882",
"0.47608277",
"0.47599152",
"0.47497493",
"0.4741375",
"0.4734563",
"0.47324103",
"0.47287878",
"0.47215125",
"0.47187984",
"0.4716064",
"0.47110233",
"0.4711012",
"0.4706559",
"0.47056934",
"0.47030586",
"0.47023386",
"0.4697539",
"0.46970925",
"0.46966684",
"0.46914452",
"0.46881047",
"0.46803975",
"0.46758932",
"0.46708822",
"0.46706775",
"0.4667462",
"0.46658367",
"0.46618056",
"0.46566275",
"0.4652985",
"0.46504042",
"0.4645476",
"0.46431816",
"0.463976",
"0.46339816",
"0.46335384",
"0.4632274",
"0.46320617",
"0.4631103",
"0.46305624",
"0.46282983",
"0.46265066"
] | 0.47550705 | 60 |
Return name enclosed with {? } separators | def sepName(self, englishOnly=False):
name = englishOnly and self.enName or self.name
return u'{*#%s*}' % (name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_qname(uri, name):\n if not uri or not name or name[0] in ('{', '.', '/', '['):\n return name\n else:\n return '{%s}%s' % (uri, name)",
"def extract_name():\n def _extract_name(quoted_name):\n return e.String(quoted_name.subexpression.name)\n yield (\"(λ &[name] . str)\", _extract_name)",
"def safe_name(self, name):\n\n output = \"\"\n for char in name:\n if char not in '\\\\/<>:\"|?*':\n output += char\n\n return output",
"def safe_formal_name(name):\n return re.sub(r\"\\s+\", \" \", re.sub(r'[!/\\\\:<>\"\\?\\*\\|]', \"\", name)).strip()",
"def non_local_name(self, name):\n if \"!\" in name:\n return name[:name.find(\"!\")+1]\n else:\n return name",
"def named_back_reference(name:str) -> str:\n # TODO error handling \n return f\"\\\\k<{name}>\"",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*&%s*}' % (name)",
"def format_name(self) -> str:\n decl = self.declaration\n name, _ = decl.split(\"(\", 1)\n return name",
"def render_name(name_att_list):\n res = ['']\n for k, v in name_att_list:\n v = dn_escape(v)\n res.append(\"%s=%s\" % (k, v))\n res.append('')\n return '/'.join(res)",
"def format_name_string(x: str) -> str:\n # get rid of [#] when present\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n if \"var.\" in x.lower():\n p = x.lower().find(\"var.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \" var \" in x.lower(): # need the spaces around var, because some names have the letters var in them\n p = x.lower().find(\" var \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+4] + \" <em class=\\\"species\\\">\" + x[p+4:] + \"</em>\"\n elif \"subsp.\" in x.lower():\n p = x.lower().find(\"subsp.\")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" forme \" in x.lower():\n p = x.lower().find(\" forme \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+6] + \" <em class=\\\"species\\\">\" + x[p+6:] + \"</em>\"\n elif \" f. \" in x.lower():\n p = x.lower().find(\" f. \")\n return \"<em class=\\\"species\\\">\" + x[:p] + \"</em> \" + x[p:p+3] + \" <em class=\\\"species\\\">\" + x[p+3:] + \"</em>\"\n else:\n return \"<em class=\\\"species\\\">\" + x + \"</em>\"",
"def format_name(self) -> str:\n decl = self.declaration\n name, _, _ = decl.partition(\"(\")\n return name",
"def Escape(name):\n return re.sub(r'[^\\w#-]', '_', name)",
"def _process_name(name):\n\n # Unescape HTML entities\n name = unescape(name)\n\n # Remove bracketed stuff on the end\n name = NG_RE.sub('', name).strip() # Nomenclature groups\n name = END_RE.sub('', name).strip(', ') # Words\n name = RATIO_RE.sub('', name).strip(', ') # Ratios\n\n # Remove stuff off start\n name = START_RE.sub('', name).strip()\n\n # Remove balanced start and end brackets if none in between\n name = BRACKET_RE.sub('\\g<1>', name)\n\n # Un-invert CAS style names\n comps = name.split(', ')\n if len(comps) == 2:\n if comps[1].endswith('-'):\n name = comps[0]\n name = '%s%s' % (comps[1], name)\n elif len(comps) > 2:\n name = comps[0]\n for i in range(1, len(comps)):\n if comps[i].endswith('-'):\n name = '%s%s' % (comps[i], name)\n else:\n name = '%s %s' % (name, comps[i])\n return name",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*?%s*}' % (name)",
"def split_name(fullname):",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n if not self.useFileInfo:\n return u'{*%s*}' % name\n return u'{*!%s*}' % name",
"def compile_name(self, name):\n S = [s.strip().lower() for s in name.split('|')]\n assert all(S)\n \n S = [set(x.strip().lower() for x in s.split('&')) for s in S]\n assert all(all(x) for x in S)\n \n return S",
"def generate(self, name):\n if not '?' in self._pattern and not '[' in self._pattern:\n try:\n return self._pattern.replace('*', '{}').format(name)\n except IndexError:\n # multiple *\n pass\n return ''",
"def get_name() -> str:",
"def CleanName(self,name):\n name2 = \"\"\n for c in name:\n if c == \"(\":\n break\n else: name2+=c\n\n return name2.strip(\"\\n\")",
"def latex_name(name):\r\n name = name + '_' #protects against .split('_') failing\r\n if name.startswith('['): #format leading [] as concentration\r\n head, tail = name[1:].rsplit(']', 1)\r\n head = r'[\\ce{%s}]' % head\r\n else:\r\n if '[' in name: # turn internal [] into marked-up subscripts\r\n before, inside, after = re.match(r'([^[]+)\\[(.*)\\]([^]]*)', name).groups() # separates bracketed material\r\n name = r'%s_\\ce{%s}_%s' % (before, inside, after)\r\n head, tail = name.split('_', 1)\r\n if len(head) > 1: # special cases like v12 (=> v_12) and roman multiple letter symbol\r\n if re.match(r'^.[0-9]+$', head): # single character following by integer, i.e. v0\r\n head, tail = name[0], name[1:]\r\n else:\r\n head = r'\\mathrm{%s}' % head\r\n subscripts = re.findall(r'(\\\\ce{.*}|[^_]+)_', tail) # tail.split('_') but ignoring underscore within chem mark-up\r\n if subscripts:\r\n return head + r'_{\\mathrm{' + ','.join(subscripts) + '}}'\r\n return head",
"def fmt(competitor_name: str) -> str:\n name = competitor_name.replace(\"_a\", r\" $\\alpha$ \")\n name = name.replace(\"_b\", r\" $\\beta$ \")\n return name",
"def _format_question_break(self, name):\n header = '-' * 80 + '\\n'\n buffer_length = int((80 - int(len(name))) / 2) \n header += ' ' * buffer_length + name + ' ' * buffer_length + '\\n'\n header += '-' * 80 + '\\n'\n\n return header",
"def format_name(field_name):\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()",
"def _var_name_sub(self, sprintf, quote=False):\n q = ''\n if quote:\n q = \"'\"\n name_list = map(lambda x: q + self.cdict[x][0] + q, sprintf[\"vars\"] )\n return sprintf[\"text\"] % tuple(name_list)",
"def __str__(self) -> str:\n return f'?{self.name}'",
"def format_alias_name(self, name):\n result = strip_punctuation(name)\n result = WHITESPACE_REGEX.sub(' ', result)\n return result",
"def get_name(header, splitchar=\"_\", items=2):\n if splitchar:\n return \"_\".join(header.split(splitchar)[:items]).lstrip(\">\")\n else:\n return header.lstrip(\">\")",
"def clean_name(x: str) -> str:\n x = x.replace(\", var.\", \" var.\")\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n return x",
"def format_name(self) -> str:\n decl = self.declaration\n\n # variables which are declared and assigned at the same location will\n # include the assignment in the clange declaration, so strip it out for\n # documentation.\n name, _, _ = decl.partition(\"=\")\n return name",
"def name(self) -> StringFilter:\n return self.__name",
"def adjust_name_for_printing(name):\n if name is not None:\n name2 = name\n name = name.replace(\" \", \"_\").replace(\".\", \"_\").replace(\"-\", \"_m_\")\n name = name.replace(\"+\", \"_p_\").replace(\"!\", \"_I_\")\n name = name.replace(\"**\", \"_xx_\").replace(\"*\", \"_x_\")\n name = name.replace(\"/\", \"_l_\").replace(\"@\", '_at_')\n name = name.replace(\"(\", \"_of_\").replace(\")\", \"\")\n if re.match(r'^[a-zA-Z_][a-zA-Z0-9-_]*$', name) is None:\n raise NameError(\"name {} converted to {} cannot be further converted to valid python variable name!\".format(name2, name))\n return name\n return ''",
"def format_name(self) -> str:\n return self.declaration",
"def __sanitize(name):\n if name[-1] == \"/\":\n return name[:-1]\n return name",
"def fname(self):\n buff = []\n for c in self.name:\n if c in latex_symbol_map:\n buff.append(\"$_{}$\".format(latex_symbol_map[c]))\n else:\n buff.append(c)\n return ''.join(buff)",
"def _get_pretty_name(name):\n pretty = ''\n if name.countryName:\n pretty += '/C=' + name.countryName\n if name.stateOrProvinceName:\n pretty += '/ST=' + name.stateOrProvinceName\n if name.localityName:\n pretty += '/L=' + name.localityName\n if name.organizationName:\n pretty += '/O=' + name.organizationName\n if name.organizationalUnitName:\n pretty += '/OU=' + name.organizationalUnitName\n if name.commonName:\n pretty += '/CN=' + name.commonName\n if name.emailAddress:\n pretty += '/email=' + name.emailAddress\n return pretty",
"def _extract_name(line: str) -> str:\n tokens = line[19:-2].split(\" {\")\n name = tokens[0]\n return name",
"def name(self):\n return self._name or ' & '.join(s.name for s in self.suites)",
"def success_new_brass(name):\n return 'Nom de brasserie %s' % name + ' a bien ete ajoute'",
"def print_name(nome, sobrenome):\r\n return nome + \" \" + sobrenome",
"def mark(name: str) -> str:\n return f'<mark name=\"{name}\"/>'",
"def filter_name(self, name):\n return self.form.set_value(\"generating station search\", name)",
"def variable_string(self, name):\n return \"$(\" + name + \")\"",
"def visit_name(self, node, children):\n name = ''.join(children)\n return name",
"def fullname(self, name):\n f, l = name.split(' ')\n self.first = f\n self.last = l",
"def get_name():",
"def ending_cutter(name: str):\n if name.endswith('ID') and re.match(r'^(?=\\w+[A-Z])(?=\\w+[a-z])\\w+$', name):\n return name[:-2]\n return name",
"def get_full_name(self):\n full_name = '{0} {1} {2}'.format(self.last_name, self.first_name, self.patronymic)\n return full_name.strip()",
"def full_name(self) -> str:\n # return self.separator.join(map(lambda x: x.name, self.path()))\n return self.separator.join(map(lambda x: x.tagged_name, self.path()))",
"def capture(*args:List[str], name:Union[str,None]=None) -> str:\n name = f\"?<{name}>\" if name is not None else \"\"\n return f'({name}{\"\".join(args)})'",
"def format_name(self):\n\t\tself.full_name = self.first + \" \" + self.last",
"def name_parser(string):\n return string.replace('\\n', ' ')",
"def clean_specific_name(x: str) -> str:\n\n # this is a list of terms that are not actual species names or specific names that have never been part of\n # a fiddler genus\n skip_list = (\"sp.\",\n \"spp.\",\n \"var.\",\n \"nov.\",\n \"a\",\n \"ete\",\n \"panema\",\n \"pagurus\",\n \"quadratus\",\n \"albidus\",\n \"vociferans\",\n \"raniformis\",\n \"nigra\",\n \"albicans\",\n \"arenarius\",\n \"raninus\",\n \"serratus\",\n \"cordimana\",\n \"spec.\",\n \"complex\",\n \"5\",\n \"6\",\n \"1\",\n \"afruca\",\n \"gelasimus\")\n\n if (\" \" not in x) or (\"(\" in x):\n return \"\"\n else:\n if \"{\" in x:\n x = x[:x.find(\"{\")-1]\n y = x.split(\" \")\n x = y[len(y)-1].lower()\n if (x in skip_list) or (\"gruppe\" in x) or (\"group\" in x) or (\"complex\" in x):\n return \"\"\n else:\n return x.lower()",
"def quote_name(self, name):\n name = re.sub('-', '', name)\n if name.startswith('\"') and name.endswith('\"'):\n return name\n return '\"%s\"' % (name,)",
"def FilterName(namefilter, safechar='P', reserved_names=None):\n # remove non accepted characters\n for c in r' -[]/\\;,><&*:%=+@!#^|?^':\n namefilter = namefilter.replace(c, '')\n\n # remove non english characters\n char_list = (c for c in namefilter if 0 < ord(c) < 127)\n namefilter = ''.join(char_list)\n\n # Make sure we have a non empty string\n if len(namefilter) <= 0:\n namefilter = safechar\n\n # Make sure we don't start with a number\n if namefilter[0].isdigit():\n print(namefilter)\n namefilter = safechar + namefilter\n\n # Make sure we are not using a reserved name\n if reserved_names is not None:\n while namefilter.lower() in reserved_names:\n namefilter = safechar + namefilter\n\n # Add the name to reserved names\n reserved_names.append(namefilter)\n\n return namefilter",
"def _get_name(self):\n name_string = '%s_%s' % (\n self.parameter_type,\n self.parameter_value_type)\n if self.paneltemplateparametermarker_set.count() > 0:\n marker_string = \"_\".join(sorted([m.marker.marker_abbreviation for m in self.paneltemplateparametermarker_set.all()]))\n name_string += '_' + marker_string\n if self.fluorochrome:\n name_string += '_' + self.fluorochrome.fluorochrome_abbreviation\n return name_string",
"def _get_name(self):\n return '%s: %s-%s' % (\n self.fcs_number,\n self.parameter_type,\n self.parameter_value_type)",
"def name(self):\n\n return self._name.replace(\"[]\", \"\")",
"def get_name(self):\n name = ''\n # name contains all adjacent alphanumeric symbol\n while self.current_character.isalnum():\n name += self.current_character\n self.current_character = self.file.read(1)\n self.file.seek(self.file.tell() - 1, 0)\n character = self.file.read(1)\n if character.isalnum():\n pass\n else:\n self.file.seek(self.file.tell() - 1, 0)\n return name",
"def getName(self):\n return \"\"",
"def normalize_pipeline_name(name=''):\n normalized_name = name\n for bad in '\\\\/?%#':\n normalized_name = normalized_name.replace(bad, '_')\n return normalized_name",
"def match_specific_name(name: str, specific_names: list) -> str:\n c = clean_specific_name(name)\n if c == \"\":\n return c\n else:\n y = \"\"\n for x in specific_names:\n matchlist = x.variations.split(\";\")\n if c in matchlist:\n y = x.name\n return y",
"def get_html_name(form, name):\n return form.add_prefix(name)",
"def _get_name(self, name, scopes=None, include_cond=True):\n if scopes is None:\n scopes = self._scopes\n\n scope_strings = []\n for scope in scopes:\n if self._is_name_scope(scope):\n scope_strings.append(scope)\n elif self._is_conditional_scope(scope) and include_cond:\n parent_name = scope['parent_name']\n parent_values = scope['parent_values']\n scope_string = '{name}={vals}'.format(\n name=parent_name,\n vals=','.join([str(val) for val in parent_values]))\n scope_strings.append(scope_string)\n return '/'.join(scope_strings + [name])",
"def get_name(self):\n return self._pattern",
"def get_name(descr: str) -> str:\n return descr.split()[0]",
"def _expanded_id(name: str, sep: str = '_') -> str:\n return sep.join([el.lower()\n for el in re.split(r'([A-Z]+[^A-Z]*)', name)\n if el])",
"def encode_name(param):\n sname = param\n # replace all kind of unwanted chars in a python dictname.\n sname = sname.strip()\n for ch in ['/', ' + ', ' ', '#', '&', '-', ',', '+', ]:\n if ch in sname:\n sname = sname.replace(ch, \"_\")\n\n # replace brackets\n for ch in ['(', ')']:\n if ch in sname:\n sname = sname.replace(ch, \"\")\n\n # replace the numbers 2 and 10 with the text representation\n if '10' in sname:\n sname = sname.replace('10', 'TEN')\n\n if '2' in sname:\n sname = sname.replace('2', 'TWO')\n return sname.upper()",
"def format_name(f_name, l_name): #docstring (documentation)\n if f_name == \"\" or l_name == \"\":\n return \"You didn't provide valid inputs.\"\n formated_f_name = f_name.title()\n formated_l_name = l_name.title()\n return f\"Result: {formated_f_name} {formated_l_name}\"",
"def fullname(self, name):\n\n first, last = name.split(' ')\n self.first = first\n self.last = last",
"def clean_name(name):\n return \",\".join(name.split(\",\")[:1])",
"def clean_name(name):\n return \",\".join(name.split(\",\")[:1])",
"def simplifyOutName(name):\n return \"HLTNav_\" + name.replace(\"HLTNav_\", \"\").replace(\"Trig\", \"\").replace(\"Alg\", \"\")",
"def format_name(self) -> str:\n return self.name",
"def get_name_link_html(self):\n url_text = \"{{% url 'trait_browser:source:studies:pk:detail' pk={} %}} \".format(self.pk)\n return URL_HTML.format(url=url_text, name=self.i_study_name)",
"def quote_name(self, name):\n if name.startswith(self.left_sql_quote) and name.endswith(self.right_sql_quote):\n return name # Quoting once is enough.\n return '%s%s%s' % (self.left_sql_quote, name, self.right_sql_quote)",
"def get_name(self):\r\n return ('%s %s' % ( self.first_name, self.last_name ))",
"def name_format(name):\n lst_name, fst_name = name.split(',')\n return ' '.join((fst_name, lst_name))",
"def legal_variable_name(name):\n var_name = name.replace(' ', '_')\n for char in r'''[]{}\\/^%$#@!+-<>?|'\"=~`,.;:''':\n if char in var_name:\n var_name = var_name.replace(char, '')\n for char in var_name:\n if ord(char) > 127: # remove non-ascii characters\n var_name = var_name.replace(char, '')\n return var_name",
"def get_field(fieldname):\n m = re.search(\"(^|\\\\n)%s\\\\s(.*?)\\n\" % fieldname, s, re.I)\n if not m:\n return None\n else:\n return Unquote(m.group(2))",
"def encode_name_components(self, name: Name):\n first_quot = False\n new_component = \"\"\n for component in name.components:\n if '\"' in str(component):\n if first_quot is True:\n new_component += str(component)\n first_quot = False\n else:\n first_quot = True\n if first_quot:\n new_component += str(component)\n new_component = new_component.replace(\"'b'\", \"/\").replace(\"b'\", \"\")[:-1]\n if \"=\" not in new_component and '\"' in new_component:\n new_component = new_component.replace('\"', \"\")\n start_of_component = 0\n for i in range(0, len(name.components)):\n if \"_(\" in str(name.components[i]):\n start_of_component = i\n comp_list_len = len(name.components)\n for i in range(start_of_component, comp_list_len - 2):\n name.components.pop(len(name.components) - 2)\n name.components[-2] = new_component.encode(\"ascii\")\n return name",
"def satname(rocketsatname):\n \n # split the rocket and satellite name at the bullet\n names = rocketsatname.split('•')\n \n # remove spaces around satellite name\n namefull = names[1].strip()\n \n # return the satellite's name\n return namefull",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def name(self) -> str:",
"def test_expanded_name( self ):\n\t\tself.doBasicTest(\n\t\t\t'''s := something +\n\t\t\t>something< := r\n\t\t\tr := [ab]\n\t\t\tv := [c]\n\t\t\t''',\n\t\t\t's',\n\t\t\t'abammmab',\n\t\t\t(1,[\n\t\t\t\t('r',0,1, NullResult),\n\t\t\t\t('r',1,2, NullResult),\n\t\t\t\t('r',2,3, NullResult),\n\t\t\t],3)\n\t\t)",
"def name(self):\n return \"%s %s\" % (self.first_name, self.last_name)",
"def cFormal(self):\n if not self.type:\n return self.name # special case for '...'\n else:\n arr = self.array or ''\n pointers = self.pointers or ''\n return \"%s %s%s%s\" % (self.type, pointers, self.name, arr)",
"def printname(bruce):",
"def get_query_parameter(self,original_name: Optional[str] = None) -> str:\n if not original_name:\n raise TypeError(\"original_name cannot be null.\")\n if original_name == \"count\":\n return \"%24count\"\n if original_name == \"expand\":\n return \"%24expand\"\n if original_name == \"filter\":\n return \"%24filter\"\n if original_name == \"orderby\":\n return \"%24orderby\"\n if original_name == \"search\":\n return \"%24search\"\n if original_name == \"select\":\n return \"%24select\"\n if original_name == \"skip\":\n return \"%24skip\"\n if original_name == \"top\":\n return \"%24top\"\n return original_name",
"def get_query_parameter(self,original_name: Optional[str] = None) -> str:\n if not original_name:\n raise TypeError(\"original_name cannot be null.\")\n if original_name == \"count\":\n return \"%24count\"\n if original_name == \"expand\":\n return \"%24expand\"\n if original_name == \"filter\":\n return \"%24filter\"\n if original_name == \"orderby\":\n return \"%24orderby\"\n if original_name == \"search\":\n return \"%24search\"\n if original_name == \"select\":\n return \"%24select\"\n if original_name == \"skip\":\n return \"%24skip\"\n if original_name == \"top\":\n return \"%24top\"\n return original_name",
"def sepName(self, englishOnly=False):\n name = englishOnly and self.enName or self.name\n return u'{*%s%s*}' % (self.parentLevel * '*', name)",
"def name(self):\n return str(self._options.hydraulic.pattern) if self._options.hydraulic.pattern is not None else ''",
"def get_full_name(self):\r\n full_name = '%s' % (self.name)\r\n return full_name.strip()",
"def name_value(self) -> global___Expression.NameValue:",
"def use_name(self):\n projection = proj.get_projection(self.conf.projections, self.spec)\n if not projection:\n projection = self.conf.default_projections[\"all\"]\n\n name = self.spec.format(projection)\n # Not everybody is working on linux...\n parts = name.split(\"/\")\n name = os.path.join(*parts)\n # Add optional suffixes based on constraints\n path_elements = [name] + self.conf.suffixes\n return \"-\".join(path_elements)",
"def get_rep_name(self, name):\n return \"r{0}\".format(name)",
"def get_full_name(self):\n if self.patronymic_name:\n return '{} {} {}'.format(\n self.first_name,\n self.patronymic_name,\n self.last_name,\n )\n\n return '{} {}'.format(\n self.first_name,\n self.last_name,\n )"
] | [
"0.61448735",
"0.61404973",
"0.5836852",
"0.5794541",
"0.57860225",
"0.57392246",
"0.5660936",
"0.56530035",
"0.5644217",
"0.55994993",
"0.55715615",
"0.55315167",
"0.55184275",
"0.54990566",
"0.54926336",
"0.5441188",
"0.5408375",
"0.5391947",
"0.53832364",
"0.5359637",
"0.5346842",
"0.53380084",
"0.5330564",
"0.53142434",
"0.52700996",
"0.524386",
"0.5241395",
"0.5233396",
"0.5231413",
"0.52298325",
"0.5229409",
"0.52205145",
"0.5205116",
"0.51899874",
"0.5175646",
"0.5157742",
"0.5152366",
"0.5143119",
"0.5132167",
"0.51301634",
"0.51278013",
"0.5103898",
"0.5086814",
"0.5084781",
"0.50829315",
"0.5073549",
"0.5044718",
"0.5029175",
"0.50255185",
"0.50253445",
"0.5024888",
"0.50179005",
"0.5001062",
"0.49965125",
"0.4993822",
"0.49925566",
"0.4990841",
"0.49782714",
"0.49752626",
"0.49584284",
"0.49572417",
"0.4957172",
"0.49540657",
"0.49521312",
"0.49429262",
"0.49422178",
"0.49277678",
"0.49253523",
"0.4921725",
"0.4921004",
"0.49199083",
"0.49199083",
"0.49191892",
"0.49006087",
"0.48929736",
"0.4892349",
"0.48865047",
"0.48834217",
"0.48830917",
"0.4882462",
"0.48709264",
"0.4869607",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48630777",
"0.48587474",
"0.48578084",
"0.48543957",
"0.4853977",
"0.48533097",
"0.48533097",
"0.4851776",
"0.48514396",
"0.48460093",
"0.48432255",
"0.48307502",
"0.48286083",
"0.4824451"
] | 0.5159675 | 35 |
Return formatted text for this field | def outputText(self, item, titleMode, internal=False):
return repr(len(item.descendLevelList(-self.parentLevel))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()",
"def formatted(self) -> str:\r\n ...",
"def format(self) -> str:",
"def text(self) -> str:",
"def get_as_text(self):\n d = {\n 'user': self.user or self.name,\n 'date': self.submit_date,\n 'text': self.text,\n 'domain': self.site.domain,\n 'url': self.get_absolute_url()\n }\n return _('Posted by %(user)s at %(date)s\\n\\n%(review)s\\n\\nhttp://%(domain)s%(url)s') % d",
"def get_text(self):\n inp = \" \"\n if self.link_id:\n inp += \"LINK \" + self.link_id\n inp += self.status + ' '\n if self.node_id:\n inp += \"NODE \" + self.node_id + ' '\n if self.value:\n inp += self.control_type.name + ' ' + str(self.value) + ' '\n if self.time:\n inp += self.time + ' '\n if self.clock_time:\n inp += self.clock_time + ' '\n # TODO: research correct formatting of time, clock_time options\n return inp",
"def format(self) -> str:\n return self._format",
"def format(self) -> str:\n return self._format",
"def getText(self):\r\n return \"\"",
"def value_as_text(self):\n property_name = \"_%s_as_text\" % self.attribute.type\n return getattr(self, property_name, self.value)",
"def get_text_format(self) -> constants.TextFormatStr:\n return constants.TEXT_FORMAT.inverse[self.textFormat()]",
"def getFormattedText(self):\r\n h = \"00\"\r\n m = \"00\"\r\n s = \"00\"\r\n if(self.seconds < 10):\r\n s = \"0\" + str(self.seconds)\r\n else:\r\n s = str(self.seconds)\r\n\r\n if(self.minutes < 10):\r\n m = \"0\" + str(self.minutes)\r\n else:\r\n m = str(self.minutes)\r\n\r\n if(self.hours < 10):\r\n h = \"0\" + str(self.hours)\r\n else:\r\n h = str(self.hours)\r\n\r\n return h + \":\" + m + \":\" + s",
"def get_text(self):\n return self.rule_id + '\\t' + self.rule_text",
"def get_text(self):\n return self.get_property('text')",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def getText():",
"def _get_FIELD_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n template = ''\n template += '{:d}' if field.decimals == 0 else '{:.%sf}' % field.decimals\n template += ' ' if field.spaced_display else ''\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def TEXT(number, format_type):\n raise NotImplementedError()",
"def format(self) -> str:\n return pulumi.get(self, \"format\")",
"def text(self) -> str:\n return self.__text",
"def show(self) -> str:\n return f'[{self.font}]{self.text}[{self.font}]' if self.font else self.text",
"def formatName(self):\r\n return self.title.getVal() + \" \" + self.first.getVal() + \" \" + self.last.getVal()",
"def getText(self):\n return(' '.join(map(lambda x:x.text,self.getNested())))",
"def get_text(self) -> str:\n return self.text",
"def text(self):\n return self.__text",
"def getText(self):",
"def get_text(self):\n return self.text",
"def text(self):\n return ''",
"def get_text(self) -> str:\n return self._text",
"def get_formatted_text(self, n_cols):",
"def text(self) -> str:\n return self._impl.get_text()",
"def format_item_display(self, obj):\n return u\"%s - %s\" % (escape(obj.nombre),obj.rfc)",
"def text(self) -> LocalizedString:\n return self._text",
"def as_text(self) -> str:\n txt = ''\n with self._th_lock:\n # purge expired value (reach ttl_s) from values dict\n purge_l = []\n for key, (_value, _timestamp_ms, expire_at) in self._values_d.items():\n if expire_at and time.monotonic() > expire_at:\n purge_l.append(key)\n for rm_key in purge_l:\n self._values_d.pop(rm_key)\n # if any value exists, format an exposition message\n if self._values_d:\n # add a comment line if defined\n if self.comment:\n # apply escapes to comment\n esc_comment = str(self.comment)\n for rep_args in [('\\\\', '\\\\\\\\'), ('\\n', '\\\\n')]:\n esc_comment = esc_comment.replace(*rep_args)\n txt += f'# HELP {self.name} {esc_comment}\\n'\n # add a type line if defined\n if self.type is not MetricType.UNTYPED:\n txt += f'# TYPE {self.name} {self.type.value}\\n'\n # add every \"name{labels} value [timestamp]\" for the metric\n for lbl_id_str, (value, ts, _expire_at) in self._values_d.items():\n if self._type is MetricType.HISTOGRAM:\n txt += self._data2txt_histogram(lbl_id_str, value)\n elif self._type is MetricType.SUMMARY:\n txt += self._data2txt_summary(lbl_id_str, value)\n else:\n txt += self._data2txt_default(lbl_id_str, value, ts)\n return txt",
"def __str__(self):\n txt = \"%s:\\n\" % self.name\n txt += \" Charge: %.4f\\n\" % self.charge\n txt += \" Radius: %.4f\" % self.radius\n return txt",
"def text(self):\n if self.is_root:\n return ''\n elif self.is_comment:\n return self.__value\n elif self.is_flag:\n if self.__value:\n return '[{0}]'.format(self.name)\n else:\n return '!{0}!'.format(self.name)\n else:\n return '[{0}:{1}]'.format(self.name, self.value)",
"def __repr__(self) -> str:\n return f\"{self.text}\"",
"def formatOutput(self, storedText, titleMode, internal=False):\n prefix = self.prefix\n suffix = self.suffix\n if titleMode:\n if self.html:\n storedText = self.removeMarkup(storedText)\n if globalref.docRef.formHtml:\n prefix = self.removeMarkup(prefix)\n suffix = self.removeMarkup(suffix)\n else:\n if not self.html:\n storedText = escape(storedText).replace('\\n', '<br />')\n if not globalref.docRef.formHtml:\n prefix = escape(prefix)\n suffix = escape(suffix)\n return u'%s%s%s' % (prefix, storedText, suffix)",
"def text(self) -> str:\n return self._text",
"def format(self):\n return self._format",
"def get_formatter(self, **kwargs):\n config = dict([\n (attr, getattr(self, attr))\n for attr in [\n \"include_sign\",\n \"group_with_commas\",\n \"num_decimal_places\",\n ]\n ])\n config.update(kwargs)\n return \"\".join([\n \"{\",\n config.get(\"field_name\", \"\"),\n \":\",\n \"+\" if config[\"include_sign\"] else \"\",\n \",\" if config[\"group_with_commas\"] else \"\",\n \".\", str(config[\"num_decimal_places\"]), \"f\",\n \"}\",\n ])",
"def text(self):\n\n if self.status.full_text:\n return self.status.full_text\n elif self.status.text:\n return self.text\n else:\n return MISSING",
"def to_str(self):\n return self.template.format(\n text_color=self.color.to_str(),\n font_type=self.font_type.to_str(),\n font_weight=self.font_weight.to_str(),\n font_size=self.font_size.to_str()\n )",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def __str__(self):\n return self.text",
"def _text_formatting(bs4_tag):\n return bs4_tag.get_text().replace('\\n', '')",
"def text(self):\n return self.name, self.fontfile, self.fontsize",
"def plain_text(self) -> str:\n return pulumi.get(self, \"plain_text\")",
"def _get_FIELD_humanized_display(self, field):\n value = getattr(self, field.attname)\n if value is None:\n return\n power = max([i for i in utils.POWERS if value // i > 0 and i > 1])\n value /= power\n template = ''\n template += '{:.%sf}' % field.humanized_decimals\n template += ' ' if field.spaced_display else ''\n template += utils.POWERS[power]\n template += '{!s:s}'\n return template.format(value, field.unit)",
"def format( self ) :\n\n return( self.__format )",
"def __repr__(self) -> str:\r\n\r\n saida = \"Format: \"\r\n x = self.getformat()\r\n for _ in range(len(x)):\r\n saida = f\"{saida}{x[_]}\"\r\n if _ < len(x)-1:\r\n saida += \", \"\r\n saida += \"\\n\"\r\n return saida",
"def text(self):\n return self.label.text()",
"def html(self):\n bop = ('<b>' if self._bold else '')\n iop = ('<i>' if self._italic else '')\n icl = ('</i>' if self._italic else '')\n bcl = ('</b>' if self._bold else '')\n txt = escape(self._text)\n s = '%s%s%s%s%s' % (bop, iop, txt, icl, bcl)\n return '%s' % s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title} :\" + s\n\n return s",
"def format_value(text):\n return text.encode('utf8').replace('\\n', ' ').replace('\\r', ' ')",
"def get_text(self):\n logging.getLogger(__name__).info(\"Element text: {}\\nby = {}\\nvalue = {}\".format(\n self.driver.find_element(self.by, self.value).text, self.by, self.value))\n return self.driver.find_element(self.by, self.value).text",
"def get_instance_text(instance):\n values = []\n for fieldname in registry[instance.__class__]:\n values.extend(resolve_field_value(\n [instance], fieldname.split('__')))\n return u' '.join(values)",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n return text",
"def text(self, v=''):\n return str(v)",
"def _to_text(self, value):\n raise NotImplementedError",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def get_as_subtext_field(field, field_title=None) -> str:\n s = \"\"\n if field:\n s = f\"{field} | \"\n else:\n return \"\"\n\n if field_title:\n s = f\"{field_title}: \" + s\n\n return s",
"def __str__(self):\n return self.fmt.format(*self.args, **self.kwargs)",
"def field_display(obj, field):\n return get_field_value(obj, field)",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n return self._text",
"def text(self):\n if hasattr(self,'label'):\n return str(self.label.text())\n else:\n return self.key",
"def __str__(self):\n return self.format()",
"def text(self):\n parts = [(\"%s\" if isinstance(p, Insert) else p) for p in self.parts]\n parts = [(\"%%\" if p == \"%\" else p) for p in parts] # escape percent\n return \"\".join(parts)",
"def Text(self):\n return self._text",
"def __str__(self):\n struct_repr = \", \".join([\n \"type: \" + str(self.type),\n \"text: \" + str(self.text)\n ])\n\n return f\"StatusText: [{struct_repr}]\"",
"def GetText(self):\r\n \r\n return self._text",
"def getText(self):\n return self.text",
"def getText(self):\n return self.text",
"def to_text(self, floatformat: str = \".6f\") -> str:\n return self.val.to_text(floatformat)",
"def __str__(self):\n #Format data from default fields\n template = \"{number:4}|{rep:4}|{time:5}{priority:+2}|\" \\\n \"{record_type:8}|{name:17}\"\n default_fields = template.format(**self)\n \n #Format data from custom fields\n custom_field_list = []\n for label in self.custom_labels:\n custom_field_list.append(\"|{:17}:{!s:<5}\".format(label,\n self[label]))\n custom_fields = \"\".join(custom_field_list)\n \n return default_fields + custom_fields",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def strftime(self, format):\n return \"\"",
"def __str__(self):\n\t\treturn self.text",
"def outputText(self, item, titleMode, internal=False):\n field = None\n while not field:\n item = item.parent\n if item:\n field = item.nodeFormat().findField(self.name)\n else:\n return ''\n return field.outputText(item, titleMode, internal)",
"def format(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"format\")",
"def text(self):\n # type: () -> str\n return self._text",
"def get_text(self):",
"def text(self):\n return self.full_text",
"def __str__(self):\n return \"%s\\n\" % self.text + \" \" * self.col + \"^\"",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% on line \" + self.line\n return text",
"def _entity_as_text(self):\n return str(self.value)",
"def format(self, record):\n message = record.getMessage()\n asctime = self.formatTime(record, self.datefmt)\n name = yellow(record.name)\n\n s = \"%(timestamp)s %(levelname)s %(name)s \" % {\n \"timestamp\": green(\"%s,%03d\" % (asctime, record.msecs), bold=True),\n \"levelname\": self.LEVELS[record.levelname],\n \"name\": name,\n }\n\n if \"\\n\" in message:\n indent_length = len(re_color_codes.sub(\"\", s))\n message = message.replace(\"\\n\", \"\\n\" + \" \" * indent_length)\n\n s += message\n return s",
"def get_text(self):\n # If percentage is zero, round it\n if self.percentage == 0:\n self.percentage = str(\"< 0.01\")\n text = str(self.percentage) + \"% in \" + self.name\n text += \" [\" + self.file_name + \"]\"\n return text",
"def text(self):\n\t\treturn ' '.join([self.write_components[x] for x in self.write_components])"
] | [
"0.75734353",
"0.7379207",
"0.7205578",
"0.68481845",
"0.67844886",
"0.67808527",
"0.67703915",
"0.67703915",
"0.67655444",
"0.6745665",
"0.6687435",
"0.66469747",
"0.6644202",
"0.66413474",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65842545",
"0.65741307",
"0.6567402",
"0.6558896",
"0.6555393",
"0.655068",
"0.6547239",
"0.6544499",
"0.6535529",
"0.6517592",
"0.6480058",
"0.6460372",
"0.6459885",
"0.64553267",
"0.6446324",
"0.6445358",
"0.64076585",
"0.6392125",
"0.6380471",
"0.6367286",
"0.6361198",
"0.6353135",
"0.6348966",
"0.63427186",
"0.6320017",
"0.6318294",
"0.63155836",
"0.6308729",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.6299974",
"0.62890583",
"0.62872475",
"0.6284665",
"0.6283615",
"0.62564605",
"0.62539566",
"0.6250457",
"0.6246106",
"0.6245501",
"0.6238378",
"0.62316114",
"0.62306285",
"0.6227439",
"0.6216431",
"0.6214085",
"0.6207841",
"0.6207841",
"0.62025124",
"0.618629",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6185114",
"0.6184535",
"0.6183745",
"0.6183568",
"0.61735356",
"0.61702335",
"0.61699766",
"0.6169714",
"0.6169714",
"0.6168279",
"0.616314",
"0.6158217",
"0.6158217",
"0.6158217",
"0.6156037",
"0.613794",
"0.6137155",
"0.61364275",
"0.6114419",
"0.61141664",
"0.6103432",
"0.61010504",
"0.6098953",
"0.609143",
"0.60909635",
"0.60876095"
] | 0.0 | -1 |
Returns the statistics of this bot in the current trained status | def get_stats(self):
stats = "\n\nBOT STATS: This bot currently knowns "
if self.intents:
categoryqty = 0
patternqty = 0
responseqty = 0
for intent in self.intents['intents']:
categoryqty += 1
patternqty += len(intent['patterns'])
responseqty += len(intent['responses'])
stats += str(categoryqty)
stats += " Categories with in total "
stats += str(patternqty)
stats += " Input Patterns and "
stats += str(responseqty)
stats += " possible Responses"
stats += "\n\n"
return stats | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_stats(self):\n return self.stats",
"def get_stats(self):\n return utils.csv_to_dict(wait(self.proto.stat()))",
"def get_stats(self):\n return self.manager.get_stats(self)",
"def statistics(self):\n return self.get_statistics()",
"def get_statistics(self):\n train_loss, test_loss = self.learner.get_statistics()\n return train_loss, test_loss, np.mean(self.rewards), np.mean(self.surrogate_losses)",
"def stats(self):\n return self._stats",
"def getStats(self):\n\n raise NotImplementedError",
"def stats(self):\n url = client.build_url('stats')\n _, res_json = client.get(url, headers=self.headers)\n\n return res_json",
"def statistics(self):\n return self._statistics",
"def stats(self):\n resp = self.server.request(\"get\", \"/jobs/%s/%s/stats\" %\n (self.sessionid, self.name))\n return self.server.json_body(resp)",
"def get_statistics(self):\n return self.results",
"async def twitter_status(self, ctx):\n server_channels = set(c.id for c in ctx.message.server.channels)\n\n followed_count = 0\n displayed_count = 0\n for chan_conf in self.conf.follows:\n # Check if this channel is displayed in the server\n if set(c.id for c in chan_conf.discord_channels) & server_channels:\n followed_count += 1\n displayed_count += sum(c.received_count for c in chan_conf.discord_channels if c.id in server_channels)\n\n # Calculate the average tweets processed per minute\n minutes = (time.time() - self.bot.start_time) / 60\n processed_average = self.processed_tweets / minutes\n processed_average = '< 1' if processed_average < 1 else round(processed_average)\n tweets_processed = '{} (avg {} / min)'.format(self.processed_tweets, processed_average)\n\n # Display the info\n if self.stream.running:\n embed = discord.Embed(title='Stream status', description='Online', colour=0x00ff00)\n else:\n embed = discord.Embed(title='Stream status', description='Offline', colour=0xff0000)\n embed.add_field(name='Tweets processed since startup', value=tweets_processed, inline=False)\n embed.add_field(name='Channels followed', value=followed_count)\n embed.add_field(name='Tweets displayed', value=displayed_count)\n\n await self.bot.say(embed=embed)",
"def stats(self):\n pass",
"def stats(self, **kwargs):\n return self.client.api.stats(self.id, **kwargs)",
"async def stats(self, ctx: Message):\n\t\tawait self.open_account(ctx.author.id, ctx.author.username)\n\t\tuserid = ctx.author.id\n\t\tusers = await self.get_stats_data()\n\n\t\trancmds = users[str(userid)][\"rancmd\"]\n\t\txp = users[str(userid)][\"xp\"]\n\t\tmsgs = users[str(userid)][\"sentmsgs\"]\n\t\twhisperto = [ctx.author.id]\n\t\tawait self.send(message=f\"{ctx.author.mention} Here are your stats! • Ran {rancmds} DogeBoss commands • XP: {xp} • Sent {msgs} messages\", whisper=whisperto)",
"def getCurrentStats(self):\n params = {\n 'method': 'getCurrentStats'\n }\n stats = self.request(params)\n if 'error' in stats:\n return False\n\n return stats",
"def get_run_stats(self):\n return self.run_stats",
"async def stats(self, ctx) -> None:\n stats = self.bot.numbers.statistics\n await ctx.send(\n \"\",\n embed=NumEmbed(\n title=\"Number Statistics\",\n colour=0x007E80,\n fields={\n \"Numbers Given\": stats[\"numbers_given\"],\n \"Even Numbers\": stats[\"evens\"],\n \"Odd Numbers\": stats[\"odds\"],\n\n \"Highest Number\": stats[\"highest_info\"],\n \"Lowest Positive\": stats[\"lowest_positive_info\"],\n \"Lowest Number\": stats[\"lowest_info\"],\n\n \"Sum of Numbers\": stats[\"sum\"],\n \"Mean\": stats[\"mean\"],\n \"Median\": stats[\"median\"],\n\n \"Below 500\": stats[\"below_500\"],\n \"Below 1000\": stats[\"below_1000\"],\n \"Below 2500\": stats[\"below_2500\"],\n },\n user=ctx.author,\n ),\n )",
"def get_statistics(self):\n url = \"https://api.imgur.com/3/account/{0}/stats\".format(self.name)\n return self._imgur._send_request(url, needs_auth=True)",
"def stats(self):\n return self.rpc.call(MsfRpcMethod.CoreModuleStats)",
"def get_stats(self): \n return dict(l.split('\\t', 1) \\\n for l in wait(self.proto.stat()).splitlines() if l)",
"def stats(self):",
"def stats(self) -> Dict:\n return self._stats",
"def get_stats(self):\n\n win_points = 0\n lose_points = 0\n\n for username in self.bets:\n bet_for_win, points = self.bets[username]\n if bet_for_win:\n win_points += points\n else:\n lose_points += points\n\n return win_points, lose_points",
"def statistics(self):\n return self._queue.statistics(self._name)",
"def get_health(self):\n return self.bot_client.send_command(_Command.GetHealth)",
"def get_all_stats(self) -> Dict[str, Any]:\n return self.http.get(self.config.paths.stat)",
"def stats(self):\n try:\n slack_id = MENTION_RE.search(self.command_body).groups()[0]\n except AttributeError:\n slack_id = None\n\n if slack_id:\n users = [UserManager.get_by_slack_id(slack_id)]\n else:\n users = self.session.query(User).filter(User.tea_type.isnot(None)).all()\n\n results = []\n\n for user in users:\n results.append({\n 'real_name': user.real_name,\n 'teas_drunk': user.teas_drunk,\n 'teas_brewed': user.teas_brewed,\n 'times_brewed': user.times_brewed,\n 'teas_received': user.teas_received\n })\n\n return post_message('', self.channel, attachments=[\n {\n \"fallback\": \"Teabot Stats\",\n \"pretext\": \"\",\n \"author_name\": \"%s\" % result['real_name'],\n \"fields\": [\n {\n \"value\": \"Number of tea cups consumed -> %(teas_drunk)s\\nNumber of tea cups brewed -> %(teas_brewed)s\\nNumber of times you've brewed tea -> %(times_brewed)s\\nNumber of tea cups you were served -> %(teas_received)s\" % result,\n \"short\": False\n },\n ]\n }\n for result in results\n ])",
"async def skribbl_get_stats(self) -> int:\r\n return await self.read(self._skribbl_get_stats)",
"def base_stats(self):\n return (\n self._get_seconds_played_stats_items()\n + self._get_possessions_played_stats_items()\n )",
"async def status(self, ctx: Context):\n # Get lines of code\n lines_of_code = os.popen(\n r'find . -path ./.venv -prune -false -o -name \"*.py\" -exec cat {} \\; | wc -l').read()\n\n # Get memory usage\n process = psutil.Process(os.getpid())\n memory_usage = process.memory_info().rss / 1024 ** 2\n\n await ctx.send(\n embed=discord.Embed(\n title=f'{self.bot.user.name} Status',\n colour=self.bot.user.colour\n ).set_thumbnail(\n url=self.bot.user.avatar_url\n ).add_field(\n name='Users:', value=len(self.bot.users)\n ).add_field(\n name='Guilds:', value=len(self.bot.guilds)\n ).add_field(\n name='Started at:', value=format_dt(self.bot._start_time)\n ).add_field(\n name='Memory usage:', value=f'{memory_usage:.2f} MB'\n ).add_field(\n name='Cogs loaded:', value=len(self.bot.cogs)\n ).add_field(\n name='Lines of code:', value=lines_of_code or 'Unknown'\n ).add_field(\n name='Quick links:',\n value='[Source Code](https://github.com/bijij/Silvally)',\n inline=False\n )\n )",
"def get_stats(self):\n return {\n \"pings_sent\" : self.ping_count,\n \"measurements\" : self.measurements,\n }",
"def get_profile_stats():\n return p_stats",
"def status(self):\n return self._call_txtrader_api('status', {})",
"def get_statistics(self):\n\t\treturn Job(SDK.PrlSrv_GetStatistics(self.handle)[0])",
"def stats(self, **kwargs):\n return stats.stats(self._host, self._session, **kwargs)",
"def get_stats():\r\n stats = {\r\n \"progress_precent\": 100.0*finished_work_units_amount/work_units_amount,\r\n \"results\": None if work_status == Db.WorkStatusNames.finished_work.value else Db.collect_results(),\r\n #If it's already finished, then all the results were already sent to the main server.\r\n }\r\n return stats",
"def get_stats(self):\n # Retrieve all trainers\n session = self._db_session()\n trainers = []\n regular_trainer_list = session.query(RegularTrainer).filter(\n RegularTrainer.type == \"Regular Trainer\").all()\n for trainer in regular_trainer_list:\n trainers.append(trainer)\n gym_leader_list = session.query(GymLeader).filter(\n GymLeader.type == \"Gym Leader\").all()\n for trainer in gym_leader_list:\n trainers.append(trainer)\n session.close()\n\n num_total_trainers = 0\n num_gym_leaders = 0\n num_regular_trainers = 0\n num_trainers_with_partner = 0\n num_trainer_per_location = {}\n\n for trainer in trainers:\n num_total_trainers += 1\n if trainer.type == 'Regular Trainer':\n num_regular_trainers += 1\n if trainer.have_partner is 1:\n num_trainers_with_partner += 1\n else:\n num_gym_leaders += 1\n\n for trainer in trainers:\n if trainer.location in num_trainer_per_location:\n num_trainer_per_location[trainer.location] += 1\n else:\n num_trainer_per_location.update({trainer.location: 1})\n\n stats_output = TrainerStats(\n num_total_trainers, num_gym_leaders, num_regular_trainers,\n num_trainers_with_partner, num_trainer_per_location)\n\n return stats_output",
"async def getstatuses(self, ctx):\n final_list = \"\"\n statuses = await ex.get_bot_statuses()\n if statuses is not None:\n for status in await ex.get_bot_statuses():\n final_list += f\"{status[0]}\\n\"\n else:\n final_list = \"None\"\n embed = discord.Embed(title=\"Statuses\", description=final_list)\n await ctx.send(embed=embed)",
"def stats(self):\n\n for hero in self.heroes:\n print(\"{} has {} kills and {} deaths.\".format(hero.name, hero.kills, hero.deaths))",
"def server_agent_statistics(ctx):\n data = ctx.obj.get_agent_statistics()\n output_json_data(data)",
"def get_statuses(self):\n return self.statuses",
"def event_stats(self):\n return self.base_stats",
"def get_status(self):\n return str(self.percentage) + \"%\", self.downloaded, self.speed",
"def get_player_stats() -> List[BaseStat]:\n return [BoostStat(),\n PositionalTendencies(),\n Averages(),\n BallDistanceStat(),\n ControlsStat(),\n SpeedTendencies(),\n CarryStat(),\n PerPossessionStat(),\n SpeedTendencies(),\n RumbleItemStat(),\n KickoffStat(),\n DropshotStats(),\n DemoStat()\n ]",
"def metrics(self):\n return self.verificationRun.metrics()",
"def get_stats(self):\n _url = f\"{self.connector.base_url}/projects/{self.project_id}/stats\"\n\n _response = self.connector.http_call(\"get\", _url)\n\n # Update object\n self.stats = _response.json()",
"def get_trading_stats(self):\r\n method = self.public_endpoints['trading_stats']['method']\r\n url = self.base_url + self.public_endpoints['trading_stats']['url']\r\n req = requests.request(method, url)\r\n res = req.json()\r\n\r\n if res['success'] == True:\r\n return res[\"result\"]\r\n else:\r\n return res",
"def get_stats(self):\n return scales.getStats()[self.stats_name]",
"async def status(self, ctx):\n self.logger.info(misolog.format_log(ctx, f\"\"))\n up_time = time.time() - self.start_time\n m, s = divmod(up_time, 60)\n h, m = divmod(m, 60)\n d, h = divmod(h, 24)\n uptime_string = \"%d days %d hours %d minutes %d seconds\" % (d, h, m, s)\n\n stime = time.time() - psutil.boot_time()\n m, s = divmod(stime, 60)\n h, m = divmod(m, 60)\n d, h = divmod(h, 24)\n system_uptime_string = \"%d days %d hours %d minutes %d seconds\" % (d, h, m, s)\n\n mem = psutil.virtual_memory()\n\n pid = os.getpid()\n memory_use = psutil.Process(pid).memory_info()[0]\n\n content = discord.Embed(title=f\"Miso Bot | version {main.version}\")\n content.set_thumbnail(url=self.client.user.avatar_url)\n\n content.add_field(name=\"Bot process uptime\", value=uptime_string)\n content.add_field(name=\"System CPU Usage\", value=f\"{psutil.cpu_percent()}%\")\n content.add_field(name=\"System uptime\", value=system_uptime_string)\n\n content.add_field(name=\"System RAM Usage\", value=f\"{mem.percent}%\")\n content.add_field(name=\"Bot memory usage\", value=f\"{memory_use/math.pow(1024, 2):.2f}MB\")\n\n await ctx.send(embed=content)",
"async def view_stats(self, ctx):\n app_info = await self.bot.application_info()\n total_ram = (psutil.virtual_memory().total >> 30) + 1\n embed = discord.Embed(\n title=\"Bot Stats\",\n description=f\"Running on a dedicated server with {total_ram}GB RAM \\n provided by RandomGhost#0666.\",\n )\n\n embed.add_field(name=\"**__General Info__**\", inline=False, value=\"\\u200b\")\n embed.add_field(name=\"Latency\", value=f\"{self.bot.latency*1000:.03f}ms\")\n embed.add_field(name=\"Guild Count\", value=f\"{len(self.bot.guilds):,}\")\n embed.add_field(name=\"User Count\", value=f\"{len(self.bot.users):,}\")\n\n embed.add_field(name=\"**__Technical Info__**\", inline=False, value=\"\\u200b\")\n embed.add_field(name=\"System CPU Usage\", value=f\"{psutil.cpu_percent():.02f}%\")\n embed.add_field(name=\"System RAM Usage\", value=f\"{psutil.virtual_memory().used/1048576:.02f} MB\")\n embed.add_field(name=\"System Uptime\", value=f\"{timedelta(seconds=int(time.time() - psutil.boot_time()))}\")\n embed.add_field(name=\"Bot CPU Usage\", value=f\"{process.cpu_percent():.02f}%\")\n embed.add_field(name=\"Bot RAM Usage\", value=f\"{process.memory_info().rss / 1048576:.02f} MB\")\n embed.add_field(name=\"Bot Uptime\", value=f\"{timedelta(seconds=int(time.time() - process.create_time()))}\")\n\n embed.add_field(name=\"**__Links__**\", inline=False, value=\"\\u200b\")\n embed.add_field(name=\"Support Server\", value=\"[https://discord.swaglyrics.dev](https://discord.swaglyrics.dev)\")\n embed.add_field(name=\"Invite\", value=\"[https://invite.swaglyrics.dev](https://invite.swaglyrics.dev)\")\n embed.add_field(\n name=\"Source\",\n value=\"[https://swaglyrics.dev/SwagLyrics-Discord-Bot]\" \"(https://swaglyrics.dev/SwagLyrics-discord-bot)\",\n )\n\n embed.set_footer(\n text=f\"Made by {app_info.owner} • {self.bot.get_user(512708394994368548)}\",\n icon_url=[\n app_info.owner.avatar_url_as(size=128),\n self.bot.get_user(512708394994368548).avatar_url_as(size=128),\n ][getrandbits(1)],\n ) # randomize clash or flabbet avatar\n\n await ctx.send(embed=embed)",
"def GetStats(self):\r\n\t\tArg1 = self.href\r\n\t\treturn self._execute('GetStats', payload=locals(), response_object=None)",
"def showUserStats(self) :\n self.getAllStats()\n self.getNbTotalLevelsPlayed()\n Scenario.messageAllStats(self.level_history[0].created_at)\n self.showBestStats()\n self.showWorstStats()\n self.showAverageStats()",
"def get_send_statistics(self):\r\n return self._make_request('GetSendStatistics')",
"async def stats(ctx):\n pythonVersion = platform.python_version()\n dpyVersion = discord.__version__\n serverCount = len(bot.guilds)\n memberCount = len(set(bot.get_all_members()))\n\n embed = discord.Embed(\n title=f\"{bot.user.name} Stats\",\n description=\"\\uFEFF\",\n colour=ctx.author.colour,\n timestamp=ctx.message.created_at,\n )\n\n embed.add_field(name=\"Bot Version:\", value=\"0.0.1\")\n embed.add_field(name=\"Python Version:\", value=pythonVersion)\n embed.add_field(name=\"Discord.Py Version\", value=dpyVersion)\n embed.add_field(name=\"Total Guilds:\", value=serverCount)\n embed.add_field(name=\"Total Users:\", value=memberCount)\n embed.add_field(name=\"Bot Developers:\", value=\"<@271612318947868673>\")\n\n embed.set_footer(text=f\"Carpe Noctem | {bot.user.name}\")\n embed.set_author(name=bot.user.name, icon_url=bot.user.avatar_url)\n\n await ctx.send(embed=embed)",
"async def botinfo(self, ctx):\n\n dev = await self.bot.fetch_user(170506717140877312)\n\n start = perf_counter()\n status_msg = await ctx.send('Beregner ping...')\n end = perf_counter()\n ping = int((end - start) * 1000)\n\n now = time()\n diff = int(now - self.bot.uptime)\n days, remainder = divmod(diff, 24 * 60 * 60)\n hours, remainder = divmod(remainder, 60 * 60)\n minutes, seconds = divmod(remainder, 60)\n\n process = Process(getpid())\n memory_usage = round(process.memory_info().rss / 1000000, 1)\n cpu_percent = process.cpu_percent()\n\n total_members = []\n online_members = []\n idle_members = []\n dnd_members = []\n offline_members = []\n for guild in self.bot.guilds:\n for member in guild.members:\n if member.id in total_members:\n continue\n total_members.append(member.id)\n if str(member.status) == 'online':\n online_members.append(member.id)\n elif str(member.status) == 'idle':\n idle_members.append(member.id)\n elif str(member.status) == 'dnd':\n dnd_members.append(member.id)\n elif str(member.status) == 'offline':\n offline_members.append(member.id)\n\n embed = discord.Embed(color=ctx.me.color, url=self.bot.misc['website'])\n embed.set_author(name=dev.name, icon_url=dev.avatar_url)\n embed.set_thumbnail(url=self.bot.user.avatar_url)\n embed.add_field(name='Dev', value=f'{dev.mention}\\n{dev.name}#{dev.discriminator}')\n embed.add_field(name='Oppetid', value=f'{days}d {hours}t {minutes}m {seconds}s')\n embed.add_field(name='Ping', value=f'Ekte ping: {ping} ms\\nWebsocket ping: {int(self.bot.latency * 1000)} ms')\n embed.add_field(name='Servere', value=len(self.bot.guilds))\n embed.add_field(name='Discord.py', value=discord.__version__)\n embed.add_field(name='Python', value=platform.python_version())\n embed.add_field(name='Ressursbruk', value=f'RAM: {memory_usage} MB\\nCPU: {cpu_percent}%')\n embed.add_field(name='Maskin', value=f'{platform.system()} {platform.release()}')\n embed.add_field(name=f'Brukere ({len(total_members)})',\n value=f'{self.bot.emoji[\"online\"]}{len(online_members)} ' +\n f'{self.bot.emoji[\"idle\"]}{len(idle_members)} ' +\n f'{self.bot.emoji[\"dnd\"]}{len(dnd_members)} ' +\n f'{self.bot.emoji[\"offline\"]}{len(offline_members)}')\n embed.add_field(name='Lenker', value='[Inviter](https://discordapp.com/oauth2/authorize?client_' +\n f'id={self.bot.user.id}&permissions=388174&scope=bot) ' +\n f'| [Nettside]({self.bot.misc[\"website\"]}) ' +\n f'| [Kildekode]({self.bot.misc[\"source_code\"]})')\n await Defaults.set_footer(ctx, embed)\n await status_msg.edit(embed=embed, content=None)",
"def get_status(self):\n r = requests.get(self.base_url + '/status')\n return r.json()",
"def stats(self):\r\n\t\tdata = self._get('global/', query=None)\r\n\t\treturn data",
"def summary_statistics(self):\n display_str = f'--- {self.server_ip} ping statistics ---\\n'\n\n transmitted = str(self.request_count)\n received = str(self.reply_count)\n loss = str(round((1 - self.reply_count / self.request_count) * 100))\n total_time = str(round(self.total_end - self.total_start))\n\n display_str += f'{transmitted} transmitted, {received} received, ' \\\n f'{loss}% loss, time {total_time} ms\\n'\n if self.reply_count:\n rtt_min = str(min(self.rtt_list))\n rtt_avg = str(round(sum(self.rtt_list) / len(self.rtt_list)))\n rtt_max = str(max(self.rtt_list))\n display_str += f'rtt min/avg/max = {rtt_min}/{rtt_avg}/{rtt_max} '\\\n f'ms'\n else:\n display_str += 'rtt min/avg/max = 0/0/0 ms'\n\n return display_str",
"def status(self):\n r = requests.get('/'.join([self.base_url, self.ENDPOINT_STATUS]))\n return r.json()",
"async def generate_leg_statistics(self) -> list:\n\n # General total amount of things\n amount_of_sessions = await self.bot.db.fetchval(\"SELECT COUNT(id) FROM legislature_sessions\")\n amount_of_bills = await self.bot.db.fetchval(\"SELECT COUNT(id) FROM legislature_bills\")\n amount_of_laws = await self.bot.db.fetchval(\"SELECT COUNT(law_id) FROM legislature_laws\")\n amount_of_motions = await self.bot.db.fetchval(\"SELECT COUNT(id) FROM legislature_motions\")\n\n # Sorted statistics by Discord Member\n amount_of_bills_by_submitter = self.count_rows_from_db_record(await self.bot.db.fetch(\"SELECT submitter FROM \"\n \"legislature_bills\"),\n 'submitter')\n amount_of_sessions_by_speaker = self.count_rows_from_db_record(await self.bot.db.fetch(\"SELECT speaker FROM \"\n \"legislature_sessions\"),\n 'speaker')\n query = \"\"\"SELECT submitter FROM legislature_bills AS b WHERE exists (SELECT 1 FROM legislature_laws l\n WHERE l.bill_id = b.id)\"\"\"\n amount_of_laws_by_submitter = self.count_rows_from_db_record(await self.bot.db.fetch(query), 'submitter')\n\n # Prettified sorted statistics by discord.Member\n pretty_top_submitter = self.get_pretty_stats(self.sort_dict_by_value(amount_of_bills_by_submitter), 'bills')\n\n pretty_top_speaker = self.get_pretty_stats(self.sort_dict_by_value(amount_of_sessions_by_speaker), 'sessions')\n\n pretty_top_lawmaker = self.get_pretty_stats(self.sort_dict_by_value(amount_of_laws_by_submitter), 'laws')\n\n return [amount_of_sessions, amount_of_bills, amount_of_laws, amount_of_motions,\n pretty_top_submitter, pretty_top_speaker, pretty_top_lawmaker]",
"def get_stats(self):\n if len(self.customer_agents) > 0:\n waiting = avg([customer.get_waiting_time() for customer in self.customer_agents.values()])\n total = avg(\n [customer.total_time() for customer in self.customer_agents.values() if customer.total_time()])\n else:\n waiting, total = 0, 0\n\n return {\n \"waiting\": \"{0:.2f}\".format(waiting),\n \"totaltime\": \"{0:.2f}\".format(total),\n \"finished\": self.is_simulation_finished(),\n \"is_running\": self.simulation_running,\n }",
"def status():\n aux = {\"Number games\": len(games), \"Path execution\": path_games}\n for j, game in enumerate(games.games_status):\n aux[\"Game \" + str(j)] = game\n return aux",
"def _get_job_status(self):\n total_hits = session.query(BoxHit).filter_by(training_job_id=self.id).count()\n num_hits_left = session.query(BoxHit).filter_by(training_job_id=self.id, outstanding=True).count()\n total_urls = self.num_urls\n num_urls_left = session.query(VideoTrainingURL).filter_by(job=self, processed=False).count()\n faces_obtained = MTurkBox.query.filter_by(label=self.evaluator.target_label, result=True).count()\n return '\\n'.join([\n '------------- Stats for Job ID: %s -------------' % str(self.id) ,\n 'Job for Label : %s' % self.label.name,\n 'Total URLs : %d' % total_urls,\n 'Total HITs : %d' % total_hits,\n 'unprocessed URLS : %d' % num_urls_left,\n 'outstanding Hits : %d' % num_hits_left,\n 'Job Finish Status : %s' % self.finished,\n 'Faces Obtained : %d' % faces_obtained,\n ]) + '\\n'",
"def stats():\n return jsonify(shorten.get_stats(get_db(), app.config['MINI_URL_BASE']))",
"def base_stats(self) -> typing.Dict[StatEnum, int]:\n return self._base_stats",
"def statuses(self):\n big = BigCommerceAPI()\n response = big.get('orderstatuses')\n return response.text",
"def getStats(self):\n if self.type != \"CREATURE\" and self.type != None:\n return\n self.stats = _xmlUrlToDict(serverString + \"/rest/creature/\" + self.id, float)",
"def present_status(self):\n output = ''\n if self.stats['hand']:\n output += 'Ready: \\n'\n for card in sorted(self.stats['hand'], key=itemgetter('name')):\n output += card_format(card) + '\\n'\n output += '\\n'\n if self.stats['active']:\n output += 'Active: \\n'\n for card in self.stats['active']:\n output += card_format(card) + '\\n'\n if self.stats['discard']:\n output += '\\nSpent: \\n'\n for card in self.stats['discard']:\n output += card_format(card) + '\\n'\n output += '\\n'\n output += 'Spells: \\n'\n for power in self.stats['powers']:\n output += '%s x %d\\n' % (power, self.stats['powers'][power])\n if self.stats['opponent']:\n output += '\\nCurrent Activity:\\n'\n output += '%s' % (card_format(self.stats['opponent']))\n header_print('Status')\n print(output)",
"def get_statistics(self):\n\t\treturn Job(SDK.PrlVm_GetStatistics(self.handle)[0])",
"def advancedStats():",
"def get_statistics(self):\n with self._conn.begin():\n stats = dict(\n self._conn.execute(\n \"SELECT * FROM get_statistics()\"\n ).first().items()\n )\n stats['builds_last_hour'] = {\n row.abi_tag: row.builds\n for row in self._conn.execute(\n \"SELECT * FROM get_builds_last_hour()\"\n )\n }\n return stats",
"def insights(self):\r\n return insights.Insights(self)",
"def TableStatistics(self):\n return self._get_attribute('tableStatistics')",
"async def trainer_stats(ctx, user: discord.User):\r\n trainer_data = load_file(file_path_trainer)\r\n user_id = \"{}\".format(user.id)\r\n file = trainer_data[\"Trainers\"][user_id]\r\n trainer = file[\"ID\"]\r\n title = file[\"Title\"]\r\n challenges = str(file[\"Times Challenged\"])\r\n wins = str(file[\"Wins\"])\r\n await bot.say(\"Trainer ID: \" + trainer + \"\\nTitle: \" + title + \"\\nTimes Challenged: \" + challenges +\" \\nWins: \" + wins)",
"async def cmd_stats(self, ctx):\n\n guild = ctx.guild\n members = await guild.fetch_members().flatten()\n answer = f''\n embed = discord.Embed(title=\"Statistiken\",\n description=f'Wir haben aktuell {len(members)} Mitglieder auf diesem Server, verteilt auf folgende Rollen:')\n\n for role in guild.roles:\n if not self.get_key(role):\n continue\n role_members = role.members\n if len(role_members) > 0 and not role.name.startswith(\"Farbe\"):\n embed.add_field(name=role.name, value=f'{len(role_members)} Mitglieder', inline=False)\n\n no_role = 0\n for member in members:\n # ToDo Search for study roles only!\n if len(member.roles) == 1:\n no_role += 1\n\n embed.add_field(name=\"\\u200B\", value=\"\\u200b\", inline=False)\n embed.add_field(name=\"Mitglieder ohne Rolle\", value=str(no_role), inline=False)\n\n await ctx.channel.send(answer, embed=embed)",
"def get_stats(self, **kwargs):\n resp = self.get(_u.build_uri(\"stats\"), kwargs)\n return utils.handle_response(resp)",
"def status(self):\n now = int(time())\n return {\n 'smrt': {\n 'smrt_version': '1.0.0',\n 'app_loaded': True,\n 'uptime': now - self._started\n },\n 'application': {\n 'name': 'Cogsworth',\n 'status': 'OK',\n 'version': '0.0.1'\n },\n 'server_time': now,\n 'status': {\n 'amount_successful': self._requests_successful,\n 'amount_warning': self._requests_warning,\n 'amount_error': self._requests_error,\n 'amount_bad': self._requests_bad,\n 'amount_total': (self._requests_successful\n + self._requests_warning\n + self._requests_error\n + self._requests_bad)\n }\n }",
"def get_team_stats() -> List[BaseStat]:\n return [PossessionStat(),\n TeamTendencies(),\n RelativeTendencies(),\n PerPossessionStat(),\n RumbleItemStat(),\n PreRumbleGoals(),\n DropshotStats()\n ]",
"def statistics(self):\n stats = {'passed': 0, 'failed': 0, 'passed_baseline': 0,\n 'failed_baseline': 0, 'skipped': 0}\n for test in self.cards:\n if test.status == 'passed':\n stats['passed'] += 1\n if test.image_status != 'match':\n stats['failed_baseline'] += 1\n elif test.status == 'failed':\n stats['failed'] += 1\n if test.image_status == 'match':\n stats['passed_baseline'] += 1\n elif test.status == 'skipped':\n stats['skipped'] += 1\n return stats",
"async def stats(self, ctx: commands.Context):\n users = len(self.bot.users)\n guilds = len(self.bot.guilds)\n\n embed = Embed(color=Color.dark_green())\n embed.add_field(name=\"Guilds\", value=guilds)\n embed.add_field(name=\"Users\", value=users)\n embed.set_thumbnail(url=ctx.guild.me.avatar_url)\n\n await ctx.send(embed=embed)",
"def server_stats():\n out = subprocess.check_output(cmd_preamble + [\"admin\", \"stats\"])\n return out.decode()",
"def returnPlayerStats(self):\n\t\tplayerStats = [self.name, \n\t\t\t\t\t self.agility, \n\t\t\t\t\t self.personality, \n\t\t\t\t\t self.sanity, \n\t\t\t\t\t self.strength, \n\t\t\t\t\t self.progress]\n\t\treturn playerStats",
"def get_stats(self):\n self.stats = self.soup.find('table', id='statsTable')",
"def get_status(self):\n # find status\n # search in summary file first\n self.status = \"running\"\n status = self.search_summary(\"status\")\n if status:\n self.status = status.split()[1]\n # define running time\n # search in summary file first\n self.running_time = \"00:00:00\"\n running_time = self.search_summary(\"running-time\")\n if running_time:\n self.running_time = running_time.split()[1]\n # calculate running time\n else:\n now = datetime.datetime.now()\n elapsed_time = (now - self.ctime).seconds\n hours, remainder = divmod(elapsed_time, 3600)\n minutes, seconds = divmod(remainder, 60)\n self.running_time = (\n f\"{int(hours):02}:{int(minutes):02}:{int(seconds):02}\"\n )",
"async def get_stats():\n ret = {}\n counter = 0\n counter_error = 0\n counter_completed = 0\n list_duration = list()\n for j in mngr.transcode_requests:\n counter = counter + 1\n task = mngr.transcode_requests[j]\n if task.state == State.ERROR:\n counter_error = counter_error + 1\n elif task.state == State.COMPLETED:\n counter_completed += 1\n list_duration.append(task.duration)\n\n if not counter_completed:\n percent = 0\n aver = 0\n else:\n percent = np.percentile(np.array(list_duration), np.array(95))\n aver = np.average(np.array(list_duration))\n\n ret[\"completed ratio\"]=float(counter_completed/counter)\n ret[\"duration 95th percentile\"] = percent\n ret[\"average\"] = aver\n\n return ret",
"def stats(self):\r\n return {}",
"def get_batch_stats(self, batch):\n\t\t\n\t\treturn self.batch_stats[batch]",
"def event_stats(self):\n pass",
"def stats(self):\n return self._solution",
"def stats(self):\n return self._solution",
"def stats(self):\n return self._solution",
"def getStcStats(self):\n return (self._totalSentences,\n float(self._totalWords) / float(self._totalSentences))",
"def show_stats(self):\n print(self.team_one.name + \" stats: \")\n self.team_one.stats()\n print(self.team_two.name + \" stats: \")\n self.team_two.stats()",
"def status_counts(self):\n return self._status_counts",
"def get_current_health(self):\n return self.health",
"def get_statuses():\n statuses = list()\n\n for status in tweepy.Cursor(api.user_timeline, id=836104384366936066).items():\n if is_prediction(status):\n statuses.append(status)\n else:\n continue\n\n return statuses",
"def get_summarized_results(self):\n stats = [v.stats() for (k, v) in self.examples.items() if v.is_ready()]\n res = self.ExampleClass.average_stats(stats)\n\n res['loss'] = self.loss/self.loss_cnt\n res['recent_loss'] = sum(self.recent_loss_array) / sum(self.recent_loss_bs_array)\n\n return res",
"def get_health(self):\n return self.health",
"def get_stats(self) -> Dict[str, Any]:\r\n stats = {}\r\n for attr in [attr for attr in self.__dict__ if attr not in Stats.PRINT_IGNORES]:\r\n stats[attr] = self.get_stat(attr)\r\n stats[\"level\"] = self.level\r\n return stats"
] | [
"0.71037495",
"0.7084966",
"0.6931377",
"0.6927751",
"0.6916035",
"0.6905006",
"0.6834757",
"0.67052895",
"0.6688532",
"0.66650486",
"0.66525644",
"0.6650676",
"0.66471237",
"0.6636821",
"0.66244614",
"0.6586594",
"0.6574154",
"0.6523172",
"0.64859945",
"0.64738023",
"0.6458877",
"0.6419824",
"0.6388401",
"0.63747346",
"0.63508016",
"0.63434225",
"0.6340269",
"0.6331783",
"0.632498",
"0.6317226",
"0.6305874",
"0.62972015",
"0.62947786",
"0.62464255",
"0.6242397",
"0.62340415",
"0.6227448",
"0.6214561",
"0.6212179",
"0.6192473",
"0.6180871",
"0.61791396",
"0.6159114",
"0.6151301",
"0.61492074",
"0.6146456",
"0.6143203",
"0.61280006",
"0.6126288",
"0.611293",
"0.6109915",
"0.6090582",
"0.6083171",
"0.60774714",
"0.6076649",
"0.6062499",
"0.6054348",
"0.6053813",
"0.6033937",
"0.6023372",
"0.6023371",
"0.6013298",
"0.59704775",
"0.59592456",
"0.5952395",
"0.59493756",
"0.5945832",
"0.5942782",
"0.59408945",
"0.5929167",
"0.5920313",
"0.59199",
"0.5911114",
"0.58900684",
"0.5877058",
"0.58751535",
"0.58670133",
"0.5866488",
"0.5865893",
"0.5856574",
"0.5853825",
"0.5853727",
"0.5851028",
"0.58432",
"0.5815352",
"0.58140826",
"0.58041275",
"0.5799508",
"0.5794736",
"0.57931185",
"0.57931185",
"0.57931185",
"0.5790913",
"0.57907057",
"0.5784785",
"0.5783132",
"0.5774628",
"0.577106",
"0.57575524",
"0.5751036"
] | 0.69746816 | 2 |
Interpolates between two vectors that are nonzero and don't both lie on a line going through origin. First normalizes v2 to have the same norm as v1. Then interpolates between the two vectors on the hypersphere. | def interpolate_hypersphere(v1, v2, num_steps):
v1_norm = tf.norm(v1)
v2_norm = tf.norm(v2)
v2_normalized = v2 * (v1_norm / v2_norm)
vectors = []
for step in range(num_steps):
interpolated = v1 + (v2_normalized - v1) * step / (num_steps - 1)
interpolated_norm = tf.norm(interpolated)
interpolated_normalized = interpolated * (v1_norm / interpolated_norm)
vectors.append(interpolated_normalized)
return tf.stack(vectors) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersectionOfTwoLines(p1, v1, p2, v2):\n # if we transform multiple points in one go\n if len(v1.shape) == 2:\n a1 = np.einsum('ij,ij->i', v1, v1)\n a2 = np.einsum('ij,ij->i', v1, v2)\n b1 = -np.einsum('ij,ij->i', v2, v1)\n b2 = -np.einsum('ij,ij->i', v2, v2)\n c1 = -np.einsum('ij,j->i', v1, p1 - p2)\n c2 = -np.einsum('ij,j->i', v2, p1 - p2)\n res = np.linalg.solve(np.array([[a1, b1], [a2, b2]]).transpose(2, 0, 1), np.array([c1, c2]).T)\n res = res[:, None, :]\n return np.mean([p1 + res[..., 0] * v1, p2 + res[..., 1] * v2], axis=0)\n else: # or just one point\n a1 = np.dot(v1, v1)\n a2 = np.dot(v1, v2)\n b1 = -np.dot(v2, v1)\n b2 = -np.dot(v2, v2)\n c1 = -np.dot(v1, p1 - p2)\n c2 = -np.dot(v2, p1 - p2)\n try:\n res = np.linalg.solve(np.array([[a1, b1], [a2, b2]]), np.array([c1, c2]))\n except np.linalg.LinAlgError:\n return np.ones(3)*np.nan\n res = res[None, None, :]\n return np.mean([p1 + res[..., 0] * v1, p2 + res[..., 1] * v2], axis=0)[0]",
"def intersect_2_lines(P1, V1, P2, V2):\n Vx = np.cross(V1, V2)\n s = np.dot(np.cross(P2 - P1, V1), Vx)/np.dot(Vx, Vx)\n return s",
"def distanceOfTwoLines(p1, v1, p2, v2):\n # if we transform multiple points in one go\n if len(v1.shape) == 2:\n a1 = np.einsum('ij,ij->i', v1, v1)\n a2 = np.einsum('ij,ij->i', v1, v2)\n b1 = -np.einsum('ij,ij->i', v2, v1)\n b2 = -np.einsum('ij,ij->i', v2, v2)\n c1 = -np.einsum('ij,j->i', v1, p1 - p2)\n c2 = -np.einsum('ij,j->i', v2, p1 - p2)\n res = np.linalg.solve(np.array([[a1, b1], [a2, b2]]).transpose(2, 0, 1), np.array([c1, c2]).T)\n res = res[:, None, :]\n return np.linalg.norm((p1 + res[..., 0] * v1) - (p2 + res[..., 1] * v2), axis=1)\n else: # or just one point\n a1 = np.dot(v1, v1)\n a2 = np.dot(v1, v2)\n b1 = -np.dot(v2, v1)\n b2 = -np.dot(v2, v2)\n c1 = -np.dot(v1, p1 - p2)\n c2 = -np.dot(v2, p1 - p2)\n try:\n res = np.linalg.solve(np.array([[a1, b1], [a2, b2]]), np.array([c1, c2]))\n except np.linalg.LinAlgError:\n return 0\n res = res[None, None, :]\n return np.linalg.norm((p1 + res[..., 0] * v1) - (p2 + res[..., 1] * v2), axis=1)[0]",
"def intersection(v1, v2):\n x = v1[0:2] + v2[0:2]\n y = v1[2:4] + v2[2:4]\n if( x[3] == 0 ): #To avoid a divide by zero, if x[3] is 0 then we just solve for where lineA equals x[2]\n t1 = (x[2] - x[0])/\\\n (x[1])\n return [ v1[0] + v1[1]*t1, v1[2] + v1[3]*t1 ]\n\n else: \n t1 = ( y[0] - y[2] + (y[3]/x[3])*(x[2] - x[0]) )/\\\n ( (y[3]*x[1])/x[3] - y[1] )\n return [ v1[0] + v1[1]*t1, v1[2] + v1[3]*t1 ]",
"def make_q(v0, v2):\n return (v0.y - v2.y)/(v0.x - v2.x)",
"def linear_interpolate(x, x0, y0, x1, y1):\n try:\n return (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0)\n except ZeroDivisionError:\n return 0.0",
"def __init__(self,v0,v1):\n self.vinputs = v0,v1\n self.xhi = max([v0[0],v1[0]])\n self.yhi,self.ylo = v0[1]>v1[1] and (v0[1],v1[1],) or (v1[1],v0[1])\n\n self.m = (v1[0]-v0[0]) / (v1[1]-v0[1]) ### (x1-x0)/(y1-y0)\n self.b = v0[0] - (v0[1] * self.m) ### x0 - y0*(x1-x0)/(y1-y0)",
"def vincenty(lat1, lon1, lat2, lon2,\n r_major=6378.1370, r_minor=6356.752314, r_sphere=None):\n lat1 = m.radians(lat1)\n lat2 = m.radians(lat2)\n lon1 = m.radians(lon1)\n lon2 = m.radians(lon2)\n \n if (r_sphere is not None):\n r_major = r_sphere\n r_minor = r_sphere\n f = 0.0\n else:\n f = (r_major-r_minor)/r_major\n \n U1 = m.atan((1.0-f) * m.tan(lat1))\n U2 = m.atan((1.0-f) * m.tan(lat2))\n L = lon2 - lon1\n \n epsilon = 1E-12 # Accuracy (10E-12 -> ~ 0.06mm)\n max_iter = 500\n lam = L\n \n cU1 = m.cos(U1)\n cU2 = m.cos(U2)\n sU1 = m.sin(U1)\n sU2 = m.sin(U2)\n \n for i in range(max_iter):\n lam_old = lam\n sLam = m.sin(lam)\n cLam = m.cos(lam)\n sin_sig = m.sqrt((cU2*sLam)**2 + (cU1*sU2 - sU1*cU2*cLam)**2)\n cos_sig = sU1*sU2 + cU1*cU2*cLam\n sig = m.atan2(sin_sig,cos_sig)\n sin_alp = (cU1*cU2*sLam) / sin_sig\n cos2_alp = 1.0 - sin_alp**2\n if (cos2_alp == 0.0):\n # equitorial line\n cos_2sigm = 100\n C = 0.0\n else:\n cos_2sigm = cos_sig - (2.0*sU1*sU2)/cos2_alp\n C = f/16.0 * cos2_alp * (4.0 + f*(4.0-3.0*cos2_alp))\n lam = L + (1.0 - C) * f * sin_alp * \\\n (sig + C * sin_sig * (cos_2sigm + C * cos_sig * \\\n (-1.0 + 2.0 * cos_2sigm**2)))\n if ((m.fabs(lam - lam_old)) <= epsilon):\n # Found a solution in i iters...\n break\n elif (i == max_iter):\n # Catch the out of iters case, never seen this.\n raise Exception(\"Failed to solve for distance\")\n \n usq = cos2_alp * ((r_major**2 - r_minor**2) / r_minor**2)\n A = 1 + usq/16384 * (4096 + usq*(-768 + usq*(320 - 175*usq)))\n B = usq/1024 * (256 + usq*(-128 + usq*(74 - 47*usq)))\n del_sig = B * sin_sig * (cos_2sigm + 0.25*B*(cos_sig*( \\\n -1 + 2*cos_2sigm**2) - (1.0/6.0)*B*cos_2sigm * ( \\\n -3 + 4*sin_sig**2) * (-3 + 4 * cos_2sigm**2)))\n s = r_minor * A * (sig - del_sig)\n alp1 = m.atan2(cU2*m.sin(lam),(cU1*sU2-sU1*cU2*m.cos(lam)))\n alp2 = m.atan2(cU1*m.sin(lam),(cU1*sU2*m.cos(lam)-sU1*cU2))\n\n return (s, m.degrees(alp1), m.degrees(alp2))",
"def nor_vector(p1: Vec2, p2: Vec2) -> Vec2:\n return Vec2(p1.y - p2.y, p2.x - p1.x)",
"def midpoint_line(a, b):\n return scale_vector(add_vectors(a, b), 0.5)",
"def _LinearInterpolate(x0, target, x1, y0, y1):\n if x0 == x1:\n return (y0 + y1) / 2\n return (y1 - y0) * (target - x0) / (x1 - x0) + y0",
"def planeLineIntersect(p1, p2, equ):\n n = vector(equ[0], equ[1], equ[2])\n v1, v2 = vector(p1), vector(p2)\n t = (equ[3] - n.dotProduct(v2)) / (n.dotProduct(v1 - v2))\n return (t * v1 + (1 - t) * v2).coords()",
"def test_from_two_vectors(self):\r\n for _ in range(20):\r\n v0 = np.random.randn(3)\r\n v1 = np.random.randn(3)\r\n v0 /= np.linalg.norm(v0)\r\n v1 /= np.linalg.norm(v1)\r\n\r\n q = from_two_vectors(v0, v1)\r\n R = to_rotation(q)\r\n\r\n zero_vec = R @ v0 - v1\r\n self.assertAlmostEqual(np.linalg.norm(zero_vec), 0.0)\r\n\r\n q_inv = from_two_vectors(v1, v0)\r\n R_inv = to_rotation(q_inv)\r\n zero_matrix = R @ R_inv - np.identity(3)\r\n self.assertAlmostEqual(np.linalg.norm(zero_matrix), 0.0)",
"def projection(v1, v2):\n v1 = v1.astype(np.float64)\n\n if np.any(v1):\n result = (np.dot(v1, v2) / np.dot(v1, v1)) * v1\n else:\n result = np.zeros(3)\n\n return result",
"def cross(v1: Vec2, v2: Vec2) -> float:\n return v1.x * v2.x + v1.y * v2.y",
"def intersection(line1, line2):\n p0, p1, p2, p3 = map(\n lambda tup : np.array(tup[:2]),\n [line1[0], line1[1], line2[0], line2[1]]\n )\n p1, p2, p3 = map(lambda x : x - p0, [p1, p2, p3])\n transform = np.zeros((2, 2))\n transform[:,0], transform[:,1] = p1, p2\n if np.linalg.det(transform) == 0: return\n inv = np.linalg.inv(transform)\n new_p3 = np.dot(inv, p3.reshape((2, 1)))\n #Where does line connecting (0, 1) to new_p3 hit x axis\n x_intercept = new_p3[0] / (1 - new_p3[1]) \n result = np.dot(transform, [[x_intercept], [0]])\n result = result.reshape((2,)) + p0\n return result",
"def two_norm(v):\n return math.sqrt(dot_product(v, v))",
"def mirror_vector_vector(v1, v2):\n return subtract_vectors(v1, scale_vector(v2, 2 * dot_vectors(v1, v2)))",
"def sweptAABB(b1, b2):\n\tnormalX = 0;\n\tnormalY = 0;\n\n\t\"\"\"\n\tfloat xInvEntry, yInvEntry;\n\tfloat xInvExit, yInvExit;\n\n\t// find the distance between the objects on the near and far sides for both x and y\n\tif (b1.vx > 0.0f) {\n\t\txInvEntry = b2.x - (b1.x + b1.w);\n\t\txInvExit = (b2.x + b2.w) - b1.x;\n\t} else {\n\t\txInvEntry = (b2.x + b2.w) - b1.x;\n\t\txInvExit = b2.x - (b1.x + b1.w);\n\t}\n\n\tif (b1.vy > 0.0f) {\n\t\tyInvEntry = b2.y - (b1.y + b1.h);\n\t\tyInvExit = (b2.y + b2.h) - b1.y;\n\t} else {\n\t\tyInvEntry = (b2.y + b2.h) - b1.y;\n\t\tyInvExit = b2.y - (b1.y + b1.h);\n\t}\n\t\"\"\"\n\n\txInvEntry = 0;\n\tyInvEntry = 0;\n\txInvExit = 0;\n\tyInvExit = 0;\n\n\tif (b1.vx > 0):\n\t\txInvEntry = b2.x - (b1.x + b1.w);\n\t\txInvExit = (b2.x + b2.w) - b1.x;\n\telse:\n\t\txInvEntry = (b2.x + b2.w) - b1.x;\n\t\txInvExit = b2.x - (b1.x + b1.w);\n\t\n\n\tif (b1.vy > 0):\n\t\tyInvEntry = b2.y - (b1.y + b1.h);\n\t\tyInvExit = (b2.y + b2.h) - b1.y;\n\telse:\n\t\tyInvEntry = (b2.y + b2.h) - b1.y;\n\t\tyInvExit = b2.y - (b1.y + b1.h);\n\n\t\"\"\"\n\t// find time of collision and time of leaving for each axis (if statement is to prevent divide by zero)\n\tfloat xEntry, yEntry;\n\tfloat xExit, yExit;\n\n\tif (b1.vx == 0.0f) {\n\t\txEntry = -std::numeric_limits<float>::infinity();\n\t\txExit = std::numeric_limits<float>::infinity();\n\t} else {\n\t\txEntry = xInvEntry / b1.vx;\n\t\txExit = xInvExit / b1.vx;\n\t}\n\n\tif (b1.vy == 0.0f) {\n\t\tyEntry = -std::numeric_limits<float>::infinity();\n\t\tyExit = std::numeric_limits<float>::infinity();\n\t} else {\n\t\tyEntry = yInvEntry / b1.vy;\n\t\tyExit = yInvExit / b1.vy;\n\t}\n\t\"\"\"\n\txEntry = 0;\n\tyEntry = 0;\n\txExit = 0;\n\tyExit = 0;\n\n\tif (b1.vx == 0):\n\t\txEntry = -float(\"inf\");\n\t\txExit = float(\"inf\");\n\telse:\n\t\txEntry = xInvEntry / b1.vx;\n\t\txExit = xInvExit / b1.vx;\n\n\tif (b1.vy == 0):\n\t\tyEntry = -float(\"inf\");\n\t\tyExit = float(\"inf\");\n\telse:\n\t\tyEntry = yInvEntry / b1.vy;\n\t\tyExit = yInvExit / b1.vy;\n\t\n\tif (yEntry > 1):\n\t\tyEntry = -float(\"inf\");\n\tif (xEntry > 1):\n\t\txEntry = -float(\"inf\");\n\n\n\t\"\"\"\n\t// find the earliest/latest times of collision\n\tfloat entryTime = std::max(xEntry, yEntry);\n\tfloat exitTime = std::min(xExit, yExit);\n\t\"\"\"\n\n\tentryTime = max(xEntry, yEntry);\n\texitTime = min(xExit, yExit);\n\n\t\"\"\"\n\t// if there was no collision\n\tif (entryTime > exitTime || xEntry < 0.0f && yEntry < 0.0f || xEntry > 1.0f || yEntry > 1.0f) {\n\t\tnormalX = 0.0f;\n\t\tnormalY = 0.0f;\n\t\treturn 1.0f;\n\t} else {\n\t\t// if there was a collision\n\t\t// calculate normal of collided surface\n\t\tif (xEntry > yEntry) {\n\t\t\tif (xInvEntry < 0.0f) {\n\t\t\t\tnormalX = 1.0f;\n\t\t\t\tnormalY = 0.0f;\n\t\t\t} else {\n\t\t\t\tnormalX = -1.0f;\n\t\t\t\tnormalY = 0.0f;\n\t\t\t}\n\t\t} else {\n\t\t\tif (yInvEntry < 0.0f) {\n\t\t\t\tnormalX = 0.0f;\n\t\t\t\tnormalY = 1.0f;\n\t\t\t} else {\n\t\t\t\tnormalX = 0.0f;\n\t\t\t\tnormalY = -1.0f;\n\t\t\t}\n\t\t}\n\n\t\t// return the time of collision\n\t\treturn entryTime;\n\t}\n\t\"\"\"\n\n\t\"\"\"\n\tif (entryTime > exitTime)\n\t\treturn 1.0f; // This check was correct.\n\tif (entryX < 0.0f && entryY < 0.0f)\n\t\treturn 1.0f;\n\tif (entryX < 0.0f) {\n\t\t// Check that the bounding box started overlapped or not.\n\t\tif (s.max.x < t.min.x || s.min.x > t.max.x)\n\t\t\treturn 1.0f;\n\t}\n\tif (entryY < 0.0f) {\n\t\t// Check that the bounding box started overlapped or not.\n\t\tif (s.max.y < t.min.y || s.min.y > t.max.y)\n\t\t\treturn 1.0f;\n\t}\"\"\"\n\n\n\t# if (entryTime > exitTime or xEntry < 0 and yEntry < 0 or xEntry > 1 or yEntry > 1):\n\t# \tnormalX = 0;\n\t# \tnormalY = 0;\n\t# \treturn (1, (normalX, normalY));\n\t# else:\n\n\tnormalX = 0;\n\tnormalY = 0;\n\n\tif (entryTime > exitTime):\n\t\treturn (1, (0, 0));\n\t\n\tif (xEntry < 0 and yEntry < 0):\n\t\treturn (1, (0, 0));\n\n\tif (xEntry < 0):\n\t\tif (b1.x + b1.w < b2.x or b1.x > b2.x + b2.w):\n\t\t\treturn (1, (0, 0));\n\n\tif (yEntry < 0):\n\t\tif (b1.y + b1.h < b2.y or b1.y > b2.y + b2.h):\n\t\t\treturn (1, (0, 0));\n\n\tif (xEntry > yEntry):\n\t\tif (xInvEntry < 0):\n\t\t\tnormalX = 1;\n\t\t\tnormalY = 0;\n\t\telse:\n\t\t\tnormalX = -1;\n\t\t\tnormalY = 0;\n\telse:\n\t\tif (yInvEntry < 0):\n\t\t\tnormalX = 0;\n\t\t\tnormalY = 1;\n\t\telse:\n\t\t\tnormalX = 0;\n\t\t\tnormalY = -1;\n\n\treturn (entryTime, (normalX, normalY));",
"def normalize_vector(v1):\n #this gets the vector length\n vector_length = get_vector_norm(v1)\n \n #divides each coordinate of the vector by its norm\n for key in v1:\n v1[key] = v1[key]/ vector_length",
"def InterpolateSurfaceVectorsWithLine():\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, PointData, PolygonData = CreateMatrixVTK(VTKString)\r\n Centroids1,Vectors1 = ElementNormal(PointData,PolygonData)\r\n # Load full volume centroid\r\n NCF_Str = OpenData(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles\",\"new_centroids_file.dat\")\r\n HeaderNCF,Centroids2 = CreateMatrixDat(NCF_Str)\r\n print('Loading Finished \\n Inserting Centre Line...')\r\n # Create Plane of vectors through centreline.\r\n PlaneCentroids,PlaneVectors = InsertCentreLine(Centroids1,Vectors1,50)\r\n print('Centre Line Inserted \\n Interpolating Centroids...')\r\n # Interpolate Vectors\r\n Vectors2 = VectorInter(PlaneCentroids,PlaneVectors,Centroids2)\r\n # Make the data more sparse to display better.\r\n C1,V1 = SparseData(PlaneCentroids,PlaneVectors,0.1)\r\n C2,V2 = SparseData(Centroids2,Vectors2,0.1)\r\n print('Interpolation Finished \\n Plotting...')\r\n # Plot Data\r\n fig = plt.figure()\r\n\r\n ax1 = fig.add_subplot(121,projection = '3d')\r\n DisplaySliceVectors(C1,V1,ax1,5,10)\r\n\r\n ax2 = fig.add_subplot(122,projection = '3d')\r\n DisplaySliceVectors(C2,V2,ax2,5,10)\r\n\r\n plt.show()\r\n\r\n header = 'TITLE = \\\"Normal Surface Vectors With Central axis Line\\\"\\nVARIABLES = \\\"XV\\\", \\\"YV\\\", \\\"ZV\\\" \\nZONE T=\\\"Step 0 Incr 0\\\" \\nF = VECTORS'\r\n\r\n np.savetxt(\"C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/OutputFiles/SurfaceLineVectorInterpolation.dat\",Vectors2,header = header,comments='')",
"def dist_vincenty(lat1, lon1, lat2, lon2, iterations=20):\r\n if lat1 < -90 or lat1 > 90 or lat2 < -90 or lat2 > 90 or lon1 < -180 or lon1 > 180 or lon2 < -180 or lon2 > 180:\r\n raise ValueError(\r\n \"Latitude values shoulds range from (-90,90) and longitude from (-180,180) but one of the input values is out of bounds. Latitude_1: %f, Logitude_1: %f, Latitude_2: %f, Logitude_2: %f\" %\r\n (lat1, lon1, lat2, lon2))\r\n\r\n major, minor, f = 6378137, 6356752.314245, 1 / 298.257223563\r\n\r\n lat1, lng1, lat2, lng2 = radians(\r\n lat1), radians(lon1), radians(lat2), radians(lon2)\r\n delta_lng = lng2 - lng1\r\n reduced_lat1, reduced_lat2 = atan(\r\n (1 - f) * tan(lat1)), atan((1 - f) * tan(lat2))\r\n\r\n sin_reduced1, cos_reduced1 = sin(reduced_lat1), cos(reduced_lat1)\r\n sin_reduced2, cos_reduced2 = sin(reduced_lat2), cos(reduced_lat2)\r\n\r\n lambda_lng = delta_lng\r\n lambda_prime = 2 * pi\r\n while abs(lambda_lng - lambda_prime) > 10e-12 and iterations > 0:\r\n sin_lambda_lng, cos_lambda_lng = sin(lambda_lng), cos(lambda_lng)\r\n\r\n sin_sigma = sqrt(\r\n (cos_reduced2 * sin_lambda_lng) ** 2 +\r\n (cos_reduced1 * sin_reduced2 -\r\n sin_reduced1 * cos_reduced2 * cos_lambda_lng) ** 2\r\n )\r\n if sin_sigma == 0:\r\n return 0 # Coincident points\r\n\r\n cos_sigma = (\r\n sin_reduced1 * sin_reduced2 +\r\n cos_reduced1 * cos_reduced2 * cos_lambda_lng\r\n )\r\n sigma = atan2(sin_sigma, cos_sigma)\r\n\r\n sin_alpha = (cos_reduced1 * cos_reduced2 * sin_lambda_lng / sin_sigma)\r\n cos_sq_alpha = 1 - sin_alpha ** 2\r\n\r\n if cos_sq_alpha != 0:\r\n cos2_sigma_m = cos_sigma - 2 * \\\r\n (sin_reduced1 * sin_reduced2 / cos_sq_alpha)\r\n else:\r\n cos2_sigma_m = 0.0 # Equatorial line\r\n\r\n C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha))\r\n\r\n lambda_prime = lambda_lng\r\n lambda_lng = (\r\n delta_lng + (1 - C) * f * sin_alpha * (\r\n sigma + C * sin_sigma * (\r\n cos2_sigma_m + C * cos_sigma * (-1 + 2 * cos2_sigma_m ** 2)\r\n )\r\n )\r\n )\r\n iterations -= 1\r\n\r\n if iterations == 0:\r\n raise ValueError(\"Vincenty formula failed to converge!\")\r\n\r\n u_sq = cos_sq_alpha * (major ** 2 - minor ** 2) / minor ** 2\r\n A = 1 + u_sq / 16384. * (4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)))\r\n B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq)))\r\n delta_sigma = B * sin_sigma * (\r\n cos2_sigma_m + B / 4. * (cos_sigma * (-1 + 2 * cos2_sigma_m ** 2) -\r\n B / 6. * cos2_sigma_m * (-3 + 4 * sin_sigma ** 2) *\r\n (-3 + 4 * cos2_sigma_m ** 2))\r\n )\r\n s = minor * A * (sigma - delta_sigma)\r\n\r\n return round(s, 3) # round to 1mm precision\r",
"def line_sphere_intersection(p1, p2, c, r):\n\t# FILL in your code here\n\n\tline_vector=np.subtract(p2,p1) #np.array([p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2] ])\n\tval=np.sqrt(np.sum([(p2 - p1)**2\n\t\t\t\t\t\t for p1, p2 in zip(p1,p2)]))\n\n\tif val==0:\n\t\tunit_vector=np.array([0,0,0])\n\telse:\n\t\tunit_vector=[linevec/val for linevec in line_vector]\n\tvecO_C=np.subtract(p1,c)\n\t\t\n\tres=np.dot(unit_vector,vecO_C)* np.dot(unit_vector,vecO_C) - ( np.dot(vecO_C, vecO_C) - r*r )\n\treturn res",
"def linear_triangulation(p1, p2, m1, m2):\n num_points = p1.shape[1]\n res = np.ones((4, num_points))\n\n for i in range(num_points):\n A = np.asarray([\n (p1[0, i] * m1[2, :] - m1[0, :]),\n (p1[1, i] * m1[2, :] - m1[1, :]),\n (p2[0, i] * m2[2, :] - m2[0, :]),\n (p2[1, i] * m2[2, :] - m2[1, :])\n ])\n\n _, _, V = np.linalg.svd(A)\n X = V[-1, :4]\n res[:, i] = X / X[3]\n\n return res",
"def is_linearly_independent_2x2(u, v):\n uv = get_uv(u, v)\n if uv[0][0] * uv[1][1] - uv[1][0] * uv[0][1] != 0:\n return True\n else:\n return False",
"def solve(self, v1, v0, normalize=False):\n if normalize:\n dv = -(v1 - v0)/v0\n else:\n dv = v1 - v0\n return -np.dot(self.H, dv)",
"def distance(v1: Union[np.ndarray, np.iterable, int, float], v2: Union[np.ndarray, np.iterable, int, float],\n normalised=True) -> float:\n return 1 - np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)) if not normalised else 1 - np.dot(v1, v2)",
"def interpolV(y, x, newX):\r\n \r\n num = len(x)\r\n #if (num != len(y)):\r\n #//System.out.println(\"Toolbox.interpolV(): Old x and y must be same length\"); \r\n \r\n newNum = len(newX)\r\n #//System.out.println(\"interpolV: newNum \" + newNum + \" num \" + num); \r\n #newY = [0.0 for i in range(newNum)]\r\n\r\n#//Renormalize ordinates:\r\n \r\n iMinAndMax = minMax(y)\r\n norm = y[iMinAndMax[1]]\r\n #//System.out.println(\"norm \" + norm);\r\n #yNorm = [0.0 for i in range(num)]\r\n newYNorm = [0.0 for i in range(newNum)] \r\n #for i in range(num):\r\n # yNorm[i] = y[i] / norm \r\n yNorm = [ x / norm for x in y ]\r\n\r\n#// Set any newX elements that are *less than* the first x element to th first \r\n#// x element - \"0th order extrapolation\"\r\n#//\r\n start = 0\r\n for i in range(newNum):\r\n if (newX[i] <= x[1]):\r\n newYNorm[i] = yNorm[0]\r\n start += 1\r\n \r\n if (newX[i] > x[1]):\r\n break\r\n \r\n \r\n#//System.out.println(\"start \" + start);\r\n#//System.out.println(\"x[0] \" + x[0] + \" x[1] \" + x[1] + \" newX[start] \" + newX[start]);\r\n#double jWght, jm1Wght, denom;\r\n\r\n\r\n if (start < newNum-1):\r\n\r\n j = 1 #//initialize old abscissae index\r\n #//outer loop over new abscissae\r\n for i in range(start, newNum):\r\n\r\n #//System.out.println(\"i \" + i + \" j \" + j);\r\n\r\n#// break out if current element newX is *greater* that last x element\r\n if ( (newX[i] > x[num-1]) or (j > (num-1)) ):\r\n break \r\n \r\n\r\n while (x[j] < newX[i]): \r\n j += 1\r\n \r\n #//System.out.println(\"i \" + i + \" newX[i] \" + newX[i] + \" j \" + j + \" x[j-1] \" + x[j-1] + \" x[j] \" + x[j]);\r\n #//1st order Lagrange method:\r\n jWght = newX[i] * (1.0 - (x[j-1]/newX[i])) #//(newX[i]-x[j-1])\r\n jm1Wght = x[j] * (1.0 - (newX[i]/x[j])) #//(x[j]-newX[i])\r\n denom = x[j] * (1.0 - (x[j-1]/x[j])) #//(x[j]-x[j-1])\r\n jWght = jWght / denom\r\n jm1Wght = jm1Wght / denom\r\n #//newYNorm[i] = (yNorm[j]*(newX[i]-x[j-1])) + (yNorm[j-1]*(x[j]-newX[i]));\r\n newYNorm[i] = (yNorm[j]*jWght) + (yNorm[j-1]*jm1Wght)\r\n #//System.out.println(\"i \" + i + \" newYNorm[i] \" + newYNorm[i] + \" j \" + j + \" yNorm[j-1] \" + yNorm[j-1] + \" yNorm[j] \" + yNorm[j]);\r\n \r\n\r\n#// Set any newX elements that are *greater than* the first x element to the last \r\n#// x element - \"0th order extrapolation\"\r\n#//\r\n for i in range(newNum):\r\n if (newX[i] >= x[num-1]):\r\n newYNorm[i] = yNorm[num-1]\r\n \r\n \r\n\r\n #//Restore orinate scale\r\n #for i in range(newNum):\r\n # newY[i] = newYNorm[i] * norm \r\n newY = [ x * norm for x in newYNorm ]\r\n\r\n\r\n return newY",
"def dist_2D(v1, v2):\n return ((v1[0]-v2[0])**2 + (v1[1]-v2[1])**2 )**(0.5)",
"def calculate_velocity_induced_by_line_vortices(\n points, origins, terminations, strengths, collapse=True\n):\n\n # Expand the dimensionality of the points input. It is now of shape (N x 1 x 3). This will allow numpy to\n # broadcast the upcoming subtractions.\n points = np.expand_dims(points, axis=1)\n\n # Define the vectors from the vortex to the points. r_1 and r_2 now both are of shape (N x M x 3). Each row/column\n # pair holds the vector associated with each point/vortex pair.\n r_1 = points - origins\n r_2 = points - terminations\n\n # Define the vector from the vortex origins to the vortex terminations. This is of shape (N x M x 3).\n r_0 = r_1 - r_2\n\n # Calculate the vector cross product. This is of shape (N x M x 3).\n r_1_cross_r_2 = np.cross(r_1, r_2)\n\n # Calculate the cross product's absolute magnitude. This is of shape (N x M).\n r_1_cross_r_2_absolute_magnitude = (\n r_1_cross_r_2[:, :, 0] ** 2\n + r_1_cross_r_2[:, :, 1] ** 2\n + r_1_cross_r_2[:, :, 2] ** 2\n )\n\n # Calculate the vector lengths. These are of shape (N x M).\n r_1_length = np.linalg.norm(r_1, axis=-1)\n r_2_length = np.linalg.norm(r_2, axis=-1)\n\n # Define the radius of the line vortices. This is used to get rid of any singularities.\n radius = 3.0e-16\n\n # Set the lengths and the absolute magnitudes to zero, at the places where the lengths and absolute magnitudes are\n # less than the vortex radius. This insures that the calculation for the constant k will produce np.inf or np.nan\n # values at the locations where there are singularities.\n r_1_length[r_1_length < radius] = 0\n r_2_length[r_2_length < radius] = 0\n r_1_cross_r_2_absolute_magnitude[r_1_cross_r_2_absolute_magnitude < radius] = 0\n\n # Calculate the vector dot products. This uses numpy's einsum function for speed.\n r_0_dot_r_1 = np.einsum(\"ijk,ijk->ij\", r_0, r_1)\n r_0_dot_r_2 = np.einsum(\"ijk,ijk->ij\", r_0, r_2)\n\n # Calculate k and then the induced velocity, ignoring any divide-by-zero or nan errors. k is of shape (N x M)\n with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n k = (\n strengths\n / (4 * np.pi * r_1_cross_r_2_absolute_magnitude)\n * (r_0_dot_r_1 / r_1_length - r_0_dot_r_2 / r_2_length)\n )\n\n # Set the shape of k to be (N x M x 1) to support numpy broadcasting in the subsequent multiplication.\n k = np.expand_dims(k, axis=2)\n\n # Multiple k by the cross products of r_1 and r_2 to get the non-collapsed matrix of induced velocities. This is\n # of shape (M x N x 3).\n induced_velocities = k * r_1_cross_r_2\n\n # Set the values of the induced velocity to zero where there are singularities.\n induced_velocities[np.isinf(induced_velocities)] = 0\n induced_velocities[np.isnan(induced_velocities)] = 0\n\n if collapse:\n induced_velocities = np.sum(induced_velocities, axis=1)\n\n return induced_velocities",
"def _normal_vector(o, p0_3d, p1_3d):\n # The vector between middle point of v1-v2 and object center location\n # is the normal vector I'm looking for\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\n # normalize so I can to length computation on it\n vn.normalize()\n return vn",
"def hellinger_dist(v1, v2):\n if len(v1) != len(v2):\n raise ValueError(\"Vectors should have the same size! \")\n return sqrt( sum( map(lambda e: \n (sqrt(e[0])-sqrt(e[1]))**2, zip(v1,v2))))/sqrt(2)",
"def segmentsIntersect(self, other, allowProjInt = False):\n \n \"\"\"\n If we are not allowing projected intersection and the bounding boxes\n do not intersect then return -3, None.\n \"\"\"\n if(not(allowProjInt) and not(self.doBoundingBoxesIntersect(other))): return -3, None #return if bounding boxes do not intersect\n \"\"\" A special case for colinear lines. \"\"\" \n if(self.areColinear(other)):\n \"\"\"\n First place all four endpoint into a set. This will elliminate shared\n end points. Next, convert the set back into a list so it can\n finally be sorted.\n \"\"\"\n pointList = sorted(list(set([self.start, self.end, other.start, other.end])), key=self.calcT) \n if len(pointList) == 3:\n \"\"\"\n if there are only three points in the list then return 2, the\n middle point in the list since it is the shared point of the\n two lines.\n \"\"\"\n return 2, pointList[1] #if they are colinear and two ends have the same point return that point\n elif len(pointList) == 2:\n \"\"\" If the two lines have the same endpoints. \"\"\"\n return 2.5, self.getMidPoint()\n else:\n \"\"\"\n If the length was not three then we know it is length 4 in which case\n we turn the two middle points into a line and return 3, the line's\n midpoint.\n \"\"\"\n tempLine = Line(pointList[1], pointList[2])\n return 3, tempLine.getMidPoint() #If they are colinear return half way inbetween middle two points\n \"\"\"\n To calculate the intersection of two points we put the lines into the\n form P+tr and Q+us where P and Q are the starting points of the lines\n r and s are vectors form the starting point to the end point, and\n t and u are scalars. Set the two equations equal to each other and \n then solve for t and u. If t and u are in the range [0-1] then the\n intersection point lines on the lines, else it is a projected point.\n \"\"\"\n r = np.subtract(self.end.get2DPoint(), self.start.get2DPoint())\n s = np.subtract(other.end.get2DPoint(), other.start.get2DPoint())\n Q_Less_P = np.subtract(other.start.get2DPoint(), self.start.get2DPoint())\n denom = np.cross(r, s)*1.0\n t = np.cross(Q_Less_P, s)/denom\n u = np.cross(Q_Less_P, r)/denom \n point = p.Point(self.start.x + r[c.X]*t, self.start.y+r[c.Y]*t) \n #If t or u are not in the range 0-1 then the intersection is projected\n if(t > 1 or u > 1 or t < 0 or u < 0):\n \"\"\"\n Due to floating point problems sometimes if t or u is outside the 0-1\n range we end up inside this if statement but are actually at the end\n of one of the lines. I can't figure out how to properly add in a tolerance\n so we are taking the four end points putting them into a list,\n then comparing them to the calculated point. The Point module is\n properly handling tolerances so if the point == any of the end\n points then we should not return a projected point.\n \"\"\"\n if not any(point == lineEnd for lineEnd in (self.start, self.end,\n other.start, other.end)):\n return -1, point #return for projected intersection of non-colinear lines\n return 1, point #lines intersect at given point",
"def intersects(p1, p2):\n if p1^p2:\n return -(np.dot(p1.v, p2.w) * np.eye(3, 3) + \\\n p1.w.reshape((3,1)) @ p2.v.reshape((1,3)) - \n p2.w.reshape((3,1)) @ p1.v.reshape((1,3))) * sm.unitvec(np.cross(p1.w, p2.w))\n else:\n return None",
"def _intersection_homogenous(homog_line_0, homog_line_1):\n # NB: renamed from '_intersection'\n eps = 1e-13\n a,b,c=homog_line_0\n u,v,w=homog_line_1\n D=float(b*u-v*a)\n if abs(D)<eps:\n # parallel lines\n return None, None\n xp=-(w*b-c*v)/D\n yp= (w*a-c*u)/D\n\n return xp, yp",
"def point_to_line_signed(p: Vec2, p0: Vec2, p1: Vec2):\n return cross(norm(nor_vector(p0, p1)), dir_vector(p, p0))",
"def lim_and_line2(v1, v2, round_lims=True):\n\n vmin = np.min((v1.min(), v2.min()))\n vmax = np.max((v1.max(), v2.max()))\n\n if round_lims:\n vmin = np.floor(vmin)\n vmax = np.ceil(vmax)\n\n ax=pl.gca()\n pl.plot([vmin,vmax], [vmin,vmax], 'k:', linewidth=1)\n pl.plot([vmin,vmax], [0,0], 'k:', linewidth=1)\n pl.plot([0,0], [vmin,vmax], 'k:', linewidth=1)\n\n # Aarghh\n for i in range(2):\n ticks = ax.get_yticks()\n ax.set_xticks(ticks)\n\n ax.set_xlim(vmin, vmax)\n ax.set_ylim(vmin, vmax)",
"def normalise(a, b):\n dy = b[1] - a[1]\n dx = b[0] - a[0]\n vector = (dy ** 2 + dx ** 2) ** 0.5\n # Normalise, round and cast to int\n dx = int(round(dx / vector))\n dy = int(round(dy / vector))\n \n return (dx, dy)",
"def l2(u: np.ndarray, v: np.ndarray) -> np.ndarray:\n\n return (u - v) ** 2",
"def addRevLineSeg(self, x1, y1, x2, y2):\n # tip triangles\n if np.allclose(x1, 0.0):\n a = [x1, y1, 0.0]\n for (sa1, ca1), (sa2, ca2) in self._mesh.sincos:\n r = x2\n b = [r * sa2, y2, r * ca2]\n c = [r * sa1, y2, r * ca1]\n self.addTri(a, b, c, None if np.allclose(y1, y2) else a)\n # shank end triangle fan, p1 = top center\n elif np.allclose(x2, 0.0):\n a = [x2, y2, 0.0]\n for (sa1, ca1), (sa2, ca2) in self._mesh.sincos:\n b = [x1 * sa1, y1, x1 * ca1]\n c = [x1 * sa2, y1, x1 * ca2]\n self.addTri(a, b, c, None if np.allclose(y1, y2) else a)\n # triangle strip\n # d o--o c\n # | /|\n # |/ |\n # a o--o b\n else:\n for (sa1, ca1), (sa2, ca2) in self._mesh.sincos:\n self.addQuad([x1 * sa1, y1, x1 * ca1], # a\n [x1 * sa2, y1, x1 * ca2], # b\n [x2 * sa2, y2, x2 * ca2], # c\n [x2 * sa1, y2, x2 * ca1]) # d",
"def linear_interpolate_value_change(t0, v0, t1, v1, dt):\n return (v1 - v0)/float(t1-t0) * dt",
"def _intersection(line_points_0, line_points_1):\n u,v = line_points_0,line_points_1\n (A,B),(C,D) = line_points_0,line_points_1\n h1 = _homogenous_line(A,B)\n h2 = _homogenous_line(C,D)\n P = _intersection_homogenous(h1, h2)\n return P",
"def line_param(v1,v2):\n if (v1[0]-v2[0] != 0.):\n m = (v1[1] - v2[1])/(v1[0] - v2[0])\n b = -m*v1[0] + v1[1]\n if num.fabs(m)>1.0e6:\n m = None\n b = v1[0]\n else: \n m = None\n b = v1[0]\n return (m,b)",
"def line_segment_intersection(line1,\n line2):\n a = float(line1[0][0]*line1[1][1] - line1[0][1]*line1[1][0])\n b = float(line1[0][1] - line1[1][1])\n c = float(line1[1][0] - line1[0][0])\n\n d = float(line2[0][0]*line2[1][1] - line2[0][1]*line2[1][0])\n e = float(line2[0][1] - line2[1][1])\n f = float(line2[1][0] - line2[0][0])\n\n prod = b*f - c*e\n if abs(prod) < 1e-10:\n return (np.inf, np.inf)\n\n xc = (d*c - a*f) / prod\n yc = (a*e - b*d) / prod\n\n sign_x1 = (xc - line1[0][0])*(xc - line1[1][0])\n sign_y1 = (yc - line1[0][1])*(yc - line1[1][1])\n\n if sign_x1 > 1e-10:\n return (np.inf, np.inf)\n if sign_x1 < 1e-10:\n if sign_y1 > 1e-10:\n return (np.inf, np.inf)\n\n sign_x2 = (xc - line2[0][0])*(xc - line2[1][0])\n sign_y2 = (yc - line2[0][1])*(yc - line2[1][1])\n\n if sign_x2 > 1e-10:\n return (np.inf, np.inf)\n if sign_x2 == 1e-10:\n if sign_y2 > 1e-10:\n return (np.inf, np.inf)\n return (int(xc), int(yc))",
"def test_inverse_of_linear_vector_transforms(free_alg: Drudge):\n\n dr = free_alg\n p = dr.names\n v = p.v\n\n a = Vec('a')\n b = Vec('b')\n\n defs = [\n dr.define(a, v + 1),\n dr.define(b, v - 1)\n ]\n res = dr.lvt_inv(defs)\n\n assert len(res) == 2\n half = Rational(1, 2)\n one_checked = False\n v_checked = False\n for i in res:\n if i.lhs == 1:\n assert (i - half * a + half * b).simplify() == 0\n one_checked = True\n elif i.lhs == v:\n assert (i - half * a - half * b).simplify() == 0\n v_checked = True\n else:\n assert False\n continue\n\n assert one_checked and v_checked",
"def line_intercept(p1,p2,p3,p4):\n # Note if vertical line m = None and b holds x-val\n (m1,b1) = line_param(p1,p2)\n (m2,b2) = line_param(p3,p4)\n if (m1 != None) and (m2 != None):\n if (m1-m2) != 0.:\n x = (b2-b1)/(m1-m2)\n y = m1*x + b1\n else:\n return (None,0)\n elif (m1 == None) and (m2 != None):\n x = b1 \n y = m2*x + b2\n elif (m1 != None) and (m2 == None):\n x = b2\n y = m1*x + b1\n else:\n return (None,0) \n \n # min and max of points. \n max_x1 = max(p1[0], p2[0])\n min_x1 = min(p1[0], p2[0])\n max_y1 = max(p1[1], p2[1])\n min_y1 = min(p1[1], p2[1])\n max_x2 = max(p3[0], p4[0])\n min_x2 = min(p3[0], p4[0])\n max_y2 = max(p3[1], p4[1])\n min_y2 = min(p3[1], p4[1])\n #check if the intersection is in bounds\n flag = 1\n if x > max_x1 or x < min_x1:\n flag = 0\n elif x > max_x2 or x < min_x2:\n flag = 0\n elif y > max_y1 or y < min_y1: \n flag = 0\n elif y > max_y2 or y < min_y2: \n flag = 0\n #check if the intersection point corresponds to an end point\n intercept = num.array([x,y])\n def _same(p1,p2,prec=0.0001):\n \"\"\" are two points the same \"\"\"\n #return num.all(num.equal(p1,p2))\n t1 = num.fabs(p1[0]-p2[0]) < prec\n t2 = num.fabs(p1[1]-p2[1]) < prec\n if t1 and t2:\n #print \"same\", p1,p2\n return True\n if flag == 1:\n if _same(intercept,p1):\n flag = 2\n elif _same(intercept,p2):\n flag = 2\n elif _same(intercept,p3):\n flag = 2\n elif _same(intercept,p4):\n flag = 2\n return (intercept,flag)",
"def dist(v1: vect2d, v2: vect2d) -> float:\n d = ((v2.x - v1.x)**2 + (v2.y - v1.y)**2) ** 0.5\n return d",
"def interpolate(self, distance, normalized=...): # -> BaseGeometry:\n ...",
"def vincenty_direct_solution(begin_lat, begin_lon, begin_azimuth, distance, a, b, f):\n # Convert latitude, longitude, azimuth of the begining point to radians\n lat1 = math.radians(begin_lat)\n lon1 = math.radians(begin_lon)\n alfa1 = math.radians(begin_azimuth)\n\n sinAlfa1 = math.sin(alfa1)\n cosAlfa1 = math.cos(alfa1)\n\n # U1 - reduced latitude\n tanU1 = (1 - f) * math.tan(lat1)\n cosU1 = 1 / math.sqrt(1 + tanU1 * tanU1)\n sinU1 = tanU1 * cosU1\n\n # sigma1 - angular distance on the sphere from the equator to begining point\n sigma1 = math.atan2(tanU1, math.cos(alfa1))\n\n # sinAlfa - azimuth of the geodesic at the equator\n sinAlfa = cosU1 * sinAlfa1\n cosSqAlfa = 1 - sinAlfa * sinAlfa\n uSq = cosSqAlfa * (a * a - b * b) / (b * b)\n A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))\n B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))\n\n sigma = distance / (b * A)\n sigmap = 1\n\n while (math.fabs(sigma - sigmap) > 1e-12):\n cos2sigmaM = math.cos(2 * sigma1 + sigma)\n sinSigma = math.sin(sigma)\n cosSigma = math.cos(sigma)\n dSigma = B * sinSigma * (cos2sigmaM + B / 4 * (\n cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM) - B / 6 * cos2sigmaM * (\n -3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2sigmaM * cos2sigmaM)))\n sigmap = sigma\n sigma = distance / (b * A) + dSigma\n\n var_aux = sinU1 * sinSigma - cosU1 * cosSigma * cosAlfa1 # Auxiliary variable\n\n # Latitude of the end point in radians\n lat2 = math.atan2(sinU1 * cosSigma + cosU1 * sinSigma * cosAlfa1,\n (1 - f) * math.sqrt(sinAlfa * sinAlfa + var_aux * var_aux))\n\n lamb = math.atan2(sinSigma * sinAlfa1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlfa1)\n C = f / 16 * cosSqAlfa * (4 + f * (4 - 3 * cosSqAlfa))\n L = lamb - (1 - C) * f * sinAlfa * (\n sigma + C * sinSigma * (cos2sigmaM + C * cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM)))\n # Longitude of the second point in radians\n lon2 = (lon1 + L + 3 * math.pi) % (2 * math.pi) - math.pi\n\n # Convert to decimal degrees\n lat2_dd = math.degrees(lat2)\n lon2_dd = math.degrees(lon2)\n\n return lat2_dd, lon2_dd",
"def lineBoxIntersection(w1, w2, b, xmin, ymin, xmax, ymax):\n \n point1 = None\n point2 = None\n if w2 == 0:\n x1a = -(w2*ymin + b)*1.0/w1\n x1b = -(w2*ymax + b)*1.0/w1\n \n point1 = (x1a, ymin)\n point2 = (x1b, ymax)\n else:\n x2a = -(w1*xmin + b)*1.0/w2\n x2b = -(w1*xmax + b)*1.0/w2\n \n if w1 == 0:\n point1 = (xmin, x2a)\n point2 = (xmax, x2b)\n else:\n\n x1a = -(w2*ymin + b)*1.0/w1\n x1b = -(w2*ymax + b)*1.0/w1\n # Point 1\n if x2a < ymin:\n if xmin <= x1a and x1a <= xmax:\n # Point 1 on bottom edge\n point1 = (x1a, ymin)\n elif x2a > ymax:\n if xmin <= x1b and x1b <= xmax:\n # Point 1 on top edge\n point1 = (x1b, ymax)\n else:\n # Point 1 on left edge\n point1 = (xmin, x2a)\n \n # Point 2\n if point1 is not None:\n if x2b < ymin:\n # Point 2 on bottom edge\n point2 = (x1a, ymin)\n elif x2b > ymax:\n # Point 2 on top edge\n point2 = (x1b, ymax)\n else:\n # Point 2 on right edge\n point2 = (xmax, x2b) \n return (point1, point2)",
"def cross(v1: Vector, v2: Vector) -> Vector: # Function is fucked TODO\n if len(v1.coords) != 3 or len(v2.coords) != 3:\n raise ValueError(\"Vectors have to be 3 fucking D, nøøb\")\n x = v1.y * v2.z - v1.z * v2.y\n y = v1.z * v2.x - v1.x * v2.z\n z = v1.x * v2.y - v1.y * v2.x\n return Vector(x, y, z)",
"def triangulation(P1, P2, x1, x2):\n A = np.zeros((4, 4))\n p1_1 = P1[0, :]\n p1_2 = P1[1, :]\n p1_3 = P1[2, :]\n \n p2_1 = P2[0, :]\n p2_2 = P2[1, :]\n p2_3 = P2[2, :]\n \n A[0,:] = x1[0] * p1_3 - p1_1\n A[1,:] = x1[1] * p1_3 - p1_2\n A[2,:] = x2[0] * p2_3 - p2_1\n A[3,:] = x2[1] * p2_3 - p2_2\n \n U, S, Vt = np.linalg.svd(A)\n #Vt=Vt.T\n x = Vt[:, -1]\n x[0] /= x[3]\n x[1] /= x[3]\n x[2] /= x[3]\n return x[:3]",
"def cubic_interp1d(x0, x, y):\n x = np.asfarray(x)\n y = np.asfarray(y)\n\n # remove non finite values\n # indexes = np.isfinite(x)\n # x = x[indexes]\n # y = y[indexes]\n\n # check if sorted\n if np.any(np.diff(x) < 0):\n indexes = np.argsort(x)\n x = x[indexes]\n y = y[indexes]\n\n size = len(x)\n\n xdiff = np.diff(x)\n ydiff = np.diff(y)\n\n # allocate buffer matrices\n Li = np.empty(size)\n Li_1 = np.empty(size - 1)\n z = np.empty(size)\n\n # fill diagonals Li and Li-1 and solve [L][y] = [B]\n Li[0] = np.sqrt(2 * xdiff[0])\n Li_1[0] = 0.0\n B0 = 0.0 # natural boundary\n z[0] = B0 / Li[0]\n\n for i in range(1, size - 1, 1):\n Li_1[i] = xdiff[i - 1] / Li[i - 1]\n Li[i] = np.sqrt(2 * (xdiff[i - 1] + xdiff[i]) - Li_1[i - 1] * Li_1[i - 1])\n Bi = 6 * (ydiff[i] / xdiff[i] - ydiff[i - 1] / xdiff[i - 1])\n z[i] = (Bi - Li_1[i - 1] * z[i - 1]) / Li[i]\n\n i = size - 1\n Li_1[i - 1] = xdiff[-1] / Li[i - 1]\n Li[i] = np.sqrt(2 * xdiff[-1] - Li_1[i - 1] * Li_1[i - 1])\n Bi = 0.0 # natural boundary\n z[i] = (Bi - Li_1[i - 1] * z[i - 1]) / Li[i]\n\n # solve [L.T][x] = [y]\n i = size - 1\n z[i] = z[i] / Li[i]\n for i in range(size - 2, -1, -1):\n z[i] = (z[i] - Li_1[i - 1] * z[i + 1]) / Li[i]\n\n # find index\n index = x.searchsorted(x0)\n np.clip(index, 1, size - 1, index)\n\n xi1, xi0 = x[index], x[index - 1]\n yi1, yi0 = y[index], y[index - 1]\n zi1, zi0 = z[index], z[index - 1]\n hi1 = xi1 - xi0\n\n # calculate cubic\n f0 = zi0 / (6 * hi1) * (xi1 - x0) ** 3 + zi1 / (6 * hi1) * (x0 - xi0) ** 3 + (yi1 / hi1 - zi1 * hi1 / 6) * (\n x0 - xi0) + (yi0 / hi1 - zi0 * hi1 / 6) * (xi1 - x0)\n\n return f0",
"def an_intersection(v1, b1):\n try:\n return intersection(v1, b1, np.array([1,1]), 0)\n except np.linalg.linalg.LinAlgError:\n print v1\n return intersection(v1, b1, np.array([-1,1]), 0)",
"def inverse_linear ( a , b ) :\n \n x0 , f0 = a.x , a.fx\n x1 , f1 = b.x , b.fx\n\n if f0 == f1 or isequal ( f0 , f1 ) : return None\n\n return ( x0 * f1 - x1 * f0 ) / ( f1 - f0 )",
"def lmap(v: float, x: Interval, y: Interval) -> float:\n return y[0] + (v - x[0]) * (y[1] - y[0]) / (x[1] - x[0])",
"def skew_midpoint(vert1: vec3d, direct1: vec3d, vert2: vec3d, direct2: vec3d):\n perp_both = np.cross(direct1, direct2)\n scale = np.dot(perp_both, perp_both)\n\n sp_diff = vert2 - vert1\n\n temp = np.cross(sp_diff, direct2)\n on1 = vert1 + direct1 * np.dot(perp_both, temp) / scale\n\n temp = np.cross(sp_diff, direct1)\n on2 = vert2 + direct2 * np.dot(perp_both, temp) / scale\n\n scale = np.linalg.norm(on1 - on2)\n\n res = (on1 + on2) * 0.5\n return scale, res",
"def rect2uvs(rect1, rect2):\n c1 = rectCenter(rect1)\n c2 = rectCenter(rect2)\n s1 = rectSize(rect1)\n s2 = rectSize(rect2)\n\n ####################\n # TODO - part 1b\n # round the rects first \n # plug both sets of coords into:\n # x' = x + (x-x0) * s\n # y' = y + (y-y0) * s\n # to solve for s\n # then use calculated s and coords into:\n # x' = x + u + (x-x0) * s\n # y' = y + v + (y-y0) * s\n # to solve for u and v\n # handle the case where the scale needs to be averaged??\n\n scaleX = (s2[0] - s1[0]) / s1[0]\n scaleY = (s2[1] - s1[1]) / s1[1]\n\n if scaleX is not scaleY:\n scale = (scaleX + scaleY) / 2\n else:\n scale = scaleX\n\n\n u1 = rect2[0] - rect1[0] - ((rect1[0] - c1[0]) * scale)\n u2 = rect2[1] - rect1[1] - ((rect1[1] - c1[0]) * scale)\n u = (u1+u2) / 2\n\n v1 = rect2[2] - rect1[2] - ((rect1[2] - c1[1]) * scale)\n v2 = rect2[3] - rect1[3] - ((rect1[3] - c1[1]) * scale)\n v = (v1+v2) / 2\n\n mot = [u, v, scale, c1[0], c1[1]]\n ####################\n\n return mot",
"def line_line_intersection(a1: Vector3, a2: Vector3, b1: Vector3, b2: Vector3) -> Vector3:\n # From https://stackoverflow.com/a/20677983/7245441\n\n def det(a: Vector3, b: Vector3) -> float:\n return a.x * b.y - a.y * b.x\n\n y_diff = Vector3(a1.y - a2.y, b1.y - b2.y, 0)\n x_diff = Vector3(a1.x - a2.x, b1.x - b2.x, 0)\n\n div = det(x_diff, y_diff)\n if div == 0:\n raise Exception(\"Lines do not intersect\")\n\n d = Vector3(det(a1, a2), det(b1, b2), 0)\n x = det(d, x_diff) / div\n y = det(d, y_diff) / div\n\n return Vector3(x, y, 0)",
"def lin_trim_error(a: np.ndarray, b: np.ndarray, start: float = 0.5,\n end: float = 0.1, start_v: float = 0,\n end_v: float = 0.5) -> np.ndarray:\n start_w = np.linspace(start_v, 1, start * len(b), endpoint=False)\n end_w = np.linspace(end_v, 1, end * len(b), endpoint=False)[::-1]\n mid_w = np.ones(len(b) - len(start_w) - len(end_w))\n weights = np.concatenate((start_w, mid_w, end_w))\n return (np.square(a - b) * weights).sum(axis=1)",
"def elastic_shooting(q1,v, mode=0):\n d = sqrt(innerprod_q2(v,v))\n if d < 0.00001:\n q2n = q1\n else:\n q2n = cos(d)*q1 + (sin(d)/d)*v\n if mode == 1:\n q2n = project_curve(q2n)\n \n return (q2n)",
"def generate_normals(v1, v2, v3, normalize_result=True):\n # make vectors relative to v2\n # we assume opengl counter-clockwise ordering\n a = v1 - v2\n b = v3 - v2\n n = cross(b, a)\n if normalize_result:\n n = normalize(n)\n return n",
"def vincenty_direct_solution(begin_lat, begin_lon, begin_azimuth, distance, a, b, f):\n # Convert latitude, longitude, azimuth of the begining point to radians\n lat1 = math.radians(begin_lat)\n lon1 = math.radians(begin_lon)\n alfa1 = math.radians(begin_azimuth)\n\n sinAlfa1 = math.sin(alfa1)\n cosAlfa1 = math.cos(alfa1)\n \n # U1 - reduced latitude\n tanU1 = (1 - f) * math.tan(lat1)\n cosU1 = 1 / math.sqrt(1 + tanU1 * tanU1)\n sinU1 = tanU1 * cosU1\n \n # sigma1 - angular distance on the sphere from the equator to begining point\n sigma1 = math.atan2(tanU1, math.cos(alfa1))\n \n # sinAlfa - azimuth of the geodesic at the equator\n sinAlfa = cosU1 * sinAlfa1\n cosSqAlfa = 1 - sinAlfa * sinAlfa\n uSq = cosSqAlfa * (a * a - b * b) / (b * b)\n A = 1 + uSq/16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))\n B = uSq/1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))\n \n sigma = distance / (b * A)\n sigmap = 1\n \n while (math.fabs(sigma - sigmap) > 1e-12):\n cos2sigmaM = math.cos(2 * sigma1 + sigma)\n sinSigma = math.sin(sigma)\n cosSigma = math.cos(sigma)\n dSigma = B*sinSigma*(cos2sigmaM+B/4*(cosSigma*(-1+2*cos2sigmaM*cos2sigmaM)-B/6*cos2sigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2sigmaM*cos2sigmaM))) \n sigmap = sigma\n sigma = distance / (b * A) + dSigma\n \n var_aux = sinU1 * sinSigma - cosU1 * cosSigma * cosAlfa1\n \n # Latitude of the end point in radians\n lat2 = math.atan2(sinU1 * cosSigma + cosU1 * sinSigma*cosAlfa1, (1 - f)*math.sqrt(sinAlfa * sinAlfa + var_aux*var_aux))\n \n lamb = math.atan2 (sinSigma * sinAlfa1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlfa1)\n C = f / 16 * cosSqAlfa * (4 + f * (4 - 3 * cosSqAlfa))\n L = lamb - (1 - C) * f * sinAlfa *(sigma + C * sinSigma * (cos2sigmaM + C * cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM)))\n # Longitude of the second point in radians\n lon2 = (lon1 + L +3*math.pi)%(2*math.pi) - math.pi\n \n # Convert to decimal degrees\n lat2_dd = math.degrees(lat2) \n lon2_dd = math.degrees(lon2)\n \n return lat2_dd, lon2_dd",
"def get_cross2d(v1, v2):\n return v1[0]*v2[1] - v1[1]*v2[0]",
"def line_line_shortest_dist_unbounded(r1: np.ndarray, v1: np.ndarray, r2: np.ndarray, v2: np.ndarray,\n eps: float = 1e-5) -> Tuple[float, Tuple[float, float]]:\n\n # check that lines are not parallel\n # normalised dot product must not be 1 or -1\n if np.abs(np.dot(v1, v2)) < np.linalg.norm(v1) * np.linalg.norm(v2) - eps:\n R = r2 - r1\n A = np.array([[np.dot(v1, v1), -np.dot(v1, v2)],\n [np.dot(v2, v1), -np.dot(v2, v2)]])\n b = np.array([np.dot(R, v1), np.dot(R, v2)])\n t1, t2 = np.matmul(np.linalg.inv(A), b)\n d = np.linalg.norm((r1 + v1 * t1) - (r2 + v2 * t2))\n else:\n # case where two lines are parallel\n # then fix one point and find shortest distance to that point\n t1 = 0\n d, t2 = line_point_shortest_dist(r2, v2, r1)\n\n return d, (t1, t2)",
"def closest_distance_between_lines(\n a0,\n a1,\n b0,\n b1,\n clamp_all=False,\n clamp_a0=False,\n clamp_a1=False,\n clamp_b0=False,\n clamp_b1=False,\n):\n\n # If clampAll=True, set all clamps to True\n if clamp_all:\n clamp_a0 = True\n clamp_a1 = True\n clamp_b0 = True\n clamp_b1 = True\n\n a0 = np.asarray(a0)\n a1 = np.asarray(a1)\n b0 = np.asarray(b0)\n b1 = np.asarray(b1)\n\n # Calculate denomitator\n A = a1 - a0\n B = b1 - b0\n magA = np.linalg.norm(A)\n magB = np.linalg.norm(B)\n\n _A = A / magA\n _B = B / magB\n\n # due to numerical instabilities there is a test for the case _A and _B are almost parallel\n if not ((np.allclose(_A, _B) or np.allclose(_A, -_B))):\n # non parallel\n # worsk also for strong parallel lines\n cross = np.cross(_A, _B)\n denom = np.linalg.norm(cross) ** 2\n else:\n # almost paralel vectors\n # this is due to numerical stability\n denom = 0\n\n # If lines are parallel (denom=0) test if lines overlap.\n # If they don't overlap then there is a closest point solution.\n # If they do overlap, there are infinite closest positions, but there is a closest distance\n if not denom:\n d0 = np.dot(_A, (b0 - a0))\n\n # Overlap only possible with clamping\n if clamp_a0 or clamp_a1 or clamp_b0 or clamp_b1:\n d1 = np.dot(_A, (b1 - a0))\n\n # Is segment B before A?\n if d0 <= 0 >= d1:\n if clamp_a0 and clamp_b1:\n if np.absolute(d0) < np.absolute(d1):\n return a0, b0, np.linalg.norm(a0 - b0)\n return a0, b1, np.linalg.norm(a0 - b1)\n\n # Is segment B after A?\n elif d0 >= magA <= d1:\n if clamp_a1 and clamp_b0:\n if np.absolute(d0) < np.absolute(d1):\n return a1, b0, np.linalg.norm(a1 - b0)\n return a1, b1, np.linalg.norm(a1 - b1)\n\n # Segments overlap, return distance between parallel segments\n return None, None, np.linalg.norm(((d0 * _A) + a0) - b0)\n\n # Lines criss-cross: Calculate the projected closest points\n t = b0 - a0\n detA = np.linalg.det([t, _B, cross])\n detB = np.linalg.det([t, _A, cross])\n\n t0 = detA / denom\n t1 = detB / denom\n\n pA = a0 + (_A * t0) # Projected closest point on segment A\n pB = b0 + (_B * t1) # Projected closest point on segment B\n\n # Clamp projections\n if clamp_a0 or clamp_a1 or clamp_b0 or clamp_b1:\n if clamp_a0 and t0 < 0:\n pA = a0\n elif clamp_a1 and t0 > magA:\n pA = a1\n\n if clamp_b0 and t1 < 0:\n pB = b0\n elif clamp_b1 and t1 > magB:\n pB = b1\n\n # Clamp projection A\n if (clamp_a0 and t0 < 0) or (clamp_a1 and t0 > magA):\n dot = np.dot(_B, (pA - b0))\n if clamp_b0 and dot < 0:\n dot = 0\n elif clamp_b1 and dot > magB:\n dot = magB\n pB = b0 + (_B * dot)\n\n # Clamp projection B\n if (clamp_b0 and t1 < 0) or (clamp_b1 and t1 > magB):\n dot = np.dot(_A, (pB - a0))\n if clamp_a0 and dot < 0:\n dot = 0\n elif clamp_a1 and dot > magA:\n dot = magA\n pA = a0 + (_A * dot)\n\n return pA, pB, np.linalg.norm(pA - pB)",
"def InverseLine(self, lat1, lon1, lat2, lon2,\n caps = GeodesicCapability.STANDARD |\n GeodesicCapability.DISTANCE_IN):\n\n from geographiclib.geodesicline import GeodesicLine\n a12, _, salp1, calp1, _, _, _, _, _, _ = self._GenInverse(\n lat1, lon1, lat2, lon2, 0)\n azi1 = Math.atan2d(salp1, calp1)\n if caps & (Geodesic.OUT_MASK & Geodesic.DISTANCE_IN):\n caps |= Geodesic.DISTANCE\n line = GeodesicLine(self, lat1, lon1, azi1, caps, salp1, calp1)\n line.SetArc(a12)\n return line",
"def normalizeVert(v, radius):\n # calculate current distance\n dist = (v.co.x ** 2 + v.co.y ** 2 + v.co.z ** 2) ** 0.5\n\n # normalize\n for axis in range(3):\n v.co[axis] = v.co[axis] / dist * radius",
"def interpolate(x0, y0, x1, y1, x):\n y = (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0)\n\n return y",
"def test_perpendicular_to_vectors():\n random_state = np.random.RandomState(0)\n a = pr.norm_vector(pr.random_vector(random_state))\n a1 = pr.norm_vector(pr.random_vector(random_state))\n b = pr.norm_vector(pr.perpendicular_to_vectors(a, a1))\n c = pr.norm_vector(pr.perpendicular_to_vectors(a, b))\n assert_almost_equal(pr.angle_between_vectors(a, b), np.pi / 2.0)\n assert_almost_equal(pr.angle_between_vectors(a, c), np.pi / 2.0)\n assert_almost_equal(pr.angle_between_vectors(b, c), np.pi / 2.0)\n assert_array_almost_equal(pr.perpendicular_to_vectors(b, c), a)\n assert_array_almost_equal(pr.perpendicular_to_vectors(c, a), b)",
"def interpol(self,x,y,x1):\n \n N = len(x)\n i = np.minimum(np.maximum(np.searchsorted(x,x1,side='right'),1),N-1)\n xl = x[i-1]\n xr = x[i]\n yl = y[i-1]\n yr = y[i]\n y1 = yl + (yr-yl)/(xr-xl) * (x1-xl)\n above = x1 > x[-1]\n below = x1 < x[0]\n y1 = np.where(above,y[-1] + (x1 - x[-1]) * (y[-1]-y[-2])/(x[-1]-x[-2]), y1)\n y1 = np.where(below,y[0],y1)\n \n return y1, i",
"def interpolate(x1, x2, u, N):\n \n # finding the magnitude of each component\n a1 = np.matmul(x1, u)\n a2 = np.matmul(x2, u)\n\n ims = [np.matmul(u, t * a1 + (1 - t) * a2) \\\n for t in np.linspace(0, 1, N)]\n\n return np.stack(ims, 0)",
"def intersect_segment(self, p1, p2):\n p1 = base.getvector(p1)\n if len(p1) == 2:\n p1 = np.r_[p1, 1]\n p2 = base.getvector(p2)\n if len(p2) == 2:\n p2 = np.r_[p2, 1]\n \n\n z1 = self.line * p1\n z2 = self.line * p2\n\n if np.sign(z1) != np.sign(z2):\n return True\n if self.contains(p1) or self.contains(p2):\n return True\n return False",
"def cross2(u, v, w):\n return dot2(u, w) * v - dot2(u, v) * w",
"def normal(point0: Point, point1: Point) -> Tuple[Point, float]:\n mid: Point = ((point0[0] + point1[0]) / 2, (point0[1] + point1[1]) / 2)\n v: Vector2 = (point1[0] - point0[0], point1[1] - point0[1])\n normal: Vector2 = (-v[1], v[0])\n\n angle = math.atan(v[1] / v[0])\n angleNorm = math.atan(normal[1] / normal[0])\n assert(abs(abs(angle - angleNorm) - math.pi / 2) < 0.001)\n\n x = [mid[0], mid[0] + normal[0]]\n y = [mid[1], mid[1] + normal[1]]\n plt.plot(x, y, \":\")\n\n return (mid, angleNorm)",
"def _inner_product_a2(\n self, tangent_vec_a, tangent_vec_b, base_point, vertex_areas_bp\n ):\n laplacian_at_base_point = self._space.laplacian(base_point)\n return self.a2 * gs.sum(\n gs.einsum(\n \"...bi,...bi->...b\",\n laplacian_at_base_point(tangent_vec_a),\n laplacian_at_base_point(tangent_vec_b),\n )\n / vertex_areas_bp,\n axis=-1,\n )",
"def orient(ps, origin, v1, v2):\r\n \r\n ps = np.vstack((v1, v2, ps))\r\n ps -= origin\r\n if ps[0][1] == 0:\r\n a = 0\r\n else:\r\n a = np.arcsin(np.fabs(ps[0][1]) / np.sqrt(ps[0][1] ** 2 + ps[0][2] ** 2))\r\n if (ps[0][1] < 0 <= ps[0][2]) or (ps[0][1] > 0 > ps[0][2]):\r\n a = 2 * np.pi - a\r\n if (ps[0][1] * np.sin(a) + ps[0][2] * np.cos(a)) < 0:\r\n a = np.pi + a \r\n ps = rotate(a, ps, 0)\r\n if ps[0][0] == 0:\r\n b = 0\r\n else:\r\n b = np.arcsin(np.fabs(ps[0][0]) / np.sqrt(ps[0][0] ** 2 + ps[0][2] ** 2))\r\n if (ps[0][0] < 0 and ps[0][2] < 0) or (ps[0][0] > 0 and ps[0][2] > 0):\r\n b = 2 * np.pi - b\r\n if (ps[0][2] * np.cos(b) - ps[0][0] * np.sin(b)) < 0:\r\n b = np.pi + b\r\n ps = rotate(b, ps, 1)\r\n if ps[1][1] == 0:\r\n c = 0\r\n else:\r\n c = np.arcsin(np.fabs(ps[1][1]) / np.sqrt(ps[1][0]**2 + ps[1][1]**2))\r\n if (ps[1][0] < 0 and ps[1][1] < 0) or (ps[1][0] > 0 and ps[1][1] > 0):\r\n c = 2 * np.pi - c\r\n if (ps[1][0] * np.cos(c) - ps[1][1] * np.sin(c)) < 0:\r\n c = np.pi + c\r\n ps = rotate(c, ps, 2)\r\n return ps[2:]",
"def vincenty(lon0, lat0, a1, s):\n\n lon0 = np.deg2rad(lon0)\n lat0 = np.deg2rad(lat0)\n a1 = np.deg2rad(a1)\n s = np.deg2rad(s)\n\n sina = np.cos(lat0) * np.sin(a1)\n\n num1 = np.sin(lat0) * np.cos(s) + np.cos(lat0) * np.sin(s) * np.cos(a1)\n den1 = np.sqrt(\n sina**2 + (np.sin(lat0) * np.sin(s) - np.cos(lat0) * np.cos(a1)) ** 2\n )\n lat = np.rad2deg(np.arctan2(num1, den1))\n\n num2 = np.sin(s) * np.sin(a1)\n den2 = np.cos(lat0) * np.cos(s) - np.sin(lat0) * np.sin(s) * np.cos(a1)\n L = np.arctan2(num2, den2)\n lon = np.rad2deg(lon0 + L)\n\n return lon, lat",
"def on_line_and_between_endpoints_2d(pt1, pt2, pt, tol=None):\r\n if tol is None:\r\n tol = get_tol_2d()\r\n return geometry.gmOnLineAndBetweenEndpointsWithTol(pt1, pt2, pt, tol)",
"def _min_norm_element_from2(v1v1, v1v2, v2v2):\n if v1v2 >= v1v1:\n # Case: Fig 1, third column\n gamma = 0.999\n cost = v1v1\n return gamma, cost\n if v1v2 >= v2v2:\n # Case: Fig 1, first column\n gamma = 0.001\n cost = v2v2\n return gamma, cost\n # Case: Fig 1, second column\n gamma = -1.0 * ( (v1v2 - v2v2) / (v1v1+v2v2 - 2*v1v2) )\n cost = v2v2 + gamma*(v1v2 - v2v2)\n return gamma, cost",
"def linear_interpolate_value_at_time(t0, v0, t1, v1, t):\n return v0 + linear_interpolate_value_change(t0, v0, t1, v1, t - t0)",
"def translation_separation(t1: np.ndarray, t2: np.ndarray) -> float:\n return np.linalg.norm(t1 - t2)",
"def _add_vectors(v1, v2):\n x = math.cos(v1[1]) * v1[0] + math.cos(v2[1]) * v2[0]\n y = math.sin(v1[1]) * v1[0] + math.sin(v2[1]) * v2[0]\n\n angle = 0.5 * math.pi - math.atan2(y, x)\n length = math.hypot(x, y)\n return (length, angle)",
"def l1(u: np.ndarray, v: np.ndarray) -> np.ndarray:\n\n return np.abs(u - v)",
"def intersect(v, p):\n\t# Solve for t: 100 = 4 * (px + t * vx)^2 + (py + t * vy)^2\n\t# Note: 4 * px^2 + py^2 - 100 = 0\n\tt = sum([c*vi*pi for (c,vi,pi) in zip((-8.0, -2.0),v,p)]) \n\tt /= sum([c * vi**2 for (c,vi) in zip((4.0,1.0),v)])\n\treturn [pi + vi * t for (pi, vi) in zip(p, v)]",
"def normal_vector(origin, vectors):\n return np.cross(vectors[0] - origin, vectors[1] - origin)",
"def bessellsuniv(x, y, z1, z2, lab, rzero):\n nlab = len(lab)\n omega = np.zeros(nlab, dtype=np.complex_)\n za, zb, N = circle_line_intersection(z1, z2, x + y * 1j, rzero * abs(lab[0]))\n if N > 0:\n for n in range(nlab):\n omega[n] = bessellsuni(x, y, za, zb, lab[n])\n return omega",
"def test_lineclip():\n # %% LOWER to UPPER test\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\n 0, 0, 4, 6)\n\n assert [x1, y1, x2, y2] == approx([2, 3, 3.3333333333333, 5])\n # %% no intersection test\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\n 0, 0.1, 0, 0.1)\n\n assert x1 is None and y1 is None and x2 is None and y2 is None\n # %% left to right test\n x1, y1, x2, y2 = plc.cohensutherland(1, 5, 4, 3,\n 0, 4, 5, 4)\n\n assert [x1, y1, x2, y2] == [1, 4, 4, 4]",
"def advect (u, v):\r\n # NOTICE: memory usage might be too high, could optimize\r\n\r\n # Store the values from timestep n\r\n un = u\r\n vn = v\r\n\r\n for i in range (height):\r\n for j in range (width):\r\n oldpos = coord (i,j) - dt * np.stack((u[i,j], v[i,j]))\r\n u[i,j], v[i,j] = interpolate (un, vn, oldpos)\r\n\r\n\r\n # Return values for timestep n+1\r\n return u, v",
"def point_to_line_abs(p: Vec2, p0: Vec2, p1: Vec2):\n return abs(point_to_line_signed(p, p0, p1))",
"def _lines_intersection(self, other):\n\n the_slope, the_y_intercept = False, False\n\n # parallel?\n if self.slope == other.slope:\n return (\n self.y_intercept == other.y_intercept and\n self.x_value == other.x_value\n )\n\n if self.is_vertical():\n x = self.x_value\n the_slope = other.slope\n the_y_intercept = other.y_intercept\n elif other.is_vertical():\n x = other.x_value\n else:\n x = (other.y_intercept - self.y_intercept) / (self.slope - other.slope)\n\n if the_slope is None or the_slope is False:\n the_slope = self.slope\n the_y_intercept = self.y_intercept\n\n y = the_slope * x + the_y_intercept\n\n return Point(x, y)",
"def fun(x0, x1, y0, y1, xx, yy): \n\n # Look for point of intersection between interpolated curve between nodes in x, y\n # and the normal to the face between nodes (x0, y0) and (x1, y1)\n # Transform coordinate axes\n # Center of face is xs, ys\n xs = (x0 + x1)/2.\n ys = (y0 + y1)/2.\n\n if abs(y1 - y0) > abs(x1 - x0):\n theta = arctan((x1 - x0)/(y1 - y0))\n theta2 = arctan((xx - xs)/(yy - ys))\n dy = (yy - ys)/cos(theta2)\n xn = copy(xx)\n yn = copy(yy)\n xn = dy*sin(theta2 - theta)\n yn = dy*cos(theta2 - theta)\n w = barycentric_weight(yn)\n y2 = - yn\n f = zeros(len(y2), float)\n ss = sum(w/y2)\n f[:] = w/y2/ss\n dy = dot(f, xn)\n xny = xs + dy*sin(theta + pi/2.)\n yny = ys + dy*cos(theta + pi/2.)\n\n else: \n theta = arctan((y1 - y0)/(x1 - x0))\n theta2 = arctan((yy - ys)/(xx - xs))\n dx = (xx - xs)/cos(theta)\n xn = copy(xx)\n yn = copy(yy)\n xn = dx*cos(theta2 - theta)\n yn = dx*sin(theta2 - theta)\n w = barycentric_weight(xn)\n x2 = - xn\n f = zeros(len(x2), float)\n ss = sum(w/x2)\n f[:] = w/x2/ss\n dy = dot(f, yn)\n xny = xs + dy*cos(theta + pi/2.)\n yny = ys + dy*sin(theta + pi/2.)\n \n return xny, yny",
"def get_intersection(l0, l1):\n # Source: https://en.wikipedia.org/wiki/Line–line_intersection\n\n denominator = (l0[0] - l0[1]) * (l1[2] - l1[3]) -\\\n (l0[2] - l0[3]) * (l1[0] - l1[1])\n\n x_nominator = (l0[0] * l0[3] - l0[2] * l0[1]) * (l1[0] - l1[1]) -\\\n (l1[0] * l1[3] - l1[2] * l1[1]) * (l0[0] - l0[1])\n y_nominator = (l0[0] * l0[3] - l0[2] * l0[1]) * (l1[2] - l1[3]) -\\\n (l1[0] * l1[3] - l1[2] * l1[1]) * (l0[2] - l0[3])\n\n return [x_nominator / denominator, y_nominator / denominator]",
"def minmaxdenorm2d(v, minv0, maxv0, minv1, maxv1):\n v[:, 0] *= maxv0 - minv0\n v[:, 0] += minv0\n v[:, 1] *= maxv1 - minv1\n v[:, 1] += minv1\n return v",
"def _intersection_forward_line_segment(semiinf_line1, line2, semiinf_h_line1=None, h_line2=None):\n\n semiinf_h_line1 = _homogenous_line(*semiinf_line1) if semiinf_h_line1 is None else semiinf_h_line1\n h_line2 = _homogenous_line(*line2) if h_line2 is None else h_line2\n\n P = _intersection_homogenous(semiinf_h_line1, h_line2)\n if not _point_within_bounds(line2,P):\n # semi-infinite line does not intersect the particular SEGMENT of line2\n return None, P\n\n A,B = semiinf_line1\n if abs(B[1]-A[1])>=abs(B[0]-A[0]):\n t = (P[1]-A[1])/(B[1]-A[1])\n else:\n t = (P[0]-A[0])/(B[0]-A[0])\n\n if t>0: # intersection lies behind A, i.e. toward or beyond B\n return None, P\n\n return (P[0]-A[0])**2+(P[1]-A[1])**2, P",
"def _line_from_two_points(pt1: np.array, pt2: np.array) -> np.array:\n numLine = pt1.shape[0]\n lines = np.zeros((numLine, 6))\n n = np.cross(pt1, pt2)\n n = n / (matlib.repmat(np.sqrt(np.sum(n ** 2, 1, keepdims=True)), 1, 3) + 1e-9)\n lines[:, 0:3] = n\n\n areaXY = np.abs(np.sum(n * matlib.repmat([0, 0, 1], numLine, 1), 1, keepdims=True))\n areaYZ = np.abs(np.sum(n * matlib.repmat([1, 0, 0], numLine, 1), 1, keepdims=True))\n areaZX = np.abs(np.sum(n * matlib.repmat([0, 1, 0], numLine, 1), 1, keepdims=True))\n planeIDs = np.argmax(np.hstack([areaXY, areaYZ, areaZX]), axis=1) + 1\n lines[:, 3] = planeIDs\n\n for i in range(numLine):\n uv = _xyz2uvN(np.vstack([pt1[i, :], pt2[i, :]]), lines[i, 3])\n umax = uv[:, 0].max() + np.pi\n umin = uv[:, 0].min() + np.pi\n if umax - umin > np.pi:\n lines[i, 4:6] = np.array([umax, umin]) / 2 / np.pi\n else:\n lines[i, 4:6] = np.array([umin, umax]) / 2 / np.pi\n\n return lines",
"def project_vectors_ab(a, b):\n # print('dot = ', np.dot(a,b))\n # print('norm = ', np.linalg.norm(b))\n return np.dot(a, b) / np.linalg.norm(b)",
"def slerp(z1, z2, t):\n z1_l = z1.pow(2).sum(dim=-1, keepdim=True).sqrt()\n z1_n = z1 / z1_l\n\n z2_l = z2.pow(2).sum(dim=-1, keepdim=True).sqrt()\n z2_n = z2 / z2_l\n\n dot = torch.sum(z1_n * z2_n, dim=-1).clamp(-1, 1)\n theta_0 = torch.acos(dot)\n theta = t * theta_0\n\n z3 = z2_n - dot * z1_n\n z3 = z3 / z3.pow(2).sum(dim=-1, keepdim=True).sqrt()\n\n return lerp(z1_l, z2_l, t) * (z1_n * torch.cos(theta) + z3 * torch.sin(theta))",
"def l2_distance(v1, v2):\n\treturn np.linalg.norm(np.array(v1) - np.array(v2))",
"def line_line_shortest_dist_bounded(r1: np.ndarray, v1: np.ndarray, r2: np.ndarray, v2: np.ndarray,\n eps: float = 1e-5) -> Tuple[float, Tuple[float, float]]:\n\n # check against unbounded version first\n best_dist, (best_t1, best_t2) = line_line_shortest_dist_unbounded(r1, v1, r2, v2, eps=eps)\n\n if not (0 <= best_t1 <= 1 and 0 <= best_t2 <= 1):\n\n # enters here if unbounded optimal not in feasible region\n # solution therefore must be on the boundary\n # so check all edges and corners\n dr = r1 - r2\n v1_dot_v2 = np.dot(v1, v2)\n dr_dot_v1 = np.dot(dr, v1)\n dr_dot_v2 = np.dot(dr, v2)\n norm_v1_sq = np.dot(v1, v1)\n norm_v2_sq = np.dot(v2, v2)\n\n best_dist = np.inf\n best_t1, best_t2 = None, None\n dist = lambda t1, t2: np.linalg.norm(dr + (v1 * t1) - (v2 * t2))\n\n for t1_fixed in [0, 1, None]:\n\n for t2_fixed in [0, 1, None]:\n\n if t1_fixed is None and t2_fixed is None:\n # this case not on edge, skipped\n continue\n elif t1_fixed is None:\n # case when t2_guess fixed\n t1_guess = (v1_dot_v2 * t2_fixed - dr_dot_v1) / norm_v1_sq\n t2_guess = t2_fixed\n elif t2_fixed is None:\n # case when t1_guess fixed\n t1_guess = t1_fixed\n t2_guess = (v1_dot_v2 * t1_fixed + dr_dot_v2) / norm_v2_sq\n else:\n t1_guess = t1_fixed\n t2_guess = t2_fixed\n\n if 0 <= t1_guess <= 1 and 0 <= t2_guess <= 1:\n # only consider if the terms are in the bounds\n d = dist(t1_guess, t2_guess)\n if d < best_dist:\n best_dist = d\n best_t1 = t1_guess\n best_t2 = t2_guess\n\n return best_dist, (best_t1, best_t2)"
] | [
"0.6572107",
"0.6260578",
"0.60963017",
"0.60499376",
"0.59216046",
"0.588906",
"0.584281",
"0.58285564",
"0.5783416",
"0.5775993",
"0.57329005",
"0.5730922",
"0.5719066",
"0.57099354",
"0.56855845",
"0.56546366",
"0.565153",
"0.56246614",
"0.5574889",
"0.5566318",
"0.5547199",
"0.55358326",
"0.5532392",
"0.5508854",
"0.5501112",
"0.54998463",
"0.54860836",
"0.5475693",
"0.5462909",
"0.5454843",
"0.54427826",
"0.5440186",
"0.5409279",
"0.540487",
"0.54012454",
"0.5390144",
"0.53883964",
"0.53869885",
"0.5374569",
"0.5372839",
"0.53704995",
"0.53439003",
"0.5327482",
"0.53247666",
"0.5315718",
"0.5315415",
"0.53059447",
"0.5297027",
"0.529062",
"0.5288853",
"0.5285436",
"0.52729106",
"0.5270645",
"0.52581596",
"0.5254961",
"0.52544",
"0.5246817",
"0.524456",
"0.52394986",
"0.52292883",
"0.5225132",
"0.52227145",
"0.52208",
"0.52102447",
"0.5195572",
"0.51934797",
"0.51905906",
"0.51842445",
"0.5181947",
"0.51811326",
"0.5180363",
"0.51737696",
"0.5171748",
"0.5168978",
"0.516081",
"0.5159565",
"0.5158235",
"0.5156009",
"0.5152526",
"0.5149446",
"0.51451594",
"0.51423794",
"0.5141557",
"0.51412356",
"0.5139158",
"0.5135055",
"0.5129828",
"0.51268756",
"0.5123999",
"0.5122812",
"0.511904",
"0.51078176",
"0.51057297",
"0.5102663",
"0.51025385",
"0.5102095",
"0.51005274",
"0.50907415",
"0.5077143",
"0.5074389"
] | 0.6959037 | 0 |
Simple way to display an image. | def display_image(image):
image = tf.constant(image)
image = tf.image.convert_image_dtype(image, tf.uint8)
return PIL.Image.fromarray(image.numpy()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_image(file_location):\n img = Image.open(file_location)\n img.show()",
"def display(self):\n display(self.image)",
"def display(self, image):\n raise NotImplementedError()",
"def showimage(image):\n mplt.figure()\n mplt.imshow(image)\n mplt.show()",
"def showImage(self, image):\n \n self.image = img",
"def show(self, image_dir_root=None):\n self.get_image(image_dir_root=image_dir_root).show()",
"def show_file(file_location):\n img = Image.open(file_location)\n img.show()",
"def showImg(img, binary=True, fName=''):\n img = img[0, 0, :, :]\n\n if binary:\n img = img > 0.5\n\n img = Image.fromarray(np.uint8(img * 255), mode='L')\n\n if fName:\n img.save('assets/' + fName + '.png')\n else:\n img.show()",
"def show_image(path):\n img = mpimg.imread(path)\n imgplot = plt.imshow(img)\n plt.show()\n plt.close()",
"def show(self):\n\n self.image.show()",
"def display_image(mat):\n\timg = Image.fromarray(mat)\n\timg.show()",
"def show_image(self):\n cv2.imshow(self.config.DISPLAY_NAME, self.image)",
"def display(image, name=\"Image\"):\n cv2.imshow(name, image)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n cv2.imwrite(\"{}.png\".format(name), image)",
"def _display_img(self):\n if self._file_path is None:\n Debug.printi(\"No picture has been loaded to preview\", Debug.Level.ERROR)\n return\n photo = self._open_img(self._file_path)\n ImageViewDialog(self._parent, self._file_name, photo)",
"def show_image(f, x, y):\n window_surface.blit(f, (x, y))",
"def show_image(image):\r\n plt.imshow(image, cmap='gray')\r\n plt.show()",
"def display_image(window_name, image):\n cv2.namedWindow(window_name)\n cv2.imshow(window_name, image)\n cv2.waitKey(0)",
"def show(title: str, imagePath: str):\n image = cv2.imread (imagePath)\n cv2.imshow (title, image)",
"def display_image(img, label):\n cv2.imshow(label,img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()",
"def view(self):\n window = tk.Tk()\n label = tk.Label(window)\n label.pack()\n img = self.get_tkimage()\n label[\"image\"] = label.img = img\n window.mainloop()",
"def show_image(img, figsize=(10, 10)):\n plt.figure(figsize=figsize)\n plt.imshow(img)\n plt.show()",
"def display_image(self, window_name, image):\n cv2.namedWindow(window_name)\n cv2.imshow(window_name, image)\n cv2.waitKey(0)",
"def show_img(self):\n if self.image is not None:\n cv2.imshow(self.image_window, self.image)\n cv2.waitKey(1)\n else:\n rospy.loginfo(\"No image to show yet\")",
"def show_image(dataset, domain, image_class, image_name):\n\timage_file = io.imread(os.path.join(\"data\", dataset, domain, \"images\", image_class, image_name))\n\tplt.imshow(image_file)\n\tplt.pause(0.001)\n\tplt.figure()",
"def show(type,img):\n # print(img)\n cv2.imshow(type, img)\n cv2.waitKey()",
"def display_image(self, img, img_pos):\n image = tk.Label(self.top, image=img)\n image.grid(row=img_pos[0], column=img_pos[1],\n columnspan=img_pos[2], rowspan=img_pos[3])",
"def displayImage(winName, img):\n cv.imshow(winName, img)\n cv.waitKey(0)",
"def show_picture(self, data):\n raise NotImplementedError",
"def showBtnImg(*args, **kwargs):\n\targs[0].get_image().show()",
"def show(img, name=\"img\"):\n cv2.imshow(name, img)\n cv2.waitKey(0)\n cv2.destroyWindow(name)",
"def printImage(imageObject):\n # TODO\n pass",
"def showImage(self,image):\n if isinstance(image,QtGui.QImage):\n filename = None\n else:\n filename = str(image)\n image = QtGui.QImage(filename)\n if image.isNull():\n raise ValueError,\"Cannot load image file %s\" % filename\n #print(\"Size %sx%s\" % (image.width(),image.height()))\n self.setPixmap(QtGui.QPixmap.fromImage(image))\n self.filename = filename\n self.image = image \n self.zoom = 1.0",
"def show_me():\n # Scumbag thumbnail code\n try:\n from PIL import Image\n except ImportError:\n pass\n else:\n filename = os.path.join(app.static_folder, 'img', 'badumtss.png')\n image = Image.open(filename)\n\n return render_template('show_me.html')",
"def display_image(window_name, img):\n cv2.imshow(window_name, img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()",
"def show_figure(filebase, directory, **kwargs):\n filename = filebase.format(**kwargs)\n if directory is not None:\n filename = directory + '/' + filename\n display(HTML(\"<img src='{filename}'>\".format(filename=filename)))",
"def __draw_image(self):\n if self.image_name is not None:\n img = mpimg.imread(self.image_name)\n extent = (0.5, self.xmax+0.5, -0.5, self.ymax-0.5)\n self.ax.imshow(img, extent=extent, origin='lower',\n alpha=self.image_alpha)",
"def show_image_ref():\n return get_image_ref()",
"def display_image ( X ):\r\n\t# on teste que le tableau contient bien 256 valeurs\r\n\tif X.size != 256:\r\n\t\traise ValueError ( \"Les images doivent etre de 16x16 pixels\" )\r\n\r\n\t# on cree une image pour imshow: chaque pixel est un tableau a 3 valeurs\r\n\t# (1 pour chaque canal R,G,B). Ces valeurs sont entre 0 et 1\r\n\tY = X / X.max ()\r\n\timg = np.zeros ( ( Y.size, 3 ) )\r\n\tfor i in range ( 3 ):\r\n\t\timg[:,i] = X\r\n\r\n\t# on indique que toutes les images sont de 16x16 pixels\r\n\timg.shape = (16,16,3)\r\n\r\n\t# affichage de l'image\r\n\tplt.imshow( img )\r\n\tplt.show ()",
"def image_show(img, cmap=None, suptitle=\"\"):\n fig = plt.figure()\n fig.suptitle(suptitle, fontsize=14, fontweight='bold')\n\n if cmap is not None:\n plt.imshow(img, cmap=cmap, vmin=0, vmax=255)\n else:\n plt.imshow(img)\n plt.show()",
"def imDisplay(filename: str, representation: int):\r\n img=imReadAndConvert(filename, representation)\r\n if representation==LOAD_GRAY_SCALE:\r\n plt.imshow(img,cmap='gray')\r\n else:\r\n plt.imshow(img)\r\n plt.show()",
"def display_image(self, image):\n self._frame.clear()\n self._frame.setMinimumWidth(500)\n self._frame.setMinimumHeight(300)\n self._frame.setAlignment(Qt.AlignCenter)\n\n if image is not None:\n if image.is_valid():\n pixmap = image.to_qt_pixmap(self._frame.size())\n self._frame.setPixmap(pixmap)\n else:\n self._frame.setText(\"Image Not Found\")",
"def show_image(img, title='image', method='opencv'):\n if method.lower() == 'opencv':\n cv2.imshow(title, img)\n cv2.waitKey(0)\n elif method.lower() == 'pylab':\n plt.figure(title)\n plt.axis('off')\n plt.imshow(img)\n plt.show()",
"def show(image):\n from matplotlib import pyplot\n import matplotlib as mpl\n fig = pyplot.figure()\n ax = fig.add_subplot(1,1,1)\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\n imgplot.set_interpolation('nearest')\n ax.xaxis.set_ticks_position('top')\n ax.yaxis.set_ticks_position('left')\n pyplot.show()",
"def show(image):\n from matplotlib import pyplot\n import matplotlib as mpl\n fig = pyplot.figure()\n ax = fig.add_subplot(1,1,1)\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\n imgplot.set_interpolation('nearest')\n ax.xaxis.set_ticks_position('top')\n ax.yaxis.set_ticks_position('left')\n pyplot.show()",
"def show(image):\n from matplotlib import pyplot\n import matplotlib as mpl\n fig = pyplot.figure()\n ax = fig.add_subplot(1,1,1)\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\n imgplot.set_interpolation('nearest')\n ax.xaxis.set_ticks_position('top')\n ax.yaxis.set_ticks_position('left')\n pyplot.show()",
"def show_image(self, idx):\n image, target = self.__getitem__(self, idx)\n im_h, im_w, _ = image.size()\n labels_num = target['labels']\n rescale = torch.tensor([[im_w, im_h, im_w, im_h]])\n bboxs = target['boxes'] * rescale\n img = image.permute(1, 2, 0).numpy()\n for i, bboxe in enumerate(bboxs):\n x, y, xm, ym = bboxe\n label = class_name[int(labels_num[i])]\n plot_one_box((int(x), int(y), int(xm), int(ym)), img, label=label, line_thickness=3)\n cv2.imshow('image', img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()",
"def show_image(self, image_set='train', index=None, interactive_mode=True):\n if interactive_mode:\n plt.ion()\n else:\n plt.ioff()\n\n if image_set == 'train':\n target = self.train_dataset\n else:\n target = self.test_dataset\n\n if index is None:\n index = randint(0, len(target['data']))\n\n plt.figure(num=self.LABELS[target['labels'][index]])\n plt.imshow(target['data'][index])\n plt.show()",
"def display_image(X):\n\n\tim = X.reshape(28, 28)\n\ttemp = plt.imshow(im)\n\tplt.show()",
"def display_images(filenames):\n for filename in filenames:\n display(Image(filename))",
"def show_with_matplotlib(img, title):\n\n # Convert BGR image to RGB:\n img_RGB = img[:, :, ::-1]\n\n # Show the image using matplotlib:\n plt.imshow(img_RGB)\n plt.title(title)\n plt.show()",
"def make_image():\n click.echo(\"make_image\")",
"def display_img(title,img):\r\n cv2.namedWindow('img', cv2.WINDOW_NORMAL)\r\n cv2.setWindowTitle('img',title)\r\n cv2.resizeWindow('img',600,400)\r\n\r\n #Display Image on screen\r\n cv2.imshow('img',img)\r\n\r\n #Mantain output until user presses a key\r\n cv2.waitKey(0)\r\n\r\n #Destroy windows when user presses a key\r\n cv2.destroyAllWindows()",
"def image_capture_demo():\n return render_template('image_capture_demo.html')",
"def show_image(image, windowTitle=\"image\"):\n\n cv.imshow(windowTitle, image)\n cv.waitKey(0)\n cv.destroyAllWindows()",
"def show(self) -> None:\n cv.imshow(str(self.__class__), self.output_image)",
"def display(image, fx=1, fy=1):\n image = cv2.resize(image, (0, 0), fx=fx, fy=fy)\n cv2.imshow('Image', image)\n cv2.waitKey(0)\n cv2.destroyAllWindows()",
"def display(self):\n image_qt = ImageQt.ImageQt(self.view_state.get_image())\n self.imageLabel.setPixmap(QtGui.QPixmap.fromImage(image_qt))\n self.imageLabel.adjustSize()",
"def imdisplay(filename, representation):\n\n image = read_image(filename, representation)\n plt.imshow(image, cmap=\"gray\")\n plt.show()",
"def show_one_ins_image(self, pic_path):\n img = Image.open(pic_path)\n self.epd_drv.show_one_image(img)",
"def matplotlibDisplay(img, title=\"Image\", colorFlag = 'gray'):\n plt.imshow(img, colorFlag)\n plt.title(title)\n plt.xticks([])\n plt.yticks([])\n plt.show()",
"def show_image(img, bw=False, alpha=1, no_ticks=True, title=''):\n if not bw:\n plt.imshow(img, alpha=alpha)\n else:\n plt.imshow(img, alpha=alpha, cmap=plt.get_cmap('gray'))\n if no_ticks:\n plt.xticks([]), plt.yticks([])\n if title != '':\n plt.title = title\n plt.show()\n return",
"def hello_image(image):\n return \"Hello %s!\" % image",
"def image(name, value, width=\"\", height=\"\", alt=None):\n if alt is None:\n alt = name\n log.debug(u\"image %s\" % value)\n html = u\"<img id=\\\"%s\\\" \" % name\n html += u'alt=\"%s\" ' % alt\n if width:\n html += u\"width=\\\"%s\\\" \" % width\n if height:\n html += u\"height=\\\"%s\\\" \" % height\n html += u\"src=\\\"%s\\\" \" % value\n html += u\"/>\\n\"\n return html",
"def image(request, ef_id):\n ef = get_object_or_404(ExamFile, id=ef_id)\n thumb = get_thumbnail_path(ef)\n daimage = file(thumb, 'rb').read()\n return HttpResponse(content=daimage, mimetype='image/png')",
"def imdisplay(filename, representation):\n image = read_image(filename, representation)\n\n if representation == GRAY_OUT:\n plt.imshow(image, cmap='gray')\n else:\n plt.imshow(image)\n\n plt.show()",
"def imdisplay(filename, representation):\n img = read_image(filename, representation)\n if representation == GS_REP:\n plt.imshow(img, cmap=plt.cm.gray)\n else:\n plt.imshow(img)",
"def show_shot(path_to_images, name_image):\n crrt_image = misc.imread(\"./{}/{}\".format(path_to_images, name_image))\n\n plt.imshow(crrt_image)\n\n plt.draw()\n plt.pause(0.5)",
"def onclick_open_image(self):\n filename = select_file(\n \"Select Image\",\n \"../\",\n \"Image Files (*.jpeg *.jpg *.png *.gif *.bmg)\")\n if filename:\n param_name = select_file(\n \"Select Parameter\", \"../\", \"Parameter Files (*.json)\")\n if param_name:\n self.moildev = Moildev(param_name)\n self.image = read_image(filename)\n self.h, self.w = self.image.shape[:2]\n self.show_to_window()",
"def img(self, name, img_, **kwargs):\n self.vis.images(img_.cpu().numpy(),\n win=name,\n opts=dict(title=name),\n **kwargs\n )",
"def image(self, src=None, **kw):\n if src:\n kw['src'] = src\n return self._open('img', **kw)",
"def imshow(img):\n imadd(img)\n plt.ion()\n plt.show()",
"def show(image):\n fig = pyplot.figure()\n axis = fig.add_subplot(1, 1, 1)\n imgplot = axis.imshow(image)\n imgplot.set_interpolation('nearest')\n axis.xaxis.set_ticks_position('top')\n axis.yaxis.set_ticks_position('left')\n pyplot.show()",
"def display(array):\n if isinstance(array, np.ndarray):\n plt.imshow(array)\n plt.show()\n else:\n raise TypeError(\"display() needs a numpy ndarray as parameter, \"\n f\"got {type(array)}\")",
"def plot_single_image(image):\n image = image.cpu()\n \n assert type(image) is torch.Tensor, 'Image to plot is not torch.Tensor'\n image_size = int(np.sqrt(image.shape[0]))\n image = image.view(image_size, image_size)\n \n fig = plt.imshow(image, cmap = 'gray')\n fig.axes.get_xaxis().set_visible(False)\n fig.axes.get_yaxis().set_visible(False)\n plt.show()\n plt.close('all')",
"def show(image):\n fig = pyplot.figure()\n ax = fig.add_subplot(1,1,1)\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\n imgplot.set_interpolation('nearest')\n ax.xaxis.set_ticks_position('top')\n ax.yaxis.set_ticks_position('left')\n pyplot.show()",
"def display(self, image):\n assert(image.mode == '1')\n assert(image.size[0] == self.width)\n assert(image.size[1] == self.height)\n\n self.command(\n const.COLUMNADDR, 0x00, self.width-1, # Column start/end address\n const.PAGEADDR, 0x00, self.pages-1) # Page start/end address\n\n pix = list(image.getdata())\n step = self.width * 8\n buf = []\n for y in xrange(0, self.pages * step, step):\n i = y + self.width-1\n while i >= y:\n byte = 0\n for n in xrange(0, step, self.width):\n byte |= (pix[i + n] & 0x01) << 8\n byte >>= 1\n\n buf.append(byte)\n i -= 1\n\n self.data(buf)",
"def display_image(obj):\n\n # Hard code 30x30 due to Django admin template list size.\n return format_html(\n '<img src=%s alt=\"Profile picture\" width=\"30\" height=\"30\" />' %\n (obj.image.url if obj.image else static(\"images/users/default-profile.jpg\"))\n )",
"def visualizeImg(img):\n plt.figure(figsize=(10,4))\n plt.imshow(img)\n plt.show()",
"def show_image(img, title):\n cv2.imshow(title, img) # show pic\n k = cv2.waitKey(0)\n if k == 27: # wait until esc\n cv2.destroyAllWindows()",
"async def imageShow(self, ctx: Context, name: str, imageType=\"icons\"):\n imageSingular = self.getSingularImageType(imageType)\n\n # Check to see if this icon exists in dictionary\n images = await self.config.guild(ctx.guild).get_attr(imageType)()\n if name not in images.keys():\n await ctx.send(f\"This {imageSingular} doesn't exist!\")\n return\n\n filepath = self.getFullFilepath(ctx.guild, images[name], imageType=imageType)\n\n # Send file to discord\n try:\n image = discord.File(filepath, filename=images[name][\"filename\"])\n await ctx.send(file=image)\n except FileNotFoundError:\n await ctx.send(error(\"The file does not exist\"))\n self.logger.error(\"File does not exist %s\", filepath)",
"def imdisplay(filename, representation):\n im = read_image(filename, representation)\n if representation == 1:\n plt.imshow(im, cmap='gray')\n plt.show()\n if representation == 2:\n plt.imshow(im)\n plt.show()",
"def show_image(im, rescale=False) :\r\n \r\n plt.figure()\r\n im = im.copy()\r\n im.resize(*LFW_IMAGESIZE)\r\n if rescale :\r\n plt.imshow(im.astype(float), cmap=plt.cm.get_cmap(\"gray\"))\r\n else :\r\n plt.imshow(im.astype(float), cmap=plt.cm.get_cmap(\"gray\"), vmin=0, vmax=255)\r\n plt.axis('off')\r\n plt.show()",
"def main():\n images = Images()\n #print images.create_image_urls()\n print images.get_image_random()\n print images.get_image(12)",
"def display_image(self, window_title: str = 'Drone Camera'):\n cv2.imshow(window_title, self.output)\n cv2.waitKey(1)",
"def image(self, path):\n im = Image.open(path).convert(\"RGB\")\n # Convert the RGB image in printable image\n self._convert_and_print_image(im)",
"def _image(filename):\n return TK.PhotoImage(file=filename)",
"def showImage(self, img):\n cv2.namedWindow(self.NAME_WINDOW,cv2.WINDOW_NORMAL)\n cv2.resizeWindow(self.NAME_WINDOW, 300, 700)\n cv2.imshow(self.NAME_WINDOW , img)\n cv2.waitKey(0)",
"def show_image(img, greyscale=False, ordering='channel_last'):\n # to channel_last if channel exists\n if len(img.shape) > 2 and ordering == 'channel_first':\n img = np.moveaxis(img, 0, -1)\n\n if img.dtype == np.uint8 and np.max(img) <= 1:\n img = img * 255\n\n img = np.squeeze(img)\n if greyscale or len(img.shape) < 3:\n plt.imshow(img, cmap='gray')\n return\n \n plt.imshow(img)",
"def show_one(img):\n dpi = 40\n margin = 0.05\n nda = sitk.GetArrayFromImage(img)\n spacing = img.GetSpacing()\n extent = (0, nda.shape[1] * spacing[1], nda.shape[0] * spacing[0], 0)\n figsize = (5, 5)\n fig = plt.figure(figsize=figsize, dpi=dpi)\n ax = fig.add_axes([margin, margin, 1 - 2 * margin, 1 - 2 * margin])\n\n plt.set_cmap(\"gray\")\n ax.imshow(nda, extent=extent, interpolation=None)",
"def show(self, exec_rasterize = False):\n\n if (exec_rasterize):\n self.rasterize()\n\n Image.fromarray(self._image).show()",
"def show_img(\n X: np.ndarray,\n file_prefix=None,\n file_suffix='.png',\n scale=None,\n show=True,\n **kwargs,\n) -> Optional[PIL.Image.Image]:\n kwargs.setdefault('origin', 'upper') # Sane default: image is oriented like print(X)\n path = tempfile.mktemp(prefix='%s-' % file_prefix, suffix=file_suffix)\n plt.imsave(path, X, **kwargs)\n\n # XXX Can't resize IPython.display.Image\n # display(IPython.display.Image(filename=path))\n\n # Can resize PIL.Image\n image = PIL.Image.open(path)\n if scale:\n if isinstance(scale, (int, float)):\n scale = dict(wx=scale, hx=scale)\n elif isinstance(scale, (tuple, list)):\n (wx, hx) = scale\n scale = dict(wx=wx, hx=hx)\n scale = dict(scale) # Copy so we can mutate\n scale.setdefault('wx', 1)\n scale.setdefault('hx', 1)\n if 'w' not in scale and 'h' not in scale:\n scale['w'] = int(scale['wx'] * image.size[0])\n scale['h'] = int(scale['hx'] * image.size[1])\n elif 'w' not in scale:\n scale['w'] = int(scale['h'] / image.size[1] * image.size[0])\n elif 'h' not in scale:\n scale['h'] = int(scale['w'] / image.size[0] * image.size[1])\n scale.setdefault('resample', PIL.Image.NEAREST)\n image = image.resize((scale['w'], scale['h']), resample=scale['resample'])\n\n if show:\n display(image)\n else:\n return image",
"def show_images(images):\n for name, img in images:\n cv2.imshow(name, img)\n\n cv2.waitKey(0)",
"def show_image(img_name, title='Fig', grayscale=False):\n\n if not grayscale:\n plt.imshow(img_name)\n plt.title(title)\n plt.show()\n else:\n plt.imshow(img_name, cmap='gray')\n plt.title(title)\n plt.show()",
"def print_image(indiv,name):\n routine = gp.compile(indiv,pset)\n output = gen_beat_output(routine)\n bits = np.array(map(bitlist,output)[0:24000]).transpose()\n plt.style.use('classic')\n plt.imshow(bits,interpolation='nearest',aspect='auto',cmap=plt.get_cmap('Greys'))\n plt.savefig(name+\".png\",dpi=150)",
"def fileCmd(self):\n filename = askopenfilename() \n self.cnvImgOrig.displayImage(filename)\n self.cnvImgTest.displayImage(filename)",
"def display(img, name=\"IMAGE\", wait=0):\n\tcv2.namedWindow(name, cv2.WINDOW_NORMAL)\n\tcv2.imshow(name, img)\n\tcv2.waitKey(wait) & 0xFF\n\tcv2.destroyAllWindows()",
"def show_and_save_image(img, save_path):\n try:\n import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top\n except ImportError as e:\n tf.logging.warning(\n \"Showing and saving an image requires matplotlib to be \"\n \"installed: %s\", e)\n raise NotImplementedError(\"Image display and save not implemented.\")\n plt.imshow(img)\n with tf.gfile.Open(save_path, \"wb\") as sp:\n plt.savefig(sp)",
"def show(img, win_name='qr code'):\n cv2.imshow(win_name, img)\n cv2.waitKey(0)",
"def show_images(images, db):\n images = [int(image) for image in images]\n files = get_img_files(images, db)\n show_files(files)",
"def print_image(img):\r\n # On affiche l'image\r\n plt.figure(figsize=(20, 5))\r\n plt.subplot(1, 2, 1)\r\n plt.imshow(img)\r\n # On affiche l'histogramme\r\n plt.subplot(1, 2, 2)\r\n plt.hist(img.flatten(), bins=range(256))\r\n plt.show()"
] | [
"0.8048858",
"0.8006258",
"0.77966094",
"0.77039",
"0.7659002",
"0.7594677",
"0.7467195",
"0.738566",
"0.73560387",
"0.7331477",
"0.7289763",
"0.72389597",
"0.71857244",
"0.71550286",
"0.71386063",
"0.71089727",
"0.7097741",
"0.70939577",
"0.7092677",
"0.70303416",
"0.7018979",
"0.6999921",
"0.69989127",
"0.69983417",
"0.69781154",
"0.69271106",
"0.6922351",
"0.692038",
"0.6907098",
"0.68886",
"0.68590915",
"0.68249935",
"0.67761916",
"0.67752516",
"0.6767197",
"0.6754646",
"0.67199403",
"0.67082334",
"0.6678593",
"0.6677901",
"0.6668056",
"0.66535413",
"0.66523856",
"0.66523856",
"0.66523856",
"0.6636702",
"0.6630889",
"0.66142046",
"0.66130626",
"0.66023356",
"0.6592119",
"0.6576722",
"0.6575201",
"0.65602267",
"0.6544909",
"0.6544519",
"0.65360606",
"0.65356797",
"0.6508662",
"0.6508238",
"0.64635026",
"0.6459484",
"0.64582074",
"0.64502835",
"0.64446765",
"0.6444133",
"0.64433783",
"0.6435964",
"0.6421308",
"0.6416062",
"0.6413358",
"0.64007914",
"0.6390775",
"0.638794",
"0.6370346",
"0.63665825",
"0.63650376",
"0.63611925",
"0.63447136",
"0.63330853",
"0.63281554",
"0.63042665",
"0.62965274",
"0.62895757",
"0.62836385",
"0.6283443",
"0.6271355",
"0.62631524",
"0.6260019",
"0.6259989",
"0.62563723",
"0.62473965",
"0.6245319",
"0.62391925",
"0.6238639",
"0.62279654",
"0.62263364",
"0.6224828",
"0.62233764",
"0.6213758"
] | 0.68926775 | 29 |
Given a set of images, show an animation. | def animate(images):
images = np.array(images)
converted_images = np.clip(images * 255, 0, 255).astype(np.uint8)
imageio.mimsave('./animation.gif', converted_images)
return embed.embed_file('./animation.gif') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_images(images):\n for name, img in images:\n cv2.imshow(name, img)\n\n cv2.waitKey(0)",
"def display_images(filenames):\n for filename in filenames:\n display(Image(filename))",
"def display_frames_as_gif(frames):\n fig=e.cube.show_layout(frames[0]) \n print(\"Drawn\")\n def animate(i):\n return e.cube.update_plot(frames[i])\n anim = animation.FuncAnimation(fig, animate, frames = len(frames), interval=50,blit=True)",
"def animate(frames):\n plt.grid('on')\n ax = plt.gca()\n ax.set_xticks(np.arange(0.5, 10, 1))\n ax.set_yticks(np.arange(0.5, 10, 1))\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n\n for i in range(len(env_list)):\n ax.imshow(env_list[i],cmap='binary')\n plt.pause(0.05)",
"def show(images, concat=True, return_plots=False):\r\n if concat:\r\n images = np.concatenate([img_to_rgb(img) for img in images], axis=1)\r\n return show([images], concat=False, return_plots=return_plots)\r\n else:\r\n plots = []\r\n for img in images:\r\n fig = plt.figure(figsize=(15, 7))\r\n plots.append(fig)\r\n plt.imshow((img * 255).astype(np.uint8))\r\n plt.show()\r\n if return_plots:\r\n return plots",
"def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')",
"def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()",
"def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()",
"def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()",
"def show_images(images, cols = 1, titles = None):\n import matplotlib.pyplot as plt\n import numpy as np\n \n assert((titles is None) or (len(images) == len(titles)))\n n_images = len(images)\n if titles is None: titles = ['Frame %d' % i for i in range(n_images)]\n fig = plt.figure()\n for n, (image, title) in enumerate(zip(images, titles)):\n a = fig.add_subplot(np.ceil(n_images/float(cols)), cols, n + 1)\n if image.ndim == 2:\n plt.gray()\n plt.imshow(image)\n a.set_title(title, size = 50)\n a.axis('off')\n fig.set_size_inches(np.array(fig.get_size_inches()) * n_images)\n plt.show()",
"def matplotlibDisplayMulti(imgs, titles=None, colorFlag='gray'):\n if titles is None:\n titles = []\n for i in range(len(imgs)):\n titles.append(\"IMAGE \" + str(i))\n for i in range(len(imgs)):\n plt.subplot(1, len(imgs), 1+i)\n plt.imshow(imgs[i], colorFlag)\n plt.title(titles[i])\n plt.xticks([])\n plt.yticks([])\n plt.show()",
"def show_images_pyplot(images, titles, cols=1):\n assert len(images) == len(titles), 'Every image should have unique title!'\n n_images = len(images)\n fig = plt.figure()\n for n, (image, title) in enumerate(zip(images, titles)):\n a = fig.add_subplot(cols, np.ceil(n_images / float(cols)), n + 1)\n if image.ndim == 2:\n plt.gray()\n plt.axis('off')\n plt.imshow(image)\n a.set_title(title)\n manager = plt.get_current_fig_manager()\n manager.resize(*manager.window.maxsize())\n plt.show()",
"def animate(directory,gifname,n_t,step=2,duration=0.2):\n\t# create list of filenames\n\tfnames = dir_fname(directory,\"*\")\n\t# create list of plots\n\timages=[] \n\tfor k in range(0,n_t):\n\t\tk = k*step\n\t\tprint('Mounting Im '+ str(k))\n\t\tFIG_NAME=fnames[k]\n\t\timages.append(imageio.imread(FIG_NAME)) # read\n\t# Now we can assemble the video\n\timageio.mimsave(gifname, images,duration=duration) # create gif\n\tprint('Animation'+gifname+'Ready')\n\treturn True",
"def make_movie_views(self, animation, filename=\"brainmovie%07d.png\", \n offset=0, fps=30, size=(1920, 1080), alpha=1, frame_sleep=0.05,\n frame_start=0, interpolation=\"linear\"):\n allframes = self._get_anim_seq(animation, fps, interpolation)\n for fr, frame in enumerate(allframes[frame_start:], frame_start):\n self._set_view(**frame)\n time.sleep(frame_sleep)\n self.getImage(filename%(fr+offset+1), size=size)\n time.sleep(frame_sleep)",
"def show_images_opencv(images, titles):\n assert len(images) == len(titles), 'Every image should have unique title!'\n for img, title in zip(images, titles):\n cv2.imshow(title, img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def setAnimations(*args):",
"def visualize(**images):\r\n n_images = len(images)\r\n plt.figure(figsize=(20, 8))\r\n for idx, (name, image) in enumerate(images.items()):\r\n plt.subplot(1, n_images, idx + 1)\r\n plt.xticks([])\r\n plt.yticks([])\r\n # get title from the parameter names\r\n plt.title(name.replace('_', ' ').title(), fontsize=20)\r\n plt.imshow(image)\r\n plt.show()",
"def show_images(images, cols = 1, titles = None):\n params = {'axes.titlesize': 8,\n 'axes.labelsize': 8,\n 'font.size': 8,\n 'legend.fontsize': 8,\n 'xtick.labelsize': 8,\n 'ytick.labelsize': 8,\n 'font.family': 'DejaVu Serif',\n 'font.serif': 'Computer Modern',\n }\n plt.rcParams.update(params)\n assert((titles is None)or (len(images) == len(titles)))\n n_images = len(images)\n if titles is None: titles = ['Image (%d)' % i for i in range(1,n_images + 1)]\n fig = plt.figure()\n plt.title(\"Point Shift Sweeps from -30 to 30\")\n \n for n, (image, title) in enumerate(zip(images, titles)):\n \n a = fig.add_subplot(cols, np.ceil(n_images/float(cols)), n + 1)\n a.get_yaxis().set_visible(False)\n a.get_xaxis().set_visible(False)\n\n if image.ndim == 2:\n plt.gray()\n plt.imshow(image, origin='lower') \n fig.set_size_inches(np.array(fig.get_size_inches()))\n \n\n plt.show()",
"def browse_images(images, titles=None):\n\n if titles == None:\n titles = [i for i in range(len(images))]\n\n n = len(images)\n\n def view_image(i):\n plt.imshow(images[i][:, :, ::-1], cmap=plt.cm.gray_r, interpolation='nearest')\n plt.title(titles[i], y=-0.5)\n plt.show()\n\n interact(view_image, i=(1, n - 1))",
"def show_images(images, cols=1, titles=None):\n assert ((titles is None) or (len(images) == len(titles)))\n n_images = len(images)\n if titles is None: titles = ['Image (%d)' % i for i in range(1, n_images + 1)]\n fig = plt.figure()\n for n, (image, title) in enumerate(zip(images, titles)):\n a = fig.add_subplot(cols, np.ceil(n_images / float(cols)), n + 1)\n if image.ndim == 2:\n plt.gray()\n plt.imshow(image)\n a.set_title(title)\n fig.set_size_inches(np.array(fig.get_size_inches()) * n_images)\n plt.show()",
"def display_images(images, imageConversion=cv.COLOR_BGR2RGB, titles=[], columns=4, rows=None, show=True):\n if not show:\n return\n if imageConversion is not None:\n images = [cv.cvtColor(img, imageConversion) for img in images]\n\n # append filtered image\n if rows is None:\n rows = ceil(float(len(images)) / columns)\n\n try:\n for i in xrange(len(images)):\n plt.subplot(rows,columns,i+1),plt.imshow(images[i],'gray')\n if titles:\n plt.title(titles[i])\n plt.xticks([]),plt.yticks([])\n plt.show()\n except:\n logging.exception(\"Could not plot / show images. Saving instead.\")\n save_plt_figure(plt, \"img_show\")",
"def show_images(processed_video, unprocessed_video, arraylength, isFirst, levels, calculating_boarder, fps):\n processed_video = upsample_images(processed_video, unprocessed_video, arraylength, levels)\n if not isFirst:\n processed_video = processed_video[-calculating_boarder:]\n for image in processed_video:\n time.sleep(1/fps)\n cv2.imshow(\"colour changes pulse\", image)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break",
"def show_images(images, cols=1, titles=None):\n assert((titles is None)or (len(images) == len(titles)))\n n_images = len(images)\n if titles is None: titles = ['Image (%d)' % i for i in range(1,n_images + 1)]\n fig = plt.figure()\n for n, (image, title) in enumerate(zip(images, titles)):\n a = fig.add_subplot(cols, np.ceil(n_images/float(cols)), n + 1)\n if image.ndim == 2:\n plt.gray()\n plt.imshow(image)\n a.set_title(title)\n fig.set_size_inches(np.array(fig.get_size_inches()) * n_images)\n plt.show()",
"def display_animation(anim):\n plt.close(anim._fig)\n return HTML(anim_to_html(anim))",
"def show_images(images, cols = 1, titles = None):\n assert((titles is None)or (len(images) == len(titles)))\n n_images = len(images)\n if titles is None: titles = ['Image (%d)' % i for i in range(1,n_images + 1)]\n fig = plt.figure()\n for n, (image, title) in enumerate(zip(images, titles)):\n a = fig.add_subplot(cols, np.ceil(n_images/float(cols)), n + 1)\n if image.ndim == 2:\n plt.gray()\n plt.imshow(image)\n a.set_title(title)\n fig.set_size_inches(np.array(fig.get_size_inches()) * n_images)\n plt.show()",
"def show_images(images, cols = 1, titles = None):\n assert((titles is None)or (len(images) == len(titles)))\n n_images = len(images)\n if titles is None: titles = ['Image (%d)' % i for i in range(1,n_images + 1)]\n fig = plt.figure()\n for n, (image, title) in enumerate(zip(images, titles)):\n a = fig.add_subplot(cols, np.ceil(n_images/float(cols)), n + 1)\n if image.ndim == 2:\n plt.gray()\n plt.imshow(image)\n a.set_title(title)\n fig.set_size_inches(np.array(fig.get_size_inches()) * n_images)\n plt.show()",
"def show_files(file_locations):\n for file_loc in file_locations:\n show_image(file_loc)",
"def display_imgs(img_dir,img_list):\n for img in img_list:\n display_img(img_dir, img)",
"def showImages(images):\n idx = 0\n\n while True:\n\n cv2.imshow(\"Image\", images[idx])\n\n if cv2.waitKey(15) & 0xFF == ord(\"d\"):\n if idx+1 >= len(images):\n print(\"This is the last image in the set.\")\n else:\n idx += 1\n print(\"Viewing image no. {0} / {1}\".format(idx+1, len(images)))\n\n if cv2.waitKey(15) & 0xFF == ord(\"a\"):\n if idx-1 < 0:\n print(\"This is the first image in the set.\")\n else:\n idx -= 1\n print(\"Viewing image no. {0} / {1}\".format(idx+1, len(images)))\n\n if cv2.waitKey(15) & 0xFF == ord(\"q\"):\n break",
"def display_keyframes(self):\n\n if len(self.keyframe_inds) > 0:\n image_stack = []\n for keyframe_index in self.keyframe_inds:\n keyframe_image = self.images[keyframe_index]\n keyframe_depth = self.depths[keyframe_index]\n\n image_and_depth = vis.create_image_depth_figure(keyframe_image, keyframe_depth)\n image_stack.append(image_and_depth)\n\n image_stack = np.concatenate(image_stack, axis=0)\n if len(self.keyframe_inds) > 1:\n image_stack = cv2.resize(image_stack, None, fx=0.5, fy=0.5)\n\n cv2.imshow('keyframes', image_stack / 255.0)\n cv2.waitKey(10)",
"def grid_animation_quick(self, frames, iterations=10, fps=0.02, figsize=(6, 6)):\r\n color_map = matplotlib.colors.ListedColormap(['white', 'black'])\r\n\r\n fig, ax = plt.subplots(figsize=figsize)\r\n\r\n for r in np.arange(0, iterations):\r\n ax.cla()\r\n ax.axes.grid(False)\r\n ax.set_axis_off()\r\n im = ax.imshow(frames[0], cmap=color_map, animated=True)\r\n for image, step in zip(frames[1:], np.arange(1, len(frames[1:])+1)):\r\n time.sleep(fps)\r\n ax.title.set_text('Rule 942 | Step ' + str(step) + ' | Active ' + str(int(np.sum(image))))\r\n im.set_data(image)\r\n fig.canvas.draw()",
"def plot_many_images(images, titles, rows=1, columns=2):\n for i, image in enumerate(images):\n plt.subplot(rows, columns, i + 1)\n plt.imshow(image, \"gray\")\n plt.title(titles[i])\n plt.xticks([]), plt.yticks([]) # Hide tick marks\n plt.show()",
"def show_images(images, level,cols = 1,titles = None):\n assert((titles is None)or (len(images) == len(titles)))\n n_images = len(images)\n if titles is None: titles = ['Image (%d)' % i for i in range(1,n_images + 1)]\n fig = plt.figure()\n for n, (image, title) in enumerate(zip(images, titles)):\n a = fig.add_subplot(cols, np.ceil(n_images/float(cols)), n + 1)\n if image.ndim == 2:\n plt.gray()\n plt.imshow(image)\n a.set_title(title)\n fig.set_size_inches(np.array(fig.get_size_inches()) * n_images)\n plt.savefig(\"SteerablePyramid/level\"+ str(level) +\".png\")\n plt.clf()",
"def show_images(images, db):\n images = [int(image) for image in images]\n files = get_img_files(images, db)\n show_files(files)",
"def create_gif(self, number_of_images=80, duration=0.1, output_filename=\"plot.gif\"):\n if self.quick_plot is None:\n self.quick_plot = pybamm.QuickPlot(self._solution)\n\n self.quick_plot.create_gif(\n number_of_images=number_of_images,\n duration=duration,\n output_filename=output_filename,\n )",
"def display_frames_as_gif(frames, video_name):\n Writer = animation.writers['ffmpeg']\n writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)\n #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\n patch = plt.imshow(frames[0])\n plt.axis('off')\n\n def animate(i):\n patch.set_data(frames[i])\n\n anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\n# display(display_animation(anim, default_mode='loop'))\n anim.save(result_floder + '/' + video_name, writer=writer)",
"def show_images(images, save=None, size=None):\n assert len(images) > 0, \"images should contain at least 1 element\"\n assert len(images[0].shape) == 3, \"each image should contain 3 elements (c, w,h)\"\n \n fig, ax = plt.subplots(nrows=images[0].shape[0], ncols=len(images))\n \n for i in range(len(images)): \n for j in range(images[0].shape[0]):\n ax[i,j].imshow(images[i][j,:,:], cmap='gray')\n \n plt.show()",
"def displayImgs(imgs, titles = None, wait=0):\n\tif len(imgs) > 100:\n\t\tprint \"WARNING: DisplayImgs: List is of length \" + str(len(imgs))\n\t\tprint \"Please reduce list size to avoid improper display\"\n\t\treturn\n\tif titles is None:\n\t\tcount = 1\n\t\tfor i in imgs:\n\t\t\tcv2.namedWindow(\"IMAGE\" + str(count), cv2.WINDOW_NORMAL)\n\t\t\tcv2.imshow(\"IMAGE\" + str(count), i)\n\t\t\tcount += 1\n\telse:\n\t\tcount = 0\n\t\tfor i in imgs:\n\t\t\tcv2.namedWindow(titles[count], cv2.WINDOW_NORMAL)\n\t\t\tcv2.imshow(titles[count], i)\n\t\t\tcount += 1\n\tcv2.waitKey(wait) & 0xFF\n\tcv2.destroyAllWindows()",
"def write_frames(self, images):\n for img in images:\n self.write_frame(img)",
"def do_animations(self):\n self.animate_bloop(700, 160, 50)",
"def plotImages(images_arr):\n \n fig, axes = plt.subplots(1, 5, figsize=(20,20))\n axes = axes.flatten()\n for img, ax in zip( images_arr, axes):\n ax.imshow(img)\n ax.axis('off')\n plt.tight_layout()\n plt.show()\n \n return",
"def graphical(cls, images):\n images = [(plt.imread(i), i.split(os.path.sep)[-1]) for i in images]\n views = [View(ViewPosition.click(img, path), img, img) for img, path in images]\n return cls(views)",
"def show_four_images(img1, img2, img3, img4, title):\n shape = (460, 250)\n # Get all images in same size for better display\n img1 = cv2.resize(img1, shape)\n img2 = cv2.resize(img2, shape)\n img3 = cv2.resize(img3, shape)\n img4 = cv2.resize(img4, shape)\n # combined 2 images horizontally\n numpy_horizontal1 = np.hstack((img1, img2))\n # combined the rest 2 images horizontally\n numpy_horizontal2 = np.hstack((img3, img4))\n # now combined all vertically to 1 image and display\n numpy_vertical = np.vstack((numpy_horizontal1, numpy_horizontal2))\n # final thing - show the output:\n show_image(numpy_vertical, title)",
"def animate(self,frame,im = None):\n # With matplotlib, it's much, much faster to just update the properties\n # of a display object than it is to create a new one, so we'll just update\n # the data and position of the same objects throughout this animation...\n\n # Since we're making an animation with matplotlib, we need \n # ion() instead of show()...\n fig = plt.gcf()\n ax = plt.axes([.25, .55, .6, .4], facecolor='y')\n plt.axis('off')\n\n # Make an image based on the first frame that we'll update later\n # (The first frame is never actually displayed)\n if im is None:\n plt.imshow(frame,cmap='brg')\n else:\n plt.imshow(im)\n plt.title('Image Space')\n\n # Make 4 rectangles that we can later move to the position of each paw\n rects = [Rectangle((0,0), 1,1, fc='none', ec='red') for i in range(4)]\n [ax.add_patch(rect) for rect in rects]\n\n\n # Process and display each frame\n\n paw_slices = self.find_paws(frame)\n\n # Hide any rectangles that might be visible\n [rect.set_visible(False) for rect in rects]\n\n # Set the position and size of a rectangle for each paw and display it\n for slice, rect in zip(paw_slices, rects):\n dy, dx = slice\n rect.set_xy((dx.start, dy.start))\n rect.set_width(dx.stop - dx.start + 1)\n rect.set_height(dy.stop - dy.start + 1)\n rect.set_visible(True)",
"def show_shot(path_to_images, name_image):\n crrt_image = misc.imread(\"./{}/{}\".format(path_to_images, name_image))\n\n plt.imshow(crrt_image)\n\n plt.draw()\n plt.pause(0.5)",
"def load_images(self):\r\n self.standing_frame = [load_image(\"cat1.png\")]\r\n self.walk_frames_r = [load_image(\"cat2.png\"), load_image(\"cat3.png\"),\r\n load_image(\"cat4.png\")]",
"def visualize_MTL(**images):\r\n n = len(images)\r\n plt.figure(figsize=(16, 5))\r\n for i, (name, image) in enumerate(images.items()):\r\n if image==None:\r\n continue\r\n else:\r\n plt.subplot(1, n, i + 1)\r\n plt.xticks([])\r\n plt.yticks([])\r\n plt.title(' '.join(name.split('_')).title())\r\n plt.imshow(image)\r\n plt.show()",
"def _spin_up(self, images, duration):\n total = 0\n # pylint: disable=no-member\n\n for image in images:\n self.microbit.display.show(image)\n time.sleep(0.05)\n total += 0.05\n if total >= duration:\n return\n remaining = duration - total\n self._full_speed_rumble(images[-2:], remaining)\n self.set_display()",
"def show(self):\r\n\r\n anim = animation.FuncAnimation(self.fig, self.animate, \r\n frames=list(self.object_stream), repeat=False,\r\n interval=self.interval, blit=self.blit)\r\n\r\n super().show()",
"def plot_images(imgs, caption=''):\n global vis\n if len(imgs.shape) == 3:\n imgs = np.expand_dims(imgs, axis=0)\n if imgs.shape[-1] == 3 or imgs.shape[-1] == 1:\n imgs = imgs.transpose((0, 3, 1, 2))\n opts = dict(caption=caption)\n win = vis.images(np.clip(imgs, 0, 255), opts=opts)\n return win",
"def compose_in_gif(images, output_file, delay):\n images[0].save(\n output_file, \n format='GIF', append_images=images[1:], \n save_all=True, duration=delay, loop=0,\n )",
"def visualize(**images):\n n_images = len(images)\n plt.figure(figsize=(20,8))\n for idx, (name, image) in enumerate(images.items()):\n plt.subplot(1, n_images, idx + 1)\n plt.xticks([]); \n plt.yticks([])\n # get title from the parameter names\n plt.title(name.replace('_',' ').title(), fontsize=20)\n plt.imshow(image)\n plt.savefig('sample_gt_pred_2_max.jpeg')\n plt.show()",
"def AddImageFrames(self):\n img_lst = self.CollectImageFilenames()\n for img in img_lst:\n img_exist_ptrn = re.compile(r'.*({}).*'.format(img))\n if not img_exist_ptrn.search(self._latex_str):\n self._latex_str += bmr_frame.format(img, img.replace('_', ' '))\n print(\"Added image {}.\".format(img))",
"def images_show(images: Sequence, labels: Sequence[str] = None, title: str = '') -> None:\n\n nb_img = len(images)\n\n if nb_img == 0:\n raise ValueError('No image to print')\n\n # Only on image, no need of subplot\n if nb_img == 1:\n plt.imshow(images[0], interpolation='none')\n plt.axis('off')\n title_str = ''\n if title:\n title_str = title\n if labels and len(labels) > 0 and labels[0]:\n if len(title_str) > 0:\n title_str += '\\n' + labels[0]\n else:\n title_str = labels[0]\n if len(title_str) > 0:\n plt.title(title_str)\n\n # More than 1 image\n else:\n if nb_img < 4:\n # For 3 or below just plot them in one line\n nb_rows = 1\n nb_cols = nb_img\n else:\n nb_rows = nb_cols = ceil(sqrt(nb_img))\n nb_rows = ceil(nb_img / nb_rows) # Remove empty rows if necessary\n\n # Create subplots\n fig, axs = plt.subplots(nrows=nb_rows, ncols=nb_cols, figsize=(nb_cols * 2, nb_rows * 2 + 1))\n\n for row in range(nb_rows):\n for col in range(nb_cols):\n i = row * nb_cols + col\n if nb_rows == 1:\n ax = axs[col]\n else:\n ax = axs[row, col]\n # Disable axis even if no image\n ax.axis('off')\n # Add image and image caption\n if i < len(images):\n ax.imshow(images[i], interpolation='none')\n if labels and len(labels) > i and labels[i]:\n ax.set_title(labels[i])\n\n if title:\n fig.suptitle(title)\n\n # Adjust the padding between and around subplots\n plt.tight_layout()\n # Show it\n plt.show()",
"def show_fashion_mnist(images, labels):\n use_svg_display()\n # the '_' here means we don't need that parameter\n # here init a figure to plot images\n _, figs = plt.subplots(1, len(images), figsize=(12, 12))\n for f, img, lbl in zip(figs, images, labels):\n # show the image\n f.imshow(img.view(28, 28).numpy())\n # set title\n f.set_title(lbl)\n # hide the x and y axis\n f.axes.get_xaxis().set_visible(False)\n f.axes.get_yaxis().set_visible(False)\n # show the plot figure\n plt.show()",
"def show_images(imgs, num_rows, num_cols, scale=2):\n figsize = (num_cols*scale, num_rows*scale)\n _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)\n for i in range(num_rows):\n for j in range(num_cols):\n # show the target image\n axes[i][j].imshow(imgs[i*num_cols+j])\n # set the sub-axis to be invisible\n axes[i][j].axes.get_xaxis().set_visible(False)\n axes[i][j].axes.get_yaxis().set_visible(False)\n # remember to show figure at last\n plt.show()\n return axes",
"def animate_with_pil_frame_sequence(self, pil_frame_sequence, frames_per_second=15):\n\n sleep_time = 1/frames_per_second\n for animation_frame in pil_frame_sequence:\n tic = time.time()\n self._set_image_from_pil_image(animation_frame)\n self.update()\n toc = time.time()\n frame_generation_time = toc-tic\n if frame_generation_time < sleep_time:\n new_sleep_time = sleep_time - frame_generation_time\n time.sleep(new_sleep_time)\n else:\n pass",
"def show_imgs(dataset, n_imgs, plot_size=(15, 15), cmap=None):\n n_cols = int(np.sqrt(n_imgs))\n n_rows = int(np.ceil(np.sqrt(n_imgs)))\n class_idx = dataset.class_to_idx\n idx_class = idx_to_class(class_idx)\n\n fig, axes = plt.subplots(n_rows, n_cols, figsize=plot_size)\n for i, ax in enumerate(axes.flatten()):\n ax.axis('off')\n title = f'Class : {idx_class[dataset.targets[i]]}'\n ax.imshow(dataset.data[i], cmap=cmap)\n ax.set_title(title)\n fig.tight_layout()",
"def animated_popup():\r\n IMAGES = ['spin1.png', 'spin2.png', 'spin3.png', 'spin4.png', \r\n 'spin5.png', 'spin6.png', 'spin7.png', 'spin8.png']\r\n\r\n def image_iter() -> iter:\r\n \"\"\" create generator for animated popup images \"\"\"\r\n return ('Images/' + image for image in IMAGES)\r\n \r\n img = image_iter()\r\n \r\n layout = [[sg.Text('Testing network connection...')],[sg.Image(filename=next(img), key='LOAD')]]\r\n window = sg.Window('Loading...', layout=layout, element_justification='center', \r\n keep_on_top=True, grab_anywhere=True, no_titlebar=True)\r\n\r\n while not STATUS:\r\n window.read(timeout=80)\r\n try:\r\n window['LOAD'].update(filename=next(img))\r\n except StopIteration:\r\n img = image_iter()\r\n window['LOAD'].update(filename=next(img))\r\n window.close()\r\n sg.popup_ok('Complete!')",
"def plot_images(imgs_org, imgs_pred, nb_examples=10):\n if nb_examples == 0:\n return\n\n n = nb_examples\n plt.figure(figsize=(nb_examples * 2, 4))\n for i in range(n):\n # display original\n ax = plt.subplot(2, n, i + 1)\n plt.imshow(imgs_org[i].reshape(84, 84))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n\n # display reconstruction\n ax = plt.subplot(2, n, i + 1 + n)\n plt.imshow(imgs_pred[i].reshape(84, 84))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n plt.show()",
"def show(self, root):\n if isinstance(root, str):\n root = Image.open(root)\n frames_img = []\n try:\n for i in count(1):\n frames_img.append(ImageTk.PhotoImage(root.copy()))\n root.seek(i)\n except EOFError as e:\n pass\n # TODO: uncomment this line in final version\n # ls.get_logger().error(f'failed to load the picture, due to: {str(e)}')\n self.frames = cycle(frames_img)\n try:\n self.delay = root.info['duration']\n except:\n self.delay = 100\n if len(frames_img) == 1:\n self.config(image=next(self.frames))\n else:\n self.show_next_frame()",
"def plot_gallery(images, rescale=False, title=None, subtitles=[], n_row=4, n_col=5):\r\n \r\n plt.figure(figsize=(1.8*n_col, 2.4*n_row))\r\n if title:\r\n plt.suptitle(title, size=16)\r\n for i, comp in enumerate(images) :\r\n plt.subplot(n_row, n_col, i+1)\r\n if rescale :\r\n plt.imshow(comp.reshape(LFW_IMAGESIZE), cmap=plt.cm.get_cmap(\"gray\"))\r\n else :\r\n plt.imshow(comp.reshape(LFW_IMAGESIZE), cmap=plt.cm.get_cmap(\"gray\"), vmin=0, vmax=255)\r\n if subtitles:\r\n plt.title(subtitles[i], size=12)\r\n plt.axis('off')\r\n plt.show()",
"def fdplot(self, imx):\n fig = plt.figure()\n maxval = np.max(imx)\n ims = list(map(lambda im: [plt.imshow(np.fabs(im),norm=colors.Normalize(0.0,maxval))], imx))\n animation = anim.ArtistAnimation(fig,ims,interval=50)\n plt.show()",
"def output_images(self, images, callback=None):\n\n def _cb(*args):\n if callback:\n callback(*args)\n\n if len(images) == 0:\n return;\n\n image = images.pop(0) # remove the image as it's displayed to prevent duplicates\n _cb('image', image.msg_id, image.id, image.name, image.encode_preview(), image.type, image.date)\n self.output_images(self.extracted_images, callback)",
"def plot_images(images_dict, plotting=True):\n\n fig, axs = plt.subplots(len(images_dict), sharex=True, sharey=True)\n\n for key, fig in zip(images_dict, range(len(images_dict))):\n image = images_dict[key]\n axs[fig].imshow(image)\n\n if plotting:\n plt.plot()\n\n return fig, axs",
"def plot_predictions(images, filename):\n imagex = format_image(images, 4)\n mosaic = create_mosaic(imagex, 2, 2)\n plt.figure(figsize=(12, 12))\n plt.imshow(mosaic, cmap='gray')\n plt.axis('off')\n plt.savefig(filename + '.png', bbox_inches='tight')",
"def display_images():\n vc = cv2.VideoCapture(0) # Open webcam\n figure, ax = plt.subplots(1, 2, figsize=(10, 5)) # Intiialise plot\n\n count = 0 # Counter for number of aquired frames\n intensity = [] # Append intensity across time\n\n # For loop over generator here\n intensity.append(imageintensity)\n plot_image_and_brightness() # Call plot function\n count += 1\n\n # This triggers exit sequences when user presses q\n if cv2.waitKey(1) & 0xFF == ord('q'):\n # Clean up here\n plt.close('all') # close plots\n generator.close() # Use generator exit for clean up,\n break # break loop",
"def playAnimation(self, *args):\n return _osgAnimation.BasicAnimationManager_playAnimation(self, *args)",
"def _full_speed_rumble(self, images, duration):\n while duration > 0:\n self.microbit.display.show(images[0]) # pylint: disable=no-member\n time.sleep(0.04)\n self.microbit.display.show(images[1]) # pylint: disable=no-member\n time.sleep(0.04)\n duration -= 0.08",
"def show_images(imgs, num_rows, num_cols, scale=2):\n figsize = (num_cols * scale, num_rows * scale)\n _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)\n for i in range(num_rows):\n for j in range(num_cols):\n axes[i][j].imshow(imgs[i * num_cols + j].asnumpy())\n axes[i][j].axes.get_xaxis().set_visible(False)\n axes[i][j].axes.get_yaxis().set_visible(False)\n return axes",
"def at_anim(seq, anim, d):\n at(\"ANIM\", seq, [anim, d])",
"def anim_scatter_plot(points_list, values, \n fname=\"anim_scatter.mpg\", fps=2, *args, **kwargs):\n print \"Genrating temp images\"\n for idx, pts in enumerate(points_list):\n print \"\\tPlot %i of %i\" % (idx, len(points_list))\n scatter_plot(pts, values, \"_tmp_%i.png\" % idx, *args, **kwargs)\n print \"Creating animation\" \n os.system(\"mencoder 'mf://_tmp_*.png' -mf type=png:fps=%i -ovc\\\n lavc -lavcopts vcodec=wmv2 -oac copy -o %s\" % (fps, fname))\n print \"Removing temp files\"\n os.system(\"rm -f _tmp_*.png\")",
"def showSnapshots(self):\n from .utils import sp\n s = self.getSnapshots()\n ax = sp(len(s))\n for i, S in enumerate(s):\n ax[i].imshow(S)",
"def animate(self, phi_list, chi_list, omega_list, delay=0.02):\n for phi in phi_list:\n for chi in chi_list:\n for omega in omega_list:\n self.getplatepos(phi, chi, omega)\n self.plot_goniometer()\n time.sleep(delay)\n pass",
"def create_animations(figure, filename=None, sharing=\"public\", auto_open=True):\n # This function is no longer needed since plot now supports figures with\n # frames. Delegate to this implementation for compatibility\n return plot(figure, filename=filename, sharing=sharing, auto_open=auto_open)",
"def animate(i):\n plot_viz_x = []\n plot_viz_y = []\n for node in graph:\n node_x, node_y = node.position\n agent_count = node.agent_count\n\n for _ in range(0, agent_count):\n plot_viz_x.append(self._get_visual_position(node_x))\n plot_viz_y.append(self._get_visual_position(node_y))\n\n self.plots[0].set_data(plot_viz_x, plot_viz_y)\n self.plots[1].set_data(leader.visual[0], leader.visual[1])\n return self.plots",
"def im_show(img_list,title=['']):\n Error = False\n if title == ['']:\n title=[f'Image {i+1}' for i in range(len(img_list))]\n if len(title) != len(img_list):\n print('ERROR 1 (im_show)')\n Error = True\n if not Error:\n for i,img in enumerate(img_list):\n cv2.imshow(title[i],img)\n cv2.waitKey(0)\n cv2.destroyAllWindows()",
"def animate(frames, **kwds):\n return Animation(frames, **kwds)",
"def display_sample_images(self):\n if self.train_dataset is None:\n self.init_datasets()\n\n images, labels = next(self.train_dataset)\n plt.figure(figsize=(5,5))\n for n in range(min(25, images.shape[0])):\n ax = plt.subplot(5,5,n+1)\n plt.imshow(images[n])\n if len(labels.shape) == 1:\n plt.title(self.class_names[int(labels[n])].title())\n else:\n m = np.argmax(labels[n])\n plt.title(self.class_names[int(labels[n, m])].title())\n plt.axis('off')\n\n plt.tight_layout()\n plt.show()",
"def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5): #@save\n figsize = (num_cols * scale, num_rows * scale)\n _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)\n axes = axes.flatten()\n for i, (ax, img) in enumerate(zip(axes, imgs)):\n ax.imshow(d2l.numpy(img))\n ax.axes.get_xaxis().set_visible(False)\n ax.axes.get_yaxis().set_visible(False)\n if titles:\n ax.set_title(titles[i])\n return axes",
"def start_animation(self):\n\t\ttime.sleep(1)\n\t\tself.fishbowl.animate_balls()",
"def animate(i): \n ax1.clear()\n font_dict = {'family':'sans-serif',\n 'color':'darkred',\n 'size':8}\n for i in range(len(xt)):\n ax1.text(xt[i], yt[i], tt[i], fontdict=font_dict)\n ax1.plot(xs, ys)\n #ax1.scatter(xt, yt, 'yo')\n\n # This is for plotting the coordinates and the class of the detected object\n animated_plot = plt.plot(xt, yt, 'yo')[0]\n animated_plot.set_xdata(xt)\n animated_plot.set_ydata(yt)\n plt.draw()",
"def show_imgs(imgs, row, col):\n if len(imgs) != (row * col):\n raise ValueError(\n \"Invalid imgs len:{} col:{} row:{}\".format(len(imgs), row, col))\n\n for i, img in enumerate(imgs):\n plot_num = i+1\n plt.subplot(row, col, plot_num)\n plt.tick_params(labelbottom=False) # x軸の削除\n plt.tick_params(labelleft=False) # y軸の削除\n plt.imshow(img)\n plt.show()",
"def add_images(self, images_list, show_pbar=False):\n filenames = []\n if show_pbar:\n images_list = tqdm(images_list)\n for image in images_list:\n filenames.append(self.add_image(image))\n return filenames",
"def visualize_predictions(self, images, preds, targets):\n\n class_names = ['angry', 'happy', 'sad']\n images = images[:8]\n preds = preds[:8]\n targets = targets[:8]\n\n # determine size of the grid based for the given batch size\n num_rows = int(torch.tensor(len(images)).float().sqrt().floor())\n\n fig = plt.figure(figsize=(7, 7))\n for i in range(len(images)):\n plt.subplot(num_rows, len(images) // num_rows + 1, i+1)\n img = images[i].permute(1, 2, 0).cpu().numpy()\n img = np.array([0.229, 0.224, 0.225]) * img + np.array([0.485, 0.456, 0.406])\n img = np.clip(img, 0, 1)\n plt.imshow(img)\n plt.title(f'pred: {class_names[preds[i]]}'\n f'\\ntruth: [{class_names[targets[i]]}]')\n plt.axis('off')\n\n self.logger.experiment.add_figure(\n 'predictions', fig, global_step=self.global_step)",
"def show_images(imgs, nrows, ncols, figsize=None):\n figsize = (ncols, nrows)\n _, figs = plt.subplots(nrows, ncols, figsize=figsize)\n for i in range(nrows):\n for j in range(ncols):\n figs[i][j].imshow(imgs[i*ncols+j].asnumpy())\n figs[i][j].axes.get_xaxis().set_visible(False)\n figs[i][j].axes.get_yaxis().set_visible(False)\n plt.show()",
"def show_image(dataset, domain, image_class, image_name):\n\timage_file = io.imread(os.path.join(\"data\", dataset, domain, \"images\", image_class, image_name))\n\tplt.imshow(image_file)\n\tplt.pause(0.001)\n\tplt.figure()",
"def start_sim(self):\n self.anim = animation.FuncAnimation(self.fig, self.anim_func, frames = self.timesteps, interval = 1, blit=True)\n plt.show()",
"def view_images(dataset, size):\n images, labels = dataset\n assert images.shape[0] == labels.shape[0]\n\n num_images = images.shape[0]\n num_cols = 3\n num_rows = np.ceil(num_images / num_cols).astype(\"int\")\n plt.figure(figsize=size)\n for i in range(num_images):\n image = images[i]\n label = labels[i]\n ax = plt.subplot(num_rows, num_cols, i + 1)\n plt.imshow(np.array(image, dtype=\"float\"))\n plt.title(\"Number: \" + str(label))\n plt.axis(\"off\")",
"def run_animation(self):\n\n def _get_frame(frame_index, plots):\n \"\"\" Should be called by run_animations only. \"\"\"\n\n # TODO Using the indices of the self.frames, plot in correct location.\n # Okay right now there is a problem where it's unknown whether the set of coordinates\n # is a line or a dot -- that info got lost up there\n\n for amb_index in range(len(self.frames[frame_index])):\n xs = self.frames[frame_index][amb_index][0]\n ys = self.frames[frame_index][amb_index][1]\n\n # if len(xs) > 1:\n # if xs[0] == xs[1]:\n # plots[amb_index][1].set_data([xs[0]], [ys[0]])\n # if xs[-2] == xs[-1]:\n # plots[amb_index][1].set_data([xs[-1]], [ys[-1]])\n\n plots[amb_index][0].set_data(xs, ys)\n\n print(plots[len(self.ambulance_locations)])\n\n return plots,\n\n fig = plt.figure(figsize=(14, 8))\n\n # TODO need [number of ambulances] x [number of states]\n\n plots = []\n for i in range(len(self.ambulance_locations)):\n new_color = self.ambulance_colors[i]\n\n line_plot, = plt.plot([], [],\n marker='+',\n linestyle='',\n markerfacecolor=new_color,\n markeredgecolor=new_color,\n label=\"Ambulance {} Path\".format(i + 1))\n\n # dot_plot, = plt.plot([], [],\n # marker='o',\n # linestyle='',\n # markerfacecolor=new_color,\n # markeredgecolor=new_color)\n\n # plots.append([line_plot, dot_plot])\n\n plots.append([line_plot])\n\n base_plot = plt.scatter([base.longitude for base in self.bases],\n [base.latitude for base in self.bases],\n marker=\"D\", color=\"black\", label=\"Bases\")\n hospital_plot = plt.scatter([hospital.longitude for hospital in self.hospitals],\n [hospital.latitude for hospital in self.hospitals],\n marker=\"P\", color=\"r\", label=\"Hospitals\")\n\n plots.append(base_plot)\n plots.append(hospital_plot)\n\n # TODO Make boundaries parameters\n\n img = plt.imread(\"./visuals/simple.png\")\n plt.imshow(img, extent=[-117.017637, -117.167672, 32.710484, 32.823033])\n plt.legend(loc=\"upper right\")\n print(\"draw the animation\")\n ani = animation.FuncAnimation(fig, _get_frame, len(self.frames),\n fargs=(plots,), interval=50)\n\n plt.show()\n\n # fps = 15\n # print('save the animation')\n # print(\"it may take up to {}\".format(len(self.frames)/fps))\n # ani.save('regional_vis6.mp4', fps=fps, dpi=150)"
] | [
"0.6905455",
"0.6872684",
"0.68629754",
"0.6797282",
"0.66781235",
"0.6561315",
"0.6522247",
"0.6522247",
"0.6522247",
"0.6437156",
"0.6422651",
"0.6395544",
"0.6391225",
"0.63497686",
"0.63120157",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.62429947",
"0.6235614",
"0.62281764",
"0.6216612",
"0.62069076",
"0.62049395",
"0.61916256",
"0.6190184",
"0.61768305",
"0.6173066",
"0.6173066",
"0.6172273",
"0.6169124",
"0.6162418",
"0.6137297",
"0.6106282",
"0.6098531",
"0.6082471",
"0.6080413",
"0.6050795",
"0.6033436",
"0.60258865",
"0.6021975",
"0.6015738",
"0.6012602",
"0.6006107",
"0.59950167",
"0.59934807",
"0.59585214",
"0.5954317",
"0.5946946",
"0.5940692",
"0.58957094",
"0.5886332",
"0.58758175",
"0.58703196",
"0.58041537",
"0.5789685",
"0.57793456",
"0.5775244",
"0.57745284",
"0.5767155",
"0.5764301",
"0.57378054",
"0.572505",
"0.5723607",
"0.57225513",
"0.57190263",
"0.5698563",
"0.56966984",
"0.5686105",
"0.5676574",
"0.5676492",
"0.56761676",
"0.5670818",
"0.56683344",
"0.56548005",
"0.5640257",
"0.56381065",
"0.56297195",
"0.5624847",
"0.5624753",
"0.5599994",
"0.5598926",
"0.55972844",
"0.55898964",
"0.5578154",
"0.5575946",
"0.557054",
"0.5565315",
"0.5551381",
"0.554995",
"0.5546831",
"0.55424404",
"0.55415654"
] | 0.76514333 | 0 |
funkce vyhodnoti stav herniho pole | def vyhodnot(pole):
if "xxx" in pole:
return("x")
elif "ooo" in pole:
return("o")
elif "-" not in pole:
return("!")
else:
return("-") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pohyb(seznam_tahu, seznam_ovoce, tah,radky, sloupce):\n\n x= seznam_tahu [len(seznam_tahu)-1][0] # [x,y] souradnice noveho tahu\n y= seznam_tahu [len(seznam_tahu)-1][1]\n\n if tah == \"s\": #sever\n y -= 1\n elif tah == \"j\": #jih\n y += 1\n elif tah == \"v\": #vychod\n x += 1\n elif tah == \"z\": #zapad\n x -= 1\n else:\n print(\"Zadal jsi spatne pismeno.\" )\n return()\n\n if x<0 or x>sloupce-1 or y<0 or y>radky-1: #tah mimo pole\n print(\"Tah neni mozny, je mimo hraci pole. Opakuj tah.\")\n elif [x,y] in seznam_tahu: #jiz obsazene policko hadem\n print(\"Tah neni mozny, had uz na nem je. Opakuj tah.\")\n elif [x,y] in seznam_ovoce: #policko s ovocem, vola se funkce snez\n snez (seznam_ovoce, seznam_tahu,[x,y],radky, sloupce)\n else:\n seznam_tahu.append([x,y]) #tah na volne policko, prida se tah a odebere posledni bod\n seznam_tahu.pop(0)",
"def mezclar_bolsa(self):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def zapisi_pot(pot):",
"def zapisi_pot(pot):",
"def zapisi_pot(pot):",
"def zapisi_pot(pot):",
"def zapisi_pot(pot):",
"def zapisi_pot(pot):",
"def podziel(self):\n def fraktal(dlugosc, alpha, poziom):\n \"\"\"Metoda wyznaczajaca fraktal.\n\n Metoda ta przyjmuje dlugosc, kat oraz poziom drzewa.\n Na bazie podanych parametrow wylicza fraktal z podanych w zadaniu wzorow.\n Zwraca liste zawierajaca punkX oraz punktY fraktalu.\n \"\"\"\n#obliczanie punktow punktu Abis dla kazdego poziomu galezi\n x = float(self.p2[0] + self.dlugosc * cos(alpha))\n y = float(self.p2[1] + self.dlugosc * sin(alpha))\n return [round(x), round(y)]\n\n#petla przechodzaca po wszystkich poziomach drzewa\n while self.tmp <= self.poziom:\n#obliczanie grubosci, dlugosci galezi oraz kolorowanie jej\n self.grubosc = float((2 * self.grubosc + 1) / 3)\n self.dlugosc = float((2 * self.dlugosc) / 3)\n self.kolor += 6\n\n #sprawdzenie czy kolor nie wyszedl po za skale maksymalnej wartosci\n if self.kolor > 255:\n self.kolor = 255\n\n#rozbicie obliczen na poziom 1 i wyzej\n#Abis jest to punkt prawy dla kazdej galezi\n#B jest to punkt srodkowy dla kazdej galezi\n#C jest to punkt srodkowy dla kazdej galezi\n\n#obliczenia dla pierwszego poziomu\n if self.tmp < 2:\n#obliczenie fraktalu, prawa galaz dla kazdej galezi\n#podstawienie obliczonych wartosci z punktu Abis do pozostalych wedlug podanych wzorow\n Abis = fraktal(self.dlugosc, self.alpha, self.poziom)\n B = [round(self.p2[0]), round(Abis[1])]\n C = [round(-Abis[0] + 2 * self.p2[0]), round(Abis[1])]\n\n#zwiekszenie poziomu drzewa o jeden\n self.tmp += 1\n\n#tutaj nastepuje zwrocenie obiektow typu Branch z nowo obliczonymi wartosciami\n return [Branch(self.p2, Abis, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp),\n Branch(self.p2, B, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp),\n Branch(self.p2, C, self.dlugosc, self.grubosc, self.kolor, self.alpha, self.tmp)]\n#obliczenia poziomow wyzej niz pierwszy\n else:\n#obliczanie kata dla punktu prawego\n self.zetprim = randint(-1, 1) * randint(1, self.s)\n self.beta = self.alpha + self.zetprim\n\n#obliczanie kata dla punktu srodkowego\n self.zetbis = randint(-1, 1) * randint(1, self.s)\n self.gamma = self.alpha + self.zetbis\n\n#obliczanie kata dla punktu lewego\n self.zetter = randint(-1, 1) * randint(1, self.s)\n self.teta = self.alpha + self.zetter\n\n#obliczenie fraktalu, prawa galaz dla kazdej galezi\n#podstawienie obliczonych wartosci z punktu Abis do pozostalych wedlug podanych wzorow\n Abis = fraktal(self.dlugosc, self.beta, self.poziom)\n B = [round(self.p2[0]), round(Abis[1])]\n C = [round(-Abis[0] + 2 * self.p2[0]), round(Abis[1])]\n\n#zwiekszenie poziomu drzewa o jeden\n self.tmp += 1\n\n#tutaj nastepuje zwrocenie obiektow typu Branch z nowo obliczonymi wartosciami\n return [Branch(self.p2, Abis, self.dlugosc, self.grubosc, self.kolor, self.beta, self.tmp),\n Branch(self.p2, B, self.dlugosc, self.grubosc, self.kolor, self.gamma, self.tmp),\n Branch(self.p2, C, self.dlugosc, self.grubosc, self.kolor, self.teta, self.tmp)]",
"def cliquer_sur_unité(self):",
"def ohodnotP(row, col, znak, prevx, prevy, pocet_ciest, hlbka, mx): # vpravo\r\n\r\n susedia = getSusedia_ohodnot(row, col, znak)\r\n\r\n if (values[row][col] != \"W\" and col != 5):\r\n hlbka += 1\r\n\r\n if col == 5:\r\n if values[row][col] == \"W\" and hlbka != 0:\r\n hlbka -= 1\r\n dlzkyP.append(hlbka)\r\n\r\n if (col != 5 and hlbka < mx):\r\n for sused in susedia:\r\n if (sused[1] == col + 1 or (sused[1] == col and (sused[0] != prevx or sused[1] != prevy))):\r\n if sused[1] == 5:\r\n pocet_ciest += 1\r\n pocet_ciest += ohodnotP(sused[0], sused[1], znak, row, col, 0, hlbka, mx)\r\n if (values[sused[0]][sused[1]] == \"W\") and col == 4: # nema zmysel sem umiestnovat - radsej inde\r\n pocet_ciest = 0\r\n return pocet_ciest",
"def lineaarinen():\n x = []\n y = []\n if not kirjasto[\"korjaus\"]:\n try:\n for erottaja in kirjasto[\"lineaariset_arvot\"]:\n x_arvo, y_arvo = erottaja\n x.append(x_arvo)\n y.append(y_arvo)\n kirjasto[\"lineaariset_arvot\"] = []\n kirjasto[\"pisteet\"] = []\n if x and x[0] != x[1] and y[0] != y[1]:\n kk = (y[1]-y[0])/(x[1]-x[0])\n intensiteetti_korjaus = []\n for j in kirjasto[\"kineettiset_energiat\"]:\n y_korjaava = kk * (j - x[0]) + y[0]\n intensiteetti_korjaus.append(y_korjaava)\n for k, l in enumerate(kirjasto[\"intensiteetit\"]):\n korjaus = l - intensiteetti_korjaus[k]\n kirjasto[\"korjaus\"].append(korjaus)\n else:\n ik.avaa_viesti_ikkuna(\"Error\", \"Korjauspisteiden valinnassa tapahtui virhe\")\n return\n except IndexError:\n ik.avaa_viesti_ikkuna(\"Error\", \"Korjauspisteitä ei ole valittu\")\n else:\n ikkuna(\"korjattu_spektri\", kirjasto[\"kineettiset_energiat\"], kirjasto[\"korjaus\"], \"Integroi\", integrointi)\n else:\n ikkuna(\"korjattu_spektri\", kirjasto[\"kineettiset_energiat\"], kirjasto[\"korjaus\"], \"Integroi\", integrointi)",
"def vytvor_hru (seznam_tahu, seznam_ovoce, radky, sloupce):\n hriste = hraci_pole(radky, sloupce)\n vloz(hriste,seznam_ovoce, \"O\")\n vloz(hriste, seznam_tahu, \"X\")\n return(hriste)",
"def solvate(self):\n\n pass",
"def verteileKarten(anzahlSpieler):\n pass",
"def zmiana_glosnosci(utwor, procent = 0):\r\n if(-1 <= procent <= 1):\r\n #ile razy mamy pomnozyc amplitude naszego dzwieku\r\n mnoznik = 0\r\n if( procent < 0 ):\r\n mnoznik = 1 + procent\r\n else:\r\n # obliczamy najwyzsza amplitude w danym utworze i ona bedzie \r\n # wyznaczac jak bardzo mozemy podglosnic\r\n maks_ampli = 0\r\n maks_ampli = max(abs(utwor))\r\n mnoznik = 32767/maks_ampli # maksymalny mnoznik\r\n # mnoznik minimalnie moze osiagnac wartosc 1, to co powyzej \r\n # (mnoznik-1) mnozymy o procent zglosnienia\r\n # i dodajemy do podstawy (czyli 1)\r\n mnoznik = 1 + (mnoznik - 1)*procent\r\n glosniej = mnoznik * utwor\r\n #glosniej = np.array(glosniej, dtype=np.int16)\r\n glosniej = glosniej.astype(np.int16) \r\n return glosniej\r\n else:\r\n print(\"Podaj procent z zakresu -1 do 1\")",
"def ohodnotL(row, col, znak, prevx, prevy, pocet_ciest, hlbka, mx): # vlavo\r\n\r\n susedia = getSusedia_ohodnot(row, col, znak)\r\n\r\n if (values[row][col] != \"W\" and col != 0):\r\n hlbka += 1\r\n\r\n if col == 0:\r\n if values[row][col] == \"W\" and hlbka != 0:\r\n hlbka -= 1\r\n dlzkyL.append(hlbka)\r\n\r\n if (col != 0 and hlbka < mx):\r\n for sused in susedia:\r\n if (sused[1] == col - 1 or (sused[1] == col and (sused[0] != prevx or sused[1] != prevy))):\r\n if sused[1] == 0:\r\n pocet_ciest += 1\r\n pocet_ciest += ohodnotL(sused[0], sused[1], znak, row, col, 0, hlbka, mx)\r\n if (values[sused[0]][sused[1]] == \"W\") and col == 1: # nema zmysel sem umiestnovat - radsej inde\r\n pocet_ciest = 0\r\n return pocet_ciest",
"def desplazamientox(tiempo,velocidad):\r\n #se realiza un operacion para encontrar el el desplzamiento horizaontal\r\n x=tiempo*velocidad\r\n #se regresa el valor de x\r\n return x",
"def dodajPrzedmiot(self, przedmiot: Przedmiot):\n self.przedmioty[przedmiot.nazwa]=przedmiot",
"def piskvorky(pole):\n\n print('Ahoj. Toto je hra 1D piskvorky. Pocitac hra so symbolmi \\'O\\', ty hras so symbolmi \\'X\\'.') \n while \"-\" in pole:\n if vyhodnot(pole) == False:\n break\n else:\n pole = tah_hraca(pole, cislo_policka)\n if vyhodnot(pole) == False:\n break\n else:\n pole = tah_pocitaca(pole, cislo_policka, mozne_policka1, mozne_policka2)\n if \"-\" not in pole:\n vyhodnot(pole)\n return print(\"Dakujem za hru.\")",
"def piskvorky(pole):\n\n print('Ahoj. Toto je hra 1D piskvorky. Pocitac hra so symbolmi \\'O\\', ty hras so symbolmi \\'X\\'.') \n while \"-\" in pole:\n if vyhodnot(pole) == False:\n break\n else:\n pole = tah_hraca(pole, str_policka)\n if vyhodnot(pole) == False:\n break\n else:\n pole = tah_pocitaca(pole, symbol=\"O\")\n if \"-\" not in pole:\n vyhodnot(pole)\n return print(\"Dakujem za hru.\")",
"def vloz (pole, pozice, znak):\n for k in pozice:\n pole [k[1]] [k[0]]= znak",
"def uvozi(self, encoding=\"UTF-8\"):\n insert = self.stroskovno_mesto.dodajanje(stevilo=1)\n super().uvozi(encoding=encoding, insert=insert)",
"def prebaci_dan_nazad(self):\r\n value = int(self.brojDanaCombo.currentText()) #integer broj dana\r\n self.emit(QtCore.SIGNAL('promjeni_datum(PyQt_PyObject)'), -value)\r\n msg = 'request pomak {0} dana unazad'.format(value)\r\n logging.info(msg)",
"def get_mvts(self, plateau):\n if self.type == \"p\": #Pion\n if self.color == \"w\":\n diags = [[self.x-1, self.y+1],[self.x+1, self.y+1]] #Mouvements possibles de diagonales\n faces = [[self.x, self.y+1]] #Mouvements possibles de face\n if not self.moved: #Si le pion n'a pas encore bougé de la partie\n faces.append([self.x, self.y+2])\n else:\n diags = [[self.x-1, self.y-1], [self.x+1, self.y-1]]\n faces = [[self.x, self.y-1]] #Mouvements possibles de \n if not self.moved:\n faces.append([self.x, self.y-2])\n pos = [] #Position de déplacement validées\n for d in diags:\n if verif_case(d[0], d[1]): #Si la case est sur le plateau \n pion = plateau.get_pion(d[0],d[1])\n if pion != None and pion.color != self.color: #Si il y a un pion ennemi\n pos.append(d)\n for f in faces: \n if verif_case(f[0],f[1]):\n pion = plateau.get_pion(f[0], f[1])\n if pion == None: #Si il n'y a pas de pion\n pos.append(f)\n return pos\n elif self.type == \"t\": #Tour\n pos = []\n dir = [[1,0],[-1,0],[0,1],[0,-1]] #4 directions possibles\n for d in dir:\n x,y = self.x+d[0],self.y+d[1] #Projection de position\n while verif_case(x,y): #Tant que (x, y) est sur le plateau\n pion = plateau.get_pion(x, y)\n if pion != None: #Si il y a un pion\n if pion.color != self.color: #Si il n'est pas allié\n pos.append([x,y])\n break\n pos.append([x,y])\n x += d[0]\n y += d[1]\n return pos\n elif self.type == \"c\": #Cavalier\n l = [-2,-1,1,2]\n mvts = [[x,y] for x in l for y in l if abs(x)!=abs(y)]\n pos = []\n for m in mvts:\n x = self.x + m[0]\n y = self.y + m[1]\n if verif_case(x,y):\n pion = plateau.get_pion(x, y)\n if pion == None or pion.color != self.color:\n pos.append([x, y])\n return pos\n elif self.type == \"f\": #Fou\n dir = [[1,1],[-1,1],[-1,-1],[1,-1]]\n pos = []\n for d in dir:\n x,y = self.x+d[0],self.y+d[1]\n while verif_case(x,y):\n pion = plateau.get_pion(x, y)\n if pion != None:\n if pion.color != self.color:\n pos.append([x,y])\n break\n pos.append([x,y])\n x += d[0]\n y += d[1]\n return pos\n elif self.type == \"k\": #Roi\n mvts = [[1,0],[-1,1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]] #4 mouvements possibles\n pos = []\n for m in mvts:\n x = self.x + m[0]\n y = self.y + m[1]\n if verif_case(x, y):\n pion = plateau.get_pion(x, y)\n if pion == None or pion.color != self.color:\n pos.append([self.x + m[0], self.y + m[1]])\n return pos\n elif self.type == \"q\": #Dame\n pos = []\n dir = [[1,0],[1,-1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]]\n for d in dir:\n x,y = self.x+d[0],self.y+d[1]\n while verif_case(x,y):\n pion = plateau.get_pion(x, y)\n if pion != None:\n if pion.color != joueur:\n pos.append([x,y])\n break\n pos.append([x,y])\n x += d[0]\n y += d[1]\n return pos",
"def hra(kolo):\r\n\r\n kolo = 0\r\n vitaz = None #zaciname bez vitaza\r\n\r\n global values\r\n\r\n while not vitaz: #dokym nemame vitaza\r\n kolo += 1 #posun kola\r\n if kolo % 2 == 1: #ak sme v neparnom kole aktivny hrac je W(biely)\r\n aktivny_hrac = \"W\"\r\n else: #ak sme v parnom kole aktivny hrac je B(cierny)\r\n aktivny_hrac = \"B\"\r\n\r\n print('Kolo: ' + str(kolo) + '\\n'\r\n + 'Na ťahu: ' + str(aktivny_hrac))\r\n\r\n vykresli_pole(values)\r\n\r\n if aktivny_hrac == \"W\": #ak je W aktivny hrac zavola funkciu pre tah hraca\r\n print('Zadajte súradnice - číslo riadku a stĺpec bez medzery (napr. 1A):')\r\n tah = hrac_input()\r\n\r\n if aktivny_hrac == \"B\": #ak je B aktivny hrac zavola funkciu pre tah pocitaca\r\n tah = hra_pocitac()\r\n\r\n if (prehladavanie_hex_W(\"W\")): #kontrola ci nemame vitaza\r\n vitaz = prehladavanie_hex_W(\"W\")\r\n elif (prehladavanie_hex_B(\"B\")):\r\n vitaz = prehladavanie_hex_B(\"B\")\r\n\r\n if vitaz in [\"W\", \"B\"]: #ak mame vitaza, koniec hry, vypise vitaza\r\n vykresli_pole(values)\r\n print(vitaz + \" \" + \"VYHRAL HRU\")\r\n print('\\n')\r\n print('Ak chcete hrať znovu stlačte 0 a ENTER')\r\n x = input()\r\n if x == \"0\":\r\n values = [[\" \" for i in range(pocet_stlpcov)] for j in range(pocet_riadkov)]\r\n return hra(0)",
"def citanje_svih(self):\n with open(self.putanja, \"r\") as file:\n podaci = []\n for linija in file.readlines():\n podaci.append(self.napravi_entitet(linija))\n return podaci",
"def afficher_V(V, titre=\"Fonction valeur de la politique selon méthode de Monte Carlo première visite\"):\n # Déterminer les quadrillages des axes X et Y\n min_x = min(etat[0] for etat in V.keys()) # axe des x : main du joueur\n max_x = max(etat[0] for etat in V.keys())\n min_y = min(etat[1] for etat in V.keys()) # axe des y : main de la banque\n max_y = max(etat[1] for etat in V.keys())\n\n x_range = np.arange(min_x, max_x + 1)\n y_range = np.arange(min_y, max_y + 1)\n X, Y = np.meshgrid(x_range, y_range)\n\n # Rassembler les valeurs de z pour tous les (x, y) : distinguer les cas avec et sans as utilisable\n Z_sans_as = np.apply_along_axis(lambda _: V[(_[0], _[1], False)], 2, np.dstack([X, Y]))\n Z_as = np.apply_along_axis(lambda _: V[(_[0], _[1], True)], 2, np.dstack([X, Y]))\n\n def afficher_surface(X, Y, Z, titre):\n fig = plt.figure(figsize=(20, 10))\n ax = fig.add_subplot(111, projection='3d')\n surface = ax.plot_surface(X, Y, Z, rstride=1, cstride=1,\n cmap=matplotlib.cm.Reds, vmin=-1.0, vmax=1.0)\n ax.set_xlabel('Total joueur')\n ax.set_ylabel('Carte visible banque')\n ax.set_zlabel('Valeur')\n ax.set_title(titre)\n ax.view_init(ax.elev, -140)\n fig.colorbar(surface)\n plt.show()\n\n afficher_surface(X, Y, Z_sans_as, \"{} (Sans as utilisable)\".format(titre))\n afficher_surface(X, Y, Z_as, \"{} (Avec as utilisable)\".format(titre))",
"def snez (seznam_ovoce, seznam_tahu, souradnice, radky, sloupce):\n\n seznam_tahu.append(souradnice) #snezeni\n seznam_ovoce.pop(seznam_ovoce.index(souradnice)) #vymazani ze seznamu ovoce\n if (len(seznam_tahu)) == radky * sloupce: #v poli jiz neni ani jedno volne policko, konec\n return()\n if seznam_ovoce == []:\n vytvor_ovoce(seznam_ovoce, seznam_tahu,radky, sloupce) #volam funkci, ktera vytvori dalsi ovoce",
"def get_lengte(self):",
"def piskvorky1D():\n print(HLASKA_UVOD)\n \n symbol_hrace = input('Vyber si a zadej svuj herni symbol, \"x\" nebo \"o\"?: ') # vyber herniho symbolu hrace\n while symbol_hrace not in ('x', 'o'):\n symbol_hrace = input('Spatne, zadej znovu, \"x\" nebo \"o\"?: ')\n \n if symbol_hrace == 'x': # nastaveni herniho symbolu pocitace\n symbol_pocitace = 'o'\n else:\n symbol_pocitace = 'x'\n\n herni_pole = DELKA_HERNIHO_POLE * '-'\n print(herni_pole)\n \n kolo = 1\n while True:\n for tahne in (tah_hrace, tah_pocitace):\n herni_pole = tahne(herni_pole, symbol_pocitace, symbol_hrace)\n print('{}. kolo: {}'.format(kolo, herni_pole))\n stav = vyhodnot(herni_pole) # promenna, kde je ulozeno aktualni vyhodnoceni herniho pole\n if stav in KDO_VYHRAL:\n print(KDO_VYHRAL[stav])\n return\n kolo += 1",
"def homozygotie(self):\n if self.allele[1] == 0.0:\n self.homozygote = True",
"def vyhodnot(herni_pole):\n if 'xxx' in herni_pole: # vyhral hrac s x\n return 'x' \n elif 'ooo' in herni_pole: # vyhral hrac s o\n return 'o'\n elif '-' not in herni_pole: # remiza\n return '!'\n else:\n return '-' # hra jeste neskoncila",
"def pyramida(zakladna, orientacia, centrovanie):\n nova_pyramida = []\n if orientacia not in [\"normalna\", 'obratena']:\n print(\"Pyramida moze byt iba [normalna] alebo [obratena]\")\n return False\n\n if centrovanie != \"center\" and centrovanie != \"vlavo\":\n print(\"Centrovanie pyramidy moze byt iba [center] alebo [vlavo]\")\n return False\n\n if centrovanie == \"center\":\n if orientacia == \"normalna\":\n\n cislo_riadka = -1\n for i in range(1, zakladna + 1, 2): #pocet hviezdiciek rastie po 2\n #print(f\"{'*' * i:^{zakladna}}\")\n cislo_riadka +=1\n riadok = []\n for j in range(cislo_riadka,zakladna//2): #vyska pyramidy = polovica zakladne\n riadok.append(\" \") #kolky riadok, tolko medzier vlavo\n for j in range(0, i):\n riadok.append(\"*\")\n for j in range(cislo_riadka,zakladna//2): # aj v pravo\n riadok.append(\" \")\n nova_pyramida.append(riadok)\n else:\n cislo_riadka = -1\n for i in range(zakladna, 0, -2): #pocet hviezdiciek\n #print(f\"{'*' * i:^{zakladna}}\")\n cislo_riadka +=1\n riadok = []\n for j in range(0,cislo_riadka):\n riadok.append(\" \")\n for j in range(0,i):\n riadok.append(\"*\")\n for j in range(0,cislo_riadka):\n riadok.append(\" \")\n nova_pyramida.append(riadok)\n else:\n if orientacia == \"normalna\":\n for i in range(zakladna):\n #print(f\"{'*' * (i + 1)}\")\n riadok = []\n for j in range(0,i):\n riadok.append(\"*\")\n nova_pyramida.append(riadok)\n else:\n for i in range(zakladna):\n riadok = []\n #print(f\"{'*' * (zakladna - i)}\")\n for j in range(zakladna, i, -1):\n riadok.append(\"*\")\n nova_pyramida.append(riadok)\n return nova_pyramida",
"def __init__(self):\n self.nombre_roues = 4\n self.nombre_fauteils = 1\n self.moteur = False\n self.volant = True",
"def exo2():",
"def ptsigmav(self,prof_pt): #getter que halla el esfuerzo vertical en un punto\r\n sigmav=self.pext\r\n for capa in self.capas:\r\n capaini=capa.prof_init\r\n capafin=capa.prof_final\r\n if capa.prof_init >= prof_pt:\r\n break #se alcanzo una capa mas profunda a la del punto\r\n elif capa.prof_final <= prof_pt and capa.prof_final <= self.n_fret:\r\n #la capa esta encima y el nivel freatico esta debajo de la capa\r\n sigmav=sigmav + capa.gamma*(capa.prof_final - capa.prof_init)\r\n pass\r\n elif capa.prof_final <= prof_pt and capa.prof_init >= self.n_fret:\r\n #la capa esta encima y el nivel freatico en toda la capa\r\n sigmav=sigmav + capa.gamma_sat*(capa.prof_final-capa.prof_init) \r\n pass\r\n elif capa.prof_final<prof_pt and capa.prof_init < self.n_fret and capa.prof_final>self.n_fret:\r\n #la capa esta encima, pero el nivel freatico esta al interior de esa capa\r\n sigmav=sigmav + capa.gamma*(self.n_fret-capa.prof_init)\r\n sigmav=sigmav + capa.gamma_sat*(capa.prof_final-self.n_fret)\r\n pass\r\n else: #el punto se encuentra en la capa actual \r\n if capa.prof_init >= self.n_fret: #el nivel freatico esta por encima de la capa del punto\r\n sigmav=sigmav + capa.gamma_sat*(prof_pt-capa.prof_init) \r\n pass\r\n elif capa.prof_final <= self.n_fret or prof_pt <= self.n_fret: #el nivel freatico esta debajo de la capa del punto o del punto\r\n sigmav=sigmav + capa.gamma*(prof_pt-capa.prof_init)\r\n pass\r\n elif capa.prof_final>self.n_fret and capa.prof_init<self.n_fret: \r\n ##el nivel freatico esta dentro de la capa del punto y ademas esta entre el inicio de la capa y el punto\r\n sigmav=sigmav + capa.gamma*(self.n_fret-capa.prof_init)\r\n sigmav=sigmav + capa.gamma_sat*(prof_pt-self.n_fret)\r\n pass\r\n else:\r\n print('error en sigma v del punto')\r\n pass\r\n pass\r\n pass\r\n return round(sigmav,3)",
"def es_satisfecho_por(self, candidata):",
"def agregar_bolsa(self, letra, cantidad):",
"def lateral_vazio_8(tab, jog):\r\n for x in [2,4,6,8]:\r\n if eh_posicao_livre(tab,x):\r\n return x",
"def ustvari(self):\n raise NotImplementedError",
"def ustal_kon(self, f):\n kon= Kon.objects.using(settings.DBS(self.firma)).filter(id= f.nip_nabywcy)\n if kon:\n return kon[0]\n \n kon= Kon()\n \n # Numer dla zagranicznego\n nr_kon= Kon.objects.using(settings.DBS(self.firma)).exclude(nr_kon__startswith= 'Z').aggregate(Max('nr_kon'))\n kon.nr_kon= '{:05d}'.format(int(nr_kon['nr_kon__max'].strip())+1)\n\n if '/' in f.nazwa_nabywcy:\n kon.skrot, kon.nazwa= f.nazwa_nabywcy.split('/')\n else:\n kon.nazwa= f.nazwa_nabywcy\n \n kon.id= f.nip_nabywcy\n kon.idtyp= 'NIPUE' if re.match('[A-Z][A-Z]', f.nip_nabywcy) else 'NIP'\n kon.ulica, kon.kod, kon.miejsc= self.adres_kon(f.adres_nabywcy)\n \n kon.kraj= f.nip_nabywcy[:2] if re.match('[A-Z][A-Z]', f.nip_nabywcy) else 'PL'\n \n kon.id_obcy= f.id # zapamiętanie skąd się zwiął (faktura)\n \n kon.skrot= su(kon.skrot)\n kon.nazwa= su(kon.nazwa)\n kon.miejsc= su(kon.miejsc)\n kon.ulica= su(kon.ulica)\n \n kon.kiedy= datetime.date.today() # data utworzenia\n kon.data_us= kon.kiedy\n if f.termin_platnosci and f.data_wystawienia:\n kon.term_zap= (f.termin_platnosci - f.data_wystawienia).days\n \n kon.save(using= settings.DBS(self.firma))\n \n return kon",
"def insert(self, index, hodnota):\n\n # nejdrive musim zkontrolovat jestli se mi tam prvek vejde\n # to uz jsme delali v append, takze muzu vyuzit append a pridat na konec nejakou \"placeholder\" hodnotu\n self.append(0)\n\n # naposouvam prvky smerem ke konci pole, vim ze poslednim prvkem je 0 - tu prepisu predposlednim prvkem atd.\n # ukazkovy prubeh for cyklu:\n # pole: hodnota0 hodnota1 hodnota2 hodnota3 0\n # aktualni_delka: 5\n # index: 2\n # pole[4] = pole[3]\n # pole[3] = pole[2]\n # >> pole: hodnota0 hodnota1 hodnota2 hodnota2 hodnota3\n for i in range(self.aktualni_delka - 1, index, -1):\n self.pole[i] = self.pole[i - 1]\n\n # na to spravne misto umistim novou hodnotu\n # z ukazky:\n # >> pole: hodnota0 hodnota1 nova_hodnota hodnota2 hodnota3\n self.pole[index] = hodnota",
"def Wygrana():\r\n for x in range (0, ROZMIAR_PLANSZY):\r\n for y in range (0, ROZMIAR_PLANSZY):\r\n for kierunek in (\"poziom\", \"pion\", \"skos prawy\", \"skos lewy\"):\r\n iksy, kolka = SprawdzLinie ((x, y), kierunek)\r\n if iksy == 5:\r\n return X\r\n if kolka == 5:\r\n return O\r\n return False",
"def pokazPrzedmiot(self,przedmiot:str)->None:\n try:\n print(self.przedmioty[przedmiot])\n except KeyError:\n print(\"Nie ma takiego przedmiotu\")",
"def uvozi_vloge(cur):\n cur.execute(\"DELETE FROM nastopa;\")\n cur.execute(\"DELETE FROM vloga;\")\n vloge = {}\n with open('podatki/vloge.csv') as datoteka:\n podatki = csv.reader(datoteka)\n stolpci = next(podatki)\n v = stolpci.index('vloga')\n poizvedba = \"\"\"\n INSERT INTO nastopa VALUES ({})\n \"\"\".format(', '.join([\"?\"] * len(stolpci)))\n poizvedba_vloga = \"INSERT INTO vloga (naziv) VALUES (?);\"\n for vrstica in podatki:\n vloga = vrstica[v]\n if vloga not in vloge:\n cur.execute(poizvedba_vloga, [vloga])\n vloge[vloga] = cur.lastrowid\n vrstica[v] = vloge[vloga]\n cur.execute(poizvedba, vrstica)",
"def bloqueio_2(tab,jog):\r\n jog*=-1\r\n return vitoria_1(tab,jog)",
"def sprawdz(lista):\n # do_usuniecia - lista zawierajaca indeksy pol ktore zostana usuniete z glownej listy\n do_usuniecia = []\n # petla przechodzaca po wartosciach\n for i in range(len(lista) / 2):\n # j - indeks wartosci dla poszczgolnego panstwa\n j = 2 * i + 1\n # k - indeks pod ktorym nie ma wartosci\n k = 0\n # sprawdzanie ktore elementy sa bez wartosci oraz dodawanie ich do listy do usuniecia\n for el in lista[j]:\n if el is None:\n # zastosowanie unikalnosci indeksow\n if not k in do_usuniecia:\n do_usuniecia.append(k)\n\n k += 1\n # sortowanie listy z indeksami do usuniecia w sposob rosnacy\n do_usuniecia.sort()\n # nowalista - lista zawierajaca statystyki dostepne dla wszystkich panstw odpowiednio [Lata],[Wartosc]\n nowalista = []\n for i in range(len(lista)):\n # wartosc - lista zawierajaca poszczegolne dane z glownej listy\n wartosc = []\n # dodawanie wartosci, ktore sa dostepne dla wszystkich panstw do tabeli wartosc\n for j in range(len(lista[i])):\n # zastosowanie unikalnosci indeksow dla ktorych nie ma wartosci\n if not j in do_usuniecia:\n wartosc.append(lista[i][j])\n # dodawanie listy zawierajacej wynik dla poszczegolnych danych\n nowalista.append(wartosc)\n\n return nowalista",
"def dodaj_uredjaj(self, naziv, ure):\n self.uredjaji[naziv] = ure",
"def get_station_boroughs(self):\\",
"def ohodnotH_B(row, col, znak, prevx, prevy, pocet_ciest, hlbka, mx): # hore\r\n\r\n susedia = getSusedia_ohodnot(row, col, znak)\r\n\r\n if (values[row][col] != \"B\" and row != 0):\r\n hlbka += 1\r\n\r\n if row == 0:\r\n if values[row][col] == \"B\" and hlbka != 0:\r\n hlbka -= 1\r\n dlzkyHB.append(hlbka)\r\n\r\n if (row != 0 and hlbka < mx):\r\n for sused in susedia:\r\n if (sused[0] == row - 1 or (sused[0] == row and (sused[0] != prevx or sused[1] != prevy))):\r\n if sused[0] == 0:\r\n pocet_ciest += 1\r\n pocet_ciest += ohodnotH_B(sused[0], sused[1], znak, row, col, 0, hlbka, mx)\r\n return pocet_ciest",
"def update_vie(self):\n self.essais_restant[\"text\"] = \"Vous disposez de {} vies\".format(self.jeu.get_nb_vie())",
"def append(self, hodnota):\n\n # pokud je pole uz plne, musime ho zvetsit a prekopirovat hodnoty do vetsiho pole\n if self.aktualni_delka == self.realna_delka:\n nove_pole = [-1] * (self.realna_delka * 2)\n\n for i in range(self.aktualni_delka):\n nove_pole[i] = self.pole[i]\n\n self.pole = nove_pole\n self.realna_delka *= 2\n\n # ted uz mame urcite v poli misto, takze muzeme na konec pridat hodnotu a zvetsit jeho \"aktualni delku\"\n self.pole[self.aktualni_delka] = hodnota\n self.aktualni_delka += 1",
"def MINET(self):",
"def posOrdem(self, x):\n if x is not None:\n self.posOrdem(x.getEsquerdo())\n self.posOrdem(x.getDireito())\n print(x.getChave(), end = ' ')",
"def getSusedia_ohodnot(row, col, znak):\r\n\r\n susedia = set()\r\n for i, j in [(-1, 1), (-1, 0), (0, 1), (1, 0), (1, -1), (0, -1)]: #hlad vo vsetkych smeroch\r\n if (row + i) in range(pocet_riadkov) and \\\r\n (col + j) in range(pocet_stlpcov):\r\n if values[row + i][col + j] != znak: #ak na susednej pozicii nie je rovnaky znak\r\n susedia.add((row + i, col + j))\r\n return susedia",
"def get_podatke(self):\r\n if self.gKanal is not None:\r\n datumOd = self.adapt_datum(self.dateEditOd.date())\r\n datumDo = self.adapt_datum(self.dateEditDo.date())\r\n valjani = self.checkSamoValjani.isChecked()\r\n nivoValidacije = self.spinNivoValidacije.value()\r\n output = {'datumOd': datumOd,\r\n 'datumDo': datumDo,\r\n 'kanal': self.gKanal,\r\n 'valjani': valjani,\r\n 'validacija': nivoValidacije}\r\n self.emit(QtCore.SIGNAL('nacrtaj_rest_satne(PyQt_PyObject)'), output)\r\n else:\r\n QtGui.QMessageBox.information(self,\r\n 'Problem kod crtanja',\r\n 'Nije moguce nacrtati graf, kanal nije izabran')",
"def reemplaza_tildes(palabra):",
"def valg(self):\n\n lengde_mtrekk = len(self.motstander_trekk)\n\n if (lengde_mtrekk == 0) or (self.husk ==\n 0):\n return self._random_trekk()\n\n elif lengde_mtrekk <= self.husk:\n\n \"\"\"sekvens skal inneholde like mange elementer som husk\"\"\"\n if len(self.sekvens) < self.husk:\n self.sekvens.append(self.motstander_trekk[-1])\n\n return self._random_trekk()\n\n else:\n self.sekvens = self.motstander_trekk[-self.husk:]\n\n print(self.motstander_trekk)\n print(self.sekvens)\n\n self.kopi_trekk = self.motstander_trekk.copy()\n\n \"\"\"trekkene uten siste sekvens\"\"\"\n self.kopi_trekk = self.kopi_trekk[:len(\n self.kopi_trekk) - self.husk]\n print(self.kopi_trekk)\n\n \"\"\"rangerer trekkene som oftest SLÅR det motstanderen spiller etter sekvensen\"\"\"\n self.trekk_mot = {\"stein\": 0, \"saks\": 0, \"papir\": 0}\n\n \"\"\"sjekker så lenge starten på sekvensen er med i motstanderens trekk fjerner\"\"\"\n while (self.sekvens[0] in self.kopi_trekk) and (\n len(self.kopi_trekk) > self.husk):\n\n index_start = self.kopi_trekk.index(self.sekvens[0])\n\n if self.sekvens == self.kopi_trekk[index_start: (\n index_start + len(self.sekvens))]:\n print(\"den er med!\")\n print(index_start)\n index_slutt = index_start + len(self.sekvens)\n\n \"\"\"hvis index_slutt er utenfor kopi_trekk, så skal while løkken stoppes\"\"\"\n if index_slutt >= len(self.kopi_trekk):\n break\n\n print(index_slutt)\n \"\"\"ser på neste trekk etter sekvensen\"\"\"\n forventet_trekk = self.kopi_trekk[index_slutt]\n \"\"\"setter slutten som den nye starten\"\"\"\n self.kopi_trekk = self.kopi_trekk[index_slutt:]\n print(self.kopi_trekk)\n\n temp = Sammenlikning(forventet_trekk)\n print(\"1\" + forventet_trekk)\n vinner_trekk = temp.taper_mot\n print(\"2\" + vinner_trekk)\n\n self.trekk_mot[vinner_trekk] += 1\n\n for key, value in self.trekk_mot.items():\n print(key, \"->\", value)\n\n else:\n print(\"ikke i trekkene\")\n if index_start < len(self.kopi_trekk):\n self.kopi_trekk = self.kopi_trekk[index_start + 1:]\n else:\n break\n\n \"\"\"dersom sekvensen aldri har vært utført tidligere\"\"\"\n if all(value == 0 for value in self.trekk_mot.values()):\n return self._random_trekk()\n\n else:\n\n antall = 0\n flest = \"\"\n\n for trekk in self.trekk_mot:\n\n if self.trekk_mot[trekk] >= antall:\n antall = self.trekk_mot[trekk]\n flest = trekk\n\n return flest",
"def actualizar_velocidad(self):\r\n pass",
"def zyklus(self):\n neu = self.lebendig.copy() # Kopie erstellen\n for zelle in self.lebendig: # Alle lebendigen Zellen durchgehen\n anzahl = self.lebendige_nachbarn(zelle)\n if anzahl < 2 or anzahl > 3: # Vereinsamung oder Überbevölkerung\n neu.remove(zelle) # Stirbt - aus der Liste der Lebendigen entfernen\n # Prüfe alle Nachbarn einer lebendigen Zelle\n # wenn diese genau drei Nachbarn hat, muss sie evtl.\n # lebendig werden\n x, y = zelle\n if self.lebendige_nachbarn((x-1, y+1)) == 3:\n neu.add((x-1, y+1))\n if self.lebendige_nachbarn((x, y+1)) == 3:\n neu.add((x, y+1))\n if self.lebendige_nachbarn((x+1, y+1)) == 3:\n neu.add((x+1, y+1))\n if self.lebendige_nachbarn((x+1, y)) == 3:\n neu.add((x+1, y))\n if self.lebendige_nachbarn((x+1, y-1)) == 3:\n neu.add((x+1, y-1))\n if self.lebendige_nachbarn((x, y-1)) == 3:\n neu.add((x, y-1))\n if self.lebendige_nachbarn((x-1, y-1)) == 3:\n neu.add((x-1, y-1))\n if self.lebendige_nachbarn((x-1, y)) == 3:\n neu.add((x-1, y))\n self.lebendig = neu",
"def ludnosc(lista):\n # wynik - lista zawierajaca wynik koncowy dzialania funkcji(lata i wartosci dla poszczegolnych panstw)\n wynik = []\n for panstwo in lista:\n # rok - lista zawierajaca lata\n # wartosc - lista zawierajaca wartosci dla lat\n rok = []\n wartosc = []\n for element in panstwo:\n # sprawdzenie czy klucz posiada odpowiednia wartosc\n if element[1].get('key') == \"EN.POP.DNST\":\n # dodanie roku do listy\n rok.append(int(element[2].text))\n # rozpatrywanie przypadku w ktorym wartosc jest None\n if element[3].text is None:\n wartosc.append(element[3].text)\n else:\n wartosc.append(float(element[3].text))\n # dodawanie list dla poszczegolnych panstw do listy wynikowej\n wynik.append(rok)\n wynik.append(wartosc)\n\n return wynik",
"def z(self):\r\n return self.unif[2]",
"def zeige_auf_sensehat(self):\n if self.sense is not None:\n sense.clear(farbe_tot)\n for zelle in self.lebendig:\n x, y = zelle\n if 0 <= x < 8 and 0 <= y < 8:\n sense.set_pixel(zelle[0], zelle[1]. farbe_lebendig)",
"def atualizaVertice(self, v = []):\r\n\r\n #reseta as arestas para d0\r\n #for a in self.arestas:\r\n # a.peso = a.d0\r\n\r\n for vertice in v:\r\n for a in self.arestas:\r\n if (vertice.id == a.v1.id):\r\n #print (\"atualiza aresta\", a.id)\r\n if (a.v2.atualizado):\r\n a.peso = a.d2\r\n else:\r\n a.peso = a.d1\r\n\r\n\r\n if (vertice.id == a.v2.id):\r\n #print (\"atualiza aresta\", a.id)\r\n if (a.v1.atualizado):\r\n a.peso = a.d2\r\n else:\r\n a.peso = a.d1\r\n \r\n vertice.atualizado = True\r\n \r\n for vertice in v:\r\n vertice.atualizado = False",
"def morir(self):\n self.energia = 0\n self.vivo = False",
"def vesta(self):\n if(type(self.z) != type('hi')):\n return znum2sym.z2sym(self.z) + '\\t' + str(self.coord[0]) + '\\t' + str(self.coord[1]) + '\\t' + str(self.coord[2])\n elif(type(self.z) == type('hi')):\n return self.z + '\\t' + str(self.coord[0]) + '\\t' + str(self.coord[1]) + '\\t' + str(self.coord[2])",
"def degibber(self):",
"def canto_vazio_7(tab, jog):\r\n for x in [1,3,7,9]:\r\n if eh_posicao_livre(tab,x):\r\n return x",
"def vierhoekig(self):\n return self._vierhoekig.get_waarde()",
"def __init__(self):\n self.enfila= 0\n self.fila = []",
"def prebaci_dan_naprijed(self):\r\n value = int(self.brojDanaCombo.currentText()) #integer broj dana\r\n self.emit(QtCore.SIGNAL('promjeni_datum(PyQt_PyObject)'), value)\r\n msg = 'request pomak {0} dana unaprijed'.format(value)\r\n logging.info(msg)",
"def emOrdem(self, x):\n if x is not None:\n self.emOrdem(x.getEsquerdo())\n print(x.getChave(), end = ' ')\n self.emOrdem(x.getDireito())",
"def change_glavniLabel(self, ulaz):\r\n mapa = ulaz['opis']\r\n mjerenjeId = ulaz['mjerenjeId']\r\n datum = ulaz['datum']\r\n postaja = mapa['postajaNaziv']\r\n komponenta = mapa['komponentaNaziv']\r\n formula = mapa['komponentaFormula']\r\n# mjernaJedinica = mapa['komponentaMjernaJedinica']\r\n# opis = '{0}, {1}( {2} ) [{3}]. Datum : {4} . mjerenjeId:{5}'.format(postaja, komponenta, formula, mjernaJedinica, datum, mjerenjeId)\r\n opis = '{0}, {1}( {2} ). Datum : {3} . mjerenjeId:{4}'.format(postaja, komponenta, formula, datum, mjerenjeId)\r\n self.glavniLabel.setText(opis)\r\n logging.info('glavniLabel promjenjen, value = {0}'.format(opis))",
"def vitoria_1(tab,jog):\r\n for i in range(1,4):\r\n win = [(0,jog,jog), (jog,0,jog), (jog,jog,0)]\r\n coluna = obter_coluna(tab, i)\r\n linha = obter_linha(tab, i) \r\n if coluna in win:\r\n return i+3*win.index(coluna)\r\n elif linha in win:\r\n return 3*i-2+win.index(linha) \r\n if i!=3:\r\n diagonal = obter_diagonal(tab, i)\r\n if diagonal in win:\r\n if i==1:\r\n return i+4*win.index(diagonal)\r\n\r\n else:\r\n return 7-2*win.index(diagonal)",
"def ohodnotD_B(row, col, znak, prevx, prevy, pocet_ciest, hlbka, mx): # dole\r\n\r\n susedia = getSusedia_ohodnot(row, col, znak)\r\n\r\n if (values[row][col] != \"B\" and row != 5):\r\n hlbka += 1\r\n\r\n if row == 5:\r\n if values[row][col] == \"B\" and hlbka != 0:\r\n hlbka -= 1\r\n dlzkyDB.append(hlbka)\r\n\r\n if (row != 5 and hlbka < mx):\r\n for sused in susedia:\r\n if (sused[0] == row + 1 or (sused[0] == row and (sused[0] != prevx or sused[1] != prevy))):\r\n if sused[0] == 5:\r\n pocet_ciest += 1\r\n pocet_ciest += ohodnotD_B(sused[0], sused[1], znak, row, col, 0, hlbka, mx)\r\n return pocet_ciest",
"def eksport(lista):\n # wynik - lista zawierajaca wynik koncowy dzialania funkcji(lata i wartosci dla poszczegolnych panstw)\n wynik = []\n for panstwo in lista:\n # rok - lista zawierajaca lata\n # wartosc - lista zawierajaca wartosci dla lat\n rok = []\n wartosc = []\n for element in panstwo:\n # sprawdzenie czy klucz posiada odpowiednia wartosc\n if element[1].get('key') == \"NE.EXP.GNFS.CD\":\n # dodanie roku do listy\n rok.append(int(element[2].text))\n # rozpatrywanie przypadku w ktorym wartosc jest None\n if element[3].text is None:\n wartosc.append(element[3].text)\n else:\n wartosc.append(float(element[3].text))\n # dodawanie list dla poszczegolnych panstw do listy wynikowej\n wynik.append(rok)\n wynik.append(wartosc)\n\n return wynik",
"def update_E(self):",
"def entrenamiento(self,cantidad_autovectores,porcentaje_prueba):\n self.gestor_muestra.cargar(porcentaje_prueba)\n self.gestor_pca.entrenamiento(self.gestor_muestra.muestra,cantidad_autovectores)\n sujeto=[]\n aciertos=0\n for i in self.gestor_muestra.muestra.sujetos:\n sujeto.append([i.nombre,0,0,0,0,0,0])\n cant_muestras = 0\n for i in self.gestor_muestra.muestra.sujetos:\n \n for j in i.imagenes_prueba:\n cant_muestras+=1\n x,y,z=self.gestor_pca.identificacion_sujeto(j)\n if i.nombre == y:\n \n sujeto[int(i.nombre[1:])-1][3]+=1\n aciertos+=1\n else:\n sujeto[int(i.nombre[1:])-1][1]+=1\n sujeto[int(y[1:])-1][2]+=1\n\n for i in sujeto:\n \n try:\n i[4]=i[3]/(i[3]+i[1])\n except:\n i[4]=None\n \n try:\n i[5]=i[3]/(i[3]+i[2])\n except:\n i[5]=None\n \n try:\n i[6]=(2*i[5]*i[4])/(i[4]+i[5])\n except:\n i[6]=None\n \n return sujeto",
"def value(self):",
"def accueil():\r\n global etat\r\n background(0,128,128)\r\n image(tireur,0,0) \r\n rectMode(CORNERS)\r\n fill(100)\r\n rect(0,60,250,120)\r\n rect(500,60,750,120)\r\n fill(0)\r\n textSize(30)\r\n text(\"PVP\",95,100) \r\n text(\"ORDINATEUR\",520,100) \r\n if (mousePressed) and mouseX<250 and mouseX>0 and mouseY<120 and mouseY>60: #si on clique sur le rectangle jouer\r\n etat=1 #on passe en mode jeu\r\n if (mousePressed) and mouseX<750 and mouseX>500 and mouseY<120 and mouseY>60: \r\n etat=2",
"def kto_wygral():\n for x in range(0, ROZMIAR_PLANSZY):\n for y in range(0, ROZMIAR_PLANSZY):\n for kierunek in (\"poziom\", \"pion\", \"skos prawy\", \"skos lewy\"):\n iksy, kolka = sprawdz_linie((x, y), kierunek)\n if iksy == ile_do_wygranej:\n return X\n if kolka == ile_do_wygranej:\n return O\n return False",
"def turysci(lista):\n # wynik - lista zawierajaca wynik koncowy dzialania funkcji(lata i wartosci dla poszczegolnych panstw)\n wynik = []\n for panstwo in lista:\n # rok - lista zawierajaca lata\n # wartosc - lista zawierajaca wartosci dla lat\n rok = []\n wartosc = []\n for element in panstwo:\n # sprawdzenie czy klucz posiada odpowiednia wartosc\n if element[1].get('key') == \"ST.INT.ARVL\":\n # dodanie roku do listy\n rok.append(int(element[2].text))\n # rozpatrywanie przypadku w ktorym wartosc jest None\n if element[3].text is None:\n wartosc.append(element[3].text)\n else:\n wartosc.append(float(element[3].text))\n # dodawanie list dla poszczegolnych panstw do listy wynikowej\n wynik.append(rok)\n wynik.append(wartosc)\n\n return wynik",
"def initialize_bolsa(self,nivel):",
"def afficher(self):\n bordRect = (self.pos[0]-5, self.pos[1]-5, self.dim[0]+5, self.dim[1]+5)\n Fond = pygame.draw.rect(self.ecran.surface, self.ecran.couleur, bordRect, 0) # Efface le precedant text\n\n rang = 0\n verif = \"\"\n compteur = 0\n self.lignes = []\n if self.txt == \"\": self.txt = \" \"\n \n while verif != self.txt:\n verif =\"\"\n rang += self.correction(self.txt[rang:], compteur)\n compteur += 1\n for k in self.lignes:\n verif += k.txt\n\n for compteur in range(len(self.lignes)):\n self.lignes[compteur].afficher()\n\n self.dim = (self.dim[0], self.hLigne*(compteur+1)) # +1 -> Boucle for\n \n pygame.display.flip()",
"def presenetCar():",
"def nze(self) -> int:",
"def nze(self) -> int:",
"def moi(self):\n\n pass",
"def nasprotnik(igralec):\n if igralec == prvi:\n return drugi\n elif igralec == drugi:\n return prvi\n else:\n assert False, \"neveljaven nasprotnik\"",
"def veglenkestatistikk( stedfesting ):\r\n\r\n antall_stedfestingelementer = len( stedfesting )\r\n utbredelse = None\r\n unike_veglenker = None \r\n\r\n if 'type' in stedfesting[0]:\r\n if stedfesting[0]['type'] == 'Linje':\r\n utbredelse = sum( [ k['sluttposisjon']-k['startposisjon'] for k in stedfesting ] ) \r\n\r\n unike_veglenker = len( set( k['veglenkesekvensid'] for k in stedfesting ))\r\n else: \r\n unike_veglenker = len( set( k['veglenkeid'] for k in stedfesting ))\r\n if 'til_posisjon' in stedfesting[0]:\r\n utbredelse = sum( [ k['til_posisjon']-k['fra_posisjon'] for k in stedfesting ] ) \r\n\r\n return (antall_stedfestingelementer, utbredelse, unike_veglenker)",
"def change_glavniLabel(self, ulaz):\r\n mapa = ulaz['opis']\r\n mjerenjeId = ulaz['mjerenjeId']\r\n datum = ulaz['datum']\r\n postaja = mapa['postajaNaziv']\r\n komponenta = mapa['komponentaNaziv']\r\n formula = mapa['komponentaFormula']\r\n mjernaJedinica = mapa['komponentaMjernaJedinica']\r\n opis = '{0}, {1}( {2} ) [{3}]. Datum : {4} . mjerenjeId:{5}'.format(postaja, komponenta, formula, mjernaJedinica, datum, mjerenjeId)\r\n self.glavniLabel.setText(opis)\r\n msg = 'glavniLabel promjenjen, value = {0}'.format(opis)\r\n logging.info(msg)",
"def obtener_peso_arista(self, v, w):\n return self.vertices[v][w]",
"def CL(self):",
"def integrointi():\n if kirjasto[\"pisteet\"]:\n try:\n indeksi_1, indeksi_2 = etsi_indeksit(\n kirjasto[\"kineettiset_energiat\"], kirjasto[\"pisteet\"][0], kirjasto[\"pisteet\"][1]\n )\n intesiteetti_kayra = kirjasto[\"korjaus\"][indeksi_1:indeksi_2]\n energia_kayra = kirjasto[\"kineettiset_energiat\"][indeksi_1:indeksi_2]\n integraali = np.trapz(intesiteetti_kayra, energia_kayra)\n ik.avaa_viesti_ikkuna(\"integraali\", integraali)\n kirjasto[\"pisteet\"] = []\n intesiteetti_kayra = []\n energia_kayra = []\n return\n except IndexError:\n ik.avaa_viesti_ikkuna(\"Error\", \"Integrointivälin valinnassa tapahtui virhe\")\n kirjasto[\"pisteet\"] = []\n intesiteetti_kayra = []\n energia_kayra = []\n else:\n ik.avaa_viesti_ikkuna(\"Error\", \"Integrointiväliä ei ole valittu\")",
"def generar_polinomio(self):\n\t\tself.poli = 0\n\t\tfor i in range(len(self.v)):\n\t\t\tpoli2 = n(self.diferencias_divididas(self.v[0:i+1]))\n\t\t\tfor j in range(i):\n\t\t\t\tpoli2 *= self.x-self.v[j][0]\n\t\t\tself.poli = self.poli + poli2"
] | [
"0.67957395",
"0.6756377",
"0.66102165",
"0.66102165",
"0.66102165",
"0.66102165",
"0.66102165",
"0.65488034",
"0.65488034",
"0.65488034",
"0.65488034",
"0.65488034",
"0.65488034",
"0.64633155",
"0.64178115",
"0.6141689",
"0.5936104",
"0.59326565",
"0.5909775",
"0.58873224",
"0.58815026",
"0.5871474",
"0.58403456",
"0.58246213",
"0.5781114",
"0.5765704",
"0.5761174",
"0.5727937",
"0.57219315",
"0.5721044",
"0.5718414",
"0.5713563",
"0.5705507",
"0.5685668",
"0.5665571",
"0.56519794",
"0.5632477",
"0.56305885",
"0.56255275",
"0.5624473",
"0.5620988",
"0.5608424",
"0.560568",
"0.5605165",
"0.55994016",
"0.5590178",
"0.55802935",
"0.5565392",
"0.5559524",
"0.55486506",
"0.5546741",
"0.55424017",
"0.5535535",
"0.55354434",
"0.5530998",
"0.55285853",
"0.55255955",
"0.5522254",
"0.5521033",
"0.55107677",
"0.54937613",
"0.54921603",
"0.549017",
"0.54888177",
"0.54650253",
"0.5443232",
"0.5439548",
"0.5433362",
"0.54322577",
"0.5424519",
"0.5418733",
"0.5418617",
"0.5411168",
"0.54055494",
"0.5394661",
"0.53937095",
"0.53930616",
"0.5391597",
"0.5371572",
"0.53712523",
"0.5369973",
"0.53621256",
"0.5361981",
"0.5353522",
"0.53431183",
"0.5339818",
"0.533763",
"0.5336025",
"0.5332245",
"0.53231454",
"0.5322981",
"0.5318632",
"0.5318632",
"0.5306288",
"0.5305439",
"0.5298387",
"0.52970785",
"0.52895415",
"0.5288714",
"0.5287685",
"0.5281941"
] | 0.0 | -1 |
Validates that the provided parameters are compatible with the appropriate authentication method. | def validate_params(aws_default_region, aws_role_arn, aws_role_session_name, aws_access_key_id, aws_secret_access_key):
if not aws_default_region:
raise DemistoException('You must specify AWS default region.')
if bool(aws_access_key_id) != bool(aws_secret_access_key):
raise DemistoException('You must provide Access Key id and Secret key id to configure the instance with '
'credentials.')
if bool(aws_role_arn) != bool(aws_role_session_name):
raise DemistoException('Role session name is required when using role ARN.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authentication_validation(username, password, access_token):\n if bool(username) is not bool(password):\n raise Exception(\"Basic authentication requires a username AND\" \" password.\")\n if (username and access_token) or (password and access_token):\n raise Exception(\n \"Cannot use both Basic Authentication and\"\n \" OAuth2.0. Please use only one authentication\"\n \" method.\"\n )",
"def _validate_params(self):\n raise NotImplementedError('Must be implemented in subclasses.')",
"def check_authcode_params(self, request: HttpRequest, params: Iterable[str]):\n is_valid = True\n auth_code_calculation_values = [\n request.GET[param_name]\n for param_name in params\n if param_name in request.GET\n ]\n correct_auth_code = self.calculate_auth_code(\n \"|\".join(auth_code_calculation_values)\n )\n auth_code = request.GET[\"AUTHCODE\"]\n if not hmac.compare_digest(auth_code, correct_auth_code):\n logger.warning('Incorrect auth code \"{}\".'.format(auth_code))\n is_valid = False\n return is_valid",
"def _check_params(self):\n pass",
"def _validate(self, **parameters):\n provided = set(parameters.keys())\n required = set([\n field.name for field in self.fields if field.required\n ])\n optional = set([\n field.name for field in self.fields if not field.required\n ])\n\n # Determine any parameter names supplied that are not valid.\n unexpected = provided - (optional | required)\n unexpected = ['\"' + item + '\"' for item in sorted(unexpected)]\n if unexpected:\n prefix = len(unexpected) > 1 and 'parameters ' or 'parameter '\n raise ValueError('Unknown ' + prefix + ', '.join(unexpected))\n\n # Determine if any required field names not supplied.\n missing = required - provided\n missing = ['\"' + item + '\"' for item in sorted(missing)]\n if missing:\n prefix = len(missing) > 1 and 'parameters ' or 'parameter '\n raise ValueError('Missing required ' + prefix + ', '.join(missing))\n\n # Ensure all parameter values are valid types.\n for value in parameters.values():\n _validate_parameter(value)",
"def check_params(self):\n raise NotImplementedError",
"def verify_args(self, params):\n for key in self.signup_args:\n if key not in params.keys():\n details = \"we don't have %s key\" % key\n logging.info(details)\n raise CustomException(details=details, error_code='')\n\n try:\n user_type = params.get('userType')\n user_types = Config.get('users', 'user_types')\n if user_type not in user_types:\n details = \"user type: %s is not supported\" % params['userType']\n logging.info(details)\n raise CustomException(details=details, error_code='')\n except KeyError as kex:\n details = \"User types undefined, moving on %s\" % kex\n logging.info(details)\n return True",
"def valid_args(args):\n is_valid = True\n if not args.ts_url or not args.username or not args.password or not args.from_user or not args.to_user:\n eprint(\"Missing required parameters.\")\n is_valid = False\n\n return is_valid",
"def check_auth():",
"def validate(self, apiobj, method, api, param, safe):",
"def test_required_parameters(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n # Missing param : lis_person_sourcedid or ext_user_username or user_id\n with self.assertRaises(PermissionDenied):\n self._authenticate(\n {\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_contact_email_primary\": \"ashley@example.com\",\n },\n passport,\n )",
"def check_auth_interactive(self, username, submethods):\n return AUTH_FAILED",
"def authenticate(self, username: str, password: str) -> Optional[str]:",
"def authenticate(self, username: str, password: str) -> Optional[str]:",
"def supports_auth_method(self, auth_method):\n type_set = set(self.type.split('+'))\n am_set = set(auth_method.split('+'))\n return am_set.issubset(type_set)",
"def test_validate_authorization_request_required_parameters(self):\n\n request = self.make_request()\n scopes, credentials = self.auth.validate_authorization_request(request)\n\n self.assertListEqual(scopes, request.scope.split())\n assert credentials['client_id'] == request.client_id\n assert credentials['redirect_uri'] == request.redirect_uri\n assert credentials['response_type'] == request.response_type\n assert credentials['state'] == request.state\n\n self.validator.validate_client_id\\\n .assert_called_once_with(request.client_id, request)\n self.validator.validate_redirect_uri\\\n .assert_called_once_with(request.client_id, request.redirect_uri, request)",
"def authenticate(credentials):",
"def check(self):\n invalid = []\n\n if not self.route:\n invalid.append(('route', 'missing'))\n elif not self.route[1] in ['GET', 'POST', 'PUT']:\n invalid.append(('route', 'invalid method: %s' % self.route[1]))\n\n has_2xx = False\n for rcode in self.return_codes:\n code = rcode[0]\n if code >= 200 and code < 300:\n has_2xx = True\n break\n if not has_2xx:\n invalid.append(('return_codes', 'Missing succes return code doc'))\n\n if self.client_auth is None:\n invalid.append(\n ('client_auth', 'Please provide client auth requirement'))\n\n if self.user_auth is None:\n invalid.append(\n ('user_auth', 'Please provide user auth requirement'))\n\n if invalid:\n msgs = []\n for error in invalid:\n msgs.append(\"%s: %s\" % error)\n raise ValueError(\n \"APIFunc for %s is invalid: %s\"\n % (self.viewfunc.__name__,\n ', '.join(msgs)))",
"def authentication_required(meth):\n\n def check(cls, *args, **kwargs):\n if cls.authenticated:\n return meth(cls, *args, **kwargs)\n raise Error(\"Authentication required\")\n\n return check",
"def validate(self, apiobj, method, api, param, safe):\n if method in ('PUT', 'DELETE'):\n validate_strlist('site_name', param, safe, RX_SITE)\n validate_strlist('ce', param, safe, RX_FQDN)\n validate_strlist('release', param, safe, RX_RELEASE)\n validate_strlist('arch', param, safe, RX_ARCH)\n validate_lengths(safe, 'site_name', 'ce', 'release', 'arch')\n # Delay authz until we have database connection for name remapping.",
"def validate_args(engine: SqRestEngine, params: Dict):\n def req_error(param: str, exp: str, got: str) -> str:\n return f'Wrong request {param}: expected {exp} - got {got}'\n\n try:\n # we expect the following function to raise a ConnectionError\n # exception since the server was not started\n engine._get_response('verb', **params)\n assert False, f'The request did not raise an exception for {params}'\n except ConnectionError as err:\n # get the request sent in the engine._get_response function\n url = urlparse(err.request.url)\n\n # check the path matches the internal variable parameters\n api_path = f'/api/v2/{engine.iobj.table}/verb'\n url_params = {\n # <param_name> : [<got>, <expected>]\n 'ip': [url.hostname, engine.ctxt.rest_server_ip],\n 'port': [url.port, engine.ctxt.rest_server_port],\n 'transport': [url.scheme, engine.ctxt.rest_transport],\n 'path': [url.path, api_path]\n }\n\n for param, values in url_params.items():\n assert values[0] == values[1], \\\n req_error(param, values[1], values[0])\n\n # check query parameters\n url_query = parse_qs(url.query)\n for query_param, query_value in url_query.items():\n assert len(query_value) == 1, \\\n f'Got more than 1 value for {query_param}'\n query_value = query_value[0]\n if query_param == 'access_token':\n # access_token needs a special validation\n assert query_value == engine.ctxt.rest_api_key, \\\n req_error(query_param, engine.ctxt.rest_api_key,\n query_value)\n elif query_param in params:\n # check parameters set in the query\n assert params[query_param] == query_value, \\\n req_error(query_param, params[query_param], query_value)\n else:\n # check default parameters\n assert query_value == 'default', \\\n req_error(query_param, 'default', query_value)",
"def validate_credentials(self, data):\n try:\n boolean_param_list = []\n get_service_data = app.config.get('JWT_CONFIG').get('CREDENTIAL')\n token_identity_param = app.config.get('JWT_CONFIG').get('TOKEN_IDENTITY_PARAM')\n expires_delta = app.config.get('JWT_CONFIG').get('TOKEN_EXPIRY')\n expires_delta = eval(expires_delta) if isinstance(expires_delta, str) else expires_delta\n credentials = data.get('credentials')\n identity_credentials_keys = list(get_service_data.keys())\n for key in identity_credentials_keys:\n if get_service_data[key] != credentials[key]:\n boolean_param_list.append(False)\n else:\n boolean_param_list.append(True)\n\n if False in boolean_param_list:\n return {'msg': \"Incorrect Credentials\"}, 401\n else:\n access_token = self.auth_token_generate(\n identity_param_val=credentials[token_identity_param], expires_delta=expires_delta)\n return {'access_token': access_token}, 200\n except Exception as e:\n print(e)\n return {'msg': \"Incorrect Credentials\"}, 401",
"def check_valid_params(cls, **user_params):\n # Check that the appropriate number of params are provided\n if not all(key in user_params for key in cls.param.keys()):\n raise ValueError(f\"Missing parameter! Expected {cls.param.keys()} but was given {user_params.keys()}\")\n\n # Check parameter units and values\n for (key, allowed_params), user_param in zip(cls.param.items(), user_params.values()):\n\n # If both have units, check that the user param value is valid. If valid, continue. Else, error\n if type(user_param) == Quantity and type(allowed_params) == Quantity:\n if get_physical_type(user_param.unit) != get_physical_type(allowed_params.unit):\n raise UnitTypeError(f\"Incorrect units {user_param.unit} provided for parameter {key}, \"\n f\"expected {allowed_params.unit}\")\n\n elif np.isin(user_param.to(allowed_params.unit).value, allowed_params.value):\n continue\n else:\n raise ValueError(f\"Invalid value '{user_param}' provided for parameter {key}, \"\n f\"allowed value(s): {allowed_params}\")\n\n # If one only one has units, then error\n elif (type(user_param) == Quantity) ^ (type(allowed_params) == Quantity):\n # User param has units, model param is unitless\n if type(user_param) == Quantity:\n raise ValueError(f\"Invalid units {user_param.unit} for parameter {key} provided, expected None\")\n else:\n raise ValueError(f\"Missing units for parameter {key}, expected {allowed_params.unit}\")\n\n # Check that unitless user param value is valid. If valid, continue. Else, Error\n elif user_param in allowed_params:\n continue\n else:\n raise ValueError(f\"Invalid value '{user_param}' provided for parameter {key}, \"\n f\"allowed value(s): {allowed_params}\")\n\n # Check Combinations (Logic lives inside model subclasses under model.isvalid_param_combo)\n if user_params not in cls.get_param_combinations():\n raise ValueError(\n f\"Invalid parameter combination. See {cls.__class__.__name__}.get_param_combinations() for a \"\n \"list of allowed parameter combinations.\")",
"def validate_params(self, params: Scenario) -> bool:\n valid = True\n # Make sure all needed parameters were provided\n valid = valid and \"R\" in params\n valid = valid and \"L\" in params\n\n # Make sure all parameters are physically valid\n valid = valid and params[\"R\"] > 0\n valid = valid and params[\"L\"] > 0\n\n return valid",
"def test_verify_param_compare_types(self):\n utils.check_raises(lambda: ax.verify_param(\"1\", paramCompare=1, isEqual=True), HTTPInternalServerError)\n utils.check_raises(lambda: ax.verify_param(\"1\", paramCompare=True, isEqual=True), HTTPInternalServerError)\n utils.check_raises(lambda: ax.verify_param(1, paramCompare=\"1\", isEqual=True), HTTPInternalServerError)\n utils.check_raises(lambda: ax.verify_param(1, paramCompare=True, isEqual=True), HTTPInternalServerError)\n\n # strings cases handled correctly (no raise)\n utils.check_no_raise(lambda: ax.verify_param(\"1\", paramCompare=u\"1\", isEqual=True))",
"def _validate_parameters(self):\n errors = []\n for key in self.PARAMETERS.keys():\n if key not in self.request_obj.data_params:\n errors.append(key)\n\n if errors:\n raise DataParsingError('Following data items are missing: {}'.format(', '.join(errors)))\n\n for key, params in self.PARAMETERS.items():\n params[0].validate_type(key, self.request_obj.data_params.get(key), params[1])",
"async def check_auth(self, info) -> Union[User, Tuple[LSAT, Macaroon], Error]:\n # check if auth header is present\n serial_macaroon, preimage = self.get_auth(info)\n if not serial_macaroon:\n return Error(\"NoCredentials\", \"No token sent. You are not logged in\")\n # attempt to deserialize macaroon\n try:\n macaroon = Macaroon.deserialize(serial_macaroon)\n except MacaroonDeserializationException:\n return Error(\"AuthenticationError\", \"Invalid token sent\")\n\n # define types needed\n macaroon_key: bytes\n payload: Union[User, Tuple[LSAT, Macaroon]]\n # times token has been used. Only important with lsats\n used = 0\n # determine if auth is an lsat\n if \"LSAT\" in self.args.get(\"kind\"):\n lsat: Optional[LSAT] = await LSAT.get(macaroon.identifier)\n if not lsat:\n return Error(\"AuthenticationError\", \"Could not find lsat\")\n self.logger.critical(f\"comparing {preimage} with {lsat.preimage}\")\n if not preimage or preimage != lsat.preimage:\n return Error(\"AuthenticationError\", \"Invalid preimage\")\n used = lsat.used\n macaroon_key = lsat.key\n payload = lsat\n\n # auth is standard macaroon\n else:\n # lookup user by identifier\n db_user: Optional[User] = await User.get(macaroon.identifier)\n if not db_user:\n return Error(\"AuthenticationError\", \"Could not find user\")\n macaroon_key = db_user.key\n payload = db_user\n\n # verify macaroon against directive arguments\n try:\n verify(\n macaroon=macaroon,\n key=macaroon_key,\n roles=self.args.get(\"roles\"),\n caveats=self.args.get(\"caveats\"),\n used=used,\n req=info.context[\"request\"],\n )\n except MacaroonInvalidSignatureException:\n return Error(\"AuthenticationError\", \"Macaroon caveats not satisfied\")\n\n return payload",
"def _validate_action_parameters(func, params):\n if params is not None:\n # Verify field name is valid\n valid_fields = [\n FIELD_TEXT,\n FIELD_NUMERIC,\n FIELD_NO_INPUT,\n FIELD_SELECT,\n FIELD_SELECT_MULTIPLE,\n FIELD_DICT,\n FIELD_BOOLEAN\n ]\n\n for param in params:\n param_name, field_type = param['name'], param['fieldType']\n if param_name not in func.__code__.co_varnames:\n raise AssertionError(\"Unknown parameter name {0} specified for\" \\\n \" action {1}\".format(\n param_name, func.__name__))\n\n if field_type not in valid_fields:\n raise AssertionError(\"Unknown field type {0} specified for\" \\\n \" action {1} param {2}\".format(\n field_type, func.__name__, param_name))",
"def __verify_required_parameters(self, parameters, required_parameters):\n\n\t\tfor parameter in required_parameters:\n\t\t\tif False == parameters.has_key(parameter):\n\t\t\t\traise MissingParameterError(parameter)\n\n\t\treturn True",
"def validate(self):\n if self.first_name is None or not self.first_name.strip():\n raise AuthorizeInvalidError('First name on account is required.')\n if self.last_name is None or not self.last_name.strip():\n raise AuthorizeInvalidError('Last name on account is required.')\n if self.customer_type == 'business':\n if self.company is None or not self.company.strip():\n raise AuthorizeInvalidError('Company name is required.')\n if self.bank_name is None or not self.bank_name.strip():\n raise AuthorizeInvalidError('Bank name is required.')\n if self.routing_number is None or not self.routing_number.strip():\n raise AuthorizeInvalidError('Routing number is required.')\n if self.account_number is None or not self.account_number.strip():\n raise AuthorizeInvalidError('Account number is required.')\n if self.customer_type is None or not self.customer_type.strip():\n raise AuthorizeInvalidError('Customer type is required.')\n if self.customer_type not in CUSTOMER_TYPES:\n raise AuthorizeInvalidError('Customer type is not valid.')\n if self.account_type is None or not self.account_type.strip():\n raise AuthorizeInvalidError('Bank account type is required.')\n if self.account_type not in ACCOUNT_TYPES:\n raise AuthorizeInvalidError('Bank account type is not valid.')\n if self.routing_number_type is None \\\n or not self.routing_number_type.strip():\n raise AuthorizeInvalidError('Routing number type is required.')\n if self.routing_number_type not in ROUTING_NUMBER_TYPES:\n raise AuthorizeInvalidError('Routing number is not valid.')\n if self.echeck_type is None or not self.echeck_type.strip():\n raise AuthorizeInvalidError('eCheck type is required.')\n if self.echeck_type not in ECHECK_TYPES:\n raise AuthorizeInvalidError('eCheck type is not valid.')\n self._validate_account_number(self.account_number)\n self._validate_aba(self.routing_number)",
"def validate(cls, **kwargs: Any) -> None: # pragma no cover",
"def get_allowed_auths(self, username):\n method=\"\"\n sep=\"\"\n if self.users.get(username,False) and self.users[username].get('RSA:',False):\n method=method+sep+\"publickey\"\n sep=','\n if self.users.get(username,False) and self.users[username].get('PWD:',False):\n method=method+sep+\"password\"\n sep=','\n return method",
"def allow_method (self, method, user, ** kw) :\n if self.auth_required and not \\\n (user and user.authenticated and user.active) :\n return False\n if isinstance (method, pyk.string_types) :\n try :\n method = GTW.RST.HTTP_Method.Table [method]\n except KeyError :\n raise self.Status.Method_Not_Allowed \\\n ( _T (\"Unknown HTTP method `%s` requested\") % (method, )\n , valid_methods = sorted (self.SUPPORTED_METHODS)\n )\n if method and not (user and user.superuser) :\n pn = method.mode + \"_permissions\"\n permissions = getattr (self, pn)\n for p in permissions :\n if not p (user, self, ** kw) :\n if p.auth_required :\n return False\n else :\n raise self.Status.Forbidden \\\n (p.message (user, self, ** kw))\n return True",
"def _validate_parameters(self):\n super()._validate_parameters()\n\n #################### callbacks ####################\n self.callbacks = check_callback(self.callbacks)",
"def authenticate_credentials(self, **credentials):\n return None",
"def _validate_rpc_request(self, request):\n if request.get('jsonrpc', None) != '2.0':\n raise ValueError('Invalid jsonrpc: must be \"2.0\"')\n\n id = request.get('id', None)\n if not (id is None or isinstance(id, (str, int, float))):\n raise ValueError('Invalid id: must be null, string or number')\n\n method = request.get('method', None)\n if not isinstance(method, str):\n raise ValueError('Invalid method: must be string')\n\n params = request.get('params', [])\n if not isinstance(params, (dict, list)):\n raise ValueError('Invalid params: must be array or object')",
"def validate(self, credentials):\n user = authenticate(**credentials)\n if user and user.is_active:\n return user\n raise serializers.ValidationError('Incorrect Credentials')",
"def test_type_error_raised(self):\n with self.assertRaises(TypeError):\n authenticate(username=\"test\", password=\"test\")",
"def test_validate_credentials(self):\n pass",
"def _validate_user(_):\n pass",
"def validate_auth(config):\n token = config.get(CONF_ACCESS_TOKEN)\n if config[CONF_DEVICE_CLASS] == \"tv\" and not token:\n raise vol.Invalid(\n f\"When '{CONF_DEVICE_CLASS}' is 'tv' then '{CONF_ACCESS_TOKEN}' is required.\",\n path=[CONF_ACCESS_TOKEN],\n )\n return config",
"def auth_required(self, cls):\n assert cls.authentication_classes == [JWTKeyAuthentication]",
"def check_parameters_valid(self) :\n for check_parameter in self.parameters :\n if (not self.parameters[check_parameter]['set']) :\n error_message = \"Missing key -> '\" + check_parameter + \"'\"\n if (Config.logger) :\n dtpo_log('fatal', error_message)\n raise ParseError(error_message)\n\n if self.parameters[check_parameter]['type'] == 'dir' :\n value = self.parameters[check_parameter]['value']\n return_string = check_directory_permissions(value)\n if return_string :\n error_message = \"{0} not accessible \" \\\n \"-> {1}\".format(\n check_parameter,\n return_string)\n raise ParseError(error_message)\n elif self.parameters[check_parameter]['type'] == 'file' :\n value = self.parameters[check_parameter]['value']\n try :\n file_pointer = open(value)\n file_pointer.close()\n except IOError as io_error :\n error_message = \"File {0} not accessible -> {2}\" \\\n .format(\n check_parameter,\n self.parameters[check_parameter]['value'],\n str(io_error))\n raise ParseError(error_message)",
"def validate_authentication(self, username, password, handler):\n user = connection.User.find_one({ 'email' : str(username) , 'apikey' : str(password)})\n if user is None:\n msg = \"Authentication failed.\"\n raise AuthenticationFailed(msg)",
"def check_auth(username, password, expected_user, expected_pw):\n return username == expected_user and password == expected_pw",
"def clean(self):\n cleaned_data = super().clean()\n username = cleaned_data['username']\n password = cleaned_data['password']\n\n if authenticate(username=username, password=password) is None:\n raise ValidationError('Your username or password is incorrect.')",
"def valid(self, *args, **kwargs) -> Any:\n pass",
"def authenticate(self, request, **kwargs):\n\n login = kwargs.get(\n 'login',\n kwargs.get('username', None))\n password = kwargs.get('password', None)\n\n if login and password:\n\n lookup_obj = Q()\n\n authentication_methods = app_settings.AUTHENTICATION_METHODS\n if (AuthenticationMethod.PHONE in authentication_methods and\n PhoneValidationForm({'phone': login}).is_valid()):\n lookup_obj |= Q(phonenumber__phone=login)\n elif (AuthenticationMethod.EMAIL in authentication_methods and\n EmailValidationForm({'email': login}).is_valid()):\n lookup_obj |= Q(emailaddress__email=login)\n elif (AuthenticationMethod.USERNAME in authentication_methods and\n UsernameValidationForm({'username': login}).is_valid()):\n lookup_obj |= Q(username=login)\n else:\n return None\n\n if lookup_obj:\n try:\n user = User.objects.get(lookup_obj)\n if (user.check_password(password)\n and self.user_can_authenticate(user)):\n return user\n except User.DoesNotExist:\n return None\n\n return None",
"def authenticate(user, request):",
"def check_sync_input(self, sync_params):\n for req_param in REQUIRED_PARAMS:\n if req_param not in sync_params:\n logger.error(\"Received request with missing '%s' parameter\", req_param)\n raise YKSyncError('MISSING_PARAMETER', req_param)\n if req_param not in ('otp', 'nonce', 'yk_publicname') and not \\\n (sync_params[req_param] == '-1' or isinstance(sync_params[req_param], int)):\n logger.error(\"Input parameter '%s' is not correct\", req_param)\n raise YKSyncError('INVALID_PARAMETER', req_param)",
"def _validate_params(self, request_set, target_set=None, context=None):\n super()._validate_params(request_set=request_set, target_set=target_set, context=context)\n\n controller = target_set[CONTROLLER]\n if (not isinstance(controller, ControlMechanism_Base) and\n not (inspect.isclass(controller) and issubclass(controller, ControlMechanism_Base))):\n raise SystemError(\"{} (controller arg for \\'{}\\') is not a ControllerMechanism or subclass of one\".\n format(controller, self.name))\n\n for process in target_set[kwProcesses]:\n if not isinstance(process, Process):\n raise SystemError(\"{} (in processes arg for \\'{}\\') is not a Process object\".format(process, self.name))\n\n for mech, value in target_set[kwInitialValues].items():\n if not isinstance(mech, Mechanism):\n raise SystemError(\"{} (key for entry in initial_values arg for \\'{}\\') \"\n \"is not a Mechanism object\".format(mech, self.name))",
"def _validate_argument_types_match(self, rule, argument_types):\n if len(set(argument_types)) > 1:\n self.add_error(\n self.OPERATOR_ARGUMENT_TYPE_MISMATCH,\n rule=str(rule),\n argument_types=argument_types,\n )",
"def _validate_parameter_combinations(self):\n parameters = [\"type\", \"path\", \"mode\", \"default\", \"min\", \"max\"]\n parameters = {key: getattr(self, key, None) for key in parameters}\n type = parameters.pop(\"type\")\n\n # validate parameter combination\n if type in self._TYPE_COMBINATION_MAPPING:\n valid_parameters = self._TYPE_COMBINATION_MAPPING[type]\n for key, value in parameters.items():\n if key not in valid_parameters and value is not None:\n msg = \"Invalid parameter for '{}' Input, parameter '{}' should be None but got '{}'\"\n raise ValidationException(\n message=msg.format(type, key, value),\n no_personal_data_message=msg.format(\"[type]\", \"[parameter]\", \"[parameter_value]\"),\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n )",
"def check_auth(*args, **kwargs):\n r = cherrypy.request\n s = cherrypy.session\n\n username = s.get(USERNAME_SESSION_KEY, None)\n course = s.get(CUR_CRS_SESSION_KEY, None)\n # require a course to be selected\n if username and not course and r.path_info != '/auth/course':\n raise cherrypy.HTTPRedirect(\"/auth/course\")\n\n conditions = r.config.get('auth.restrict.require', None)\n if conditions is not None:\n if username:\n r.login = username\n for condition in conditions:\n # A condition is just a callable that returns true or false\n if not condition():\n raise cherrypy.HTTPRedirect(\"/auth/not-authorized\")\n else:\n s[FROMPATH_SESSION_KEY] = r.path_info\n raise cherrypy.HTTPRedirect(\"/auth/login\")",
"def validate_input():\n pass_length = None\n account_name = None\n method = None\n in_value = None\n parser = ArgumentParser()\n parser.add_argument(\"-l\", \"--length\",\n type=int,\n help=\"length of password\")\n\n parser.add_argument(\"-a\", \"--account\",\n help=\"account or site name\")\n\n parser.add_argument(\"-m\", \"--method\",\n help=\"method to take [S|C|R|U|D]\")\n\n parser.add_argument(\"-v\", \"--value\",\n help=\"Do not generate, store this value\")\n\n args = parser.parse_args()\n if args.length:\n pass_length = int(args.length)\n\n if args.account:\n account_name = str(args.account)\n\n if args.method:\n method = str.upper(args.method)\n\n if args.value:\n in_value = str(args.value)\n\n return (pass_length, account_name, method, in_value)",
"def check_user_parameters(user_information):\n\n email = user_information.get('email', '')\n sub_end_date = user_information.get('subenddate', '')\n vineyards = user_information.get('vineyards', '')\n current_date = datetime.date.today().strftime('%Y-%m-%d')\n new_user_id = user_information.get('userid', '')\n is_admin = user_information.get('admin', '')\n is_enable = user_information.get('enable', '')\n\n try:\n message = (\n 'Validating submitted user parameters.'\n )\n logger.info(message)\n check_user_id(new_user_id)\n if email != '':\n if re.match(r\"[^@]+@[^@]+\\.[^@]+\", email) is None:\n raise PlantalyticsDataException(EMAIL_INVALID)\n check_subscription_end_date(sub_end_date, current_date)\n if is_admin != '':\n if not isinstance(is_admin, bool):\n raise PlantalyticsDataException(DATA_INVALID)\n if is_enable != '':\n if not isinstance(is_enable, bool):\n raise PlantalyticsDataException(DATA_INVALID)\n if vineyards != '':\n for vineyard_id in vineyards:\n if int(vineyard_id) < 0:\n raise PlantalyticsDataException(VINEYARD_BAD_ID)\n message = (\n 'Submitted user parameters successfully validated.'\n )\n logger.info(message)\n except PlantalyticsException as e:\n raise e\n except ValueError as e:\n raise e\n except Exception as e:\n raise e",
"def _authenticate(self, request, params):\n username = params[\"username\"]\n # Quick check if we've already validated these params.\n if request.environ.get(_ENVKEY_VALID_RESPONSE):\n return True\n # Obtain the verifier information somehow.\n (_, _, verifier) = self._get_verifier(username)\n if verifier is None:\n return False\n # Validate the HMAC digest response.\n privkey = self._get_privkey(params[\"nonce\"])\n if not check_response(request, params,\n privkey=privkey, verifier=verifier):\n return False\n # Cache the successful authentication.\n request.environ[_ENVKEY_VALID_RESPONSE] = True\n return True",
"def _validate_args(self):\n\n self.logger.info(\"Validating instance arguments.\")\n\n # test if @self.account_name is an identifier.\n if not self.account_name.isidentifier():\n msg = \"Account name '{}' is not a valid identifier; problems may occur.\".format(\n self.account_name)\n self.logger.warning(msg)\n\n # verify @self.pst_file exists.\n if not os.path.isfile(self.pst_file):\n msg = \"Can't find PST file: {}\".format(self.pst_file)\n raise FileNotFoundError(msg)\n\n # verify @self.output_path exists.\n if not os.path.isdir(self.output_path):\n msg = \"Can't find folder: {}\".format(self.output_path)\n raise NotADirectoryError(msg)\n\n # make sure @self.mime_path doesn't already exist.\n if os.path.isdir(self.mime_path):\n msg = \"Can't overwrite existing MIME folder: {}\".format(self.mime_path)\n raise IsADirectoryError(msg)\n\n return",
"def _validate_user_fields(fields: dict):\n # Checks\n for k, v in fields.items():\n if k == \"username\":\n if len(v) > UserLimits.USERNAME_MAX_LENGTH or len(v) < UserLimits.USERNAME_MIN_LENGTH:\n raise ForbiddenArgument(\"invalid username\")\n\n elif k == \"fullname\":\n if len(v) > UserLimits.FULLNAME_MAX_LENGTH or len(v) < UserLimits.USERNAME_MIN_LENGTH:\n raise ForbiddenArgument(\"invalid full name\")\n\n elif k == \"email\":\n if not is_email(v) or len(v) > UserLimits.EMAIL_MAX_LENGTH or len(v) < UserLimits.EMAIL_MIN_LENGTH:\n raise ForbiddenArgument(\"invalid email\")\n\n elif k == \"password\":\n if len(v) > UserLimits.PASSWORD_MAX_LENGTH or len(v) < UserLimits.PASSWORD_MIN_LENGTH:\n raise ForbiddenArgument(\"invalid password\")",
"def _check_params(self):\n\t\tstrange_param_helper = False\n\t\tfor param in self.params:\n\t\t\n\t\t\t# It could be that the param encapsulates several values (e.g., \"FLUX_RADIUS(10)\")\n\t\t\t# So we have to dissect this\n\t\t\tmatch = re.compile(\"(\\w*)\\(\\d*\\)\").match(param)\n\t\t\tif match:\n\t\t\t\tcleanparam = match.group(1)\n\t\t\telse:\n\t\t\t\tcleanparam = param\n\t\t\t\t\n\t\t\tif cleanparam not in self.fullparamlist:\n\t\t\t\tlogger.warning(\"Parameter '%s' seems strange and might be unknown to SExtractor\" \\\n % (param))\n\t\t\t\tstrange_param_helper = True\n\t\t\t\t\n\t\tif strange_param_helper:\n\t\t\tlogger.warning(\"Known parameters are: %s\" % (self.fullparamtxt))",
"def validate(self, data):\n username = data.get(\"username\")\n password = data.get(\"password\")\n\n user = authenticate(\n request=self.context.get(\"request\"), username=username, password=password\n )\n\n if not user:\n msg = _(\"Unable to authenticate with provided credentials\")\n raise serializers.ValidationError(msg, code=\"authentication\")\n\n data[\"user\"] = user\n return data",
"def validate_methods(methods):\n if not methods:\n return\n\n for method in methods:\n if method not in Options.available_methods():\n raise InvalidMethodException(\"Invalid method: '\" + method + \\\n \"'. No method was found with this method_id. Valid choices for method are \" +\n str([method for method in Options.available_methods()]))",
"def signature_check(self, fn):\n if not isinstance(fn, type) or not issubclass(fn, forms.BaseForm):\n raise ValueError(\"validate_form only apply to Django Forms\")\n self.required_arguments_names = set()\n self.optional_arguments_names = {\"data\"}\n self.accepted_argument_names = {\"data\"}",
"def _verify_arguments(self, kwargs: dict[str, Any]):\n geom_stat_args = kwargs.keys() | self._stat._kwargs.keys()\n unknown = (\n geom_stat_args\n - self.aesthetics()\n - self.DEFAULT_PARAMS.keys() # geom aesthetics\n - self._stat.aesthetics() # geom parameters\n - self._stat.DEFAULT_PARAMS.keys() # stat aesthetics\n - { # stat parameters\n \"data\",\n \"mapping\",\n \"show_legend\", # layer parameters\n \"inherit_aes\",\n \"raster\",\n }\n ) # layer parameters\n if unknown:\n msg = (\n \"Parameters {}, are not understood by \"\n \"either the geom, stat or layer.\"\n )\n raise PlotnineError(msg.format(unknown))",
"def test_authenticate_random_credentials(self):\n \n self.assertRaises(\n TypeError, \n self.authenticator.authenticate,\n foo='bar'\n )",
"def run_parameters_validations(self):\n if self.risk_rule:\n if 'connectApi' not in self.services:\n return_error(\"You entered a risk rule but the 'connectApi' service is not chosen. \"\n \"Add the 'connectApi' service to the list or remove the risk rule.\")\n else:\n for risk_rule in self.risk_rule:\n if not is_valid_risk_rule(self, risk_rule):\n return_error(f\"The given risk rule: {risk_rule} does not exist,\"\n f\"please make sure you entered it correctly. \\n\"\n f\"To see all available risk rules run the '!rf-get-risk-rules' command.\")\n\n if self.fusion_file_path is not None:\n if 'fusion' not in self.services:\n return_error(\"You entered a fusion file path but the 'fusion' service is not chosen. \"\n \"Add the 'fusion' service to the list or remove the fusion file path.\")",
"def valid_args(self):\r\n for k in request.args.keys():\r\n if k not in ['api_key']:\r\n getattr(self.__class__, k)",
"def check_credentials_typo(credentials):\n regex_username = r'^[\\w\\.\\-]{2,}$'\n regex_password = r'[^.]{4,10}$'\n\n if not match(regex_username, credentials['username']):\n raise ValueError('invalid username typo')\n\n if not match(regex_password, credentials['password']):\n raise ValueError('invalid password typo')",
"def Check(self, parameters):",
"def check_auth(*args, **kwargs):\n\tconditions = cherrypy.request.config.get('auth.require', None)\n\tif conditions is not None:\n\t\tusername = cherrypy.session.get(SESSION_KEY)\n\t\tif username:\n\t\t\tcherrypy.request.login = username\n\t\t\tfor condition in conditions:\n\t\t\t\t# A condition is just a callable that returns true or false\n\t\t\t\tif not condition():\n\t\t\t\t\traise cherrypy.HTTPRedirect(\"/auth/login\")\n\t\telse:\n\t\t\traise cherrypy.HTTPRedirect(\"/auth/login\")",
"def _check_parameters_support(self, parameters=()):\n for parameter in parameters:\n assert parameter in self._supported, \"Estimation %s is not implemented yet\" % parameter",
"def check_auth(username, password):\n # return username == app.config['USER'] and password == app.config['PASS']\n\n return username == app.config['USER'] and password == app.config['PASS']",
"def test_mismatchedParams(self):\n self.assertRaises(irc.IRCBadModes, irc.parseModes, \"+k\", [], self.paramModes)\n self.assertRaises(\n irc.IRCBadModes,\n irc.parseModes,\n \"+kl\",\n [\"foo\", \"10\", \"lulz_extra_param\"],\n self.paramModes,\n )",
"def _get_unvalidated_auth_params(self, request):\n try:\n params = parse_authz_header(request)\n except ValueError:\n params = None\n if params is None:\n return None\n if params[\"scheme\"].lower() != \"srp-hmac\":\n return None\n return params",
"def check_authorization(self, params):\n response = self.post(f\"{self.gateway_path}/check_authorization\", params)\n return response",
"def api_auth_validate(request, access_key):\n if not request.is_json:\n return {'error' : 'Bad request, payload must be JSON', 'code' : 400}\n if not 'working_repo' in session:\n return {'error' : 'Operation requires authentication', 'code': 401}\n if session['working_repo'] != access_key:\n return {'error' : 'Not authorized for this operation', 'code' : 403}\n \n return True",
"def _check_parameters(self, ep, params):\n\n any_group_satisfied = False\n for group in ep.REQUIRED:\n if all(required_param in params for required_param in group):\n any_group_satisfied = True\n\n if not any_group_satisfied:\n raise ValueError(f\"Got parameters {params}, expected one of {ep.REQUIRED}\")\n\n for key in params:\n if key not in ep.POSSIBLE:\n raise ValueError(f\"Got {key}, expected one of {ep.POSSIBLE}\")",
"def validate(self, *args, **kwargs):\n raise NotImplementedError('Validate not implemented')",
"def __authenticate(self, data):\n if 'token' not in data:\n raise TokenError(\"Invalid Token\")\n if data['token'] != app.config['SLACK_TOKEN']:\n raise TokenError(\"Invalid Token\")",
"def _validate_query_parameters(self):\n check_years(self._years)\n check_geo_hierarchy(self.for_geo, self.in_geo)\n check_geo_estimates(self.estimate, self.for_geo)\n return True",
"def _security_check_parameters(param_dict):\n for key, value in param_dict.iteritems():\n str_value = str(value) # Could easily be an int or a float\n for bad_str in [\";\", \"&&\", \">\", \"<\", \"|\"]:\n if bad_str in str_value:\n raise ValueError(\"Rejecting suspicious argument for %s\" % key)",
"def _check_allowed_values(self, parameters):\n for key, allowed_values in self.ALLOWED_VALUES:\n self.log([u\"Checking allowed values for parameter '%s'\", key])\n if key in parameters:\n value = parameters[key]\n if value not in allowed_values:\n self._failed(u\"Parameter '%s' has value '%s' which is not allowed.\" % (key, value))\n return\n self.log(u\"Passed\")",
"def __checkArgs(self, kwargs):\n requiredArgs = self.__class__.__requiredArgs + \\\n self.__class__.__singleCompArgs if self.singleComp else\\\n self.__class__.__requiredArgs + self.__class__.__doubleCompArgs\n for arg in requiredArgs:\n if arg not in kwargs:\n raise ValueError(\"Essential keyword argument %s missing\" % arg)\n for (k, v) in kwargs.items():\n assert k in self.__class__.__allowedArgs, \"Invalid Argument %s\" % k",
"def validate(self):\n if self.params.get(\"format\"):\n if self.params[\"format\"] not in formats:\n raise ValueError(f\"format must be one of {formats}: {self.dt}\")\n for p in self.required:\n if not self.params.get(p):\n raise ValueError(f\"{p} missing: {self.dt}\")",
"def test_login_fails_for_missing_parameters(self):\n resp = self.test_client.post(\n \"/api/v1/auth/login\",\n data=dict(email='testor@example.com')) # password not given\n self.assertEqual(resp.status_code, 400)\n data = json.loads(resp.data)\n self.assertEqual(\n data[\"message\"],\n \"you need to enter both the email and the password\"\n )",
"def _verify_arguments(self):\n # if self.options.action == \"create\":\n # if self.options.encrypt_payload and not self.options.payload_secret:\n # self.parser.error('A secret must be supplied with --payload-secret option when the --encrypt-payload option is in use.')\n pass",
"def check_params(cls, **kwargs) -> None:\n\n for key, val in kwargs.items():\n cls.check_param(key, val)",
"def authenticate(self, request):\n\n return self._validate_token(request)",
"def validate_params(self, ctx):\n try:\n return self._validate_params()\n except formencode.Invalid as exc:\n unpack = exc.unpack_errors()\n self.__request.set_property(lambda: unpack,\n self._invalid_params_attr,\n reify=True)\n if self._raise_exc is True:\n self._raise(self._invalid_params_exc, unpack)",
"def __check_args(self):\n self.__check_args_type()\n self.__check_args_val()",
"def auth_required(handler_method):\n\n def check_auth(self, *args):\n self.userid, self.credentials = load_session_credentials(self)\n self.mirror_service = create_service('mirror', 'v1', self.credentials)\n # TODO: Also check that credentials are still valid.\n if self.credentials:\n try:\n self.credentials.refresh(httplib2.Http())\n return handler_method(self, *args)\n except AccessTokenRefreshError:\n # Access has been revoked.\n store_userid(self, '')\n credentials_entity = Credentials.get_by_key_name(self.userid)\n if credentials_entity:\n credentials_entity.delete()\n self.redirect('/auth')\n return check_auth",
"def is_valid_request(self, request):\r\n auth_params = request.META.get(\"HTTP_AUTHORIZATION\", [])\r\n return self.is_in(auth_params) or self.is_in(request.REQUEST)",
"def authenticate(self, request):\n return None",
"def _validate_field(param, fields):\n\n if param.field not in fields:\n raise InvalidQueryParams(**{\n 'detail': 'The sort query param value of \"%s\" is '\n 'invalid. That field does not exist on the '\n 'resource being requested.' % param.raw_field,\n 'links': LINK,\n 'parameter': PARAM,\n })",
"def request_is_valid(request):\n return 'method' in request",
"def validate_params(cls, args):\n if not (len(args) == 3 or len(args) == 5 or len(args) == 7):\n sys.exit(\n 'Execute o script passando o caminho do diretório das'\n ' imagens, ou apenas o path de uma imagem e decida se'\n ' deseja mover ou não'\n )\n args_dict = cls.__make_params(args)\n keys_args_set = set(args_dict.keys())\n if keys_args_set.difference(KEYS_DEFAULT_AS_SET) != set():\n sys.exit(\n 'Verifique a passagem de parâmetros.'\n ' Foi encontrado parâmetros desconhecidos.'\n )\n\n return cls.__check_args(args_dict)",
"def auth(username, password):\n return username == password",
"def incompatible_validator(**kwargs):\n given = 0\n for name, param in kwargs.items():\n if param is not None:\n given += 1\n params = ','.join(kwargs.keys())\n if given == 0:\n raise PyYouTubeException(ErrorMessage(\n status_code=ErrorCode.MISSING_PARAMS,\n message=f'Specify at least one of {params}'\n ))\n elif given > 1:\n raise PyYouTubeException(ErrorMessage(\n status_code=ErrorCode.INVALID_PARAMS,\n message=f'Incompatible parameters specified for {params}'\n ))",
"def check_params_equality(self, *args, **kwargs):\n raise NotImplementedError(\"Class {} must implement method 'check_params_equality'\".format(type(self)))",
"def validate(self, attrs):\n print(attrs)\n mobile_number = attrs.get('mobile_number')\n otp = attrs.get('otp')\n cache_key = OTP_PREFIX + mobile_number\n cached_otp_value = cache.get(cache_key)\n user = None\n\n if cached_otp_value == otp:\n user = get_user_model().objects.get(mobile_number=mobile_number)\n\n if not user:\n msg = _('Unable to authenticate with provided credential')\n raise serializers.ValidationError(msg, code='authentication')\n\n refresh = TokenObtainPairSerializer.get_token(user)\n data = {\n \t'refresh': str(refresh),\n \t'access': str(refresh.access_token)\n }\n\n return data",
"def _validate_credentials(self):\n\n # There should be a client_id and client secret\n return \"client_id\" in self.credentials.keys() and \"client_secret\" in self.credentials.keys() \\\n and self.credentials[\"client_id\"] and self.credentials[\"client_secret\"]"
] | [
"0.643579",
"0.64004403",
"0.6304516",
"0.62984145",
"0.60860974",
"0.60807675",
"0.60113746",
"0.59970665",
"0.5887357",
"0.5852719",
"0.58483523",
"0.58416337",
"0.5830815",
"0.5830815",
"0.578916",
"0.5777185",
"0.5774363",
"0.5750672",
"0.5682198",
"0.5681004",
"0.5663475",
"0.56386226",
"0.56344247",
"0.5622541",
"0.56145847",
"0.5612866",
"0.5589816",
"0.55856097",
"0.5579503",
"0.55712914",
"0.55702984",
"0.55600274",
"0.55383694",
"0.55318135",
"0.5508925",
"0.55053157",
"0.55051094",
"0.5488174",
"0.54821205",
"0.54703814",
"0.54659486",
"0.54606855",
"0.5455548",
"0.545089",
"0.5437955",
"0.54331183",
"0.54285216",
"0.54174507",
"0.54129946",
"0.54027426",
"0.53960794",
"0.5395449",
"0.5390892",
"0.5390801",
"0.5386482",
"0.53857934",
"0.53815997",
"0.5377784",
"0.53667843",
"0.5364289",
"0.5353859",
"0.5352409",
"0.535117",
"0.53500164",
"0.5342875",
"0.5341982",
"0.53394824",
"0.5336282",
"0.53293127",
"0.532292",
"0.5322731",
"0.5318482",
"0.53152966",
"0.53090274",
"0.53058344",
"0.53036374",
"0.5302793",
"0.52970374",
"0.5296878",
"0.5294005",
"0.52898216",
"0.5285515",
"0.5283022",
"0.5282007",
"0.52714247",
"0.5269478",
"0.52671057",
"0.5252702",
"0.52481127",
"0.5245986",
"0.5243895",
"0.5242713",
"0.5242651",
"0.5231235",
"0.5228383",
"0.52280146",
"0.5222778",
"0.52147335",
"0.5213039",
"0.5206472",
"0.5203488"
] | 0.0 | -1 |
Extract the session token from the secret_key field. | def extract_session_from_secret(secret_key, session_token):
if secret_key and '@@@' in secret_key and not session_token:
return secret_key.split('@@@')[0], secret_key.split('@@@')[1]
else:
return secret_key, session_token | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_token(self):\n token = self._session.token\n return token",
"def _shib_get_token(self): # pragma: no cover\n\n shibCookie = None\n for cookie in self._session.cookies:\n if \"shibsession\" in cookie.name:\n shibCookie = cookie\n break\n\n if not shibCookie:\n warnings.warn(\"No session token found.\", AuthenticationWarning)\n\n return shibCookie",
"def parse_token(token):\n return jwt.decode(token, app.config['JWT_SECRET'])",
"def get_session_secret():\n singleton = Secrets._get_or_make_singleton()\n return singleton.session_secret",
"def get_token(self): # pragma: no cover\n\t\treturn (session.get(\"access_token\"), \"\")",
"def peek_app_token():\n if not os.path.exists(_token_storage_path):\n return None\n\n try:\n with open(_token_storage_path) as secret_file:\n return json.loads(secret_file.read())\n\n except Exception as exc:\n log.error(f'Could not read secret file.\\n{exc}')\n traceback.print_exc(file=sys.stderr)",
"def getSessionFromJWT(token):\n token_payload = token.split('.')[1]\n\n padded_token = token_payload + \"=\" * divmod(len(token_payload), 4)[1]\n session_data = json.loads(base64.urlsafe_b64decode(padded_token))\n\n return session_data",
"def get_session_token(self, server):\n headers = {\"MMSAuth\": self.auth_token, \"MMSAuthSig\": self.auth_sig}\n url = \"https://%s/info/session/token\" % server\n session_token = self.session.get(url, headers=headers).text\n\n return session_token",
"def token(self):\n return self[\"token\"]",
"def get_token(self):\n\n try:\n return jwt.decode(self.fetch_token(), KEY, algorithms=['HS256'])\n except jwt.exceptions.DecodeError:\n raise InvalidToken",
"def get_token(self, session, **kwargs):\n return None",
"def env_var_aws_session_token():\n return 'AWS_SESSION_TOKEN'",
"def _resolve_secret_token(name, key, model_context):\n global _secret_token_map\n\n if _secret_token_map is None:\n _init_secret_token_map(model_context)\n\n secret_token = name + ':' + key\n return dictionary_utils.get_element(_secret_token_map, secret_token)",
"def get_token_from_secret_file(secret_file_path):\n try:\n with open(secret_file_path, \"r\") as f:\n return f.readline()\n except FileNotFoundError:\n raise BaseSpaceDownloadError(\"Secret file not found\")\n except PermissionError:\n raise BaseSpaceDownloadError(\"No permissions to read secret file\")",
"def get_token():\n return session.get('microsoft_token')",
"def get_token():\n return session.get('microsoft_token')",
"def getLastFmSessionKey(self, token):\n \n apiRequest = LastFmApiRequest('auth.getSession', {'token': unicode(token).encode('utf-8')})\n \n logging.debug('sessionKey URL: ' + apiRequest.url())\n \n response = apiRequest.execute()\n root = response.getroot()\n \n sessionKey = root.xpath('//key/text()')[0]\n username = root.xpath('//name/text()')[0]\n \n logging.debug('user:' + username + ' session:' + sessionKey)\n \n # I'm not crazy about the way this couples the mixin and webapp2.RequestHandler\n self.setCookie(self.SESSIONKEY_COOKIE, sessionKey)\n self.setCookie(self.USERNAME_COOKIE, username)",
"def decode_token(token):\n\n return jwt.decode(\n token, settings.JWT_SECRET, algorithms=[settings.JWT_ALGO])",
"def decode_token(token):\n try:\n # Decode token with our secret key\n payload = jwt.decode(token, SECRET_KEY)\n return payload['sub']\n except jwt.ExpiredSignatureError:\n # token has expired\n return \"Timed out. Please login to get a new token\"\n except jwt.InvalidTokenError:\n return \"Invalid token. Please register or login\"",
"def token_key(text):\n content2 = str(text.split())\n beginning = content2.find('access_token\":\"') + int(15)\n end = content2.find('token_type') - int(3)\n access_token = content2[beginning:end]\n return access_token",
"def token_key(text):\n content2 = str(text.split())\n beginning = content2.find('access_token\":\"') + int(15)\n end = content2.find('token_type') - int(3)\n access_token = content2[beginning:end]\n return access_token",
"def token():\n return os.environ.get('TOKEN', None)",
"def decode_token(token):\n try:\n payload = jwt.decode(\n token, app.config.get('SECRET_KEY'), algorithms='HS256')\n return payload['sub']\n except jwt.ExpiredSignatureError:\n return \"Expired token. Please login to get a new token\"\n except jwt.InvalidTokenError:\n return \"Invalid token. Please register or login\"",
"def get_oauth_token():\n return session.get('remote_oauth')",
"def _get_token(self): # pragma: no cover\n\n tokenCookie = None\n for cookie in self._session.cookies:\n if \"mast_token\" in cookie.name:\n tokenCookie = cookie\n break\n\n if not tokenCookie:\n warnings.warn(\"No auth token found.\", AuthenticationWarning)\n\n return tokenCookie",
"def decode_token(token):\n try:\n # try to decode the token using our SECRET variable\n payload = jwt.decode(token, app.config.get('SECRET_KEY'), algorithms=['HS256'])\n return payload['sub']\n except jwt.ExpiredSignatureError:\n # the token is expired, return an error string\n return \"Expired token. Please login to get a new token\"\n except jwt.InvalidTokenError:\n # the token is invalid, return an error string\n return \"Invalid token. Please register or login\"",
"def _get_token(self):\n return user.get_token()",
"def decode(token):\n return jwt.decode(token, app.config[\"JWT_SECRET\"], algorithms=[\"HS256\"])",
"def decode_token(token):\n decoded_token = jwt.decode(token, secret_key, algorithms=['HS256'])\n return decoded_token",
"def get_payload(cls, token):\n \n secret = cls.secret\n algo = cls.algo\n decoded = jwt.decode(token, secret, algo)\n return decoded",
"def decode_auth_token(secret_key, auth_token):\n try:\n payload = jwt.decode(auth_token, secret_key) \n is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)\n if is_blacklisted_token:\n return 'Token blacklisted. Please log in again.' \n else: \n return payload['sub']\n except jwt.ExpiredSignatureError:\n return 'Signature expired. Please log in again.'\n except jwt.InvalidTokenError:\n return 'Invalid token. Please log in again.'",
"def get_session_key(self):\n return self.session_key",
"def decode_token(token):\n try:\n # try to decode the token using our SECRET variable\n payload = jwt.decode(token, os.environ.get('SECRET', 'test'))\n return \"\", payload['sub']\n except jwt.ExpiredSignatureError:\n # the token is expired, return an error string\n return \"Expired token. Please login to get a new token\", None\n except jwt.InvalidTokenError:\n # the token is invalid, return an error string\n return \"Invalid token. Please register or login\", None",
"def get_csrf_secret():\n\tsess = managers.request_manager.get_request().session()\n\tsecret = sess.get(csrf_secret_sess_var_name, None)\n\tif not secret:\n\t\tsecret = gen_csrf_secret()\n\t\tsess[csrf_secret_sess_var_name] = secret\n\treturn secret",
"def _parse_token(self, response=None):\n token_url = 'https://tinychat.com/start?#signin'\n if response is None:\n response = util.web.http_get(url=token_url, referer=token_url, proxy=self._proxy)\n\n if response is not None and response['content'] is not None:\n soup = BeautifulSoup(response['content'], 'html.parser')\n\n token = soup.find(attrs={'name': 'csrf-token'})\n self._token = token['content']",
"def get_secrets(token):\n try:\n return get_keycloak_client().userinfo(token)['attributes'].get('secrets')\n except KeycloakError as ke:\n logger.error(\"Keycloak error: {0}\").format(ke)\n raise exceptions.TransferError\n except KeyError as ke:\n logger.error(\"Secrects not found in token.\")\n raise exceptions.TransferUnauthorized",
"def get_secret_key():\n return get_config_handler().get_secret_key()",
"def get_token(self, res):\n token = res.xpath('//*[@name=\"_csrf-app\"]')[0].attrs['value']\n return token",
"def get_token(self):\n key = self.kwargs.get(self.token_field_name, '').strip()\n if key in EMPTY_VALUES:\n key = self.request.GET.get(self.token_field_name, '').strip()\n if key in EMPTY_VALUES:\n key = self.request.POST.get(self.token_field_name, '').strip()\n if key in EMPTY_VALUES:\n key = None\n return key",
"def token(self) -> str:\n return pulumi.get(self, \"token\")",
"def token(self) -> str:\n return pulumi.get(self, \"token\")",
"def token(self) -> str:\n return pulumi.get(self, \"token\")",
"def secret_key(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"secret_key\")",
"def secret_key(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"secret_key\")",
"def secret_key(self):\n return self._secret_key",
"def decode_auth_token(auth_token):\n try:\n payload = jwt.decode(auth_token, Config.SECRET_KEY,algorithms='HS256')\n return payload\n except jwt.ExpiredSignatureError:\n return 'Signature expired. Please log in again.'\n except jwt.InvalidTokenError:\n return 'Invalid token. Please log in again.'",
"def getToken():\n token = getenv(TOKEN_NAME)\n if token == None:\n raise SystemExit('No token found. Use env variable %s' % TOKEN_NAME)\n return token",
"def get_key():\n try:\n return settings.get('backend')['secret_key']\n except AttributeError:\n raise AuthTokenGenerationException()",
"def sessionkey(cls, session):\n return session[\"credential\"][\"Authorization\"]",
"def secret_key(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"secret_key\")",
"def GetSecretKey():\n _LOG.info('Getting webapp2_secret_key.')\n return (Webapp2SecretKey.get_by_id('current_secret_key')\n .secret_key.encode('ascii', 'ignore'))",
"def get_token():\n params = {'get_token': 'get_token'}\n return load_page(API, params=params, headers={'content-type': 'application/json'})['token']",
"def _generate_token_value():\n return secrets.token_urlsafe()",
"def parse_jwt_guest_token(self, raw_token: str) -> Dict[str, Any]:\n secret = current_app.config[\"GUEST_TOKEN_JWT_SECRET\"]\n algo = current_app.config[\"GUEST_TOKEN_JWT_ALGO\"]\n audience = self._get_guest_token_jwt_audience()\n return self.pyjwt_for_guest_token.decode(\n raw_token, secret, algorithms=[algo], audience=audience\n )",
"def get_token(self):\n return self.__token",
"def get_token(self):\n return self.__token",
"def get_request_token():\n oauth = OAuth1(CLIENT_KEY, client_secret=CLIENT_SECRET)\n response = requests.post(REQUEST_TOKEN_URL, auth=oauth)\n credentials = urlparse.parse_qs(response.content)\n\n request_token = credentials.get(\"oauth_token\")[0]\n request_secret = credentials.get(\"oauth_token_secret\")[0]\n return request_token, request_secret",
"def get_token(self):\n\n return self._token",
"def get_jwt_token_from_secret_file(self, filename):\n # pylint: disable=consider-iterating-dictionary\n if filename in self.jwt_tokens.keys():\n # token for that file was checked already.\n return self.jwt_tokens[filename]\n\n cmd = [\n self.cfg.bin_dir / \"arangodb\",\n \"auth\",\n \"header\",\n \"--auth.jwt-secret\",\n str(filename),\n ]\n print(cmd)\n jwt_proc = psutil.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n logging.info(\"JWT starter has PID:\" + str(jwt_proc.pid))\n\n (header, err) = jwt_proc.communicate()\n jwt_proc.wait()\n if len(str(err)) > 3:\n raise Exception(\"error invoking the starter \" \"to generate the jwt header token! \" + str(err))\n if len(str(header).split(\" \")) != 3:\n raise Exception(\"failed to parse the output\" \" of the header command: \" + str(header))\n\n self.jwt_tokens[filename] = str(header).split(\" \")[2].split(\"\\\\\")[0]\n return self.jwt_tokens[filename]",
"async def get_user_token(\n token: Optional[str] = None,\n x_token: Optional[str] = Header(None),\n authorization: Optional[str] = Header(None),\n sessiontoken: Optional[str] = Cookie(None),\n) -> Optional[str]:\n if token:\n return token\n if x_token:\n return x_token\n if authorization and authorization.startswith(\"Bearer \"):\n return authorization[7:]\n if sessiontoken:\n return sessiontoken\n return None",
"def token(self):\r\n return self._token",
"def token(self):\n return self._token",
"def token(self):\n return self._token",
"def token(self):\n return self._token",
"def _generate_token(self):\n return sha1(\"%s#%s\" % (time(),\n self.app.cfg['sessions/secret'])).hexdigest()",
"def verify_auth_token(token):\n serializer = Serializer(SECRET_KEY)\n try:\n data = serializer.loads(token)\n except SignatureExpired:\n return None # valid token, but expired\n except BadSignature:\n return None # invalid token\n return data['token']",
"def secret_key(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"secret_key\")",
"def _get_token(self) -> str:\n if IS_SUPERVISOR:\n # On supervisor installs the token is provided by a environment variable\n return os.environ[\"HASSIO_TOKEN\"]\n return self._token",
"def __generate_session_token(self):\n\n return get_random_string(length=32)",
"def get_session_key(self, request):\r\n try:\r\n return request.session.session_key\r\n except AttributeError:\r\n return ''",
"def get_current_pub_key(token: str = Depends(token_header)):\n return decode_token(token)",
"def check_token(token: str, secret: str | List[str], max_age_seconds: int = 60 * 60 * 24) -> Any:\n return URLSafeTimedSerializer(secret).loads(token, max_age=max_age_seconds, salt=\"token\")",
"def get_csrf(session):\n login = session.get(KONFUZIO_HOST)\n csrf_token = login.cookies['csrftoken']\n return csrf_token",
"def fetch_token():\n bucket = os.environ[\"SPOTIFY_BUCKET_NAME\"]\n path = os.getenv(\"SPOTIFY_BUCKET_PATH\", \"\")\n logger.info(\"Reading Spotify OAuth token from s3://%s/%s/token.json.\" %\n (bucket, path))\n s3 = boto3.client('s3')\n content_object = s3.get_object(Bucket=bucket, Key=\"%s/token.json\" % path)\n file_content = content_object['Body'].read().decode('utf-8')\n token = json.loads(file_content)\n return token",
"def decode_token(token):\n payload = None\n try:\n payload = jwt.decode(token.encode('utf-8'), '1$Arh\"1bWa/7+OS', algorithm='HS256')['u_id']\n except jwt.InvalidTokenError:\n pass\n return payload",
"def secret_key(self):\n return None",
"def verify_auth_token(cls, token):\n s = Serializer(current_app.config['SECRET_KEY'])\n try:\n data = s.loads(token)\n except:\n return None\n user = User.query.get(data['id'])\n if user and user.session_token == token:\n return user\n return None",
"def _server_cookie_secret() -> str:\n return secrets.token_hex()",
"def _get_creds_from_token(token):\n cred_string = base64.b64decode(token).decode(\"ascii\")\n username, password = str(cred_string).split(\":\")\n return username, password",
"def get_token(self):\n self.session.headers.pop(\"Authorization\", None) # delete old token if was\n\n data = json.dumps({\"password\": self.password, \"username\": self.username})\n answer = self.server_request(self._authTokenPath, data=data)\n\n try:\n self.token = json.loads(answer)[\"token\"]\n self.session.headers.update({\"Authorization\": \"Token \" + self.token})\n except KeyError as err:\n print_unexpected_json_error_key(err, answer, self._authTokenPath)\n exit(1)",
"def __get_authentication_token(self):\n cache = load_json(self._tokenPath)\n return cache[\"authentication_token\"]",
"def get_session(client_id, client_secret):\n client = BackendApplicationClient(client_id=client_id)\n session = OAuth2Session(client=client)\n session.fetch_token(token_url='https://api.intra.42.fr/oauth/token', client_id=client_id,\n client_secret=client_secret)\n return session",
"def token(self):\n if not self._token:\n self._token = self.authenicate().token\n\n return self._token",
"def verify_jwt(token):\n return jwt.decode(token.encode(), SECRET_KEY)",
"def secret_access_key(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"secret_access_key\")",
"def get_secret():\n if not DEFAULT_KEY_FILE.exists():\n raise Exception(\"Authentication key must be stored in a file named \" + DEFAULT_KEY_FILE.name)\n\n retval = DEFAULT_KEY_FILE.read_text().strip()\n if not retval or len(retval) < 10:\n raise Exception(\"Invalid authentication token\")\n return retval",
"def shared_secret(self):\n return self.__shared_secret",
"def get_secret(self, secret_name):\n secret = self._sm.access_secret_version(name=secret_name).payload.data.decode()\n try:\n return json.loads(secret)\n except json.decoder.JSONDecodeError:\n return secret",
"def get_token(self, bot_id):\n res = self.execute(TABELLE['bot']['select']['by_id'], (bot_id,))\n # print(res)\n return res",
"def getToken(request):\n try:\n token = request.META['HTTP_AUTHORIZATION'].split()[1]\n except:\n token = \"\"\n return token",
"def decode(encoded_token):\n return jwt.decode(encoded_token, key=settings.JWT_AUTH['JWT_SECRET_KEY'])",
"def token(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"token\")",
"def parse_token(req):\n auth_string_list = req.headers.get('Authorization').split()\n # Check in correct format i.e. Bearer: 39xds03lda0...\n if len(auth_string_list) == 1:\n raise ValueError('Authorization has invalid format')\n else:\n token = auth_string_list[1]\n data = jwt.decode(token, config.SECRET_KEY, algorithms='HS256')\n return data",
"def get_live_token():\n token_file = open(os.path.dirname(__file__) + TOKEN_FILE_PATH, \"r\")\n keyword = \"GITLAB_API_SECRET\"\n for tokens in token_file:\n token = tokens.split(\"\\n\")\n for token_key in token:\n if keyword in token_key:\n gitlab_token = token_key.split(\"\\\"\")[1]\n token_file.close()\n return gitlab_token",
"def token(self):\n return self._generate_jwt_token()",
"def token(self):\n return self._generate_jwt_token()",
"def token(self):\n return self._generate_jwt_token()",
"def token(self):\n print(\"getter of token called\")\n return self._token",
"async def token(request: Request):\n return get_token()",
"def decode_auth_token(auth_token):\n try:\n payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))\n\n # is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)\n # if is_blacklisted_token:\n # return 'Token blacklisted. Please log in again.'\n # else:\n return payload['sub']\n except jwt.ExpiredSignatureError:\n return 'Signature expired. Please log in again.'\n except jwt.InvalidTokenError:\n return 'Invalid token. Please log in again.'"
] | [
"0.6786535",
"0.6588912",
"0.6564999",
"0.6549351",
"0.65473354",
"0.6426423",
"0.64007133",
"0.6390965",
"0.6321878",
"0.63127387",
"0.6308861",
"0.63074374",
"0.62886924",
"0.62571794",
"0.6218154",
"0.6218154",
"0.61798644",
"0.61466336",
"0.61005646",
"0.6099376",
"0.6099376",
"0.60896754",
"0.60170996",
"0.6011757",
"0.6001665",
"0.5987707",
"0.5979479",
"0.5932924",
"0.5922859",
"0.5914152",
"0.590193",
"0.5890477",
"0.5885433",
"0.58732617",
"0.58715576",
"0.5865724",
"0.5863552",
"0.5861534",
"0.58495903",
"0.58447546",
"0.58447546",
"0.58447546",
"0.5833891",
"0.5833891",
"0.5833786",
"0.5830892",
"0.5829681",
"0.58240426",
"0.5806866",
"0.5802945",
"0.5802764",
"0.5791629",
"0.5778602",
"0.5776226",
"0.576981",
"0.576981",
"0.57671946",
"0.57651794",
"0.5761046",
"0.5749205",
"0.5744818",
"0.5741685",
"0.5741685",
"0.5741685",
"0.5719755",
"0.57170385",
"0.57117426",
"0.5710569",
"0.5695893",
"0.56848645",
"0.56796515",
"0.567787",
"0.56772256",
"0.5673711",
"0.5653964",
"0.56504416",
"0.56483346",
"0.5637925",
"0.56364393",
"0.56338817",
"0.56252515",
"0.5620112",
"0.55900675",
"0.5576974",
"0.55656016",
"0.5563197",
"0.5560515",
"0.55509645",
"0.55434567",
"0.5529723",
"0.5529146",
"0.55280435",
"0.5526452",
"0.55193263",
"0.55188966",
"0.55188966",
"0.55188966",
"0.5518053",
"0.55135643",
"0.55092174"
] | 0.7777419 | 0 |
Parse command line arguments | def parse_args():
parser = argparse.ArgumentParser(
description='Farm')
parser.add_argument(
'-s', '--source',
help='Harvest source (AMQP host such as amqp://guest:guest@localhost:5672)',
required=True)
parser.add_argument(
'-q', '--queue',
help='Queue name to harvest from',
required=True)
parser.add_argument(
'-a', '--add',
help='Harvester instance (file)',
required=True,
type=argparse.FileType('rb'))
return vars(parser.parse_args()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds should be visualized\")\n parser.add_argument(\"--directory\", \"-d\",\n help=\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\")\n args = parser.parse_args()\n return args.visualization, args.directory",
"def parseArguments(self):\n iterator = iter(sys.argv[1:]) # Skip file name\n for argument in iterator:\n if len(argument) < 2 or argument[:2] != '--':\n self.error('syntax error \"{}\"'.format(argument))\n else:\n def getValueOfArgument(): return next(iterator)\n self.parseArgument(argument[2:], getValueOfArgument)",
"def parse_command_line_arguments(argv):\n print(\"reading command line arguments in...\")\n\n parser = argparse.ArgumentParser(description='Description of your program')\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\n args = parser.parse_args()\n\n return args.input, args.predicting, args.scoring, args.scale",
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()",
"def __parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-f', '--force', action=\"store_true\", default=False,\n help='overwrite existing database files during import')\n parser.add_argument('-e', '--extension', action=\"store\", default='txt',\n help='specify file extension. default is \"txt\"')\n parser.add_argument('-d', '--delimiter', action=\"store\", default='\\t',\n help='specify column delimiter. default is tab (\\\\t)')\n parser.add_argument('-m', '--mark', action=\"store\", default='.',\n help='specify decimal mark for numeric data. default is'\n ' dot (.)')\n parser.add_argument('-o', '--outformat', action=\"store\", default='npz',\n help='specify output database format. default is \"npz\"'\n ' for numpy database. use \"mat\" for matlab '\n ' database format.')\n parser.add_argument('-r', '--recursive', action=\"store_true\", default=False,\n help='recursively walk through all sub-directories of'\n ' current working directory')\n parser.add_argument('-p', '--pcs', action=\"store_true\", default=True,\n help='indicate if files are pcs files.')\n parser.add_argument('-c', '--colheadlines', action=\"store\", default='1',\n help='number of lines spanned by the column headers')\n args = parser.parse_args()\n return args",
"def _parse_command_line_arguments():\n parser = ArgumentParser(\n description=(\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\n ),\n )\n parser.add_argument(\n 'ts-file',\n type=str,\n help=(\n 'A file containing the TS sky map'\n ),\n )\n parser.add_argument('--skiprows',\n type=int,\n help='number of rows to skip at the top (default 0)',\n required=False)\n parser.set_defaults(skiprows=0)\n arguments = vars(parser.parse_args())\n return arguments",
"def parse_command_line_arguments():\n\n description, epilog = __doc__.split(\"\\n\\n\", 1)\n\n parser = argparse.ArgumentParser(\n formatter_class=argparse.RawDescriptionHelpFormatter,\n description=description,\n epilog=epilog)\n\n parser.add_argument('-s', '--s', dest='s', action='store', type=float, required=True,\n help='Minimum frequency')\n parser.add_argument('-c', '--credentials', dest='credentials', action='store',\n default=\"./.tpass\",\n help='File with Twitter credentials (username and password, separated by a space)')\n\n args = parser.parse_args()\n \n return args",
"def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\n parser.add_argument('-r', '--resources_dir', type=unicode)\n parser.add_argument('-t', '--total_docs', type=int)\n parser.add_argument('-m', '--mapping', type=unicode,\n help='File with the yago to lkif mapping')\n\n return parser.parse_args()",
"def __parse_args(self):\n for argument in self.args:\n source_arg = re.match(\"^(--source=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n input_arg = re.match(\"^(--input=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n stats_arg = re.match(\"^(--stats=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n help_arg = re.match(\"^--help$\", argument)\n vars_arg = re.match(\"^--vars$\", argument)\n insts_arg = re.match(\"^--insts$\", argument)\n if source_arg:\n self.sourceFile = source_arg.group(2)\n self.passedArgs.append(\"source\")\n elif input_arg:\n self.inputFile = input_arg.group(2)\n self.passedArgs.append(\"input\")\n elif help_arg:\n print(\"napoveda\")\n sys.exit(0)\n elif stats_arg:\n self.statsFile = stats_arg.group(2)\n self.passedArgs.append(\"stats\")\n elif vars_arg:\n self.passedArgs.append(\"vars\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"vars\"\n elif insts_arg:\n self.passedArgs.append(\"insts\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"insts\"\n else:\n raise ArgError(\"Unknown argument or format of the argument! (\" + argument + \")\")",
"def parse_arguments(self):\n \n for arg in sys.argv[1:]:\n (key, sep, value) = arg.partition(\"=\")\n if sep != \"=\":\n raise ProcessorError(\"Illegal argument '%s'\" % arg)\n self.update_data(key, value)",
"def parseArgs():\n parser = argparse.ArgumentParser(description='Runs RHEAS simulation.')\n parser.add_argument('config', help='configuration file')\n parser.add_argument('-d', metavar='DB', help='name of database to connect')\n parser.add_argument('-u', help='update database', action='store_true')\n args = parser.parse_args()\n return args.config, args.d, args.u",
"def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--model\", choices=['vgg', 'unet', 'fpn'], required=True, help=\"Choose model.\")\r\n parser.add_argument(\"--dataset\", choices=['full', 'small'], required=True, help=\"Choose dataset.\")\r\n\r\n return parser.parse_args()",
"def parse_cmd_arguments():\n parser = argparse.ArgumentParser(description='Process some integers.')\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\n parser.add_argument('-o', '--output', required=True,\n help='ouput JSON file')\n parser.add_argument('-d', '--debug', required=False,\n help='log level. Can be 0-3. Defaults to 0')\n\n return parser.parse_args()",
"def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # All reference encoders\n parser.add_argument(\"--step\", dest=\"step\", default=\"10\", type=int, help=\"step size\")\n parser.add_argument(\"--repeats\", dest=\"repeats\", type=int, default=1, help=\"repeats\")\n\n parser.add_argument(dest=\"image\", default=None,\n help=\"select the test image to run\")\n\n args = parser.parse_args()\n return args",
"def parseArgs():\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset', default='fsod', help='training dataset') # use fsod dataset for default\n parser.add_argument('--cfg', dest='cfg_file', required=True, help='optional config file')\n parser.add_argument('--load_ckpt', help='path to load checkpoint')\n parser.add_argument('--load_detectron', help='path to load detectron weight pickle file')\n parser.add_argument('--output_dir', help='output directory to save the testing results.')\n parser.add_argument('--range', help='[start, end)', type=int, nargs=2)\n parser.add_argument('--visualize', dest='visualize', help='output images of detection', action='store_true')\n return parser.parse_args()",
"def parse_cmdline():\n\tparser = ArgumentParser(prog=\"FastP_QC.py\", description=\"\"\"Script collects stats from fastp jsons.\"\"\")\n\tparser.add_argument(\"-r1\", \"--r1_stats\", dest=\"r1_stats\", action=\"store\", required=True, help=\"Text file with r1 stats, from q30.py script.\")\n\tparser.add_argument(\"-r2\", \"--r2_stats\", dest=\"r2_stats\", action=\"store\", required=True, help=\"Text file with r2 stats, from q30.py script.\")\n\tparser.add_argument(\"-n\", \"--name\", dest=\"name\", action=\"store\", required=True, help=\"Sample name\")\n\targs = parser.parse_args()\n\treturn args",
"def parse_args():\n parser = default_argument_parser()\n parser.add_argument(\"--label-map\",\n dest=\"label_map\",\n type=pathlib.Path,\n help=\"Label map in YAML format which maps from category \"\n \"ID to name.\")\n parser.add_argument(\"--train-csv\",\n dest=\"train_csv\",\n required=True,\n type=pathlib.Path,\n help=\"Path to training data CSV file.\")\n parser.add_argument(\"--valid-csv\",\n dest=\"valid_csv\",\n required=False,\n type=pathlib.Path,\n help=\"Optional path to validation data CSV file.\")\n parser.add_argument(\n \"--image-width\",\n type=int,\n help=\"Image width (optional, used to speed up dataset processing).\")\n parser.add_argument(\n \"--image-height\",\n type=int,\n help=\"Image height (optional, used to speed up dataset processing).\")\n return parser.parse_args()",
"def parse_command_line():\n parser = argparse.ArgumentParser()\n\n help_str = \\\n 'The collection folder to sort files into. ' \\\n 'If the folder does not exist, it will be created along with the ' \\\n 'necessary contents.'\n parser.add_argument('-c', '--collection', help=help_str)\n\n help_str = \\\n 'The source folder to import files from. Has to exist and ' \\\n 'has to be a folder.'\n parser.add_argument('-s', '--source', help=help_str, required=False)\n\n help_str = \\\n 'View the gallery in random order auto skpping after the' \\\n 'given amount of seconds'\n parser.add_argument('-v', '--view', help=help_str, required=False)\n\n return parser.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\n metavar='<application_name>')\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\n metavar='<fetch_interval in seconds>')\n return parser.parse_args()",
"def parse_args():\n\tparser = argparse.ArgumentParser(description='Show video statistics.')\n\tparser.add_argument('--sort', metavar='FIELD', choices=['views', 'likes', 'dislikes'],\n\t default='views',\n\t help='sort by the specified field. Options are views, likes and dislikes.')\n\tparser.add_argument('--max', metavar='MAX', type=int, help='show the top MAX entries only.')\n\tparser.add_argument('--csv', action='store_true', default=False,\n\t help='output the data in CSV format.')\n\tparser.add_argument('--table', action='store_true', default=False,\n\t help='output the data in an ascii table.')\n\tparser.add_argument('--workers', type=int, default=8,\n\t help='number of workers to use, 8 by default.')\n\treturn parser.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser(description=\"\"\"A script to get the kmer frequency\n from csv files with kmer counts from genomes.\"\"\")\n\n parser.add_argument('-sd',\n '--sub_dir',\n type=str,\n dest='sub_dir',\n help='Subdirectory name for output files.') # kmer_count\n\n parser.add_argument('-do',\n '--dir_out',\n type=str,\n dest='dir_out',\n help='directory name for output files.') # Results/kmer_freq\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-t\", \"-threads\", help=\"specifies a thread count for parallel operations\", type=int)\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"CUDAPOA Python API sample program.\")\n parser.add_argument('-m',\n help=\"Run MSA generation. By default consensusis generated.\",\n action='store_true')\n parser.add_argument('-p',\n help=\"Print output MSA or consensus for each POA group.\",\n action='store_true')\n parser.add_argument('-l',\n help=\"Use long or short read sample data.\",\n action='store_true')\n return parser.parse_args()",
"def argumentsParser(args):\n\targuments = []\n\tif args.find('\"') > -1:\n\t\tt_arguments = args.split('\"')\n\t\tfor a in t_arguments:\n\t\t\tif a == '' or a == ' ':\n\t\t\t\tpass\n\t\t\telif a[-1] == ' ':\n\t\t\t\targuments.append(a[:-1])\n\t\t\telse:\n\t\t\t\targuments.append(a)\n\telif args.find(\"'\") > -1:\n\t\tt_arguments = args.split(\"'\")\n\t\tfor a in t_arguments:\n\t\t\tif a == '' or a == ' ':\n\t\t\t\tpass\n\t\t\telif a[-1] == ' ':\n\t\t\t\targuments.append(a[:-1])\n\t\t\telse:\n\t\t\t\targuments.append(a)\n\telif args == ' ':\n\t\tpass\n\telse:\n\t\targuments = args.split(' ')\n\treturn arguments",
"def parse_arguments():\n # shift away script name\n scriptname=sys.argv[0]\n shift()\n ncl_cmd=list()\n quali_cmd=list()\n id_cmd=list() \n while(len(sys.argv)>0):\n carg = sys.argv[0]\n shift()\n if(carg == \"--nucleotide\"):\n ncl_cmd = mungeArgs(sys.argv)\n elif(carg == \"--quality\"):\n quali_cmd = mungeArgs(sys.argv)\n elif(carg == \"--id\" ):\n id_cmd = mungeArgs(sys.argv)\n elif(carg in [\"-h\", \"--help\"]):\n usage()\n else:\n usage(error=True)\n # Excess arguments which are not processed \n if(len(sys.argv) > 0):\n sys.stdout.write(\"Excess arguments!\\n\")\n sys.stdout.flush()\n usage(error=True)\n\n # external modules rely on non-empty argv array, \n # re-append the script name as first command line argument\n sys.argv.append(scriptname)\n return (id_cmd, ncl_cmd, quali_cmd)",
"def parse_arguments():\n parser = ArgumentParser()\n\n # For development/testing\n parser.add_argument(\"--dev\", help=\"run the code of the developers tag\")\n\n return parser.parse_args()",
"def parse_args(args=None):\n return AP.parse_args(args=args)",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--version',\n metavar=\"<str>\",\n help=\"Input data version number\",\n type=str,\n required=True\n )\n args = parser.parse_args()\n return args",
"def process_command_line_arguments() -> Namespace:\n\n parser = build_parser()\n arguments = parser.parse_args()\n\n return arguments",
"def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--obs_len\",\n default=20,\n type=int,\n help=\"Directory where the sequences (csv files) are saved\",\n )\n parser.add_argument(\n \"--data_dir\",\n default=\"\",\n type=str,\n help=\"Directory where the sequences (csv files) are saved\",\n )\n parser.add_argument(\n \"--feature_dir\",\n default=\"\",\n type=str,\n help=\"Directory where the computed features are saved\",\n )\n parser.add_argument(\"--mode\",\n required=True,\n type=str,\n help=\"train/val/test/compute_all/lanes_only\")\n parser.add_argument(\n \"--sequence_num\",\n default=-1,\n type=int,\n help=\"Specify a specific sequence to visualize.\",\n )\n parser.add_argument(\n \"--batch_start\",\n default=0,\n type=int,\n help=\"Specify the starting row of features to visualize.\",\n )\n parser.add_argument(\n \"--batch_end\",\n default=-1,\n type=int,\n help=\"Specify the last row to visualize, -1 to visualize till end.\",\n )\n parser.add_argument(\n \"--single_figure\",\n default=False,\n action=\"store_true\",\n help=\"Plot all candidates for a scenein one figure.\",\n )\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('n_iter',\n help='number of iteration',\n type=int)\n parser.add_argument('n_processes',\n help='number of processes',\n type=int)\n parser.add_argument('method',\n help='mutual exclusion method')\n parser.add_argument('duration',\n help='Duration of each process',\n type=float)\n return parser.parse_args()",
"def parse_arguments(args=sys.argv[1:]):\n \n parser = argparse.ArgumentParser()\n \n parser.add_argument('-i', '--input',\n help=\"Path of input file to read. Default: {d}\".format(d=INPUT_FILE),\n default=INPUT_FILE)\n \n return parser.parse_args(args)",
"def parse_arguments():\n\n parser = argparse.ArgumentParser(\n description=\"生成用户字符串识别的切分字符串\"\n )\n parser.add_argument(\n \"-o\",\n \"--output_dir\",\n type=str,\n nargs=\"?\",\n help=\"The output directory\",\n default=\"output/\"\n )\n parser.add_argument(\n \"-i\",\n \"--input_file\",\n type=str,\n nargs=\"?\",\n help=\"When set, this argument uses a specified text file as source for the text\",\n default=\"\",\n required=True\n )\n parser.add_argument(\n \"-mi\",\n \"--min_char_count\",\n type=int,\n nargs=\"?\",\n help=\"The minimum number of characters per line, Default is 3.\",\n default=3,\n\n )\n parser.add_argument(\n \"-ma\",\n \"--max_char_count\",\n type=int,\n nargs=\"?\",\n help=\"The maximum number of characters per line, Default is 20.\",\n default=20,\n )\n return parser.parse_args()",
"def parse_command_line_arguments():\n parser = argparse.ArgumentParser()\n\n # Positional args\n parser.add_argument('data_directory', action=\"store\")\n\n # Optional args\n parser.add_argument('--save_dir', action='store',\n dest='save_dir',\n help='Load categories names from given file',\n default=\"checkpoint.pth\")\n\n parser.add_argument('--gpu', action='store_true',\n dest='device',\n help='Device of prediction processing',\n default=False)\n\n parser.add_argument('--arch', action='store',\n dest='arch',\n help='Name of pre-trained network used for training',\n default=\"vgg11\")\n\n parser.add_argument('--learning_rate', action='store',\n dest='learning_rate',\n help='value of training learning rate',\n default=0.001)\n\n parser.add_argument('--hidden_units', action='store',\n dest='hidden_units',\n help='Number of units in the fully-connected hidden '\n 'layer of the neural netwrork',\n default=512)\n\n parser.add_argument('--epochs', action='store',\n dest='epochs',\n help='Number of training epochs',\n default=5)\n\n # Parse all args\n results = parser.parse_args()\n\n return results",
"def parseArguments():\n # Create argument parser\n parser = argparse.ArgumentParser()\n\n # Optional arguments\n parser.add_argument(\"-t\", \"--test\", help=\"Optionally test algorithm on subsample of the data. Set to 1 for testing\", type=int, default=0)\n\n parser.add_argument(\"--cores\", help=\"Optimized code for a server with a lot of RAM, set to the number of available cores\", type=int, default=40)\n\n\n # Print version\n parser.add_argument(\"--version\", action=\"version\", version='%(prog)s - Version 2.0') #version 1.0 is for the observations in June 2018\n #version 1.1 contains the optimizations made after the june observations (mainly the switch to stackmags)\n #version 1.2 changed sim class to NOT include the list of failed candidates (not qsos)\n #... copied changes made to crossval version\n #version 1.5 added check for duplicate quasars and remove them\n #version 1.6 new simulated quasars (december)\n ##-------------------\n #version 2.0: combined training of classifier and regressor, streamlined input\n #version 2.1: Tryied to updates excluded area to a little more than stripe 82 but decided not to keep it, so no change\n\n # Parse arguments\n args = parser.parse_args()\n\n return args",
"def arg_parse():\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\n \"-f\",\n \"--fpath\",\n type=str,\n required=True,\n help=\"Path to files to generate test data from e.g. /badc/cmip5/data/cmip5/output1/MOHC/HadGEM2-ES/rcp85/mon/atmos/Amon/r1i1p1/latest/tas\",\n )\n\n parser.add_argument(\n \"-t\",\n \"--time_only\",\n default=False,\n help=\"Only generate one time step of this dataset\",\n action=\"store_true\",\n )\n\n parser.add_argument(\n \"-s\",\n \"--step\",\n type=int,\n default=100,\n help=\"Step to select latitude/longitude by. Only relevant when time_only is False\",\n )\n\n parser.add_argument(\n \"-n\",\n \"--number\",\n type=int,\n default=0,\n help=\"Number of files to generate. Default is all files. Only relevant when time_only is False\",\n )\n\n parser.add_argument(\n \"-l\",\n \"--level\",\n type=int,\n default=-1,\n help=\"Number of levels to extract, starting with index 0.\",\n )\n\n parser.add_argument(\n \"-c\", \"--compress\", help=\"Compress the files.\", action=\"store_true\"\n )\n\n return parser.parse_args()",
"def parse_args():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input_path\", required=True)\n parser.add_argument(\"-c\", \"--config\", required=True)\n return parser.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-e\", \"--events\", type=str,\n help=\"path to events CSV-file\")\n parser.add_argument(\"-d\", \"--data\", type=str,\n help=\"path to data CSV-file\")\n parser.add_argument(\"-l\", \"--limit\", nargs='?', type=int, default=None,\n help=\"max records to be processed\")\n parser.add_argument(\"-t\", \"--timezone\", nargs='?', type=int, default=5,\n help=\"date and time shift\")\n parser.add_argument(\"-o\", \"--optimized\", action='store_true',\n help=\"if specified, then data CSV will be processed\"\n \" by small chunks to escape memory issues\")\n parser.add_argument(\"-v\", \"--verbose\", action='store_true')\n parser.add_argument(\"--output-folder\", nargs='?', type=str,\n default=\"linked\")\n return vars(parser.parse_args())",
"def Args(parser):",
"def parse_args():\n parser = ArgumentParser()\n parser.add_argument('-t', '--timer', action='store_true', \\\n help='Time the first random generation')\n parser.add_argument('-i', '--ibmq', default='', help='IBMQ token')\n parser.add_argument('-b', '--backend', default='', help='IBMQ backend')\n return parser.parse_args()",
"def parse_arguments():\n p = argparse.ArgumentParser(description='Prepare the dataset for use by neural models.')\n p.add_argument(\"json_file\", type=argparse.FileType('r'), help=\"json file with all the data\")\n p.add_argument(\"prefix\", type=str, help=\"prefix for all the generated files\")\n p.add_argument(\"data_type\", type=str, choices=[\"names\", \"comments\", \"nc\"],\n default=\"nc\", help=\"type of the information recorded in the dataset\")\n p.add_argument(\"labels\", type=str, choices=[\"PROG\", \"ALL\", \"TOP\"],\n default=\"PROG\", help=\"method by which to choose the labels for the dataset\")\n p.add_argument(\"-other_label\", type=str, required=False, default=\"\",\n help=\"label to use instead of all infrequent labels. \"\n \"This can be left blank to ignore infrequent labels altogether\")\n p.add_argument(\"-label_num\", type=int, default=100, required=False,\n help=\"Number of most frequent labels to keep. Works with label_choice=TOP\")\n p.add_argument(\"-min_prog_labels\", type=int, default=5, required=False,\n help=\"Minimal number of programs a label has to appear in for it to be included \"\n \"in the dataset. Works with label_choice=PROG\")\n p.add_argument(\"-test_prog_list\", type=argparse.FileType('r'), default=None, required=False,\n help=\"file with the list of programs in the test set (optional)\")\n\n return p.parse_args(sys.argv[1:])",
"def parse_args():\n\n parser = argparse.ArgumentParser(description='Disk metric sender')\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\n\n return parser.parse_args()",
"def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument('session', help='Session Label')\n ap.add_argument('-sd', '--subjects_dir', help='Subjects Dir',\n default='/tmp')\n return ap.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser(description=\"Parse library type information.\")\n parser.add_argument(\"input_file\", help=\"Salmon library type information file.\")\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(description='Google reminders cli',\n epilog=usage,\n formatter_class=argparse.RawTextHelpFormatter)\n return parser.parse_args()",
"def _parse_args(argv):\n parser = make_parser()\n args = parser.parse_args(argv)\n LOGGER.setLevel(to_log_level(args.loglevel))\n\n if not args.inputs:\n if args.list:\n tlist = \", \".join(API.list_types())\n _exit_with_output(\"Supported config types: \" + tlist)\n elif args.env:\n cnf = os.environ.copy()\n _output_result(cnf, args.output, args.otype or \"json\", None, None)\n sys.exit(0)\n else:\n parser.print_usage()\n sys.exit(1)\n\n if args.validate and args.schema is None:\n _exit_with_output(\"--validate option requires --scheme option\", 1)\n\n return args",
"def parse_arguments():\n parser = argparse.ArgumentParser(\n description=\"script for downloading and merging log files from S3 for particular time period\")\n parser.add_argument(\"-s\", \n \"--startdate\", \n help=\"start date in format YYYYMMDD\", \n required=True, \n type=valid_date)\n parser.add_argument(\"-e\", \"--enddate\", \n help=\"end date in format YYYYMMDD\", \n required=True, \n type=valid_date)\n parser.add_argument(\"-f\", \n \"--file\", \n help=\"destination file\", \n required=True)\n parser.add_argument( \"-c\", \"--config\",\n default=\"/Users/samarius/.get_analytics_log.config.json\",\n help=\"configuration file path\")\n\n\n try:\n args = parser.parse_args()\n return args\n except Exception as e:\n print \"can't parse command line args: {}\".format(repr(e))\n raise",
"def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-f\", \"--file\", help=\"file with the cohort you want to check / fix\", type=str, required=True)\n parser.add_argument(\"-o\", \"--outdir\", help=\"where should the files and the result readme be stored?\", type=str, required=True)\n return parser.parse_args()",
"def arg_parse():\n p = ap.ArgumentParser()\n p.add_argument('infile',\n help='path to file containing objects')\n p.add_argument('n1',\n help='night 1')\n p.add_argument('n2',\n help='night 2')\n p.add_argument('observatory',\n help='Astropy name of observatory')\n return p.parse_args()",
"def parse_args():\n parser = OptionParser()\n parser.add_option('--data-file', '-f', default='train_data.hdf5',\n help=\"The path to the data file\")\n parser.add_option('--runs-per-epoch', '-r', type='int',\n help=\"The number of runs per epoch (train samples count)\")\n parser.add_option('--avg-window-size', '-w', default='1', type='int',\n help=\"The window size for moving average\")\n\n (options, args) = parser.parse_args()\n return options",
"def parse_arguments():\n #usage = \"usage: %(prog)s [options] <message file>\" + DESCRIPTION\n parser = ArgumentParser()\n parser.add_argument('-v', '--version', action='version', version=VERSION)\n parser.add_argument('source', metavar='source', help='input logfile or directory with logfiles')\n\n \"\"\"\n parser.add_argument('-m', '--mat-id', metavar='string', # or stare_false\n dest=\"id_mat\", default='', # negative store value\n help=\"material id to grep\")\n parser.add_argument('-c', '--count', metavar='N', type=int, # or stare_false\n dest=\"count\", default=0, # negative store value\n help=\"count\")\n parser.add_argument('-p', '--pattern', metavar='string', # or stare_false\n dest=\"pattern\", default='xxx', # negative store value\n help=\"search pattern within logfile\")\n \"\"\"\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Subscription Watch CSV file packaging script\", prog=sys.argv[0])\n\n # required args\n parser.add_argument(\"-f\", \"--filepath\", required=True,\n help=\"path to files to package\")\n parser.add_argument(\n \"-s\",\n \"--max-size\",\n type=int,\n default=DEFAULT_MAX_SIZE,\n help=f\"Maximum size of packages in MiB. (Default: {DEFAULT_MAX_SIZE} MiB)\",\n )\n parser.add_argument(\n \"-o\", \"--overwrite\", action=\"store_true\", default=False, help=\"whether to overwrite existing files.\"\n )\n parser.add_argument(\"--ocp-cluster-id\", required=True,\n help=\"OCP Cluster ID\")\n parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n default=0, help=\"increase verbosity (up to -vvv)\")\n return parser.parse_args()",
"def parseArguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('--output_folder',\n help='Path of the folder where output files should be written.')\n parser.add_argument('--partition_id',\n help='ID of the computer partition to collect data from.')\n parser.add_argument('--collector_db',\n help='The path of slapos collect database.')\n\n return parser.parse_args()",
"def parse_command_line() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'pet_database',\n type=str,\n help='path to pet database'\n )\n parser.add_argument(\n '--image_dir',\n default='data/images'\n )\n parser.add_argument(\n '--log',\n default=None,\n help='log file path'\n )\n\n args = parser.parse_args()\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\n return args",
"def parse_args():\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\n parser.add_argument('--prepare', action='store_true',\n help='create the directories, prepare the vocabulary and embeddings')\n parser.add_argument('--train', action='store_true',\n help='train the model')\n parser.add_argument('--generate', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gentest', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gpu', type=str, default='0',\n help='specify gpu device')\n\n train_settings = parser.add_argument_group('train settings')\n train_settings.add_argument('--optim', default='Adam',\n help='optimizer type')\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\n help='learning rate')\n train_settings.add_argument('--weight_decay', type=float, default=0,\n help='weight decay')\n train_settings.add_argument('--dropout', type=float, default=0,\n help='dropout keep rate')\n train_settings.add_argument('--batch_size', type=int, default=128,\n help='train batch size')\n train_settings.add_argument('--epochs', type=int, default=10,\n help='train epochs')\n\n model_settings = parser.add_argument_group('model settings')\n model_settings.add_argument('--embed_size', type=int, default=128,\n help='size of the embeddings')\n model_settings.add_argument('--hidden_size', type=int, default=256,\n help='size of LSTM hidden units')\n model_settings.add_argument('--max_seq_len', type=int, default=50,\n help='max passage num in one sample')\n model_settings.add_argument('--max_gen_len', type=int, default=50,\n help='max length of passage')\n\n path_settings = parser.add_argument_group('path settings')\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\n help='the dir to save vocabulary')\n path_settings.add_argument('--model_dir', default='../data/models/',\n help='the dir to store models')\n path_settings.add_argument('--result_dir', default='../data/results/',\n help='the dir to output the results')\n path_settings.add_argument('--summary_dir', default='../data/summary/',\n help='the dir to write tensorboard summary')\n path_settings.add_argument('--log_path',\n help='path of the log file. If not set, logs are printed to console')\n return parser.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser(description=\"Parse Diff Exp output files\")\n parser.add_argument(\"raw_file\", help=\"DE analysis output file (.tab).\")\n parser.add_argument(\"output_json\", help=\"Output JSON\")\n parser.add_argument(\"output_file\", help=\"Output file\")\n parser.add_argument(\"--gene_id\", help=\"Gene_IDs column name\", type=str)\n parser.add_argument(\"--fdr\", help=\"FDR column name\", type=str)\n parser.add_argument(\"--pvalue\", help=\"Pvalue column name\", type=str)\n parser.add_argument(\"--fwer\", help=\"FWER column name\", type=str)\n parser.add_argument(\"--logodds\", help=\"Log Odds column name\", type=str)\n parser.add_argument(\"--logfc\", help=\"logfc column name\", type=str)\n parser.add_argument(\"--stat\", help=\"Statistics column name\", type=str)\n return parser.parse_args()",
"def parse_args():\n\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\n return parser.parse_args()",
"def parse_args():\n parser = common_parser()\n parser.description = (\n \"Given a sequence dict, fasta index or a bed file, scatter over the \"\n \"defined contigs/regions. Each contig/region will be split into \"\n \"multiple overlapping regions, which will be written to a new bed \"\n \"file. Each contig will be placed in a new file, unless the length of \"\n \"the contigs/regions doesn't exceed a given number.\")\n\n parser.add_argument(\"-c\", \"--chunk-size\", type=int, default=1e6,\n metavar=\"SIZE\",\n help=\"The size of the chunks. The first chunk in a \"\n \"region or contig will be exactly length SIZE, \"\n \"subsequent chunks will SIZE + OVERLAP and the final \"\n \"chunk may be anywhere from 0.5 to 1.5 times SIZE \"\n \"plus overlap. If a region (or contig) is smaller \"\n \"than SIZE the original regions will be returned. \"\n \"Defaults to 1e6\")\n parser.add_argument(\"-m\", \"--minimum-bp-per-file\", type=int, default=45e6,\n help=\"The minimum number of bases represented within \"\n \"a single output bed file. If an input contig or \"\n \"region is smaller than this MINIMUM_BP_PER_FILE, \"\n \"then the next contigs/regions will be placed in the \"\n \"same file untill this minimum is met. Defaults to \"\n \"45e6.\")\n parser.add_argument(\"-o\", \"--overlap\", type=int, default=150,\n help=\"The number of bases which each chunk should \"\n \"overlap with the preceding one. Defaults to 150.\")\n parser.add_argument(\"-S\", \"--split-contigs\", action=\"store_true\",\n help=\"If set, contigs are allowed to be split up over \"\n \"multiple files.\")\n args = parser.parse_args()\n return args",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-d\",\n \"--debug\",\n help=\"Print lots of debugging statements\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.DEBUG,\n default=logging.ERROR,\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n help=\"Be verbose\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.INFO,\n )\n parser.add_argument(\"runscript\", default=None)\n return parser.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input\", dest=\"input_file\", help=\"input file or pattern\", default=\"\")\n parser.add_argument(\"-o\", \"--output\", dest=\"output_file\", help=\"output file or pattern\", default=\"\")\n parser.add_argument(\"-d\", \"--debug\", dest=\"debug\", action='store_true')\n parser.add_argument(\"-v\", \"--verbose\", dest=\"verbose\", action='store_true')\n parser.set_defaults(verbose=False)\n parser.set_defaults(debug=False)\n return parser.parse_args()",
"def parse_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'config',\n help='Config file')\n parser.add_argument(\n '--quiet',\n '-q',\n action='store_true',\n help='do not print to console'\n )\n parser.add_argument(\n '--password',\n '-p',\n action='store_true',\n help='Set password in keyring.'\n )\n parser.add_argument(\n '--update',\n '-u',\n action='store_true',\n help='Only add transactions after last date in database.'\n )\n parser.add_argument(\n '--mark_seen',\n '-m',\n action='store_true',\n help='Mark fetched emails as seen.'\n )\n\n return parser.parse_args()",
"def _parse_args():\n args = sys.argv[1:]\n cmd_parser = argparse.ArgumentParser()\n cmd_parser.add_argument(\n '--produce-sub',\n dest='produce_sub',\n help='Produce submision file',\n default=False,\n action='store_true',\n )\n cmd_parser.add_argument(\n '--search-cv',\n dest='search_cv',\n help='Perform Search of parameters',\n default=False,\n action='store_true',\n )\n cmd_opts = cmd_parser.parse_args(args=args)\n return cmd_opts",
"def parseInputArgs():\n parser = argparse.ArgumentParser(description=\"Unix cut analog\", usage='%(prog)s [arguments]')\n\n # pos arg\n parser.add_argument('filename', type=str, help='input file name')\n\n # req arg\n requiredNamed = parser.add_argument_group('required arguments')\n requiredNamed.add_argument('-f', '--fields', type=str, help='list of fields, separated by comma', required=True)\n # optional args\n parser.add_argument('-s', '--separator', type=str, default='\\t', help='column separator, default tab')\n\n args = parser.parse_args()\n return args",
"def parse_arguments():\n parser = argparse.ArgumentParser(description=\"Note: Plot depth files.\")\n parser.add_argument(\"-d\", \"--depth_dir\", help='depth file directory')\n parser.add_argument(\"-r\", \"--result_dir\", help='output directory')\n parser.add_argument(\"-f\", \"--ref\", help='one depth file as ref')\n parser.add_argument(\"-w\", \"--window_size\", help='sliding window size')\n\n args = parser.parse_args()\n return args",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--zarr_dir',\n type=str,\n help='path to directory of zarr files',\n )\n parser.add_argument(\n '--tiff_dir',\n type=str,\n help='path to directory of tiff files',\n )\n parser.add_argument(\n '--output_dir',\n type=str,\n help='path to directory for writing',\n )\n parser.add_argument(\n '--config_path',\n type=str,\n default=None,\n help='path to yaml preprocess config file',\n )\n \n args = parser.parse_args()\n return args",
"def parseArgs(arguments=None):\n\tparser = generateParser(None)\n\treturn parser.parse_known_args(arguments)",
"def parse_args():\n parser = ArgumentParser(\n description=__doc__, formatter_class=ArgumentDefaultsHelpFormatter\n )\n parser.add_argument(\n '-i', '--infile', type=is_valid_file, action=FullPaths,\n metavar='FILE', required=True, help='''Settings file'''\n )\n parser.add_argument(\n '-d', '--ddc_file', type=is_valid_file, action=FullPaths,\n metavar='FILE', default='ddc2_nios2_sw.elf',\n help='''DDC2 download file'''\n )\n parser.add_argument(\n '-t', '--time', type=int, metavar='INT', default=5,\n help='''Number of seconds to run DDC2'''\n )\n parser.add_argument(\n '-o', '--outfile', type=str, default='./data/test/test',\n metavar='FILE', required=False,\n help='''Output location of data (no need to include file extension)'''\n )\n parser.add_argument(\n '--live', action='store_true', default=False,\n help='''Live visualisation'''\n )\n parser.add_argument(\n '-v', '--verbose', action='store_true', default=False,\n help='''Verbose'''\n )\n args = parser.parse_args()\n return args",
"def parse_cmdline(argv):\n if argv is None:\n argv = sys.argv[1:]\n\n # initialize the parser object:\n parser = argparse.ArgumentParser(description='Calculates A and Ea from Gaussian output files using GoodVibes. '\n 'List files to be analyzed, reactant(s) first and ending with the '\n 'transition structure. These can be listed on the command line or in '\n 'a file (each line listing a set of reactant(s) and transition '\n 'structure).')\n parser.add_argument(\"-d\", \"--out_dir\", help=\"A directory where output files should be saved. The default location \"\n \"is the current working directory.\", default=None)\n parser.add_argument(\"-f\", dest=\"freq_cutoff\", help=\"Cut-off frequency for both entropy and enthalpy (wavenumbers) \"\n \"(default = 0)\", default=\"0\")\n parser.add_argument(\"-l\", \"--list\", help=\"The location of the list of Gaussian output files. \"\n \"The default file name.\", default=None)\n parser.add_argument(\"-q\", \"--quasiharmonic\", help=\"Use the '-q' option in GoodVibes, which turns on turns on \"\n \"quasi-harmonic corrections to both entropy and enthalpy in the \"\n \"Gibbs free energy (qh-G(T)) output from GoodVibes. \",\n action='store_true')\n parser.add_argument(\"--temp\", help=\"Temperature in K for calculating \\u0394G. The default is the first \"\n \"temperature in 'temp_range' (if specified). If a value is given, the program \"\n \"will use the temperature closest to it in the temp_range.\", default=None)\n parser.add_argument(\"-ti\", \"--temp_range\", help=\"Initial temp, final temp, (and optionally) step size (K) for \"\n \"thermochemistry calculations. The default range is 300,600,30\",\n default=\"300,600,30\")\n parser.add_argument(\"-v\", \"--vib_scale\", help=\"Scaling factor to be used for vibrational frequencies. If not \"\n \"provided, the GoodVibes default value will be used.\",\n default=None)\n parser.add_argument(\"-p\", \"--plot\", help=\"Make a \\u0394G plot at the specified temp. The default is False.\",\n action='store_true')\n parser.add_argument(\"-pl\", \"--plot_labels\", help=\"Optional labels for \\u0394G plot. Enter as a list.\",\n default=None)\n parser.add_argument(\"-c\", \"--vibes_check\", help=\"In addition to standard checks always run (matching solvent, \"\n \"level of theory, stoichiometry, charge, multiplicity, and \"\n \"Gaussian versions), run files through GoodVibes '--check' before \"\n \"performing calculations. The default is False.\",\n action='store_true')\n parser.add_argument(\"-o\", \"--output_fname\", help=\"The name of the output file to be created. The default is the \"\n \"list name with the extension '.csv', or '{}' if no list name \"\n \"provided.\".format(DEF_OUT_FILE_NAME), default=None)\n\n parser.add_argument(\"-s\", \"--save_vibes\", help=\"Save the output from running GoodVibes in separate files, \"\n \"named with the Gaussian log file prefix and '.dat'. \"\n \"The default is False.\",\n action='store_true')\n parser.add_argument(\"-t\", \"--tog_vibes\", help=\"Save the output from running GoodVibes in one file, \"\n \"renamed with the output file prefix and '.dat'. \"\n \"The default is False.\",\n action='store_true')\n\n args = None\n try:\n args = parser.parse_known_args(argv)\n options = args[0]\n if not options.out_dir:\n options.out_dir = os.getcwd()\n # user can define a new directory as the output directory\n if not os.path.exists(options.out_dir):\n os.makedirs(options.out_dir)\n\n if options.output_fname:\n options.output_fname = os.path.abspath(os.path.join(options.out_dir, options.output_fname))\n elif options.list:\n options.output_fname = create_out_fname(options.list, ext='.csv', base_dir=options.out_dir)\n else:\n options.output_fname = create_out_fname(DEF_OUT_FILE_NAME, ext='.csv', base_dir=options.out_dir)\n\n if options.plot_labels:\n options.plot_labels = options.plot_labels.split(',')\n else:\n options.plot_labels = ['']\n\n if options.vib_scale:\n options.vib_scale = float(options.vib_scale)\n\n except (SystemExit, ValueError) as e:\n if hasattr(e, 'code') and e.code == 0:\n return args, GOOD_RET\n warning(e)\n parser.print_help()\n return args, INPUT_ERROR\n\n return args, GOOD_RET",
"def parse_args():\n parser = argparse.ArgumentParser(description='Extract left-turn speed data CSV files from Excel')\n parser.add_argument('veh_conflict_data', type=str, help='Excel file with all veh conflicts data')\n return parser.parse_args()",
"def readArgs():\n parser = argparse.ArgumentParser(description=\n \"\"\"Debug script. This program is used in order to generate a summary\n statistics for the csv files generated by the annotation_parser. Things\n like the average amount of overlap of each window and the average deviation.\n \"\"\")\n\n parser.add_argument('-f', '--csv-dir', metavar='',\n dest='csv_dir',\n action='store', default=os.path.dirname(os.path.abspath(__file__)),\n help='Specify the csv directory.')\n parser.add_argument('-d', '--deviation', metavar='',\n dest='deviation', action='store',\n default=50,\n help='percentage set point from which evaluate the deviation from.')\n\n return parser.parse_args()",
"def parse_args(args):\n parser = argparse.ArgumentParser(\n description=\"Lookup table generator for Image Comparison\")\n parser.add_argument(\n \"--version\",\n action=\"version\",\n version=\"lookuptable {ver}\".format(ver=__version__))\n parser.add_argument(\n \"-f\",\n \"--folder\",\n dest=\"imagefolder\",\n help=\"path to image folder\",\n type=str,\n metavar=\"STRING\")\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to INFO\",\n action=\"store_const\",\n const=logging.INFO)\n parser.add_argument(\n \"-vv\",\n \"--very-verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to DEBUG\",\n action=\"store_const\",\n const=logging.DEBUG)\n return parser.parse_args(args)",
"def parse_command_line():\n parser = argparse.ArgumentParser(description='Parses ID\\'s from the DDI compendium search results, and then downloads the html and puts them into a sqlite database.')\n parser.add_argument('-f', '--file', dest='file',\n action='store',\n help='Filenname to be read')\n arg_manager = parser.parse_args()\n return arg_manager",
"def parse_args():\n parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)\n parser.add_argument(\"plumes\", help=\"path to input plume file\")\n parser.add_argument(\"output\", help=\"path to output plume file\")\n parser.add_argument(\"-r\", \"--radius\", required=True,\n help=\"radius (meters) for nearest neighbor clustering\")\n parser.add_argument(\"-v\", \"--visualize\", action='store_true',\n help=\"Show plot of points/clusters (default=no plot)\")\n args = parser.parse_args()\n return args.plumes, args.output, float(args.radius), args.visualize",
"def parse_args():\n help_text = \"\"\"\n Analyzer of the frequency of use of nouns in the headings of posts on hubr.com\n \"\"\"\n parser = argparse.ArgumentParser(\n description=help_text\n )\n parser.add_argument(\n '-p',\n '--pages',\n type=int,\n dest='page_count',\n default=PAGE_COUNT,\n help=f'Number of pages to parse, default is {PAGE_COUNT}.'\n )\n parser.add_argument(\n '-s',\n '--start',\n type=int,\n default=PAGE_START,\n dest='start_page',\n help=f'Start page number, default is {PAGE_START}.',\n )\n parser.add_argument(\n '-t',\n '--top',\n type=int,\n default=TOP_SIZE,\n dest='top_size',\n help=f'The size of the top noun, default is {TOP_SIZE}.',\n )\n\n return parser.parse_args()",
"def _parse_args():\n parser = argparse.ArgumentParser(description=\"\")\n #parser.add_argument(\"args\", metavar=\"N\", type=str, nargs=\"*\", help=\"Positional arguments.\")\n #parser.add_argument(\"\", dest=\"\", type=\"\", default=, help=)\n #parser.add_argument(\"--version\", action=\"version\", version=\"<the version>\")\n\n return parser.parse_args()",
"def parse_command_line():\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"img\", type=argparse.FileType(\"r\"),\n help=\"The image file to test\")\n\n encoders = [\"sse2\", \"sse4.1\", \"avx2\"]\n parser.add_argument(\"--encoder\", dest=\"encoder\", default=\"avx2\",\n choices=encoders, help=\"select encoder variant\")\n\n testquant = [str(x) for x in range (0, 101, 10)]\n testqual = [\"-fastest\", \"-fast\", \"-medium\", \"-thorough\", \"-exhaustive\"]\n qualities = testqual + testquant\n parser.add_argument(\"--test-quality\", dest=\"quality\", default=\"medium\",\n choices=qualities, help=\"select compression quality\")\n\n parser.add_argument(\"--no-startup\", dest=\"noStartup\", default=False,\n action=\"store_true\", help=\"Exclude init\")\n\n args = parser.parse_args()\n\n return args",
"def parse_args():\n\n\t#diff_help = 'Use flag to calculate differences.'\n\t#ratio_help = 'Use flag to calculate ratios.'\n\t#cte_help = 'Use flag to subtract flt from flc for same rootname'\n\tncores_help = 'Number of cores to use for multiprocessing. Default value is 8.'\n\tfirst_help = 'Path to first image(s) to be compared.'\n\tfile_help = 'file type to be compared.'\n\n\tncores = 1\n\n\tparser = argparse.ArgumentParser()\n\t#parser.add_argument('-n', type=int, help=ncores_help, action='store',\n\t#\trequired=False, default=ncores)\n\tparser.add_argument('fp', type=str, metavar='first_path', help=first_help, action='store')\n\tparser.add_argument('ft', type=str, metavar='file_type', help=file_help, action='store')\n\targs=parser.parse_args()\n\n\treturn args",
"def parse_arguments():\n parser = argparse.ArgumentParser(description='Scraper')\n parser.add_argument('--prefix', help='Prefix for saving files', default=\"\")\n parser.add_argument('--path', help='Dir path', default=\"\")\n parser.add_argument('--urls_path', help='Url path', default=False)\n parser.add_argument('--url', help='Url', default=False)\n parser.add_argument('--disney', dest='disney', action='store_true', help=\"Choose all disney movies\")\n parser.add_argument('--ngram', help='Max ngram', default=2)\n\n args = parser.parse_args()\n return args",
"def parse_arguments():\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"--accessions\", help=\"A json file with old/new family mapppings\")\n parser.add_argument(\"--add-header\", help=\"Print descriptive header\",\n action=\"store_true\", default=False)\n parser.add_argument(\"--add-links\", help=\"Creates hyperlinks to available Rfam html content\",\n action=\"store_true\", default=False)\n return parser",
"def parse_args(args=None):\n\t\treturn _get_args_parser().parse_args(args)",
"def _parse_args():\n parser = argparse.ArgumentParser(description='Run DAFI.')\n parser.add_argument('input_file', help='Name (path) of input file')\n return parser.parse_args()",
"def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # Optional Argument\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\n return parser.parse_args()",
"def parse_cmdline(argv):\n if argv is None:\n argv = sys.argv[1:]\n\n # initialize the parser object:\n parser = argparse.ArgumentParser(description='For each timestep, gather the energy information output by LAMMPS '\n 'in the log file.')\n parser.add_argument(\"-f\", \"--file\", help=\"The log file to be processed.\",\n default=None)\n parser.add_argument(\"-l\", \"--list_file\", help=\"The a file with a list of log files to be processes.\",\n default=None)\n args = None\n try:\n args = parser.parse_args(argv)\n if args.file is None:\n args.file_list = []\n else:\n if os.path.isfile(args.file):\n args.file_list = [args.file]\n args.source_name = args.file\n else:\n raise IOError(\"Could not find specified log file: {}\".format(args.file))\n if args.list_file is not None:\n args.file_list += file_rows_to_list(args.list_file)\n args.source_name = args.list_file\n if len(args.file_list) < 1:\n raise InvalidDataError(\"Found no log file names to process. Specify one or more files as specified in \"\n \"the help documentation ('-h').\")\n except IOError as e:\n warning(\"Problems reading file:\", e)\n parser.print_help()\n return args, IO_ERROR\n except (KeyError, InvalidDataError, SystemExit) as e:\n if hasattr(e, 'code') and e.code == 0:\n return args, GOOD_RET\n warning(e)\n parser.print_help()\n return args, INPUT_ERROR\n return args, GOOD_RET",
"def parse_args():\n\n\t# Define the input parser\n\tdesc = \"computes long term temperature anomaly trend for the GHNC dataset\"\n\tepilog = \"\"\"\ndatarange input argument is of the format:\n\t\t YYYY[MM[DD]][:YYYY[MM[DD]]]\nWhere the date before the optional ':'' represents the lower bound of\nthe range and the optional date after the : represents the upper\nbound. The optional elements of the date default to the lowest possible\nvalue for the lower bound and to the maximum possible for the upper\none. For example,\n\t2006 is equivalent to 2006/01/01:2006/12/31\n\t2006/02 is equivalent to 2006/02/01:2006/02/28\n\"\"\"\n\n\tparser = argparse.ArgumentParser(description=desc, epilog=epilog,\n\t\t\t\t\t\tformatter_class=argparse.RawDescriptionHelpFormatter)\n\tparser.add_argument(\"daterange\",\n\t\t\t\t\t\thelp=\"range of dates to make available locally\")\n\tparser.add_argument('-t',\"--timeseries\",nargs=2,metavar=('lon','lat'),type=float,\n\t\t\t\t\t\thelp=\"plot timeseries for the lon lat pair of coordinates\")\n\tparser.add_argument('-r',\"--recompute\",default=False,action='store_true',\n\t\t\t\t\t\thelp=\"force recompute trend\")\n\n\treturn parser.parse_args()",
"def _parse_args():\n parser = argparse.ArgumentParser(description='main.py')\n \n # General system running and configuration options\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\n\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\n \n # Some common arguments for your convenience\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\n parser.add_argument('--lr', type=float, default=.001)\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\n # 65 is all you need for GeoQuery\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\n\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\n # 50-200 might be a good range to start with for embedding and LSTM sizes\n args = parser.parse_args()\n return args",
"def parse_command_line_arguments():\n parser = argparse.ArgumentParser(\n description=\"Convert dependency files into list of GitHub links.\",\n epilog=\"For help with this program, contact John Speed at jmeyers@iqt.org.\",\n )\n parser.add_argument(\n \"--python\",\n default=False, # default value is False\n help=\"Convert requirements.txt file into GitHub links.\",\n )\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(description=\"Re-ID feature extractor\")\n parser.add_argument(\n \"--model\",\n default=\"resources/networks/mars-small128.ckpt-68577\",\n help=\"Path to checkpoint file\")\n parser.add_argument(\n \"--loss_mode\", default=\"cosine\", help=\"Network loss training mode\")\n parser.add_argument(\n \"--mot_dir\", help=\"Path to MOTChallenge directory (train or test)\",\n required=True)\n parser.add_argument(\n \"--detection_dir\", help=\"Path to custom detections. Defaults to \"\n \"standard MOT detections Directory structure should be the default \"\n \"MOTChallenge structure: [sequence]/det/det.txt\", default=None)\n parser.add_argument(\n \"--output_dir\", help=\"Output directory. Will be created if it does not\"\n \" exist.\", default=\"detections\")\n return parser.parse_args()",
"def parseArgs ():\n independentBaseName = None\n dependentBaseName = None\n independentTSID = None\n dependentTSID = None\n statisticsFile = None\n nEquations = None\n logFile = None\n #\n # Loop through command line arguments\n for arg in sys.argv:\n parts = arg.split('=')\n if ( (parts == None) or (len(parts) != 2) ):\n # Not an arg=value command line argument\n continue\n argName = parts[0].upper()\n argValue = parts[1]\n if ( argName == 'DEPENDENTBASENAME' ):\n dependentBaseName = argValue\n elif ( argName == 'DEPENDENTTSID' ):\n dependentTSID = argValue\n elif ( argName == 'INDEPENDENTBASENAME' ):\n independentBaseName = argValue\n elif ( argName == 'INDEPENDENTTSID' ):\n independentTSID = argValue\n elif ( argName == 'LOGFILE' ):\n logFile = argValue\n elif ( argName == 'NUMBEROFEQUATIONS' ):\n nEquations = int(argValue)\n elif ( argName == 'STATISTICSFILE' ):\n statisticsFile = argValue\n return ( independentBaseName, dependentBaseName, independentTSID, dependentTSID,\n statisticsFile, nEquations, logFile )",
"def parse_args():\r\n desc = \"Check for the longest running requests in bookie\"\r\n parser = argparse.ArgumentParser(description=desc)\r\n\r\n parser.add_argument('-l', '--log', dest='log',\r\n action='store',\r\n default=None,\r\n required=True,\r\n help=\"log file we're reading requests from\")\r\n\r\n parser.add_argument('-n', '--number', dest='count',\r\n action='store',\r\n default=10,\r\n type=int,\r\n required=False,\r\n help=\"how many urls do we wish to see, default 10\")\r\n\r\n\r\n args = parser.parse_args()\r\n return args",
"def parse_args():\n description = \"Plots loss data from DriveNet\"\n parser = argparse.ArgumentParser(description=description)\n\n parser.add_argument('path', metavar='P', type=str, nargs='?',\n help='path of the loss data to be plotted.')\n return parser.parse_args()",
"def _parse_args():\n parser = argparse.ArgumentParser(description='Pure-python command-line calculator.')\n\n parser.add_argument('EXPRESSION', action=\"store\", type=str, help=\"expression string to evaluate\")\n parser.add_argument('-m', '--use-modules', nargs='+', action=\"store\", dest=\"MODULE\", type=str,\n help=\"additional modules to use\")\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(description=\"Deep SORT\")\n parser.add_argument(\n \"--input\", help=\"Path to MOTChallenge sequence directory\",\n default=None, required=True)\n return parser.parse_args()",
"def parse_cmdline_args():\n parser = argparse.ArgumentParser(description=\"Guesses the functional element for host.\")\n ##\n ## Internal options\n ##\n parser.add_argument(\"--json\", dest=\"json\", action='store_true', help=\"output in JSON\")\n\n ##\n ## PuppetDB options\n ##\n pdbconf = PdbConfig()\n pdbconf.add_standard_args(parser)\n\n parser.add_argument(\"host\", metavar=\"HOST\",\n help=\"hostnames to query for FE\")\n\n return parser.parse_args()",
"def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument(\n '--host', dest='host', default=None,\n help='Host for XNAT. Default: env XNAT_HOST.')\n ap.add_argument(\n '-u', '--username', dest='username', default=None,\n help='Username for XNAT.')\n ap.add_argument('project', help='Project Label')\n ap.add_argument('session', help='Session Label')\n ap.add_argument(\n 'proc_suffix', help='Proc name suffix', nargs='?', default='')\n ap.add_argument(\n '-sd', '--subjects_dir', dest='subjects_dir',\n help='Subjects Directory',\n default=os.environ.get('SUBJECTS_DIR', '/tmp'))\n return ap.parse_args()",
"def _parse_args():\n usage = \"usage: %prog [options] arg1 arg2\"\n parser = optparse.OptionParser()\n parser.add_option(\n '--platform', dest='platform', default=\"\", type = \"string\",\n help='platform name: UC 360 baidu etc.')\n parser.add_option(\n '--workspace', dest='workspace', default=\"./\", type = \"string\",\n help='project directory.')\n parser.add_option(\n '--project', dest='projectDir', default=\"./destProject\", type = \"string\",\n help='project directory.')\n # parser.add_option(\n # \"-t\", dest=\"test\", action=\"store_const\", const=lambda:_test, default=_test2, help=\"////////////\"\n # )\n options, args = parser.parse_args()\n # positional arguments are ignored\n return options, args",
"def parse_args():\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\n required=False, help='Specifies the base path for both logs and apk_downloads.')\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\n help='Specifies the path to a credential file in .toml format.')\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\n help='Specifies the maximum number of apks per category to download.')\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-t\", \"--thoughtspot_host\", required=True,\n help=\"domain or ip. E.g. http://1.1.1.1\")\n parser.add_argument(\"-u\", \"--username\", required=True,\n help=\"username - must have administrative privileges\")\n parser.add_argument(\"-p\", \"--password\", required=True,\n help=\"password - must have administrative privileges\")\n parser.add_argument(\"-d\", \"--delimiter\", default=',',\n help=\"character to seperate values by. Default to comma\")\n parser.add_argument(\"-c\", \"--csv\", action=\"store_true\",\n help=\"create csv file called permissions.csv\")\n parser.add_argument(\"-s\", \"--share\", action=\"store_true\",\n help=\"output usable format for share api\")\n return parser.parse_args()",
"def parse_args():\n p = argparse.ArgumentParser(\n description='Parse system logs, for fun or something')\n p.add_argument('-l', '--log', dest='log_file', help='The log file')\n p.add_argument('-f', '--filter', dest='filter', help='filter by daemon')\n return p.parse_args()",
"def parse_args(args):\n\n parser = argparse.ArgumentParser(\n description=\"\"\"Generates and runs an afni_proc.py script to preprocess resting state fMRI data\"\"\",\n formatter_class=argparse.RawDescriptionHelpFormatter)\n\n # Optional Flags\n parser.add_argument(\"-t\", \"--trs_remove\", action=\"store\", default=5, type=int, metavar='TRs',\n help=\"\"\"number of trs to remove at the beginning of the epi data\n (default = 5 trs)\"\"\")\n parser.add_argument(\"-d\", \"--dim_voxel\", action=\"store\", default=2.0, type=float, metavar='MM',\n help=\"voxel dimensions in mm that processed epi will be resampled to (default = 2.0 mm)\")\n parser.add_argument(\"-b\", \"--bandpass\", action=\"store\", default=[0.01, 0.25], nargs=2, type=float, metavar=\"F\",\n help=\"bandpass frequencies lower and upper limits (default = 0.01 0.25)\")\n parser.add_argument(\"-v\", \"--volumes\", action=\"store\", default=0, type=int, metavar=\"V\",\n help=\"\"\"truncate the epi data to the inputted number of volumes, useful if subjects have data \n with different numbers of volumes (default = no truncation)\"\"\")\n parser.add_argument(\"-f\", \"--fwhm\", action=\"store\", default=5.0, type=float, metavar=\"MM\",\n help=\"the full width half maximum that is used when blurring (default = 5.0 mm)\")\n parser.add_argument(\"-c\", \"--cores\", action=\"store\", default=cpu_count(), type=int, metavar=\"C\",\n help=\"number of cores supplied to 3dDeconvolve (default = all cores)\")\n parser.add_argument(\"-s\", \"--subj_id\", action=\"store\", default=\"sub\", metavar=\"SUB\",\n help=\"text file of subject ids (default = sub)\")\n parser.add_argument(\"-T\", \"--time_step\", action=\"store\", default=0, type=float, metavar=\"TS\",\n help=\"set the time step for bandpassing (default = ts in header info\")\n\n parser.add_argument(\"-g\", \"--global_signal_regression\", action=\"store_false\", default=True,\n help=\"do not perform global signal regression (default = perform gsr)\")\n\n parser.add_argument(\"-r\", \"--rerun\", action=\"store_true\", default=False,\n help=\"\"\"rerun preprocessing, override and delete previous results in \n 'Processed' folder (default = don't override)\"\"\")\n parser.add_argument(\"-m\", \"--motion_param\", action=\"store_true\", default=False,\n help=\"use 12 motion parameters for regression (default = 6 motion parameters)\")\n parser.add_argument(\"-G\", \"--gm_blur\", action=\"store_true\", default=False,\n help=\"blur only in grey matter mask (default = blur in whole brain)\")\n parser.add_argument(\"-n\", \"--nl_reg\", action=\"store_true\", default=False,\n help=\"use non-linear warp between anatomical and MNI template (default = linear warp)\")\n\n # Required Inputs\n required = parser.add_argument_group(\"required arguments\")\n required.add_argument(\"-e\", \"--epi\", action=\"store\", required=True,\n help=\"text file of paths to raw epi data\")\n required.add_argument(\"-a\", \"--anat\", action=\"store\", required=True,\n help=\"text file of paths to raw anatomical data\")\n required.add_argument(\"-o\", \"--out_dir\", action=\"store\", required=True, metavar=\"OUT\",\n help=\"text file of paths to output directory\")\n result = parser.parse_args(args)\n\n # Make sure inputted parameters are legal\n assert (os.path.isfile(result.epi)), \"{} does not exist or is not a file\".format(result.epi)\n assert (os.path.isfile(result.anat)), \"{} does not exist or is not a file\".format(result.ant)\n assert (result.trs_remove >= 0), \"Cannot remove negative trs\"\n assert (result.dim_voxel >= 0), \"Cannot have a negative voxel dimension\"\n assert (np.all(np.array(result.bandpass) > 0)), \"Cannot have a negative frequency limit for bandpassing\"\n assert (result.volumes > -1), \"Number of volumes must be greater than 0\"\n assert (result.cores > 0), \"Number of cores used must be greater than 0\"\n assert (result.time_step > -1), \"Time step must be greater than 0\"\n\n return result"
] | [
"0.84956664",
"0.77526116",
"0.7492404",
"0.74425805",
"0.74166906",
"0.7415034",
"0.7406717",
"0.7405937",
"0.7394592",
"0.739314",
"0.7353777",
"0.73531276",
"0.73295814",
"0.7326098",
"0.73121136",
"0.7297962",
"0.72947985",
"0.7294619",
"0.7293887",
"0.7288054",
"0.7277133",
"0.72563785",
"0.72437865",
"0.7243087",
"0.72430533",
"0.7241911",
"0.72298014",
"0.7221696",
"0.7221482",
"0.7207887",
"0.72045344",
"0.72003675",
"0.7200169",
"0.71875507",
"0.7184408",
"0.71760046",
"0.7175724",
"0.7172937",
"0.7172867",
"0.7172343",
"0.7171222",
"0.7161979",
"0.71516496",
"0.71502995",
"0.71464944",
"0.7145171",
"0.71446747",
"0.71436745",
"0.71359694",
"0.7126661",
"0.712521",
"0.7119091",
"0.7114765",
"0.71143436",
"0.71121776",
"0.71119547",
"0.71076643",
"0.7100978",
"0.70999265",
"0.70973307",
"0.7091392",
"0.70905906",
"0.7086302",
"0.70848346",
"0.7082589",
"0.7079362",
"0.7078844",
"0.70729834",
"0.70726",
"0.7072261",
"0.7068931",
"0.70667356",
"0.7065753",
"0.70650667",
"0.7060762",
"0.70596355",
"0.70589256",
"0.7055559",
"0.7053237",
"0.7052089",
"0.7050814",
"0.7050462",
"0.70480955",
"0.7043109",
"0.70421845",
"0.704139",
"0.70407385",
"0.7039865",
"0.703852",
"0.7036937",
"0.7035592",
"0.70350444",
"0.70347494",
"0.70328957",
"0.70296645",
"0.70276535",
"0.7026858",
"0.70266956",
"0.7026401",
"0.70247054",
"0.70229745"
] | 0.0 | -1 |
Testing to do a scrap of consumed material. | def test_manufacturing_scrap(self):
# Update demo products
(self.product_4 | self.product_2).write({
'tracking': 'lot',
})
# Update Bill Of Material to remove product with phantom bom.
self.bom_3.bom_line_ids.filtered(lambda x: x.product_id == self.product_5).unlink()
# Create Inventory Adjustment For Stick and Stone Tools with lot.
lot_product_4 = self.env['stock.production.lot'].create({
'name': '0000000000001',
'product_id': self.product_4.id,
'company_id': self.env.company.id,
})
lot_product_2 = self.env['stock.production.lot'].create({
'name': '0000000000002',
'product_id': self.product_2.id,
'company_id': self.env.company.id,
})
stock_inv_product_4 = self.env['stock.inventory'].create({
'name': 'Stock Inventory for Stick',
'product_ids': [(4, self.product_4.id)],
'line_ids': [
(0, 0, {'product_id': self.product_4.id, 'product_uom_id': self.product_4.uom_id.id, 'product_qty': 8, 'prod_lot_id': lot_product_4.id, 'location_id': self.stock_location_14.id}),
]})
stock_inv_product_2 = self.env['stock.inventory'].create({
'name': 'Stock Inventory for Stone Tools',
'product_ids': [(4, self.product_2.id)],
'line_ids': [
(0, 0, {'product_id': self.product_2.id, 'product_uom_id': self.product_2.uom_id.id, 'product_qty': 12, 'prod_lot_id': lot_product_2.id, 'location_id': self.stock_location_14.id})
]})
(stock_inv_product_4 | stock_inv_product_2)._action_start()
stock_inv_product_2.action_validate()
stock_inv_product_4.action_validate()
#Create Manufacturing order.
production_form = Form(self.env['mrp.production'])
production_form.product_id = self.product_6
production_form.bom_id = self.bom_3
production_form.product_qty = 12
production_form.product_uom_id = self.product_6.uom_id
production_3 = production_form.save()
production_3.action_confirm()
production_3.action_assign()
# Check Manufacturing order's availability.
self.assertEqual(production_3.reservation_state, 'assigned', "Production order's availability should be Available.")
location_id = production_3.move_raw_ids.filtered(lambda x: x.state not in ('done', 'cancel')) and production_3.location_src_id.id or production_3.location_dest_id.id,
# Scrap Product Wood without lot to check assert raise ?.
scrap_id = self.env['stock.scrap'].with_context(active_model='mrp.production', active_id=production_3.id).create({'product_id': self.product_2.id, 'scrap_qty': 1.0, 'product_uom_id': self.product_2.uom_id.id, 'location_id': location_id, 'production_id': production_3.id})
with self.assertRaises(UserError):
scrap_id.do_scrap()
# Scrap Product Wood with lot.
self.env['stock.scrap'].with_context(active_model='mrp.production', active_id=production_3.id).create({'product_id': self.product_2.id, 'scrap_qty': 1.0, 'product_uom_id': self.product_2.uom_id.id, 'location_id': location_id, 'lot_id': lot_product_2.id, 'production_id': production_3.id})
#Check scrap move is created for this production order.
#TODO: should check with scrap objects link in between | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_extract_recipe_from_website(self):\n pass",
"def _scrape(self):",
"def test_JCB_VISUAL_MATERIALS( self ):\n driver = self.driver\n driver.get(self.base_url + \"/record=b5660654~S6\")\n driver.find_element_by_link_text(\"Request\").click()\n self.assertTrue( 'aeon' in driver.current_url )\n self.assertTrue( 'ReferenceNumber=b5660654' in driver.current_url )\n self.assertTrue( 'ItemTitle=Thomas%20Jefferson' in driver.current_url )\n self.assertTrue( 'ItemAuthor=&ItemPublisher' in driver.current_url )\n self.assertTrue( 'ItemPublisher=Princeton' in driver.current_url )\n self.assertTrue( 'CallNumber=VHS' in driver.current_url )\n # self.assertTrue( 'Notes=(bibnum%3A%20b5660654)' in driver.current_url )\n self.assertEqual( 'ItemInfo2=', driver.current_url[-10:] )",
"def test():\n from datas import whatlinks_page\n\n pages = whatlinks_page.whatlinks\n\n for qid in extract_linked_items(pages):\n page = get_itempage(qid)\n try:\n page.get()\n substitute_item_in_dataset(page, get_itempage(\"Q1660508\"), get_itempage(\"Q1622272\") )\n\n except Exception as exc:\n print('wow : <{}> ({}) something is wrong.'.format(exc, type(exc)))",
"def test_scrape_multiple(self):\n self.assertEqual(self.scrapes[0].title, 'First article')\n self.assertEqual(self.scrapes[0].content, ['First para', 'Second para'])\n self.assertEqual(self.scrapes[1].title, 'Second article')\n self.assertEqual(self.scrapes[1].content, ['Para 1', 'Para 2'])\n self.assertEqual(self.scrapes[2].title, 'Third article')\n self.assertEqual(self.scrapes[2].content, ['Thing one', 'Thing two'])",
"def test_scrape_multiple(self):\n self.assertEqual(self.scrapes[0].title, 'First article')\n self.assertEqual(self.scrapes[0].content, ['First para', 'Second para'])\n self.assertEqual(self.scrapes[1].title, 'Second article')\n self.assertEqual(self.scrapes[1].content, ['Para 1', 'Para 2'])\n self.assertEqual(self.scrapes[2].title, 'Third article')\n self.assertEqual(self.scrapes[2].content, ['Thing one', 'Thing two'])",
"def test_scrape(self):\n self.assertEqual(self.scraped.title, 'Heading!')\n self.assertEqual(self.scraped.link_text, 'Go to Google')\n self.assertEqual(self.scraped.link_url, 'http://Google.com')",
"def test_get_recipe_information(self):\n pass",
"def test_create_material_multi_over(self):\n expected_materials_01 = [\n ['cotton'],\n ['cotton'],\n ['wool', 'AAA', 'BBB', 'CCC'],\n ]\n\n expected_materials_02 = [\n ['cotton', '00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11'],\n ['cotton', '00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11'],\n ['wool', 'AAA', 'BBB', 'CCC', '00', '01', '02', '03', '04', '05', '06', '07', '08'],\n ]\n\n select_listings_to_edit(self.driver)\n d = self.driver\n bp = BulkPage(d)\n\n # deselect 2, 3\n bp.click_on_listings(['Second something 1235 (2)', 'Third something LG-512a (3)'])\n\n # append AAA BBB CCC materials to the 1st listing\n send_keys(bp.operation_input(), 'AAA,BBB ,CCC')\n click(bp.operation_apply())\n\n material_names = bp.material_names()\n assert material_names == expected_materials_01\n\n # append 00, 01, 02... to all listings\n bp.click_on_listings(['Second something 1235 (2)', 'Third something LG-512a (3)'])\n send_keys(bp.operation_input(), '00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14, 15')\n click(bp.operation_apply())\n\n material_names = bp.material_names()\n assert material_names == expected_materials_02",
"def scrape(self):\n pass",
"def test_scrape_results(self):\n self.assertIsInstance(self.scrapes, EntityList)\n self.assertEqual(len(self.scrapes), 3)\n self.assertEqual([s.title for s in self.scrapes[1:]], ['Second article', 'Third article'])",
"def test_scrape_results(self):\n self.assertIsInstance(self.scrapes, EntityList)\n self.assertEqual(len(self.scrapes), 3)\n self.assertEqual([s.title for s in self.scrapes[1:]], ['Second article', 'Third article'])",
"def test_cards_get(self):\n pass",
"def test_get_art_info(self):\n pass",
"def test_gethardwares_item(self):\n pass",
"def test_get_analyzed_recipe_instructions(self):\n pass",
"def test_direct_usage(self):\n r = RscHtmlReader()\n fname = '10.1039_C6OB02074G.html'\n f = io.open(os.path.join(os.path.dirname(__file__), 'data', 'rsc', fname), 'rb')\n content = f.read()\n d = r.readstring(content)\n self.assertEqual(len(d.elements), 60)",
"def parse(self, response):\n self.driver.get(response.url)\n product_category=response.meta[\"category_text\"]\n products=response.xpath(\"//*[(@class='list-item')]\")\n \n # item containers for storing product\n items = CrawlingECommerceItem()\n \n # iterating over search results\n # for product in products:\n # # Defining the XPaths\n # XPATH_PRODUCT_LINK=\".//*[contains(concat( ' ', @class, ' ' ), concat( ' ', 'goods-tit', ' ' ))]//a\"\n # XPATH_PRODUCT_NAME=\".//div[@class='goods-introudce']//a/@href\"\n # XPATH_PRODUCT_PRICE=\".//div[@class='catalog-detail']//div[@class='detail-right']//p/text()\"\n # XPATH_PRODUCT_IMAGE_LINK=\".//img\"\n\n # raw_product_name=product.xpath(XPATH_PRODUCT_NAME).get()\n # raw_product_price=product.xpath(XPATH_PRODUCT_PRICE).get()\n # raw_product_image_link=product.xpath(XPATH_PRODUCT_IMAGE_LINK).extract()\n # raw_product_link=product.xpath(XPATH_PRODUCT_LINK).get()\n\n # # cleaning the data\n # product_name=''.join(raw_product_name).strip(\n # ) if raw_product_name else None\n # product_price=''.join(raw_product_price).strip(\n # ) if raw_product_price else None\n # product_image_link=''.join(raw_product_image_link).strip(\n # ) if raw_product_image_link else None\n # product_link=''.join(raw_product_link).strip(\n # ) if raw_product_link else None\n\n # # storing item\n # yield CrawlingECommerceItem (\n # product_name=product_name,\n # product_price=product_price,\n # product_url=product_link,\n # product_category=product_category,\n # image_urls=raw_product_image_link\n # )\n\n # # yield items\n \n # XPATH_PRAGINATION_LINK=\"//*[(@class='next right')]/a/@href\"\n\n yield response.follow(str(response.request.url), callback = self.parse, meta = {\"category_text\": product_category})",
"def test_create_material(self):\n expected_materials = [\n ['cotton', 'AAA'],\n ['cotton', 'AAA'],\n ['wool', 'AAA'],\n ]\n\n select_listings_to_edit(self.driver)\n d = self.driver\n bp = BulkPage(d)\n\n send_keys(bp.operation_input(), 'AAA')\n click(bp.operation_apply())\n\n material_names = bp.material_names()\n assert material_names == expected_materials\n\n apply_class = bp.operation_apply().get_attribute('class')\n assert 'inactive' in apply_class.split(' ')",
"def test_analyze_recipe_instructions(self):\n pass",
"def test_display_review(self):\n\n result = self.client.get(\"/brand/P87985432\")\n self.assertIn(b\"ever ever\", result.data)",
"def test_search_recipes(self):\n pass",
"def test_gettem_using_get(self):\n pass",
"def test_parse_valid(self):\n mock_scraper = MockCtdScraper()\n scrape_gen = mock_scraper.scrape(TEST_CHUNKSIZE)\n self.parser.parse(next(scrape_gen))",
"def test_collect_demands(self):\n pass",
"def test_private_fetch_law(self, mock_law_pages):\n\n with requests_mock.mock() as mock_requests:\n test_text = (self.input_html.rstrip('</div>') +\n \"\"\"><table><a href=\"gigi\">gigi</table>\n<table><tbody><a href=\"gogo\">gogo</table></tbody></div>\"\"\")\n mock_requests.get(agc_law.FIRST_PAGE, text=test_text, status_code=200)\n mock_storage = Mock()\n mock_law_pages.return_value = \"hulahoop\"\n sys.stdout = captured = StringIO()\n self.law._fetch_law(('test', agc_law.FIRST_PAGE), mock_storage)\n self.assertEqual(captured.getvalue(),\n 'Requesting page test\\n')\n self.assertIn(call('hulahoop'), mock_storage.extend.call_args_list)\n sys.stdout = sys.__stdout__",
"def test_can_start_a_list_and_retrieve_it_later(self):\n self.browser.get('http://localhost:8000')\n\n # Ela notou que o título e o cabeçalho da página diz Listas de Tarefas\n self.assertIn('Listas de Tarefas', self.browser.title)\n self.fail('Finish the test!')\n\n # Ela é imediatamente convidada a colocar uma tarefa na lista\n\n # Ela digita \"Comprar coxinhas\" em uma caixa de texto (Edith é uma\n # PyLady)\n\n # Quando ela tecla Enter, a página atualiza, e agora a página lista\n # \"1: Comprar coxinha\" como um item em uma lista de tarefas\n\n # Ainda tem uma caixa de texto convidando-a a adicionar um outro item.\n # Ela digita \"Comer as coxinhas\" (Edith é muito metódica)\n\n # A página atualiza novamente, e agora mostra ambos os itens na lista\n # dela\n\n # Edith se pergunta se o site lembrará da sua lista. Então ela vê que o\n # site gerou uma URL única para ela - Tem um texto explicativo para\n # esse efeito.\n\n # Ela visita a URL - Sua lista de tarefas ainda está lá.",
"def test_get_scan(self):\n pass",
"def test_get_random_recipes(self):\n pass",
"def test_get_scans(self):\n pass",
"def test_get_consumed_with_empty_result(self, m):\n url = \"https://www.cellartracker.com/xlquery.asp?User=test-username&Password=test-password&Table=Consumed&Format=tab&Location=1\"\n file = open(\"./tests/fixtures/consumed_empty.tsv\", \"r\")\n m.register_uri(\"GET\", url, status_code=200, text=file.read())\n file.close\n\n cellartracker = CellarTracker(username=\"test-username\", password=\"test-password\")\n data = cellartracker.get_consumed()\n self.assertEqual([], data)",
"def test_search_shoes_item_to_buy(self):\n self.driver.find_element_by_id(\"search_query_top\").send_keys(\"shoes\")\n self.driver.find_element_by_name(\"submit_search\").click()\n self.driver.find_element_by_xpath(\n \"/html/body/div[1]/div[2]/div/div[3]/div[2]/ul/li[2]/div/div[1]/div/a[1]/img\").click()\n self.driver.find_element_by_name(\"Submit\").click()\n time.sleep(5)",
"def test_create_material_multi_basic(self):\n expected_materials = [\n ['cotton', 'AAA', 'BBB', 'CCC'],\n ['cotton', 'AAA', 'BBB', 'CCC'],\n ['wool', 'AAA', 'BBB', 'CCC'],\n ]\n\n select_listings_to_edit(self.driver)\n d = self.driver\n bp = BulkPage(d)\n\n send_keys(bp.operation_input(), 'AAA,BBB ,CCC')\n click(bp.operation_apply())\n\n material_names = bp.material_names()\n assert material_names == expected_materials",
"def test_extract(self):\n for document in [test_pdfutil.BLANK, test_pdfutil.LOREM]:\n paper = factories.Paper.create(document=factory.django.FileField(\n data=document))\n paper_url = \"{}/{}\".format(EXTRACT_URL, paper.unique_id)\n\n c = django.test.Client()\n variables = [\"funding\", \"grant_id\"]\n for var in variables:\n var_url = \"{}/{}\".format(paper_url, var)\n self.assertEqual(b'{\"value\":null}', c.get(var_url).content)\n\n # Extract all at once\n self.assertEqual(b'{\"funding\":null,\"grant_id\":null}',\n c.get(paper_url).content)",
"def test_gettesttools_html(self):\n pass",
"def test_document_retrieval(self):",
"def test_get_learners(self):\n pass",
"def test_get_results(self):\n pass",
"def test_process_data(self):\n pass",
"def test_loading_document(self):",
"def test_get_items_page(self, mock_requests_get):\n result = resources.get_items_page(1, \"a\", 1)\n\n assert result.total == 97\n\n item = result.items[0]\n assert item.id == 1\n assert item.name == \"Thing\"\n assert item.description == \"A thing\"\n\n assert item.current.price == 100\n assert item.today.price == 110\n\n assert item.members is True\n\n item = result.items[1]\n\n assert item.current.price == 11300\n assert item.today.price == 24400000\n\n assert item.members is False\n\n item = result.items[2]\n\n assert item.current.price == 1800000000\n assert item.today.price == 43657",
"def test_tips(self):\n res = self.client.get(\"/tips\")\n data = res.data.decode(\"utf-8\")\n assert res.status == \"200 OK\"\n assert \"Bits and pieces\" in data",
"def test_service_item_search(self):\n\n flag = \"user\"\n api = \"service.item.editsn\"\n #current_page = 1\n search_info = json.dumps({\n })\n sn_pre = '730300010036664'#'730300010034444'\n sn_after = '730300010036665'#'730300010033333'\n result = self.access_api(flag = flag, api = api, sn_pre=sn_pre, sn_after=sn_after)\n #self.assertTrue('data_list' in result)\n #print(result[\"data_list\"])",
"def test_find_stock_items(self):\n pass",
"def test_basic_info(self):\n\n url = reverse('stock-item-detail', kwargs={'pk': 1})\n\n response = self.client.get(url)\n self.assertEqual(response.status_code, 200)\n\n html = str(response.content)\n\n # Part name\n self.assertIn('Stock Item: M2x4 LPHS', html)\n\n # Quantity\n self.assertIn('<h5>Available Quantity</h5>', html)\n self.assertIn('<h5>4000', html)\n\n # Batch code\n self.assertIn('Batch', html)\n self.assertIn('<td>B123</td>', html)\n\n # Actions to check\n actions = [\n \"id=\\\\\\'stock-count\\\\\\' title=\\\\\\'Count stock\\\\\\'\",\n \"id=\\\\\\'stock-add\\\\\\' title=\\\\\\'Add stock\\\\\\'\",\n \"id=\\\\\\'stock-remove\\\\\\' title=\\\\\\'Remove stock\\\\\\'\",\n \"id=\\\\\\'stock-move\\\\\\' title=\\\\\\'Transfer stock\\\\\\'\",\n \"id=\\\\\\'stock-duplicate\\\\\\'\",\n \"id=\\\\\\'stock-edit\\\\\\'\",\n \"id=\\\\\\'stock-delete\\\\\\'\",\n ]\n\n # Initially we should not have any of the required permissions\n for act in actions:\n self.assertNotIn(act, html)\n\n # Give the user all the permissions\n self.assignRole('stock.add')\n self.assignRole('stock.change')\n self.assignRole('stock.delete')\n\n response = self.client.get(url)\n html = str(response.content)\n\n for act in actions:\n self.assertIn(act, html)",
"def test_analyze_a_recipe_search_query(self):\n pass",
"def test_read_not_interested(self):\n try:\n self.reader.read(self.books[2], 0, 0)\n self.fail(\"Readed book not interested\")\n except AssertionError:\n pass",
"def test_meme_get(self):\n pass",
"def test_get_item_details(self, mock_requests_get):\n details = resources.get_item_details(21787)\n\n item = details.item\n assert item.id == 21787\n assert item.name == \"Steadfast boots\"\n assert item.type == \"Miscellaneous\"\n assert item.current.price == 5900000\n assert item.today.price == -138200\n assert item.members is True",
"def test_create_recipe_card(self):\n pass",
"def test_client_risk_assessment_retrieve(self):\n pass",
"def test_scrape(self):\n keyword = [\"COVID\", \"Libur\", \"Deloitte\", \"Jakarta Barat\", \"Banjir Bandang\"]\n for i in range(len(keyword)):\n response = self.client.get(\"/v1/news/\", params = {\"keyword\": keyword[i]})\n self.assertEqual(response.status_code, 200)",
"def test_summarize_recipe(self):\n pass",
"def test_listing_from_wall(self):",
"def test_get_recipe_information_bulk(self):\n pass",
"def test_iterate_next_urls_not_html(self):\n self.mini_spider_thread.grab_url('http://example.com/iterate_next_urls/not_html_webpage') \n self.assertTrue(self.mini_spider_thread.grab_url_success)\n self.assertEqual(len(list(self.mini_spider_thread.iterate_next_urls(self.url_obj))), 0)",
"def test_view_product_description_page(self):\r\n response = self.client.get('/product_description/nutella/')\r\n self.assertEqual(response.status_code, 200)",
"def test_retrieve_recipes(self):\n sample_quizz()\n sample_quizz()\n\n res = self.client.get(QUIZZES_URL)\n\n quizzes = Quizz.objects.all()\n serializer = QuizzSerializer(quizzes, many=True)\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data, serializer.data)",
"def test_02_visit_again(self):",
"def test_get_run(self):\n pass",
"def test_retrieve_recipes(self):\n sample_recipe(name=\"Avocado toast\")\n sample_recipe(name='Baklava')\n\n res = self.client.get(RECIPES_URL)\n\n recipes = Recipe.objects.all()\n serializer = RecipeSerializer(recipes, many=True)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 2)\n self.assertEqual(res.data, serializer.data)",
"def test_visualize_recipe_taste(self):\n pass",
"def grab_mApe_results (searchType) :\n\n mape_main_url = 'https://www.mightyape.co.nz/'\n #Defining the url paths for search types\n mape_mv_category_url = 'movies-tv/movies?q='\n mape_mv_format_search_url = 'movieformat~blu-ray'\n\n #This is the final url string\n searchUrl = ''\n\n #Checking search type\n if searchType is SEARCH_BD_MV_TYPE :\n searchUrl = mape_main_url+mape_mv_category_url+mape_mv_format_search_url\n elif searchType is 'Title' :\n searchUrl = 'https://www.mightyape.co.nz/movies-tv/movies/all?sort=2&q=movieformat~blu-ray'\n\n\n #Using a dictionary to store data, as contains list with objects\n mape_list = {}\n\n page = requests.get(searchUrl)\n tree = html.fromstring(page.content)\n\n data = tree.xpath('//div[@class=\"product-list gallery-view\"]/div[@class=\"product\"]/div[@class=\"title\"]/a') #<--- WORKS\n\n data_alt = tree.xpath('//div[@class=\"product-list gallery-view\"]/div[@class=\"product\"]')\n\n print('Getting results from url:',searchUrl)\n print('Number of objects=',len(data_alt))\n count = 1\n\n for item in data_alt :\n simple_item = item.xpath('div[@class=\"title\"]/a')\n title = simple_item[0].text\n link = simple_item[0].get('href')\n format = item.xpath('div[@class=\"format\"]/text()')\n rating = item.xpath('div[@class=\"customer-rating\"]/span/span[@class=\"average\"]/text()')\n base_price = item.xpath('div[@class=\"price\"]/s/text()')\n hot_price = item.xpath('div[@class=\"price\"]/span[@class=\"price hot\"]/text()')\n normal_price = item.xpath('div[@class=\"price\"]/span[@class=\"price\"]/text()')\n if len(rating) > 0 :\n #temp_mv = Movie_object(title,format[0],rating[0].strip(), mape_main_url + link,normal_price, base_price, hot_price)\n print(title,format[0],rating[0].strip(), mape_main_url + link,normal_price, base_price, hot_price)\n #mape_list[title] = temp_mv\n else :\n print(title, format[0], 'n/a', mape_main_url + link, normal_price, base_price, hot_price)\n #temp_mv = Movie_object(title, format[0], 'n/a', mape_main_url + link, normal_price, base_price, hot_price)\n #mape_list[title] = temp_mv\n\n\n count += 1\n\n return mape_list",
"def test_discover(self):\n client = Client()\n response = client.get('/discover/authors')\n print 'status code for authors', response.status_code\n self.failUnlessEqual(response.status_code, 200)\n\n response = client.get('/simple_search') \n print 'status code for simple search', response.status_code\n self.failUnlessEqual(response.status_code, 200)\n\n response = client.get('/extended_search') \n print 'status code for extended search', response.status_code\n self.failUnlessEqual(response.status_code, 200)\n \n response = client.get('/discover/languages') \n print 'status code for languages', response.status_code\n self.failUnlessEqual(response.status_code, 200) \n \n response = client.get('/discover/subjects') \n print 'status code for tags', response.status_code\n self.failUnlessEqual(response.status_code, 200)",
"def test_art_from_taste_space(self):",
"def parse_search_result(self, response):\n item = ElectronicItem()\n\n part_number = cleansplit(Selector(text=response.body)\n #.css(\"li.ttipartnumber a ::text/li[@class='ttipartnumber']/a/text()\"))\n #.css(\"li.ttipartnumber a::text\"))\n .xpath(\"//meta[@itemprop='sku']/@content\"))\n manufacturer_part_number = cleansplit(Selector(text=response.body)\n .xpath(\"//meta[@itemprop='mpn']/@content\"))\n #.css(\"li.mfrpartnumber a::text\"))\n manufacturer_name = cleansplit(Selector(text=response.body)\n .xpath(\"//td[@class='oc_row']/div/img/@title\"))\n #.css(\"li.manufacturer::text\"))\n description = cleansplit(Selector(text=response.body)\n .xpath(\"//span[@itemprop='description']/text()\"))\n #.css(\"td.description::text\"))\n quantity_available = cleansplit(Selector(text=response.body)\n .xpath(\"//table[1]/tbody[1]/tr/td[5]//text()\"))\n #.css(\"td.availability::text\"))\n image_url = cleansplit(Selector(text=response.body)\n .xpath(\"//table[1]/tbody[1]/tr/td[2]/img[1]/@src\"))\n\n '''\n This is variable handler when no content in selected xpath. so this algorithm will keep list balanced.\n and alyways will process zip iteration. and return scaped item. see customfunction.py for listbalancer method'''\n if not quantity_available: quantity_available = listbalancer(part_number)\n if not image_url: image_url = listbalancer(image_url)\n if not description: description = listbalancer(description)\n\n for i, j, k, l, m, n in zip(part_number, manufacturer_part_number, manufacturer_name,\n description, quantity_available, image_url):\n item['manufacturer'] = k\n item['manufacturer_part_number'] = j\n item['supplier'] = self.spider_name\n item['supplier_part_number'] = i\n item['description'] = l\n item['image_url'] = n\n item['product_url'] = response.url\n item['stock_qty'] = cleanqty(m.replace(u'\\xa0', u''))\n yield item\n #next_url = response.xpath(\n # '//a[@id=\"ctl00_PlaceHolderMain_results_pagingFooter_ctl08_HyperLink6\"]//@href').extract_first()\n next_url = response.xpath(\"//nav[1]/ul[1]/li[4]/a[1]/@href\").extract_first()\n if self.debug: print \"Next URL -> %s\" % (next_url)\n if next_url:\n \"Following Next Page {0}\".format(response.urljoin(next_url))\n yield Request(response.urljoin(next_url), callback=self.parse_search_result, dont_filter=True)\n # items.append(dict(item))\n # return items",
"def test_homepage(self):\n\n response = self.client.get(\"/\")\n self.assertIn(\"Books</title>\", response.data)\n self.assertIn(\"Goodreads ID\", response.data)",
"def test_post_chain_search(self):\n pass",
"def getMNACGenerator():\n\n # 0 - 89 (something between 80 and 90\n searchBaseUrl = u'http://www.museunacional.cat/en/advanced-piece-search?title_1=&title=&field_piece_inventory_number_value=&keys=&field_piece_type_value_i18n[0]=pintura&&&page=%s'\n # 0 - 48, for some reason not all paintings get returned in the main query\n # searchBaseUrl = u'http://www.museunacional.cat/en/advanced-piece-search?field_piece_type_value_i18n[0]=pintura&field_piece_info_content_value[p.%%2019th]=p.%%2019th&field_piece_info_content_value[q.%%2020th]=q.%%2020th&&page=%s'\n htmlparser = HTMLParser.HTMLParser()\n\n foundit=True\n\n for i in range(0, 89):\n searchUrl = searchBaseUrl % (i,)\n print searchUrl\n searchPage = urllib2.urlopen(searchUrl)\n searchPageData = searchPage.read()\n\n searchRegex = u'\\<a href\\=\\\"(\\/en\\/colleccio\\/[^\\\"]+)\\\"\\>Read more\\<\\/a\\>'\n itemmatches = re.finditer(searchRegex, searchPageData)\n urllist = []\n #for match in matches:\n # try:\n # # #bla = unicode(match.group(1), u'utf-8')\n # urllist.append(u'http://www.dulwichpicturegallery.org.uk%s' % (match.group(1),))\n # except UnicodeDecodeError:\n # pywikibot.output(u'Found an url I cannot parse: %s' % (unicode(match.group(1), u'utf-8'),))#\n\n #print len(urllist)\n #urlset = set(urllist)\n #print len(urlset)\n\n\n for itemmatch in itemmatches:\n url = u'http://www.museunacional.cat%s' % (itemmatch.group(1),)\n print url\n\n if url==u'http://adsfasdfasdf':\n foundit=True\n if not foundit:\n continue\n metadata = {}\n\n metadata['collectionqid'] = u'Q861252'\n metadata['collectionshort'] = u'MNAC'\n metadata['locationqid'] = u'Q861252'\n metadata['instanceofqid'] = u'Q3305213'\n \n metadata['url'] = url\n\n itemPage = urllib2.urlopen(url)\n itemPageData = unicode(itemPage.read(), u'utf-8')\n \n #print itemPageEnData\n titleRegex = u'<li class=\"ca first\"><a href=\"/ca/colleccio/[^\\\"]+\" class=\"language-link\" xml:lang=\"ca\" title=\"([^\\\"]+)\">Català</a></li>[\\r\\n\\t\\s]*<li class=\"es\"><a href=\"/es/colleccio/[^\\\"]+\" class=\"language-link\" xml:lang=\"es\" title=\"([^\\\"]+)\">Español</a></li>[\\r\\n\\t\\s]*<li class=\"en last active\"><a href=\"/en/colleccio/[^\\\"]+\" class=\"language-link active\" xml:lang=\"en\" title=\"([^\\\"]+)\">English</a></li>'\n #titleEnRegex = u'<main class=\"main narrow\">[\\r\\n\\t\\s]+<h1>[\\r\\n\\t\\s]*([^<]+)[\\r\\n\\t\\s]*</h1>'\n creatorRegex = u'<div class=\"ds-author-piece\">([^<]+)</div>'\n dateRegex = u'Painting<div class=\"ds-feature\"><p>(\\d\\d\\d\\d)</p></div>' #FIXME: Only matches on real years\n invRegex = u'Inventory number: </div><p>([^<]+)</p>'\n\n # Could also get Dimensions, Materials, Acquisition\n \n matchTitle = re.search(titleRegex, itemPageData)\n if not matchTitle:\n pywikibot.output(u'The title data for this painting is BORKED!')\n continue\n\n #FIXME: Check encoding\n\n metadata['title'] = { u'ca' : htmlparser.unescape(matchTitle.group(1)),\n u'es' : htmlparser.unescape(matchTitle.group(2)),\n u'en' : htmlparser.unescape(matchTitle.group(3)),\n }\n \n #pywikibot.output(metadata.get('title'))\n\n creatorMatch = re.search(creatorRegex, itemPageData)\n if not creatorMatch:\n pywikibot.output(u'The creator data for this painting is BORKED!')\n continue\n\n #FIXME: Add some logic for work after and clean up\n\n name = htmlparser.unescape(creatorMatch.group(1))\n # We need to normalize the name\n if u',' in name:\n (surname, sep, firstname) = name.partition(u',')\n name = u'%s %s' % (firstname.strip(), surname.strip(),)\n metadata['creatorname'] = name\n \n metadata['description'] = { u'nl' : u'%s van %s' % (u'schilderij', metadata.get('creatorname'),),\n u'en' : u'%s by %s' % (u'painting', metadata.get('creatorname'),),\n u'ca' : u'%s de %s' % (u'pintura', metadata.get('creatorname'),),\n u'es' : u'%s de %s' % (u'pintura', metadata.get('creatorname'),),\n }\n\n\n invMatch = re.search(invRegex, itemPageData)\n\n if not invMatch:\n pywikibot.output(u'No inventory number found! Skipping')\n continue\n \n metadata['id'] = invMatch.group(1)\n metadata['idpid'] = u'P217'\n\n dateMatch = re.search(dateRegex, itemPageData)\n\n if dateMatch:\n metadata['inception'] = dateMatch.group(1)\n\n yield metadata",
"def test_shelve_reading(self, *_):\n shelf = models.Shelf.objects.get(identifier=\"reading\")\n request = self.factory.post(\n \"\", {\"book\": self.book.id, \"shelf\": shelf.identifier}\n )\n request.user = self.local_user\n\n with patch(\"bookwyrm.models.activitypub_mixin.broadcast_task.delay\"):\n views.shelve(request)\n # make sure the book is on the shelf\n self.assertEqual(shelf.books.get(), self.book)",
"def test_get_food(self):\n pass",
"def test_airbnb_scenario(self):\r\n self.main_page_object = mainPage(self.driver)\r\n self.main_page_object.select_experiences()\r\n self.main_page_object.search_experiences_by_city()\r\n\r\n self.experience_page_object = experiencesPage(self.driver)\r\n self.experience_page_object.add_date()\r\n self.experience_page_object.select_guests()\r\n\r\n self.experience_page_object.price_filter()\r\n self.experience_page_object.search_result1()\r\n self.experience_page_object.search_result2()\r\n\r\n # self.experience_page_object.assert_results()\r",
"def test_read_artifact(self):\n pass",
"def test_parsing_action(self):\n self.grammar.parse(open(TEST_ASSETS + '/test_item.txt').read())",
"def test_read_book(self):\n\n delete_books()\n\n book = create_book(\"title one\")[\"book\"]\n\n with test_client.get(\"/book/{}/\".format(book[\"id\"])) as response:\n\n self.assertEqual(\n json.loads(response.get_data(as_text=True)),\n {\n \"status\": \"success\",\n \"book\": book\n }\n )\n\n \"\"\"\n clear the table, create several books and read them\n \"\"\"\n\n delete_books()\n\n book_one = create_book(\"title one\")[\"book\"]\n book_two = create_book(\"title two\")[\"book\"]\n\n with test_client.get(\"/book/{}/\".format(book_one[\"id\"])) as response:\n\n self.assertEqual(\n json.loads(response.get_data(as_text=True)),\n {\n \"status\": \"success\",\n \"book\": book_one\n }\n )\n\n with test_client.get(\"/book/{}/\".format(book_two[\"id\"])) as response:\n\n self.assertEqual(\n json.loads(response.get_data(as_text=True)),\n {\n \"status\": \"success\",\n \"book\": book_two\n }\n )",
"def test_open_fill(self):",
"def test_export_html(self):\r\n resp = self.client.get_html(self.url)\r\n self.assertEquals(resp.status_code, 200)\r\n self.assertContains(resp, \"Export My Course Content\")",
"def test_autocomplete_recipe_search(self):\n pass",
"def test_parse_sample_sheet(self):\n pass",
"def getTestResults():",
"def test_retrieve_recipes(self):\n sample_recipe(user=self.user)\n sample_recipe(user=self.user, title=\"Beans\")\n\n res = self.client.get(RECIPE_URL)\n\n recipes = Recipe.objects.all().order_by('-id')\n serializer = RecipeSerializer(recipes, many=True)\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(len(res.data), 2)\n self.assertEqual(res.data, serializer.data)",
"def test_discover(self):\n response = Tmdb.discover()\n self.assertTrue(int(response.status_code) == 200)\n data = response.json()\n self.assertTrue(isinstance(data['results'], list))\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)",
"def test_details(self, mock_product, mock_nutrival):\n mock_product.return_value = MagicMock(\n side_effect=Products.objects.filter()\n )\n mock_product.return_value.first.return_value = Products(rating=\"a\")\n mock_nutrival.return_value = MagicMock(\n side_effect=Products.objects.filter()\n )\n mock_nutrival.return_value.first.return_value = NutritionalValues()\n response = self.client.get(\"/details/1/\")\n self.assertEqual(response.status_code, 200)\n self.assertTemplateUsed(response, \"search/base.html\")\n self.assertTemplateUsed(response, \"search/search_form.html\")\n self.assertTemplateUsed(response, \"search/details.html\")\n self.assertIsInstance(response.context[\"product\"], Products)\n self.assertIsInstance(response.context[\"nutrival\"], NutritionalValues)\n self.assertIn(\"nutriscore-a\", response.context[\"nutriscore\"])",
"def test_another_read(self):\n self.reader._timing = [3, 2, 3, 3, 1, 1]\n score, time = self.reader.read(self.books[0], 0, 6)\n self.assertTrue(self.books[0].id_book not in self.reader._books)\n self.assertEqual(0, score)\n self.assertEqual(9, time)",
"def testProtractedPostApplicationSanityChecks(self):\n self.assertLess(self.c.get_species_richness(1), self.c.get_species_richness(3))\n self.assertLess(self.c.get_species_richness(2), self.c.get_species_richness(4))\n self.assertLess(self.c.get_species_richness(5), self.c.get_species_richness(3))\n self.assertLess(self.c.get_species_richness(6), self.c.get_species_richness(4))\n self.assertEqual(4, self.c.get_species_richness(1))\n self.assertEqual(4, self.c.get_species_richness(2))\n self.assertEqual(7, self.c.get_species_richness(3))\n self.assertEqual(7, self.c.get_species_richness(4))\n self.assertEqual(4, self.c.get_species_richness(5))\n self.assertEqual(4, self.c.get_species_richness(6))\n self.assertEqual(21, self.c.get_species_richness(7))\n self.assertEqual(38, self.c.get_species_richness(8))",
"def testProtractedPostApplicationSanityChecks(self):\n self.assertLess(self.c.get_species_richness(1), self.c.get_species_richness(3))\n self.assertLess(self.c.get_species_richness(2), self.c.get_species_richness(4))\n self.assertLess(self.c.get_species_richness(5), self.c.get_species_richness(3))\n self.assertLess(self.c.get_species_richness(6), self.c.get_species_richness(4))\n self.assertEqual(4, self.c.get_species_richness(1))\n self.assertEqual(4, self.c.get_species_richness(2))\n self.assertEqual(7, self.c.get_species_richness(3))\n self.assertEqual(7, self.c.get_species_richness(4))\n self.assertEqual(4, self.c.get_species_richness(5))\n self.assertEqual(4, self.c.get_species_richness(6))\n self.assertEqual(21, self.c.get_species_richness(7))\n self.assertEqual(38, self.c.get_species_richness(8))",
"def testProtractedPostApplicationSanityChecks(self):\n self.assertLess(self.c.get_species_richness(1), self.c.get_species_richness(3))\n self.assertLess(self.c.get_species_richness(2), self.c.get_species_richness(4))\n self.assertLess(self.c.get_species_richness(5), self.c.get_species_richness(3))\n self.assertLess(self.c.get_species_richness(6), self.c.get_species_richness(4))\n self.assertEqual(4, self.c.get_species_richness(1))\n self.assertEqual(4, self.c.get_species_richness(2))\n self.assertEqual(7, self.c.get_species_richness(3))\n self.assertEqual(7, self.c.get_species_richness(4))\n self.assertEqual(4, self.c.get_species_richness(5))\n self.assertEqual(4, self.c.get_species_richness(6))\n self.assertEqual(21, self.c.get_species_richness(7))\n self.assertEqual(38, self.c.get_species_richness(8))",
"def test_retrieve_recipes(self):\n sample_recipe(user = self.user)\n sample_recipe(user = self.user)\n\n res = self.client.get(RECIPE_URL)\n\n recipes = Recipe.objects.all().order_by('-id')\n serializer = RecipeSerializer(recipes, many=True) # many=true returns the data as a list\n\n self.assertEqual(res.status_code, status.HTTP_200_OK)\n self.assertEqual(res.data, serializer.data)",
"def test_all_good_recovered(self):\n # Start sampling\n self.driver.start_sampling()\n\n self.create_sample_data_set_dir(\n \"DOS15908_1st7_step1.DAT\",\n RECOV_DIR,\n \"DOS15908.DAT\",\n copy_metadata=False\n )\n self.assert_data(\n (DostadParserRecoveredDataParticle, DostadParserRecoveredMetadataDataParticle),\n 'test_data_1r.txt.result.yml',\n count=2,\n timeout=10\n )\n\n self.create_sample_data_set_dir(\n \"DOS15908_1st7_step2.DAT\",\n RECOV_DIR,\n \"DOS15909.DAT\",\n copy_metadata=False\n )\n self.assert_data(\n DostadParserRecoveredDataParticle,\n 'test_data_2r.txt.result.yml',\n count=1\n )",
"def test_fetch(self, mock_find_law, mock_process_join,\n mock_process_start, mock_process_manager):\n\n mock_find_law.return_value = [1, 2, 3]\n mock_process_manager.list.return_value = [3, 4, 5]\n self.law.fetch()\n self.assertEqual(mock_process_join.call_count, 3)\n self.assertEqual(mock_process_start.call_count, 3)\n self.assertEqual(mock_process_manager.call_count, 1)",
"def extract_data():\n books = WebScraper().get_top_100_data()\n time.sleep(2)\n BookDetailsWebScrapper().save_book_details(books)\n _save_extract_state(books)",
"def test_get_part(self):\n pass",
"def test_gather_success(self):\n gathered_items = self.Quant._gather(self.apple, self.test_stock_location_01)\n # Check the number of apple quants returned is correct\n self.assertEqual(len(gathered_items), 3)\n # Check that the products are all of expected type\n self.assertEqual(gathered_items.product_id, self.apple)\n\n # Unfold the returned quants\n _q1, second_quant, _q2 = gathered_items\n # Check when quant_ids is set in the context\n gathered_items_subset = self.Quant.with_context(quant_ids=[second_quant.id])._gather(\n self.apple, self.test_stock_location_01\n )\n self.assertEqual(len(gathered_items_subset), 1)\n self.assertEqual(gathered_items_subset.product_id, self.apple)\n self.assertEqual(gathered_items_subset, second_quant)",
"def test_food_content(self):\n bs = self.get_soup(baseUrl + 'food/')\n self.assertOneExists(bs, \"#page_food\")",
"def test_get_details7(self):\n pass",
"def test_get_offers(self):\n pass",
"def test_scrape_multiple(self):\n self.assertEqual(self.blogs[0].title, 'First article')\n self.assertEqual(self.blogs[0].content, ['First para', 'Second para'])\n self.assertEqual(self.blogs[1].title, 'Second article')\n self.assertEqual(self.blogs[1].content, ['Para 1', 'Para 2'])\n self.assertEqual(self.blogs[2].title, 'Third article')\n self.assertEqual(self.blogs[2].content, ['Thing one', 'Thing two'])",
"def test_products_get(mocker, data):\n mocker.patch(\"sps.request.fetch\", autospec=True)\n request.fetch.return_value = data\n assert products.get(None, \"fake-file-name\", False, False)\n request.fetch.assert_called_with(\"https://scc.suse.com/api/package_search/products\")",
"def test_load_book_details(self, mock_get):\n\n c = Client()\n data = {\n 'search_type': self.filter_subject,\n 'search_value': self.subject,\n }\n response = c.get('/taric_books/%s/' % self.ISBN)\n\n self.assertEqual(response.status_code, 200)",
"def test_retrieve_successsfully(self):\n create_sample_recipe(user=self.user)\n create_sample_recipe(user=self.user, title='Snack')\n\n recipes = Recipe.objects.all().order_by('-id')\n serializer = RecipeSerializer(recipes, many=True)\n\n res = self.client.get(RECIPE_URL)\n\n self.assertEqual(serializer.data, res.data)\n self.assertEqual(res.status_code, status.HTTP_200_OK)"
] | [
"0.64861304",
"0.60452384",
"0.60298216",
"0.6010472",
"0.6002515",
"0.6002515",
"0.5930737",
"0.59229994",
"0.5865279",
"0.5826006",
"0.5802774",
"0.5802774",
"0.56953853",
"0.568463",
"0.56727046",
"0.56668943",
"0.56484073",
"0.56198096",
"0.56014913",
"0.5600095",
"0.5565852",
"0.5529819",
"0.5511538",
"0.5501881",
"0.55010056",
"0.54968446",
"0.54958725",
"0.5483249",
"0.54816705",
"0.54626405",
"0.54493016",
"0.54483634",
"0.5443088",
"0.5435942",
"0.54358065",
"0.5430933",
"0.54233193",
"0.5415565",
"0.5410333",
"0.54020315",
"0.53933793",
"0.5393209",
"0.53892994",
"0.5387123",
"0.5384388",
"0.5376054",
"0.53737855",
"0.5368577",
"0.53684986",
"0.5366465",
"0.5359382",
"0.5356515",
"0.5354101",
"0.5353258",
"0.5348225",
"0.5340782",
"0.5328387",
"0.5327537",
"0.5320508",
"0.5296314",
"0.5290321",
"0.5286185",
"0.52824634",
"0.5281869",
"0.5281785",
"0.52807564",
"0.52680105",
"0.5266461",
"0.5265566",
"0.526057",
"0.5256725",
"0.5255079",
"0.52541316",
"0.52431643",
"0.523907",
"0.5238525",
"0.5238321",
"0.52356374",
"0.5232471",
"0.52285856",
"0.52270675",
"0.5221084",
"0.52185136",
"0.52173257",
"0.5215994",
"0.5215994",
"0.5215994",
"0.5212941",
"0.5211453",
"0.52081716",
"0.520748",
"0.5206783",
"0.51967376",
"0.5184957",
"0.51826775",
"0.5178656",
"0.5175612",
"0.51739854",
"0.5172618",
"0.516812"
] | 0.68666345 | 0 |
This test checks a tracked manufactured product will go to location defined in putaway strategy when the production is recorded with product.produce wizard. | def test_putaway_after_manufacturing_3(self):
self.laptop.tracking = 'serial'
mo_laptop = self.new_mo_laptop()
serial = self.env['stock.production.lot'].create({'product_id': self.laptop.id, 'company_id': self.env.company.id})
mo_form = Form(mo_laptop)
mo_form.qty_producing = 1
mo_form.lot_producing_id = serial
mo_laptop = mo_form.save()
mo_laptop.button_mark_done()
# We check if the laptop go in the depot and not in the stock
move = mo_laptop.move_finished_ids
location_dest = move.move_line_ids.location_dest_id
self.assertEqual(location_dest.id, self.depot_location.id)
self.assertNotEqual(location_dest.id, self.stock_location.id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_generate_with_putaway(self):\n nbre_of_lines = 4\n shelf_location = self.env['stock.location'].create({\n 'name': 'shelf1',\n 'usage': 'internal',\n 'location_id': self.location_dest.id,\n })\n\n # Checks a first time without putaway...\n move = self.get_new_move(nbre_of_lines)\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n ))\n form_wizard.next_serial_count = nbre_of_lines\n form_wizard.next_serial_number = '001'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n\n for move_line in move.move_line_nosuggest_ids:\n self.assertEqual(move_line.qty_done, 1)\n # The location dest must be the default one.\n self.assertEqual(move_line.location_dest_id.id, self.location_dest.id)\n\n # We need to activate multi-locations to use putaway rules.\n grp_multi_loc = self.env.ref('stock.group_stock_multi_locations')\n self.env.user.write({'groups_id': [(4, grp_multi_loc.id)]})\n # Creates a putaway rule\n putaway_product = self.env['stock.putaway.rule'].create({\n 'product_id': self.product_serial.id,\n 'location_in_id': self.location_dest.id,\n 'location_out_id': shelf_location.id,\n })\n\n # Checks now with putaway...\n move = self.get_new_move(nbre_of_lines)\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n ))\n form_wizard.next_serial_count = nbre_of_lines\n form_wizard.next_serial_number = '001'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n\n for move_line in move.move_line_nosuggest_ids:\n self.assertEqual(move_line.qty_done, 1)\n # The location dest must be now the one from the putaway.\n self.assertEqual(move_line.location_dest_id.id, shelf_location.id)",
"def test_manufacturing_scrap(self):\n\n # Update demo products\n (self.product_4 | self.product_2).write({\n 'tracking': 'lot',\n })\n\n # Update Bill Of Material to remove product with phantom bom.\n self.bom_3.bom_line_ids.filtered(lambda x: x.product_id == self.product_5).unlink()\n\n # Create Inventory Adjustment For Stick and Stone Tools with lot.\n lot_product_4 = self.env['stock.production.lot'].create({\n 'name': '0000000000001',\n 'product_id': self.product_4.id,\n 'company_id': self.env.company.id,\n })\n lot_product_2 = self.env['stock.production.lot'].create({\n 'name': '0000000000002',\n 'product_id': self.product_2.id,\n 'company_id': self.env.company.id,\n })\n\n stock_inv_product_4 = self.env['stock.inventory'].create({\n 'name': 'Stock Inventory for Stick',\n 'product_ids': [(4, self.product_4.id)],\n 'line_ids': [\n (0, 0, {'product_id': self.product_4.id, 'product_uom_id': self.product_4.uom_id.id, 'product_qty': 8, 'prod_lot_id': lot_product_4.id, 'location_id': self.stock_location_14.id}),\n ]})\n\n stock_inv_product_2 = self.env['stock.inventory'].create({\n 'name': 'Stock Inventory for Stone Tools',\n 'product_ids': [(4, self.product_2.id)],\n 'line_ids': [\n (0, 0, {'product_id': self.product_2.id, 'product_uom_id': self.product_2.uom_id.id, 'product_qty': 12, 'prod_lot_id': lot_product_2.id, 'location_id': self.stock_location_14.id})\n ]})\n (stock_inv_product_4 | stock_inv_product_2)._action_start()\n stock_inv_product_2.action_validate()\n stock_inv_product_4.action_validate()\n\n #Create Manufacturing order.\n production_form = Form(self.env['mrp.production'])\n production_form.product_id = self.product_6\n production_form.bom_id = self.bom_3\n production_form.product_qty = 12\n production_form.product_uom_id = self.product_6.uom_id\n production_3 = production_form.save()\n production_3.action_confirm()\n production_3.action_assign()\n\n # Check Manufacturing order's availability.\n self.assertEqual(production_3.reservation_state, 'assigned', \"Production order's availability should be Available.\")\n\n location_id = production_3.move_raw_ids.filtered(lambda x: x.state not in ('done', 'cancel')) and production_3.location_src_id.id or production_3.location_dest_id.id,\n\n # Scrap Product Wood without lot to check assert raise ?.\n scrap_id = self.env['stock.scrap'].with_context(active_model='mrp.production', active_id=production_3.id).create({'product_id': self.product_2.id, 'scrap_qty': 1.0, 'product_uom_id': self.product_2.uom_id.id, 'location_id': location_id, 'production_id': production_3.id})\n with self.assertRaises(UserError):\n scrap_id.do_scrap()\n\n # Scrap Product Wood with lot.\n self.env['stock.scrap'].with_context(active_model='mrp.production', active_id=production_3.id).create({'product_id': self.product_2.id, 'scrap_qty': 1.0, 'product_uom_id': self.product_2.uom_id.id, 'location_id': location_id, 'lot_id': lot_product_2.id, 'production_id': production_3.id})\n\n #Check scrap move is created for this production order.\n #TODO: should check with scrap objects link in between",
"def test_buy_now(self):\n catalog_page = CatalogPage(self.driver)\n product_page = ProductPage(self.driver)\n payment_page = PaymentPage(self.driver)\n payment_review_page = PaymentReviewPage(self.driver)\n payment_info_page = PaymentInfoPage(self.driver)\n success_page = SuccessPage(self.driver)\n # buy the new product\n navigate_to(self.driver, ProductPage.URL(self.new_product['product']['title']))\n product_page.add_to_cart.click()\n # by an old product\n catalog_page.catalog.click()\n # Sort products to move the newly created to last page\n catalog_page.sorting_order.select_by_visible_text(\"Date, old to new\")\n catalog_page.image.random_click()\n product = product_page.product.get_text()\n product_page.add_to_cart.click()\n catalog_page.catalog.click()\n catalog_page.cart.click()\n payment_dic = {\n 'address' : f'{randint(1, 99999)} {random_name(5, 8)}',\n 'city' : \"San Francisco\",\n 'email_or_mobile_phone_number_input' : random_name(8) + \"@gmail.com\",\n 'last_name' : random_name(3, 12),\n 'zip_code' : '94107',\n }\n if randint(0, 1):\n payment_dic['first_name'] = random_name(4, 16)\n if randint(0, 1):\n payment_dic['address2'] = random_name(5)\n for _ in payment_dic:\n exec(f\"payment_page.{_}.enter(payment_dic['{_}'])\")\n payment_page.continue_to_shipping.click()\n payment_review_page.continue_to_payment.click()\n payment_info_page.full_address.get_text()\n # validate address\n for _ in ['address', 'city', 'zip_code']:\n assert_and_log(payment_dic[_] in payment_info_page.full_address.get_text(),\n f\"{_} in full address\")\n payment_info_page.enter_bogus_payment(1)\n assert_and_log(success_page.thank_you.find_visible_element(),\n \"'Thank you' appeared as a sign of successful transaction\",\n continue_on_error=False)\n validate(success_page.basic_validation_list)",
"def test_single_quant_non_default_locations(self):\n pick = self.quant_1.create_picking(\n self.picking_type_pick,\n location_id=self.test_stock_location_01.id,\n location_dest_id=self.test_goodsout_location_02.id,\n )\n # Confirm default location used if non specified\n self.assertEqual(pick.location_id, self.test_stock_location_01)\n self.assertNotEqual(pick.location_id, self.picking_type_pick.default_location_src_id)\n # Confirm default dest location used if non specified\n self.assertEqual(pick.location_dest_id, self.test_goodsout_location_02)\n self.assertNotEqual(pick.location_id, self.picking_type_pick.default_location_dest_id)",
"def test_updateLocationInL4NewInL3(self):\n sel = self.selenium\n # Login\n self.login()\n # Load the Shelter\n self.open_record(\"Shelter within L4 Location\")\n\n # Check that the location is set\n self.assertEqual(\"Specific Location in L4\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n location = sel.get_attribute(\"//a[starts-with(@onclick, 's3_viewMap')]/@onclick\")\n location_id = location.split(\"(\")[1].split(\")\")[0]\n self.assertEqual(location_id, sel.get_value(\"cr_shelter_location_id\"))\n # Check that the dropdown is set\n self.assertEqual(location_id, sel.get_value(\"gis_location_\"))\n\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_L2\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L2\"))\n self.failUnless(sel.is_visible(\"gis_location_L3\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L3\"))\n self.failUnless(sel.is_visible(\"gis_location_L4\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L4\"))\n self.failUnless(sel.is_visible(\"gis_location_\"))\n self.failUnless(sel.is_visible(\"gis_location_label_\"))\n self.failUnless(sel.is_visible(\"gis_location_details-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_add-btn\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"cr_shelter_location_id\"))\n self.failIf(sel.is_visible(\"gis_location_name\"))\n self.failIf(sel.is_visible(\"gis_location_name_label\"))\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failIf(sel.is_visible(\"gis_location_map-btn\"))\n self.failIf(sel.is_visible(\"gis_location_advanced_div\"))\n\n # Select the L3\n sel.select(\"gis_location_L3\", \"label=Turgeau\")\n # Check that L4 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Babiole\", sel.get_table(\"//div[@id='content']/div[2]/form/table.17.0\"))\n\n # Click on the Add button\n sel.click(\"gis_location_add-btn\")\n # Check that the components appear correctly\n self.failUnless(sel.is_visible(\"gis_location_name\"))\n self.failUnless(sel.is_visible(\"gis_location_name_label\"))\n self.failUnless(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failUnless(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failUnless(sel.is_visible(\"gis_location_map-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_advanced_div\"))\n # Check that components which should remain invisible, are\n self.failIf(sel.is_visible(\"gis_location_lat_row\"))\n self.failIf(sel.is_visible(\"gis_location_lon_row\"))\n\n # Fill in a Name & Address\n sel.type(\"gis_location_name\", \"New in L3\")\n sel.type(\"gis_location_addr_street\", \"5 Ruelle Chochotte\")\n\n # Open the Advanced Tab\n sel.click(\"gis_location_advanced_checkbox\")\n # Check that the components appear correctly\n self.failUnless(sel.is_visible(\"gis_location_lat_row\"))\n self.failUnless(sel.is_visible(\"gis_location_lon_row\"))\n\n # Fill in Lat & Lon\n sel.type(\"gis_location_lat\", \"18.53171116\")\n sel.type(\"gis_location_lon\", \"-72.33020758\")\n\n # Save the form (with changes)\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter updated\")\n # Shelter has correct location\n self.assertEqual(\"New in L3 (N 18.53171116 W -72.33020758)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n\n # Load again\n self.open_record(\"Shelter within L4 Location\")\n # Check that the location is set\n self.assertEqual(\"New in L3 (N 18.53171116 W -72.33020758)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n location = sel.get_attribute(\"//a[starts-with(@onclick, 's3_viewMap')]/@onclick\")\n location_id = location.split(\"(\")[1].split(\")\")[0]\n self.assertEqual(location_id, sel.get_value(\"cr_shelter_location_id\"))\n # Check that the dropdown is set\n self.assertEqual(location_id, sel.get_value(\"gis_location_\"))\n\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_L2\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L2\"))\n self.failUnless(sel.is_visible(\"gis_location_L3\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L3\"))\n self.failUnless(sel.is_visible(\"gis_location_L4\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L4\"))\n self.failUnless(sel.is_visible(\"gis_location_\"))\n self.failUnless(sel.is_visible(\"gis_location_label_\"))\n self.failUnless(sel.is_visible(\"gis_location_details-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_add-btn\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"cr_shelter_location_id\"))\n self.failIf(sel.is_visible(\"gis_location_name\"))\n self.failIf(sel.is_visible(\"gis_location_name_label\"))\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failIf(sel.is_visible(\"gis_location_map-btn\"))\n self.failIf(sel.is_visible(\"gis_location_advanced_div\"))\n self.failIf(sel.is_visible(\"gis_location_lat_row\"))\n self.failIf(sel.is_visible(\"gis_location_lon_row\"))\n\n # Click on 'Details' button\n sel.click(\"gis_location_details-btn\")\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failUnless(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failUnless(sel.is_visible(\"gis_location_map-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_advanced_div\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_lat_row\"))\n self.failIf(sel.is_visible(\"gis_location_lon_row\"))\n\n # Check that the Street Address is populated\n self.assertEqual(\"5 Ruelle Chochotte\", sel.get_text(\"gis_location_addr_street\"))\n\n # Open the Advanced Tab\n sel.click(\"gis_location_advanced_checkbox\")\n # Check that the components appear correctly\n self.failUnless(sel.is_visible(\"gis_location_lat_row\"))\n self.failUnless(sel.is_visible(\"gis_location_lon_row\"))\n\n # Check that the Lat/Lon are populated\n self.assertEqual(\"18.53171116\", sel.get_value(\"gis_location_lat\"))\n self.assertEqual(\"-72.33020758\", sel.get_value(\"gis_location_lon\"))",
"def test_locationInL0(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter within L0 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Create a new location\n sel.click(\"gis_location_add-btn\")\n sel.type(\"gis_location_name\", \"Specific Location in L0\")\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Specific Location in L0\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_update_goal(self):\n pass",
"def test_locationInL2(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter within L2 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Select the L1\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Select the L2\n sel.select(\"gis_location_L2\", \"label=Port-Au-Prince\")\n # Check that L3 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...MartissantTurgeau\", sel.get_table(\"//div[@id='content']/div[2]/form/table.15.0\"))\n # Create a new location\n sel.click(\"gis_location_add-btn\")\n sel.type(\"gis_location_name\", \"Specific Location in L2\")\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Specific Location in L2\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_product_produce_3_with_analytic(self):\n acc = self.env['account.account'].search([('code', '=', '115.01.01')])\n self.env.ref('product.product_category_all').write(\n {'property_valuation': 'real_time',\n 'property_stock_account_input_categ_id': acc.id,\n 'property_stock_account_output_categ_id': acc.id})\n self.test_product_produce_3()\n move_obj = self.env['account.move']\n self.assertTrue(\n (self.last_mo.account_analytic_in_id |\n self.last_mo.account_analytic_out_id),\n 'The MO does not have account analytic')\n for fmove in self.last_mo.move_finished_ids:\n # Checking analytic account\n am = move_obj.search([('stock_move_id', '=', fmove.id)])\n # Looking for the Journal entry related\n self.assertTrue(am, 'The move does not have an entry related')\n line = am.line_ids.filtered(\n lambda a: a.analytic_account_id ==\n self.last_mo.account_analytic_out_id)\n # It should have only one line with the same analytic\n self.assertEqual(\n len(line), 1,\n 'There is more than one line with the same analytic')\n # The line must have debit\n self.assertTrue(line.credit > 0)\n\n for fmove in self.last_mo.move_raw_ids:\n # Checking analytic account\n am = move_obj.search([('stock_move_id', '=', fmove.id)])\n # Looking for the Journal entry related\n self.assertTrue(am, 'The move does not have an entry related')\n line = am.line_ids.filtered(\n lambda a: a.analytic_account_id ==\n self.last_mo.account_analytic_in_id)\n # It should have only one line with the same analytic\n self.assertEqual(\n len(line), 1,\n 'There is more than one line with the same analytic')\n # The line must have credit\n self.assertTrue(line.debit > 0)",
"def test_locationInL3(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter within L3 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Select the L1\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Select the L2\n sel.select(\"gis_location_L2\", \"label=Port-Au-Prince\")\n # Check that L3 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...MartissantTurgeau\", sel.get_table(\"//div[@id='content']/div[2]/form/table.15.0\"))\n # Select the L3\n sel.select(\"gis_location_L3\", \"label=Martissant\")\n # Check that L4 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Carrefour Feuilles\", sel.get_table(\"//div[@id='content']/div[2]/form/table.17.0\"))\n # Create a new location\n sel.click(\"gis_location_add-btn\")\n sel.type(\"gis_location_name\", \"Specific Location in L3\")\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Specific Location in L3\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_locationL2(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter with an L2 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Select the L1\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Select the L2\n sel.select(\"gis_location_L2\", \"label=Port-Au-Prince\")\n # Check that L3 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...MartissantTurgeau\", sel.get_table(\"//div[@id='content']/div[2]/form/table.15.0\"))\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Port-Au-Prince (Ouest)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_locationInL1(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter within L1 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Select the L1\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Create a new location\n sel.click(\"gis_location_add-btn\")\n sel.type(\"gis_location_name\", \"Specific Location in L1\")\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Specific Location in L1\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_locationL0(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter with an L0 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Haiti\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_updateLocationEmptyL0(self):\n sel = self.selenium\n # Login\n self.login()\n # Load the Shelter\n self.open_record(\"Shelter with no Location\")\n # Check that the location is currently blank\n self.check_blank()\n\n # Save the form (without changes)\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter updated\")\n # Shelter has correct location\n self.assertEqual(\"-\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n\n # Load again\n self.open_record(\"Shelter with no Location\")\n # Check that the location is still blank\n self.check_blank()\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Save the form (with changes)\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter updated\")\n # Shelter has correct location\n self.assertEqual(\"Haiti\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n\n # Load again\n self.open_record(\"Shelter with no Location\")\n # Check that the location is set\n self.assertEqual(\"Haiti\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n location = sel.get_attribute(\"//a[starts-with(@onclick, 's3_viewMap')]/@onclick\")\n location_id = location.split(\"(\")[1].split(\")\")[0]\n self.assertEqual(location_id, sel.get_value(\"cr_shelter_location_id\"))\n # Check that the dropdown is set\n self.assertEqual(location_id, sel.get_value(\"gis_location_L0\"))\n\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_add-btn\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"cr_shelter_location_id\"))\n self.failIf(sel.is_visible(\"gis_location_L2\"))\n self.failIf(sel.is_visible(\"gis_location_label_L2\"))\n self.failIf(sel.is_visible(\"gis_location_L3\"))\n self.failIf(sel.is_visible(\"gis_location_label_L3\"))\n self.failIf(sel.is_visible(\"gis_location_L4\"))\n self.failIf(sel.is_visible(\"gis_location_label_L4\"))\n self.failIf(sel.is_visible(\"gis_location_\"))\n self.failIf(sel.is_visible(\"gis_location_label_\"))\n self.failIf(sel.is_visible(\"gis_location_name\"))\n self.failIf(sel.is_visible(\"gis_location_name_label\"))\n self.failIf(sel.is_visible(\"gis_location_details-btn\"))\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failIf(sel.is_visible(\"gis_location_map-btn\"))\n self.failIf(sel.is_visible(\"gis_location_advanced_div\"))",
"def test_locationL3(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter with an L3 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Select the L2\n sel.select(\"gis_location_L2\", \"label=Port-Au-Prince\")\n # Check that L3 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...MartissantTurgeau\", sel.get_table(\"//div[@id='content']/div[2]/form/table.15.0\"))\n # Select the L3\n sel.select(\"gis_location_L3\", \"label=Martissant\")\n # Check that L4 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Carrefour Feuilles\", sel.get_table(\"//div[@id='content']/div[2]/form/table.17.0\"))\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Martissant (Port-Au-Prince)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_locationL1(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter with an L1 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Select the L1\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Ouest (Haiti)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_households_in_admin_unit(self):",
"def test_update_location_premium(self):\n\n url = reverse('location-detail', args=(self.location.id,))\n data = {\n 'point': 200,\n }\n json_data = json.dumps(data)\n self.client.credentials(HTTP_AUTHORIZATION=self.token)\n response = self.client.put(path=url, content_type='application/json', data=json_data)\n self.assertEqual(first=400, second=response.status_code)",
"def test_post_activate_marketplace_vendor_v3(self):\n pass",
"def setUp(self):\n self.location = Location.get(TEST_LOCATION)",
"def test_updateLocationL0Empty(self):\n sel = self.selenium\n # Login\n self.login()\n # Load the Shelter\n self.open_record(\"Shelter with no Location\")\n # Check that the location is currently set\n self.assertEqual(\"Haiti\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n location = sel.get_attribute(\"//a[starts-with(@onclick, 's3_viewMap')]/@onclick\")\n location_id = location.split(\"(\")[1].split(\")\")[0]\n self.assertEqual(location_id, sel.get_value(\"cr_shelter_location_id\"))\n # Check that the dropdown is set\n self.assertEqual(location_id, sel.get_value(\"gis_location_L0\"))\n\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L1\"))\n self.failUnless(sel.is_visible(\"gis_location_add-btn\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"cr_shelter_location_id\"))\n self.failIf(sel.is_visible(\"gis_location_L2\"))\n self.failIf(sel.is_visible(\"gis_location_label_L2\"))\n self.failIf(sel.is_visible(\"gis_location_L3\"))\n self.failIf(sel.is_visible(\"gis_location_label_L3\"))\n self.failIf(sel.is_visible(\"gis_location_L4\"))\n self.failIf(sel.is_visible(\"gis_location_label_L4\"))\n self.failIf(sel.is_visible(\"gis_location_\"))\n self.failIf(sel.is_visible(\"gis_location_label_\"))\n self.failIf(sel.is_visible(\"gis_location_name\"))\n self.failIf(sel.is_visible(\"gis_location_name_label\"))\n self.failIf(sel.is_visible(\"gis_location_details-btn\"))\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failIf(sel.is_visible(\"gis_location_map-btn\"))\n self.failIf(sel.is_visible(\"gis_location_advanced_div\"))\n\n # De-select the L0\n sel.select(\"gis_location_L0\", \"label=Select a location...\")\n # Check that the real location has been set to blank\n self.assertEqual(\"\", sel.get_value(\"cr_shelter_location_id\"))\n # Check that L1 dropdown disappears correctly\n time.sleep(1)\n self.failIf(sel.is_visible(\"gis_location_L1\"))\n self.failIf(sel.is_visible(\"gis_location_label_L1\"))\n # Save the form (with changes)\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter updated\")\n # Shelter has correct location\n self.assertEqual(\"-\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_kit_planned_transfer(self):\n picking = self.env['stock.picking'].create({\n 'location_id': self.test_supplier.id,\n 'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,\n 'partner_id': self.test_partner.id,\n 'picking_type_id': self.env.ref('stock.picking_type_in').id,\n 'immediate_transfer': False,\n })\n move_receipt_1 = self.env['stock.move'].create({\n 'name': self.kit_parent.name,\n 'product_id': self.kit_parent.id,\n 'product_uom_qty': 3,\n 'product_uom': self.kit_parent.uom_id.id,\n 'picking_id': picking.id,\n 'picking_type_id': self.env.ref('stock.picking_type_in').id,\n 'location_id': self.test_supplier.id,\n 'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,\n })\n picking.action_confirm()\n\n # We check that the picking has the correct quantities after its move were splitted.\n self.assertEqual(len(picking.move_lines), 7)\n for move_line in picking.move_lines:\n self.assertEqual(move_line.product_qty, self.expected_quantities[move_line.product_id])",
"def test_locationInL4(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter within L4 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Select the L1\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Select the L2\n sel.select(\"gis_location_L2\", \"label=Port-Au-Prince\")\n # Check that L3 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...MartissantTurgeau\", sel.get_table(\"//div[@id='content']/div[2]/form/table.15.0\"))\n # Select the L3\n sel.select(\"gis_location_L3\", \"label=Martissant\")\n # Check that L4 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Carrefour Feuilles\", sel.get_table(\"//div[@id='content']/div[2]/form/table.17.0\"))\n # Select the L4\n sel.select(\"gis_location_L4\", \"label=Carrefour Feuilles\")\n # Check that specific location dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Clinique Communautaire de Martissant\", sel.get_table(\"//div[@id='content']/div[2]/form/table.19.0\"))\n # Create a new location\n sel.click(\"gis_location_add-btn\")\n sel.type(\"gis_location_name\", \"Specific Location in L4\")\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Specific Location in L4\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_search_product_detail(self, setup):\n product_id = self.nutella.id\n path = reverse('website:detail', args=(product_id,))\n assert resolve(path).view_name == 'website:detail'",
"def test_updateLocationNoParentL0(self):\n sel = self.selenium\n # Login\n self.login()\n # Load the Shelter\n self.open_record(\"Shelter with no Parent\")\n\n # Check that the location is set\n self.assertEqual(\"New parentless Location (N 51.0 E 1.0)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n location = sel.get_attribute(\"//a[starts-with(@onclick, 's3_viewMap')]/@onclick\")\n location_id = location.split(\"(\")[1].split(\")\")[0]\n self.assertEqual(location_id, sel.get_value(\"cr_shelter_location_id\"))\n # Check that the dropdown is set\n self.assertEqual(location_id, sel.get_value(\"gis_location_\"))\n\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_\"))\n self.failUnless(sel.is_visible(\"gis_location_label_\"))\n self.failUnless(sel.is_visible(\"gis_location_details-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_add-btn\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"cr_shelter_location_id\"))\n self.failIf(sel.is_visible(\"gis_location_L1\"))\n self.failIf(sel.is_visible(\"gis_location_label_L1\"))\n self.failIf(sel.is_visible(\"gis_location_L2\"))\n self.failIf(sel.is_visible(\"gis_location_label_L2\"))\n self.failIf(sel.is_visible(\"gis_location_L3\"))\n self.failIf(sel.is_visible(\"gis_location_label_L3\"))\n self.failIf(sel.is_visible(\"gis_location_L4\"))\n self.failIf(sel.is_visible(\"gis_location_label_L4\"))\n self.failIf(sel.is_visible(\"gis_location_name\"))\n self.failIf(sel.is_visible(\"gis_location_name_label\"))\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failIf(sel.is_visible(\"gis_location_map-btn\"))\n self.failIf(sel.is_visible(\"gis_location_advanced_div\"))\n\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Save the form (with changes)\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter updated\")\n # Shelter has correct location\n self.assertEqual(\"Haiti\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_create_goal(self):\n pass",
"def test_create_shipment(self):\n pass",
"def test_training_location(self):\n self.assertIsInstance(self.one_off_training.location, Location)\n self.assertEqual(self.one_off_training.location, self.location)",
"def test_plant_harvest():\n plant = plant_factory()\n user = plant.user\n plant.user_active = user\n plant.harvest()\n assert plant.dead\n assert plant.user_active is None\n assert plant.get(user_active=user)",
"def test_post_voltage_maps(self):\n pass",
"def test_get_goal(self):\n pass",
"def test_if_fires_on_zone_appear(self):\n assert setup_component(self.hass, automation.DOMAIN, {\n automation.DOMAIN: {\n 'trigger': {\n 'platform': 'geo_location',\n 'source': 'test_source',\n 'zone': 'zone.test',\n 'event': 'enter',\n },\n 'action': {\n 'service': 'test.automation',\n 'data_template': {\n 'some': '{{ trigger.%s }}' % '}} - {{ trigger.'.join((\n 'platform', 'entity_id',\n 'from_state.state', 'to_state.state',\n 'zone.name'))\n },\n\n }\n }\n })\n\n # Entity appears in zone without previously existing outside the zone.\n context = Context()\n self.hass.states.set('geo_location.entity', 'hello', {\n 'latitude': 32.880586,\n 'longitude': -117.237564,\n 'source': 'test_source'\n }, context=context)\n self.hass.block_till_done()\n\n self.assertEqual(1, len(self.calls))\n assert self.calls[0].context is context\n self.assertEqual(\n 'geo_location - geo_location.entity - - hello - test',\n self.calls[0].data['some'])",
"def test_box_move(self) -> None:\n # starting box and target location\n box_number = 'BOX64346'\n target_location = '0409C2'\n bm = BoxManagementClass()\n\n # add a new box\n _ = bm.box_new(box_number=box_number, box_type=2)\n\n # fill it\n location = '0101A1'\n product = 'Corn'\n exp_year = 2022\n exp_mo_start = 0\n exp_mo_end = 0\n box_rec = Box.objects.select_related('box_type', ).get(\n box_number=box_number)\n location_rec = Location.objects.get(loc_code=location)\n product_rec = Product.objects.get(prod_name=product)\n _ = bm.box_fill(\n box=box_rec,\n location=location_rec,\n product=product_rec,\n exp_year=exp_year,\n exp_mo_start=exp_mo_start,\n exp_mo_end=exp_mo_end\n )\n\n # get the box just created and filled\n box_rec = Box.objects.select_related(\n 'box_type',\n 'product',\n 'product__prod_cat',\n ).get(box_number=box_number)\n box_type_rec = box_rec.box_type\n product_rec = box_rec.product\n prod_cat_rec = product_rec.prod_cat\n exp_year = box_rec.exp_year\n exp_mo_start = box_rec.exp_month_start\n exp_mo_end = box_rec.exp_month_end\n date_time_filled = box_rec.date_filled\n date_filled = date_time_filled.date()\n\n # get the location record and associates for the target location\n location_rec = Location.objects.select_related(\n 'loc_row',\n 'loc_bin',\n 'loc_tier',\n ).get(loc_code=target_location)\n loc_row_rec = location_rec.loc_row\n loc_bin_rec = location_rec.loc_bin\n loc_tier_rec = location_rec.loc_tier\n\n # move the box to a new location and save changes\n box_moved = bm.box_move(box_rec, location_rec)\n\n assert box_moved.box_number == box_number\n assert box_moved.box_type == box_type_rec\n assert box_moved.location == location_rec\n assert box_moved.product == product_rec\n assert box_moved.exp_year == exp_year\n assert box_moved.exp_month_start == exp_mo_start\n assert box_moved.exp_month_end == exp_mo_end\n assert box_moved.date_filled == date_time_filled\n assert box_moved.quantity == box_type_rec.box_type_qty\n\n # find the corresponding activity record\n act_moved = Activity.objects.filter(\n box_number__exact=box_number,\n date_filled__exact=date_filled,\n ).latest('-date_consumed')\n\n # box number part of filter above\n assert act_moved.box_type == box_type_rec.box_type_code\n assert act_moved.loc_row == loc_row_rec.loc_row\n assert act_moved.loc_bin == loc_bin_rec.loc_bin\n assert act_moved.loc_tier == loc_tier_rec.loc_tier\n assert act_moved.prod_name == product_rec.prod_name\n assert act_moved.prod_cat_name == prod_cat_rec.prod_cat_name\n # date filled part of filter above\n assert act_moved.date_consumed is None\n assert act_moved.exp_year == exp_year\n assert act_moved.exp_month_start == exp_mo_start\n assert act_moved.exp_month_end == exp_mo_end\n assert act_moved.quantity == box_type_rec.box_type_qty\n assert act_moved.duration == 0\n assert act_moved.adjustment_code is None\n return",
"def test_locationL4(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter with an L4 Location\")\n # Select the L0\n sel.select(\"gis_location_L0\", \"label=Haiti\")\n # Check that L1 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Ouest\", sel.get_table(\"//div[@id='content']/div[2]/form/table.11.0\"))\n # Select the L1\n sel.select(\"gis_location_L1\", \"label=Ouest\")\n # Check that L2 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Port-Au-Prince\", sel.get_table(\"//div[@id='content']/div[2]/form/table.13.0\"))\n # Select the L2\n sel.select(\"gis_location_L2\", \"label=Port-Au-Prince\")\n # Check that L3 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...MartissantTurgeau\", sel.get_table(\"//div[@id='content']/div[2]/form/table.15.0\"))\n # Select the L3\n sel.select(\"gis_location_L3\", \"label=Martissant\")\n # Check that L4 dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Carrefour Feuilles\", sel.get_table(\"//div[@id='content']/div[2]/form/table.17.0\"))\n # Select the L4\n sel.select(\"gis_location_L4\", \"label=Carrefour Feuilles\")\n # Check that 'L5' dropdown appears correctly\n time.sleep(4)\n self.assertEqual(\"Select a location...Clinique Communautaire de Martissant\", sel.get_table(\"//div[@id='content']/div[2]/form/table.19.0\"))\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")\n # Shelter has correct location\n self.assertEqual(\"Carrefour Feuilles\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_check_user_location_and_goal_location_match_state_and_next_state():\n for _ in range(50):\n env = Four_Rooms_Environment()\n env.reset()\n for _ in range(50):\n move = randint(0, 3)\n env.step(move)\n assert env.state == [env.location_to_state(env.current_user_location), env.location_to_state(env.current_goal_location)]\n assert env.next_state == [env.location_to_state(env.current_user_location), env.location_to_state(env.current_goal_location)]",
"def _test_set_new_pos(self):\n self.p.setup(siteInfo={}, source=None, device=self.device)\n time.sleep(0.3) if self.using_mock else time.sleep(3)\n act_position = self.device.getActPosition()\n offset = 0.5\n self.p.setOffset(offset)\n time.sleep(0.3) if self.using_mock else time.sleep(3)\n self.assertAlmostEqual(\n self.p.getPosition(), \n act_position + offset, \n places=1\n )\n self.assertAlmostEqual(\n act_position + offset, \n self.device.getActPosition(), \n places=1\n )",
"def test_location(self):\n self.assertEqual(self.show.country, 'USA')\n self.assertEqual(self.show.state, 'VA')\n self.assertEqual(self.show.city, 'Hampton')",
"def testUpdateLocation(self):\n change = ChangeState(self.config, \"changestate_t\")\n\n locationAction = self.daoFactory(classname=\"Locations.New\")\n locationAction.execute(\"site1\", pnn=\"T2_CH_CERN\")\n locationAction.execute(\"site2\", pnn=\"T1_US_FNAL_Disk\")\n\n testWorkflow = Workflow(spec=self.specUrl, owner=\"Steve\",\n name=\"wf001\", task=self.taskName)\n testWorkflow.create()\n testFileset = Fileset(name=\"TestFileset\")\n testFileset.create()\n testSubscription = Subscription(fileset=testFileset,\n workflow=testWorkflow,\n split_algo=\"FileBased\")\n testSubscription.create()\n\n testFileA = File(lfn=\"SomeLFNA\", events=1024, size=2048,\n locations=set([\"T2_CH_CERN\", \"T1_US_FNAL_Disk\"]))\n testFileB = File(lfn=\"SomeLFNB\", events=1025, size=2049,\n locations=set([\"T2_CH_CERN\", \"T1_US_FNAL_Disk\"]))\n testFileA.create()\n testFileB.create()\n\n testFileset.addFile(testFileA)\n testFileset.addFile(testFileB)\n testFileset.commit()\n\n splitter = SplitterFactory()\n jobFactory = splitter(package=\"WMCore.WMBS\",\n subscription=testSubscription)\n jobGroup = jobFactory(files_per_job=1)[0]\n\n assert len(jobGroup.jobs) == 2, \\\n \"Error: Splitting should have created two jobs.\"\n\n testJobA = jobGroup.jobs[0]\n testJobA[\"user\"] = \"sfoulkes\"\n testJobA[\"group\"] = \"DMWM\"\n testJobA[\"taskType\"] = \"Merge\"\n testJobA[\"site_cms_name\"] = \"site1\"\n testJobB = jobGroup.jobs[1]\n testJobB[\"user\"] = \"sfoulkes\"\n testJobB[\"group\"] = \"DMWM\"\n testJobB[\"taskType\"] = \"Processing\"\n testJobB[\"site_cms_name\"] = \"site2\"\n\n change.propagate([testJobA, testJobB], \"new\", \"none\")\n change.propagate([testJobA, testJobB], \"created\", \"new\")\n change.propagate([testJobA, testJobB], \"executing\", \"created\")\n\n testJobADoc = change.jobsdatabase.document(testJobA[\"couch_record\"])\n\n maxKey = max(testJobADoc[\"states\"].keys())\n transition = testJobADoc[\"states\"][maxKey]\n self.assertEqual(transition[\"location\"], \"site1\")\n\n testJobBDoc = change.jobsdatabase.document(testJobB[\"couch_record\"])\n\n maxKey = max(testJobBDoc[\"states\"].keys())\n transition = testJobBDoc[\"states\"][maxKey]\n self.assertEqual(transition[\"location\"], \"site2\")\n\n jobs = [{'jobid': 1, 'location': 'site2'}]\n\n change.recordLocationChange(jobs)\n\n testJobADoc = change.jobsdatabase.document(testJobA[\"couch_record\"])\n\n maxKey = max(testJobADoc[\"states\"].keys())\n transition = testJobADoc[\"states\"][maxKey]\n self.assertEqual(transition[\"location\"], \"site2\")\n\n listJobsDAO = self.daoFactory(classname=\"Jobs.GetLocation\")\n jobid = [{'jobid': 1}, {'jobid': 2}]\n jobsLocation = listJobsDAO.execute(jobid)\n for job in jobsLocation:\n self.assertEqual(job['site_name'], 'site2')\n\n return",
"def location_fixture():\n return _create_location()",
"def test_update_goal_metric(self):\n pass",
"def test_06_replacement_product_wizard(self):\n # Create a purchase order with two lines.\n order = self.create_po()\n sellable_product = self.product_obj.browse(self.sellable_product)\n draft_product = self.product_obj.browse(self.draft_product)\n self.create_pol(order, sellable_product)\n self.create_pol(order, draft_product)\n self.assertNotIn('obsolete',\n order.order_line.mapped('product_id.state2'))\n\n # Update sellable product to obsolete\n # NOTE: This check check the write() method of the product.product\n # record.\n self.assertIn(sellable_product, order.order_line.mapped('product_id'))\n self.assertEqual(sellable_product.state2, 'sellable')\n sellable_product.state2 = 'obsolete'\n self.assertEqual(sellable_product.state2, 'obsolete')\n\n # Check that the purchase order line now have a obsolete line.\n obsolete_order_line = order.order_line.filtered(\n lambda line: line.product_id.state2 == 'obsolete')\n self.assertTrue(obsolete_order_line)\n self.assertEqual(obsolete_order_line.product_id, sellable_product)\n\n # Simulate click on the \"Check Discontinued Products\" button to run the\n # replacemenet product wizard.\n wiz = self.wiz_obj.with_context({\n 'active_id': order.id,\n 'active_ids': [order.id],\n 'active_model': 'purchase.order',\n }).create({})\n\n # Chech that the wizard auto create correctly the replacement lines.\n # The replacement line must be linked/generate to the obsolete purchase\n # order line.\n self.assertTrue(wiz.lines)\n self.assertEqual(len(wiz.lines), 1)\n self.assertEqual(obsolete_order_line, wiz.lines.mapped('line_id'))\n\n # TODO add a case to try to add a new replacement line manually. this\n # must be fail.\n\n # Try to add an obsolete replacement product in the replacement line.\n # This will raise an exception becuase only not obsolete products can\n # be used as a valid replacement.\n wiz_line = wiz.lines[0]\n with self.assertRaises(exceptions.ValidationError):\n wiz_line.replacement_product_id = self.obsolete_replacement\n\n # Add a sellable replacement product in the replacement line.\n wiz_line.replacement_product_id = self.sellable_replacement\n self.assertEqual(wiz_line.replacement_product_id.id,\n self.sellable_replacement)\n\n # Make the replacement in the purchase order by clicking the button\n # \"Replace\" in the replacement wizard and check that the changes were\n # applied to the purchase order line.\n wiz.replacement()\n self.assertEqual(obsolete_order_line.product_id,\n wiz_line.replacement_product_id)\n self.assertEqual(obsolete_order_line.discontinued_product_id,\n wiz_line.discontinued_product_id)",
"async def test_setup_with_custom_location(hass: HomeAssistant) -> None:\n # Set up some mock feed entries for this test.\n mock_entry_1 = _generate_mock_feed_entry(\n \"1234\", \"Title 1\", 20.5, (38.1, -3.1), category=\"Category 1\"\n )\n\n with patch(\"georss_qld_bushfire_alert_client.QldBushfireAlertFeed\") as mock_feed:\n mock_feed.return_value.update.return_value = \"OK\", [mock_entry_1]\n\n with assert_setup_component(1, geo_location.DOMAIN):\n assert await async_setup_component(\n hass, geo_location.DOMAIN, CONFIG_WITH_CUSTOM_LOCATION\n )\n await hass.async_block_till_done()\n\n # Artificially trigger update.\n hass.bus.async_fire(EVENT_HOMEASSISTANT_START)\n # Collect events.\n await hass.async_block_till_done()\n\n all_states = hass.states.async_all()\n assert len(all_states) == 1\n\n assert mock_feed.call_args == call(\n (40.4, -3.7), filter_categories=[], filter_radius=200.0\n )",
"def test_location(self):\n self.assertEqual(self.show.country, None)\n self.assertEqual(self.show.state, None)\n self.assertEqual(self.show.country, None)",
"def record_location(data):\n product = OrderDetail.objects.get(ac_od_id=data['ac_od_id'])\n product.location = data['location']\n return product.save()",
"def test_actionWithTargetInAdjacentDarkRoom(self):\n self.otherRoom = objects.Thing(store=self.store, name=u'Elsewhere')\n objects.Container.createFor(self.otherRoom, capacity=1000)\n objects.Exit.link(self.location, self.otherRoom, u'west')\n self.player.moveTo(self.otherRoom)\n self.observer.moveTo(self.otherRoom)\n self.assertCommandOutput(\n \"wear pants\",\n [commandutils.E(u\"Who's that?\")],\n [])",
"def test_if_fires_on_zone_enter(self):\n context = Context()\n self.hass.states.set('geo_location.entity', 'hello', {\n 'latitude': 32.881011,\n 'longitude': -117.234758,\n 'source': 'test_source'\n })\n self.hass.block_till_done()\n\n assert setup_component(self.hass, automation.DOMAIN, {\n automation.DOMAIN: {\n 'trigger': {\n 'platform': 'geo_location',\n 'source': 'test_source',\n 'zone': 'zone.test',\n 'event': 'enter',\n },\n 'action': {\n 'service': 'test.automation',\n 'data_template': {\n 'some': '{{ trigger.%s }}' % '}} - {{ trigger.'.join((\n 'platform', 'entity_id',\n 'from_state.state', 'to_state.state',\n 'zone.name'))\n },\n\n }\n }\n })\n\n self.hass.states.set('geo_location.entity', 'hello', {\n 'latitude': 32.880586,\n 'longitude': -117.237564\n }, context=context)\n self.hass.block_till_done()\n\n self.assertEqual(1, len(self.calls))\n assert self.calls[0].context is context\n self.assertEqual(\n 'geo_location - geo_location.entity - hello - hello - test',\n self.calls[0].data['some'])\n\n # Set out of zone again so we can trigger call\n self.hass.states.set('geo_location.entity', 'hello', {\n 'latitude': 32.881011,\n 'longitude': -117.234758\n })\n self.hass.block_till_done()\n\n common.turn_off(self.hass)\n self.hass.block_till_done()\n\n self.hass.states.set('geo_location.entity', 'hello', {\n 'latitude': 32.880586,\n 'longitude': -117.237564\n })\n self.hass.block_till_done()\n\n self.assertEqual(1, len(self.calls))",
"def move_to_location(cardinal_point):\r\n\r\n\ttry:\r\n\r\n\t\told_room = config[\"GAMEDATA\"][\"CURRENTZONE\"]\r\n\t\tnew_room = world.WORLD_ROOMS[old_room][cardinal_point]\r\n\t\t\r\n\t\tif new_room == None:\r\n\t\t\ttprint(\"You cannot go there.\")\r\n\t\t\treturn\r\n\r\n\t\t\r\n\t\tnew_room_name = getstring(world.WORLD_ROOMS[new_room][\"NAME\"])\r\n\t\t\r\n\t\tdebug(\"new_room = \" + str(new_room))\r\n\t\tdebug(\"new_room_name = \" + str(new_room_name))\r\n\r\n\t\tif world.WORLD_ROOMS[new_room][\"NEEDITEM\"] != None: # If an item is required to go there...\r\n\t\t\tcurrent_inventory = config[\"GAMEDATA\"][\"INVENTORY\"]\r\n\t\t\tneeded_item_id = world.WORLD_ITEMS[world.WORLD_ROOMS[new_room][\"NEEDITEM\"]][\"ID\"]\r\n\t\t\tneeded_item_name = world.WORLD_ITEMS[world.WORLD_ROOMS[new_room][\"NEEDITEM\"]][\"NAME\"]\r\n\t\t\t\r\n\t\t\tif current_inventory == None:\r\n\t\t\t\ttprint(\"You do not have the required item in your inventory,\")\r\n\t\t\t\ttprint(\"You need to have '\" + needed_item_name + \"'\")\r\n\t\t\t\treturn\r\n\t\t\t\t\r\n\t\t\telse: # Inventory isn't blank\r\n\t\t\t\tfor item_id in current_inventory:\r\n\t\t\t\t\tif item_id == needed_item_id: # If the player have the needed item in his inventory...\r\n\t\t\t\t\t\ttprint(\"You entered by using \" + needed_item_name)\r\n\t\t\t\t\t\ttprint(\"you are now at : \" + new_room_name)\r\n\t\t\t\t\t\tconfig[\"GAMEDATA\"][\"CURRENTZONE\"] = new_room\r\n\t\t\t\t\t\treturn # Exits the function\r\n\t\t\t\t\t\r\n\t\t\t\t# If we arrive here, this means that the player doesn't have the needed item.\r\n\t\t\t\ttprint(\"You do not have the required item in your inventory,\")\r\n\t\t\t\ttprint(\"You need to have '\" + needed_item_name + \"'\")\r\n\t\t\t\treturn\r\n\t\t\t\r\n\t\telse: # The room doesn't requires an item...\r\n\t\t\tconfig[\"GAMEDATA\"][\"CURRENTZONE\"] = new_room\r\n\t\t\ttprint(\"You are now at : \" + new_room_name)\r\n\t\t\treturn\r\n\t\r\n\texcept Exception as error: # If we arrive here, this means that there is a bug in there, oops.\r\n\t\tprint(\"ERROR! in function move_to_location() try block raised an exception !\")\r\n\t\tprint(str(error))\r\n\t\ttraceback.print_exc()\r\n\t\treturn",
"def test_location_model_link_1(self):\n with app.test_request_context():\n location1 = db.session.query(Location).first()\n launch1 = location1.launches[0]\n self.assertEqual(launch1.rocket, \"Long March 2F\")",
"def test_click_Locationtypes(self):\n self.tc_id = \"Ts_013\"\n self.tc_desc = \"Verify user is able to click Location types\"\n self.tc_step = \"TC Start\"\n\n clickLocationTypes = ClickLocationTypes(self.driver)\n\n self.tc_step = \"Launch the url\"\n clickLocationTypes.launchUrl(\"https://massdtaiot.com/dtahip/\")\n self.tc_step = \"Select all cities\"\n clickLocationTypes.allcities()\n self.tc_step = \"Click the HIP CSA filter\"\n clickLocationTypes.clickHIPCSALoc()\n clickLocationTypes.clickonLegend()\n clickLocationTypes.clickHIPFarmStandLoc()\n clickLocationTypes.clickonLegend()\n clickLocationTypes.clickHIPFarmerMarketBoothLoc()\n clickLocationTypes.clickonLegend()\n clickLocationTypes.clickHIPMobileMarketLoc()\n clickLocationTypes.clickonLegend()\n clickLocationTypes.clickHIPFarmerMarketLoc()",
"def test_save_updates_current_location_on_create(self, location_fixture):\n loc1, loc2, loc3 = location_fixture\n\n location1 = Location.objects.get(id=loc1)\n location2 = Location.objects.get(id=loc2)\n location3 = Location.objects.get(id=loc3)\n\n # The active location should be the last one that was created\n assert location1.status == Location.FORMER\n assert location2.status == Location.FORMER\n assert location3.status == Location.CURRENT",
"def test_lands_on_goal_correctly():\n env = Four_Rooms_Environment(stochastic_actions_probability=0.0)\n env.reset()\n env.move_user(env.current_user_location, (3, 3))\n env.move_goal(env.current_goal_location, (2, 2))\n\n env.step(0)\n assert env.reward == env.step_reward_for_not_achieving_goal\n assert not env.done\n\n env.step(3)\n assert env.reward == env.reward_for_achieving_goal\n assert env.done\n\n env = Four_Rooms_Environment(stochastic_actions_probability=0.0)\n env.reset()\n env.move_user(env.current_user_location, (2, 3))\n env.move_goal(env.current_goal_location, (2, 8))\n for move in [2, 1, 1, 1, 1, 1, 0]:\n env.step(move)\n if move != 0:\n assert env.reward == env.step_reward_for_not_achieving_goal\n assert not env.done\n else:\n assert env.reward == env.reward_for_achieving_goal\n assert env.done",
"def test_update_zr_location_profile(self):\n pass",
"def test_change_provisioned_throughput_usual_case():",
"def test_non_matching_location(self):\n user1 = get_user_model().objects.get(username='test1@example.com')\n self.client.login(username='test1@example.com', password='1')\n\n office = OfficeLocation.objects.all()[0]\n org = OrgGroup.objects.filter(parent__isnull=True)[0]\n\n submission1 = Interest()\n submission1.owner = user1\n submission1.for_coffee = True\n submission1.save()\n submission1.locations.add(office)\n submission1.departments.add(org)\n\n resp = self.client.get(reverse('mystery:mystery'))\n self.assertContains(resp, \"Cancel this\", status_code=200)\n\n user2 = random_user()\n office2 = OfficeLocation()\n office2.id = \"test_id\"\n office2.street = \"test office\"\n office2.city = \"test office\"\n office2.state = \"test office\"\n office2.zip = \"test office\"\n office2.save()\n submission2 = Interest()\n submission2.owner = user2\n submission2.is_active = False\n submission2.save()\n submission2.for_coffee = True\n submission2.locations.add(office2)\n submission2.departments.add(org)\n submission2.is_active = True\n submission2.save()\n\n resp = self.client.get(reverse('mystery:mystery'))\n self.assertContains(resp, \"Cancel this\", status_code=200)",
"def test_location_detail_api_redirect(self):\n\n # get object\n location_api_1 = Location.objects.get(location_name='location_api_1')\n # login testuser\n self.client.login(username='testuser_location_api', password='tvjnIPBlhP9P3ixDHVE7')\n # create url\n destination = urllib.parse.quote('/api/location/' + str(location_api_1.location_id) + '/', safe='/')\n # get response\n response = self.client.get('/api/location/' + str(location_api_1.location_id), follow=True)\n # compare\n self.assertRedirects(response, destination, status_code=301, target_status_code=200)",
"def test_updateLocationEmptyNewNoParent(self):\n sel = self.selenium\n # Login\n self.login()\n # Load the Shelter\n self.open_record(\"Shelter with no Parent\")\n # Check that the location is currently blank\n self.check_blank()\n\n # Click on the Add button\n sel.click(\"gis_location_add-btn\")\n # Check that the components appear correctly\n self.failUnless(sel.is_visible(\"gis_location_name\"))\n self.failUnless(sel.is_visible(\"gis_location_name_label\"))\n self.failUnless(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failUnless(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failUnless(sel.is_visible(\"gis_location_map-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_advanced_div\"))\n # Check that components which should remain invisible, are\n self.failIf(sel.is_visible(\"gis_location_lat_row\"))\n self.failIf(sel.is_visible(\"gis_location_lon_row\"))\n\n # Fill in a Name & Address\n sel.type(\"gis_location_name\", \"New parentless Location\")\n sel.type(\"gis_location_addr_street\", \"45 Sheep Street\")\n\n # Open Map\n sel.click(\"gis_location_map-btn\")\n # Check it's now visible\n time.sleep(1)\n self.failUnless(sel.is_visible(\"gis-map-window\"))\n # Close Map\n sel.click(\"//div[@id='gis-map-window']/div/div/div/div/div[contains(@class, 'x-tool-close')]\")\n # Check it's not visible\n self.failIf(sel.is_visible(\"gis-map-window\"))\n\n # Open the Advanced Tab\n sel.click(\"gis_location_advanced_checkbox\")\n # Check that the components appear correctly\n self.failUnless(sel.is_visible(\"gis_location_lat_row\"))\n self.failUnless(sel.is_visible(\"gis_location_lon_row\"))\n\n # Open Converter\n sel.click(\"gis_location_converter-btn\")\n # Check it's now visible\n time.sleep(1)\n self.failUnless(sel.is_visible(\"gis-convert-win\"))\n # @ToDo: Use this to do a conversion\n # Close Converter\n sel.click(\"//div[@id='gis-convert-win']/div/div/div/div/div[contains(@class, 'x-tool-close')]\")\n # Check it's not visible\n self.failIf(sel.is_visible(\"gis-convert-win\"))\n\n # Fill in Lat & Lon\n sel.type(\"gis_location_lat\", \"51\")\n sel.type(\"gis_location_lon\", \"1\")\n\n # Save the form (with changes)\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter updated\")\n # Shelter has correct location\n self.assertEqual(\"New parentless Location (N 51.0 E 1.0)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n\n # Load again\n self.open_record(\"Shelter with no Parent\")\n # Check that the location is set\n self.assertEqual(\"New parentless Location (N 51.0 E 1.0)\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n location = sel.get_attribute(\"//a[starts-with(@onclick, 's3_viewMap')]/@onclick\")\n location_id = location.split(\"(\")[1].split(\")\")[0]\n self.assertEqual(location_id, sel.get_value(\"cr_shelter_location_id\"))\n # Check that the dropdown is set\n self.assertEqual(location_id, sel.get_value(\"gis_location_\"))\n\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_\"))\n self.failUnless(sel.is_visible(\"gis_location_label_\"))\n self.failUnless(sel.is_visible(\"gis_location_details-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_add-btn\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"cr_shelter_location_id\"))\n self.failIf(sel.is_visible(\"gis_location_L1\"))\n self.failIf(sel.is_visible(\"gis_location_label_L1\"))\n self.failIf(sel.is_visible(\"gis_location_L2\"))\n self.failIf(sel.is_visible(\"gis_location_label_L2\"))\n self.failIf(sel.is_visible(\"gis_location_L3\"))\n self.failIf(sel.is_visible(\"gis_location_label_L3\"))\n self.failIf(sel.is_visible(\"gis_location_L4\"))\n self.failIf(sel.is_visible(\"gis_location_label_L4\"))\n self.failIf(sel.is_visible(\"gis_location_name\"))\n self.failIf(sel.is_visible(\"gis_location_name_label\"))\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failIf(sel.is_visible(\"gis_location_map-btn\"))\n self.failIf(sel.is_visible(\"gis_location_advanced_div\"))\n self.failIf(sel.is_visible(\"gis_location_lat_row\"))\n self.failIf(sel.is_visible(\"gis_location_lon_row\"))\n\n # Click on 'Details' button\n sel.click(\"gis_location_details-btn\")\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failUnless(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failUnless(sel.is_visible(\"gis_location_map-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_advanced_div\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_lat_row\"))\n self.failIf(sel.is_visible(\"gis_location_lon_row\"))\n\n # Check that the Street Address is populated\n self.assertEqual(\"45 Sheep Street\", sel.get_text(\"gis_location_addr_street\"))\n\n # Open the Advanced Tab\n sel.click(\"gis_location_advanced_checkbox\")\n # Check that the components appear correctly\n self.failUnless(sel.is_visible(\"gis_location_lat_row\"))\n self.failUnless(sel.is_visible(\"gis_location_lon_row\"))\n\n # Check that the Lat/Lon are populated\n self.assertEqual(\"51.0\", sel.get_value(\"gis_location_lat\"))\n self.assertEqual(\"1.0\", sel.get_value(\"gis_location_lon\"))",
"def test_02_product_update(self):\n # Update new product state2 from default draft to sellable\n new_product = self.create_product()\n self.assertEqual(new_product.state2, 'draft')\n new_product.state2 = 'sellable'\n self.assertEqual(new_product.state2, 'sellable')\n\n # Same but to an existing demo product.\n demo_product = self.product_obj.browse(\n self.ref('product_lifecycle.product_product_4g'))\n self.assertEqual(demo_product.state2, 'sellable')\n demo_product.state2 = 'draft'\n self.assertEqual(demo_product.state2, 'draft')\n\n # Update new product invividual field (field defined in product.product\n # model).\n self.assertEqual(new_product.default_code, 'A2330')\n new_product.default_code = 'A2330-1'\n self.assertEqual(new_product.default_code, 'A2330-1')\n\n # Same but to an existing demo product.\n self.assertEqual(demo_product.default_code, 'A2329')\n demo_product.default_code = 'A2329-1'\n self.assertEqual(demo_product.default_code, 'A2329-1')\n\n # Update new product commom characteristic (field defined in\n # product.template) and check that affects the another product\n # variants\n self.assertFalse(new_product.description)\n new_product.description = 'This is a New Product'\n self.assertEqual(new_product.description, 'This is a New Product')\n self.assertEqual(demo_product.description, 'This is a New Product')\n demo_product.description = False\n self.assertFalse(demo_product.description)",
"def open_location(self):\n try:\n self.assertEqual(self.test_location, self.selenium.get_location())\n except AssertionError, self.e:\n self.verificationErrors.append(str(self.e))",
"def test_operate_storage_initial(self, on):\n\n if on is False:\n override = {}\n else:\n override = {\"techs.test_supply_plus.constraints.storage_initial\": 0.5}\n m = build_model(\n override, \"simple_supply_and_supply_plus,operate,investment_costs\"\n )\n\n with pytest.warns(exceptions.ModelWarning) as warning:\n m.run(build_only=True)\n if on is False:\n assert check_error_or_warning(warning, \"Initial stored energy not defined\")\n assert (\n m._model_data.storage_initial.loc[\"a\", \"test_supply_plus\"].item() == 0\n )\n elif on is True:\n assert not check_error_or_warning(\n warning, \"Initial stored energy not defined\"\n )\n assert (\n m._model_data.storage_initial.loc[\"a\", \"test_supply_plus\"].item() == 0.5\n )",
"def test_add_product_to_cart(self, driver):\n logging.info(\"Start test case: Continue Shop\")\n data = self.test_data[\"Continue Shop\"][\"Products\"][0]\n logging.info(f\"Test data: [{data}]\")\n product_name = data[\"Product Name\"]\n\n select_product(driver, data[\"Page\"], product_name)\n add_product_to_cart(driver, data[\"Size\"], data[\"Color\"], data[\"Quantity\"])\n assert is_product_in_cart(driver, product_name)\n continue_shopping_from_order_summary(driver)\n assert verify_current_page_is_home(driver)",
"def test_updateLocationNoParentEmpty(self):\n sel = self.selenium\n # Login\n self.login()\n # Load the Shelter\n self.open_record(\"Shelter with no Parent\")\n\n # Check that the location is set\n self.assertEqual(\"Location with no Parent\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))\n location = sel.get_attribute(\"//a[starts-with(@onclick, 's3_viewMap')]/@onclick\")\n location_id = location.split(\"(\")[1].split(\")\")[0]\n self.assertEqual(location_id, sel.get_value(\"cr_shelter_location_id\"))\n # Check that the dropdown is set\n self.assertEqual(location_id, sel.get_value(\"gis_location_\"))\n\n # Check that the components which should be visible, are\n self.failUnless(sel.is_visible(\"gis_location_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_label_L0\"))\n self.failUnless(sel.is_visible(\"gis_location_\"))\n self.failUnless(sel.is_visible(\"gis_location_label_\"))\n self.failUnless(sel.is_visible(\"gis_location_details-btn\"))\n self.failUnless(sel.is_visible(\"gis_location_add-btn\"))\n # Check that the components which should be hidden, are\n self.failIf(sel.is_visible(\"cr_shelter_location_id\"))\n self.failIf(sel.is_visible(\"gis_location_L1\"))\n self.failIf(sel.is_visible(\"gis_location_label_L1\"))\n self.failIf(sel.is_visible(\"gis_location_L2\"))\n self.failIf(sel.is_visible(\"gis_location_label_L2\"))\n self.failIf(sel.is_visible(\"gis_location_L3\"))\n self.failIf(sel.is_visible(\"gis_location_label_L3\"))\n self.failIf(sel.is_visible(\"gis_location_L4\"))\n self.failIf(sel.is_visible(\"gis_location_label_L4\"))\n self.failIf(sel.is_visible(\"gis_location_name\"))\n self.failIf(sel.is_visible(\"gis_location_name_label\"))\n self.failIf(sel.is_visible(\"gis_location_cancel-btn\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_row\"))\n self.failIf(sel.is_visible(\"gis_location_addr_street_label\"))\n self.failIf(sel.is_visible(\"gis_location_map-btn\"))\n self.failIf(sel.is_visible(\"gis_location_advanced_div\"))\n\n # De-select the Specific\n sel.select(\"gis_location_\", \"label=Select a location...\")\n # Check that the real location has been set to blank\n self.assertEqual(\"\", sel.get_value(\"cr_shelter_location_id\"))\n # Save the form (with changes)\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter updated\")\n # Shelter has correct location\n self.assertEqual(\"-\", sel.get_table(\"//div[@id='rheader']/div/table.1.1\"))",
"def test_submit_for_endorsement(self):",
"def test_update_scenario(self):\n pass",
"def test_put_small_and_light_enrollment_by_seller_sku(self):\n pass",
"def test_create_location(self):\n location = self.location\n\n self.assertTrue(isinstance(location, Location))\n self.assertEqual(location.name, \"Test Location\")",
"def test_pds_location_endpoint(self):\n endpoint = settings.PDS_LOCATION_ENDPOINT\n access_token = config.ACCESS_TOKEN\n self.assertValidGetOicJsonEndpoint(endpoint, access_token)",
"def test_change_parent_location(self):\n pass",
"def test_save_updates_current_location_on_save(self, location_fixture):\n loc1, loc2, loc3 = location_fixture\n\n location1 = Location.objects.get(id=loc1)\n\n # Saving this location should make it the Active location.\n location1.status = Location.CURRENT\n location1.save()\n\n # Refresh/Get the objects to get the updated statuses.\n location1 = Location.objects.get(id=loc1)\n location2 = Location.objects.get(id=loc2)\n location3 = Location.objects.get(id=loc3)\n\n assert location1.status == Location.CURRENT\n assert location2.status == Location.FORMER\n assert location3.status == Location.FORMER",
"def test_locationEmpty(self):\n sel = self.selenium\n # Login\n self.login()\n self.create_header()\n # Fill in the mandatory fields\n sel.type(\"cr_shelter_name\", \"Shelter with no Location\")\n # Save the form\n sel.click(\"//input[@value='Save']\")\n sel.wait_for_page_to_load(\"30000\")\n # Shelter saved\n self.action.successMsg(\"Shelter added\")",
"def test_location_to_state_and_state_to_location_match():\n env = Four_Rooms_Environment(stochastic_actions_probability=0.0)\n env.reset()\n for row in range(env.grid_height):\n for col in range(env.grid_width):\n assert env.location_to_state((row, col)) == env.location_to_state(env.state_to_location(env.location_to_state((row, col))))",
"def plan_production() -> str:\r\n monthly_forecasts = app.config[\"monthly_sales_forecasts\"]\r\n # True if the dictionary monthly_forecasts is empty.\r\n if not monthly_forecasts:\r\n return (\"No prediction has been made. Please click first on the \"\r\n + \"button 'First: predict sales' on the tracking screen.\")\r\n batches = app.config[\"batches\"]\r\n tanks = app.config[\"tanks\"]\r\n inventory = app.config[\"inventory\"]\r\n # Holds actual number of beers in inventory and actual number of beers that\r\n # will be finished in the next three months on basis of production stage.\r\n three_month_end_inv = {\"dunkers\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"pilsner\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"red_helles\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0}}\r\n # Calculates when product. stage will be finished for 3 consecutive months.\r\n for batch in batches.values():\r\n # True if batch is already finished, continue with next batch.\r\n if batch.bottles_put_in_inventory:\r\n continue\r\n # Implies batch isn't assigned to phase, values are set in next if-else\r\n end_phase4 = \"\"\r\n end_phase3_4 = \"\"\r\n end_phase2_4 = \"\"\r\n end_phase1_4 = \"\"\r\n # Calculates end time of each batch assuming that each batch goes\r\n # directly to the next production phase without any delays.\r\n # True if the batch is in production phase 4 (bottling).\r\n if batch.time_end_phase4 != \"\":\r\n # Phase 4 ends when time_end_phase4 is reached.\r\n end_phase4 = batch.time_end_phase4\r\n # Else True if the batch is in production phase 3 (conditioning).\r\n elif batch.time_end_phase3 != \"\":\r\n # If the product is in phase 3, then the product will be finished\r\n # after the duration of phase 3 + phase 4 ends.\r\n # One minute per bottle (1/60) and each bottle contains 0.5 litres.\r\n duration_p4 = (1 / 60) * batch.volume * 2 # In hours.\r\n end_phase3_4 = batch.time_end_phase3 + timedelta(hours=duration_p4)\r\n # Else True if the batch is in production phase 2 (fermentation).\r\n elif batch.time_end_phase2 != \"\":\r\n # P2 product will be finished after duration p2 + p3 + p4 ends.\r\n duration_p3 = 336 # In hours.\r\n duration_p4 = (1 / 60) * batch.volume * 2\r\n end_phase2_4 = (batch.time_end_phase2\r\n + timedelta(hours=duration_p3)\r\n + timedelta(hours=duration_p4))\r\n # Else True if the batch is in production phase 1 (hot brewing).\r\n elif batch.time_end_phase1 != \"\":\r\n # P1 product will be finished after durat. p1 + p2 + p3 + p4 ends.\r\n duration_p2 = 672 # In hours.\r\n duration_p3 = 336\r\n duration_p4 = (1 / 60) * batch.volume * 2\r\n end_phase1_4 = (batch.time_end_phase1\r\n + timedelta(hours=duration_p2)\r\n + timedelta(hours=duration_p3)\r\n + timedelta(hours=duration_p4))\r\n # Gets current month and is incremented for each iteration of for loop\r\n # to represent month number of this_month, next_month, and third_month.\r\n incre_month = datetime.now().month\r\n months = [\"this_month\", \"next_month\", \"third_month\"]\r\n # Calculates end of month inv. values for this, next, and third month.\r\n for index, _ in enumerate(months):\r\n # * 2 to get the number of bottles, 1 litre equals 2 bottles.\r\n volume = batch.volume * 2\r\n # True if phase4 has been reached and end month matches inc month.\r\n if end_phase4 != \"\" and end_phase4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n # Elif True if p3 has been reached and end month matches inc month.\r\n elif end_phase3_4 != \"\" and end_phase3_4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n # Elif True if p2 has been reached and end month matches inc month.\r\n elif end_phase2_4 != \"\" and end_phase2_4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n # Elif True if p1 has been reached and end month matches inc month.\r\n elif end_phase1_4 != \"\" and end_phase1_4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n incre_month += 1\r\n # If month number is incremented to 13, it is set to 1 (January).\r\n if incre_month == 13:\r\n incre_month = 1\r\n # Adds actual inventory quantities to calculated end of month quantities.\r\n for beer_type in three_month_end_inv:\r\n inventory_item_quantity = inventory.get_inv_items_quantity(beer_type)\r\n inventory_quantity = inventory_item_quantity[\"num\"]\r\n # Actual inventory quantities are only added to this_month inventory.\r\n three_month_end_inv[beer_type][\"this_month\"] += inventory_quantity\r\n # Holds three months (end of month) forecasted sales values.\r\n three_month_forecast = {\"dunkers\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"pilsner\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"red_helles\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0}}\r\n # Builds date-index to access forecast value for this, next, and 3rd month.\r\n # 1. Builds date-index for this month.\r\n # Gets current datetime.\r\n current_datetime = datetime.now()\r\n # Gets current month.\r\n current_month = current_datetime.month\r\n # Gets current year.\r\n current_year = current_datetime.year\r\n # Creates date-index to access forecast value for this month.\r\n dt1st_month = datetime(current_year, current_month, 1) # 1st day of month.\r\n # Gets number of days of the current month.\r\n number_days = monthrange(current_year, current_month)[1]\r\n # 2. Builds date-index for next month.\r\n # Gets next datetime.\r\n next_datetime = current_datetime + timedelta(days=number_days)\r\n # Gets next month.\r\n next_month = next_datetime.month\r\n # Gets year in next month.\r\n next_months_year = next_datetime.year\r\n # Creates date-index to access forecast value for next month.\r\n dt2nd_month = datetime(next_months_year, next_month, 1)\r\n # Gets number of days of the next month.\r\n number_days = monthrange(next_months_year, next_month)[1]\r\n # 3. Builds date-index for 3rd month.\r\n # Gets 3rd datetime.\r\n third_datetime = next_datetime + timedelta(days=number_days)\r\n # Gets 3rd month.\r\n third_month = third_datetime.month\r\n # Gets year in 3rd month.\r\n third_months_year = third_datetime.year\r\n # Creates date-index to access forecast value for 3rd month.\r\n dt3rd_month = datetime(third_months_year, third_month, 1)\r\n # Gets and stores forecast values for three months in three_month_forecast.\r\n for beer_type in monthly_forecasts:\r\n forecast_1st = monthly_forecasts[beer_type].predicted_mean[dt1st_month]\r\n forecast_2nd = monthly_forecasts[beer_type].predicted_mean[dt2nd_month]\r\n forecast_3rd = monthly_forecasts[beer_type].predicted_mean[dt3rd_month]\r\n try:\r\n three_month_forecast[beer_type][\"this_month\"] = int(forecast_1st)\r\n three_month_forecast[beer_type][\"next_month\"] = int(forecast_2nd)\r\n three_month_forecast[beer_type][\"third_month\"] = int(forecast_3rd)\r\n except ValueError as error:\r\n app.config[\"logger\"].error(error)\r\n # Holds 3 months differ. between forecast and finished inv. for each beer.\r\n diff_3months_forecast_actual = {\"dunkers\": 0, \"pilsner\": 0,\r\n \"red_helles\": 0}\r\n # Calculates for each beer differ. between forecast and finished inventory.\r\n for beer_type in three_month_end_inv:\r\n # Holds finished inventory quantity for 3 months per beer type.\r\n fin_inv_beer_3months = 0\r\n # Holds forecasted sales quantity for 3 months per beer type.\r\n forecast_beer_3months = 0\r\n # 2nd for loop to iterate over dict in dict to calculate difference.\r\n for month in three_month_end_inv[beer_type]:\r\n fin_inv_beer_3months += three_month_end_inv[beer_type][month]\r\n forecast_beer_3months += three_month_forecast[beer_type][month]\r\n diff_beer_3months = fin_inv_beer_3months - forecast_beer_3months\r\n diff_3months_forecast_actual[beer_type] = diff_beer_3months\r\n # Determines which beer should be produced next;\r\n # beer type with highest negative difference between finished inventory and\r\n # sales forecast is recommended to be produced if equipment is available.\r\n # Gets beer type with highest negative difference.\r\n produce_beer = min(diff_3months_forecast_actual,\r\n key=lambda beer: diff_3months_forecast_actual[beer])\r\n used_tanks = []\r\n # Adds the names of all used tanks to used_tanks' list.\r\n for batch in batches.values():\r\n # True if tank is used.\r\n if batch.phase_current_tank != \"\":\r\n used_tanks.append(batch.phase_current_tank)\r\n all_tanks = tanks.get_tank_names()\r\n available_tanks = [tank for tank in all_tanks if tank not in used_tanks]\r\n capable_tanks = {}\r\n # Checks if tank with right capability is available.\r\n for tank_name in available_tanks:\r\n # Uses tank_name to get value of Tanks' instance var with same name.\r\n tank_value = tanks.get_tank_value(tank_name)\r\n # True if tank with right capability is available.\r\n if \"ferm\" in tank_value[\"capability\"]:\r\n # Puts tank's volume into capable_tanks dictionary.\r\n capable_tanks[tank_name] = tank_value[\"volume\"]\r\n # Selects tank with highest volume if tank with right capab. is available.\r\n if capable_tanks:\r\n use_tank = max(capable_tanks, key=lambda beer: capable_tanks[beer])\r\n use_tank_volume = capable_tanks[use_tank]\r\n else:\r\n use_tank = \"'currently no tank with right capability available'\"\r\n use_tank_volume = 0\r\n # Creates recommendation for the user.\r\n recommendation = (\"Based on the three-month forecast and production phases\"\r\n + \", available tanks, capabilities and volumes, it is \"\r\n + \"recommended to produce <b>{0}</b> in tank <b>{1}</b> \"\r\n + \"next.\").format(produce_beer, use_tank)\r\n # Creates reasoning for the user.\r\n # Creates HTML table containing three months end inventory.\r\n html_3months_end_inv_table = update_three_months_table(three_month_end_inv)\r\n # Creates HTML table containing three months forecasted sales.\r\n html_3months_foreca_table = update_three_months_table(three_month_forecast)\r\n reason = (\"Actual number of beers in inventory and actual number of beers \"\r\n + \"that will be finished in the next three months are:<br>\"\r\n + \"\"\"<table>\r\n <tr>\r\n <th></th>\r\n <th>This month</th>\r\n <th>Next month</th>\r\n <th>Third month</th>\r\n </tr>\"\"\" + html_3months_end_inv_table + \"</table><br>\"\r\n + \"Three months forecasted sales (in bottles) are:\"\r\n + \"\"\"<table>\r\n <tr>\r\n <th></th>\r\n <th>This month</th>\r\n <th>Next month</th>\r\n <th>Third month</th>\r\n </tr>\"\"\" + html_3months_foreca_table + \"</table><br>\"\r\n + \"Beer type with highest difference between forecast and \"\r\n + \"finished inventory is recommended to be produced if \"\r\n + \"equipment is available. The difference is (in bottles):<br>\"\r\n + \"\"\"<table>\r\n <tr>\r\n <th>Dunkers</th>\r\n <th>Pilsner</th>\r\n <th>Red Helles</th>\r\n </tr>\r\n <tr>\r\n <td>{0}</td>\r\n <td>{1}</td>\r\n <td>{2}</td>\r\n </tr></table><br>\r\n \"\"\".format(diff_3months_forecast_actual[\"dunkers\"],\r\n diff_3months_forecast_actual[\"pilsner\"],\r\n diff_3months_forecast_actual[\"red_helles\"])\r\n + \"Available tank(s) with right capability is/are:<b>\"\r\n + str(capable_tanks) + \"</b>, where the highest available \"\r\n + \"volume is <b>{}</b> litres. \".format(use_tank_volume)\r\n + (\"Thus, it is recommended to produce <b>{0}</b> in tank \"\r\n + \"<b>{1}</b>.\").format(produce_beer, use_tank))\r\n return (\"\"\"<style>\r\n h1, h2, h3 {\r\n font-family: arial, sans-serif;\r\n }\r\n table {\r\n font-family: arial, sans-serif;\r\n border-collapse: collapse;\r\n width: 100%;\r\n }\r\n td, th {\r\n border: 1px solid #dddddd;\r\n text-align: left;\r\n padding: 8px;\r\n }\r\n tr:nth-child(even) {\r\n background-color: #dddddd;\r\n }\r\n </style>\r\n <h2>Plan production</h2>\"\"\"\r\n + recommendation\r\n + \"<br><br><b>Reasoning:</b></br>\"\r\n + reason\r\n + \"\"\"<form action=\"/\" method=\"POST\">\r\n <input type=\"hidden\">\r\n <br>\r\n <input type=\"submit\" value=\"Go back to tracking screen\">\r\n </form>\"\"\")",
"def test_lta_good(self):\n self.assertIsNone(api.inventory.check(self.lta_order_good))",
"def test_post_monitoring_schedule_manufacturer_v3(self):\n pass",
"def test_get_shipment(self):\n pass",
"def test_poi_update_with_coords(self):\n\n # Data that we'll post to the server to get the poi updated\n new_poi = {\n 'name': 'Test Name', 'alt_name': 'Tester Obj',\n 'description': 'Test Description',\n 'latitude': 45.0,\n 'longitude': -124.0,\n 'history': 'history', 'facts': 'It\\'s a test',\n 'street': '750 NW Lighthouse Dr', 'city': 'Newport', 'state': 'OR',\n 'zip': '97365', 'location_description': 'test loc description',\n 'contact_name': 'Test Contact', 'website': '', 'email': '',\n 'phone': '', 'category_ids': '1,2', 'hazard_ids': '1,2',\n 'image_ids': '', 'video_ids': ''}\n\n self.client.post(\n reverse('edit-poi', kwargs={'id': '1'}), new_poi)\n\n # These values are changed by the server after being received from\n # the client/web page. The preparation IDs are going to be changed\n # into objects, so we'll not need the list fields\n del new_poi['category_ids']\n del new_poi['hazard_ids']\n del new_poi['video_ids']\n del new_poi['image_ids']\n del new_poi['longitude']\n del new_poi['latitude']\n\n new_poi['phone'] = None\n\n poi = PointOfInterest.objects.get(id=1)\n for field in new_poi:\n self.assertEqual(getattr(poi, field), new_poi[field])\n\n self.assertEqual(poi.location.y, 45.0000000) # latitude\n self.assertEqual(poi.location.x, -124.000000) # longitude\n\n hazards = [hazard.id for hazard in poi.hazards.all()]\n categories = [category.id for category in poi.categories.all()]\n\n self.assertEqual(sorted(hazards), [1, 2])\n self.assertEqual(sorted(categories), [1, 2])",
"def test_update(self):\n metadata = self.metadata_sofia # the metadata'd stay the same\n places_initial_batch = dict(\n list(self.places_sofia.items())[:len(self.places_sofia) // 2]) # get the first half of a dict\n load_to_datastore(places=places_initial_batch, metadata=metadata)\n\n # sanity checking\n CommonAssertions.run_all_tests_single_area_loaded(tester=self, places=places_initial_batch, metadata=metadata)\n\n # now load a second batch (which is just all of the available data)\n load_to_datastore(places=self.places_sofia, metadata=metadata)\n # and test again\n CommonAssertions.run_all_tests_single_area_loaded(tester=self, places=self.places_sofia, metadata=metadata)",
"def test_case_customer_complete_courseevent_order(self):",
"def set_product(location, product_array):\r\n\r\n db = get_db()\r\n b_id = session.get(\"user_id\")\r\n product_id = product_array[0]\r\n quantity = product_array[1]\r\n if location != \"Move out\":\r\n product_exists = db.execute(\r\n \"SELECT * FROM warehouse WHERE prod_id = ? AND loc_id = ? AND b_id = ?\",\r\n (product_id, location, b_id),\r\n ).fetchone()\r\n if product_exists:\r\n ogquantity = db.execute(\r\n \"SELECT qty FROM warehouse WHERE loc_id = ? AND prod_id = ? AND b_id = ?\",\r\n (location, product_id, b_id,),\r\n ).fetchone()[0]\r\n newquantity = ogquantity + quantity\r\n query = \"UPDATE warehouse SET qty = ? WHERE loc_id = ? AND prod_id = ? AND b_id = ?\"\r\n db.execute(query, (newquantity, location, product_id, b_id,))\r\n db.commit()\r\n else:\r\n db.execute(\r\n \"INSERT INTO warehouse (b_id, prod_id, qty, loc_id) values (?, ?, ?, ?)\",\r\n (b_id, product_id, quantity, location),\r\n )\r\n db.commit()",
"def test_product_get_absolute_url(self):\n self.assertEquals(Product.get_absolute_url(self.prod_1),\n '/snacks/product/1/')",
"def test_init(self):\n self.assertEqual(self.location, Ship(self.location).location)",
"def test_part_1_power_levels(serial, location, output):\n grid = part_1.Grid(serial)\n assert grid.get(location) == output",
"def test_gather_location_no_product(self):\n gathered_items = self.Quant._gather(self.apple, self.test_stock_location_02)\n # Check the number of apple quants returned is correct\n self.assertFalse(len(gathered_items))",
"def test_01_lunch_order(self):\r\n cr, uid = self.cr, self.uid\r\n self.test_00_lunch_order()\r\n #We receive the order so we confirm the order line so it's state will be 'confirmed'\r\n #A cashmove will be created and we will test that the cashmove amount equals the order line price\r\n self.order_one.confirm()\r\n self.order_one = self.lunch_order_line.browse(cr,uid,self.new_id_order_line,context=None)\r\n #we check that our order_line is a 'confirmed' one and that there are a cashmove linked to that order_line with an amount equals to the order line price:\r\n self.assertEqual(self.order_one.state,'confirmed')\r\n self.assertTrue(self.order_one.cashmove)\r\n self.assertTrue(self.order_one.cashmove[0].amount==-self.order_one.price)",
"def test_purchase_products(self, driver):\n logging.info(\"Start test case: checkout product successfully\")\n products = self.test_data[\"Purchase Products\"][\"Products\"]\n address = self.test_data[\"Purchase Products\"][\"Address\"]\n payment_info = self.test_data[\"Purchase Products\"][\"Payment Info\"]\n logging.info(f\"Test Data: {self.test_data['Purchase Products']}\")\n\n select_product(driver, products[0][\"Page\"], products[0][\"Product Name\"])\n add_product_to_cart(driver, products[0][\"Size\"], products[0][\"Color\"], products[0][\"Quantity\"])\n checkout_from_order_summary(driver)\n set_address(driver, address[\"Billing Address\"], address[\"Country\"], address[\"City\"], address[\"Zip\"])\n checkout_order_to_pay(driver, payment_info[\"Payment Type\"])\n pay_order(driver, payment_info[\"Card ID\"], payment_info[\"Expired Date\"], payment_info[\"CVC\"])\n verify_message(driver, \"Order was successful\")",
"async def test_action_set_position(\n hass: HomeAssistant,\n entity_registry: er.EntityRegistry,\n enable_custom_integrations: None,\n) -> None:\n entry = entity_registry.async_get_or_create(DOMAIN, \"test\", \"5678\")\n\n assert await async_setup_component(\n hass,\n automation.DOMAIN,\n {\n automation.DOMAIN: [\n {\n \"trigger\": {\n \"platform\": \"event\",\n \"event_type\": \"test_event_set_pos\",\n },\n \"action\": {\n \"domain\": DOMAIN,\n \"device_id\": \"abcdefgh\",\n \"entity_id\": entry.id,\n \"type\": \"set_position\",\n \"position\": 25,\n },\n },\n {\n \"trigger\": {\n \"platform\": \"event\",\n \"event_type\": \"test_event_set_tilt_pos\",\n },\n \"action\": {\n \"domain\": DOMAIN,\n \"device_id\": \"abcdefgh\",\n \"entity_id\": entry.id,\n \"type\": \"set_tilt_position\",\n \"position\": 75,\n },\n },\n ]\n },\n )\n await hass.async_block_till_done()\n\n cover_pos_calls = async_mock_service(hass, \"cover\", \"set_cover_position\")\n tilt_pos_calls = async_mock_service(hass, \"cover\", \"set_cover_tilt_position\")\n\n hass.bus.async_fire(\"test_event_set_pos\")\n await hass.async_block_till_done()\n assert len(cover_pos_calls) == 1\n assert len(tilt_pos_calls) == 0\n\n hass.bus.async_fire(\"test_event_set_tilt_pos\")\n await hass.async_block_till_done()\n assert len(cover_pos_calls) == 1\n assert len(tilt_pos_calls) == 1\n\n assert cover_pos_calls[0].domain == DOMAIN\n assert cover_pos_calls[0].service == \"set_cover_position\"\n assert cover_pos_calls[0].data == {\"entity_id\": entry.entity_id, \"position\": 25}\n assert tilt_pos_calls[0].domain == DOMAIN\n assert tilt_pos_calls[0].service == \"set_cover_tilt_position\"\n assert tilt_pos_calls[0].data == {\"entity_id\": entry.entity_id, \"tilt_position\": 75}",
"def _test_out_of_range(self):\n self.cdbconf.setup('KKG')\n self.cdbconf.setConfiguration('CUSTOM_OPT')\n az, el, latitude = [radians(50)] * 3\n site_info = {'latitude': latitude}\n self.p.setup(site_info, self.source, self.device)\n self.p.setRewindingMode('AUTO')\n offset = 20\n max_limit = self.device.getMaxLimit() \n min_limit = self.device.getMinLimit()\n Pis = max_limit - offset/2\n time.sleep(0.2) if self.using_mock else time.sleep(3)\n self.p.setPosition(Pis)\n time.sleep(0.2) # Wait a bit for the setup\n max_rewinding_steps = (max_limit - min_limit) // self.device.getStep()\n expected = Pis - max_rewinding_steps*self.device.getStep() + offset\n self.source.setAzimuth(az)\n self.source.setElevation(el)\n self.p.startUpdating('MNG_TRACK', 'ANT_NORTH', az, el, None, None)\n time.sleep(0.2) if self.using_mock else time.sleep(3)\n self.p.setOffset(offset)\n time.sleep(0.2) if self.using_mock else time.sleep(3)\n self.assertEqual(self.device.getActPosition(), expected)",
"def test_ship_orders(self):\n pass",
"def test_place(self):\n places = self.geographies.find({ 'geoid': '1562600' })\n\n self.assertEqual(places.count(), 1)\n\n place = places[0]\n\n self.assertEqual(place['sumlev'], config.SUMLEV_PLACE)\n self.assertEqual(place['metadata']['NAME'], 'Pearl City CDP')\n self.assertEqual(place['metadata']['STATE'], '15')\n self.assertEqual(place['metadata']['PLACE'], '62600')\n\n pop_2000 = 30976\n pop_2010 = 47698 \n self._test_totalpop(place, pop_2000, pop_2010)",
"def test_spawn(self):\n self.grid.spawn()\n\n self.assertEqual(xyzroom.XYZRoom.objects.all().count(), 6)\n self.assertEqual(xyzroom.XYZExit.objects.all().count(), 10)\n\n room1 = xyzroom.XYZRoom.objects.get_xyz(xyz=(0, 1, \"map12a\"))\n room2 = xyzroom.XYZRoom.objects.get_xyz(xyz=(1, 0, \"map12b\"))\n east_exit = [exi for exi in room1.exits if exi.db_key == \"east\"][0]\n west_exit = [exi for exi in room2.exits if exi.db_key == \"west\"][0]\n\n # make sure exits traverse the maps\n self.assertEqual(east_exit.db_destination, room2)\n self.assertEqual(west_exit.db_destination, room1)",
"def test_6(self):\n toothpaste = Store.Product(11, \"toothpaste\", \"dental\", 2, 4)\n milk = Store.Product(12, \"milk\", \"dairy\", 2, 3)\n eggs = Store.Product(14, \"eggs\", \"dairy\", 2, 2)\n apple_juice = Store.Product(13, \"apple juice\", \"drink\", 1, 1)\n\n s = Store.Store()\n s.add_product(toothpaste)\n s.add_product(milk)\n s.add_product(eggs)\n s.add_product(apple_juice)\n\n henry = Store.Customer(\"henry\", \"mrh\", False)\n s.add_member(henry)\n\n s.add_product_to_member_cart(11, \"mrh\")\n s.add_product_to_member_cart(12, \"mrh\")\n s.add_product_to_member_cart(14, \"mrh\")\n self.assertAlmostEqual(s.check_out_member(\"mrh\"), 6.42, \"not the correct checkout amount\")",
"def move_orders_job_shop():\n # First: Move order from order_pool to the respective WIP\n # Second: route products as shown below\n # P1: M1-M2-M3\n # P2: M1-M3-M2\n # P3: M2-M1-M3\n # P4: M2-M3-M1\n # P5: M3-M1-M2\n # P6: M3-M2-M1\n # Third: after production is done, move order to FGI\n\n ##################### Step 1: empty the machines that have finished production in the previous step\n # The routing here doesn't contain the first production step, since the routing to that step\n # takes place in the order release process\n list_of_product_types = [1, 2, 3, 4, 5, 6]\n list_of_destinations = [\n [environment.wip_B, environment.wip_C, environment.finished_goods_inventory],\n [environment.wip_C, environment.wip_B, environment.finished_goods_inventory],\n [environment.wip_A, environment.wip_C, environment.finished_goods_inventory],\n [environment.wip_C, environment.wip_A, environment.finished_goods_inventory],\n [environment.wip_A, environment.wip_B, environment.finished_goods_inventory],\n [environment.wip_B, environment.wip_A, environment.finished_goods_inventory]\n ]\n # Move order from machine to the next wip, if processing_time_remaining of order is 0\n for machine_element in environment.list_of_all_machines:\n if len(machine_element.orders_inside_the_machine) == 1:\n order = machine_element.orders_inside_the_machine[0]\n if order.processing_time_remaining <= 0:\n destination = \\\n list_of_destinations[list_of_product_types.index(order.product_type)][order.current_production_step]\n # print(\"destination \" + str(len(destination)) + \" | machine \" + str(len(machine_element.orders_inside_the_machine)))\n destination.append(machine_element.orders_inside_the_machine.pop(0))\n # print(\"destination \" + str(len(destination)) + \" | machine \" + str(len(machine_element.orders_inside_the_machine)))\n ##### example case product type 1, step 0:\n # von destinations nehme list item 0 (prodtype)\n # von list item 0 nehme list item 0 (prodstep)\n # füge da die order ein\n order.current_production_step += 1\n\n ##################### Step 2: move orders from WIPs into the machines\n # Each origin belongs to one destination.\n # The first item in destinations belongs to the first item in origins and so on.\n # The order movements shown in Step 2 do not depend on the order's product type,\n # instead they depend on the machine scheduling policy.\n # In this version, only a first come, first serve policy is implemented.\n list_of_destinations = environment.list_of_all_machines\n list_of_origins = environment.list_of_all_wip_elements\n wip_names = [\"wip_A\", \"wip_B\", \"wip_C\", \"wip_D\", \"wip_E\", \"wip_F\"]\n\n for machine in list_of_destinations:\n if global_settings.scheduling_policy == \"first_come_first_serve\" and \\\n len(machine.orders_inside_the_machine) == 0 and \\\n len(list_of_origins[list_of_destinations.index(machine)]) > 0:\n\n ############ debugging info ############\n if global_settings.show_movements_from_wip_to_machine == True:\n print(\"Step \" + str(\n global_settings.current_time) + \": Order moved from \" +\n wip_names[list_of_destinations.index(machine)] + \" to \" + str(\n machine.name) + \". Orders in \" +\n wip_names[list_of_destinations.index(machine)] + \": \" + str(\n len(list_of_origins[list_of_destinations.index(machine)])))\n ########################\n machine.orders_inside_the_machine.append(list_of_origins[list_of_destinations.index(machine)].pop(0))\n environment.set_new_random_processing_time(machine) # set a new random processing time for the next order\n machine.orders_inside_the_machine[0].processing_time_remaining = machine.processing_time\n machine.orders_inside_the_machine[0].arrival_times_m1m2m3.append(global_settings.current_time)\n\n ##################### Step 3: move orders from FGI to shipped when order due date is reached\n # Move orders from FGI to shipped_orders once they have reached their due_date\n if global_settings.current_time % global_settings.duration_of_one_period == 0:\n ship_orders()\n return",
"def setUp(self):\n super(TestProductLifecycle, self).setUp()\n self.sellable_product = self.ref('product.product_product_4c')\n self.obsolete_product = self.ref('product.product_product_4b')\n self.draft_product = self.ref('product.product_product_4')\n self.sellable_replacement = self.ref(\n 'product_lifecycle.product_product_4g')\n self.obsolete_replacement = self.ref(\n 'product_lifecycle.product_product_4f')\n self.product_obj = self.env['product.product']\n self.order_obj = self.env['purchase.order']\n self.imd_obj = self.env['ir.model.data']\n self.wiz_obj = self.env['replacement.product']",
"def test_post_monitoring_schedule_vendor_v3(self):\n pass",
"def test_pallet_finish(self) -> None:\n # set some arbitrary values\n pallet_name = 'Hopefully this never matches !@#$%^&*()_+'\n location_code = '0409C2'\n box_type_code = 'Evans'\n starting_box_number = 98765\n number_of_boxes = 40\n ending_box_number = starting_box_number + number_of_boxes\n product_choices = 'Corn', 'Green Beans'\n exp_year_choices = (now().year + 1), (now().year + 2)\n\n # get corresponding records\n box_type_rec = BoxType.objects.get(box_type_code=box_type_code)\n product1 = Product.objects.get(prod_name=product_choices[0])\n product2 = Product.objects.get(prod_name=product_choices[1])\n product_rec_choices = product1, product2\n\n bm = BoxManagementClass()\n\n # build the pallet\n location_rec = Location.objects.get(loc_code=location_code)\n pallet_rec = Pallet.objects.create(\n name=pallet_name,\n location=location_rec,\n pallet_status=Pallet.FILL,\n )\n pallet_rec_id = pallet_rec.id\n\n # build table of values for later comparison\n pallet_box_info = dict()\n for ndx, box_number in enumerate(\n range(starting_box_number, ending_box_number)):\n ind = ndx % 2\n box_name = BoxNumber.format_box_number(box_number)\n product = product_rec_choices[ind]\n exp_year = exp_year_choices[ind]\n box_rec = bm.box_new(box_number=box_name, box_type=box_type_rec)\n pallet_box_rec = PalletBox.objects.create(\n pallet=pallet_rec,\n box_number=box_name,\n box=box_rec,\n product=product,\n exp_year=exp_year,\n box_status=PalletBox.NEW\n )\n pallet_box_info[box_number] = PalletBoxInfo(\n pallet_box_id=pallet_box_rec.id, box_id=box_rec.id,\n box_number=box_name, product=product, exp_year=exp_year)\n\n # finish (publish) the pallet\n bm.pallet_finish(pallet_rec)\n\n # validate that worked properly\n for entry in pallet_box_info:\n with raises(PalletBox.DoesNotExist):\n _ = PalletBox.objects.get(\n pk=pallet_box_info[entry].pallet_box_id\n )\n box_rec = Box.objects.get(pk=pallet_box_info[entry].box_id)\n assert box_rec.box_number == pallet_box_info[entry].box_number\n assert box_rec.box_type == box_type_rec\n assert box_rec.location == location_rec\n assert box_rec.product == pallet_box_info[entry].product\n assert box_rec.exp_year == pallet_box_info[entry].exp_year\n assert box_rec.exp_month_start == 0\n assert box_rec.exp_month_end == 0\n filled_seconds_ago = (now() - box_rec.date_filled).total_seconds()\n assert filled_seconds_ago < 10\n assert box_rec.quantity == box_type_rec.box_type_qty\n\n with raises(Pallet.DoesNotExist):\n _ = Pallet.objects.get(pk=pallet_rec_id)\n return",
"def test_sale_service(self):\n sale_order_vals = {\n 'partner_id': self.partner_usd.id,\n 'partner_invoice_id': self.partner_usd.id,\n 'partner_shipping_id': self.partner_usd.id,\n 'order_line': [(0, 0, {\n 'name': self.product_delivery_timesheet2.name,\n 'product_id': self.product_delivery_timesheet2.id,\n 'product_uom_qty': 50,\n 'product_uom': self.product_delivery_timesheet2.uom_id.id,\n 'price_unit': self.product_delivery_timesheet2.list_price\n }),\n ],\n 'pricelist_id': self.pricelist_usd.id,\n }\n sale_order = self.env['sale.order'].create(sale_order_vals)\n sale_order.order_line._compute_product_updatable()\n self.assertTrue(sale_order.order_line[0].product_updatable)\n sale_order.action_confirm()\n sale_order.order_line._compute_product_updatable()\n self.assertFalse(sale_order.order_line[0].product_updatable)\n self.assertEqual(sale_order.invoice_status, 'no', 'Sale Service: there should be nothing to invoice after validation')\n\n # check task creation\n project = self.project_global\n task = project.task_ids.filtered(lambda t: t.name == '%s:%s' % (sale_order.name, self.product_delivery_timesheet2.name))\n self.assertTrue(task, 'Sale Service: task is not created')\n self.assertEqual(task.partner_id, sale_order.partner_id, 'Sale Service: customer should be the same on task and on SO')\n # register timesheet on task\n self.env['account.analytic.line'].create({\n 'name': 'Test Line',\n 'project_id': project.id,\n 'task_id': task.id,\n 'unit_amount': 50,\n 'employee_id': self.employee_manager.id,\n })\n self.assertEqual(sale_order.invoice_status, 'to invoice', 'Sale Service: there should be sale_ordermething to invoice after registering timesheets')\n sale_order.action_invoice_create()\n line = sale_order.order_line\n self.assertTrue(line.product_uom_qty == line.qty_delivered == line.qty_invoiced, 'Sale Service: line should be invoiced completely')\n self.assertEqual(sale_order.invoice_status, 'invoiced', 'Sale Service: SO should be invoiced')\n self.assertEqual(sale_order.tasks_count, 1, \"A task should have been created on SO confirmation.\")\n\n # Add a line on the confirmed SO, and it should generate a new task directly\n product_service_task = self.env['product.product'].create({\n 'name': \"Delivered Service\",\n 'standard_price': 30,\n 'list_price': 90,\n 'type': 'service',\n 'invoice_policy': 'delivery',\n 'uom_id': self.env.ref('product.product_uom_hour').id,\n 'uom_po_id': self.env.ref('product.product_uom_hour').id,\n 'default_code': 'SERV-DELI',\n 'service_type': 'timesheet',\n 'service_tracking': 'task_global_project',\n 'project_id': project.id\n })\n\n self.env['sale.order.line'].create({\n 'name': product_service_task.name,\n 'product_id': product_service_task.id,\n 'product_uom_qty': 10,\n 'product_uom': product_service_task.uom_id.id,\n 'price_unit': product_service_task.list_price,\n 'order_id': sale_order.id,\n })\n\n self.assertEqual(sale_order.tasks_count, 2, \"Adding a new service line on a confirmer SO should create a new task.\")",
"def test_create_confirm_delivery_details(self):\n pass",
"def test_property_page(self):\n self.property_page.proceed_to_property_page()\n\n \"\"\"Step2 - Check rooms section\n Exp2 - Property page opened \"\"\"\n self.property_page.check_rooms_section()\n\n \"\"\"Step3 - Check other section\n Exp3 - Each item works well \"\"\"\n self.property_page.check_other_section()",
"def test_post_opening_balance_journals(self):\n pass",
"def go_product_page(self, driver, product_id, website):\n link = self.product_url(website, product_id)\n self.go_and_assert(driver, link, website)",
"def test_homepage_with_location(self):\r\n\r\n with self.client:\r\n response = self.client.get('/?location=US-CA')\r\n self.assertEqual(response.status_code, 200)\r\n self.assertIn(b'California News', response.data)\r\n\r\n response = self.client.get('/?location=US-FAKE')\r\n self.assertEqual(response.status_code, 200)\r\n self.assertIn(b'No data found for that region.', response.data)"
] | [
"0.68906146",
"0.6246047",
"0.6090114",
"0.6084227",
"0.6050358",
"0.6022465",
"0.5951435",
"0.592476",
"0.59018815",
"0.5867885",
"0.58634603",
"0.58565384",
"0.58413273",
"0.58121234",
"0.58035403",
"0.5710238",
"0.5670679",
"0.5666164",
"0.564475",
"0.5602386",
"0.5602123",
"0.5572282",
"0.55630136",
"0.5558942",
"0.5558823",
"0.55381566",
"0.5525468",
"0.54971665",
"0.5489381",
"0.5486223",
"0.54859585",
"0.54771024",
"0.5476842",
"0.54737777",
"0.54699856",
"0.54689604",
"0.54627013",
"0.5456467",
"0.5455608",
"0.54523975",
"0.544615",
"0.54443127",
"0.5439535",
"0.5434651",
"0.54280573",
"0.5427064",
"0.5422213",
"0.5415904",
"0.5412992",
"0.54115325",
"0.5391427",
"0.5391115",
"0.5383686",
"0.53728354",
"0.5370947",
"0.5366116",
"0.53655916",
"0.53615034",
"0.5358393",
"0.5358153",
"0.53560346",
"0.5354276",
"0.5348135",
"0.53411067",
"0.5337193",
"0.53299624",
"0.5327965",
"0.53279114",
"0.5325675",
"0.53214085",
"0.5305116",
"0.5305001",
"0.52800727",
"0.52776885",
"0.52740484",
"0.5257144",
"0.52493197",
"0.524909",
"0.5240303",
"0.52402675",
"0.5240073",
"0.52320206",
"0.5220715",
"0.5219383",
"0.5219349",
"0.5218639",
"0.52105075",
"0.52044654",
"0.5203252",
"0.5202275",
"0.51992863",
"0.51947415",
"0.5187007",
"0.51817894",
"0.5180506",
"0.517696",
"0.5176879",
"0.51702434",
"0.51677924",
"0.51670593"
] | 0.7612206 | 0 |
Make sure a kit is split in the corrects quantity_done by components in case of an immediate transfer. | def test_kit_immediate_transfer(self):
picking = self.env['stock.picking'].create({
'location_id': self.test_supplier.id,
'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,
'partner_id': self.test_partner.id,
'picking_type_id': self.env.ref('stock.picking_type_in').id,
'immediate_transfer': True
})
move_receipt_1 = self.env['stock.move'].create({
'name': self.kit_parent.name,
'product_id': self.kit_parent.id,
'quantity_done': 3,
'product_uom': self.kit_parent.uom_id.id,
'picking_id': picking.id,
'picking_type_id': self.env.ref('stock.picking_type_in').id,
'location_id': self.test_supplier.id,
'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,
})
picking.button_validate()
# We check that the picking has the correct quantities after its move were splitted.
self.assertEqual(len(picking.move_lines), 7)
for move_line in picking.move_lines:
self.assertEqual(move_line.quantity_done, self.expected_quantities[move_line.product_id]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_kit_planned_transfer(self):\n picking = self.env['stock.picking'].create({\n 'location_id': self.test_supplier.id,\n 'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,\n 'partner_id': self.test_partner.id,\n 'picking_type_id': self.env.ref('stock.picking_type_in').id,\n 'immediate_transfer': False,\n })\n move_receipt_1 = self.env['stock.move'].create({\n 'name': self.kit_parent.name,\n 'product_id': self.kit_parent.id,\n 'product_uom_qty': 3,\n 'product_uom': self.kit_parent.uom_id.id,\n 'picking_id': picking.id,\n 'picking_type_id': self.env.ref('stock.picking_type_in').id,\n 'location_id': self.test_supplier.id,\n 'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,\n })\n picking.action_confirm()\n\n # We check that the picking has the correct quantities after its move were splitted.\n self.assertEqual(len(picking.move_lines), 7)\n for move_line in picking.move_lines:\n self.assertEqual(move_line.product_qty, self.expected_quantities[move_line.product_id])",
"def _check_overprocessed_subcontract_qty(self):\n overprocessed_moves = self.env['stock.move']\n for move in self:\n if not move.is_subcontract:\n continue\n # Extra quantity is allowed when components do not need to be register\n if not move._has_tracked_subcontract_components():\n continue\n rounding = move.product_uom.rounding\n if float_compare(move.quantity_done, move.move_orig_ids.production_id.qty_produced, precision_rounding=rounding) > 0:\n overprocessed_moves |= move\n if overprocessed_moves:\n raise UserError(_(\"\"\"\nYou have to use 'Records Components' button in order to register quantity for a\nsubcontracted product(s) with tracked component(s):\n %s.\nIf you want to process more than initially planned, you\ncan use the edit + unlock buttons in order to adapt the initial demand on the\noperations.\"\"\") % ('\\n'.join(overprocessed_moves.mapped('product_id.display_name'))))",
"def set_so_pack_operation_lot(self, picking):\n StockProductionLot = self.env['stock.production.lot']\n sale_line_obj = self.env['sale.order.line']\n has_wrong_lots = False\n for del_move in picking.move_lines:\n del_move.move_line_ids.unlink()\n for move in picking.move_lines:\n picking_type = picking.picking_type_id\n # lots_necessary = True\n if picking_type:\n if not picking_type.use_existing_lots:\n picking_type.write({'use_existing_lots':True})\n # lots_necessary = picking_type and picking_type.use_existing_lots\n qty = 0\n qty_done = 0\n pack_lots = []\n pack_lot_id = []\n for ord_line in self.order_line:\n if ord_line.lot_id and ord_line.lot_id.product_id.id == move.product_id.id:\n pack_lot_id.append(ord_line.lot_id.id)\n # if pack_lot_names and lots_necessary:\n if pack_lot_id:\n for lot_id in list(set(pack_lot_id)):\n stock_production_lot = StockProductionLot.search([('id', '=', lot_id), ('product_id', '=', move.product_id.id)])\n sale_order_line = sale_line_obj.search([('lot_id', '=', lot_id),('order_id', '=', self.id), ('product_id', '=', move.product_id.id)])\n if stock_production_lot and sale_order_line:\n if stock_production_lot.product_id.tracking == 'lot':\n # if a lot nr is set through the frontend it will refer to the full quantity\n qty = sale_order_line[0].product_uom_qty\n else:\n qty = 1.0\n qty_done += qty\n pack_lots.append({'lot_id': stock_production_lot.id, 'qty': qty})\n else:\n has_wrong_lots = True\n # elif move.product_id.tracking == 'none' or not lots_necessary:\n elif move.product_id.tracking == 'none':\n qty_done = move.product_uom_qty\n else:\n has_wrong_lots = True\n for pack_lot in pack_lots:\n lot_id, qty = pack_lot['lot_id'], pack_lot['qty']\n self.env['stock.move.line'].create({\n 'move_id': move.id,\n 'product_id': move.product_id.id,\n 'product_uom_id': move.product_uom.id,\n 'qty_done': qty,\n 'location_id': move.location_id.id,\n 'location_dest_id': move.location_dest_id.id,\n 'lot_id': lot_id,\n })\n if not pack_lots:\n move.quantity_done = qty_done\n return has_wrong_lots",
"def stock_move_action_done(self):\n\t\tself.filtered(lambda move: move.state == 'draft').action_confirm()\n\n\t\tUom = self.env['product.uom']\n\t\tQuant = self.env['stock.quant']\n\n\t\tpickings = self.env['stock.picking']\n\t\tprocurements = self.env['procurement.order']\n\t\toperations = self.env['stock.pack.operation']\n\n\t\tremaining_move_qty = {}\n\n\t\tfor move in self:\n\t\t\tif move.picking_id:\n\t\t\t\tpickings |= move.picking_id\n\t\t\tremaining_move_qty[move.id] = move.product_qty\n\t\t\tfor link in move.linked_move_operation_ids:\n\t\t\t\toperations |= link.operation_id\n\t\t\t\tpickings |= link.operation_id.picking_id\n\n\t\t# Sort operations according to entire packages first, then package + lot, package only, lot only\n\t\toperations = operations.sorted(\n\t\t\tkey=lambda x: ((x.package_id and not x.product_id) and -4 or 0) + (x.package_id and -2 or 0) + (\n\t\t\tx.pack_lot_ids and -1 or 0))\n\n\t\tfor operation in operations:\n\n\t\t\t# product given: result put immediately in the result package (if False: without package)\n\t\t\t# but if pack moved entirely, quants should not be written anything for the destination package\n\t\t\tquant_dest_package_id = operation.product_id and operation.result_package_id.id or False\n\t\t\tentire_pack = not operation.product_id and True or False\n\n\t\t\t# compute quantities for each lot + check quantities match\n\t\t\tlot_quantities = dict((pack_lot.lot_id.id, operation.product_uom_id._compute_quantity(pack_lot.qty,\n\t\t\t operation.product_id.uom_id)\n\t\t\t ) for pack_lot in operation.pack_lot_ids)\n\n\t\t\tqty = operation.product_qty\n\t\t\tif operation.product_uom_id and operation.product_uom_id != operation.product_id.uom_id:\n\t\t\t\tqty = operation.product_uom_id._compute_quantity(qty, operation.product_id.uom_id)\n\t\t\tif operation.pack_lot_ids and float_compare(sum(lot_quantities.values()), qty,\n\t\t\t precision_rounding=operation.product_id.uom_id.rounding) != 0.0:\n\t\t\t\traise UserError(_(\n\t\t\t\t\t'You have a difference between the quantity on the operation and the quantities specified for the lots. '))\n\n\t\t\tquants_taken = []\n\t\t\tfalse_quants = []\n\t\t\tlot_move_qty = {}\n\n\t\t\tprout_move_qty = {}\n\t\t\tfor link in operation.linked_move_operation_ids:\n\t\t\t\tprout_move_qty[link.move_id] = prout_move_qty.get(link.move_id, 0.0) + link.qty\n\n\t\t\t# Process every move only once for every pack operation\n\t\t\tfor move in prout_move_qty.keys():\n\t\t\t\t# TDE FIXME: do in batch ?\n\t\t\t\tmove.check_tracking(operation)\n\n\t\t\t\t# TDE FIXME: I bet the message error is wrong\n\t\t\t\t# if not remaining_move_qty.get(move.id):\n\t\t\t\t# \traise UserError(_(\n\t\t\t\t# \t\t\"The roundings of your unit of measure %s on the move vs. %s on the product don't allow to do these operations or you are not transferring the picking at once. \") % (\n\t\t\t\t# \t move.product_uom.name, move.product_id.uom_id.name))\n\n\t\t\t\tif not operation.pack_lot_ids:\n\t\t\t\t\tpreferred_domain_list = [[('reservation_id', '=', move.id)], [('reservation_id', '=', False)],\n\t\t\t\t\t ['&', ('reservation_id', '!=', move.id),\n\t\t\t\t\t ('reservation_id', '!=', False)]]\n\t\t\t\t\tquants = Quant.quants_get_preferred_domain(\n\t\t\t\t\t\tprout_move_qty[move], move, ops=operation, domain=[('qty', '>', 0)],\n\t\t\t\t\t\tpreferred_domain_list=preferred_domain_list)\n\t\t\t\t\tQuant.quants_move(quants, move, operation.location_dest_id, location_from=operation.location_id,\n\t\t\t\t\t lot_id=False, owner_id=operation.owner_id.id,\n\t\t\t\t\t src_package_id=operation.package_id.id,\n\t\t\t\t\t dest_package_id=quant_dest_package_id, entire_pack=entire_pack)\n\t\t\t\telse:\n\t\t\t\t\t# Check what you can do with reserved quants already\n\t\t\t\t\tqty_on_link = prout_move_qty[move]\n\t\t\t\t\trounding = operation.product_id.uom_id.rounding\n\t\t\t\t\tfor reserved_quant in move.reserved_quant_ids:\n\t\t\t\t\t\tif (reserved_quant.owner_id.id != operation.owner_id.id) or (\n\t\t\t\t\t\t\treserved_quant.location_id.id != operation.location_id.id) or \\\n\t\t\t\t\t\t\t\t(reserved_quant.package_id.id != operation.package_id.id):\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\tif not reserved_quant.lot_id:\n\t\t\t\t\t\t\tfalse_quants += [reserved_quant]\n\t\t\t\t\t\telif float_compare(lot_quantities.get(reserved_quant.lot_id.id, 0), 0,\n\t\t\t\t\t\t precision_rounding=rounding) > 0:\n\t\t\t\t\t\t\tif float_compare(lot_quantities[reserved_quant.lot_id.id], reserved_quant.qty,\n\t\t\t\t\t\t\t precision_rounding=rounding) >= 0:\n\t\t\t\t\t\t\t\tlot_quantities[reserved_quant.lot_id.id] -= reserved_quant.qty\n\t\t\t\t\t\t\t\tquants_taken += [(reserved_quant, reserved_quant.qty)]\n\t\t\t\t\t\t\t\tqty_on_link -= reserved_quant.qty\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tquants_taken += [(reserved_quant, lot_quantities[reserved_quant.lot_id.id])]\n\t\t\t\t\t\t\t\tlot_quantities[reserved_quant.lot_id.id] = 0\n\t\t\t\t\t\t\t\tqty_on_link -= lot_quantities[reserved_quant.lot_id.id]\n\t\t\t\t\tlot_move_qty[move.id] = qty_on_link\n\n\t\t\t\tremaining_move_qty[move.id] -= prout_move_qty[move]\n\n\t\t\t# Handle lots separately\n\t\t\tif operation.pack_lot_ids:\n\t\t\t\t# TDE FIXME: fix call to move_quants_by_lot to ease understanding\n\t\t\t\tself._move_quants_by_lot(operation, lot_quantities, quants_taken, false_quants, lot_move_qty,\n\t\t\t\t quant_dest_package_id)\n\n\t\t\t# Handle pack in pack\n\t\t\tif not operation.product_id and operation.package_id and operation.result_package_id.id != operation.package_id.parent_id.id:\n\t\t\t\toperation.package_id.sudo().write({'parent_id': operation.result_package_id.id})\n\n\t\t# Check for remaining qtys and unreserve/check move_dest_id in\n\t\tmove_dest_ids = set()\n\t\tfor move in self:\n\t\t\tif float_compare(remaining_move_qty[move.id], 0,\n\t\t\t precision_rounding=move.product_id.uom_id.rounding) > 0: # In case no pack operations in picking\n\t\t\t\tmove.check_tracking(False) # TDE: do in batch ? redone ? check this\n\n\t\t\t\tpreferred_domain_list = [[('reservation_id', '=', move.id)], [('reservation_id', '=', False)],\n\t\t\t\t ['&', ('reservation_id', '!=', move.id), ('reservation_id', '!=', False)]]\n\t\t\t\tquants = Quant.quants_get_preferred_domain(\n\t\t\t\t\tremaining_move_qty[move.id], move, domain=[('qty', '>', 0)],\n\t\t\t\t\tpreferred_domain_list=preferred_domain_list)\n\t\t\t\tQuant.quants_move(\n\t\t\t\t\tquants, move, move.location_dest_id,\n\t\t\t\t\tlot_id=move.restrict_lot_id.id, owner_id=move.restrict_partner_id.id)\n\n\t\t\t# If the move has a destination, add it to the list to reserve\n\t\t\tif move.move_dest_id and move.move_dest_id.state in ('waiting', 'confirmed'):\n\t\t\t\tmove_dest_ids.add(move.move_dest_id.id)\n\n\t\t\tif move.procurement_id:\n\t\t\t\tprocurements |= move.procurement_id\n\n\t\t\t# unreserve the quants and make them available for other operations/moves\n\t\t\tmove.quants_unreserve()\n\n\t\t# Check the packages have been placed in the correct locations\n\t\tself.mapped('quant_ids').filtered(lambda quant: quant.package_id and quant.qty > 0).mapped(\n\t\t\t'package_id')._check_location_constraint()\n\n\t\t# set the move as done\n\t\tself.write({'state': 'done', 'date': time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)})\n\t\tprocurements.check()\n\t\t# assign destination moves\n\t\tif move_dest_ids:\n\t\t\t# TDE FIXME: record setise me\n\t\t\tself.browse(list(move_dest_ids)).action_assign_stock_move()\n\n\t\tpickings.filtered(lambda picking: picking.state == 'done' and not picking.date_done).write(\n\t\t\t{'date_done': time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)})\n\n\t\treturn True",
"def ingredient_used_canceled(self, item, quantity):\n logger.info('ReleaseDiscard ingredient used canceled initiated')\n try:\n quantity = Decimal(quantity).quantize(Decimal('0.11'))\n inventory_list = self.Inventory.search([('location', '=', self.used.id)]\n , order=[('batch_number', 'DESC')])\n product = self.Product.search([('name', '=', item),\n ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n done = False\n today = date.today()\n for i in inventory_list:\n for j in i.lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n # pdb.set_trace()\n if Decimal(j.quantity) >= Decimal(quantity):\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\n self.move(from_location=self.used, to_location=self.kitchen, item=product,\n quantity=quantity,\n batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=quantity, batch=i.batch_number)\n j.save()\n self.check_and_delete(i)\n done = True\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n self.move(from_location=self.used, to_location=self.kitchen, item=product,\n quantity=j.quantity, batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=j.quantity, batch=i.batch_number)\n j.quantity = 0\n j.save()\n self.check_and_delete(i)\n # transaction.cursor.commit()\n i.save()\n if done:\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False",
"def _action_done(self):\r\n\r\n # First, we loop over all the move lines to do a preliminary check: `qty_done` should not\r\n # be negative and, according to the presence of a picking type or a linked inventory\r\n # adjustment, enforce some rules on the `lot_id` field. If `qty_done` is null, we unlink\r\n # the line. It is mandatory in order to free the reservation and correctly apply\r\n # `action_done` on the next move lines.\r\n ml_to_delete = self.env['stock.move.line']\r\n for ml in self:\r\n # Check here if `ml.qty_done` respects the rounding of `ml.product_uom_id`.\r\n uom_qty = float_round(ml.qty_done, precision_rounding=ml.product_uom_id.rounding, rounding_method='HALF-UP')\r\n precision_digits = self.env['decimal.precision'].precision_get('Product Unit of Measure')\r\n qty_done = float_round(ml.qty_done, precision_digits=precision_digits, rounding_method='HALF-UP')\r\n if float_compare(uom_qty, qty_done, precision_digits=precision_digits) != 0:\r\n raise UserError(_('The quantity done for the product \"%s\" doesn\\'t respect the rounding precision \\\r\n defined on the unit of measure \"%s\". Please change the quantity done or the \\\r\n rounding precision of your unit of measure.') % (ml.product_id.display_name, ml.product_uom_id.name))\r\n\r\n qty_done_float_compared = float_compare(ml.qty_done, 0, precision_rounding=ml.product_uom_id.rounding)\r\n if qty_done_float_compared > 0:\r\n if ml.product_id.tracking != 'none':\r\n picking_type_id = ml.move_id.picking_type_id\r\n if picking_type_id:\r\n if picking_type_id.use_create_lots:\r\n # If a picking type is linked, we may have to create a production lot on\r\n # the fly before assigning it to the move line if the user checked both\r\n # `use_create_lots` and `use_existing_lots`.\r\n if ml.lot_name and ml.date_reference and not ml.lot_id:\r\n lot = self.env['stock.production.lot'].create(\r\n {'name': ml.lot_name, 'product_id': ml.product_id.id, 'date_refer': ml.date_reference}\r\n )\r\n ml.write({'lot_id': lot.id})\r\n data_dates = ml.lot_id._get_dattes(ml.product_id.id,ml.date_reference)\r\n for field, value in data_dates.items():\r\n setattr(ml.lot_id, field, value)\r\n elif not picking_type_id.use_create_lots and not picking_type_id.use_existing_lots:\r\n # If the user disabled both `use_create_lots` and `use_existing_lots`\r\n # checkboxes on the picking type, he's allowed to enter tracked\r\n # products without a `lot_id`.\r\n continue\r\n elif ml.move_id.inventory_id:\r\n # If an inventory adjustment is linked, the user is allowed to enter\r\n # tracked products without a `lot_id`.\r\n continue\r\n\r\n if not ml.lot_id:\r\n raise UserError(_('You need to supply a lot/serial number for %s.') % ml.product_id.name)\r\n elif qty_done_float_compared < 0:\r\n raise UserError(_('No negative quantities allowed'))\r\n else:\r\n ml_to_delete |= ml\r\n ml_to_delete.unlink()\r\n\r\n # Now, we can actually move the quant.\r\n done_ml = self.env['stock.move.line']\r\n for ml in self - ml_to_delete:\r\n if ml.product_id.type == 'product':\r\n Quant = self.env['stock.quant']\r\n rounding = ml.product_uom_id.rounding\r\n\r\n # if this move line is force assigned, unreserve elsewhere if needed\r\n if not ml.location_id.should_bypass_reservation() and float_compare(ml.qty_done, ml.product_qty, precision_rounding=rounding) > 0:\r\n extra_qty = ml.qty_done - ml.product_qty\r\n ml._free_reservation(ml.product_id, ml.location_id, extra_qty, lot_id=ml.lot_id, package_id=ml.package_id, owner_id=ml.owner_id, ml_to_ignore=done_ml)\r\n # unreserve what's been reserved\r\n if not ml.location_id.should_bypass_reservation() and ml.product_id.type == 'product' and ml.product_qty:\r\n try:\r\n Quant._update_reserved_quantity(ml.product_id, ml.location_id, -ml.product_qty, lot_id=ml.lot_id, package_id=ml.package_id, owner_id=ml.owner_id, strict=True)\r\n except UserError:\r\n Quant._update_reserved_quantity(ml.product_id, ml.location_id, -ml.product_qty, lot_id=False, package_id=ml.package_id, owner_id=ml.owner_id, strict=True)\r\n\r\n # move what's been actually done\r\n quantity = ml.product_uom_id._compute_quantity(ml.qty_done, ml.move_id.product_id.uom_id, rounding_method='HALF-UP')\r\n available_qty, in_date = Quant._update_available_quantity(ml.product_id, ml.location_id, -quantity, lot_id=ml.lot_id, package_id=ml.package_id, owner_id=ml.owner_id)\r\n if available_qty < 0 and ml.lot_id:\r\n # see if we can compensate the negative quants with some untracked quants\r\n untracked_qty = Quant._get_available_quantity(ml.product_id, ml.location_id, lot_id=False, package_id=ml.package_id, owner_id=ml.owner_id, strict=True)\r\n if untracked_qty:\r\n taken_from_untracked_qty = min(untracked_qty, abs(quantity))\r\n Quant._update_available_quantity(ml.product_id, ml.location_id, -taken_from_untracked_qty, lot_id=False, package_id=ml.package_id, owner_id=ml.owner_id)\r\n Quant._update_available_quantity(ml.product_id, ml.location_id, taken_from_untracked_qty, lot_id=ml.lot_id, package_id=ml.package_id, owner_id=ml.owner_id)\r\n Quant._update_available_quantity(ml.product_id, ml.location_dest_id, quantity, lot_id=ml.lot_id, package_id=ml.result_package_id, owner_id=ml.owner_id, in_date=in_date)\r\n done_ml |= ml\r\n # Reset the reserved quantity as we just moved it to the destination location.\r\n (self - ml_to_delete).with_context(bypass_reservation_update=True).write({\r\n 'product_uom_qty': 0.00,\r\n 'date': fields.Datetime.now(),\r\n })",
"def test_putaway_after_manufacturing_3(self):\n self.laptop.tracking = 'serial'\n mo_laptop = self.new_mo_laptop()\n serial = self.env['stock.production.lot'].create({'product_id': self.laptop.id, 'company_id': self.env.company.id})\n\n mo_form = Form(mo_laptop)\n mo_form.qty_producing = 1\n mo_form.lot_producing_id = serial\n mo_laptop = mo_form.save()\n mo_laptop.button_mark_done()\n\n # We check if the laptop go in the depot and not in the stock\n move = mo_laptop.move_finished_ids\n location_dest = move.move_line_ids.location_dest_id\n self.assertEqual(location_dest.id, self.depot_location.id)\n self.assertNotEqual(location_dest.id, self.stock_location.id)",
"def ingredient_used(self, item, quantity):\n logger.info('ReleaseDiscard ingredient used initiated')\n try:\n quantity = Decimal(quantity).quantize(Decimal('0.11'))\n inventory_list = self.Inventory.search([('location', '=', self.kitchen.id)]\n , order=[('batch_number', 'ASC')])\n product = self.Product.search([('name', '=', item),\n ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n done = False\n today = date.today()\n for i in inventory_list:\n for j in i.lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n if Decimal(j.quantity) >= Decimal(quantity):\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\n quantity=quantity,\n batch_number=i.batch_number)\n self.store_inventory(location=self.used, inventory_stock=j,\n quantity=quantity, batch=i.batch_number)\n j.save()\n self.check_and_delete(i)\n done = True\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\n quantity=j.quantity, batch_number=i.batch_number)\n self.store_inventory(location=self.used, inventory_stock=j,\n quantity=j.quantity, batch=i.batch_number)\n j.quantity = 0\n j.save()\n self.check_and_delete(i)\n # transaction.cursor.commit()\n i.save()\n if done:\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False",
"def test_excess_quantity(self):\n excess = self._uncertain_demand.excess_stock\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n variance = [(item - avg_order) for item in self._data_set.values()]\n stdev = pow(sum([pow(j, 2) for j in variance]) / len(self._data_set), 0.5)\n cal_safety = lambda x, y, z: x * y * (z ** 0.5)\n safety_stock = cal_safety(float(self._z_value), float(stdev), float(self._lead_time))\n cal_reorder_level = lambda x, y, z: ((x ** 0.5) * y) + z\n reorder = cal_reorder_level(float(self._lead_time), avg_order, float(safety_stock))\n cal_excess = lambda x, y, z: round(x - (y + (y - z)), 0) if x > y + (y - z) else 0\n test_excess = cal_excess(self._quantity_on_hand, reorder, safety_stock)\n self.assertEqual(int(excess), int(test_excess))",
"def _is_order_filled(self):\r\n if self.filled_quantity == self.quantity:\r\n self.order_finish()",
"def test_generate_04_generate_in_multiple_time(self):\n nbre_of_lines = 10\n move = self.get_new_move(nbre_of_lines)\n\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n ))\n # First assignment\n form_wizard.next_serial_count = 3\n form_wizard.next_serial_number = '001'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Second assignment\n form_wizard.next_serial_count = 2\n form_wizard.next_serial_number = 'bilou-64'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Third assignment\n form_wizard.next_serial_count = 4\n form_wizard.next_serial_number = 'ro-1337-bot'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n\n # Checks all move lines have the right SN\n generated_numbers = [\n # Correspond to the first assignment\n '001', '002', '003',\n # Correspond to the second assignment\n 'bilou-64', 'bilou-65',\n # Correspond to the third assignment\n 'ro-1337-bot', 'ro-1338-bot', 'ro-1339-bot', 'ro-1340-bot',\n ]\n self.assertEqual(len(move.move_line_ids), nbre_of_lines + len(generated_numbers))\n self.assertEqual(len(move.move_line_nosuggest_ids), len(generated_numbers))\n for move_line in move.move_line_nosuggest_ids:\n self.assertEqual(move_line.qty_done, 1)\n self.assertEqual(move_line.lot_name, generated_numbers.pop(0))\n for move_line in (move.move_line_ids - move.move_line_nosuggest_ids):\n self.assertEqual(move_line.qty_done, 0)\n self.assertEqual(move_line.lot_name, False)",
"def test_initial_risk_position_sizer_without_cap(self):\n fraction_at_risk = 0.23\n signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk, self.last_price, self.timer.now())\n orders = self.initial_risk_position_sizer.size_signals([signal])\n\n self.assertEqual(len(orders), 2) # market order and stop order\n portfolio_value = self.initial_position / self.initial_allocation\n target_quantity = float(np.floor(portfolio_value * self.initial_risk / fraction_at_risk))\n additional_contracts = target_quantity - self.initial_position\n self.assertEqual(orders[0], Order(self.ticker, additional_contracts, MarketOrder(), TimeInForce.OPG))\n\n stop_price = self.last_price * (1 - fraction_at_risk)\n stop_quantity = -(self.initial_position + additional_contracts)\n self.assertEqual(orders[1], Order(self.ticker, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))",
"def test_product_buy_more_then_have(self):\n result_buy = self.info_list.product_buy(\"соль 1 кг\", 50)\n self.assertFalse(result_buy)",
"def test_initial_risk_position_sizer_without_cap(self):\n fraction_at_risk = 0.23\n signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk)\n orders = self.initial_risk_position_sizer.size_signals([signal])\n\n self.assertEqual(len(orders), 2) # market order and stop order\n portfolio_value = self.initial_position / self.initial_allocation\n target_quantity = int(np.floor(portfolio_value * self.initial_risk / fraction_at_risk))\n additional_contracts = target_quantity - self.initial_position\n self.assertEqual(orders[0], Order(self.contract, additional_contracts, MarketOrder(), TimeInForce.OPG))\n\n stop_price = self.last_price * (1 - fraction_at_risk)\n stop_quantity = -(self.initial_position + additional_contracts)\n self.assertEqual(orders[1], Order(self.contract, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))",
"def test_fifo_with_nones(self):\n # Leave quant1, quant 2 with `in_date: False`\n # Leave quant 2 with no package, set quant1 and quant2 packages.\n self.quant1.write({\"package_id\": self.pack1.id})\n self.quant3.write({\"package_id\": self.pack3.id, \"in_date\": datetime.now()})\n\n # Reserve quantity - one apple\n reserved_quants = self.Quant._update_reserved_quantity(\n self.apple, self.test_stock_location_01, 1\n )\n reserved_quant = reserved_quants[0][0]\n\n self.assertFalse(reserved_quant.in_date)\n self.assertFalse(reserved_quant.package_id)\n self.assertEqual(reserved_quant, self.quant2)",
"def action_stagger_purchase_delivery(self):\n for wizard in self:\n #On vérifie que la quantité entrée est inférieure à la quantité de la ligne \n #d'achat \n purchase_line = wizard.purchase_line_id\n price_unit = purchase_line.price_unit\n if wizard.quantity <= 0:\n raise except_orm(_(\"Error\"), _('You must enter a quantity superior to 0'))\n \n if wizard.quantity >= purchase_line.sec_uom_qty:\n raise except_orm(_(\"Error\"), _('You must enter a quantity inferior to the initial purchase '\n 'line quantity'))\n \n #On récupère les valeurs entrées dans le wizard\n values = {'sec_uom_qty': wizard.quantity,\n 'expected_date': wizard.new_date}\n new_line = purchase_line.copy(values)\n new_line._onchange_sec_uom_qty(with_warning=False)\n new_line._onchange_uom_qty()\n new_line._onchange_uoi_qty()\n new_line.write({'price_unit': price_unit})\n #On décrémente la ligne initiale de la quantité de la nouvelle ligne (car celle-ci respecte forcément\n #le multiple et le minimum\n purchase_line.write({'sec_uom_qty': purchase_line.sec_uom_qty - wizard.quantity})\n purchase_line._onchange_sec_uom_qty(with_warning=False)\n purchase_line._onchange_uom_qty()\n purchase_line._onchange_uoi_qty()\n purchase_line.write({'price_unit': price_unit})\n #On retourne l'achat\n if wizard.purchase_id:\n action_dict = get_form_view(self, 'purchase.purchase_order_see_form')\n if action_dict and action_dict.get('id') and action_dict.get('type'):\n action = self.env[action_dict['type']].browse(action_dict['id'])\n action_struc = action.read()\n action_struc[0]['res_id'] = wizard.purchase_id.id\n action_struc = action_struc[0]\n \n return action_struc\n else:\n return {'type': 'ir.actions.act_window_close'}",
"def calc_qty(self, cr, uid, production_id, context=None):\n prod = self.pool.get('mrp.production').browse(cr, uid,production_id\n , context=context)\n done = 0.0\n for wo in prod.workcenter_lines:\n for mrej in wo.moves_rejection:\n done += mrej.s_rejected_qty or 0.0\n for move in prod.move_created_ids2:\n if move.product_id == prod.product_id:\n #ignore scrapped and extra consumed\n if (not move.scrapped) or (not move.extra_consumed):\n done += move.product_qty\n if (prod.product_qty - done) <= 0:\n raise osv.except_osv(_('Warning!'), _('Click on \"Force To Close\" button to generate remain scrap order.'))\n return (prod.product_qty - done) or prod.product_qty",
"def __confirm_trade_lots(\n self, trade_lots: int, trade_price: float, trader_fund: int\n ):\n final_trade_lots = 0\n trade_volume = abs(trade_lots) * self.board_lot\n if trade_lots > 0:\n if self.__have_enough_money(trader_fund, trade_price, trade_volume):\n final_trade_lots = trade_lots\n else:\n final_trade_lots = 0\n elif trade_lots < 0:\n hold_volume = self.hold_volume\n if self.__have_enough_volume(hold_volume, trade_volume):\n final_trade_lots = trade_lots\n else:\n final_trade_lots = 0\n return final_trade_lots",
"def test_fifo_without_nones(self):\n # Give each quant a package_id and in_date\n oldest_time = datetime.now() - timedelta(days=5)\n self.quant1.write({\"package_id\": self.pack1.id, \"in_date\": datetime.now()})\n self.quant2.write({\"package_id\": self.pack2.id, \"in_date\": oldest_time})\n self.quant3.write({\"package_id\": self.pack3.id, \"in_date\": oldest_time})\n\n # Reserve quantity - one apple\n reserved_quants = self.Quant._update_reserved_quantity(\n self.apple, self.test_stock_location_01, 1\n )\n reserved_quant = reserved_quants[0][0]\n\n # Should choose between quant2 and quant3 based on `in_date`.\n # Choose quant2 as it has a smaller package id.\n self.assertEqual(reserved_quant.in_date, oldest_time)\n self.assertEqual(reserved_quant.package_id, self.pack2)\n self.assertEqual(reserved_quant, self.quant2)",
"def test_fixed_order_quantity(self):\n fixed_order_quantity = self._uncertain_demand.fixed_order_quantity\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n cal_fixed_orders = lambda j, x, y, z: (2 * j * (x / (y * z))) ** 0.5\n test_fixed_orders = cal_fixed_orders(\n float(self._reorder_cost),\n float(avg_order),\n float(self._unit_cost),\n float(self._holding_cost_percentge)\n )\n\n self.assertEqual(int(fixed_order_quantity), int(test_fixed_orders))",
"def test_for_non_splittable_hand(self):\n hand = self._hand\n cards = [BjCard('clubs', '7'), BjCard('diamonds', '4')]\n for card in cards:\n hand.add_card(card)\n self.assertEqual(hand.can_split, False)",
"def parts_demand(request):\n critical_part = []\n quantity = None\n bom_name = None\n if request.method == 'POST':\n form = PartsDemandForm(request.POST)\n if form.is_valid():\n bom_name = form.cleaned_data['bom']\n quantity = int(form.cleaned_data['quantity'])\n warehouse = form.cleaned_data['warehouse']\n warehouse_obj = Warehouse.objects.get(warehouse_name=warehouse)\n stock = calculate_stock(warehouse_obj)\n parts = get_bom_parts(bom_name)\n print(stock)\n for part in parts:\n part_qty = float(part['Qty'])\n part_name = part['PartName']\n part_number = part['PartNumber']\n if stock.get(part_name):\n av_stock = stock.get(part_name)['total_usable_stock']\n # print(av_stock, quantity, part_qty, quantity * part_qty)\n else:\n av_stock = 0\n critical = int(av_stock) - int(quantity * part_qty)\n if critical <= 0:\n test = {\n \"critical_qty\": critical,\n \"part_number\": part_number,\n \"part_name\": part_name\n }\n critical_part.append(test)\n else:\n form = PartsDemandForm()\n context = {\n 'form': form,\n 'critical_part': critical_part,\n 'quantity': quantity,\n 'bom': bom_name,\n }\n\n return render(request, 'inventory/parts_demand.html', context)",
"def _action_done(self):\n for ml in self:\n if ml.lot_name_in == ml.lot_name_repeat:\n if ml.lot_id and ml.lot_name_in and ml.product_id.tracking == 'serial':\n ml.lot_id.name = ml.lot_name_in\n ml.lot_id.lot_name_chasis = ml.lot_name\n ml.lot_id.edicion = ml.move_id.edicion\n ml.lot_id.colorinterno = ml.move_id.colorinterno.id\n ml.lot_id.colorexterno = ml.move_id.colorexterno.id\n ml.lot_id.n_llaves = ml.n_llaves\n ml.lot_id.cant_llaves = ml.cant_llaves\n ml.lot_id.n_caja = ml.n_caja\n ml.lot_id.mot_desarmada = ml.mot_desarmada\n ml.lot_name = ml.lot_name_in\n ml.lot_id.embarque = ml.picking_id.embarque\n for incidence in ml.incidencia:\n ml.lot_id.incidencia = [(4, incidence.id)]\n for incid in ml.lot_id.incidencia:\n incid.lot_id = ml.lot_id.id\n else:\n raise ValidationError(_(\n 'El numero de chasis \"%s\" no esta igual que el repetido') % ml.lot_name_in)\n\n super(StockMoveLine, self)._action_done()",
"def test_initial_risk_position_sizer_with_cap(self):\n fraction_at_risk = 0.01 # will give leverage of 2, that will be capped to 1.5\n signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk, self.last_price, self.timer.now())\n orders = self.initial_risk_position_sizer.size_signals([signal])\n\n self.assertEqual(len(orders), 2) # market order and stop order\n portfolio_value = self.initial_position / self.initial_allocation\n max_leverage = self.initial_risk_position_sizer.max_target_percentage\n target_quantity = float(np.floor(portfolio_value * max_leverage))\n additional_contracts = target_quantity - self.initial_position\n self.assertEqual(orders[0], Order(self.ticker, additional_contracts, MarketOrder(), TimeInForce.OPG))\n\n stop_price = self.last_price * (1 - fraction_at_risk)\n stop_quantity = -(self.initial_position + additional_contracts)\n self.assertEqual(orders[1], Order(self.ticker, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))",
"def test_01_base(self):\n # Create/validate PO\n order = self.create_and_validate_po()\n\n # Validate picking\n picking = order.picking_ids[0]\n picking.do_transfer()\n self.assertEqual(picking.state, 'done')",
"def _buy(self, units=1):\n self.quantity -= units",
"def test_initial_risk_position_sizer_with_cap(self):\n fraction_at_risk = 0.01 # will give leverage of 2, that will be capped to 1.5\n signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk)\n orders = self.initial_risk_position_sizer.size_signals([signal])\n\n self.assertEqual(len(orders), 2) # market order and stop order\n portfolio_value = self.initial_position / self.initial_allocation\n max_leverage = self.initial_risk_position_sizer.max_target_percentage\n target_quantity = int(np.floor(portfolio_value * max_leverage))\n additional_contracts = target_quantity - self.initial_position\n self.assertEqual(orders[0], Order(self.contract, additional_contracts, MarketOrder(), TimeInForce.OPG))\n\n stop_price = self.last_price * (1 - fraction_at_risk)\n stop_quantity = -(self.initial_position + additional_contracts)\n self.assertEqual(orders[1], Order(self.contract, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))",
"def test_single_quant_assign_correct_quant(self):\n Quant = self.env[\"stock.quant\"]\n\n # Create a bunch of identical quants in the same location\n quants = Quant.browse()\n for i in range(5):\n quants |= self.create_quant(self.apple.id, self.test_stock_location_01.id, 10)\n self.assertEqual(len(quants), 5)\n\n quant = quants[2]\n pick = quant.create_picking(self.picking_type_pick, confirm=True, assign=True)\n self.assertEqual(pick.state, \"assigned\")\n self.assertEqual(quant.reserved_quantity, 10)",
"def test_purchase_order_product_bundle(self):\n self.purchase = self.env['purchase.order'].with_user(self.purchase_user).create(self.order_vals)\n self.assertTrue(self.purchase, 'Purchase: no purchase order created')\n self.assertEqual(self.purchase.invoice_status, 'no', 'Purchase: PO invoice_status should be \"Not purchased\"')\n self.assertEqual(self.purchase.order_line.mapped('qty_received'), [0.0, 0.0], 'Purchase: no product should be received\"')\n self.assertEqual(self.purchase.order_line.mapped('qty_invoiced'), [0.0, 0.0], 'Purchase: no product should be invoiced\"')\n\n self.purchase.button_confirm()\n self.assertEqual(self.purchase.state, 'purchase', 'Purchase: PO state should be \"Purchase\"')\n self.assertEqual(self.purchase.invoice_status, 'to invoice', 'Purchase: PO invoice_status should be \"Waiting Invoices\"')\n\n self.assertEqual(self.purchase.picking_count, 1, 'Purchase: one picking should be created\"')\n self.picking = self.purchase.picking_ids[0]\n self.picking.move_line_ids.write({'qty_done': 1.0})\n self.picking.button_validate()\n\n product_bundle_line = self.purchase.order_line.filtered(lambda l: l.product_id == self.product_bundle_id)\n product_3_line = self.purchase.order_line.filtered(lambda l: l.product_id == self.product_3)\n self.bundle_order_qty = sum(product_bundle_line.mapped('product_uom_qty'))\n self.product_3_order_qty = sum(product_3_line.mapped('product_uom_qty'))\n self.total_bundle_order_qty = self.count_item_pack *self.bundle_order_qty\n\n self.assertEqual(self.bundle_order_qty, 1, 'Purchase: product bundle ordered quantity')\n self.assertEqual(self.total_bundle_order_qty, 3, 'Purchase: product bundle total quantity')\n self.assertEqual(self.product_3_order_qty, 1, 'Purchase: product Samsung S20 ordered quantity')\n self.assertEqual(product_bundle_line.mapped('qty_received'), [self.total_bundle_order_qty], 'Purchase: the product bundle should be received\"')\n self.assertEqual(product_3_line.mapped('qty_received'), [self.product_3_order_qty], 'Purchase: the product samsung S20 should be received\"')\n \n move_form = Form(self.env['account.move'].with_context(default_move_type='in_invoice'))\n move_form.partner_id = self.vendor\n move_form.purchase_id = self.purchase\n self.bill = move_form.save()\n\n # Control Policy products is On ordered quantities\n # self.bundle_order_qty = 1\n # self.product_3_order_qty = 1\n self.assertEqual(self.purchase.order_line.mapped('qty_invoiced'), [1, 1], 'Purchase: all products should be invoiced based on ordered quantity\"')",
"def validate_product_quantity(item, qty):\n return True",
"def test_sell_ticket_valid_quantity(self, *_):\n # logout to invalidate any logged in session\n self.open(base_url + '/logout')\n # login a user\n self.open(base_url + '/login')\n # fill email and password\n self.type(\"#email\", \"test_frontend@test.com\")\n self.type(\"#password\", \"Test_frontend@\")\n # click enter button\n self.click('input[type=\"submit\"]')\n # open the /sell route\n self.open(base_url)\n # Enter an invalid ticket name\n self.type('#name_sell', \"ticketname\")\n self.type('#quantity_sell', \"-1\")\n self.type(\"#price_sell\", \"15\")\n self.type(\"#exp_date_sell\", \"20200921\")\n self.click('#submit-sell')\n # Assert that the valid error message is shown\n self.assert_text(\"Invalid quantity of tickets\", \"#message\")\n\n # logout to invalidate any logged in session\n self.open(base_url + '/logout')\n # login a user\n self.open(base_url + '/login')\n # fill email and password\n self.type(\"#email\", \"test_frontend@test.com\")\n self.type(\"#password\", \"Test_frontend@\")\n # click enter button\n self.click('input[type=\"submit\"]')\n # open the /sell route\n self.open(base_url)\n # Enter an invalid ticket name\n self.type('#name_sell', \"ticketname\")\n self.type('#quantity_sell', \"101\")\n self.type(\"#price_sell\", \"15\")\n self.type(\"#exp_date_sell\", \"20200921\")\n self.click('#submit-sell')\n # Assert that the valid error message is shown\n self.assert_text(\"Invalid quantity of tickets\", \"#message\")",
"def test_stock_quantity_own_part(self):\n self.portfolio = './app/test/payloads/port_own_part.json'\n self.stock = ['ETH', 'BTC']\n self.stock_url = 'https://min-api.cryptocompare.com/data/pricemultifull?fsyms=ETH&tsyms=USD'\n\n expected_data = {'ETH': 1.108, 'BTC': 0}\n\n #Run stock_quantity on test data\n self.add_perf = PortfolioAddPerf(self.portfolio, self.stock, self.stock_url)\n return_data = self.add_perf.stock_quantity()\n\n self.assertEqual(expected_data, return_data)",
"def test_for_splittable_hand_with_ten_value_cards(self):\n hand = self._hand\n cards = [BjCard('clubs', '10'), BjCard('diamonds', 'K')]\n for card in cards:\n hand.add_card(card)\n self.assertEqual(hand.can_split, True)",
"def determine_required_goods(self, output_amount: int):\n required_goods = self.required_goods.several(output_amount)\n required_labor = self.labor_amount * output_amount\n return required_goods, required_labor",
"def qty_available(quant) -> float:\n return quant.quantity - quant.reserved_quantity",
"def test_for_splittable_hand(self):\n hand = self._hand\n cards = [BjCard('clubs', '5'), BjCard('diamonds', '5')]\n for card in cards:\n hand.add_card(card)\n self.assertEqual(hand.can_split, True)",
"def test_cook_set_free(cook_busy, product_for_cook):\n cook_busy.set_free(True)\n # if product needs to be cooked\n assert product_for_cook.get_need_cook_status() is True\n cook_busy.cook_dish(product_for_cook)\n assert product_for_cook.get_need_cook_status() is False",
"async def depots_required(\n bot: sc2.BotAI,\n ) -> int:\n growth_speed = 0\n townhall_count = bot.structures(\n {UnitTypeId.COMMANDCENTER, UnitTypeId.PLANETARYFORTRESS, UnitTypeId.ORBITALCOMMAND}\n ).ready.amount\n\n rax_count = bot.structures(UnitTypeId.BARRACKS).ready.amount\n rax_count += bot.structures(UnitTypeId.BARRACKSREACTOR).ready.amount\n\n factory_count = bot.structures(UnitTypeId.FACTORY).ready.amount\n factory_count += bot.structures(UnitTypeId.FACTORYREACTOR).ready.amount\n starport_count = bot.structures(UnitTypeId.STARPORT).ready.amount\n starport_count += bot.structures(UnitTypeId.STARPORTREACTOR).ready.amount\n\n # Probes/scv take 12 seconds to build\n # https://liquipedia.net/starcraft2/Nexus_(Legacy_of_the_Void)\n growth_speed += townhall_count / 12.0\n\n # https://liquipedia.net/starcraft2/Barracks_(Legacy_of_the_Void)\n # fastest usage is marauder supply with 2 supply and train 21 seconds\n growth_speed += rax_count * 2 / 21.0\n\n # https://liquipedia.net/starcraft2/Factory_(Legacy_of_the_Void)\n # fastest usage is helliom with 2 supply and build time of 21 seconds\n growth_speed += factory_count * 2 / 21.0\n\n # https://liquipedia.net/starcraft2/Starport_(Legacy_of_the_Void)\n # We'll use viking timing here\n growth_speed += starport_count * 2 / 30.0\n\n growth_speed *= 1.2 # Just a little bit of margin of error\n build_time = 21 # depot build time\n # build_time += min(self.ai.time / 60, 5) # probe walk time\n\n predicted_supply = min(200, bot.supply_used + build_time * growth_speed)\n current_depots = bot.structures(\n {UnitTypeId.SUPPLYDEPOT, UnitTypeId.SUPPLYDEPOTLOWERED, UnitTypeId.SUPPLYDEPOTDROP}\n ).ready.amount\n\n if bot.supply_cap == 200:\n return current_depots\n\n return ceil((predicted_supply - bot.supply_cap) / 8) + current_depots",
"def create(self, request, *args, **kwargs):\n user = request.user\n\n # Copy the request data, to side-step \"mutability\" issues\n data = OrderedDict()\n # Update with cleaned input data\n data.update(self.clean_data(request.data))\n\n quantity = data.get('quantity', None)\n\n if quantity is None:\n raise ValidationError({\n 'quantity': _('Quantity is required'),\n })\n\n try:\n part = Part.objects.get(pk=data.get('part', None))\n except (ValueError, Part.DoesNotExist):\n raise ValidationError({\n 'part': _('Valid part must be supplied'),\n })\n\n # Set default location (if not provided)\n if 'location' not in data:\n location = part.get_default_location()\n\n if location:\n data['location'] = location.pk\n\n expiry_date = data.get('expiry_date', None)\n\n # An expiry date was *not* specified - try to infer it!\n if expiry_date is None and part.default_expiry > 0:\n data['expiry_date'] = datetime.now().date() + timedelta(days=part.default_expiry)\n\n # Attempt to extract serial numbers from submitted data\n serials = None\n\n # Check if a set of serial numbers was provided\n serial_numbers = data.get('serial_numbers', '')\n\n # Check if the supplier_part has a package size defined, which is not 1\n if 'supplier_part' in data and data['supplier_part'] is not None:\n try:\n supplier_part = SupplierPart.objects.get(pk=data.get('supplier_part', None))\n except (ValueError, SupplierPart.DoesNotExist):\n raise ValidationError({\n 'supplier_part': _('The given supplier part does not exist'),\n })\n\n if supplier_part.base_quantity() != 1:\n # Skip this check if pack size is 1 - makes no difference\n # use_pack_size = True -> Multiply quantity by pack size\n # use_pack_size = False -> Use quantity as is\n if 'use_pack_size' not in data:\n raise ValidationError({\n 'use_pack_size': _('The supplier part has a pack size defined, but flag use_pack_size not set'),\n })\n else:\n if bool(data.get('use_pack_size')):\n quantity = data['quantity'] = supplier_part.base_quantity(quantity)\n\n # Divide purchase price by pack size, to save correct price per stock item\n if data['purchase_price'] and supplier_part.pack_quantity_native:\n try:\n data['purchase_price'] = float(data['purchase_price']) / float(supplier_part.pack_quantity_native)\n except ValueError:\n pass\n\n # Now remove the flag from data, so that it doesn't interfere with saving\n # Do this regardless of results above\n if 'use_pack_size' in data:\n data.pop('use_pack_size')\n\n # Assign serial numbers for a trackable part\n if serial_numbers:\n\n if not part.trackable:\n raise ValidationError({\n 'serial_numbers': [_(\"Serial numbers cannot be supplied for a non-trackable part\")]\n })\n\n # If serial numbers are specified, check that they match!\n try:\n serials = extract_serial_numbers(\n serial_numbers,\n quantity,\n part.get_latest_serial_number()\n )\n\n # Determine if any of the specified serial numbers are invalid\n # Note \"invalid\" means either they already exist, or do not pass custom rules\n invalid = []\n errors = []\n\n for serial in serials:\n try:\n part.validate_serial_number(serial, raise_error=True)\n except DjangoValidationError as exc:\n # Catch raised error to extract specific error information\n invalid.append(serial)\n\n if exc.message not in errors:\n errors.append(exc.message)\n\n if len(errors) > 0:\n\n msg = _(\"The following serial numbers already exist or are invalid\")\n msg += \" : \"\n msg += \",\".join([str(e) for e in invalid])\n\n raise ValidationError({\n 'serial_numbers': errors + [msg]\n })\n\n except DjangoValidationError as e:\n raise ValidationError({\n 'quantity': e.messages,\n 'serial_numbers': e.messages,\n })\n\n if serials is not None:\n \"\"\"If the stock item is going to be serialized, set the quantity to 1.\"\"\"\n data['quantity'] = 1\n\n # De-serialize the provided data\n serializer = self.get_serializer(data=data)\n serializer.is_valid(raise_exception=True)\n\n with transaction.atomic():\n\n # Create an initial StockItem object\n item = serializer.save()\n\n if serials:\n # Assign the first serial number to the \"master\" item\n item.serial = serials[0]\n\n # Save the item (with user information)\n item.save(user=user)\n\n if serials:\n for serial in serials[1:]:\n\n # Create a duplicate stock item with the next serial number\n item.pk = None\n item.serial = serial\n\n item.save(user=user)\n\n response_data = {\n 'quantity': quantity,\n 'serial_numbers': serials,\n }\n\n else:\n response_data = serializer.data\n\n return Response(response_data, status=status.HTTP_201_CREATED, headers=self.get_success_headers(serializer.data))",
"def abc_transfer_wizard(self, lines, packages, data, params, res):\n # TODO: Add support for packages.\n res['results']['transfer'] = 'failure'\n action = self.do_enter_transfer_details()\n wizard = self.env['stock.transfer_details'].browse(action['res_id'])\n # Keep track of matched transfer items\n matched_ids = []\n for line in lines:\n if line['id'] > 0:\n # Original line. Match against item in wizard.\n if line['packop_id']:\n item = wizard.item_ids.filtered(lambda i: i.packop_id.id == line['packop_id']['id'])\n item.quantity = line['qty_done']\n matched_ids.append(item.id)\n else:\n # What if we don't have packop_id. Will this ever occur?\n _logger.warn(_(\"Couldn't match line (id %s) against existing transfer item!\\nlines:%s\\ntransfer items:%s\") % (line['id'], lines, wizard.item_ids.read()))\n else:\n # New line. Create a new item.\n # TODO: Split item based on original line from another package.\n item = wizard.item_ids.create({\n 'transfer_id': wizard.id,\n 'product_id': line['product_id']['id'],\n 'product_uom_id': line['product_uom_id']['id'],\n 'quantity': line['qty_done'],\n 'sourceloc_id': line['sourceloc_id']['id'],\n 'destinationloc_id': line['destinationloc_id']['id'],\n # 'result_package_id': line['result_package_id']['id'],\n # 'destinationloc_id': line['destinationloc_id']['id'],\n })\n matched_ids.append(item.id)\n extra_items = wizard.item_ids.filtered(lambda i: i.id not in matched_ids)\n if extra_items:\n _logger.warn(_(\"Found and deleted extra transfer items! %s\" % extra_items.read()))\n extra_items.unlink()\n wizard.do_detailed_transfer()\n res['results']['transfer'] = 'success'\n params['wizard'] = wizard",
"def test_generate_02_prefix_suffix(self):\n nbre_of_lines = 10\n # Case #1: Prefix, no suffix\n move = self.get_new_move(nbre_of_lines)\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n default_next_serial_number='bilou-87',\n default_next_serial_count=nbre_of_lines,\n ))\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Checks all move lines have the right SN\n generated_numbers = [\n 'bilou-87', 'bilou-88', 'bilou-89', 'bilou-90', 'bilou-91',\n 'bilou-92', 'bilou-93', 'bilou-94', 'bilou-95', 'bilou-96'\n ]\n for move_line in move.move_line_nosuggest_ids:\n # For a product tracked by SN, the `qty_done` is set on 1 when\n # `lot_name` is set.\n self.assertEqual(move_line.qty_done, 1)\n self.assertEqual(\n move_line.lot_name,\n generated_numbers.pop(0)\n )\n\n # Case #2: No prefix, suffix\n move = self.get_new_move(nbre_of_lines)\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n default_next_serial_number='005-ccc',\n default_next_serial_count=nbre_of_lines,\n ))\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Checks all move lines have the right SN\n generated_numbers = [\n '005-ccc', '006-ccc', '007-ccc', '008-ccc', '009-ccc',\n '010-ccc', '011-ccc', '012-ccc', '013-ccc', '014-ccc'\n ]\n for move_line in move.move_line_nosuggest_ids:\n # For a product tracked by SN, the `qty_done` is set on 1 when\n # `lot_name` is set.\n self.assertEqual(move_line.qty_done, 1)\n self.assertEqual(\n move_line.lot_name,\n generated_numbers.pop(0)\n )\n\n # Case #3: Prefix + suffix\n move = self.get_new_move(nbre_of_lines)\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n default_next_serial_number='alpha-012-345-beta',\n default_next_serial_count=nbre_of_lines,\n ))\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Checks all move lines have the right SN\n generated_numbers = [\n 'alpha-012-345-beta', 'alpha-012-346-beta', 'alpha-012-347-beta',\n 'alpha-012-348-beta', 'alpha-012-349-beta', 'alpha-012-350-beta',\n 'alpha-012-351-beta', 'alpha-012-352-beta', 'alpha-012-353-beta',\n 'alpha-012-354-beta'\n ]\n for move_line in move.move_line_nosuggest_ids:\n # For a product tracked by SN, the `qty_done` is set on 1 when\n # `lot_name` is set.\n self.assertEqual(move_line.qty_done, 1)\n self.assertEqual(\n move_line.lot_name,\n generated_numbers.pop(0)\n )\n\n # Case #4: Prefix + suffix, identical number pattern\n move = self.get_new_move(nbre_of_lines)\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n default_next_serial_number='BAV023B00001S00001',\n default_next_serial_count=nbre_of_lines,\n ))\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Checks all move lines have the right SN\n generated_numbers = [\n 'BAV023B00001S00001', 'BAV023B00001S00002', 'BAV023B00001S00003',\n 'BAV023B00001S00004', 'BAV023B00001S00005', 'BAV023B00001S00006',\n 'BAV023B00001S00007', 'BAV023B00001S00008', 'BAV023B00001S00009',\n 'BAV023B00001S00010'\n ]\n for move_line in move.move_line_nosuggest_ids:\n # For a product tracked by SN, the `qty_done` is set on 1 when\n # `lot_name` is set.\n self.assertEqual(move_line.qty_done, 1)\n self.assertEqual(\n move_line.lot_name,\n generated_numbers.pop(0)\n )",
"def test_operate_storage_initial(self, on):\n\n if on is False:\n override = {}\n else:\n override = {\"techs.test_supply_plus.constraints.storage_initial\": 0.5}\n m = build_model(\n override, \"simple_supply_and_supply_plus,operate,investment_costs\"\n )\n\n with pytest.warns(exceptions.ModelWarning) as warning:\n m.run(build_only=True)\n if on is False:\n assert check_error_or_warning(warning, \"Initial stored energy not defined\")\n assert (\n m._model_data.storage_initial.loc[\"a\", \"test_supply_plus\"].item() == 0\n )\n elif on is True:\n assert not check_error_or_warning(\n warning, \"Initial stored energy not defined\"\n )\n assert (\n m._model_data.storage_initial.loc[\"a\", \"test_supply_plus\"].item() == 0.5\n )",
"def test_single_quant(self):\n pick = self.quant_1.create_picking(self.picking_type_pick)\n # Confirm made in state draft\n self.assertEqual(pick.state, \"draft\")\n # Confirm quant location used if non specified\n self.assertEqual(pick.location_id, self.test_stock_location_01)\n # Confirm default dest location used if non specified\n self.assertEqual(pick.location_dest_id, self.picking_type_pick.default_location_dest_id)\n # Confirm correct picking type id associated\n self.assertEqual(pick.picking_type_id, self.picking_type_pick)\n # Check default priority is 0 = 'Normal'\n self.assertEqual(pick.priority, \"0\")\n # Check picking has correct products associated to it\n self.assertEqual(pick.product_id, self.apple)\n # Check picking has correct quantities associated to it\n self.assertEqual(pick.move_lines.product_id, self.apple)\n self.assertEqual(pick.move_lines.product_qty, 10)",
"def test_setup(self):\n assert self.transaction_behaviour.setup() is None\n self.assert_quantity_in_outbox(0)",
"def test_compute_partial_charges(self):\n # TODO: Test only one molecule for speed?\n # TODO: Do we need to deepcopy each molecule, or is setUp called separately for each test method?\n import numpy as np\n from simtk import unit\n\n # Do not modify original molecules.\n molecules = copy.deepcopy(mini_drug_bank())\n\n # Test a single toolkit at a time\n # Removed ['amber', 'amberff94'] from OE list, as those won't find the residue types they're expecting\n toolkit_to_charge_method = {\n OpenEyeToolkitWrapper: [\n \"mmff\",\n \"mmff94\",\n \"am1bcc\",\n \"am1bccnosymspt\",\n \"am1bccelf10\",\n ],\n AmberToolsToolkitWrapper: [\"bcc\", \"gas\", \"mul\"],\n }\n\n manual_skips = []\n\n manual_skips.append(\n \"ZINC1564378\"\n ) # Warning: OEMMFF94Charges: assigning OEMMFFAtomTypes failed on mol .\n manual_skips.append(\n \"ZINC00265517\"\n ) # Warning: OEMMFF94Charges: assigning OEMMFFAtomTypes failed on mol .\n\n for toolkit in list(toolkit_to_charge_method.keys()):\n toolkit_registry = ToolkitRegistry(toolkit_precedence=[toolkit])\n for charge_model in toolkit_to_charge_method[toolkit]:\n c = 0\n for molecule in molecules[:1]: # Just test first molecule to save time\n c += 1\n if molecule.name in manual_skips: # Manual skips, hopefully rare\n continue\n molecule.compute_partial_charges(\n charge_model=charge_model, toolkit_registry=toolkit_registry\n )\n charges1 = molecule._partial_charges\n # Make sure everything isn't 0s\n assert (abs(charges1 / unit.elementary_charge) > 0.01).any()\n # Check total charge\n charges_sum_unitless = charges1.sum() / unit.elementary_charge\n # if abs(charges_sum_unitless - float(molecule.total_charge)) > 0.0001:\n # print('c {} molecule {} charge_sum {} molecule.total_charge {}'.format(c, molecule.name,\n # charges_sum_unitless,\n # molecule.total_charge))\n # assert_almost_equal(charges_sum_unitless, molecule.total_charge, decimal=4)\n\n # Call should be faster second time due to caching\n # TODO: Implement caching\n molecule.compute_partial_charges(\n charge_model=charge_model, toolkit_registry=toolkit_registry\n )\n charges2 = molecule._partial_charges\n assert np.allclose(charges1, charges2, atol=0.002)",
"def stepCheckInitialAndFinalCheckbookInventory(self, sequence=None, sequence_list=None, **kw):\n # check the inventory of the bank account\n self.assertEqual(self.simulation_tool.getCurrentInventory(payment=self.bank_account_2.getRelativeUrl(), resource=self.currency_1.getRelativeUrl()), 100000)\n self.assertEqual(self.simulation_tool.getFutureInventory(payment=self.bank_account_2.getRelativeUrl(), resource=self.currency_1.getRelativeUrl()), 100000)",
"def action_confirm(self):\n if any(not l.is_available for l in self.mapped('order_line')):\n raise UserError(_('Some of your products in order does not have enough quantity available'))\n res = super(SaleOrder, self).action_confirm()\n return res",
"def test_charge_increment_model_invalid_number_of_cis(self, force_field):\n del force_field._parameter_handlers[\"ToolkitAM1BCC\"]\n cimh = force_field.get_parameter_handler(\n \"ChargeIncrementModel\",\n handler_kwargs={\"version\": \"0.3\", \"partial_charge_method\": \"formal_charge\"},\n )\n cimh.add_parameter(\n {\n \"smirks\": \"[C:1][C:2][O:3]\",\n \"charge_increment1\": 0.3 * unit.elementary_charge,\n \"charge_increment2\": -0.2 * unit.elementary_charge,\n \"charge_increment3\": -0.1 * unit.elementary_charge,\n }\n )\n\n # Add ONE MORE chargeincrement parameter than there are tagged atoms and ensure an exception is raised\n cimh.parameters[0].charge_increment.append(0.01 * unit.elementary_charge)\n top = Topology.from_molecules([create_ethanol()])\n with pytest.raises(\n SMIRNOFFSpecError,\n match=\"number of chargeincrements must be either the same\",\n ):\n force_field.create_openmm_system(top)\n\n # Ensure that parameterization with the correct number of increments DOES NOT raise an exception\n cimh.parameters[0].charge_increment = cimh.parameters[0].charge_increment[:2]\n force_field.create_openmm_system(top)\n\n # Add TWO LESS chargeincrement parameters than there are tagged atoms and ensure an exception is raised\n cimh.parameters[0].charge_increment = cimh.parameters[0].charge_increment[:1]\n with pytest.raises(\n SMIRNOFFSpecError,\n match=\"number of chargeincrements must be either the same\",\n ):\n force_field.create_openmm_system(top)",
"def change_product_qty(self):\n Inventory = self.env['stock.inventory']\n\n\n for wizard in self:\n product = wizard.product_id.with_context(location=wizard.location_id.id, lot_id=wizard.lot_id.id)\n line_data = wizard._action_start_line()\n\n\n if wizard.product_id.id and wizard.lot_id.id:\n inventory_filter = 'none'\n elif wizard.product_id.id:\n inventory_filter = 'product'\n else:\n inventory_filter = 'none'\n inventory = Inventory.create({\n 'name': _('INV: %s') % tools.ustr(wizard.product_id.display_name),\n 'filter': inventory_filter,\n 'product_id': wizard.product_id.id,\n 'location_id': wizard.location_id.id,\n 'lot_id': wizard.lot_id.id,\n 'line_ids': [(0, 0, line_data)],\n })\n inventory.action_done()\n return {'type': 'ir.actions.act_window_close'}",
"def test_lots_of_coins_given(self):\n item, change, _ = give_item_and_change('apple', '1.00 0.5 0.2 0.1 0.1 0.05 0.02 0.02 0.01')\n self.assertEqual(item, 'apple')\n self.assertEqual(change, [1.0, 0.5, 0.05, 0.02])",
"def test_act_iv(self):\n # setup\n self.transaction_behaviour.processing = None\n self.transaction_behaviour.waiting = []\n\n # operation\n self.transaction_behaviour.act()\n\n # after\n self.assert_quantity_in_outbox(0)",
"def _prepare_pack_ops(self, quants, forced_qties):\n valid_quants = quants.filtered(lambda quant: quant.qty > 0)\n _Mapping = namedtuple('Mapping', ('product', 'package', 'owner', 'location', 'location_dst_id','move_id'))\n all_products = valid_quants.mapped('product_id') | self.env['product.product'].browse(set(m.product_id.id for m,q in forced_qties)) | self.move_lines.mapped('product_id')\n computed_putaway_locations = dict(\n (product, self.location_dest_id.get_putaway_strategy(product) or self.location_dest_id.id) for product in all_products)\n product_to_uom = dict((product.id, product.uom_id) for product in all_products)\n picking_moves = self.move_lines.filtered(lambda move: move.state not in ('done', 'cancel'))\n for move in picking_moves:\n # If we encounter an UoM that is smaller than the default UoM or the one already chosen, use the new one instead.\n if move.product_uom != product_to_uom[move.product_id.id] and move.product_uom.factor > product_to_uom[move.product_id.id].factor:\n product_to_uom[move.product_id.id] = move.product_uom\n if len(picking_moves.mapped('location_id')) > 1:\n raise UserError(_('The source location must be the same for all the moves of the picking.'))\n if len(picking_moves.mapped('location_dest_id')) > 1:\n raise UserError(_('The destination location must be the same for all the moves of the picking.'))\n pack_operation_values = []\n # find the packages we can move as a whole, create pack operations and mark related quants as done\n top_lvl_packages = valid_quants._get_top_level_packages(computed_putaway_locations)\n for pack in top_lvl_packages:\n pack_quants = pack.get_content()\n pack_operation_values.append({\n 'picking_id': self.id,\n 'package_id': pack.id,\n 'product_qty': 1.0,\n 'location_id': pack.location_id.id,\n 'location_dest_id': computed_putaway_locations[pack_quants[0].product_id],\n 'owner_id': pack.owner_id.id,\n })\n valid_quants -= pack_quants\n # Go through all remaining reserved quants and group by product, package, owner, source location and dest location\n # Lots will go into pack operation lot object\n qtys_grouped = {}\n lots_grouped = {}\n for quant in valid_quants:\n key = _Mapping(quant.product_id, quant.package_id, quant.owner_id, quant.location_id, computed_putaway_locations[quant.product_id], quant.reservation_id)\n qtys_grouped.setdefault(key, 0.0)\n qtys_grouped[key] += quant.qty\n if quant.product_id.tracking != 'none' and quant.lot_id:\n lots_grouped.setdefault(key, dict()).setdefault(quant.lot_id.id, 0.0)\n lots_grouped[key][quant.lot_id.id] += quant.qty\n # Do the same for the forced quantities (in cases of force_assign or incomming shipment for example)\n for move_f, qty in forced_qties:\n if qty <= 0.0:\n continue\n key = _Mapping(move_f.product_id, self.env['stock.quant.package'], self.owner_id, self.location_id, computed_putaway_locations[move_f.product_id], move_f)\n qtys_grouped.setdefault(key, 0.0)\n qtys_grouped[key] += qty\n # Create the necessary operations for the grouped quants and remaining qtys\n Uom = self.env['product.uom']\n move_id_to_vals = {} # use it to create operations using the same order as the picking stock moves\n for mapping, qty in qtys_grouped.items():\n uom = product_to_uom[mapping.product.id]\n val_dict = {\n 'picking_id': self.id,\n 'product_qty': mapping.product.uom_id._compute_quantity(qty, uom),\n 'product_id': mapping.product.id,\n 'package_id': mapping.package.id,\n 'owner_id': mapping.owner.id,\n 'location_id': mapping.location.id,\n 'location_dest_id': mapping.location_dst_id,\n 'product_uom_id': uom.id,\n 'pack_lot_ids': [\n (0, 0, {'lot_id': lot, 'qty': 0.0, 'qty_todo': lots_grouped[mapping][lot]})\n for lot in lots_grouped.get(mapping, {}).keys()],\n }\n move_id_to_vals.setdefault(mapping.move_id.id, list()).append(val_dict)\n for move in self.move_lines.filtered(lambda move: move.state not in ('done', 'cancel')):\n values = move_id_to_vals.pop(move.id, [])\n pack_operation_values += values\n return pack_operation_values",
"def test_product_buy_missing_goods(self):\n result_buy = self.info_list.product_buy(\"хлеб серый хлебозавод\", 3)\n self.assertFalse(result_buy)",
"def test_empty_units(self):\n command_line = [\"filesystem\", \"create\", \"pn\", \"fn\", '--size=\"312\"']\n for prefix in [[], [\"--propagate\"]]:\n self.check_system_exit(prefix + command_line, _PARSE_ERROR)",
"def handle_quantity(self, line):\n #ok\n\n if line in [\"#c\", \"#C\"]:\n self.cancel_operation()\n return\n try:\n if line:\n new_qty = self.op_data['qty']\n #aqui tengo que escribir la nueva cantidad\n\n self.state = \"scan_location\"\n message = u\"Scan correcto. Scanee la ubicacion\\n\"\n message += self.get_operation_str(mode='scan_location')\n\n except Exception, e:\n str_error = u\"Error al cambiar la cantidad %s\\n\" % line\n self._snd(str_error + e.message)",
"def confirm_harvest_pickle(before, after):\n assert after.strategy.balanceOf > before.strategy.balanceOf\n assert after.strategy.pickleBalance == 0\n assert after.strategy.stakingRewards.stakedPickle == 0\n if before.sett.pricePerFullShare:\n assert after.sett.pricePerFullShare > before.sett.pricePerFullShare",
"def test_free_product(self):\n product = self.create_product(price=D('0.00'))\n\n res = self.do_get_basket()\n self.assertEqual(res.status_code, 200)\n basket_id = res.data['id']\n\n res = self.do_add_to_basket(product.id)\n self.assertEqual(res.status_code, 200)\n\n cs_url, cs_data = self.do_sign_auth_request(basket_id)\n\n self.assertEqual(cs_data['amount'], '0.00')\n\n res = self.do_cybersource_post(cs_url, cs_data)\n self.assertEqual(res.status_code, 302)\n self.check_finished_order(cs_data['reference_number'], product.id)",
"def test_check_bundle_4(self):\n self.tkt.data_add = set()\n import_genome.check_bundle(self.bndl,\n ticket_ref=\"ticket\",\n file_ref=\"flat_file\",\n retrieve_ref=\"phagesdb\",\n retain_ref=\"mysql\")\n count = count_status(self.bndl, \"error\", \"warning\")\n with self.subTest():\n self.assertEqual(len(self.bndl.evaluations), 5)\n with self.subTest():\n self.assertEqual(count, 0)",
"def test_assign_charges_to_molecule_in_parts_using_multiple_library_charges(self):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_in_parts_ff,\n )\n\n molecules = [\n Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\")),\n Molecule.from_file(get_data_file_path(\"molecules/ethanol_reordered.sdf\")),\n ]\n top = Topology.from_molecules(molecules)\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n expected_charges = [\n -0.2,\n -0.1,\n 0.3,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n -0.2,\n 0.3,\n -0.1,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n ] * openmm_unit.elementary_charge\n for particle_index, expected_charge in enumerate(expected_charges):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q == expected_charge",
"def put_ask(curr, depth, asset, price, price2):\n #Transaction 1\n tmp_list = bitty.buy_limit(asset+\"-\"+curr, depth, price)\n time.sleep(5) #wait for network latency\n wait = 0\n while wait < 15:\n oList = bitty.get_open_orders(asset + \"-\" + curr)['result']\n if oList: #if there are orders open, wait until 15\n wait += 1\n print(\"Alt order outstanding\")\n else:#order is filled, switch liquidity assets\n break\n time.sleep(1)\n print(wait)\n if wait == 15: #if it's been 15 seconds and the order is not filled, cancel it\n\n for o in oList:\n orderId = o['OrderUuid']\n bitty.cancel(orderId)\n time.sleep(5)\n if asset == \"BTC\":\n asset = \"ETH\"\n elif asset == \"ETH\":\n asset = \"BTC\"\n bal_result = bitty.get_balance(curr)['result'] # gets exact balance of the altcoin, including dust\n depth_to_main = bal_result['Balance']\n print(\"Order canceled, submitting sell order for any quantity filled.\")\n bitty.sell_limit(asset + \"-\" + curr, depth_to_main, price2)\n return(asset) #back to searching\n\n if asset == \"BTC\":\n asset = \"ETH\"\n elif asset == \"ETH\":\n asset = \"BTC\"\n\n #Transaction 2\n bal_result = bitty.get_balance(curr)['result'] # gets exact balance of the altcoin, including dust\n depth_to_main = bal_result['Balance']\n print(depth_to_main)\n print(\"Submitting transaction 2, please wait, this may take a while.\")\n tmp_list = bitty.sell_limit(asset + \"-\" + curr, depth_to_main, price2)\n while tmp_list['success'] == False:\n print(\"Order failed.\")\n time.sleep(5)\n tmp_list = bitty.sell_limit(asset + \"-\" + curr, depth_to_main, price2)\n\n time.sleep(15)#wait for latency\n wait = 5\n oList= []\n while wait < 86400: #wait ten minutes\n oList = bitty.get_open_orders(asset + \"-\" + curr)['result']\n if oList:\n wait += 5\n if wait % 60 == 0:\n price2 = recast_lower_sell(oList, asset, curr, price2)\n #elif wait > 675:\n # price2 = recast_lower_sell(oList, asset, curr, depth_to_main, price2)\n print(\"Main order outstanding\")\n else:\n return(asset)\n time.sleep(5)\n if wait == 86400:\n return(\"timeout\")",
"def test_library_charges_dont_parameterize_molecule_because_of_incomplete_coverage(\n self,\n ):\n molecules = [Molecule.from_file(get_data_file_path(\"molecules/toluene.sdf\"))]\n top = Topology.from_molecules(molecules)\n\n # The library charges in the FF should not be able to fully cover toluene\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n # Delete the ToolkitAM1BCCHandler so the molecule won't get charges from anywhere\n del ff._parameter_handlers[\"ToolkitAM1BCC\"]\n with pytest.raises(\n RuntimeError, match=\"Cc1ccccc1 could not be fully assigned charges\"\n ):\n omm_system = ff.create_openmm_system(top)\n\n # If we do NOT delete the ToolkiAM1BCCHandler, then toluene should be assigned some nonzero partial charges.\n # The exact value will vary by toolkit, so we don't test that here.\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n for particle_index in range(top.n_atoms):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q != 0 * unit.elementary_charge",
"def test_manager_add_task_material_wrong(self):\n try:\n # Material with `quantity = 0.0`\n self.action.write({\"material_ids\": [(\n 0, 0, {\"product_id\": self.product.id, \"quantity\": 0.0})]})\n except ValidationError as err:\n self.assertEqual(\n str(err.args[0]),\n \"Quantity of material consumed must be greater than 0.\")\n\n try:\n # Material with `negative quantity`\n self.action.write({\"material_ids\": [(\n 0, 0, {\"product_id\": self.product.id, \"quantity\": -10.0})]})\n except ValidationError as err:\n self.assertEqual(\n str(err.args[0]),\n \"Quantity of material consumed must be greater than 0.\")",
"def prepare_funding(self):\n entity_miner = self.entities[0]\n\n entity_miner.send_bitcoins(entity_miner.address)\n entity_miner.purchase_mastercoins(500.0)\n\n self.generate_block()\n self.check_balance(entity_miner.address, MSC, '50000.00000000', '0.00000000')\n self.check_balance(entity_miner.address, TMSC, '50000.00000000', '0.00000000')",
"def test_error_num_qubits(self, basis_state, wires):\n\n with pytest.raises(ValueError, match=\"'basis_state' must be of shape\"):\n BasisStatePreparation(basis_state, wires)",
"def clean(self):\n cleaned_data = super().clean()\n variant = cleaned_data.get('variant')\n quantity = cleaned_data.get('quantity')\n if variant and quantity is not None:\n try:\n variant.check_quantity(quantity)\n except InsufficientStock as e:\n error = forms.ValidationError(\n pgettext_lazy(\n 'Add item form error',\n 'Could not add item. '\n 'Only %(remaining)d remaining in stock.' %\n {'remaining': e.item.quantity_available}))\n self.add_error('quantity', error)\n return cleaned_data",
"def test_teleport_minimal_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.teleport_circuit()\n targets = ref_algorithms.teleport_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)",
"def test_shortage_quantity(self):\n shortages = self._uncertain_demand.shortages\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n variance = [(item - avg_order) for item in self._data_set.values()]\n stdev = pow(sum([pow(j, 2) for j in variance]) / len(self._data_set), 0.5)\n cal_safety = lambda x, y, z: x * y * (z ** 0.5)\n safety_stock = cal_safety(float(self._z_value), float(stdev), float(self._lead_time))\n cal_reorder_level = lambda x, y, z: ((x ** 0.5) * y) + z\n reorder = cal_reorder_level(float(self._lead_time), avg_order, float(safety_stock))\n cal_shortages = lambda l, k, j, x, y: round(abs(((j + (j - k)) - l) + x)) if l < k else 0\n test_shortage = cal_shortages(\n self._quantity_on_hand,\n safety_stock, reorder,\n self._quantity_on_hand,\n self._backlog\n )\n self.assertEqual(shortages, test_shortage)",
"def test_multiple_quants(self):\n # Get all quants in test package\n quants = self.quant_1 | self.quant_2\n pick = quants.create_picking(self.picking_type_pick)\n # Check picking has correct location\n self.assertEqual(pick.location_id, self.stock_location)\n # Check picking has correct products and quantities associated to it\n self.assertEqual(pick.move_lines.product_id, quants.product_id)\n self.assertEqual(pick.move_lines.mapped(\"product_qty\"), [10.0, 10.0])",
"def onchange_begin_transaction(self,cr,uid,ids,lot_id,pieces,length,heigth,width,context=None):\n if context is None:\n context = {}\n res = {'value':{}}\n \n if lot_id:\n \n lot_obj = self.pool.get('stock.production.lot')\n product_obj = self.pool.get('product.uom')\n lot_brw = lot_obj.browse(cr,uid,lot_id,context=context)\n area = lot_brw.virtual\n \n if lot_brw.product_id.stock_driver == 'normal' :\n res['value'].update({'factor': 3})\n if lot_brw.product_id.stock_driver == 'tile' :\n res['value'].update({'factor': 2})\n if lot_brw.product_id.stock_driver == 'slab' :\n res['value'].update({'factor': 1})\n if lot_brw.product_id.stock_driver == 'block' :\n res['value'].update({'factor': 0})\n \n res['value'].update({'length':lot_brw.length})\n res['value'].update({'length1':lot_brw.length})\n res['value'].update({'heigth':lot_brw.heigth})\n res['value'].update({'heigth1':lot_brw.heigth})\n res['value'].update({'width':lot_brw.width})\n res['value'].update({'width1':lot_brw.width})\n \n if lot_brw.product_id.stock_driver == 'tile' :\n if pieces == False:\n pieces = product_obj._compute_pieces2(cr, uid,lot_brw.product_id.stock_driver, lot_brw.virtual, lot_brw.length, lot_brw.heigth, lot_brw.width)\n else:\n area = product_obj._compute_area(cr, uid,lot_brw.product_id.stock_driver, pieces, lot_brw.length, lot_brw.heigth, lot_brw.width)\n res['value'].update({'length':lot_brw.length})\n res['value'].update({'length1':lot_brw.length})\n res['value'].update({'heigth':lot_brw.heigth})\n res['value'].update({'heigth1':lot_brw.heigth})\n res['value'].update({'width':lot_brw.width})\n res['value'].update({'width1':lot_brw.width})\n res['value'].update({'pieces_qty':pieces})\n res['value'].update({'pieces_qty1':pieces})\n res['value'].update({'quantity':area})\n res['value'].update({'quantity1':area})\n\n if lot_brw.product_id.stock_driver in ('slab','block'):\n pieces = 1\n area = product_obj._compute_area(cr, uid,lot_brw.product_id.stock_driver, pieces,length,heigth,width)\n res['value'].update({'quantity': area})\n res['value'].update({'quantity1': area})\n \n if lot_brw.virtual == 0:\n raise osv.except_osv(_('Processing Error'), _('The lot specified is not available in the stock')\\\n ) \n return res",
"def _update_reserved_quantity(self, product_id, location_id, quantity, lot_id=None, package_id=None, owner_id=None,\n strict=False):\n self = self.sudo()\n rounding = product_id.uom_id.rounding\n quants = self._gather(product_id, location_id, lot_id=lot_id, package_id=package_id, owner_id=owner_id,\n strict=strict)\n reserved_quants = []\n\n if float_compare(quantity, 0, precision_rounding=rounding) > 0:\n # if we want to reserve\n available_quantity = self._get_available_quantity(product_id, location_id, lot_id=lot_id,\n package_id=package_id, owner_id=owner_id, strict=strict)\n if float_compare(quantity, available_quantity, precision_rounding=rounding) > 0:\n raise UserError(_('It is not possible to reserve more products of %s than you have in stock.',\n product_id.display_name))\n elif float_compare(quantity, 0, precision_rounding=rounding) < 0:\n # if we want to unreserve\n available_quantity = sum(quants.mapped('reserved_quantity'))\n # if float_compare(abs(quantity), available_quantity, precision_rounding=rounding) > 0:\n # raise UserError(_('It is not possible to unreserve more products of %s than you have in stock.',\n # product_id.display_name))\n else:\n return reserved_quants\n\n for quant in quants:\n if float_compare(quantity, 0, precision_rounding=rounding) > 0:\n max_quantity_on_quant = quant.quantity - quant.reserved_quantity\n if float_compare(max_quantity_on_quant, 0, precision_rounding=rounding) <= 0:\n continue\n max_quantity_on_quant = min(max_quantity_on_quant, quantity)\n quant.reserved_quantity += max_quantity_on_quant\n reserved_quants.append((quant, max_quantity_on_quant))\n quantity -= max_quantity_on_quant\n available_quantity -= max_quantity_on_quant\n else:\n max_quantity_on_quant = min(quant.reserved_quantity, abs(quantity))\n quant.reserved_quantity -= max_quantity_on_quant\n reserved_quants.append((quant, -max_quantity_on_quant))\n quantity += max_quantity_on_quant\n available_quantity += max_quantity_on_quant\n\n if float_is_zero(quantity, precision_rounding=rounding) or float_is_zero(available_quantity,\n precision_rounding=rounding):\n break\n return reserved_quants",
"def test_check_bundle_6(self):\n self.tkt.data_retrieve = set()\n import_genome.check_bundle(self.bndl,\n ticket_ref=\"ticket\",\n file_ref=\"flat_file\",\n retrieve_ref=\"phagesdb\",\n retain_ref=\"mysql\")\n count = count_status(self.bndl, \"error\", \"warning\")\n with self.subTest():\n self.assertEqual(len(self.bndl.evaluations), 5)\n with self.subTest():\n self.assertEqual(count, 0)",
"def action_consume_custom(self, cr, uid, ids, product_qty, location_id=False, restrict_lot_id=False, restrict_partner_id=False,\r\n consumed_for=False, context=None):\r\n if context is None:\r\n context = {}\r\n res = []\r\n production_obj = self.pool.get('mrp.production.custom')\r\n\r\n if product_qty <= 0:\r\n raise osv.except_osv(_('Warning!'), _('Please provide proper quantity.'))\r\n #because of the action_confirm that can create extra moves in case of phantom bom, we need to make 2 loops\r\n ids2 = []\r\n for move in self.browse(cr, uid, ids, context=context):\r\n if move.state == 'draft':\r\n ids2.extend(self.action_confirm(cr, uid, [move.id], context=context))\r\n else:\r\n ids2.append(move.id)\r\n\r\n prod_orders = set()\r\n for move in self.browse(cr, uid, ids2, context=context):\r\n prod_orders.add(move.custom_production_id.id)\r\n print\"Total Qty>>>\",product_qty\r\n move_qty = product_qty\r\n if move_qty <= 0.00:\r\n raise osv.except_osv(_('Error!'), _('Cannot consume a move with negative or zero quantity.'))\r\n \r\n quantity_rest = move_qty - product_qty\r\n print\"Rest Qty>>>\",quantity_rest\r\n # Compare with numbers of move uom as we want to avoid a split with 0 qty\r\n quantity_rest_uom = move.product_uom_qty - self.pool.get(\"product.uom\")._compute_qty_obj(cr, uid, move.product_id.uom_id, product_qty, move.product_uom)\r\n if float_compare(quantity_rest_uom, 0, precision_rounding=move.product_uom.rounding) != 0:\r\n new_mov = self.split(cr, uid, move, quantity_rest, context=context)\r\n print\"New Move>>>\",new_mov\r\n res.append(new_mov)\r\n vals = {'restrict_lot_id': restrict_lot_id,\r\n 'restrict_partner_id': restrict_partner_id,\r\n 'consumed_for': consumed_for}\r\n if location_id:\r\n vals.update({'location_id': location_id})\r\n self.write(cr, uid, [move.id], vals, context=context)\r\n # Original moves will be the quantities consumed, so they need to be done\r\n self.action_done(cr, uid, ids2, context=context)\r\n if res:\r\n self.action_assign(cr, uid, res, context=context)\r\n if prod_orders:\r\n \r\n production_obj.action_in_production(cr, uid, list(prod_orders), context=None)\r\n #production_obj.signal_workflow(cr, uid, list(prod_orders), 'button_produce')\r\n return res",
"def test_split_payment_with_discount_and_adjustment(self):\n debit_jobs(\n [\n (self.job, A(480), Entry.FLAT_DEBIT),\n (self.job2, A(480), Entry.WORK_DEBIT),\n ]\n )\n self.assertEquals(A(480), self.job2.account.balance)\n self.assert_balances(promised=A(960), balance=A(480), invoiced=A(480))\n credit_jobs(\n [\n (self.job, A(440), A(0), A(40)), # adjusted\n (self.job2, A(460), A(20), A(0)), # discounted\n ],\n D(900),\n )\n self.assert_balances(\n bank=A(900, 0, 0),\n debited=A(480),\n invoiced=A(440), # debited (480) + adjustment (-40) = invoiced (440)\n paid=A(-440),\n credited=A(-480), # payment (-440) + adjustment (-40) = credited (-480)\n partial=A(900).net_amount,\n tax=A(900).tax_amount,\n )\n self.assert_balances(\n bank=A(900, 0, 0),\n debited=A(480),\n invoiced=A(480), # debited (480) + adjustment (0) = invoiced (480)\n paid=A(-480),\n credited=A(-480), # payment (-480) + adjustment (0) = credited (-480)\n partial=A(900).net_amount,\n tax=A(900).tax_amount,\n switch_to_job=self.job2,\n )",
"def test_funny_units(self):\n command_line = [\"filesystem\", \"create\", \"pn\", \"fn\", '--size=\"312WiB\"']\n for prefix in [[], [\"--propagate\"]]:\n self.check_system_exit(prefix + command_line, _PARSE_ERROR)",
"def test_deal_sufficient_cards(self):\n cards = self.deck._deal(10)\n self.assertEqual(len(cards), 10)\n self.assertEqual(self.deck.count(), 42)",
"def test_amount_not_enough(self):\n item, change, _ = give_item_and_change('coke', .50)\n self.assertIsNone(item)\n self.assertEqual(change, 0.5)",
"def test_required_deleted_chain_gets_stubbed(self):\n self.txn.store_delete(\"felix-b\")\n self.assertEqual(self.txn.affected_chains, set([\"felix-b\"]))\n self.assertEqual(self.txn.chains_to_stub_out, set([\"felix-b\"]))\n self.assertEqual(self.txn.chains_to_delete, set())\n self.assertEqual(self.txn.referenced_chains,\n set([\"felix-b\", \"felix-stub\"]))\n self.assertEqual(\n self.txn.prog_chains,\n {\n \"felix-a\": [],\n \"felix-c\": [],\n })\n self.assertEqual(self.txn.required_chns,\n {\"felix-a\": set([\"felix-b\", \"felix-stub\"])})\n self.assertEqual(self.txn.requiring_chns,\n {\"felix-b\": set([\"felix-a\"]),\n \"felix-stub\": set([\"felix-a\"])})",
"def destroy(self, good, quantity=None):\n if quantity is None:\n self._haves[good] = 0\n else:\n self._haves[good] -= quantity\n if self._haves[good] < 0:\n self._haves[good] = 0\n raise NotEnoughGoods(self.name, good, quantity - self._haves[good])",
"def warehouse_officer_confirm_qty(self):\n if (\n self.approve_request_ids is None\n or self.approve_request_ids is False\n ):\n raise UserError(\"No line(s) defined!\")\n self._compute_confirm()\n for line in self.approve_request_ids:\n line._compute_state()\n if any(line.state != \"available\" for line in self.approve_request_ids):\n raise Warning(\n \"Please procure the items that are short in stock or process pending purchase agreements and try again!\"\n )\n else:\n self.state = 'transfer'",
"def test_set_pack_number(self):\n\n # Setup new games and attempt to set their number of packs\n valid_packs = [\n 1,\n 2,\n 3,\n 4,\n 5,\n 100,\n ]\n for packs in valid_packs:\n game = Game()\n game.setup_new_game()\n self.assertEqual(game.state.name, \"get_number_of_packs\", msg=\"The initial game state was not correctly set.\")\n game.set_pack_number(packs)\n self.assertEqual(len(game.deck), packs * 52, msg=\"The number of packs was not correctly set with \" + str(packs) + \" packs.\")\n\n # Make sure that the new game state was correctly set\n self.assertEqual(game.state.name, \"get_player_chips\", msg=\"The game state after setting the number of packs was not correctly set.\")\n\n # Try to set invalid pack numbers\n invalid_packs = [\n -1,\n 0,\n -100,\n 1.5,\n ]\n for packs in invalid_packs:\n game = Game()\n game.setup_new_game()\n self.assertEqual(game.state.name, \"get_number_of_packs\", msg=\"The initial game state was not correctly set.\")\n success = False\n try:\n game.set_pack_number(packs)\n except InvalidPackNumber:\n success = True\n self.assertTrue(success, msg=\"An invalid number of packs \" + str(packs) + \" was able to be set.\")\n\n # Try to reset the number of packs to throw an error\n game = Game()\n game.setup_new_game()\n self.assertEqual(game.state.name, \"get_number_of_packs\", msg=\"The initial game state was not correctly set.\")\n game.set_pack_number(1)\n success = False\n try:\n game.set_pack_number(1)\n except InvalidGameMethodOrder:\n success = True\n self.assertTrue(success, msg=\"The number of packs in a deck was incorrectly able to be reset.\")",
"def buy_stock(\n real_movement,\n signal,\n initial_money = 10000,\n max_buy = 1,\n max_sell = 1,\n):\n starting_money = initial_money\n states_sell = []\n states_buy = []\n states_money = []\n current_inventory = 0\n \n def buy(i, initial_money, current_inventory):\n shares = initial_money // real_movement[i]\n if shares < 1:\n print(\n 'day %d: total balances %f, not enough money to buy a unit price %f'\n % (i, initial_money, real_movement[i])\n )\n else:\n if shares > max_buy:\n buy_units = max_buy\n else:\n buy_units = shares\n initial_money -= buy_units * real_movement[i]\n current_inventory += buy_units\n print(\n 'day %d: buy %d units at price %f, total balance %f'\n % (i, buy_units, buy_units * real_movement[i], initial_money)\n )\n states_buy.append(0)\n return initial_money, current_inventory\n \n for i in range(real_movement.shape[0]):\n state = signal[i]\n if state == 1:\n initial_money, current_inventory = buy(\n i, initial_money, current_inventory\n )\n states_buy.append(i)\n elif state == -1:\n if current_inventory == 0:\n print('day %d: cannot sell anything, inventory 0' % (i))\n else:\n if current_inventory > max_sell:\n sell_units = max_sell\n else:\n sell_units = current_inventory\n current_inventory -= sell_units\n total_sell = sell_units * real_movement[i]\n initial_money += total_sell\n try:\n invest = (\n (real_movement[i] - real_movement[states_buy[-1]])\n / real_movement[states_buy[-1]]\n ) * 100\n except:\n invest = 0\n print(\n 'day %d, sell %d units at price %f, investment %f %%, total balance %f,'\n % (i, sell_units, total_sell, invest, initial_money)\n )\n states_sell.append(i)\n states_money.append(initial_money)\n \n invest = ((initial_money - starting_money) / starting_money) * 100\n total_gains = initial_money - starting_money\n return states_buy, states_sell, total_gains, invest, states_money",
"def release(self, item, quantity):\n logger.info('ReleaseDiscard item release initiated')\n try:\n with Transaction().start(DBNAME, 1) as transaction:\n transaction.context = config.get_config().context\n quantity = Decimal(quantity)\n inventory_list = self.Inventory.search([('location', '=', self.inventory.id)]\n , order=[('batch_number', 'ASC')])\n product = self.Product.search([('name', '=', item),\n ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n done = False\n today = date.today()\n for i in inventory_list:\n for j in i.lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n if Decimal(j.quantity) >= Decimal(quantity):\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\n self.move(from_location=self.inventory, to_location=self.kitchen, item=product,\n quantity=quantity,\n batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=quantity, batch=i.batch_number)\n j.save()\n self.check_and_delete(i)\n done = True\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n self.move(from_location=self.inventory, to_location=self.kitchen, item=product,\n quantity=j.quantity, batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=j.quantity, batch=i.batch_number)\n j.quantity = 0\n j.save()\n self.check_and_delete(i)\n # transaction.cursor.commit()\n i.save()\n transaction.cursor.commit()\n if done:\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False",
"def test_simtk_list_of_quantities_to_pint():\n list_of_quantities = [val * omm_unit.meter for val in range(10)]\n quantity_list = omm_unit.meter * [val for val in range(10)]\n\n assert list_of_quantities != quantity_list\n assert all(simtk_to_pint(list_of_quantities) == simtk_to_pint(quantity_list))",
"def test_ComputerPartition_error_twoSalePackingList(self):\n sequence_list = SequenceList()\n sequence_string = self.prepare_start_requested_computer_partition_sequence_string + '\\\n LoginDefaultUser \\\n SetHostingAfterSetupStartDate \\\n Tic \\\n Logout \\\n SlapLoginCurrentComputer \\\n CheckSuccessComputerPartitionErrorCall \\\n Tic \\\n LoginDefaultUser \\\n CheckSalePackingListNoErrorText \\\n SetHostingBeforeSetupStartDate \\\n Tic \\\n Logout \\\n SlapLoginCurrentComputer \\\n CheckSuccessComputerPartitionErrorCall \\\n Tic \\\n SlapLogout \\\n LoginDefaultUser \\\n CheckSalePackingListErrorText \\\n Logout \\\n LoginERP5TypeTestCase \\\n CheckSiteConsistency \\\n Logout \\\n '\n sequence_list.addSequenceString(sequence_string)\n sequence_list.play(self)",
"def action_done_from_ui(self, cr, uid, picking_id, context=None):\n # write qty_done into field product_qty for every package_operation before doing the transfer\n pack_op_obj = self.pool.get('stock.pack.operation')\n for operation in self.browse(cr, uid, picking_id, context=context).pack_operation_ids:\n pack_op_obj.write(cr, uid, operation.id, {'product_qty': operation.qty_done},\n context=dict(context, no_recompute=True))\n self.do_transfer(cr, uid, [picking_id], context=context)\n # return id of next picking to work on\n return self.get_next_picking_for_ui(cr, uid, context=context)",
"def test_assign_orders():\n allocator = RecipeAllocator()\n allocator.load_data(\n orders_dir=\"tests/orders.json\", recipes_dir=\"tests/recipes.json\"\n )\n result = allocator.assign_orders(box_type=\"vegetarian\")\n assert result[\"excess_stock\"].loc[\"recipe_2\", \"stock_count\"] == 6",
"def use(self):\n if self.price_of_trip == 0:\n print(\"Sorry your card has been used\")\n else:\n self.price_of_trip -= self.price_of_trip\n print(\"Done\")",
"def create(self, good, quantity):\n self._haves[good] += quantity",
"def test_create422_below_min_quantity(self):\n card_order_editable = CardOrderEditable(\n quantity = 1\n )\n with self.assertRaises(Exception) as context:\n self.api.create(self.card, self.card_order_editable)\n self.assertTrue(\"Number of cards in order must be at least\" in context.exception.__str__())",
"def check_stock(self):\n if self.quantity > self.item.quantity:\n return \"%s Please adjust your cart.\" % CartItem.get_insufficient_stock_msg(self.item.quantity)\n return None",
"def test_not_ready_if_insufficient_working_space(self):\n self.command.package = self.input_ovf\n\n self.command.ui.default_confirm_response = False\n with mock.patch.object(self.command,\n 'working_dir_disk_space_required',\n return_value=(1 << 60)):\n ready, reason = self.command.ready_to_run()\n\n self.assertFalse(ready)\n self.assertRegex(reason, \"Insufficient disk space available for\"\n \" temporary file storage\")\n\n # User can opt to continue anyway\n self.command.ui.default_confirm_response = True\n self.command._cached_disk_requirements.clear()\n with mock.patch.object(self.command,\n 'working_dir_disk_space_required',\n return_value=(1 << 60)):\n ready, reason = self.command.ready_to_run()\n\n self.assertTrue(ready)",
"def generate_orders(self, good):\n surplus = self.inventory.surplus(good)\n if surplus >= 1: # sell inventory\n # the original only old one item here\n sell_amount = surplus\n order = self.create_sell_order(good, surplus)\n if order:\n # print('{} sells {} {}'.format(self.pop_job.title, sell_amount, good.name))\n self.market.sell(order)\n else: # buy more\n shortage = self.inventory.shortage(good)\n free_space = self.inventory.empty_space\n\n if shortage > 0:\n if shortage <= free_space:\n # enough space for ideal order\n limit = shortage\n else:\n # not enough space for ideal order\n limit = math.floor(free_space / shortage)\n\n if limit > 0:\n order = self.create_buy_order(good, limit)\n if order:\n # print('{} buys {} {}'.format(self.pop_job.title, limit, good.name))\n self.market.buy(order)\n # else:\n # print(\"{} has no shortage of {} (has shortage: {})\".format(self.pop_job.title, good.title, shortage))",
"def test_make_order_with_quantity_invalid(self):\n response = self.api_test_client.post('{}/orders'.format(\n self.BASE_URL), json={\n 'item_name': 'Watermelon', 'item_price': 50, 'quantity': -3\n }, headers={'Content-Type': 'application/json'})\n\n self.assertEqual(response.status_code, 400)\n self.assertEqual(response_as_json(\n response)['message'], 'Bad request. Price and quantity must be ints >= 1')",
"def test_partial_deck_has_fewer_cards(self):\n self.assertEqual(len(self.partialDeck.deck), 46)",
"def _validate_qty(values: dict):\n\n if not (quantity := values.get('quantity')):\n raise ValueError(\"Quantity attribute is required.\")\n\n if not (symbol := values.get('symbol')):\n raise ValueError(\"Symbol attribute is required.\")\n\n filter = symbol.filters.lot_size_filter\n # if ONE :=1 and not filter.min_qty <= quantity <= filter.max_qty:\n # ValueError(\"The quantity is not in valid range.\")\n\n if filter.step_size and not is_valid_significant_digits(\n quantity,\n symbol.qty_decimal_precision\n ):\n raise ValueError(\"The quantity precision is not valid.\")\n\n return values",
"def prepare_simulation(self, components):\n # The compressor has two foreign states, the inlet pressure and the\n # outlet pressure. Usually this is the storage pressure of the storage\n # at that bus. But a fixed pressure can also be set.\n\n # Get the inlet pressure [bar].\n p_in = self.get_foreign_state_value(components, 0)\n # Get the outlet pressure [bar].\n p_out = self.get_foreign_state_value(components, 1)\n\n # If the pressure difference is lower than 0.01 [bar], the specific\n # compression energy is zero\n if p_out - p_in < 0.01:\n spec_compression_work = 0\n else:\n # Get the compression ratio [-]\n p_ratio = p_out / p_in\n\n # Initial assumption for the polytropic exponent, value taken from MATLAB [-]\n n_initial = 1.6\n # Calculates the output temperature [K]\n temp_out = min(max(self.temp_in,\n self.temp_in * p_ratio ** ((n_initial - 1) / n_initial)),\n self.temp_in + 60)\n # Get temperature ratio [-]\n temp_ratio = temp_out / self.temp_in\n # Calculates the polytropic exponent [-]\n n = 1 / (1 - (log(temp_ratio) / log(p_ratio)))\n # Gets the compressibility factors of the hydrogen entering and\n # leaving the compressor [-]\n [z_in, z_out] = calculate_compressibility_factor(p_in, p_out, self.temp_in, temp_out)\n real_gas = (z_in + z_out) / 2\n # Specific compression work [kJ/kg]\n spec_compression_work = (\n (1 / self.efficiency) *\n self.R_H2 *\n self.temp_in *\n (n / (n - 1)) *\n ((((p_ratio) ** ((n - 1) / n))) - 1) *\n real_gas) / 1000\n\n # Convert specific compression work into electrical energy needed per kg H2 [Wh/kg]\n self.spec_compression_energy = float(spec_compression_work / 3.6)",
"def test_deal_insufficient_cards(self):\n cards = self.deck._deal(100)\n self.assertEqual(len(cards), 52)\n self.assertEqual(self.deck.count(), 0)",
"def test_puthardwares_item(self):\n pass",
"def test_adding_a_new_item_with_no_supply(self): \n print '\\n'\n logger.debug('Add a new item to a current PO via PUT')\n print '\\n'\n \n #Verifying po in database\n self.assertEqual(self.po.id, 1)\n self.assertEqual(self.po.items.count(), 1)\n self.assertEqual(self.po.grand_total, Decimal('129.58'))\n self.assertEqual(timezone('Asia/Bangkok').normalize(self.po.order_date).date(), datetime.datetime.now().date())\n item = self.po.items.all()[0]\n self.assertEqual(item.id, 1)\n self.assertEqual(item.quantity, 10)\n self.assertEqual(item.total, Decimal('121.1'))\n \n modified_po_data = copy.deepcopy(base_purchase_order)\n modified_po_data['items'][1]['unit_cost'] = Decimal('11.99')\n modified_po_data['items'][1]['comments'] = 'test change'\n modified_po_data['items'][1]['description'] = \"test description change\"\n del modified_po_data['items'][1]['supply']\n resp = self.client.put('/api/v1/purchase-order/1/',\n format='json',\n data=modified_po_data)\n \n #Verify the response\n self.assertEqual(resp.status_code, 200, msg=resp)\n po = resp.data\n self.assertEqual(po['id'], 1)\n self.assertEqual(po['supplier']['id'], 1)\n self.assertEqual(po['vat'], 7)\n #self.assertEqual(Decimal(po['grand_total']), Decimal('74.85'))\n self.assertEqual(po['discount'], 0)\n self.assertEqual(po['revision'], 1)\n self.assertEqual(len(po['items']), 2)\n #self.assertEqual(po['status'], 'PAID')\n #Check the new pdf\n #webbrowser.get(\"open -a /Applications/Google\\ Chrome.app %s\").open(po['pdf']['url'])\n \n item1 = po['items'][0]\n logger.debug(item1)\n self.assertEqual(item1['id'], 2)\n self.assertEqual(item1['quantity'], Decimal('10.0000000000'))\n self.assertEqual(item1['description'], u'Pattern: Maxx, Col: Blue')\n self.assertEqual(Decimal(item1['unit_cost']), Decimal('12.1100'))\n self.assertEqual(Decimal(item1['total']), Decimal('121.10'))\n\n item2 = po['items'][1]\n logger.debug(item2)\n self.assertEqual(item2['id'], 3)\n self.assertEqual(item2['quantity'], Decimal('3.0000000000'))\n self.assertEqual(item2['comments'], 'test change')\n self.assertEqual(item2['description'], 'test description change')\n self.assertEqual(Decimal(item2['unit_cost']), Decimal('11.99'))\n self.assertEqual(Decimal(item2['total']), Decimal('35.97'))\n \n #Verify database record\n po = PurchaseOrder.objects.get(pk=1)\n \n self.assertEqual(po.supplier.id, 1)\n #self.assertEqual(timezone('Asia/Bangkok').normalize(po.order_date), datetime.datetime.now().date())\n self.assertEqual(po.vat, 7)\n self.assertEqual(po.grand_total, Decimal('168.06'))\n self.assertEqual(po.items.count(), 2)\n \n # Check new item in the database\n item2_d = po.items.all().order_by('id')[1]\n self.assertEqual(item2_d.id, 3)\n self.assertEqual(item2_d.description, 'test description change')\n self.assertEqual(item2_d.comments, 'test change')\n self.assertEqual(item2_d.quantity, 3)\n self.assertEqual(item2_d.unit_cost, Decimal('11.99'))\n self.assertEqual(item2_d.total, Decimal('35.97'))\n\n # Check new supply product in the database\n products = SupplyProduct.objects.filter(supply=item2_d.supply, supplier=self.po.supplier)\n self.assertEqual(products.count(), 1)\n product = products.all()[0]\n self.assertEqual(product.supply.id, item2_d.supply.id)\n self.assertEqual(product.supplier.id, self.po.supplier.id)\n self.assertEqual(product.cost, Decimal('11.99'))",
"def test_noQuantity(self):\n # result = self.parser.parse(\"d6\")\n\n # TODO\n # self.assertIsNone(result)"
] | [
"0.61881334",
"0.60192597",
"0.57607996",
"0.556063",
"0.55559486",
"0.553951",
"0.5507649",
"0.5501214",
"0.53878224",
"0.5373135",
"0.5346838",
"0.53159076",
"0.53042346",
"0.530181",
"0.5292941",
"0.5262657",
"0.5252141",
"0.5244603",
"0.52374023",
"0.5235112",
"0.52324265",
"0.5227628",
"0.5203922",
"0.5168775",
"0.5154514",
"0.5151504",
"0.5150079",
"0.51411873",
"0.5138534",
"0.51321965",
"0.5129531",
"0.51146835",
"0.5113095",
"0.5109367",
"0.5101431",
"0.50967765",
"0.50620836",
"0.50587237",
"0.5040467",
"0.5020853",
"0.5012007",
"0.49990422",
"0.49943492",
"0.499196",
"0.49906716",
"0.4984178",
"0.49800867",
"0.4978447",
"0.4972636",
"0.49670908",
"0.49620113",
"0.49619493",
"0.49540144",
"0.4953576",
"0.49523863",
"0.49520627",
"0.49453214",
"0.4944181",
"0.49429104",
"0.49427328",
"0.49282014",
"0.4917951",
"0.4895139",
"0.48924714",
"0.48838964",
"0.4883895",
"0.48771378",
"0.487559",
"0.48700792",
"0.48604384",
"0.48595256",
"0.48571026",
"0.48547155",
"0.48514414",
"0.48466587",
"0.48408866",
"0.48391885",
"0.483571",
"0.4835193",
"0.4832402",
"0.48320213",
"0.4824932",
"0.48043817",
"0.47994044",
"0.4797874",
"0.47941497",
"0.4792775",
"0.47899315",
"0.47840953",
"0.4783588",
"0.4782401",
"0.47817242",
"0.47815967",
"0.47751",
"0.47655588",
"0.47598314",
"0.4754921",
"0.47529903",
"0.473901",
"0.47387618"
] | 0.6650053 | 0 |
Make sure a kit is split in the corrects product_qty by components in case of a planned transfer. | def test_kit_planned_transfer(self):
picking = self.env['stock.picking'].create({
'location_id': self.test_supplier.id,
'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,
'partner_id': self.test_partner.id,
'picking_type_id': self.env.ref('stock.picking_type_in').id,
'immediate_transfer': False,
})
move_receipt_1 = self.env['stock.move'].create({
'name': self.kit_parent.name,
'product_id': self.kit_parent.id,
'product_uom_qty': 3,
'product_uom': self.kit_parent.uom_id.id,
'picking_id': picking.id,
'picking_type_id': self.env.ref('stock.picking_type_in').id,
'location_id': self.test_supplier.id,
'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,
})
picking.action_confirm()
# We check that the picking has the correct quantities after its move were splitted.
self.assertEqual(len(picking.move_lines), 7)
for move_line in picking.move_lines:
self.assertEqual(move_line.product_qty, self.expected_quantities[move_line.product_id]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_overprocessed_subcontract_qty(self):\n overprocessed_moves = self.env['stock.move']\n for move in self:\n if not move.is_subcontract:\n continue\n # Extra quantity is allowed when components do not need to be register\n if not move._has_tracked_subcontract_components():\n continue\n rounding = move.product_uom.rounding\n if float_compare(move.quantity_done, move.move_orig_ids.production_id.qty_produced, precision_rounding=rounding) > 0:\n overprocessed_moves |= move\n if overprocessed_moves:\n raise UserError(_(\"\"\"\nYou have to use 'Records Components' button in order to register quantity for a\nsubcontracted product(s) with tracked component(s):\n %s.\nIf you want to process more than initially planned, you\ncan use the edit + unlock buttons in order to adapt the initial demand on the\noperations.\"\"\") % ('\\n'.join(overprocessed_moves.mapped('product_id.display_name'))))",
"def set_so_pack_operation_lot(self, picking):\n StockProductionLot = self.env['stock.production.lot']\n sale_line_obj = self.env['sale.order.line']\n has_wrong_lots = False\n for del_move in picking.move_lines:\n del_move.move_line_ids.unlink()\n for move in picking.move_lines:\n picking_type = picking.picking_type_id\n # lots_necessary = True\n if picking_type:\n if not picking_type.use_existing_lots:\n picking_type.write({'use_existing_lots':True})\n # lots_necessary = picking_type and picking_type.use_existing_lots\n qty = 0\n qty_done = 0\n pack_lots = []\n pack_lot_id = []\n for ord_line in self.order_line:\n if ord_line.lot_id and ord_line.lot_id.product_id.id == move.product_id.id:\n pack_lot_id.append(ord_line.lot_id.id)\n # if pack_lot_names and lots_necessary:\n if pack_lot_id:\n for lot_id in list(set(pack_lot_id)):\n stock_production_lot = StockProductionLot.search([('id', '=', lot_id), ('product_id', '=', move.product_id.id)])\n sale_order_line = sale_line_obj.search([('lot_id', '=', lot_id),('order_id', '=', self.id), ('product_id', '=', move.product_id.id)])\n if stock_production_lot and sale_order_line:\n if stock_production_lot.product_id.tracking == 'lot':\n # if a lot nr is set through the frontend it will refer to the full quantity\n qty = sale_order_line[0].product_uom_qty\n else:\n qty = 1.0\n qty_done += qty\n pack_lots.append({'lot_id': stock_production_lot.id, 'qty': qty})\n else:\n has_wrong_lots = True\n # elif move.product_id.tracking == 'none' or not lots_necessary:\n elif move.product_id.tracking == 'none':\n qty_done = move.product_uom_qty\n else:\n has_wrong_lots = True\n for pack_lot in pack_lots:\n lot_id, qty = pack_lot['lot_id'], pack_lot['qty']\n self.env['stock.move.line'].create({\n 'move_id': move.id,\n 'product_id': move.product_id.id,\n 'product_uom_id': move.product_uom.id,\n 'qty_done': qty,\n 'location_id': move.location_id.id,\n 'location_dest_id': move.location_dest_id.id,\n 'lot_id': lot_id,\n })\n if not pack_lots:\n move.quantity_done = qty_done\n return has_wrong_lots",
"def test_purchase_order_product_bundle(self):\n self.purchase = self.env['purchase.order'].with_user(self.purchase_user).create(self.order_vals)\n self.assertTrue(self.purchase, 'Purchase: no purchase order created')\n self.assertEqual(self.purchase.invoice_status, 'no', 'Purchase: PO invoice_status should be \"Not purchased\"')\n self.assertEqual(self.purchase.order_line.mapped('qty_received'), [0.0, 0.0], 'Purchase: no product should be received\"')\n self.assertEqual(self.purchase.order_line.mapped('qty_invoiced'), [0.0, 0.0], 'Purchase: no product should be invoiced\"')\n\n self.purchase.button_confirm()\n self.assertEqual(self.purchase.state, 'purchase', 'Purchase: PO state should be \"Purchase\"')\n self.assertEqual(self.purchase.invoice_status, 'to invoice', 'Purchase: PO invoice_status should be \"Waiting Invoices\"')\n\n self.assertEqual(self.purchase.picking_count, 1, 'Purchase: one picking should be created\"')\n self.picking = self.purchase.picking_ids[0]\n self.picking.move_line_ids.write({'qty_done': 1.0})\n self.picking.button_validate()\n\n product_bundle_line = self.purchase.order_line.filtered(lambda l: l.product_id == self.product_bundle_id)\n product_3_line = self.purchase.order_line.filtered(lambda l: l.product_id == self.product_3)\n self.bundle_order_qty = sum(product_bundle_line.mapped('product_uom_qty'))\n self.product_3_order_qty = sum(product_3_line.mapped('product_uom_qty'))\n self.total_bundle_order_qty = self.count_item_pack *self.bundle_order_qty\n\n self.assertEqual(self.bundle_order_qty, 1, 'Purchase: product bundle ordered quantity')\n self.assertEqual(self.total_bundle_order_qty, 3, 'Purchase: product bundle total quantity')\n self.assertEqual(self.product_3_order_qty, 1, 'Purchase: product Samsung S20 ordered quantity')\n self.assertEqual(product_bundle_line.mapped('qty_received'), [self.total_bundle_order_qty], 'Purchase: the product bundle should be received\"')\n self.assertEqual(product_3_line.mapped('qty_received'), [self.product_3_order_qty], 'Purchase: the product samsung S20 should be received\"')\n \n move_form = Form(self.env['account.move'].with_context(default_move_type='in_invoice'))\n move_form.partner_id = self.vendor\n move_form.purchase_id = self.purchase\n self.bill = move_form.save()\n\n # Control Policy products is On ordered quantities\n # self.bundle_order_qty = 1\n # self.product_3_order_qty = 1\n self.assertEqual(self.purchase.order_line.mapped('qty_invoiced'), [1, 1], 'Purchase: all products should be invoiced based on ordered quantity\"')",
"def test_product_buy_more_then_have(self):\n result_buy = self.info_list.product_buy(\"соль 1 кг\", 50)\n self.assertFalse(result_buy)",
"def validate_product_quantity(item, qty):\n return True",
"def test_free_product(self):\n product = self.create_product(price=D('0.00'))\n\n res = self.do_get_basket()\n self.assertEqual(res.status_code, 200)\n basket_id = res.data['id']\n\n res = self.do_add_to_basket(product.id)\n self.assertEqual(res.status_code, 200)\n\n cs_url, cs_data = self.do_sign_auth_request(basket_id)\n\n self.assertEqual(cs_data['amount'], '0.00')\n\n res = self.do_cybersource_post(cs_url, cs_data)\n self.assertEqual(res.status_code, 302)\n self.check_finished_order(cs_data['reference_number'], product.id)",
"def calc_qty(self, cr, uid, production_id, context=None):\n prod = self.pool.get('mrp.production').browse(cr, uid,production_id\n , context=context)\n done = 0.0\n for wo in prod.workcenter_lines:\n for mrej in wo.moves_rejection:\n done += mrej.s_rejected_qty or 0.0\n for move in prod.move_created_ids2:\n if move.product_id == prod.product_id:\n #ignore scrapped and extra consumed\n if (not move.scrapped) or (not move.extra_consumed):\n done += move.product_qty\n if (prod.product_qty - done) <= 0:\n raise osv.except_osv(_('Warning!'), _('Click on \"Force To Close\" button to generate remain scrap order.'))\n return (prod.product_qty - done) or prod.product_qty",
"def parts_demand(request):\n critical_part = []\n quantity = None\n bom_name = None\n if request.method == 'POST':\n form = PartsDemandForm(request.POST)\n if form.is_valid():\n bom_name = form.cleaned_data['bom']\n quantity = int(form.cleaned_data['quantity'])\n warehouse = form.cleaned_data['warehouse']\n warehouse_obj = Warehouse.objects.get(warehouse_name=warehouse)\n stock = calculate_stock(warehouse_obj)\n parts = get_bom_parts(bom_name)\n print(stock)\n for part in parts:\n part_qty = float(part['Qty'])\n part_name = part['PartName']\n part_number = part['PartNumber']\n if stock.get(part_name):\n av_stock = stock.get(part_name)['total_usable_stock']\n # print(av_stock, quantity, part_qty, quantity * part_qty)\n else:\n av_stock = 0\n critical = int(av_stock) - int(quantity * part_qty)\n if critical <= 0:\n test = {\n \"critical_qty\": critical,\n \"part_number\": part_number,\n \"part_name\": part_name\n }\n critical_part.append(test)\n else:\n form = PartsDemandForm()\n context = {\n 'form': form,\n 'critical_part': critical_part,\n 'quantity': quantity,\n 'bom': bom_name,\n }\n\n return render(request, 'inventory/parts_demand.html', context)",
"def test_kit_immediate_transfer(self):\n picking = self.env['stock.picking'].create({\n 'location_id': self.test_supplier.id,\n 'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,\n 'partner_id': self.test_partner.id,\n 'picking_type_id': self.env.ref('stock.picking_type_in').id,\n 'immediate_transfer': True\n })\n move_receipt_1 = self.env['stock.move'].create({\n 'name': self.kit_parent.name,\n 'product_id': self.kit_parent.id,\n 'quantity_done': 3,\n 'product_uom': self.kit_parent.uom_id.id,\n 'picking_id': picking.id,\n 'picking_type_id': self.env.ref('stock.picking_type_in').id,\n 'location_id': self.test_supplier.id,\n 'location_dest_id': self.warehouse_1.wh_input_stock_loc_id.id,\n })\n picking.button_validate()\n\n # We check that the picking has the correct quantities after its move were splitted.\n self.assertEqual(len(picking.move_lines), 7)\n for move_line in picking.move_lines:\n self.assertEqual(move_line.quantity_done, self.expected_quantities[move_line.product_id])",
"def test_excess_quantity(self):\n excess = self._uncertain_demand.excess_stock\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n variance = [(item - avg_order) for item in self._data_set.values()]\n stdev = pow(sum([pow(j, 2) for j in variance]) / len(self._data_set), 0.5)\n cal_safety = lambda x, y, z: x * y * (z ** 0.5)\n safety_stock = cal_safety(float(self._z_value), float(stdev), float(self._lead_time))\n cal_reorder_level = lambda x, y, z: ((x ** 0.5) * y) + z\n reorder = cal_reorder_level(float(self._lead_time), avg_order, float(safety_stock))\n cal_excess = lambda x, y, z: round(x - (y + (y - z)), 0) if x > y + (y - z) else 0\n test_excess = cal_excess(self._quantity_on_hand, reorder, safety_stock)\n self.assertEqual(int(excess), int(test_excess))",
"def test_product_bundle_price_calculation(self):\n template = self.product_apple_bundle\n template.write({'is_calpack_price': False})\n template.write({'is_calpack_price': True})\n self.assertEqual(template.list_price, self.total_price, 'Product: a product bundle canculation sale price')\n self.assertEqual(template.standard_price, self.total_cost, 'Product: a product bundle canculation product cost')",
"def test_sell_ticket_valid_quantity(self, *_):\n # logout to invalidate any logged in session\n self.open(base_url + '/logout')\n # login a user\n self.open(base_url + '/login')\n # fill email and password\n self.type(\"#email\", \"test_frontend@test.com\")\n self.type(\"#password\", \"Test_frontend@\")\n # click enter button\n self.click('input[type=\"submit\"]')\n # open the /sell route\n self.open(base_url)\n # Enter an invalid ticket name\n self.type('#name_sell', \"ticketname\")\n self.type('#quantity_sell', \"-1\")\n self.type(\"#price_sell\", \"15\")\n self.type(\"#exp_date_sell\", \"20200921\")\n self.click('#submit-sell')\n # Assert that the valid error message is shown\n self.assert_text(\"Invalid quantity of tickets\", \"#message\")\n\n # logout to invalidate any logged in session\n self.open(base_url + '/logout')\n # login a user\n self.open(base_url + '/login')\n # fill email and password\n self.type(\"#email\", \"test_frontend@test.com\")\n self.type(\"#password\", \"Test_frontend@\")\n # click enter button\n self.click('input[type=\"submit\"]')\n # open the /sell route\n self.open(base_url)\n # Enter an invalid ticket name\n self.type('#name_sell', \"ticketname\")\n self.type('#quantity_sell', \"101\")\n self.type(\"#price_sell\", \"15\")\n self.type(\"#exp_date_sell\", \"20200921\")\n self.click('#submit-sell')\n # Assert that the valid error message is shown\n self.assert_text(\"Invalid quantity of tickets\", \"#message\")",
"def test_bundle_is_product_pack(self):\n template = self.product_apple_bundle\n product_pack_ids = template.product_pack_ids\n self.assertTrue(template.is_pack, 'Product template is a bundle pack')\n self.assertTrue(len(product_pack_ids) != 0, 'Product: a product bundle should have product pack')\n self.assertEqual(len(product_pack_ids), 3, 'Product: a product bundle should have product pack')",
"def test_product_buy_missing_goods(self):\n result_buy = self.info_list.product_buy(\"хлеб серый хлебозавод\", 3)\n self.assertFalse(result_buy)",
"def test_stock_quantity_own_part(self):\n self.portfolio = './app/test/payloads/port_own_part.json'\n self.stock = ['ETH', 'BTC']\n self.stock_url = 'https://min-api.cryptocompare.com/data/pricemultifull?fsyms=ETH&tsyms=USD'\n\n expected_data = {'ETH': 1.108, 'BTC': 0}\n\n #Run stock_quantity on test data\n self.add_perf = PortfolioAddPerf(self.portfolio, self.stock, self.stock_url)\n return_data = self.add_perf.stock_quantity()\n\n self.assertEqual(expected_data, return_data)",
"def change_product_qty(self):\n Inventory = self.env['stock.inventory']\n\n\n for wizard in self:\n product = wizard.product_id.with_context(location=wizard.location_id.id, lot_id=wizard.lot_id.id)\n line_data = wizard._action_start_line()\n\n\n if wizard.product_id.id and wizard.lot_id.id:\n inventory_filter = 'none'\n elif wizard.product_id.id:\n inventory_filter = 'product'\n else:\n inventory_filter = 'none'\n inventory = Inventory.create({\n 'name': _('INV: %s') % tools.ustr(wizard.product_id.display_name),\n 'filter': inventory_filter,\n 'product_id': wizard.product_id.id,\n 'location_id': wizard.location_id.id,\n 'lot_id': wizard.lot_id.id,\n 'line_ids': [(0, 0, line_data)],\n })\n inventory.action_done()\n return {'type': 'ir.actions.act_window_close'}",
"def test_product_buy(self):\n result_buy = self.info_list.product_buy(\"соль 1 кг\", 5)\n self.assertEqual(result_buy, 175)",
"def action_consume_custom(self, cr, uid, ids, product_qty, location_id=False, restrict_lot_id=False, restrict_partner_id=False,\r\n consumed_for=False, context=None):\r\n if context is None:\r\n context = {}\r\n res = []\r\n production_obj = self.pool.get('mrp.production.custom')\r\n\r\n if product_qty <= 0:\r\n raise osv.except_osv(_('Warning!'), _('Please provide proper quantity.'))\r\n #because of the action_confirm that can create extra moves in case of phantom bom, we need to make 2 loops\r\n ids2 = []\r\n for move in self.browse(cr, uid, ids, context=context):\r\n if move.state == 'draft':\r\n ids2.extend(self.action_confirm(cr, uid, [move.id], context=context))\r\n else:\r\n ids2.append(move.id)\r\n\r\n prod_orders = set()\r\n for move in self.browse(cr, uid, ids2, context=context):\r\n prod_orders.add(move.custom_production_id.id)\r\n print\"Total Qty>>>\",product_qty\r\n move_qty = product_qty\r\n if move_qty <= 0.00:\r\n raise osv.except_osv(_('Error!'), _('Cannot consume a move with negative or zero quantity.'))\r\n \r\n quantity_rest = move_qty - product_qty\r\n print\"Rest Qty>>>\",quantity_rest\r\n # Compare with numbers of move uom as we want to avoid a split with 0 qty\r\n quantity_rest_uom = move.product_uom_qty - self.pool.get(\"product.uom\")._compute_qty_obj(cr, uid, move.product_id.uom_id, product_qty, move.product_uom)\r\n if float_compare(quantity_rest_uom, 0, precision_rounding=move.product_uom.rounding) != 0:\r\n new_mov = self.split(cr, uid, move, quantity_rest, context=context)\r\n print\"New Move>>>\",new_mov\r\n res.append(new_mov)\r\n vals = {'restrict_lot_id': restrict_lot_id,\r\n 'restrict_partner_id': restrict_partner_id,\r\n 'consumed_for': consumed_for}\r\n if location_id:\r\n vals.update({'location_id': location_id})\r\n self.write(cr, uid, [move.id], vals, context=context)\r\n # Original moves will be the quantities consumed, so they need to be done\r\n self.action_done(cr, uid, ids2, context=context)\r\n if res:\r\n self.action_assign(cr, uid, res, context=context)\r\n if prod_orders:\r\n \r\n production_obj.action_in_production(cr, uid, list(prod_orders), context=None)\r\n #production_obj.signal_workflow(cr, uid, list(prod_orders), 'button_produce')\r\n return res",
"def test_putaway_after_manufacturing_3(self):\n self.laptop.tracking = 'serial'\n mo_laptop = self.new_mo_laptop()\n serial = self.env['stock.production.lot'].create({'product_id': self.laptop.id, 'company_id': self.env.company.id})\n\n mo_form = Form(mo_laptop)\n mo_form.qty_producing = 1\n mo_form.lot_producing_id = serial\n mo_laptop = mo_form.save()\n mo_laptop.button_mark_done()\n\n # We check if the laptop go in the depot and not in the stock\n move = mo_laptop.move_finished_ids\n location_dest = move.move_line_ids.location_dest_id\n self.assertEqual(location_dest.id, self.depot_location.id)\n self.assertNotEqual(location_dest.id, self.stock_location.id)",
"def create(self, request, *args, **kwargs):\n user = request.user\n\n # Copy the request data, to side-step \"mutability\" issues\n data = OrderedDict()\n # Update with cleaned input data\n data.update(self.clean_data(request.data))\n\n quantity = data.get('quantity', None)\n\n if quantity is None:\n raise ValidationError({\n 'quantity': _('Quantity is required'),\n })\n\n try:\n part = Part.objects.get(pk=data.get('part', None))\n except (ValueError, Part.DoesNotExist):\n raise ValidationError({\n 'part': _('Valid part must be supplied'),\n })\n\n # Set default location (if not provided)\n if 'location' not in data:\n location = part.get_default_location()\n\n if location:\n data['location'] = location.pk\n\n expiry_date = data.get('expiry_date', None)\n\n # An expiry date was *not* specified - try to infer it!\n if expiry_date is None and part.default_expiry > 0:\n data['expiry_date'] = datetime.now().date() + timedelta(days=part.default_expiry)\n\n # Attempt to extract serial numbers from submitted data\n serials = None\n\n # Check if a set of serial numbers was provided\n serial_numbers = data.get('serial_numbers', '')\n\n # Check if the supplier_part has a package size defined, which is not 1\n if 'supplier_part' in data and data['supplier_part'] is not None:\n try:\n supplier_part = SupplierPart.objects.get(pk=data.get('supplier_part', None))\n except (ValueError, SupplierPart.DoesNotExist):\n raise ValidationError({\n 'supplier_part': _('The given supplier part does not exist'),\n })\n\n if supplier_part.base_quantity() != 1:\n # Skip this check if pack size is 1 - makes no difference\n # use_pack_size = True -> Multiply quantity by pack size\n # use_pack_size = False -> Use quantity as is\n if 'use_pack_size' not in data:\n raise ValidationError({\n 'use_pack_size': _('The supplier part has a pack size defined, but flag use_pack_size not set'),\n })\n else:\n if bool(data.get('use_pack_size')):\n quantity = data['quantity'] = supplier_part.base_quantity(quantity)\n\n # Divide purchase price by pack size, to save correct price per stock item\n if data['purchase_price'] and supplier_part.pack_quantity_native:\n try:\n data['purchase_price'] = float(data['purchase_price']) / float(supplier_part.pack_quantity_native)\n except ValueError:\n pass\n\n # Now remove the flag from data, so that it doesn't interfere with saving\n # Do this regardless of results above\n if 'use_pack_size' in data:\n data.pop('use_pack_size')\n\n # Assign serial numbers for a trackable part\n if serial_numbers:\n\n if not part.trackable:\n raise ValidationError({\n 'serial_numbers': [_(\"Serial numbers cannot be supplied for a non-trackable part\")]\n })\n\n # If serial numbers are specified, check that they match!\n try:\n serials = extract_serial_numbers(\n serial_numbers,\n quantity,\n part.get_latest_serial_number()\n )\n\n # Determine if any of the specified serial numbers are invalid\n # Note \"invalid\" means either they already exist, or do not pass custom rules\n invalid = []\n errors = []\n\n for serial in serials:\n try:\n part.validate_serial_number(serial, raise_error=True)\n except DjangoValidationError as exc:\n # Catch raised error to extract specific error information\n invalid.append(serial)\n\n if exc.message not in errors:\n errors.append(exc.message)\n\n if len(errors) > 0:\n\n msg = _(\"The following serial numbers already exist or are invalid\")\n msg += \" : \"\n msg += \",\".join([str(e) for e in invalid])\n\n raise ValidationError({\n 'serial_numbers': errors + [msg]\n })\n\n except DjangoValidationError as e:\n raise ValidationError({\n 'quantity': e.messages,\n 'serial_numbers': e.messages,\n })\n\n if serials is not None:\n \"\"\"If the stock item is going to be serialized, set the quantity to 1.\"\"\"\n data['quantity'] = 1\n\n # De-serialize the provided data\n serializer = self.get_serializer(data=data)\n serializer.is_valid(raise_exception=True)\n\n with transaction.atomic():\n\n # Create an initial StockItem object\n item = serializer.save()\n\n if serials:\n # Assign the first serial number to the \"master\" item\n item.serial = serials[0]\n\n # Save the item (with user information)\n item.save(user=user)\n\n if serials:\n for serial in serials[1:]:\n\n # Create a duplicate stock item with the next serial number\n item.pk = None\n item.serial = serial\n\n item.save(user=user)\n\n response_data = {\n 'quantity': quantity,\n 'serial_numbers': serials,\n }\n\n else:\n response_data = serializer.data\n\n return Response(response_data, status=status.HTTP_201_CREATED, headers=self.get_success_headers(serializer.data))",
"def ingredient_used(self, item, quantity):\n logger.info('ReleaseDiscard ingredient used initiated')\n try:\n quantity = Decimal(quantity).quantize(Decimal('0.11'))\n inventory_list = self.Inventory.search([('location', '=', self.kitchen.id)]\n , order=[('batch_number', 'ASC')])\n product = self.Product.search([('name', '=', item),\n ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n done = False\n today = date.today()\n for i in inventory_list:\n for j in i.lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n if Decimal(j.quantity) >= Decimal(quantity):\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\n quantity=quantity,\n batch_number=i.batch_number)\n self.store_inventory(location=self.used, inventory_stock=j,\n quantity=quantity, batch=i.batch_number)\n j.save()\n self.check_and_delete(i)\n done = True\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\n quantity=j.quantity, batch_number=i.batch_number)\n self.store_inventory(location=self.used, inventory_stock=j,\n quantity=j.quantity, batch=i.batch_number)\n j.quantity = 0\n j.save()\n self.check_and_delete(i)\n # transaction.cursor.commit()\n i.save()\n if done:\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False",
"def _onchange_product_id_check_availability(self):\n res = super(SaleOrderLine, self)._onchange_product_id_check_availability()\n if res.get('warning'):\n product = self.product_id.with_context(warehouse=self.order_id.warehouse_id.id)\n self.product_uom_qty = product.virtual_available\n if self.product_uom_qty < 0:\n self.product_uom_qty = 0\n return res",
"def action_stagger_purchase_delivery(self):\n for wizard in self:\n #On vérifie que la quantité entrée est inférieure à la quantité de la ligne \n #d'achat \n purchase_line = wizard.purchase_line_id\n price_unit = purchase_line.price_unit\n if wizard.quantity <= 0:\n raise except_orm(_(\"Error\"), _('You must enter a quantity superior to 0'))\n \n if wizard.quantity >= purchase_line.sec_uom_qty:\n raise except_orm(_(\"Error\"), _('You must enter a quantity inferior to the initial purchase '\n 'line quantity'))\n \n #On récupère les valeurs entrées dans le wizard\n values = {'sec_uom_qty': wizard.quantity,\n 'expected_date': wizard.new_date}\n new_line = purchase_line.copy(values)\n new_line._onchange_sec_uom_qty(with_warning=False)\n new_line._onchange_uom_qty()\n new_line._onchange_uoi_qty()\n new_line.write({'price_unit': price_unit})\n #On décrémente la ligne initiale de la quantité de la nouvelle ligne (car celle-ci respecte forcément\n #le multiple et le minimum\n purchase_line.write({'sec_uom_qty': purchase_line.sec_uom_qty - wizard.quantity})\n purchase_line._onchange_sec_uom_qty(with_warning=False)\n purchase_line._onchange_uom_qty()\n purchase_line._onchange_uoi_qty()\n purchase_line.write({'price_unit': price_unit})\n #On retourne l'achat\n if wizard.purchase_id:\n action_dict = get_form_view(self, 'purchase.purchase_order_see_form')\n if action_dict and action_dict.get('id') and action_dict.get('type'):\n action = self.env[action_dict['type']].browse(action_dict['id'])\n action_struc = action.read()\n action_struc[0]['res_id'] = wizard.purchase_id.id\n action_struc = action_struc[0]\n \n return action_struc\n else:\n return {'type': 'ir.actions.act_window_close'}",
"def test_06_replacement_product_wizard(self):\n # Create a purchase order with two lines.\n order = self.create_po()\n sellable_product = self.product_obj.browse(self.sellable_product)\n draft_product = self.product_obj.browse(self.draft_product)\n self.create_pol(order, sellable_product)\n self.create_pol(order, draft_product)\n self.assertNotIn('obsolete',\n order.order_line.mapped('product_id.state2'))\n\n # Update sellable product to obsolete\n # NOTE: This check check the write() method of the product.product\n # record.\n self.assertIn(sellable_product, order.order_line.mapped('product_id'))\n self.assertEqual(sellable_product.state2, 'sellable')\n sellable_product.state2 = 'obsolete'\n self.assertEqual(sellable_product.state2, 'obsolete')\n\n # Check that the purchase order line now have a obsolete line.\n obsolete_order_line = order.order_line.filtered(\n lambda line: line.product_id.state2 == 'obsolete')\n self.assertTrue(obsolete_order_line)\n self.assertEqual(obsolete_order_line.product_id, sellable_product)\n\n # Simulate click on the \"Check Discontinued Products\" button to run the\n # replacemenet product wizard.\n wiz = self.wiz_obj.with_context({\n 'active_id': order.id,\n 'active_ids': [order.id],\n 'active_model': 'purchase.order',\n }).create({})\n\n # Chech that the wizard auto create correctly the replacement lines.\n # The replacement line must be linked/generate to the obsolete purchase\n # order line.\n self.assertTrue(wiz.lines)\n self.assertEqual(len(wiz.lines), 1)\n self.assertEqual(obsolete_order_line, wiz.lines.mapped('line_id'))\n\n # TODO add a case to try to add a new replacement line manually. this\n # must be fail.\n\n # Try to add an obsolete replacement product in the replacement line.\n # This will raise an exception becuase only not obsolete products can\n # be used as a valid replacement.\n wiz_line = wiz.lines[0]\n with self.assertRaises(exceptions.ValidationError):\n wiz_line.replacement_product_id = self.obsolete_replacement\n\n # Add a sellable replacement product in the replacement line.\n wiz_line.replacement_product_id = self.sellable_replacement\n self.assertEqual(wiz_line.replacement_product_id.id,\n self.sellable_replacement)\n\n # Make the replacement in the purchase order by clicking the button\n # \"Replace\" in the replacement wizard and check that the changes were\n # applied to the purchase order line.\n wiz.replacement()\n self.assertEqual(obsolete_order_line.product_id,\n wiz_line.replacement_product_id)\n self.assertEqual(obsolete_order_line.discontinued_product_id,\n wiz_line.discontinued_product_id)",
"def _update_reserved_quantity(self, product_id, location_id, quantity, lot_id=None, package_id=None, owner_id=None,\n strict=False):\n self = self.sudo()\n rounding = product_id.uom_id.rounding\n quants = self._gather(product_id, location_id, lot_id=lot_id, package_id=package_id, owner_id=owner_id,\n strict=strict)\n reserved_quants = []\n\n if float_compare(quantity, 0, precision_rounding=rounding) > 0:\n # if we want to reserve\n available_quantity = self._get_available_quantity(product_id, location_id, lot_id=lot_id,\n package_id=package_id, owner_id=owner_id, strict=strict)\n if float_compare(quantity, available_quantity, precision_rounding=rounding) > 0:\n raise UserError(_('It is not possible to reserve more products of %s than you have in stock.',\n product_id.display_name))\n elif float_compare(quantity, 0, precision_rounding=rounding) < 0:\n # if we want to unreserve\n available_quantity = sum(quants.mapped('reserved_quantity'))\n # if float_compare(abs(quantity), available_quantity, precision_rounding=rounding) > 0:\n # raise UserError(_('It is not possible to unreserve more products of %s than you have in stock.',\n # product_id.display_name))\n else:\n return reserved_quants\n\n for quant in quants:\n if float_compare(quantity, 0, precision_rounding=rounding) > 0:\n max_quantity_on_quant = quant.quantity - quant.reserved_quantity\n if float_compare(max_quantity_on_quant, 0, precision_rounding=rounding) <= 0:\n continue\n max_quantity_on_quant = min(max_quantity_on_quant, quantity)\n quant.reserved_quantity += max_quantity_on_quant\n reserved_quants.append((quant, max_quantity_on_quant))\n quantity -= max_quantity_on_quant\n available_quantity -= max_quantity_on_quant\n else:\n max_quantity_on_quant = min(quant.reserved_quantity, abs(quantity))\n quant.reserved_quantity -= max_quantity_on_quant\n reserved_quants.append((quant, -max_quantity_on_quant))\n quantity += max_quantity_on_quant\n available_quantity += max_quantity_on_quant\n\n if float_is_zero(quantity, precision_rounding=rounding) or float_is_zero(available_quantity,\n precision_rounding=rounding):\n break\n return reserved_quants",
"def test_multiple_creates_do_not_increase_products(self):\n for i in xrange(0, 10):\n modified_po = copy.deepcopy(base_purchase_order)\n self.assertEqual(Supply.objects.get(pk=1).quantity, 10)\n \n resp = self.client.post('/api/v1/purchase-order/', format='json', data=modified_po)\n \n self.assertEqual(resp.status_code, 201, msg=resp)\n \n po_data = resp.data\n self.assertEqual(po_data['status'], 'AWAITING APPROVAL')\n\n item1 = po_data['items'][0]\n #self.assertEqual(item1['supply']['id'], 1)\n self.assertEqual(item1['status'], u'Ordered')\n\n item2 = po_data['items'][1]\n #self.assertEqual(item1['supply']['id'], 2)\n self.assertEqual(item1['status'], u'Ordered')\n \n #Test database values\n po = PurchaseOrder.objects.get(pk=resp.data['id'])\n self.assertEqual(po.status, 'AWAITING APPROVAL')\n for item in po.items.all():\n self.assertEqual(item.status, u\"Ordered\")\n \n supplier = Supplier.objects.get(pk=1)\n\n supply = Supply.objects.get(pk=1)\n self.assertEqual(supply.quantity, 10)\n self.assertEqual(supply.products.filter(supplier=supplier).count(), 1)\n\n supply = Supply.objects.get(pk=2)\n self.assertEqual(supply.quantity, 10)\n self.assertEqual(supply.products.filter(supplier=supplier).count(), 1)",
"def _prepare_pack_ops(self, quants, forced_qties):\n valid_quants = quants.filtered(lambda quant: quant.qty > 0)\n _Mapping = namedtuple('Mapping', ('product', 'package', 'owner', 'location', 'location_dst_id','move_id'))\n all_products = valid_quants.mapped('product_id') | self.env['product.product'].browse(set(m.product_id.id for m,q in forced_qties)) | self.move_lines.mapped('product_id')\n computed_putaway_locations = dict(\n (product, self.location_dest_id.get_putaway_strategy(product) or self.location_dest_id.id) for product in all_products)\n product_to_uom = dict((product.id, product.uom_id) for product in all_products)\n picking_moves = self.move_lines.filtered(lambda move: move.state not in ('done', 'cancel'))\n for move in picking_moves:\n # If we encounter an UoM that is smaller than the default UoM or the one already chosen, use the new one instead.\n if move.product_uom != product_to_uom[move.product_id.id] and move.product_uom.factor > product_to_uom[move.product_id.id].factor:\n product_to_uom[move.product_id.id] = move.product_uom\n if len(picking_moves.mapped('location_id')) > 1:\n raise UserError(_('The source location must be the same for all the moves of the picking.'))\n if len(picking_moves.mapped('location_dest_id')) > 1:\n raise UserError(_('The destination location must be the same for all the moves of the picking.'))\n pack_operation_values = []\n # find the packages we can move as a whole, create pack operations and mark related quants as done\n top_lvl_packages = valid_quants._get_top_level_packages(computed_putaway_locations)\n for pack in top_lvl_packages:\n pack_quants = pack.get_content()\n pack_operation_values.append({\n 'picking_id': self.id,\n 'package_id': pack.id,\n 'product_qty': 1.0,\n 'location_id': pack.location_id.id,\n 'location_dest_id': computed_putaway_locations[pack_quants[0].product_id],\n 'owner_id': pack.owner_id.id,\n })\n valid_quants -= pack_quants\n # Go through all remaining reserved quants and group by product, package, owner, source location and dest location\n # Lots will go into pack operation lot object\n qtys_grouped = {}\n lots_grouped = {}\n for quant in valid_quants:\n key = _Mapping(quant.product_id, quant.package_id, quant.owner_id, quant.location_id, computed_putaway_locations[quant.product_id], quant.reservation_id)\n qtys_grouped.setdefault(key, 0.0)\n qtys_grouped[key] += quant.qty\n if quant.product_id.tracking != 'none' and quant.lot_id:\n lots_grouped.setdefault(key, dict()).setdefault(quant.lot_id.id, 0.0)\n lots_grouped[key][quant.lot_id.id] += quant.qty\n # Do the same for the forced quantities (in cases of force_assign or incomming shipment for example)\n for move_f, qty in forced_qties:\n if qty <= 0.0:\n continue\n key = _Mapping(move_f.product_id, self.env['stock.quant.package'], self.owner_id, self.location_id, computed_putaway_locations[move_f.product_id], move_f)\n qtys_grouped.setdefault(key, 0.0)\n qtys_grouped[key] += qty\n # Create the necessary operations for the grouped quants and remaining qtys\n Uom = self.env['product.uom']\n move_id_to_vals = {} # use it to create operations using the same order as the picking stock moves\n for mapping, qty in qtys_grouped.items():\n uom = product_to_uom[mapping.product.id]\n val_dict = {\n 'picking_id': self.id,\n 'product_qty': mapping.product.uom_id._compute_quantity(qty, uom),\n 'product_id': mapping.product.id,\n 'package_id': mapping.package.id,\n 'owner_id': mapping.owner.id,\n 'location_id': mapping.location.id,\n 'location_dest_id': mapping.location_dst_id,\n 'product_uom_id': uom.id,\n 'pack_lot_ids': [\n (0, 0, {'lot_id': lot, 'qty': 0.0, 'qty_todo': lots_grouped[mapping][lot]})\n for lot in lots_grouped.get(mapping, {}).keys()],\n }\n move_id_to_vals.setdefault(mapping.move_id.id, list()).append(val_dict)\n for move in self.move_lines.filtered(lambda move: move.state not in ('done', 'cancel')):\n values = move_id_to_vals.pop(move.id, [])\n pack_operation_values += values\n return pack_operation_values",
"def test_product_not_available_by_stock(self):\n product = ProductFactory(stock_amount=2)\n\n for i in range(2):\n opr = OrderProductRelationFactory(product=product)\n order = opr.order\n order.paid = True\n order.save()\n\n self.assertEqual(product.left_in_stock, 0)\n self.assertFalse(product.is_stock_available)\n self.assertFalse(product.is_available())",
"def _get_new_qty_for_none_goodies_line(self, cr, uid, qty, product_id, order_id, context=None):\n goodies_line_ids = self.search(cr, uid, [\n ['order_id', '=', order_id],\n ['product_id', '=', product_id],\n ['goodie_for_line_id', '!=', False]\n ], context=context)\n for goodie_line in self.browse(cr, uid, goodies_line_ids, context=context):\n qty -= goodie_line.product_qty\n if qty < 0:\n qty = 0\n return qty",
"def test_team_builder_config_product_size_materials_post(self):\n pass",
"def ingredient_used_canceled(self, item, quantity):\n logger.info('ReleaseDiscard ingredient used canceled initiated')\n try:\n quantity = Decimal(quantity).quantize(Decimal('0.11'))\n inventory_list = self.Inventory.search([('location', '=', self.used.id)]\n , order=[('batch_number', 'DESC')])\n product = self.Product.search([('name', '=', item),\n ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n done = False\n today = date.today()\n for i in inventory_list:\n for j in i.lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n # pdb.set_trace()\n if Decimal(j.quantity) >= Decimal(quantity):\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\n self.move(from_location=self.used, to_location=self.kitchen, item=product,\n quantity=quantity,\n batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=quantity, batch=i.batch_number)\n j.save()\n self.check_and_delete(i)\n done = True\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n self.move(from_location=self.used, to_location=self.kitchen, item=product,\n quantity=j.quantity, batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=j.quantity, batch=i.batch_number)\n j.quantity = 0\n j.save()\n self.check_and_delete(i)\n # transaction.cursor.commit()\n i.save()\n if done:\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False",
"def onchange_begin_transaction(self,cr,uid,ids,lot_id,pieces,length,heigth,width,context=None):\n if context is None:\n context = {}\n res = {'value':{}}\n \n if lot_id:\n \n lot_obj = self.pool.get('stock.production.lot')\n product_obj = self.pool.get('product.uom')\n lot_brw = lot_obj.browse(cr,uid,lot_id,context=context)\n area = lot_brw.virtual\n \n if lot_brw.product_id.stock_driver == 'normal' :\n res['value'].update({'factor': 3})\n if lot_brw.product_id.stock_driver == 'tile' :\n res['value'].update({'factor': 2})\n if lot_brw.product_id.stock_driver == 'slab' :\n res['value'].update({'factor': 1})\n if lot_brw.product_id.stock_driver == 'block' :\n res['value'].update({'factor': 0})\n \n res['value'].update({'length':lot_brw.length})\n res['value'].update({'length1':lot_brw.length})\n res['value'].update({'heigth':lot_brw.heigth})\n res['value'].update({'heigth1':lot_brw.heigth})\n res['value'].update({'width':lot_brw.width})\n res['value'].update({'width1':lot_brw.width})\n \n if lot_brw.product_id.stock_driver == 'tile' :\n if pieces == False:\n pieces = product_obj._compute_pieces2(cr, uid,lot_brw.product_id.stock_driver, lot_brw.virtual, lot_brw.length, lot_brw.heigth, lot_brw.width)\n else:\n area = product_obj._compute_area(cr, uid,lot_brw.product_id.stock_driver, pieces, lot_brw.length, lot_brw.heigth, lot_brw.width)\n res['value'].update({'length':lot_brw.length})\n res['value'].update({'length1':lot_brw.length})\n res['value'].update({'heigth':lot_brw.heigth})\n res['value'].update({'heigth1':lot_brw.heigth})\n res['value'].update({'width':lot_brw.width})\n res['value'].update({'width1':lot_brw.width})\n res['value'].update({'pieces_qty':pieces})\n res['value'].update({'pieces_qty1':pieces})\n res['value'].update({'quantity':area})\n res['value'].update({'quantity1':area})\n\n if lot_brw.product_id.stock_driver in ('slab','block'):\n pieces = 1\n area = product_obj._compute_area(cr, uid,lot_brw.product_id.stock_driver, pieces,length,heigth,width)\n res['value'].update({'quantity': area})\n res['value'].update({'quantity1': area})\n \n if lot_brw.virtual == 0:\n raise osv.except_osv(_('Processing Error'), _('The lot specified is not available in the stock')\\\n ) \n return res",
"def test_fixed_order_quantity(self):\n fixed_order_quantity = self._uncertain_demand.fixed_order_quantity\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n cal_fixed_orders = lambda j, x, y, z: (2 * j * (x / (y * z))) ** 0.5\n test_fixed_orders = cal_fixed_orders(\n float(self._reorder_cost),\n float(avg_order),\n float(self._unit_cost),\n float(self._holding_cost_percentge)\n )\n\n self.assertEqual(int(fixed_order_quantity), int(test_fixed_orders))",
"def action_confirm(self):\n if any(not l.is_available for l in self.mapped('order_line')):\n raise UserError(_('Some of your products in order does not have enough quantity available'))\n res = super(SaleOrder, self).action_confirm()\n return res",
"def update_product_in_serial_number(self, cr, uid, ids, move_ids, context=None):\n if context is None:\n context = {}\n\n prodlot_obj = self.pool.get('stock.production.lot')\n move_sn_obj = self.pool.get('stock.move.serial.number')\n picking_obj = self.pool.get('stock.picking')\n move_obj = self.pool.get('stock.move')\n \n sale_order_id = False\n picking_id = False\n lines = []\n for data in self.browse(cr, uid, ids, context=context):\n date_sn = data.date_input\n if not date_sn:\n date_sn = fields.date.today() \n wz_type = data.type\n if wz_type == 'in' :\n lines = data.line_in_ids \n elif wz_type in ('out','internal') :\n lines = data.line_out_ids\n active_model = context.get('active_model') \n if active_model == 'stock.picking.out':\n active_id = context.get('active_id')\n for pick in picking_obj.browse(cr, uid, [active_id], context=context):\n movelines = pick.move_lines\n if not movelines:\n raise osv.except_osv(_('Error!'), _('Product tidak boleh kosong !')) \n product_ids = []\n total_qty_product = 0 \n for line in movelines :\n product_id = line.product_id.id \n #data semua product di picking\n product_ids.append(product_id)\n #hitung total qty product dalam satu picking\n total_qty_product += line.product_qty \n self.execute_serial_number_per_picking_out(cr, uid, ids, lines, active_id, sale_order_id,\n prodlot_obj, move_obj, move_sn_obj, picking_obj, product_ids, total_qty_product, context=context) \n elif active_model == 'stock.move': \n for move in move_obj.browse(cr, uid, move_ids, context=context): \n\n move_qty = move.product_qty\n uos_qty_rest = move.product_uos_qty\n if move.picking_id :\n picking_id = move.picking_id.id\n if move.picking_id.sale_id :\n sale_order_id = move.picking_id.sale_id.id\n if not lines:\n raise osv.except_osv(_('Error!'), _('Daftar Serial Number tidak boleh kosong !'))\n total_move_qty = 0.0\n sn_free_text = []\n for line in lines: \n quantity = line.qty\n total_move_qty += quantity\n #jika out kasih minus karena barang keluar\n if wz_type == 'out' :\n raise osv.except_osv(_('Warning!'), _(\"DO tidak bisa memasukan serial number di fitur ini !\"))\n #jika internal kasih 0 karena barang pindah di internal\n if wz_type == 'internal' :\n quantity = 0 \n if data.type == 'in' :\n prodlot_id = prodlot_obj.search(cr,uid,[('name','=',line.serial_number),('product_id','=',False),('is_used','=',False)])\n if not prodlot_id:\n raise osv.except_osv(_('Warning!'), _(\"Serial number %s belum di input \\\n atau sudah digunakan product lain !\") % (line.serial_number))\n if line.serial_number in sn_free_text:\n continue\n sn_free_text.append(line.serial_number) \n # update SN dengan product di wizard ini\n prodlot_obj.write(cr,uid,prodlot_id[0],{'product_id':data.product_id.id,'date_sn_input_in': date_sn,},context=context)\n # create stock_move_serial_number yang related ke stock_move ini\n move_sn_obj.create(cr,uid,{'stock_move_id' : move.id,\n 'serial_number_id' : prodlot_id[0],\n 'picking_id' : picking_id,\n 'product_id' : move.product_id.id,\n 'qty' : quantity,\n 'type' : 'in',\n 'sale_order_id' : sale_order_id,\n }) \n \n if not data.different_total_sn: \n if move_qty != total_move_qty:\n raise osv.except_osv(_('Processing Error!'), _('Jumlah Qty serial number (%d) tidak sama dengan jumlah qty product(%d)!') \\\n % (total_move_qty, move_qty))\n #untuk mengilangkan tombol insert SN\n move_obj.write(cr,uid,move.id,{'is_serial_number':True},context=context) \n\n #delete dulu semua data di wizard\n cr.execute('DELETE FROM stock_move_serial_number_wizard_lines_in')\n cr.execute('DELETE FROM stock_move_serial_number_wizard_lines_out')\n return True",
"def check(self, context):\n self.update_product_size()\n return True",
"def check(self, context):\n self.update_product_size()\n return True",
"def release(self, item, quantity):\n logger.info('ReleaseDiscard item release initiated')\n try:\n with Transaction().start(DBNAME, 1) as transaction:\n transaction.context = config.get_config().context\n quantity = Decimal(quantity)\n inventory_list = self.Inventory.search([('location', '=', self.inventory.id)]\n , order=[('batch_number', 'ASC')])\n product = self.Product.search([('name', '=', item),\n ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n done = False\n today = date.today()\n for i in inventory_list:\n for j in i.lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n if Decimal(j.quantity) >= Decimal(quantity):\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\n self.move(from_location=self.inventory, to_location=self.kitchen, item=product,\n quantity=quantity,\n batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=quantity, batch=i.batch_number)\n j.save()\n self.check_and_delete(i)\n done = True\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n self.move(from_location=self.inventory, to_location=self.kitchen, item=product,\n quantity=j.quantity, batch_number=i.batch_number)\n self.store_inventory(location=self.kitchen, inventory_stock=j,\n quantity=j.quantity, batch=i.batch_number)\n j.quantity = 0\n j.save()\n self.check_and_delete(i)\n # transaction.cursor.commit()\n i.save()\n transaction.cursor.commit()\n if done:\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False",
"def test_team_builder_config_product_size_materials_id_put(self):\n pass",
"def do_partial(self, cr, uid, ids, partial_datas, context=None):\n res = {}\n picking_obj = self.pool.get('stock.picking')\n product_obj = self.pool.get('product.product')\n currency_obj = self.pool.get('res.currency')\n location_obj = self.pool.get('stock.location')\n uom_obj = self.pool.get('product.uom')\n wf_service = netsvc.LocalService(\"workflow\")\n\n if context is None:\n context = {}\n\n complete, too_many, too_few = [], [], []\n move_product_qty = {}\n prodlot_ids = {}\n for move in self.browse(cr, uid, ids, context=context):\n if move.state in ('done', 'cancel'):\n continue\n partial_data = partial_datas.get('move%s' % (move.id), False)\n assert partial_data, _(\n 'Missing partial picking data for move #%s.') % (move.id)\n product_qty = partial_data.get('product_qty', 0.0)\n move_product_qty[move.id] = product_qty\n product_uom = partial_data.get('product_uom', False)\n product_price = partial_data.get('product_price', 0.0)\n product_currency = partial_data.get('product_currency', False)\n prodlot_ids[move.id] = partial_data.get('prodlot_id')\n if move.product_qty == product_qty:\n complete.append(move)\n elif move.product_qty > product_qty:\n too_few.append(move)\n else:\n too_many.append(move)\n\n # <<<< change begin <<<<<<<<<<\n # get the qty of available Alex\n product_qty_available = location_obj.get_product_qty_of_checked_locations(\n cr, uid, [],\n move.product_id.id, context=context, states=['done']).get(\n move.product_id.id, 0.0)\n # <<<< change ends <<<<<<<<<<<<\n\n # Average price computation\n if (move.picking_id.type == 'in') and (move.product_id.cost_method == 'average'):\n product = product_obj.browse(cr, uid, move.product_id.id)\n move_currency_id = move.company_id.currency_id.id\n context['currency_id'] = move_currency_id\n qty = uom_obj._compute_qty(cr, uid, product_uom, product_qty, product.uom_id.id)\n if qty > 0:\n new_price = currency_obj.compute(\n cr, uid, product_currency,\n move_currency_id, product_price)\n new_price = uom_obj._compute_price(\n cr, uid, product_uom, new_price,\n product.uom_id.id)\n if product_qty_available <= 0:\n new_std_price = new_price\n else:\n # Get the standard price\n amount_unit = product.price_get(\n 'standard_price', context=context)[product.id]\n new_std_price = ((\n amount_unit * product_qty_available) +\n (new_price * qty)) / (product_qty_available + qty)\n\n product_obj.write(\n cr, uid, [product.id],\n {'standard_price': new_std_price})\n\n # Record the values that were chosen in the wizard,\n # so they can be used for inventory valuation if\n # real-time valuation is enabled.\n self.write(\n cr, uid, [move.id],\n {'price_unit': product_price,\n 'price_currency_id': product_currency,\n })\n\n for move in too_few:\n product_qty = move_product_qty[move.id]\n if product_qty != 0:\n defaults = {\n 'product_qty': product_qty,\n 'product_uos_qty': product_qty,\n 'picking_id': move.picking_id.id,\n 'state': 'assigned',\n 'move_dest_id': False,\n 'price_unit': move.price_unit,\n }\n prodlot_id = prodlot_ids[move.id]\n if prodlot_id:\n defaults.update(prodlot_id=prodlot_id)\n new_move = self.copy(cr, uid, move.id, defaults)\n complete.append(self.browse(cr, uid, new_move))\n self.write(\n cr, uid, [move.id],\n {\n 'product_qty': move.product_qty - product_qty,\n 'product_uos_qty': move.product_qty - product_qty,\n 'prodlot_id': False,\n 'tracking_id': False,\n })\n\n for move in too_many:\n self.write(\n cr, uid, [move.id],\n {\n 'product_qty': move.product_qty,\n 'product_uos_qty': move.product_qty,\n })\n complete.append(move)\n\n for move in complete:\n if prodlot_ids.get(move.id):\n self.write(\n cr, uid, [move.id],\n {'prodlot_id': prodlot_ids.get(move.id)})\n self.action_done(cr, uid, [move.id], context=context)\n if move.picking_id.id:\n # TOCHECK : Done picking if all moves are done\n cr.execute(\"\"\"\n SELECT move.id FROM stock_picking pick\n RIGHT JOIN stock_move move ON move.picking_id = pick.id AND move.state = %s\n WHERE pick.id = %s\"\"\", ('done', move.picking_id.id))\n res = cr.fetchall()\n if len(res) == len(move.picking_id.move_lines):\n picking_obj.action_move(cr, uid, [move.picking_id.id])\n wf_service.trg_validate(uid, 'stock.picking', move.picking_id.id, 'button_done', cr)\n\n return [move.id for move in complete]",
"def test_check_user_quantity_stocks_for_given_item_with_smaller_quantity(\n offer_sell_instance,\n):\n\n result = check_user_quantity_stocks_for_given_item(\n user_id=offer_sell_instance.user.id,\n item_id=offer_sell_instance.item.id,\n quantity=\"900\",\n )\n\n assert result == True",
"def _validate_qty(values: dict):\n\n if not (quantity := values.get('quantity')):\n raise ValueError(\"Quantity attribute is required.\")\n\n if not (symbol := values.get('symbol')):\n raise ValueError(\"Symbol attribute is required.\")\n\n filter = symbol.filters.lot_size_filter\n # if ONE :=1 and not filter.min_qty <= quantity <= filter.max_qty:\n # ValueError(\"The quantity is not in valid range.\")\n\n if filter.step_size and not is_valid_significant_digits(\n quantity,\n symbol.qty_decimal_precision\n ):\n raise ValueError(\"The quantity precision is not valid.\")\n\n return values",
"def test_manufacturing_scrap(self):\n\n # Update demo products\n (self.product_4 | self.product_2).write({\n 'tracking': 'lot',\n })\n\n # Update Bill Of Material to remove product with phantom bom.\n self.bom_3.bom_line_ids.filtered(lambda x: x.product_id == self.product_5).unlink()\n\n # Create Inventory Adjustment For Stick and Stone Tools with lot.\n lot_product_4 = self.env['stock.production.lot'].create({\n 'name': '0000000000001',\n 'product_id': self.product_4.id,\n 'company_id': self.env.company.id,\n })\n lot_product_2 = self.env['stock.production.lot'].create({\n 'name': '0000000000002',\n 'product_id': self.product_2.id,\n 'company_id': self.env.company.id,\n })\n\n stock_inv_product_4 = self.env['stock.inventory'].create({\n 'name': 'Stock Inventory for Stick',\n 'product_ids': [(4, self.product_4.id)],\n 'line_ids': [\n (0, 0, {'product_id': self.product_4.id, 'product_uom_id': self.product_4.uom_id.id, 'product_qty': 8, 'prod_lot_id': lot_product_4.id, 'location_id': self.stock_location_14.id}),\n ]})\n\n stock_inv_product_2 = self.env['stock.inventory'].create({\n 'name': 'Stock Inventory for Stone Tools',\n 'product_ids': [(4, self.product_2.id)],\n 'line_ids': [\n (0, 0, {'product_id': self.product_2.id, 'product_uom_id': self.product_2.uom_id.id, 'product_qty': 12, 'prod_lot_id': lot_product_2.id, 'location_id': self.stock_location_14.id})\n ]})\n (stock_inv_product_4 | stock_inv_product_2)._action_start()\n stock_inv_product_2.action_validate()\n stock_inv_product_4.action_validate()\n\n #Create Manufacturing order.\n production_form = Form(self.env['mrp.production'])\n production_form.product_id = self.product_6\n production_form.bom_id = self.bom_3\n production_form.product_qty = 12\n production_form.product_uom_id = self.product_6.uom_id\n production_3 = production_form.save()\n production_3.action_confirm()\n production_3.action_assign()\n\n # Check Manufacturing order's availability.\n self.assertEqual(production_3.reservation_state, 'assigned', \"Production order's availability should be Available.\")\n\n location_id = production_3.move_raw_ids.filtered(lambda x: x.state not in ('done', 'cancel')) and production_3.location_src_id.id or production_3.location_dest_id.id,\n\n # Scrap Product Wood without lot to check assert raise ?.\n scrap_id = self.env['stock.scrap'].with_context(active_model='mrp.production', active_id=production_3.id).create({'product_id': self.product_2.id, 'scrap_qty': 1.0, 'product_uom_id': self.product_2.uom_id.id, 'location_id': location_id, 'production_id': production_3.id})\n with self.assertRaises(UserError):\n scrap_id.do_scrap()\n\n # Scrap Product Wood with lot.\n self.env['stock.scrap'].with_context(active_model='mrp.production', active_id=production_3.id).create({'product_id': self.product_2.id, 'scrap_qty': 1.0, 'product_uom_id': self.product_2.uom_id.id, 'location_id': location_id, 'lot_id': lot_product_2.id, 'production_id': production_3.id})\n\n #Check scrap move is created for this production order.\n #TODO: should check with scrap objects link in between",
"def test_loc_techs_storage_capacity_min_purchase_milp_constraint(self):\n m = build_model(\n {\"techs.test_storage.constraints.storage_cap_min\": 10},\n \"simple_storage,two_hours,investment_costs\",\n )\n m.run(build_only=True)\n assert not hasattr(\n m._backend_model, \"storage_capacity_min_purchase_milp_constraint\"\n )\n\n m = build_model(\n {\"techs.test_storage.constraints.storage_cap_min\": 10},\n \"storage_milp,two_hours,investment_costs\",\n )\n m.run(build_only=True)\n assert not hasattr(\n m._backend_model, \"storage_capacity_min_purchase_milp_constraint\"\n )\n\n m = build_model({}, \"storage_purchase,two_hours,investment_costs\")\n m.run(build_only=True)\n assert not hasattr(\n m._backend_model, \"storage_capacity_min_purchase_milp_constraint\"\n )\n\n m = build_model(\n {\"techs.test_storage.constraints.storage_cap_min\": 10},\n \"storage_purchase,two_hours,investment_costs\",\n )\n m.run(build_only=True)\n assert hasattr(\n m._backend_model, \"storage_capacity_min_purchase_milp_constraint\"\n )\n\n m = build_model(\n {\n \"techs.test_storage.constraints\": {\n \"storage_cap_equals\": 10,\n \"storage_cap_min\": 10,\n }\n },\n \"storage_purchase,two_hours,investment_costs\",\n )\n m.run(build_only=True)\n assert not hasattr(\n m._backend_model, \"storage_capacity_min_purchase_milp_constraint\"\n )",
"def test_cannot_sell_more_than_stock(self):\n reply = self.admin_add_product()\n\n resp = self.admin_create_user()\n reply = self.attendant_login()\n token = reply['token']\n sale = dict(products = [\n {\n \"prod_name\":\"NY_denims\", \n \"quantity\":10\n }\n\t ])\n resp = self.client.post(\n '/api/v1/sales',\n content_type='application/json',\n data=json.dumps(sale),\n headers={'Authorization': 'Bearer {}'.format(token)}\n )\n reply = json.loads(resp.data.decode())\n \n self.assertEqual(reply['message'], 'Sale record created')\n self.assertEqual(resp.status_code, 200)\n\n sale = dict(products = [\n {\n \"prod_name\":\"NY_denims\", \n \"quantity\":15\n }\n\t ])\n resp = self.client.post(\n '/api/v1/sales',\n content_type='application/json',\n data=json.dumps(sale),\n headers={'Authorization': 'Bearer {}'.format(token)}\n )\n reply = json.loads(resp.data.decode())\n \n self.assertEqual(reply['message'], 'Only 10 NY_denims available right now!')\n self.assertEqual(resp.status_code, 400)",
"def test_ComputerPartition_error_twoSalePackingList(self):\n sequence_list = SequenceList()\n sequence_string = self.prepare_start_requested_computer_partition_sequence_string + '\\\n LoginDefaultUser \\\n SetHostingAfterSetupStartDate \\\n Tic \\\n Logout \\\n SlapLoginCurrentComputer \\\n CheckSuccessComputerPartitionErrorCall \\\n Tic \\\n LoginDefaultUser \\\n CheckSalePackingListNoErrorText \\\n SetHostingBeforeSetupStartDate \\\n Tic \\\n Logout \\\n SlapLoginCurrentComputer \\\n CheckSuccessComputerPartitionErrorCall \\\n Tic \\\n SlapLogout \\\n LoginDefaultUser \\\n CheckSalePackingListErrorText \\\n Logout \\\n LoginERP5TypeTestCase \\\n CheckSiteConsistency \\\n Logout \\\n '\n sequence_list.addSequenceString(sequence_string)\n sequence_list.play(self)",
"def test_assign_orders():\n allocator = RecipeAllocator()\n allocator.load_data(\n orders_dir=\"tests/orders.json\", recipes_dir=\"tests/recipes.json\"\n )\n result = allocator.assign_orders(box_type=\"vegetarian\")\n assert result[\"excess_stock\"].loc[\"recipe_2\", \"stock_count\"] == 6",
"def test_case_1(self):\n\n orders_data = generate_orders_data([30, 10, 20])\n assigned_delivery_vehicles = SlotDelivery.assign_new_batch_order_delivery(\n slot_number=1, orders=orders_data)\n\n bike = VehicleType.objects.get(name='bike')\n self.assertEqual(len(assigned_delivery_vehicles), 2) # 2 vehicles\n self.assertEqual(\n sum(dv.vehicle_type == bike for dv in assigned_delivery_vehicles), 2\n ) # 2 bike",
"def test_multiple_quants(self):\n # Get all quants in test package\n quants = self.quant_1 | self.quant_2\n pick = quants.create_picking(self.picking_type_pick)\n # Check picking has correct location\n self.assertEqual(pick.location_id, self.stock_location)\n # Check picking has correct products and quantities associated to it\n self.assertEqual(pick.move_lines.product_id, quants.product_id)\n self.assertEqual(pick.move_lines.mapped(\"product_qty\"), [10.0, 10.0])",
"def qty_available(quant) -> float:\n return quant.quantity - quant.reserved_quantity",
"def test_buyTicket_insufficientFunds():\n old_venue_balance = testVenue.wallet\n assert not testUser4.buyTicket(testTicket3)\n assert testTicket3 not in testUser4.inventory\n assert testTicket3.for_sale\n assert testUser4.wallet == 0\n assert testVenue.wallet == old_venue_balance",
"def test_buyTicket_EmptiesWallet():\n old_venue_balance = testVenue.wallet\n assert testUser1.buyTicket(testTicket1)\n assert testUser1.inventory[-1] == testTicket1\n assert not testTicket1.for_sale\n assert testUser1.wallet == 0\n assert testVenue.wallet == old_venue_balance + testTicket1.list_price",
"def calculate_stock_batch(warehouse=None, safety_stock=None):\n if not warehouse:\n inwards = (\n Inward.objects.values(\n \"part_number__part_name\",\n \"batch_number\"\n ).order_by(\"part_number__part_name\")\n .annotate(\n inw_received_qt_total=Sum(\"received_quantity\"),\n defect_qt_total=Sum(\"defected_quantity\"),\n )\n )\n\n outwards = (\n Outward.objects.values(\n \"part_number__part_name\",\n \"batch_number\"\n ).order_by(\"part_number__part_name\")\n .annotate(outward_qt_total=Sum(\"quantity\"))\n )\n\n else:\n inwards = (\n Inward.objects.filter(to_warehouse_name=warehouse)\n .values(\n \"part_number__part_name\",\n \"batch_number\"\n ).order_by(\"part_number__part_name\")\n .annotate(\n inw_received_qt_total=Sum(\"received_quantity\"),\n defect_qt_total=Sum(\"defected_quantity\"),\n )\n )\n outwards = (\n Outward.objects.filter(from_warehouse_name=warehouse)\n .values(\n \"part_number__part_name\",\n \"batch_number\"\n ).order_by(\"part_number__part_name\")\n .annotate(outward_qt_total=Sum(\"quantity\"))\n )\n\n partnames = []\n\n for inward in inwards:\n partnames.append({\n 'part_name': inward['part_number__part_name'],\n 'inward': inward['inw_received_qt_total'],\n 'defect': inward['defect_qt_total'],\n 'outward': 0,\n 'batch_number': inward['batch_number'],\n 'total_usable_stock': inward['inw_received_qt_total'] - inward['defect_qt_total'],\n 'total_stock': inward['inw_received_qt_total'],\n })\n for outward in outwards:\n outward_partname = outward['part_number__part_name']\n outward_batch_number = outward['batch_number']\n for partname in partnames:\n if outward_partname in partname and outward_batch_number in partname:\n partname[outward_partname]['outward'] = \\\n outward['outward_qt_total']\n partname[outward_partname]['total_stock'] -= \\\n partname[outward_partname]['outward']\n\n partname[outward_partname]['total_usable_stock'] -= \\\n partname[outward_partname]['outward']\n\n return (partnames)",
"def action_consume(self, cr, uid, ids, product_qty, location_id=False, restrict_lot_id=False, restrict_partner_id=False,\n consumed_for=False, context=None):\n if context is None:\n context = {}\n res = []\n production_obj = self.pool.get('mrp.production')\n uom_obj = self.pool.get('product.uom')\n\n if product_qty <= 0:\n raise osv.except_osv(_('Warning!'), _('Please provide proper quantity.'))\n #because of the action_confirm that can create extra moves in case of phantom bom, we need to make 2 loops\n ids2 = []\n for move in self.browse(cr, uid, ids, context=context):\n if move.state == 'draft':\n ids2.extend(self.action_confirm(cr, uid, [move.id], context=context))\n else:\n ids2.append(move.id)\n\n for move in self.browse(cr, uid, ids2, context=context):\n move_qty = move.product_qty\n uom_qty = uom_obj._compute_qty(cr, uid, move.product_id.uom_id.id, product_qty, move.product_uom.id)\n if move_qty <= 0:\n raise osv.except_osv(_('Error!'), _('Cannot consume a move with negative or zero quantity.'))\n quantity_rest = move.product_qty - uom_qty\n if quantity_rest > 0:\n ctx = context.copy()\n if location_id:\n ctx['source_location_id'] = location_id\n new_mov = self.split(cr, uid, move, move_qty - quantity_rest, restrict_lot_id=restrict_lot_id, restrict_partner_id=restrict_partner_id, context=ctx)\n self.write(cr, uid, new_mov, {'consumed_for': consumed_for}, context=context)\n res.append(new_mov)\n else:\n res.append(move.id)\n if location_id:\n self.write(cr, uid, [move.id], {'location_id': location_id, 'restrict_lot_id': restrict_lot_id,\n 'restrict_partner_id': restrict_partner_id,\n 'consumed_for': consumed_for}, context=context)\n self.action_done(cr, uid, res, context=context)\n production_ids = production_obj.search(cr, uid, [('move_lines', 'in', [move.id])])\n production_obj.signal_button_produce(cr, uid, production_ids)\n for new_move in res:\n if new_move != move.id:\n #This move is not already there in move lines of production order\n production_obj.write(cr, uid, production_ids, {'move_lines': [(4, new_move)]})\n return res",
"def test_put_nveto_pmt_item(self):\n pass",
"def __confirm_trade_lots(\n self, trade_lots: int, trade_price: float, trader_fund: int\n ):\n final_trade_lots = 0\n trade_volume = abs(trade_lots) * self.board_lot\n if trade_lots > 0:\n if self.__have_enough_money(trader_fund, trade_price, trade_volume):\n final_trade_lots = trade_lots\n else:\n final_trade_lots = 0\n elif trade_lots < 0:\n hold_volume = self.hold_volume\n if self.__have_enough_volume(hold_volume, trade_volume):\n final_trade_lots = trade_lots\n else:\n final_trade_lots = 0\n return final_trade_lots",
"def clean(self):\n cleaned_data = super().clean()\n variant = cleaned_data.get('variant')\n quantity = cleaned_data.get('quantity')\n if variant and quantity is not None:\n try:\n variant.check_quantity(quantity)\n except InsufficientStock as e:\n error = forms.ValidationError(\n pgettext_lazy(\n 'Add item form error',\n 'Could not add item. '\n 'Only %(remaining)d remaining in stock.' %\n {'remaining': e.item.quantity_available}))\n self.add_error('quantity', error)\n return cleaned_data",
"def generate_orders(self, good):\n surplus = self.inventory.surplus(good)\n if surplus >= 1: # sell inventory\n # the original only old one item here\n sell_amount = surplus\n order = self.create_sell_order(good, surplus)\n if order:\n # print('{} sells {} {}'.format(self.pop_job.title, sell_amount, good.name))\n self.market.sell(order)\n else: # buy more\n shortage = self.inventory.shortage(good)\n free_space = self.inventory.empty_space\n\n if shortage > 0:\n if shortage <= free_space:\n # enough space for ideal order\n limit = shortage\n else:\n # not enough space for ideal order\n limit = math.floor(free_space / shortage)\n\n if limit > 0:\n order = self.create_buy_order(good, limit)\n if order:\n # print('{} buys {} {}'.format(self.pop_job.title, limit, good.name))\n self.market.buy(order)\n # else:\n # print(\"{} has no shortage of {} (has shortage: {})\".format(self.pop_job.title, good.title, shortage))",
"def test_loc_techs_storage_capacity_units_milp_constraint(self):\n m = build_model({}, \"simple_supply,two_hours,investment_costs\")\n m.run(build_only=True)\n assert not hasattr(m._backend_model, \"storage_capacity_units_milp_constraint\")\n\n m = build_model({}, \"supply_milp,two_hours,investment_costs\")\n m.run(build_only=True)\n assert not hasattr(m._backend_model, \"storage_capacity_units_milp_constraint\")\n\n m = build_model({}, \"storage_milp,two_hours,investment_costs\")\n m.run(build_only=True)\n assert hasattr(m._backend_model, \"storage_capacity_units_milp_constraint\")\n\n m = build_model({}, \"conversion_plus_milp,two_hours,investment_costs\")\n m.run(build_only=True)\n assert not hasattr(m._backend_model, \"storage_capacity_units_milp_constraint\")\n\n m = build_model({}, \"supply_and_supply_plus_milp,two_hours,investment_costs\")\n m.run(build_only=True)\n assert hasattr(m._backend_model, \"storage_capacity_units_milp_constraint\")",
"def test_add_to_cart_item_at_minimum_stock(self):\n response = self.client.get(\n '/self.base_url/sales/2/1',\n headers=dict(Authorization=\"Bearer \" + self.attendant_token),\n content_type = 'application/json'\n )\n response_data = json.loads(response.data)\n self.assertEqual(response_data['message'],\"The following product has reached the mimimum stock, please contact the admin for sales below minimum stock\")\n self.assertEqual(response.status_code,200)",
"def validate(self, value):\n\n current_values = dict(self.queryset.values_list('id', 'quantity'))\n for product_id in self.product_fields.keys():\n self.product_fields[product_id]['quantity'] = current_values[product_id]\n\n errors = []\n for (product_id, product_data), chosen_value in zip(self.product_fields.items(), value):\n name = product_data['name']\n int_chosen_val = int(chosen_value)\n if product_data['quantity'] == 0:\n errors.append(\n ValidationError(self.error_messages['out_of_stock'].format(name))\n )\n continue\n if int_chosen_val <= 0:\n errors.append(\n ValidationError(self.error_messages['incorrect_quantity'].format(name))\n )\n continue\n\n if product_data['quantity'] < int_chosen_val:\n errors.append(\n ValidationError(self.error_messages['less_quantity'].format(product_data['quantity'], name))\n )\n continue\n\n if len(errors) > 0:\n raise ValidationError(errors)",
"def check_stock(self):\n if self.quantity > self.item.quantity:\n return \"%s Please adjust your cart.\" % CartItem.get_insufficient_stock_msg(self.item.quantity)\n return None",
"def do_partial(self, cr, uid, ids, partial_datas, context=None):\n if context is None:\n context = {}\n else:\n context = dict(context)\n res = {}\n move_obj = self.pool.get('stock.move')\n product_obj = self.pool.get('product.product')\n currency_obj = self.pool.get('res.currency')\n uom_obj = self.pool.get('product.uom')\n sequence_obj = self.pool.get('ir.sequence')\n wf_service = netsvc.LocalService(\"workflow\")\n for pick in self.browse(cr, uid, ids, context=context):\n new_picking = None\n complete, too_many, too_few = [], [], []\n move_product_qty, prodlot_ids, product_avail, partial_qty, product_uoms = {}, {}, {}, {}, {}\n for move in pick.move_lines:\n if move.state in ('done', 'cancel'):\n continue\n partial_data = partial_datas.get('move%s'%(move.id), {})\n product_qty = partial_data.get('product_qty',0.0)\n move_product_qty[move.id] = product_qty\n product_uom = partial_data.get('product_uom',False)\n product_price = partial_data.get('product_price',0.0)\n product_currency = partial_data.get('product_currency',False)\n prodlot_id = partial_data.get('prodlot_id')\n prodlot_ids[move.id] = prodlot_id\n product_uoms[move.id] = product_uom\n partial_qty[move.id] = uom_obj._compute_qty(cr, uid, product_uoms[move.id], product_qty, move.product_uom.id)\n if move.product_qty == partial_qty[move.id]:\n complete.append(move)\n elif move.product_qty > partial_qty[move.id]:\n too_few.append(move)\n else:\n too_many.append(move)\n\n # Average price computation\n if (pick.type == 'in') and (move.product_id.cost_method == 'average'):\n ###############################################################\n pmp = self._create_line_pmp(cr, uid, [move.id],product_currency, product_price, product_qty, product_uom, context=context)\n ###############################################################\n product = product_obj.browse(cr, uid, move.product_id.id)\n# move_currency_id = move.company_id.currency_id.id\n# context['currency_id'] = move_currency_id\n qty = uom_obj._compute_qty(cr, uid, product_uom, product_qty, product.uom_id.id)\n#\n# if product.id in product_avail:\n# product_avail[product.id] += qty\n# else:\n# product_avail[product.id] = product.qty_available\n#\n if qty > 0:\n# new_price = currency_obj.compute(cr, uid, product_currency,\n# move_currency_id, product_price)\n# new_price = uom_obj._compute_price(cr, uid, product_uom, new_price,\n# product.uom_id.id)\n# if product.qty_available <= 0:\n# new_std_price = new_price\n# else:\n# # Get the standard price\n# amount_unit = product.price_get('standard_price', context=context)[product.id]\n# new_std_price = ((amount_unit * product_avail[product.id])\\\n# + (new_price * qty))/(product_avail[product.id] + qty)\n# # Write the field according to price type field\n id_pmp = self.pool.get('weighted.average.price').search(cr, uid, [('product_id', '=', product.id),('company_id','=', move.company_id.id)],order='date desc')\n obj = self.pool.get('weighted.average.price').browse(cr, uid, id_pmp[0])\n \n #TODO No creo que se deba reescribir el qty_available en ningún caso ya que es el que el sistema debe calcular\n #product_obj.write(cr, uid, [product.id], {'standard_price': obj.pmp, 'qty_available': obj.stock_qty})\n product_obj.write(cr, uid, [product.id], {'standard_price': obj.pmp})\n \n # Record the values that were chosen in the wizard, so they can be\n # used for inventory valuation if real-time valuation is enabled.\n move_obj.write(cr, uid, [move.id],\n {'price_unit': product_price,\n 'price_currency_id': product_currency})\n\n\n for move in too_few:\n product_qty = move_product_qty[move.id]\n if not new_picking:\n new_picking = self.copy(cr, uid, pick.id,\n {\n 'name': sequence_obj.get(cr, uid, 'stock.picking.%s'%(pick.type)),\n 'move_lines' : [],\n 'state':'draft',\n })\n if product_qty != 0:\n defaults = {\n 'product_qty' : product_qty,\n 'product_uos_qty': product_qty, #TODO: put correct uos_qty\n 'picking_id' : new_picking,\n 'state': 'assigned',\n 'move_dest_id': False,\n 'price_unit': move.price_unit,\n 'product_uom': product_uoms[move.id]\n }\n prodlot_id = prodlot_ids[move.id]\n if prodlot_id:\n defaults.update(prodlot_id=prodlot_id)\n move_obj.copy(cr, uid, move.id, defaults)\n move_obj.write(cr, uid, [move.id],\n {\n 'product_qty' : move.product_qty - partial_qty[move.id],\n 'product_uos_qty': move.product_qty - partial_qty[move.id], #TODO: put correct uos_qty\n\n })\n\n if new_picking:\n move_obj.write(cr, uid, [c.id for c in complete], {'picking_id': new_picking})\n for move in complete:\n defaults = {'product_uom': product_uoms[move.id], 'product_qty': move_product_qty[move.id]}\n if prodlot_ids.get(move.id):\n defaults.update({'prodlot_id': prodlot_ids[move.id]})\n move_obj.write(cr, uid, [move.id], defaults)\n for move in too_many:\n product_qty = move_product_qty[move.id]\n defaults = {\n 'product_qty' : product_qty,\n 'product_uos_qty': product_qty, #TODO: put correct uos_qty\n 'product_uom': product_uoms[move.id]\n }\n prodlot_id = prodlot_ids.get(move.id)\n if prodlot_ids.get(move.id):\n defaults.update(prodlot_id=prodlot_id)\n if new_picking:\n defaults.update(picking_id=new_picking)\n move_obj.write(cr, uid, [move.id], defaults)\n\n # At first we confirm the new picking (if necessary)\n if new_picking:\n wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_confirm', cr)\n # Then we finish the good picking\n self.write(cr, uid, [pick.id], {'backorder_id': new_picking})\n self.action_move(cr, uid, [new_picking])\n wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_done', cr)\n wf_service.trg_write(uid, 'stock.picking', pick.id, cr)\n delivered_pack_id = new_picking\n else:\n self.action_move(cr, uid, [pick.id])\n wf_service.trg_validate(uid, 'stock.picking', pick.id, 'button_done', cr)\n delivered_pack_id = pick.id\n\n delivered_pack = self.browse(cr, uid, delivered_pack_id, context=context)\n res[pick.id] = {'delivered_picking': delivered_pack.id or False}\n\n return res",
"def test_add_to_cart_item_not_in_system(self):\n # test sale products not in db\n\n response = self.client.get(\n '/self.base_url/sales/1999/2',\n headers=dict(Authorization=\"Bearer \" + self.attendant_token),\n content_type = 'application/json'\n )\n\n response_data = json.loads(response.data)\n self.assertEqual(response_data['message'],\"This product does not exist\")\n self.assertEqual(response.status_code,200)\n\n\n # test add item which is at minimum stock",
"def _check_product(self):\n\n self.importable = False\n abcde = string.ascii_uppercase[:5]\n product_infos = self.retrieve_product_infos()\n\n if product_infos['product_code'] is not None:\n try:\n Products.objects.get(\n code=product_infos['product_code']\n )\n except Products.DoesNotExist:\n if (\n product_infos['product_name'] is not None\n and product_infos['product_code'] not in ProductImportation.codes\n and product_infos['product_code'] is not None\n and product_infos['product_url'] is not None\n and product_infos['image_url'] is not None\n and product_infos['quantity'] is not None\n and product_infos['ingredients'] is not None\n and product_infos['brands'] != []\n and product_infos['stores'] != []\n and product_infos['countries'] is not None\n and product_infos['compare_to'] is not None\n and product_infos['categories_hierarchy'] is not None\n and product_infos['nutriscore'] in abcde\n and all([product_infos[nutriment] >= 0 for nutriment in self.list_nutriments])\n and Categories.objects.filter(name=product_infos['compare_to']).count() > 0\n ):\n self.name = product_infos['product_name']\n self.product_infos = product_infos\n self.code = product_infos['product_code']\n ProductImportation.codes.append(self.code)\n self.importable = True\n\n return self.importable",
"def test_team_builder_config_product_size_materials_id_replace_post(self):\n pass",
"def action_pack(self, cr, uid, picking_ids, operation_filter_ids=None, context=None):\n if operation_filter_ids is None:\n operation_filter_ids = []\n stock_operation_obj = self.pool.get('stock.pack.operation')\n package_obj = self.pool.get('stock.quant.package')\n stock_move_obj = self.pool.get('stock.move')\n package_id = False\n for picking_id in picking_ids:\n operation_search_domain = [('picking_id', '=', picking_id), ('result_package_id', '=', False)]\n if operation_filter_ids != []:\n operation_search_domain.append(('id', 'in', operation_filter_ids))\n operation_ids = stock_operation_obj.search(cr, uid, operation_search_domain, context=context)\n pack_operation_ids = []\n if operation_ids:\n for operation in stock_operation_obj.browse(cr, uid, operation_ids, context=context):\n # If we haven't done all qty in operation, we have to split into 2 operation\n op = operation\n if (operation.qty_done < operation.product_qty):\n new_operation = stock_operation_obj.copy(\n cr,\n uid,\n operation.id,\n {'product_qty': operation.qty_done, 'qty_done': operation.qty_done},\n context=context\n )\n stock_operation_obj.write(\n cr,\n uid,\n operation.id,\n {'product_qty': operation.product_qty - operation.qty_done, 'qty_done': 0},\n context=context\n )\n op = stock_operation_obj.browse(cr, uid, new_operation, context=context)\n pack_operation_ids.append(op.id)\n if op.product_id and op.location_id and op.location_dest_id:\n stock_move_obj.check_tracking_product(\n cr,\n uid,\n op.product_id,\n op.lot_id.id,\n op.location_id,\n op.location_dest_id,\n context=context\n )\n package_id = package_obj.create(cr, uid, {}, context=context)\n stock_operation_obj.write(\n cr,\n uid,\n pack_operation_ids,\n {'result_package_id': package_id},\n context=context\n )\n return package_id",
"def _buy(self, units=1):\n self.quantity -= units",
"def test_05_purchase_order(self):\n # Create purchase Order and check purchase order was created correctly\n # (without lines)\n order = self.create_po()\n self.assertTrue(order)\n self.assertFalse(order.order_line)\n\n # Add one sellable line (first line)\n sellable_product = self.product_obj.browse(self.sellable_product)\n self.create_pol(order, sellable_product)\n self.assertTrue(order.order_line)\n self.assertEquals(len(order.order_line), 1)\n self.assertIn(sellable_product, order.order_line.mapped('product_id'))\n self.assertEquals(order.order_line.product_id.state2, 'sellable')\n\n # Add one draft line (second line)\n draft_product = self.product_obj.browse(self.draft_product)\n self.create_pol(order, draft_product)\n self.assertEquals(len(order.order_line), 2)\n self.assertIn(draft_product, order.order_line.mapped('product_id'))\n self.assertEquals(set(order.order_line.mapped('product_id.state2')),\n set(['sellable', 'draft']))\n\n # Add one obsolete line. This will raise an exception.\n obsolete_product = self.product_obj.browse(self.obsolete_product)\n with self.assertRaises(exceptions.Warning):\n self.create_pol(order, obsolete_product)",
"def confirm_harvest_pickle(before, after):\n assert after.strategy.balanceOf > before.strategy.balanceOf\n assert after.strategy.pickleBalance == 0\n assert after.strategy.stakingRewards.stakedPickle == 0\n if before.sett.pricePerFullShare:\n assert after.sett.pricePerFullShare > before.sett.pricePerFullShare",
"def test_generate_04_generate_in_multiple_time(self):\n nbre_of_lines = 10\n move = self.get_new_move(nbre_of_lines)\n\n form_wizard = Form(self.env['stock.assign.serial'].with_context(\n default_move_id=move.id,\n ))\n # First assignment\n form_wizard.next_serial_count = 3\n form_wizard.next_serial_number = '001'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Second assignment\n form_wizard.next_serial_count = 2\n form_wizard.next_serial_number = 'bilou-64'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n # Third assignment\n form_wizard.next_serial_count = 4\n form_wizard.next_serial_number = 'ro-1337-bot'\n wiz = form_wizard.save()\n wiz.generate_serial_numbers()\n\n # Checks all move lines have the right SN\n generated_numbers = [\n # Correspond to the first assignment\n '001', '002', '003',\n # Correspond to the second assignment\n 'bilou-64', 'bilou-65',\n # Correspond to the third assignment\n 'ro-1337-bot', 'ro-1338-bot', 'ro-1339-bot', 'ro-1340-bot',\n ]\n self.assertEqual(len(move.move_line_ids), nbre_of_lines + len(generated_numbers))\n self.assertEqual(len(move.move_line_nosuggest_ids), len(generated_numbers))\n for move_line in move.move_line_nosuggest_ids:\n self.assertEqual(move_line.qty_done, 1)\n self.assertEqual(move_line.lot_name, generated_numbers.pop(0))\n for move_line in (move.move_line_ids - move.move_line_nosuggest_ids):\n self.assertEqual(move_line.qty_done, 0)\n self.assertEqual(move_line.lot_name, False)",
"def test_case_customer_part_orders(self):\n pass",
"def test_buyTicket_Valid_Paramaters():\n old_venue_balance = testVenue.wallet\n assert testUser3.buyTicket(testTicket3)\n assert testTicket3 in testUser3.inventory\n assert not testTicket3.for_sale\n assert testUser3.wallet == 950\n assert testVenue.wallet == old_venue_balance + testTicket3.list_price",
"def test_updating_the_supply_price(self):\n self.assertEqual(self.po.id, 1)\n self.assertEqual(self.po.items.count(), 1)\n item = self.po.items.all()[0]\n self.assertEqual(item.id, 1)\n self.assertEqual(item.unit_cost, Decimal('12.11'))\n self.assertEqual(Log.objects.all().count(), 0)\n \n modified_po = copy.deepcopy(base_purchase_order)\n modified_po['items'][0]['unit_cost'] = Decimal('10.05')\n modified_po['items'][0]['id'] = 1\n modified_po['status'] = 'PROCESSED'\n del modified_po['items'][1]\n resp = self.client.put('/api/v1/purchase-order/1/',\n format='json',\n data=modified_po)\n self.assertEqual(resp.status_code, 200, msg=resp)\n resp_obj = resp.data\n self.assertEqual(resp_obj['revision'], 1)\n #Check the new pdf\n #webbrowser.get(\"open -a /Applications/Google\\ Chrome.app %s\").open(resp_obj['pdf']['url'])\n \n self.assertEqual(resp_obj['id'], 1)\n self.assertEqual(resp_obj['supplier']['id'], 1)\n self.assertEqual(resp_obj['vat'], 7)\n self.assertEqual(resp_obj['discount'], 0)\n self.assertEqual(resp_obj['revision'], 1)\n self.assertEqual(Decimal(resp_obj['grand_total']), Decimal('107.54'))\n self.assertEqual(len(resp_obj['items']), 1)\n item1 = resp_obj['items'][0]\n self.assertEqual(item1['id'], 1)\n self.assertEqual(item1['quantity'], Decimal('10.0000000000'))\n self.assertEqual(Decimal(item1['unit_cost']), Decimal('10.05'))\n self.assertEqual(Decimal(item1['total']), Decimal('100.50'))\n \n #Confirm cost change for item and supply in the database\n po = PurchaseOrder.objects.get(pk=1)\n self.assertEqual(po.grand_total, Decimal('107.54'))\n item1 = po.items.order_by('id').all()[0]\n self.assertEqual(item1.id, 1)\n self.assertEqual(item1.quantity, 10)\n self.assertEqual(item1.unit_cost, Decimal('10.05'))\n supply = item1.supply\n supply.supplier = po.supplier\n self.assertEqual(supply.cost, Decimal('10.05'))\n \n self.assertEqual(Log.objects.all().count(), 1)\n log = Log.objects.all()[0]\n self.assertEqual(log.cost, Decimal('10.05'))\n self.assertEqual(log.supply, supply)\n self.assertEqual(log.supplier, po.supplier)\n self.assertEqual(log.message, \"Price change from 12.11USD to 10.05USD for Pattern: Maxx, Col: Blue [Supplier: Zipper World]\")\n\n # Confirm that there is still only one product for this supply and supplier\n # in the database\n products = Product.objects.filter(supply=supply, supplier=po.supplier)\n self.assertEqual(len(products), 1)",
"def test_bundle_not_have_variants(self):\n template = self.product_apple_bundle\n attribute_line_ids = template.attribute_line_ids\n self.assertTrue(template.is_pack, \"Product bundle is doesn't have variants\")\n self.assertEqual(len(attribute_line_ids), 0, 'Product: a product bundle should not have product variant')",
"def product_id_change(self, cr, uid, ids, pricelist, product, qty=0,\n uom=False, qty_uos=0, uos=False, name='', partner_id=False,\n lang=False, update_tax=True, date_order=False, packaging=False, fiscal_position=False, flag=False, context=None):\n if context is None:\n context = {}\n lang = lang or context.get('lang',False)\n if not partner_id:\n raise osv.except_osv(_('No Customer Defined !'), _('You have to select a customer in the sales form !\\nPlease set one customer before choosing a product.'))\n warning = {}\n product_uom_obj = self.pool.get('product.uom')\n partner_obj = self.pool.get('res.partner')\n product_obj = self.pool.get('product.product')\n context = dict(context, lang=lang, partner_id=partner_id)\n if partner_id:\n lang = partner_obj.browse(cr, uid, partner_id, context=context).lang\n context_partner = dict(context, lang=lang)\n\n if not product:\n return {'value': {'th_weight': 0, 'product_packaging': False,\n 'product_uos_qty': qty}, 'domain': {'product_uom': [],\n 'product_uos': []}}\n if not date_order:\n date_order = time.strftime(DEFAULT_SERVER_DATE_FORMAT)\n\n res = self.product_packaging_change(cr, uid, ids, pricelist, product, qty, uom, partner_id, packaging, context=context)\n result = res.get('value', {})\n warning_msgs = res.get('warning') and res['warning']['message'] or ''\n product_obj = product_obj.browse(cr, uid, product, context=context)\n\n uom2 = False\n if uom:\n uom2 = product_uom_obj.browse(cr, uid, uom, context=context)\n if product_obj.uom_id.category_id.id != uom2.category_id.id or context.get('force_product_uom'):\n uom = False\n uom2 = False\n if uos:\n if product_obj.uos_id:\n uos2 = product_uom_obj.browse(cr, uid, uos, context=context)\n if product_obj.uos_id.category_id.id != uos2.category_id.id:\n uos = False\n else:\n uos = False\n if product_obj.description_sale:\n result['notes'] = product_obj.description_sale\n fpos = fiscal_position and self.pool.get('account.fiscal.position').browse(cr, uid, fiscal_position, context=context) or False\n if update_tax: #The quantity only have changed\n result['delay'] = (product_obj.sale_delay or 0.0)\n result['tax_id'] = self.pool.get('account.fiscal.position').map_tax(cr, uid, fpos, product_obj.taxes_id)\n result.update({'type': product_obj.procure_method})\n\n if not flag:\n result['name'] = self.pool.get('product.product').name_get(cr, uid, [product_obj.id], context=context_partner)[0][1]\n domain = {}\n if (not uom) and (not uos):\n result['product_uom'] = product_obj.uom_id.id\n if product_obj.uos_id:\n result['product_uos'] = product_obj.uos_id.id\n result['product_uos_qty'] = qty * product_obj.uos_coeff\n uos_category_id = product_obj.uos_id.category_id.id\n else:\n result['product_uos'] = False\n result['product_uos_qty'] = qty\n uos_category_id = False\n result['th_weight'] = qty * product_obj.weight\n domain = {'product_uom':\n [('category_id', '=', product_obj.uom_id.category_id.id)],\n 'product_uos':\n [('category_id', '=', uos_category_id)]}\n\n elif uos and not uom: # only happens if uom is False\n result['product_uom'] = product_obj.uom_id and product_obj.uom_id.id\n result['product_uom_qty'] = qty_uos / product_obj.uos_coeff\n result['th_weight'] = result['product_uom_qty'] * product_obj.weight\n elif uom: # whether uos is set or not\n default_uom = product_obj.uom_id and product_obj.uom_id.id\n q = product_uom_obj._compute_qty(cr, uid, uom, qty, default_uom)\n if product_obj.uos_id:\n result['product_uos'] = product_obj.uos_id.id\n result['product_uos_qty'] = qty * product_obj.uos_coeff\n else:\n result['product_uos'] = False\n result['product_uos_qty'] = qty\n result['th_weight'] = q * product_obj.weight # Round the quantity up\n\n if not uom2:\n uom2 = product_obj.uom_id\n compare_qty = float_compare(product_obj.virtual_available * uom2.factor, qty * product_obj.uom_id.factor, precision_rounding=product_obj.uom_id.rounding)\n if (product_obj.type=='product') and int(compare_qty) == -1 \\\n and (product_obj.procure_method=='make_to_stock'):\n warn_msg = _('Planea vender %.2f %s pero sólo tiene %.2f %s disponible !\\n La existencia real es %.2f %s. (without reservations)') % \\\n (qty, uom2 and uom2.name or product_obj.uom_id.name,\n max(0,product_obj.virtual_available), product_obj.uom_id.name,\n max(0,product_obj.qty_available), product_obj.uom_id.name)\n warning_msgs += _(\"Not enough stock ! : \") + warn_msg + \"\\n\\n\"\n '''\n elif (product_obj.type=='product') and int(compare_qty) == +1 \\\n and (product_obj.procure_method=='make_to_order'):\n warn_msg = _('Planea producir %.2f %s pero usted tiene %.2f %s disponible !\\nDeberia considerar cambiar el metodo de abastecimiento a: (desde stock) en la pestaña Informacion Extra. \\nEl stock real es %.2f %s. (sin reservas)') % \\\n (qty, uom2 and uom2.name or product_obj.uom_id.name,\n max(0,product_obj.virtual_available), product_obj.uom_id.name,\n max(0,product_obj.qty_available), product_obj.uom_id.name)\n warning_msgs += _(\"Available stock ! : \") + warn_msg + \"\\n\\n\"\n '''\n # get unit price\n\n if not pricelist:\n warn_msg = _('You have to select a pricelist or a customer in the sales form !\\n'\n 'Please set one before choosing a product.')\n warning_msgs += _(\"No Pricelist ! : \") + warn_msg +\"\\n\\n\"\n else:\n price = self.pool.get('product.pricelist').price_get(cr, uid, [pricelist],\n product, qty or 1.0, partner_id, dict(context,\n uom=uom or result.get('product_uom'),\n date=date_order,\n ))[pricelist]\n if price is False:\n warn_msg = _(\"Couldn't find a pricelist line matching this product and quantity.\\n\"\n \"You have to change either the product, the quantity or the pricelist.\")\n\n warning_msgs += _(\"No valid pricelist line found ! :\") + warn_msg +\"\\n\\n\"\n else:\n result.update({'price_unit': price})\n if warning_msgs:\n warning = {\n 'title': _('Configuration Error !'),\n 'message' : warning_msgs\n }\n return {'value': result, 'domain': domain, 'warning': warning}",
"def test_fifo_without_nones(self):\n # Give each quant a package_id and in_date\n oldest_time = datetime.now() - timedelta(days=5)\n self.quant1.write({\"package_id\": self.pack1.id, \"in_date\": datetime.now()})\n self.quant2.write({\"package_id\": self.pack2.id, \"in_date\": oldest_time})\n self.quant3.write({\"package_id\": self.pack3.id, \"in_date\": oldest_time})\n\n # Reserve quantity - one apple\n reserved_quants = self.Quant._update_reserved_quantity(\n self.apple, self.test_stock_location_01, 1\n )\n reserved_quant = reserved_quants[0][0]\n\n # Should choose between quant2 and quant3 based on `in_date`.\n # Choose quant2 as it has a smaller package id.\n self.assertEqual(reserved_quant.in_date, oldest_time)\n self.assertEqual(reserved_quant.package_id, self.pack2)\n self.assertEqual(reserved_quant, self.quant2)",
"def lot_assigned(self,cr,uid,ids,context=None):\n vals={}\n if context is None:\n context = {}\n trans_brw = self.browse(cr,uid,ids,context=context)\n so_l_obj = self.pool.get('sale.order.line')\n so_obj = self.pool.get('sale.order')\n product_obj = self.pool.get('product.uom')\n lot_obj = self.pool.get('stock.production.lot')\n so_line = []\n if context['active_ids']:\n so_brw = so_obj.browse(cr,uid,context['active_ids'][0],context=context)\n for i in trans_brw:\n for line in i.sale_order_line_id:\n lot_brw = lot_obj.browse(cr,uid,line.lot_id.id,context=context)\n res = so_l_obj.product_id_change( cr, uid, ids, so_brw.pricelist_id.id, lot_brw.product_id.id, qty=line.quantity1,\n uom=False, qty_uos=0, uos=False, name='', partner_id=so_brw.partner_id.id,\n lang=False, update_tax=True, date_order=False, packaging=False, fiscal_position=False, flag=False)\n \n so_line.append((0,0,{'product_id':lot_brw.product_id and lot_brw.product_id.id,\n 'prod_lot_id':lot_brw and lot_brw.id,\n 'pieces':line.pieces_qty,\n 'product_uom_qty':line.quantity1,\n 'product_uom':lot_brw.product_id.uom_id and lot_brw.product_id.uom_id.id,\n 'name':lot_brw.product_id and lot_brw.product_id.name,\n 'price_unit':res.values()[2]['price_unit'],\n 'delay':res.values()[2]['delay'],\n 'type':res.values()[2]['type'],\n }))\n so_obj.write(cr,uid,context['active_ids'],{'order_line':so_line},context=context)",
"def handle_quantity(self, line):\n #ok\n\n if line in [\"#c\", \"#C\"]:\n self.cancel_operation()\n return\n try:\n if line:\n new_qty = self.op_data['qty']\n #aqui tengo que escribir la nueva cantidad\n\n self.state = \"scan_location\"\n message = u\"Scan correcto. Scanee la ubicacion\\n\"\n message += self.get_operation_str(mode='scan_location')\n\n except Exception, e:\n str_error = u\"Error al cambiar la cantidad %s\\n\" % line\n self._snd(str_error + e.message)",
"def test_creating_item_with_no_product_with_unit_cost(self):\n context = {'po': self.po,\n 'supplier': self.supplier}\n data = {'supply': {'id': self.supply.id},\n 'unit_cost': 10,\n 'quantity': 5,\n 'units': 'yd'}\n \n item_serializer = ItemSerializer(context=context, data=data)\n if item_serializer.is_valid(raise_exception=True):\n item_serializer.save()\n \n # Verify product is created\n self.assertEqual(Product.objects.filter(supply=self.supply, supplier=self.supplier).count(), 1)\n \n # Verify item\n resp_data = item_serializer.data\n \n self.assertEqual(resp_data['description'], 'Pattern: Maxx, Col: Blue')\n self.assertEqual(resp_data['units'], 'yd')\n self.assertEqual(Decimal(resp_data['quantity']), Decimal('5'))\n self.assertEqual(Decimal(resp_data['total']), Decimal('50'))",
"def test_adding_a_new_item_with_no_supply(self): \n print '\\n'\n logger.debug('Add a new item to a current PO via PUT')\n print '\\n'\n \n #Verifying po in database\n self.assertEqual(self.po.id, 1)\n self.assertEqual(self.po.items.count(), 1)\n self.assertEqual(self.po.grand_total, Decimal('129.58'))\n self.assertEqual(timezone('Asia/Bangkok').normalize(self.po.order_date).date(), datetime.datetime.now().date())\n item = self.po.items.all()[0]\n self.assertEqual(item.id, 1)\n self.assertEqual(item.quantity, 10)\n self.assertEqual(item.total, Decimal('121.1'))\n \n modified_po_data = copy.deepcopy(base_purchase_order)\n modified_po_data['items'][1]['unit_cost'] = Decimal('11.99')\n modified_po_data['items'][1]['comments'] = 'test change'\n modified_po_data['items'][1]['description'] = \"test description change\"\n del modified_po_data['items'][1]['supply']\n resp = self.client.put('/api/v1/purchase-order/1/',\n format='json',\n data=modified_po_data)\n \n #Verify the response\n self.assertEqual(resp.status_code, 200, msg=resp)\n po = resp.data\n self.assertEqual(po['id'], 1)\n self.assertEqual(po['supplier']['id'], 1)\n self.assertEqual(po['vat'], 7)\n #self.assertEqual(Decimal(po['grand_total']), Decimal('74.85'))\n self.assertEqual(po['discount'], 0)\n self.assertEqual(po['revision'], 1)\n self.assertEqual(len(po['items']), 2)\n #self.assertEqual(po['status'], 'PAID')\n #Check the new pdf\n #webbrowser.get(\"open -a /Applications/Google\\ Chrome.app %s\").open(po['pdf']['url'])\n \n item1 = po['items'][0]\n logger.debug(item1)\n self.assertEqual(item1['id'], 2)\n self.assertEqual(item1['quantity'], Decimal('10.0000000000'))\n self.assertEqual(item1['description'], u'Pattern: Maxx, Col: Blue')\n self.assertEqual(Decimal(item1['unit_cost']), Decimal('12.1100'))\n self.assertEqual(Decimal(item1['total']), Decimal('121.10'))\n\n item2 = po['items'][1]\n logger.debug(item2)\n self.assertEqual(item2['id'], 3)\n self.assertEqual(item2['quantity'], Decimal('3.0000000000'))\n self.assertEqual(item2['comments'], 'test change')\n self.assertEqual(item2['description'], 'test description change')\n self.assertEqual(Decimal(item2['unit_cost']), Decimal('11.99'))\n self.assertEqual(Decimal(item2['total']), Decimal('35.97'))\n \n #Verify database record\n po = PurchaseOrder.objects.get(pk=1)\n \n self.assertEqual(po.supplier.id, 1)\n #self.assertEqual(timezone('Asia/Bangkok').normalize(po.order_date), datetime.datetime.now().date())\n self.assertEqual(po.vat, 7)\n self.assertEqual(po.grand_total, Decimal('168.06'))\n self.assertEqual(po.items.count(), 2)\n \n # Check new item in the database\n item2_d = po.items.all().order_by('id')[1]\n self.assertEqual(item2_d.id, 3)\n self.assertEqual(item2_d.description, 'test description change')\n self.assertEqual(item2_d.comments, 'test change')\n self.assertEqual(item2_d.quantity, 3)\n self.assertEqual(item2_d.unit_cost, Decimal('11.99'))\n self.assertEqual(item2_d.total, Decimal('35.97'))\n\n # Check new supply product in the database\n products = SupplyProduct.objects.filter(supply=item2_d.supply, supplier=self.po.supplier)\n self.assertEqual(products.count(), 1)\n product = products.all()[0]\n self.assertEqual(product.supply.id, item2_d.supply.id)\n self.assertEqual(product.supplier.id, self.po.supplier.id)\n self.assertEqual(product.cost, Decimal('11.99'))",
"def test_fifo_with_nones(self):\n # Leave quant1, quant 2 with `in_date: False`\n # Leave quant 2 with no package, set quant1 and quant2 packages.\n self.quant1.write({\"package_id\": self.pack1.id})\n self.quant3.write({\"package_id\": self.pack3.id, \"in_date\": datetime.now()})\n\n # Reserve quantity - one apple\n reserved_quants = self.Quant._update_reserved_quantity(\n self.apple, self.test_stock_location_01, 1\n )\n reserved_quant = reserved_quants[0][0]\n\n self.assertFalse(reserved_quant.in_date)\n self.assertFalse(reserved_quant.package_id)\n self.assertEqual(reserved_quant, self.quant2)",
"def do_partial(self, cr, uid, ids, partial_datas, context=None):\n if context is None:\n context = {}\n else:\n context = dict(context)\n res = {}\n move_obj = self.pool.get('stock.move')\n product_obj = self.pool.get('product.product')\n currency_obj = self.pool.get('res.currency')\n uom_obj = self.pool.get('product.uom')\n sequence_obj = self.pool.get('ir.sequence')\n wf_service = netsvc.LocalService(\"workflow\")\n for pick in self.browse(cr, uid, ids, context=context):\n new_picking = None\n complete, too_many, too_few = [], [], []\n move_product_qty, prodlot_ids, product_avail, partial_qty, product_uoms = {}, {}, {}, {}, {}\n for move in pick.move_lines:\n if move.state in ('done', 'cancel'):\n continue\n partial_data = partial_datas.get('move%s'%(move.id), {})\n product_qty = partial_data.get('product_qty',0.0)\n move_product_qty[move.id] = product_qty\n product_uom = partial_data.get('product_uom',False)\n product_price = partial_data.get('product_price',0.0)\n product_currency = partial_data.get('product_currency',False)\n prodlot_id = partial_data.get('prodlot_id')\n prodlot_ids[move.id] = prodlot_id\n product_uoms[move.id] = product_uom\n partial_qty[move.id] = uom_obj._compute_qty(cr, uid, product_uoms[move.id], product_qty, move.product_uom.id)\n location_obj = self.pool.get('stock.location')\n if move.product_qty == partial_qty[move.id]:\n complete.append(move)\n elif move.product_qty > partial_qty[move.id]:\n too_few.append(move)\n else:\n too_many.append(move)\n\n # <<<< change begin <<<<<<<<<<\n # get the qty of available Alex\n product_qty_available = location_obj.get_product_qty_of_checked_locations(\n cr, uid, [],\n move.product_id.id, domain=[], context=context, states=['done']).get(\n move.product_id.id, 0.0)\n # <<<< change ends <<<<<<<<<<<<\n\n # Average price computation\n if (pick.type == 'in') and (move.product_id.cost_method == 'average'):\n product = product_obj.browse(cr, uid, move.product_id.id)\n move_currency_id = move.company_id.currency_id.id\n context['currency_id'] = move_currency_id\n qty = uom_obj._compute_qty(cr, uid, product_uom, product_qty, product.uom_id.id)\n\n if product.id in product_avail:\n product_avail[product.id] += qty\n else:\n # <<< changes begin. we change the way\n # of geting available products. Alex\n product_avail[product.id] = product_qty_available\n\n if qty > 0:\n new_price = currency_obj.compute(cr, uid, product_currency,\n move_currency_id, product_price)\n new_price = uom_obj._compute_price(cr, uid, product_uom, new_price,\n product.uom_id.id)\n if product_qty_available <= 0:\n new_std_price = new_price\n else:\n # Get the standard price\n amount_unit = product.price_get('standard_price', context=context)[product.id]\n new_std_price = ((amount_unit * product_avail[product.id])\\\n + (new_price * qty))/(product_avail[product.id] + qty)\n # Write the field according to price type field\n product_obj.write(cr, uid, [product.id], {'standard_price': new_std_price})\n\n # Record the values that were chosen in the wizard, so they can be\n # used for inventory valuation if real-time valuation is enabled.\n move_obj.write(cr, uid, [move.id],\n {'price_unit': product_price,\n 'price_currency_id': product_currency})\n\n\n for move in too_few:\n product_qty = move_product_qty[move.id]\n if not new_picking:\n new_picking_name = pick.name\n self.write(cr, uid, [pick.id], \n {'name': sequence_obj.get(cr, uid,\n 'stock.picking.%s'%(pick.type)),\n })\n new_picking = self.copy(cr, uid, pick.id,\n {\n 'name': new_picking_name,\n 'move_lines' : [],\n 'state':'draft',\n })\n if product_qty != 0:\n defaults = {\n 'product_qty' : product_qty,\n 'product_uos_qty': product_qty, #TODO: put correct uos_qty\n 'picking_id' : new_picking,\n 'state': 'assigned',\n 'move_dest_id': False,\n 'price_unit': move.price_unit,\n 'product_uom': product_uoms[move.id]\n }\n prodlot_id = prodlot_ids[move.id]\n if prodlot_id:\n defaults.update(prodlot_id=prodlot_id)\n move_obj.copy(cr, uid, move.id, defaults)\n move_obj.write(cr, uid, [move.id],\n {\n 'product_qty': move.product_qty - partial_qty[move.id],\n 'product_uos_qty': move.product_qty - partial_qty[move.id], #TODO: put correct uos_qty\n 'prodlot_id': False,\n 'tracking_id': False,\n })\n\n if new_picking:\n move_obj.write(cr, uid, [c.id for c in complete], {'picking_id': new_picking})\n for move in complete:\n defaults = {'product_uom': product_uoms[move.id], 'product_qty': move_product_qty[move.id]}\n if prodlot_ids.get(move.id):\n defaults.update({'prodlot_id': prodlot_ids[move.id]})\n move_obj.write(cr, uid, [move.id], defaults)\n for move in too_many:\n product_qty = move_product_qty[move.id]\n defaults = {\n 'product_qty' : product_qty,\n 'product_uos_qty': product_qty, #TODO: put correct uos_qty\n 'product_uom': product_uoms[move.id]\n }\n prodlot_id = prodlot_ids.get(move.id)\n if prodlot_ids.get(move.id):\n defaults.update(prodlot_id=prodlot_id)\n if new_picking:\n defaults.update(picking_id=new_picking)\n move_obj.write(cr, uid, [move.id], defaults)\n\n # At first we confirm the new picking (if necessary)\n if new_picking:\n wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_confirm', cr)\n # Then we finish the good picking\n self.write(cr, uid, [pick.id], {'backorder_id': new_picking})\n self.action_move(cr, uid, [new_picking], context=context)\n wf_service.trg_validate(uid, 'stock.picking', new_picking, 'button_done', cr)\n wf_service.trg_write(uid, 'stock.picking', pick.id, cr)\n delivered_pack_id = new_picking\n back_order_name = self.browse(cr, uid, delivered_pack_id, context=context).name\n self.message_post(cr, uid, ids, body=_(\"Back order <em>%s</em> has been <b>created</b>.\") % (back_order_name), context=context)\n else:\n self.action_move(cr, uid, [pick.id], context=context)\n wf_service.trg_validate(uid, 'stock.picking', pick.id, 'button_done', cr)\n delivered_pack_id = pick.id\n\n delivered_pack = self.browse(cr, uid, delivered_pack_id, context=context)\n res[pick.id] = {'delivered_picking': delivered_pack.id or False}\n\n return res",
"def test_creating_item_with_product_with_no_unit_cost(self):\n Product.objects.create(supply=self.supply, supplier=self.supplier, cost=Decimal('12.11'), \n purchasing_units=\"yd\")\n \n context = {'po': self.po,\n 'supplier': self.supplier}\n data = {'supply': {'id': self.supply.id},\n 'quantity': 5,\n 'units': 'yd'}\n \n item_serializer = ItemSerializer(context=context, data=data)\n if item_serializer.is_valid(raise_exception=True):\n item_serializer.save()\n \n # Verify product is created\n self.assertEqual(Product.objects.filter(supply=self.supply, supplier=self.supplier).count(), 1)\n \n # Verify item\n resp_data = item_serializer.data\n \n self.assertEqual(resp_data['description'], 'Pattern: Maxx, Col: Blue')\n self.assertEqual(resp_data['units'], 'yd')\n self.assertEqual(Decimal(resp_data['quantity']), Decimal('5'))\n self.assertEqual(Decimal(resp_data['total']), Decimal('60.55'))",
"def _check_sn_uniqueness(self):\n if self.product_tracking == 'serial' and self.lot_producing_id:\n sml = self.env['stock.move.line'].search_count([\n ('lot_id', '=', self.lot_producing_id.id),\n ('location_id.usage', '=', 'production'),\n ('qty_done', '=', 1),\n ('state', '=', 'done')\n ])\n if sml:\n raise UserError(_('This serial number for product %s has already been produced', self.product_id.name))\n\n for move in self.move_finished_ids:\n if move.has_tracking != 'serial' or move.product_id == self.product_id:\n continue\n for move_line in move.move_line_ids:\n domain = [\n ('lot_id', '=', move_line.lot_id.id),\n ('qty_done', '=', 1),\n ('state', '=', 'done')\n ]\n message = _('The serial number %(number)s used for byproduct %(product_name)s has already been produced',\n number=move_line.lot_id.name,\n product_name=move_line.product_id.name)\n co_prod_move_lines = self.move_finished_ids.move_line_ids.filtered(lambda ml: ml.product_id != self.product_id)\n domain_unbuild = domain + [\n ('production_id', '=', False),\n ('location_dest_id.usage', '=', 'production')\n ]\n\n # Check presence of same sn in previous productions\n duplicates = self.env['stock.move.line'].search_count(domain + [\n ('location_id.usage', '=', 'production')\n ])\n if duplicates:\n # Maybe some move lines have been compensated by unbuild\n duplicates_unbuild = self.env['stock.move.line'].search_count(domain_unbuild + [\n ('move_id.unbuild_id', '!=', False)\n ])\n if not (duplicates_unbuild and duplicates - duplicates_unbuild == 0):\n raise UserError(message)\n # Check presence of same sn in current production\n duplicates = co_prod_move_lines.filtered(lambda ml: ml.qty_done and ml.lot_id == move_line.lot_id) - move_line\n if duplicates:\n raise UserError(message)\n\n for move in self.move_raw_ids:\n if move.has_tracking != 'serial':\n continue\n for move_line in move.move_line_ids:\n if float_is_zero(move_line.qty_done, precision_rounding=move_line.product_uom_id.rounding):\n continue\n domain = [\n ('lot_id', '=', move_line.lot_id.id),\n ('qty_done', '=', 1),\n ('state', '=', 'done')\n ]\n message = _('The serial number %(number)s used for component %(component)s has already been consumed',\n number=move_line.lot_id.name,\n component=move_line.product_id.name)\n co_prod_move_lines = self.move_raw_ids.move_line_ids\n domain_unbuild = domain + [\n ('production_id', '=', False),\n ('location_id.usage', '=', 'production')\n ]\n\n # Check presence of same sn in previous productions\n duplicates = self.env['stock.move.line'].search_count(domain + [\n ('location_dest_id.usage', '=', 'production')\n ])\n if duplicates:\n # Maybe some move lines have been compensated by unbuild\n duplicates_unbuild = self.env['stock.move.line'].search_count(domain_unbuild + [\n ('move_id.unbuild_id', '!=', False)\n ])\n if not (duplicates_unbuild and duplicates - duplicates_unbuild == 0):\n raise UserError(message)\n # Check presence of same sn in current production\n duplicates = co_prod_move_lines.filtered(lambda ml: ml.qty_done and ml.lot_id == move_line.lot_id) - move_line\n if duplicates:\n raise UserError(message)",
"def test_initial_risk_position_sizer_without_cap(self):\n fraction_at_risk = 0.23\n signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk)\n orders = self.initial_risk_position_sizer.size_signals([signal])\n\n self.assertEqual(len(orders), 2) # market order and stop order\n portfolio_value = self.initial_position / self.initial_allocation\n target_quantity = int(np.floor(portfolio_value * self.initial_risk / fraction_at_risk))\n additional_contracts = target_quantity - self.initial_position\n self.assertEqual(orders[0], Order(self.contract, additional_contracts, MarketOrder(), TimeInForce.OPG))\n\n stop_price = self.last_price * (1 - fraction_at_risk)\n stop_quantity = -(self.initial_position + additional_contracts)\n self.assertEqual(orders[1], Order(self.contract, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))",
"def test_initial_risk_position_sizer_without_cap(self):\n fraction_at_risk = 0.23\n signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk, self.last_price, self.timer.now())\n orders = self.initial_risk_position_sizer.size_signals([signal])\n\n self.assertEqual(len(orders), 2) # market order and stop order\n portfolio_value = self.initial_position / self.initial_allocation\n target_quantity = float(np.floor(portfolio_value * self.initial_risk / fraction_at_risk))\n additional_contracts = target_quantity - self.initial_position\n self.assertEqual(orders[0], Order(self.ticker, additional_contracts, MarketOrder(), TimeInForce.OPG))\n\n stop_price = self.last_price * (1 - fraction_at_risk)\n stop_quantity = -(self.initial_position + additional_contracts)\n self.assertEqual(orders[1], Order(self.ticker, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))",
"def stock_move_action_done(self):\n\t\tself.filtered(lambda move: move.state == 'draft').action_confirm()\n\n\t\tUom = self.env['product.uom']\n\t\tQuant = self.env['stock.quant']\n\n\t\tpickings = self.env['stock.picking']\n\t\tprocurements = self.env['procurement.order']\n\t\toperations = self.env['stock.pack.operation']\n\n\t\tremaining_move_qty = {}\n\n\t\tfor move in self:\n\t\t\tif move.picking_id:\n\t\t\t\tpickings |= move.picking_id\n\t\t\tremaining_move_qty[move.id] = move.product_qty\n\t\t\tfor link in move.linked_move_operation_ids:\n\t\t\t\toperations |= link.operation_id\n\t\t\t\tpickings |= link.operation_id.picking_id\n\n\t\t# Sort operations according to entire packages first, then package + lot, package only, lot only\n\t\toperations = operations.sorted(\n\t\t\tkey=lambda x: ((x.package_id and not x.product_id) and -4 or 0) + (x.package_id and -2 or 0) + (\n\t\t\tx.pack_lot_ids and -1 or 0))\n\n\t\tfor operation in operations:\n\n\t\t\t# product given: result put immediately in the result package (if False: without package)\n\t\t\t# but if pack moved entirely, quants should not be written anything for the destination package\n\t\t\tquant_dest_package_id = operation.product_id and operation.result_package_id.id or False\n\t\t\tentire_pack = not operation.product_id and True or False\n\n\t\t\t# compute quantities for each lot + check quantities match\n\t\t\tlot_quantities = dict((pack_lot.lot_id.id, operation.product_uom_id._compute_quantity(pack_lot.qty,\n\t\t\t operation.product_id.uom_id)\n\t\t\t ) for pack_lot in operation.pack_lot_ids)\n\n\t\t\tqty = operation.product_qty\n\t\t\tif operation.product_uom_id and operation.product_uom_id != operation.product_id.uom_id:\n\t\t\t\tqty = operation.product_uom_id._compute_quantity(qty, operation.product_id.uom_id)\n\t\t\tif operation.pack_lot_ids and float_compare(sum(lot_quantities.values()), qty,\n\t\t\t precision_rounding=operation.product_id.uom_id.rounding) != 0.0:\n\t\t\t\traise UserError(_(\n\t\t\t\t\t'You have a difference between the quantity on the operation and the quantities specified for the lots. '))\n\n\t\t\tquants_taken = []\n\t\t\tfalse_quants = []\n\t\t\tlot_move_qty = {}\n\n\t\t\tprout_move_qty = {}\n\t\t\tfor link in operation.linked_move_operation_ids:\n\t\t\t\tprout_move_qty[link.move_id] = prout_move_qty.get(link.move_id, 0.0) + link.qty\n\n\t\t\t# Process every move only once for every pack operation\n\t\t\tfor move in prout_move_qty.keys():\n\t\t\t\t# TDE FIXME: do in batch ?\n\t\t\t\tmove.check_tracking(operation)\n\n\t\t\t\t# TDE FIXME: I bet the message error is wrong\n\t\t\t\t# if not remaining_move_qty.get(move.id):\n\t\t\t\t# \traise UserError(_(\n\t\t\t\t# \t\t\"The roundings of your unit of measure %s on the move vs. %s on the product don't allow to do these operations or you are not transferring the picking at once. \") % (\n\t\t\t\t# \t move.product_uom.name, move.product_id.uom_id.name))\n\n\t\t\t\tif not operation.pack_lot_ids:\n\t\t\t\t\tpreferred_domain_list = [[('reservation_id', '=', move.id)], [('reservation_id', '=', False)],\n\t\t\t\t\t ['&', ('reservation_id', '!=', move.id),\n\t\t\t\t\t ('reservation_id', '!=', False)]]\n\t\t\t\t\tquants = Quant.quants_get_preferred_domain(\n\t\t\t\t\t\tprout_move_qty[move], move, ops=operation, domain=[('qty', '>', 0)],\n\t\t\t\t\t\tpreferred_domain_list=preferred_domain_list)\n\t\t\t\t\tQuant.quants_move(quants, move, operation.location_dest_id, location_from=operation.location_id,\n\t\t\t\t\t lot_id=False, owner_id=operation.owner_id.id,\n\t\t\t\t\t src_package_id=operation.package_id.id,\n\t\t\t\t\t dest_package_id=quant_dest_package_id, entire_pack=entire_pack)\n\t\t\t\telse:\n\t\t\t\t\t# Check what you can do with reserved quants already\n\t\t\t\t\tqty_on_link = prout_move_qty[move]\n\t\t\t\t\trounding = operation.product_id.uom_id.rounding\n\t\t\t\t\tfor reserved_quant in move.reserved_quant_ids:\n\t\t\t\t\t\tif (reserved_quant.owner_id.id != operation.owner_id.id) or (\n\t\t\t\t\t\t\treserved_quant.location_id.id != operation.location_id.id) or \\\n\t\t\t\t\t\t\t\t(reserved_quant.package_id.id != operation.package_id.id):\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\tif not reserved_quant.lot_id:\n\t\t\t\t\t\t\tfalse_quants += [reserved_quant]\n\t\t\t\t\t\telif float_compare(lot_quantities.get(reserved_quant.lot_id.id, 0), 0,\n\t\t\t\t\t\t precision_rounding=rounding) > 0:\n\t\t\t\t\t\t\tif float_compare(lot_quantities[reserved_quant.lot_id.id], reserved_quant.qty,\n\t\t\t\t\t\t\t precision_rounding=rounding) >= 0:\n\t\t\t\t\t\t\t\tlot_quantities[reserved_quant.lot_id.id] -= reserved_quant.qty\n\t\t\t\t\t\t\t\tquants_taken += [(reserved_quant, reserved_quant.qty)]\n\t\t\t\t\t\t\t\tqty_on_link -= reserved_quant.qty\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tquants_taken += [(reserved_quant, lot_quantities[reserved_quant.lot_id.id])]\n\t\t\t\t\t\t\t\tlot_quantities[reserved_quant.lot_id.id] = 0\n\t\t\t\t\t\t\t\tqty_on_link -= lot_quantities[reserved_quant.lot_id.id]\n\t\t\t\t\tlot_move_qty[move.id] = qty_on_link\n\n\t\t\t\tremaining_move_qty[move.id] -= prout_move_qty[move]\n\n\t\t\t# Handle lots separately\n\t\t\tif operation.pack_lot_ids:\n\t\t\t\t# TDE FIXME: fix call to move_quants_by_lot to ease understanding\n\t\t\t\tself._move_quants_by_lot(operation, lot_quantities, quants_taken, false_quants, lot_move_qty,\n\t\t\t\t quant_dest_package_id)\n\n\t\t\t# Handle pack in pack\n\t\t\tif not operation.product_id and operation.package_id and operation.result_package_id.id != operation.package_id.parent_id.id:\n\t\t\t\toperation.package_id.sudo().write({'parent_id': operation.result_package_id.id})\n\n\t\t# Check for remaining qtys and unreserve/check move_dest_id in\n\t\tmove_dest_ids = set()\n\t\tfor move in self:\n\t\t\tif float_compare(remaining_move_qty[move.id], 0,\n\t\t\t precision_rounding=move.product_id.uom_id.rounding) > 0: # In case no pack operations in picking\n\t\t\t\tmove.check_tracking(False) # TDE: do in batch ? redone ? check this\n\n\t\t\t\tpreferred_domain_list = [[('reservation_id', '=', move.id)], [('reservation_id', '=', False)],\n\t\t\t\t ['&', ('reservation_id', '!=', move.id), ('reservation_id', '!=', False)]]\n\t\t\t\tquants = Quant.quants_get_preferred_domain(\n\t\t\t\t\tremaining_move_qty[move.id], move, domain=[('qty', '>', 0)],\n\t\t\t\t\tpreferred_domain_list=preferred_domain_list)\n\t\t\t\tQuant.quants_move(\n\t\t\t\t\tquants, move, move.location_dest_id,\n\t\t\t\t\tlot_id=move.restrict_lot_id.id, owner_id=move.restrict_partner_id.id)\n\n\t\t\t# If the move has a destination, add it to the list to reserve\n\t\t\tif move.move_dest_id and move.move_dest_id.state in ('waiting', 'confirmed'):\n\t\t\t\tmove_dest_ids.add(move.move_dest_id.id)\n\n\t\t\tif move.procurement_id:\n\t\t\t\tprocurements |= move.procurement_id\n\n\t\t\t# unreserve the quants and make them available for other operations/moves\n\t\t\tmove.quants_unreserve()\n\n\t\t# Check the packages have been placed in the correct locations\n\t\tself.mapped('quant_ids').filtered(lambda quant: quant.package_id and quant.qty > 0).mapped(\n\t\t\t'package_id')._check_location_constraint()\n\n\t\t# set the move as done\n\t\tself.write({'state': 'done', 'date': time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)})\n\t\tprocurements.check()\n\t\t# assign destination moves\n\t\tif move_dest_ids:\n\t\t\t# TDE FIXME: record setise me\n\t\t\tself.browse(list(move_dest_ids)).action_assign_stock_move()\n\n\t\tpickings.filtered(lambda picking: picking.state == 'done' and not picking.date_done).write(\n\t\t\t{'date_done': time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)})\n\n\t\treturn True",
"def test_patch_nveto_pmt_item(self):\n pass",
"def test_case_2(self):\n\n orders_data = generate_orders_data([50, 50])\n assigned_delivery_vehicles = SlotDelivery.assign_new_batch_order_delivery(\n slot_number=1, orders=orders_data)\n\n scooter = VehicleType.objects.get(name='scooter')\n self.assertEqual(len(assigned_delivery_vehicles), 2) # 2 vehicles\n self.assertEqual(\n sum(dv.vehicle_type == scooter for dv in assigned_delivery_vehicles), 2\n ) # 2 scooters",
"def test_single_quant(self):\n pick = self.quant_1.create_picking(self.picking_type_pick)\n # Confirm made in state draft\n self.assertEqual(pick.state, \"draft\")\n # Confirm quant location used if non specified\n self.assertEqual(pick.location_id, self.test_stock_location_01)\n # Confirm default dest location used if non specified\n self.assertEqual(pick.location_dest_id, self.picking_type_pick.default_location_dest_id)\n # Confirm correct picking type id associated\n self.assertEqual(pick.picking_type_id, self.picking_type_pick)\n # Check default priority is 0 = 'Normal'\n self.assertEqual(pick.priority, \"0\")\n # Check picking has correct products associated to it\n self.assertEqual(pick.product_id, self.apple)\n # Check picking has correct quantities associated to it\n self.assertEqual(pick.move_lines.product_id, self.apple)\n self.assertEqual(pick.move_lines.product_qty, 10)",
"def test_pallet_finish(self) -> None:\n # set some arbitrary values\n pallet_name = 'Hopefully this never matches !@#$%^&*()_+'\n location_code = '0409C2'\n box_type_code = 'Evans'\n starting_box_number = 98765\n number_of_boxes = 40\n ending_box_number = starting_box_number + number_of_boxes\n product_choices = 'Corn', 'Green Beans'\n exp_year_choices = (now().year + 1), (now().year + 2)\n\n # get corresponding records\n box_type_rec = BoxType.objects.get(box_type_code=box_type_code)\n product1 = Product.objects.get(prod_name=product_choices[0])\n product2 = Product.objects.get(prod_name=product_choices[1])\n product_rec_choices = product1, product2\n\n bm = BoxManagementClass()\n\n # build the pallet\n location_rec = Location.objects.get(loc_code=location_code)\n pallet_rec = Pallet.objects.create(\n name=pallet_name,\n location=location_rec,\n pallet_status=Pallet.FILL,\n )\n pallet_rec_id = pallet_rec.id\n\n # build table of values for later comparison\n pallet_box_info = dict()\n for ndx, box_number in enumerate(\n range(starting_box_number, ending_box_number)):\n ind = ndx % 2\n box_name = BoxNumber.format_box_number(box_number)\n product = product_rec_choices[ind]\n exp_year = exp_year_choices[ind]\n box_rec = bm.box_new(box_number=box_name, box_type=box_type_rec)\n pallet_box_rec = PalletBox.objects.create(\n pallet=pallet_rec,\n box_number=box_name,\n box=box_rec,\n product=product,\n exp_year=exp_year,\n box_status=PalletBox.NEW\n )\n pallet_box_info[box_number] = PalletBoxInfo(\n pallet_box_id=pallet_box_rec.id, box_id=box_rec.id,\n box_number=box_name, product=product, exp_year=exp_year)\n\n # finish (publish) the pallet\n bm.pallet_finish(pallet_rec)\n\n # validate that worked properly\n for entry in pallet_box_info:\n with raises(PalletBox.DoesNotExist):\n _ = PalletBox.objects.get(\n pk=pallet_box_info[entry].pallet_box_id\n )\n box_rec = Box.objects.get(pk=pallet_box_info[entry].box_id)\n assert box_rec.box_number == pallet_box_info[entry].box_number\n assert box_rec.box_type == box_type_rec\n assert box_rec.location == location_rec\n assert box_rec.product == pallet_box_info[entry].product\n assert box_rec.exp_year == pallet_box_info[entry].exp_year\n assert box_rec.exp_month_start == 0\n assert box_rec.exp_month_end == 0\n filled_seconds_ago = (now() - box_rec.date_filled).total_seconds()\n assert filled_seconds_ago < 10\n assert box_rec.quantity == box_type_rec.box_type_qty\n\n with raises(Pallet.DoesNotExist):\n _ = Pallet.objects.get(pk=pallet_rec_id)\n return",
"def xtest_adding_a_new_item_with_no_supply(self): \n print '\\n'\n logger.debug('Add a new item to a current PO via PUT')\n print '\\n'\n \n #Verifying po in database\n self.assertEqual(self.po.id, 1)\n self.assertEqual(self.po.items.count(), 1)\n self.assertEqual(self.po.grand_total, Decimal('129.58'))\n self.assertEqual(timezone('Asia/Bangkok').normalize(self.po.order_date).date(), datetime.datetime.now().date())\n item = self.po.items.all()[0]\n self.assertEqual(item.id, 1)\n self.assertEqual(item.quantity, 10)\n self.assertEqual(item.total, Decimal('121.1'))\n \n modified_po_data = copy.deepcopy(base_purchase_order)\n modified_po_data['items'][1]['unit_cost'] = Decimal('11.99')\n modified_po_data['items'][1]['comments'] = 'test change'\n modified_po_data['items'][1]['description'] = \"test description change\"\n modified_po_data['status'] = 'PROCESSED'\n\n logger.debug(modified_po_data)\n\n resp = self.client.put('/api/v1/purchase-order/1/',\n format='json',\n data=modified_po_data)\n \n #Verify the response\n self.assertEqual(resp.status_code, 200, msg=resp)\n po = resp.data\n self.assertEqual(po['id'], 1)\n self.assertEqual(po['supplier']['id'], 1)\n self.assertEqual(po['vat'], 7)\n #self.assertEqual(Decimal(po['grand_total']), Decimal('74.85'))\n self.assertEqual(po['discount'], 0)\n self.assertEqual(po['revision'], 1)\n self.assertEqual(len(po['items']), 2)\n #self.assertEqual(po['status'], 'PAID')\n #Check the new pdf\n #webtbrowser.get(\"open -a /Applications/Google\\ Chrome.app %s\").open(po['pdf']['url'])\n \n item1 = po['items'][0]\n logger.debug(item1)\n self.assertEqual(item1['id'], 2)\n self.assertEqual(item1['quantity'], '10.0000000000')\n self.assertEqual(item1['description'], u'Pattern: Maxx, Col: Blue')\n self.assertEqual(Decimal(item1['unit_cost']), Decimal('12.1100'))\n self.assertEqual(Decimal(item1['total']), Decimal('121.10'))\n\n item2 = po['items'][1]\n logger.debug(item2)\n self.assertEqual(item2['id'], 3)\n self.assertEqual(item2['quantity'], '3.0000000000')\n self.assertEqual(item2['comments'], 'test change')\n self.assertEqual(item2['description'], 'test description change')\n self.assertEqual(Decimal(item2['unit_cost']), Decimal('11.99'))\n self.assertEqual(Decimal(item2['total']), Decimal('35.97'))\n \n #Verify database record\n po = PurchaseOrder.objects.get(pk=1)\n \n self.assertEqual(po.supplier.id, 1)\n self.assertEqual(po.status, 'PROCESSED')\n #self.assertEqual(timezone('Asia/Bangkok').normalize(po.order_date), datetime.datetime.now().date())\n self.assertEqual(po.vat, 7)\n self.assertEqual(po.grand_total, Decimal('168.07'))\n self.assertEqual(po.items.count(), 2)\n \n # Check new item in the database\n item2_d = po.items.all().order_by('id')[1]\n self.assertEqual(item2_d.id, 203)\n self.assertEqual(item2_d.description, 'test description change')\n self.assertEqual(item2_d.comments, 'test change')\n self.assertEqual(item2_d.quantity, 3)\n self.assertEqual(item2_d.unit_cost, Decimal('11.99'))\n self.assertEqual(item2_d.total, Decimal('35.97'))\n\n # Check new supply product in the database\n products = SupplyProduct.objects.filter(supply=item2_d.supply, supplier=self.po.supplier)\n self.assertEqual(products.count(), 1)\n product = products.all()[0]\n self.assertEqual(product.supply.id, item2_d.supply.id)\n self.assertEqual(product.supplier.id, self.po.supplier.id)\n self.assertEqual(product.cost, Decimal('11.99'))",
"def get_basket_items_pricedrop(self, offer_info, actual_volume, product_prices):\n prod_code = offer_info.base_prod_code\n base_prod_vol = actual_volume.get(prod_code.lower())\n\n pricedrop_basket = []\n\n if base_prod_vol >= offer_info.min_vol:\n offer_on_prod = offer_info.offer_on\n if actual_volume.get(offer_on_prod.lower()):\n print(\n f\"Base product volume is greater than minimum required volume & product on offer is also available \"\n f\"in cart..\")\n if offer_info.is_limited:\n print(f\"Limited offer..\")\n if prod_code == offer_on_prod:\n # total_allowed_items_on_offer = Limit Volume of base product * (Offer Product Max Volume/Minimum volume of base product)\n total_allowed_items_on_offer = offer_info.limit_vol * (\n offer_info.offer_prod_volume / offer_info.min_vol)\n max_limit = 1\n for i in range(0, base_prod_vol):\n base_prod_actual_price = product_prices.get(prod_code.lower()).get('price')\n pricedrop_basket.append((prod_code, base_prod_actual_price))\n while max_limit <= total_allowed_items_on_offer:\n new_price = (base_prod_actual_price - (offer_info.new_price)) * -1\n pricedrop_basket.append((offer_info.offer_code, new_price))\n max_limit += 1\n else:\n total_allowed_items_on_offer = offer_info.limit_vol * (\n offer_info.offer_prod_volume / offer_info.min_vol)\n for i in range(0, base_prod_vol):\n base_prod_actual_price = product_prices.get(prod_code.lower()).get('price')\n pricedrop_basket.append((prod_code, base_prod_actual_price))\n max_limit = 1\n while max_limit <= total_allowed_items_on_offer:\n offer_onprod_actual_price = product_prices.get(offer_on_prod.lower()).get('price')\n new_price = (base_prod_actual_price - (offer_info.new_price)) * -1\n for j in range(0, actual_volume.get(offer_on_prod).lower()):\n pricedrop_basket.append((offer_on_prod, offer_onprod_actual_price))\n pricedrop_basket.append((offer_info.offer_code, new_price))\n max_limit += 1\n else:\n print(f\"Unlimited offer..\")\n if prod_code == offer_on_prod:\n for i in range(0, base_prod_vol):\n base_prod_actual_price = product_prices.get(prod_code.lower()).get('price')\n pricedrop_basket.append((prod_code, base_prod_actual_price))\n new_price = (base_prod_actual_price - (offer_info.new_price))*-1\n pricedrop_basket.append((offer_info.offer_code, new_price))\n else:\n for i in range(0, base_prod_vol):\n base_prod_actual_price = product_prices.get(prod_code.lower()).get('price')\n pricedrop_basket.append((prod_code, base_prod_actual_price))\n\n offer_onprod_actual_price = product_prices.get(offer_on_prod.lower()).get('price')\n new_price = (offer_onprod_actual_price - (offer_info.new_price)) * -1\n\n for j in range(0, actual_volume.get(offer_on_prod).lower()):\n pricedrop_basket.append((offer_on_prod, offer_onprod_actual_price))\n pricedrop_basket.append((offer_info.offer_code, new_price))\n\n return pricedrop_basket",
"def prepare_funding(self):\n entity_miner = self.entities[0]\n\n entity_miner.send_bitcoins(entity_miner.address)\n entity_miner.purchase_mastercoins(500.0)\n\n self.generate_block()\n self.check_balance(entity_miner.address, MSC, '50000.00000000', '0.00000000')\n self.check_balance(entity_miner.address, TMSC, '50000.00000000', '0.00000000')",
"def update_product(self):\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 item = ['name', 'description', 'cost', 'categories']\n id = self.lineEdit_id.text()\n list = self.product_list()\n for n in range(0, len(list)):\n try:\n update_product(item[n], list[n], id)\n self.frame_3.show()\n self.label_16.setText('UPDATE PRODUCT SUCESSFULLY!')\n except:\n self.frame_3.show()\n self.label_16.setText('ERROR UPDATE PRODUCT!')\n else:\n self.frame_3.show()\n self.label_16.setText('THERE CAN BE NO BLANCK FIELDS!')",
"def test_team_builder_config_product_size_materials_id_patch(self):\n pass",
"def test_cook_set_free(cook_busy, product_for_cook):\n cook_busy.set_free(True)\n # if product needs to be cooked\n assert product_for_cook.get_need_cook_status() is True\n cook_busy.cook_dish(product_for_cook)\n assert product_for_cook.get_need_cook_status() is False",
"def test_team_builder_config_product_size_materials_get(self):\n pass",
"def test_initial_risk_position_sizer_with_cap(self):\n fraction_at_risk = 0.01 # will give leverage of 2, that will be capped to 1.5\n signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk)\n orders = self.initial_risk_position_sizer.size_signals([signal])\n\n self.assertEqual(len(orders), 2) # market order and stop order\n portfolio_value = self.initial_position / self.initial_allocation\n max_leverage = self.initial_risk_position_sizer.max_target_percentage\n target_quantity = int(np.floor(portfolio_value * max_leverage))\n additional_contracts = target_quantity - self.initial_position\n self.assertEqual(orders[0], Order(self.contract, additional_contracts, MarketOrder(), TimeInForce.OPG))\n\n stop_price = self.last_price * (1 - fraction_at_risk)\n stop_quantity = -(self.initial_position + additional_contracts)\n self.assertEqual(orders[1], Order(self.contract, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))"
] | [
"0.62997496",
"0.6127928",
"0.6034478",
"0.6018836",
"0.59107655",
"0.5806491",
"0.5761691",
"0.5730393",
"0.5726534",
"0.57250893",
"0.5659513",
"0.56430745",
"0.56031597",
"0.5599683",
"0.55872136",
"0.5580281",
"0.55272794",
"0.55234873",
"0.55033195",
"0.54832494",
"0.5462037",
"0.5456558",
"0.5439621",
"0.54112643",
"0.5378628",
"0.53774136",
"0.5376175",
"0.5348306",
"0.53454494",
"0.53288656",
"0.5316763",
"0.5308793",
"0.53083247",
"0.5295782",
"0.52867424",
"0.527967",
"0.527967",
"0.5247711",
"0.5246651",
"0.5233093",
"0.52319324",
"0.5215694",
"0.5202196",
"0.5200204",
"0.51870805",
"0.5186509",
"0.5182124",
"0.5178201",
"0.5177799",
"0.5173091",
"0.51635945",
"0.5160199",
"0.5156667",
"0.5156379",
"0.51543504",
"0.5150903",
"0.5150734",
"0.5148976",
"0.5145278",
"0.5139924",
"0.51308954",
"0.5127834",
"0.5124042",
"0.5123402",
"0.5123336",
"0.5122118",
"0.5120679",
"0.51153",
"0.5114947",
"0.5114797",
"0.5112009",
"0.51013416",
"0.50968826",
"0.5096538",
"0.50964385",
"0.5093996",
"0.5092404",
"0.50914407",
"0.5090298",
"0.50900656",
"0.50888526",
"0.50875765",
"0.50820905",
"0.5062475",
"0.50617445",
"0.50601506",
"0.504824",
"0.50462484",
"0.5042834",
"0.504119",
"0.5040606",
"0.50314087",
"0.5019919",
"0.50176674",
"0.501442",
"0.50053406",
"0.5004059",
"0.49935544",
"0.4991405",
"0.49905917"
] | 0.6308212 | 0 |
Parse all the arguments provided from the CLI. | def get_arguments():
parser = argparse.ArgumentParser(description="DeepLab-ResNet Network")
parser.add_argument("--model", type=str, default=MODEL,
help="Model Choice (DeeplabMulti/DeeplabVGG/Oracle).")
parser.add_argument("--data-dir", type=str, default=DATA_DIRECTORY,
help="Path to the directory containing the Cityscapes dataset.")
parser.add_argument("--data-list", type=str, default=DATA_LIST_PATH,
help="Path to the file listing the images in the dataset.")
parser.add_argument("--ignore-label", type=int, default=IGNORE_LABEL,
help="The index of the label to ignore during the training.")
parser.add_argument("--num-classes", type=int, default=NUM_CLASSES,
help="Number of classes to predict (including background).")
parser.add_argument("--restore-from", type=str, default=RESTORE_FROM,
help="Where restore model parameters from.")
parser.add_argument("--gpu", type=int, default=0,
help="choose gpu device.")
parser.add_argument("--batchsize", type=int, default=4,
help="choose gpu device.")
parser.add_argument("--set", type=str, default=SET,
help="choose evaluation set.")
parser.add_argument("--save", type=str, default=SAVE_PATH,
help="Path to save result.")
parser.add_argument("--input-size", type=str, default=INPUT_SIZE,
help="Comma-separated string with height and width of source images.")
return parser.parse_args() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_args(self, argv=None):\n self.opts, self.args = self.cli_parser.parse_args(argv)\n self.check_arguments()\n self._post_process_opts_and_args()\n return self.opts, self.args",
"def _parse_args(self):\n parser = argparse.ArgumentParser()\n _, args = parser.parse_known_args()\n self.args = [a for a in args if a != '']",
"def parseArguments(self):\n iterator = iter(sys.argv[1:]) # Skip file name\n for argument in iterator:\n if len(argument) < 2 or argument[:2] != '--':\n self.error('syntax error \"{}\"'.format(argument))\n else:\n def getValueOfArgument(): return next(iterator)\n self.parseArgument(argument[2:], getValueOfArgument)",
"def process_command_line_arguments() -> Namespace:\n\n parser = build_parser()\n arguments = parser.parse_args()\n\n return arguments",
"def __parse_args(self):\n for argument in self.args:\n source_arg = re.match(\"^(--source=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n input_arg = re.match(\"^(--input=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n stats_arg = re.match(\"^(--stats=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n help_arg = re.match(\"^--help$\", argument)\n vars_arg = re.match(\"^--vars$\", argument)\n insts_arg = re.match(\"^--insts$\", argument)\n if source_arg:\n self.sourceFile = source_arg.group(2)\n self.passedArgs.append(\"source\")\n elif input_arg:\n self.inputFile = input_arg.group(2)\n self.passedArgs.append(\"input\")\n elif help_arg:\n print(\"napoveda\")\n sys.exit(0)\n elif stats_arg:\n self.statsFile = stats_arg.group(2)\n self.passedArgs.append(\"stats\")\n elif vars_arg:\n self.passedArgs.append(\"vars\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"vars\"\n elif insts_arg:\n self.passedArgs.append(\"insts\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"insts\"\n else:\n raise ArgError(\"Unknown argument or format of the argument! (\" + argument + \")\")",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds should be visualized\")\n parser.add_argument(\"--directory\", \"-d\",\n help=\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\")\n args = parser.parse_args()\n return args.visualization, args.directory",
"def __parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-f', '--force', action=\"store_true\", default=False,\n help='overwrite existing database files during import')\n parser.add_argument('-e', '--extension', action=\"store\", default='txt',\n help='specify file extension. default is \"txt\"')\n parser.add_argument('-d', '--delimiter', action=\"store\", default='\\t',\n help='specify column delimiter. default is tab (\\\\t)')\n parser.add_argument('-m', '--mark', action=\"store\", default='.',\n help='specify decimal mark for numeric data. default is'\n ' dot (.)')\n parser.add_argument('-o', '--outformat', action=\"store\", default='npz',\n help='specify output database format. default is \"npz\"'\n ' for numpy database. use \"mat\" for matlab '\n ' database format.')\n parser.add_argument('-r', '--recursive', action=\"store_true\", default=False,\n help='recursively walk through all sub-directories of'\n ' current working directory')\n parser.add_argument('-p', '--pcs', action=\"store_true\", default=True,\n help='indicate if files are pcs files.')\n parser.add_argument('-c', '--colheadlines', action=\"store\", default='1',\n help='number of lines spanned by the column headers')\n args = parser.parse_args()\n return args",
"def parse_args():\n parser = argparse.ArgumentParser(description='Google reminders cli',\n epilog=usage,\n formatter_class=argparse.RawTextHelpFormatter)\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-d\",\n \"--debug\",\n help=\"Print lots of debugging statements\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.DEBUG,\n default=logging.ERROR,\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n help=\"Be verbose\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.INFO,\n )\n parser.add_argument(\"runscript\", default=None)\n return parser.parse_args()",
"def _parse_args():\n parser = argparse.ArgumentParser(description=\"\")\n #parser.add_argument(\"args\", metavar=\"N\", type=str, nargs=\"*\", help=\"Positional arguments.\")\n #parser.add_argument(\"\", dest=\"\", type=\"\", default=, help=)\n #parser.add_argument(\"--version\", action=\"version\", version=\"<the version>\")\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\n required=False, help='Specifies the base path for both logs and apk_downloads.')\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\n help='Specifies the path to a credential file in .toml format.')\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\n help='Specifies the maximum number of apks per category to download.')\n return parser.parse_args()",
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def parse_cmd_arguments():\n parser = argparse.ArgumentParser(description='Process some integers.')\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\n parser.add_argument('-o', '--output', required=True,\n help='ouput JSON file')\n parser.add_argument('-d', '--debug', required=False,\n help='log level. Can be 0-3. Defaults to 0')\n\n return parser.parse_args()",
"def parse_args(self):\n return self.__process_args__(self.parser.parse_args())",
"def parse_args():\n\n import cdr_cleaner.args_parser as parser\n\n additional_arguments = [{\n parser.SHORT_ARGUMENT: '-e',\n parser.LONG_ARGUMENT: '--ehr_dataset_id',\n parser.ACTION: 'store',\n parser.DEST: 'ehr_dataset_id',\n parser.HELP: 'ehr_dataset_id',\n parser.REQUIRED: True\n }, {\n parser.SHORT_ARGUMENT: '-v',\n parser.LONG_ARGUMENT: '--validation_dataset_id',\n parser.ACTION: 'store',\n parser.DEST: 'validation_dataset_id',\n parser.HELP: 'validation_dataset_id',\n parser.REQUIRED: True\n }]\n args = parser.default_parse_args(additional_arguments)\n return args",
"def parse_cli():\n parser = OptionParser()\n return parser.parse_args()",
"def parse_args(self, argv=None):\n self.opts, self.args = self.cli_parser.parse_args(argv)\n self._begin_logging()\n if argv is None:\n argv = sys.argv\n logger.info(' '.join(argv))\n self._process_input_files()\n self._construct_links_of_interest()\n self._open_output_files()\n data = self._construct_data_struct()\n return data",
"def parse_cli():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"ENV\", help=\"Enviorment SCANNER, PC, REMOMTE\")\n args = parser.parse_args()\n\n return args",
"def parse_cli_args():\r\n parser = argparse.ArgumentParser(\r\n description=\"list all installed packages\")\r\n\r\n parser.add_argument(\"-v\", \"--verbose\",\r\n help=\"increase output verbosity\",\r\n action=\"store_true\")\r\n\r\n parser.add_argument(\"-d\", \"--debug\",\r\n help=\"enable debug output\",\r\n action=\"store_true\")\r\n\r\n parser.add_argument(\"-N\", \"--dry-run\",\r\n help=\"Do not perform any actions, only simulate them.\",\r\n action=\"store_true\")\r\n\r\n args = parser.parse_args()\r\n\r\n # set debug log state\r\n DebugLog.enabled = args.debug\r\n\r\n with DebugLogScopedPush(\"cli arguments:\"):\r\n DebugLog.print(str(args))\r\n\r\n return args",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('n_iter',\n help='number of iteration',\n type=int)\n parser.add_argument('n_processes',\n help='number of processes',\n type=int)\n parser.add_argument('method',\n help='mutual exclusion method')\n parser.add_argument('duration',\n help='Duration of each process',\n type=float)\n return parser.parse_args()",
"def _parse_args(argv):\n parser = make_parser()\n args = parser.parse_args(argv)\n LOGGER.setLevel(to_log_level(args.loglevel))\n\n if not args.inputs:\n if args.list:\n tlist = \", \".join(API.list_types())\n _exit_with_output(\"Supported config types: \" + tlist)\n elif args.env:\n cnf = os.environ.copy()\n _output_result(cnf, args.output, args.otype or \"json\", None, None)\n sys.exit(0)\n else:\n parser.print_usage()\n sys.exit(1)\n\n if args.validate and args.schema is None:\n _exit_with_output(\"--validate option requires --scheme option\", 1)\n\n return args",
"def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--model\", choices=['vgg', 'unet', 'fpn'], required=True, help=\"Choose model.\")\r\n parser.add_argument(\"--dataset\", choices=['full', 'small'], required=True, help=\"Choose dataset.\")\r\n\r\n return parser.parse_args()",
"def parse_arguments(self):\n \n for arg in sys.argv[1:]:\n (key, sep, value) = arg.partition(\"=\")\n if sep != \"=\":\n raise ProcessorError(\"Illegal argument '%s'\" % arg)\n self.update_data(key, value)",
"def parse_args(args=None):\n\t\treturn _get_args_parser().parse_args(args)",
"def parse_args():\n parser = ArgumentParser(\n description=\"This is a script for auto apply ipex optimization.\"\n \"\\n################################# Basic usage ############################# \\n\"\n \"\\n 1. Apply ipex optimization with fp32 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\n\"\n \"\\n 2. Apply ipex optimization with bf16 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\n\",\n formatter_class=RawTextHelpFormatter,\n )\n\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\n\n # positional\n parser.add_argument(\n \"program\",\n type=str,\n help=\"The full path to the proram/script to be launched. \"\n \"followed by all the arguments for the script\",\n )\n # rest from the training program\n parser.add_argument(\"program_args\", nargs=REMAINDER)\n return parser.parse_args()",
"def parse_args():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input_path\", required=True)\n parser.add_argument(\"-c\", \"--config\", required=True)\n return parser.parse_args()",
"def arg_parse():\n p = ap.ArgumentParser()\n p.add_argument()\n return p.parse_args()",
"def parse_args(args=None):\n return AP.parse_args(args=args)",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"auth\",\n help=\"authentication string for Infermedica API: \"\n \"APP_ID:APP_KEY or path to file containing it.\")\n parser.add_argument(\"--model\",\n help=\"use non-standard Infermedica model/language, \"\n \"e.g. infermedica-es\")\n args = parser.parse_args()\n return args",
"def parse_args():\n parser = argparse.ArgumentParser(\n description='Run the destination IoT program (CTRL-C to exit)')\n\n parser.add_argument('-v',\n '--verbose',\n default=False,\n action='store_true',\n help='Print all debug logs')\n\n parser.add_argument('-p',\n '--port',\n metavar='<port number>',\n default=7777,\n type=int,\n help='Default: 7777')\n\n parser.add_argument('-a',\n '--address',\n metavar='<email_address>',\n nargs='*',\n help='Email address(es) to receive notifications')\n\n args = parser.parse_args()\n return args",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--start\",\n type=str,\n default=\"\",\n required=False,\n help=\"The start square of the agent, in the form row,col. If not specified, this is randomized\"\n )\n parser.add_argument(\n \"--actions\",\n type=str,\n required=True,\n nargs = '+',\n help=\"The actions the agent takes, comma delimited\"\n )\n parser.add_argument(\n \"--observations\",\n type=str,\n required=True,\n nargs = '+',\n help=\"The observations the agent makes, comma delimited\"\n )\n return parser.parse_args()",
"def parse_arguments():\n # shift away script name\n scriptname=sys.argv[0]\n shift()\n ncl_cmd=list()\n quali_cmd=list()\n id_cmd=list() \n while(len(sys.argv)>0):\n carg = sys.argv[0]\n shift()\n if(carg == \"--nucleotide\"):\n ncl_cmd = mungeArgs(sys.argv)\n elif(carg == \"--quality\"):\n quali_cmd = mungeArgs(sys.argv)\n elif(carg == \"--id\" ):\n id_cmd = mungeArgs(sys.argv)\n elif(carg in [\"-h\", \"--help\"]):\n usage()\n else:\n usage(error=True)\n # Excess arguments which are not processed \n if(len(sys.argv) > 0):\n sys.stdout.write(\"Excess arguments!\\n\")\n sys.stdout.flush()\n usage(error=True)\n\n # external modules rely on non-empty argv array, \n # re-append the script name as first command line argument\n sys.argv.append(scriptname)\n return (id_cmd, ncl_cmd, quali_cmd)",
"def parseArgs():\n parser = argparse.ArgumentParser(description='Runs RHEAS simulation.')\n parser.add_argument('config', help='configuration file')\n parser.add_argument('-d', metavar='DB', help='name of database to connect')\n parser.add_argument('-u', help='update database', action='store_true')\n args = parser.parse_args()\n return args.config, args.d, args.u",
"def parseArgs(arguments=None):\n\tparser = generateParser(None)\n\treturn parser.parse_known_args(arguments)",
"def parse_args():\n parser = argparse.ArgumentParser(description=__doc__)\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"CUDAPOA Python API sample program.\")\n parser.add_argument('-m',\n help=\"Run MSA generation. By default consensusis generated.\",\n action='store_true')\n parser.add_argument('-p',\n help=\"Print output MSA or consensus for each POA group.\",\n action='store_true')\n parser.add_argument('-l',\n help=\"Use long or short read sample data.\",\n action='store_true')\n return parser.parse_args()",
"def parse_command_line_arguments(argv):\n print(\"reading command line arguments in...\")\n\n parser = argparse.ArgumentParser(description='Description of your program')\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\n args = parser.parse_args()\n\n return args.input, args.predicting, args.scoring, args.scale",
"def _parse_cmd_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"--root\", required=True,\n help=\"Root directory of data and logs.\")\n parser.add_argument(\"--log_dir\", default=\"logs\",\n help=\"Sub-directory of tensorboard logs.\")\n parser.add_argument(\"--gpu\", default=\"0\", help=\"GPU device ID.\")\n\n args = parser.parse_args()\n\n return args",
"def parse_args():\n\n parser = argparse.ArgumentParser(\n description=('Print a summarized status of all non-optimal components '\n 'of all detected MegaRAID controllers'))\n parser.add_argument(\n '-c', dest='compress', action='store_true',\n help='Compress with zlib the summary to overcome NRPE output limits.')\n parser.add_argument(\n '-a', dest='all', action='store_true',\n help='Include all components in the summary.')\n\n return parser.parse_args()",
"def parse_args():\n parser = default_argument_parser()\n parser.add_argument(\"--label-map\",\n dest=\"label_map\",\n type=pathlib.Path,\n help=\"Label map in YAML format which maps from category \"\n \"ID to name.\")\n parser.add_argument(\"--train-csv\",\n dest=\"train_csv\",\n required=True,\n type=pathlib.Path,\n help=\"Path to training data CSV file.\")\n parser.add_argument(\"--valid-csv\",\n dest=\"valid_csv\",\n required=False,\n type=pathlib.Path,\n help=\"Optional path to validation data CSV file.\")\n parser.add_argument(\n \"--image-width\",\n type=int,\n help=\"Image width (optional, used to speed up dataset processing).\")\n parser.add_argument(\n \"--image-height\",\n type=int,\n help=\"Image height (optional, used to speed up dataset processing).\")\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(\"Run arguments for system submitted tasks\")\n\n parser.add_argument(\"-f\", \"--funcs\", type=str, nargs=\"?\", required=True,\n help=\"path to pickle file containing a list of \"\n \"functions/methods that should be run by the \"\n \"submitted process\"\n )\n parser.add_argument(\"-k\", \"--kwargs\", type=str, nargs=\"?\", required=False,\n default=None,\n help=\"path to pickle file containing a dictionary of \"\n \"keyword argumnets that should be passed to the \"\n \"functions\")\n parser.add_argument(\"-e\", \"--environment\", type=str, nargs=\"?\",\n required=False,\n help=\"Optional comma-separated environment variables, \"\n \"which should be given as \"\n \"VARNAME1=value1,VARNAME2=value2 and so on. These \"\n \"will be separated and instantiated into Python's \"\n \"os.environ\")\n\n return parser.parse_args()",
"def parse_command_line_arguments():\n\n description, epilog = __doc__.split(\"\\n\\n\", 1)\n\n parser = argparse.ArgumentParser(\n formatter_class=argparse.RawDescriptionHelpFormatter,\n description=description,\n epilog=epilog)\n\n parser.add_argument('-s', '--s', dest='s', action='store', type=float, required=True,\n help='Minimum frequency')\n parser.add_argument('-c', '--credentials', dest='credentials', action='store',\n default=\"./.tpass\",\n help='File with Twitter credentials (username and password, separated by a space)')\n\n args = parser.parse_args()\n \n return args",
"def parse_arguments():\n parser = ArgumentParser()\n\n # For development/testing\n parser.add_argument(\"--dev\", help=\"run the code of the developers tag\")\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(description=__doc__)\n # If user doesn't specify an input file, read from standard input. Since\n # encodings are the worst thing, we're explicitly expecting std\n parser.add_argument('-i', '--infile',\n type=lambda x: open(x, encoding=ENCODE_IN),\n default=io.TextIOWrapper(\n sys.stdin.buffer, encoding=ENCODE_IN)\n )\n # Same thing goes with the output file.\n parser.add_argument('-o', '--outfile',\n type=lambda x: open(x, 'w', encoding=ENCODE_OUT),\n default=io.TextIOWrapper(\n sys.stdout.buffer, encoding=ENCODE_OUT)\n )\n # Set the verbosity level for the logger. The `-v` option will set it to\n # the debug level, while the `-q` will set it to the warning level.\n # Otherwise use the info level.\n verbosity = parser.add_mutually_exclusive_group()\n verbosity.add_argument('-v', '--verbose', action='store_const',\n const=logging.DEBUG, default=logging.INFO)\n verbosity.add_argument('-q', '--quiet', dest='verbose',\n action='store_const', const=logging.WARNING)\n return parser.parse_args()",
"def parse_args():\n parser = ArgumentParser()\n parser.add_argument('--agent1', required=True)\n parser.add_argument('--agent2', required=True)\n parser.add_argument('--num_games', type=int, default=100)\n parser.add_argument('--cards_in_hand', type=int, default=13)\n parser.add_argument('--verbose_mode', type=int, default=1)\n parser.add_argument('--seed', type=int, default=-1)\n\n return parser.parse_args()",
"def _parse_args():\n args = sys.argv[1:]\n cmd_parser = argparse.ArgumentParser()\n cmd_parser.add_argument(\n '--produce-sub',\n dest='produce_sub',\n help='Produce submision file',\n default=False,\n action='store_true',\n )\n cmd_parser.add_argument(\n '--search-cv',\n dest='search_cv',\n help='Perform Search of parameters',\n default=False,\n action='store_true',\n )\n cmd_opts = cmd_parser.parse_args(args=args)\n return cmd_opts",
"def parse_cli_arguments():\n parser = argparse.ArgumentParser('Generates a MANIFEST file used by the '\n 'HMP2 AnADAMA2 workflows.')\n parser.add_argument('-b', '--broad-data-sheet', required=True,\n help='Broad data product status spreadsheet. '\n 'Contains entries indicating new files to be '\n 'processed.')\n parser.add_argument('-o', '--output-manifest', required=True,\n help='Path to desired output manifest file.')\n parser.add_argument('-oi', '--origin-institute', required=True,\n help='Name of institute submitting new files '\n 'to be processed.')\n parser.add_argument('-oc', '--origin-contact', required=True,\n help='Contact person for corresponding origin '\n 'institute.')\n parser.add_argument('-oe', '--origin-contact-email', required=True,\n help='Contact email for contact person.')\n parser.add_argument('-p', '--project-name', dest='project', \n required=True,\n help='Project that sequence files belong too.')\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--version',\n metavar=\"<str>\",\n help=\"Input data version number\",\n type=str,\n required=True\n )\n args = parser.parse_args()\n return args",
"def _parse_args():\n parser = argparse.ArgumentParser(description='Pure-python command-line calculator.')\n\n parser.add_argument('EXPRESSION', action=\"store\", type=str, help=\"expression string to evaluate\")\n parser.add_argument('-m', '--use-modules', nargs='+', action=\"store\", dest=\"MODULE\", type=str,\n help=\"additional modules to use\")\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(\n description='Aggregate Elasticsearch Log data.')\n parser.add_argument(\n '--host',\n default='https://logging-es',\n type=str,\n action='store',\n help='Host name or IP of the Elasticsearch server.'\n )\n parser.add_argument(\n '--port',\n default=9200,\n type=int,\n action='store',\n help='Port number of the Elasticsearch server.'\n )\n parser.add_argument(\n '--ca_certs',\n default='secret/admin-ca',\n type=str,\n action='store',\n help='Path to the CA certificates file'\n )\n parser.add_argument(\n '--cert',\n default='secret/admin-cert',\n type=str,\n action='store',\n help='Path to the client certificate file'\n )\n parser.add_argument(\n '--key',\n default='secret/admin-key',\n type=str,\n action='store',\n help='Path to the client key file'\n )\n\n return parser.parse_args()",
"def parse(self, command_line=sys.argv[1:]):\n return self._parser.parse_args(command_line)",
"def _parse_command_line_arguments():\n parser = ArgumentParser(\n description=(\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\n ),\n )\n parser.add_argument(\n 'ts-file',\n type=str,\n help=(\n 'A file containing the TS sky map'\n ),\n )\n parser.add_argument('--skiprows',\n type=int,\n help='number of rows to skip at the top (default 0)',\n required=False)\n parser.set_defaults(skiprows=0)\n arguments = vars(parser.parse_args())\n return arguments",
"def parse_args():\n\n parser = argparse.ArgumentParser(description='Disk metric sender')\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\n\n return parser.parse_args()",
"def parse_cmdline_args():\n parser = argparse.ArgumentParser(description=\"Guesses the functional element for host.\")\n ##\n ## Internal options\n ##\n parser.add_argument(\"--json\", dest=\"json\", action='store_true', help=\"output in JSON\")\n\n ##\n ## PuppetDB options\n ##\n pdbconf = PdbConfig()\n pdbconf.add_standard_args(parser)\n\n parser.add_argument(\"host\", metavar=\"HOST\",\n help=\"hostnames to query for FE\")\n\n return parser.parse_args()",
"def parse_args():\n global Args\n parser = argparse.ArgumentParser()\n subparsers = parser.add_subparsers()\n pars_simulation(subparsers)\n pars_analyze(subparsers)\n Args = parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"auth\",\n help=\"authentication string for Infermedica API: \"\n \"APP_ID:APP_KEY or path to file containing it.\")\n parser.add_argument(\"--model\",\n help=\"use non-standard Infermedica model/language, \"\n \"e.g. infermedica-es\")\n # TODO: Check if `verbose` actually does anything.\n parser.add_argument(\"-v\", \"--verbose\",\n dest=\"verbose\", action=\"store_true\", default=False,\n help=\"dump internal state\")\n args = parser.parse_args()\n return args",
"def parse_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'config',\n help='Config file')\n parser.add_argument(\n '--quiet',\n '-q',\n action='store_true',\n help='do not print to console'\n )\n parser.add_argument(\n '--password',\n '-p',\n action='store_true',\n help='Set password in keyring.'\n )\n parser.add_argument(\n '--update',\n '-u',\n action='store_true',\n help='Only add transactions after last date in database.'\n )\n parser.add_argument(\n '--mark_seen',\n '-m',\n action='store_true',\n help='Mark fetched emails as seen.'\n )\n\n return parser.parse_args()",
"def _ParseCommandArguments():\n arg_parser = argparse.ArgumentParser()\n arg_parser.usage = __doc__\n\n arg_parser.add_argument('--download-dir',\n type=str,\n required=True,\n help='Directory into which corpora are downloaded.')\n arg_parser.add_argument('--build-dir',\n required=True,\n type=str,\n help='Directory where fuzzers were built.')\n args = arg_parser.parse_args()\n return args",
"def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(\n formatter_class=RawDescriptionHelpFormatter,\n description=\"This tool compares Master lab data with new data CSV files\",\n epilog=\"E.g.: ./cdc.py Master/Master.csv TestCaptures/data1.csv \"\n \"TestCaptures/data2.csv TestCaptures/data3.csv TestCaptures/data4.csv\",\n )\n parser.add_argument(\n \"master\", help=\"A Master CLIA CDC CSV file to process\",\n )\n parser.add_argument(\n \"new_files\",\n type=argparse.FileType(\"r\"),\n nargs=\"+\",\n help=\"A number of new CLIA CSV files to compare with Master\",\n )\n parser.add_argument(\n \"-e\", \"--extra\", action=\"store_true\", help=\"Display some extra data\",\n )\n parser.add_argument(\n \"-f\",\n \"--force\",\n action=\"store_true\",\n help=\"Bypass safety rails - very dangerous\",\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n action=\"store_true\",\n help=\"turn on verbose messages, commands and outputs\",\n )\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-t\", \"-threads\", help=\"specifies a thread count for parallel operations\", type=int)\n return parser.parse_args()",
"def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument(\n '--host', dest='host', default=None,\n help='Host for XNAT. Default: env XNAT_HOST.')\n ap.add_argument(\n '-u', '--username', dest='username', default=None,\n help='Username for XNAT.')\n ap.add_argument('project', help='Project Label')\n ap.add_argument('session', help='Session Label')\n ap.add_argument(\n 'proc_suffix', help='Proc name suffix', nargs='?', default='')\n ap.add_argument(\n '-sd', '--subjects_dir', dest='subjects_dir',\n help='Subjects Directory',\n default=os.environ.get('SUBJECTS_DIR', '/tmp'))\n return ap.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\n parser.add_argument('-r', '--resources_dir', type=unicode)\n parser.add_argument('-t', '--total_docs', type=int)\n parser.add_argument('-m', '--mapping', type=unicode,\n help='File with the yago to lkif mapping')\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument('--source-account', required=True, type=str, help='Source account to pay transaction fees')\n parser.add_argument('--channel-seeds-file', required=True, type=str, help='File path to channel seeds file')\n parser.add_argument('--accounts', required=True, type=int, help='Amount of accounts to create')\n parser.add_argument('--passphrase', required=True, type=str, help='Network passphrase')\n parser.add_argument('--horizon', action='append', help='Horizon endpoint URL (use multiple --horizon flags for multiple addresses)')\n parser.add_argument('--json-output', required=False, type=bool, help='Export output to json format')\n return parser.parse_args()",
"def parse_args():\n\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\n return parser.parse_args()",
"def Args(parser):",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"in_fq\", help=\"The fastq file containing Hi-C reads.\")\n parser.add_argument(\n \"-r\",\n \"--reference\",\n required=True,\n help=\"Path to the reference genome, in FASTA format.\",\n )\n parser.add_argument(\n \"-p\",\n \"--nb_processors\",\n default=1,\n type=int,\n help=\"number of CPUs used for alignment.\",\n )\n parser.add_argument(\n \"-o\",\n \"--out_sam\",\n help=\"Path to the output SAM file for the alignment of in_fq.\",\n )\n parser.add_argument(\n \"-T\",\n \"--tempdir\",\n default=\".\",\n help=\"Directory to write temporary files. Defaults to current directory.\",\n )\n parser.add_argument(\n \"-m\",\n \"--minimap2\",\n default=False,\n action=\"store_true\",\n help=\"Use minimap2 instead of bowtie for the alignment.\",\n )\n parser.add_argument(\n \"-l\",\n \"--min_len\",\n type=int,\n default=20,\n help=\"Minimum length to which reads should be truncated.\",\n )\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(description=\"Sequence Cleaner: Remove Duplicate Sequences, etc\",\n epilog=\"example > sequence_cleaner -q INPUT -o OUTPUT\")\n parser.add_argument('-v', '--version', action='version', version='sequence_cleaner {}'.format(version))\n parser.add_argument(\"-q\", \"--query\", help=\"Path to directory with FAST(A/Q) files\", required=True)\n parser.add_argument(\"-o\", \"--output_directory\", help=\"Path to output files\", required=True)\n parser.add_argument(\"-ml\", \"--minimum_length\", help=\"Minimum length allowed (default=0 - allows all the lengths)\",\n default=\"0\")\n parser.add_argument(\"-mn\", \"--percentage_n\", help=\"Percentage of N is allowed (default=100)\", default=\"100\")\n parser.add_argument('--keep_all_duplicates', help='Keep All Duplicate Sequences', action='store_false', required=False)\n parser.add_argument('--remove_ambiguous', help='Remove any sequence with ambiguous bases', action='store_true', required=False)\n\n parser.add_argument('-l', '--log', help='Path to log file (Default: STDOUT).', required=False)\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-e', '--env', default='production',\n help='Environment to check: integration, staging, production.')\n parser.add_argument('-l', '--log_type', default='govuk_assets',\n help='Which logs to check: govuk_assets, govuk_www.')\n parser.add_argument('-c', '--critical_age_minutes', type=int, default=60,\n help='If the newest logs are older than this many minutes, '\n 'return CRITICAL status.')\n parser.add_argument('-F', '--fake_time', type=fromisoformat,\n help='For testing purposes, use the given time as if it\\'s the current '\n 'time. Requires the format YYYY-MM-DDTHH:MM. Assumes UTC.')\n parser.add_argument('-v', '--verbose', action='count',\n help='Show DEBUG log messages.')\n return parser.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser(\n description=\"Manubot: the manuscript bot for scholarly writing\"\n )\n parser.add_argument(\n \"--version\", action=\"version\", version=f\"v{manubot.__version__}\"\n )\n subparsers = parser.add_subparsers(\n title=\"subcommands\", description=\"All operations are done through subcommands:\"\n )\n # Require specifying a sub-command\n subparsers.required = True # https://bugs.python.org/issue26510\n subparsers.dest = \"subcommand\" # https://bugs.python.org/msg186387\n add_subparser_process(subparsers)\n add_subparser_cite(subparsers)\n add_subparser_webpage(subparsers)\n add_subparser_airevision(subparsers)\n for subparser in subparsers.choices.values():\n subparser.add_argument(\n \"--log-level\",\n default=\"WARNING\",\n choices=[\"DEBUG\", \"INFO\", \"WARNING\", \"ERROR\", \"CRITICAL\"],\n help=\"Set the logging level for stderr logging\",\n )\n args = parser.parse_args()\n return args",
"def parse_args():\n\n parser = argparse.ArgumentParser(description=\"Benchmark Thing WoT server\")\n parser = utils.extend_server_arg_parser(parser)\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-d\",\n \"--duration\",\n type=mesos_maintenance.parse_timedelta,\n default=\"1h\",\n help=\"Duration of the maintenance window. Any pytimeparse unit is supported.\",\n )\n parser.add_argument(\n \"-s\",\n \"--start\",\n type=mesos_maintenance.parse_datetime,\n default=str(mesos_maintenance.now()),\n help=\"Time to start the maintenance window. Defaults to now.\",\n )\n parser.add_argument(\n \"action\",\n choices=[\n \"cluster_status\",\n \"down\",\n \"drain\",\n \"is_host_down\",\n \"is_host_drained\",\n \"is_host_draining\",\n \"is_hosts_past_maintenance_end\",\n \"is_hosts_past_maintenance_start\",\n \"is_safe_to_drain\",\n \"is_safe_to_kill\",\n \"schedule\",\n \"status\",\n \"undrain\",\n \"up\",\n ],\n help=\"Action to perform on the specified hosts\",\n )\n parser.add_argument(\n \"hostname\",\n nargs=\"*\",\n default=[getfqdn()],\n help=\"Hostname(s) of machine(s) to start draining. \"\n \"You can specify <hostname>|<ip> to avoid querying DNS to determine the corresponding IP.\",\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n action=\"count\",\n dest=\"verbose\",\n default=0,\n help=\"Print out more output.\",\n )\n return parser.parse_args()",
"def parse_args():\n parser = ArgumentParser()\n parser.add_argument('-t', '--timer', action='store_true', \\\n help='Time the first random generation')\n parser.add_argument('-i', '--ibmq', default='', help='IBMQ token')\n parser.add_argument('-b', '--backend', default='', help='IBMQ backend')\n return parser.parse_args()",
"def parse_arguments(args=sys.argv[1:]):\n \n parser = argparse.ArgumentParser()\n \n parser.add_argument('-i', '--input',\n help=\"Path of input file to read. Default: {d}\".format(d=INPUT_FILE),\n default=INPUT_FILE)\n \n return parser.parse_args(args)",
"def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # Optional Argument\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\n return parser.parse_args()",
"def parse_command_line() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'pet_database',\n type=str,\n help='path to pet database'\n )\n parser.add_argument(\n '--image_dir',\n default='data/images'\n )\n parser.add_argument(\n '--log',\n default=None,\n help='log file path'\n )\n\n args = parser.parse_args()\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\n return args",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Subscription Watch CSV file packaging script\", prog=sys.argv[0])\n\n # required args\n parser.add_argument(\"-f\", \"--filepath\", required=True,\n help=\"path to files to package\")\n parser.add_argument(\n \"-s\",\n \"--max-size\",\n type=int,\n default=DEFAULT_MAX_SIZE,\n help=f\"Maximum size of packages in MiB. (Default: {DEFAULT_MAX_SIZE} MiB)\",\n )\n parser.add_argument(\n \"-o\", \"--overwrite\", action=\"store_true\", default=False, help=\"whether to overwrite existing files.\"\n )\n parser.add_argument(\"--ocp-cluster-id\", required=True,\n help=\"OCP Cluster ID\")\n parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n default=0, help=\"increase verbosity (up to -vvv)\")\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument('--length', required=True, type=int, help='Test length in seconds')\n parser.add_argument('--txs-per-ledger', required=True, type=int, help='Transaction rate to submit (spam) in parallel for every ledger round')\n parser.add_argument('--prioritizer-seeds-file', required=True, type=str, help='File path to prioritizer seeds file')\n parser.add_argument('--spammer-seeds-file', required=True, type=str, help='File path to spammer seeds file')\n parser.add_argument('--out', default='spam-results-{}.json'.format(str(int(time.time()))), type=str, help='Spam results JSON output')\n parser.add_argument('--avg-block-time', type=int, default=5, help='Average block time. Controls the time delay between every spam round and the one just after that')\n\n parser.add_argument('--passphrase', type=str, help='Network passphrase')\n parser.add_argument('--horizon', action='append',\n help='Horizon endpoint URL (use multiple --horizon flags for multiple addresses)')\n\n return parser.parse_args()",
"def parse_arguments(cls):\r\n parser = argparse.ArgumentParser(description='Easy Infer for model benchmark')\r\n cls.base_arg_parse(parser)\r\n cls.model_arg_parse(parser)\r\n cls.task_arg_parse(parser)\r\n args = parser.parse_args()\r\n return args",
"def argumentsParser(args):\n\targuments = []\n\tif args.find('\"') > -1:\n\t\tt_arguments = args.split('\"')\n\t\tfor a in t_arguments:\n\t\t\tif a == '' or a == ' ':\n\t\t\t\tpass\n\t\t\telif a[-1] == ' ':\n\t\t\t\targuments.append(a[:-1])\n\t\t\telse:\n\t\t\t\targuments.append(a)\n\telif args.find(\"'\") > -1:\n\t\tt_arguments = args.split(\"'\")\n\t\tfor a in t_arguments:\n\t\t\tif a == '' or a == ' ':\n\t\t\t\tpass\n\t\t\telif a[-1] == ' ':\n\t\t\t\targuments.append(a[:-1])\n\t\t\telse:\n\t\t\t\targuments.append(a)\n\telif args == ' ':\n\t\tpass\n\telse:\n\t\targuments = args.split(' ')\n\treturn arguments",
"def parse_command_line():\n parser = argparse.ArgumentParser()\n\n help_str = \\\n 'The collection folder to sort files into. ' \\\n 'If the folder does not exist, it will be created along with the ' \\\n 'necessary contents.'\n parser.add_argument('-c', '--collection', help=help_str)\n\n help_str = \\\n 'The source folder to import files from. Has to exist and ' \\\n 'has to be a folder.'\n parser.add_argument('-s', '--source', help=help_str, required=False)\n\n help_str = \\\n 'View the gallery in random order auto skpping after the' \\\n 'given amount of seconds'\n parser.add_argument('-v', '--view', help=help_str, required=False)\n\n return parser.parse_args()",
"def parse_cli():\n args = {}\n arg_name = None\n arg_values = None\n parameters = {}\n\n cli_args = sys.argv\n found_params = False\n skip = True\n iterator = enumerate(cli_args)\n\n for idx, arg in iterator:\n if skip:\n skip = False\n continue\n else:\n skip = True\n\n if arg == \"--params\":\n if arg_name:\n args[arg_name] = \" \".join(arg_values)\n found_params = True\n skip = False\n\n elif arg[0:2] == \"--\" and not found_params:\n if arg_name:\n args[arg_name] = \" \".join(arg_values)\n arg_name = arg[2:]\n arg_values = []\n skip = False\n\n elif arg[0:2] == \"--\" and found_params:\n raise ValueError(\"You are trying to specify an argument after the \"\n \"--params argument. Please change the order.\")\n\n elif arg[0] == \"-\" and arg[0:2] != \"--\" and found_params:\n parameters[cli_args[idx][1:]] = cli_args[idx+1]\n\n elif arg[0] == \"-\" and arg[0:2] != \"--\" and not found_params:\n raise ValueError(\"You either try to use arguments with only one lea\"\n \"ding minus or try to specify a hyperparameter bef\"\n \"ore the --params argument. %s\" %\n \" \".join(cli_args))\n elif arg[0:2] != \"--\" and not found_params:\n arg_values.append(arg)\n skip = False\n\n elif not found_params:\n raise ValueError(\"Illegal command line string, expected an argument\"\n \" starting with -- but found %s\" % (arg,))\n\n else:\n raise ValueError(\"Illegal command line string, expected a hyperpara\"\n \"meter starting with - but found %s\" % (arg,))\n\n return args, parameters",
"def parse_args():\n p = argparse.ArgumentParser(\n description='Parse system logs, for fun or something')\n p.add_argument('-l', '--log', dest='log_file', help='The log file')\n p.add_argument('-f', '--filter', dest='filter', help='filter by daemon')\n return p.parse_args()",
"def parse_args():\r\n desc = \"Check for the longest running requests in bookie\"\r\n parser = argparse.ArgumentParser(description=desc)\r\n\r\n parser.add_argument('-l', '--log', dest='log',\r\n action='store',\r\n default=None,\r\n required=True,\r\n help=\"log file we're reading requests from\")\r\n\r\n parser.add_argument('-n', '--number', dest='count',\r\n action='store',\r\n default=10,\r\n type=int,\r\n required=False,\r\n help=\"how many urls do we wish to see, default 10\")\r\n\r\n\r\n args = parser.parse_args()\r\n return args",
"def _parse_args():\n parser = argparse.ArgumentParser(description='Run DAFI.')\n parser.add_argument('input_file', help='Name (path) of input file')\n return parser.parse_args()",
"def parse_arguments():\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\n metavar='<application_name>')\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\n metavar='<fetch_interval in seconds>')\n return parser.parse_args()",
"def parse_arguments(self,parser):\r\n return parser.parse_args()",
"def parse_cli_args() -> ArgumentParser:\n parser = ArgumentParser()\n\n group = parser.add_argument_group(\"Run parameters\")\n group.add_argument(\"--url\", type=str, default=\"DEFAULT\", help=\"URL to run the workflow on.\")\n group.add_argument(\n \"--output\",\n type=Path,\n help=\"Where to save the result locally. If save, remember to also add save flag for config.\",\n default=None,\n )\n group.add_argument(\n \"--windows\",\n type=str,\n nargs=\"*\",\n default=[wtl.Workflow.SINGLE_TAB],\n help=\"Tab names (comma-separated). Use space separation for multiple windows.\",\n )\n group.add_argument(\n \"--config\",\n type=str,\n nargs=\"*\",\n default=[],\n required=False,\n help=\"Names of config files in config/, such as \" '\"iphone_x_mobile\", or key=value pairs.',\n )\n\n cli_args = parser.parse_args()\n cli_args.config.insert(0, \"default\")\n\n if cli_args.url == \"DEFAULT\":\n cli_args.url = start_server()\n\n return cli_args",
"def command_line_parse(iargs=None):\n\n parser = create_parser()\n inps = parser.parse_args(args=iargs)\n\n return inps",
"def parse_args():\n parser = argparse.ArgumentParser()\n \n parser.add_argument('--p', dest='path_in',\n action='store', type=str, required=True, default='',\n help=\"Path relative to the data/ directory, to the input ATL01, ANC13, and ANC27 files.\")\n parser.add_argument('--atl01', dest='atl01_file',\n action='store', type=str, required=False, default=None,\n help=\"Path + filename to directory of the ATL01.\")\n parser.add_argument('--anc13', dest='anc13_path',\n action='store', type=str, required=False, default=None,\n help=\"Path to outputs directory of the ANC13.\") \n parser.add_argument('--anc27', dest='anc27_path',\n action='store', type=str, required=False, default=None,\n help=\"Path to directory of the ANC27.\")\n\n args = parser.parse_args()\n \n return args",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Trim spaces at the end of every lines.\"\n )\n parser.add_argument(\"-R\", \"-r\", action=\"store_true\", help=\"Whether to recursive\")\n parser.add_argument(\"-y\", \"--yes\", action=\"store_true\", help=\"No ask\")\n parser.add_argument(\n \"-t\", \"--type\", default=\"*\", help=\"Filter file type(Example: *.py)\"\n )\n parser.add_argument(\"-d\", \"--dir\", default=\"\", help=\"The directory path\")\n parser.add_argument(\n \"files\",\n nargs=\"+\",\n default=[],\n metavar=\"*.py\",\n help=\"files or directories\",\n )\n return parser.parse_args()",
"def _parse_args():\n parser = argparse.ArgumentParser(description='main.py')\n \n # General system running and configuration options\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\n\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\n \n # Some common arguments for your convenience\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\n parser.add_argument('--lr', type=float, default=.001)\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\n # 65 is all you need for GeoQuery\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\n\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\n # 50-200 might be a good range to start with for embedding and LSTM sizes\n args = parser.parse_args()\n return args",
"def parse_cli_args() -> argparse.Namespace:\n parser = argparse.ArgumentParser(description='Virtual analog synthesizer')\n parser.add_argument(\n '-i', '--input_path', type=str, required=True,\n help='path to input TSV file with definition of a track to be played'\n )\n parser.add_argument(\n '-p', '--presets_path', type=str, required=True,\n help='path to YAML file with definitions of timbres to be used'\n )\n parser.add_argument(\n '-o', '--output_path', type=str, required=True,\n help='path to output file where result is going to be saved as WAV'\n )\n parser.add_argument(\n '-c', '--config_path', type=str, default=None,\n help='path to configuration file'\n )\n parser.add_argument(\n '-s', '--safe_mode', dest='safe', action='store_true',\n help='validate parsed timbres before core tasks'\n )\n parser.set_defaults(safe=False)\n\n cli_args = parser.parse_args()\n return cli_args",
"def parseArguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('--output_folder',\n help='Path of the folder where output files should be written.')\n parser.add_argument('--partition_id',\n help='ID of the computer partition to collect data from.')\n parser.add_argument('--collector_db',\n help='The path of slapos collect database.')\n\n return parser.parse_args()",
"def parse_cli_args():\n\n parser = argparse.ArgumentParser(\n description='Create AMICI model and data for steadystate example.')\n\n parser.add_argument('-s', '--sbml', dest='sbml_file_name',\n required=True,\n help='SBML model filename (PEtab format)')\n\n parser.add_argument('-d', '--model-dir', dest='model_dir',\n help='Model directory containing the python module')\n\n parser.add_argument('-n', '--model-name', dest='model_name',\n required=True,\n help='Name of the AMICI model module')\n\n parser.add_argument('-m', '--measurements', dest='measurement_file_name',\n required=True,\n help='Name of measurement table (PEtab format)')\n\n parser.add_argument('-c', '--conditions', dest='condition_file_name',\n required=True,\n help='Condition table (PEtab format)')\n\n parser.add_argument('-p', '--parameters', dest='parameter_file_name',\n required=True,\n help='Condition table (PEtab format)')\n\n parser.add_argument('-o', dest='hdf5_file_name', default='data.h5',\n help='Name of HDF5 file to generate')\n\n args = parser.parse_args()\n\n return args",
"def argParse():\n p = ap.ArgumentParser()\n p.add_argument('field',\n help='Name of field')\n p.add_argument('telescope',\n help='Name of telescope',\n choices=['io', 'callisto', 'europa',\n 'ganymede', 'artemis', 'saintex',\n 'nites', 'rcos20'])\n p.add_argument('filt',\n help='Name of filter')\n return p.parse_args()",
"def parse_args():\n import argparse\n\n parser = argparse.ArgumentParser(description=\"Pilot kodi\")\n parser.add_argument(\"--server\",\"-s\",metavar=\"SERVER\",required=True,help=\"Server to connect to\")\n parser.add_argument(\"--port\",\"-p\",metavar=\"PORT\",default=8080,type=int,help=\"Port of the server\")\n parser.add_argument(\"--get-audio\",action=\"store_true\",help=\"Get audio\")\n parser.add_argument(\"--switch-audio\",action=\"store_true\",help=\"Switch Audio\")\n parser.add_argument(\"--valid-audios\",metavar=\"SUBTITLE\",default=[\"fre\",\"eng\"],type=lambda p:p.split(\",\"),help=\"Valid audios\")\n parser.add_argument(\"--get-subtitle\",action=\"store_true\",help=\"Get subtitle\")\n parser.add_argument(\"--toggle-subtitle\",action=\"store_true\",help=\"Toggle subtitles\")\n parser.add_argument(\"--switch-subtitles\",action=\"store_true\",help=\"Switch subtitles\")\n parser.add_argument(\"--valid-subtitles\",metavar=\"SUBTITLE\",default=[\"fre\"],type=lambda p:p.split(\",\"),help=\"Valid subtitles\")\n\n return parser.parse_args()",
"def parse_args():\n parser = argparse.ArgumentParser(\n description='Convert CVAT XML annotations to YOLO format'\n )\n\n parser.add_argument(\n '--cvat-xml', metavar='FILE', required=True,\n help='input file with CVAT annotation in xml format'\n )\n\n parser.add_argument(\n '--image-dir', metavar='DIRECTORY', required=False,\n help='directory which contains original images'\n )\n\n parser.add_argument(\n '--output-dir', metavar='DIRECTORY', required=True,\n help='directory for output annotations in YOLO format'\n )\n\n parser.add_argument(\n '--username', metavar='USERNAME', required=False,\n help='Username from CVAT Login page, required to download images'\n )\n\n parser.add_argument(\n '--password', metavar='PASSWORD', required=False,\n help='Password from CVAT Login page, required to download images'\n )\n\n parser.add_argument(\n '--labels', metavar='ILABELS', required=False,\n help='Labels (separated by comma) to extract. Example: car,truck,motorcycle'\n )\n\n return parser.parse_args()",
"def _parse_cli_opts(self, args):\n self._args = args\n for opt, group in self._all_cli_opts():\n opt._add_to_cli(self._oparser, group)\n\n return self._parse_config_files()",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Check the ERC 20 conformance\", usage=\"fortress-check-erc project contractName\",\n )\n\n parser.add_argument(\"project\", help=\"The codebase to be tested.\")\n\n parser.add_argument(\n \"contract_name\",\n help=\"The name of the contract. Specify the first case contract that follow the standard. Derived contracts will be checked.\",\n )\n\n parser.add_argument(\n \"--erc\",\n help=f\"ERC to be tested, available {','.join(ERCS.keys())} (default ERC20)\",\n action=\"store\",\n default=\"erc20\",\n )\n\n parser.add_argument(\n \"--json\",\n help='Export the results as a JSON file (\"--json -\" to export to stdout)',\n action=\"store\",\n default=False,\n )\n\n # Add default arguments from crytic-compile\n cryticparser.init(parser)\n\n return parser.parse_args()"
] | [
"0.8019148",
"0.78268564",
"0.7824553",
"0.78125226",
"0.7683437",
"0.7675735",
"0.7640287",
"0.7633257",
"0.76331824",
"0.7623657",
"0.7609315",
"0.7600032",
"0.7587876",
"0.7581038",
"0.75800914",
"0.75694513",
"0.7566255",
"0.75164413",
"0.7513215",
"0.7509136",
"0.750603",
"0.75040233",
"0.7502195",
"0.74971944",
"0.74815404",
"0.74805546",
"0.7478384",
"0.74556947",
"0.7455033",
"0.7444176",
"0.7437417",
"0.7430781",
"0.7426555",
"0.7397285",
"0.7395645",
"0.73877287",
"0.73822016",
"0.73792267",
"0.7377103",
"0.7375457",
"0.73648983",
"0.7363114",
"0.7359615",
"0.73518246",
"0.73415715",
"0.73414207",
"0.7338132",
"0.7336818",
"0.73328394",
"0.73243624",
"0.7321408",
"0.7318176",
"0.73179847",
"0.73157626",
"0.7315641",
"0.73013943",
"0.73001623",
"0.72992057",
"0.72961235",
"0.72952855",
"0.7284375",
"0.72842354",
"0.7283577",
"0.7281034",
"0.7280651",
"0.72792697",
"0.72749615",
"0.7273592",
"0.7265653",
"0.72654885",
"0.72618264",
"0.72550416",
"0.72544396",
"0.7254434",
"0.7254194",
"0.7245724",
"0.72411656",
"0.72367746",
"0.72360295",
"0.7233724",
"0.7230163",
"0.7229853",
"0.72254187",
"0.72252166",
"0.7222493",
"0.7221609",
"0.7210194",
"0.7209031",
"0.7200559",
"0.7199441",
"0.71989715",
"0.7198882",
"0.7198428",
"0.71961206",
"0.71948016",
"0.7192971",
"0.71890193",
"0.71882665",
"0.71791667",
"0.71749336",
"0.71732265"
] | 0.0 | -1 |
Create the model and start the evaluation process. | def main():
args = get_arguments()
w, h = map(int, args.input_size.split(','))
config_path = os.path.join(os.path.dirname(args.restore_from),'opts.yaml')
with open(config_path, 'r') as stream:
config = yaml.load(stream)
args.model = config['model']
print('ModelType:%s'%args.model)
print('NormType:%s'%config['norm_style'])
gpu0 = args.gpu
batchsize = args.batchsize
model_name = os.path.basename( os.path.dirname(args.restore_from) )
#args.save += model_name
if not os.path.exists(args.save):
os.makedirs(args.save)
confidence_path = os.path.join(args.save, 'submit/confidence')
label_path = os.path.join(args.save, 'submit/labelTrainIds')
label_invalid_path = os.path.join(args.save, 'submit/labelTrainIds_invalid')
for path in [confidence_path, label_path, label_invalid_path]:
if not os.path.exists(path):
os.makedirs(path)
if args.model == 'DeepLab':
model = DeeplabMulti(num_classes=args.num_classes, use_se = config['use_se'], train_bn = False, norm_style = config['norm_style'])
elif args.model == 'Oracle':
model = Res_Deeplab(num_classes=args.num_classes)
if args.restore_from == RESTORE_FROM:
args.restore_from = RESTORE_FROM_ORC
elif args.model == 'DeeplabVGG':
model = DeeplabVGG(num_classes=args.num_classes)
if args.restore_from == RESTORE_FROM:
args.restore_from = RESTORE_FROM_VGG
if args.restore_from[:4] == 'http' :
saved_state_dict = model_zoo.load_url(args.restore_from)
else:
saved_state_dict = torch.load(args.restore_from)
try:
model.load_state_dict(saved_state_dict)
except:
model = torch.nn.DataParallel(model)
model.load_state_dict(saved_state_dict)
model.eval()
model.cuda(gpu0)
testloader = data.DataLoader(DarkZurichDataSet(args.data_dir, args.data_list, crop_size=(h, w), resize_size=(w, h), mean=IMG_MEAN, scale=False, mirror=False, set=args.set),
batch_size=batchsize, shuffle=False, pin_memory=True, num_workers=4)
scale = 1.25
testloader2 = data.DataLoader(DarkZurichDataSet(args.data_dir, args.data_list, crop_size=(round(h*scale), round(w*scale) ), resize_size=( round(w*scale), round(h*scale)), mean=IMG_MEAN, scale=False, mirror=False, set=args.set),
batch_size=batchsize, shuffle=False, pin_memory=True, num_workers=4)
if version.parse(torch.__version__) >= version.parse('0.4.0'):
interp = nn.Upsample(size=(1080, 1920), mode='bilinear', align_corners=True)
else:
interp = nn.Upsample(size=(1080, 1920), mode='bilinear')
sm = torch.nn.Softmax(dim = 1)
log_sm = torch.nn.LogSoftmax(dim = 1)
kl_distance = nn.KLDivLoss( reduction = 'none')
prior = np.load('./utils/prior_all.npy').transpose((2,0,1))[np.newaxis, :, :, :]
prior = torch.from_numpy(prior)
for index, img_data in enumerate(zip(testloader, testloader2) ):
batch, batch2 = img_data
image, _, name = batch
image2, _, name2 = batch2
inputs = image.cuda()
inputs2 = image2.cuda()
print('\r>>>>Extracting feature...%04d/%04d'%(index*batchsize, args.batchsize*len(testloader)), end='')
if args.model == 'DeepLab':
with torch.no_grad():
output1, output2 = model(inputs)
output_batch = interp(sm(0.5* output1 + output2))
heatmap_batch = torch.sum(kl_distance(log_sm(output1), sm(output2)), dim=1)
output1, output2 = model(fliplr(inputs))
output1, output2 = fliplr(output1), fliplr(output2)
output_batch += interp(sm(0.5 * output1 + output2))
del output1, output2, inputs
output1, output2 = model(inputs2)
output_batch += interp(sm(0.5* output1 + output2))
output1, output2 = model(fliplr(inputs2))
output1, output2 = fliplr(output1), fliplr(output2)
output_batch += interp(sm(0.5 * output1 + output2))
del output1, output2, inputs2
ratio = 0.95
output_batch = output_batch.cpu() / 4
# output_batch = output_batch *(ratio + (1 - ratio) * prior)
output_batch = output_batch.data.numpy()
heatmap_batch = heatmap_batch.cpu().data.numpy()
elif args.model == 'DeeplabVGG' or args.model == 'Oracle':
output_batch = model(Variable(image).cuda())
output_batch = interp(output_batch).cpu().data.numpy()
output_batch = output_batch.transpose(0,2,3,1)
score_batch = np.max(output_batch, axis=3)
output_batch = np.asarray(np.argmax(output_batch, axis=3), dtype=np.uint8)
threshold = 0.3274
for i in range(output_batch.shape[0]):
output_single = output_batch[i,:,:]
output_col = colorize_mask(output_single)
output = Image.fromarray(output_single)
name_tmp = name[i].split('/')[-1]
dir_name = name[i].split('/')[-2]
save_path = args.save + '/' + dir_name
if not os.path.isdir(save_path):
os.mkdir(save_path)
output.save('%s/%s' % (save_path, name_tmp))
print('%s/%s' % (save_path, name_tmp))
output_col.save('%s/%s_color.png' % (save_path, name_tmp.split('.')[0]))
# heatmap_tmp = heatmap_batch[i,:,:]/np.max(heatmap_batch[i,:,:])
# fig = plt.figure()
# plt.axis('off')
# heatmap = plt.imshow(heatmap_tmp, cmap='viridis')
# fig.colorbar(heatmap)
# fig.savefig('%s/%s_heatmap.png' % (save_path, name_tmp.split('.')[0]))
if args.set == 'test' or args.set == 'val':
# label
output.save('%s/%s' % (label_path, name_tmp))
# label invalid
output_single[score_batch[i, :, :] < threshold] = 255
output = Image.fromarray(output_single)
output.save('%s/%s' % (label_invalid_path, name_tmp))
# conficence
confidence = score_batch[i, :, :] * 65535
confidence = np.asarray(confidence, dtype=np.uint16)
print(confidence.min(), confidence.max())
iio.imwrite('%s/%s' % (confidence_path, name_tmp), confidence)
return args.save | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)",
"def train_and_eval(self):\n self.__create_indexes()\n model = None\n model = None\n if self.model == 'OMult':\n model = OMult(self.kwargs)\n elif self.model == 'ConvO':\n model = ConvO(self.kwargs)\n elif self.model == 'QMult':\n model = QMult(self.kwargs)\n elif self.model == 'ConvQ':\n model = ConvQ(self.kwargs)\n elif self.model == 'OMultBatch':\n model = OMultBatch(self.kwargs)\n elif self.model == 'ConvOBatch':\n model = ConvOBatch(self.kwargs)\n elif self.model == 'QMultBatch':\n model = QMultBatch(self.kwargs)\n elif self.model == 'ConvQBatch':\n model = ConvQBatch(self.kwargs)\n else:\n print(self.model, ' is not valid name')\n raise ValueError\n\n self.train(model)\n self.eval(model)",
"def evaluate_model(self):\r\n self.model.eval() # sets layers to eval mode (e.g. norm, dropout)\r\n with torch.no_grad(): # deactivates autograd engine\r\n\r\n # generate graphs required for model evaluation\r\n # note that evaluation of the generated graphs happens in\r\n # `generate_graphs()`, and molecules are saved as `self` attributes\r\n self.generate_graphs(n_samples=self.C.n_samples, evaluation=True)\r\n\r\n print(\"* Evaluating model.\", flush=True)\r\n anal.evaluate_model(valid_dataloader=self.valid_dataloader,\r\n train_dataloader=self.train_dataloader,\r\n nll_per_action=self.nll_per_action,\r\n model=self.model)\r\n\r\n self.nll_per_action = None # don't need anymore\r\n\r\n print(f\"* Saving model state at Epoch {self.current_epoch}.\", flush=True)\r\n\r\n # `pickle.HIGHEST_PROTOCOL` good for large objects\r\n model_path_and_filename = (self.C.job_dir + f\"model_restart_{self.current_epoch}.pth\")\r\n torch.save(obj=self.model,\r\n f=model_path_and_filename,\r\n pickle_protocol=pickle.HIGHEST_PROTOCOL)",
"def main():\n data = load_data()\n analyze_features(data['full_features'])\n model = train(data)\n\n with open('model.pickle', 'wb') as f:\n pickle.dump(model, f)\n evaluate(model, data)",
"def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()",
"def run_model(self):\n hparams = self.hparams\n\n # Build the child graph\n with tf.Graph().as_default(), tf.device(\n '/cpu:0' if FLAGS.use_cpu else '/gpu:0'):\n m, meval = self._build_models()\n\n # Figure out what epoch we are on\n starting_epoch = self._calc_starting_epoch(m)\n\n # Run the validation error right at the beginning\n valid_accuracy = self.eval_child_model(\n meval, self.data_loader, 'val')\n tf.logging.info('Before Training Epoch: {} Val Acc: {}'.format(\n starting_epoch, valid_accuracy))\n training_accuracy = None\n\n for curr_epoch in xrange(starting_epoch, hparams.num_epochs):\n\n # Run one training epoch\n training_accuracy = self._run_training_loop(m, curr_epoch)\n\n valid_accuracy = self.eval_child_model(\n meval, self.data_loader, 'val')\n tf.logging.info('Epoch: {} Valid Acc: {}'.format(\n curr_epoch, valid_accuracy))\n\n valid_accuracy, test_accuracy = self._compute_final_accuracies(\n meval)\n\n tf.logging.info(\n 'Train Acc: {} Valid Acc: {} Test Acc: {}'.format(\n training_accuracy, valid_accuracy, test_accuracy))",
"def create_eval(self):\n self.ev_id = \"ev-\" + base64.b32encode(os.urandom(10)).decode(\"ascii\")\n self.ev_name = \"Evaluation: \" + self.ml_name\n self._ml.create_evaluation(\n EvaluationId=self.ev_id,\n EvaluationName=self.ev_name,\n MLModelId=self.ml_id,\n EvaluationDataSourceId=self.fold.eval_ds_id\n )\n logger.info(\"Created Evaluation \" + self.ev_id)",
"def _set_eval(self):\n\n if self.model.__dict__['training']:\n self.model.eval()",
"def entry(self):\n if not os.path.isfile('model'):\n train()\n schedule.every(0.01).seconds.do(predict, self)\n while True:\n schedule.run_pending()",
"def train(self):\n # setup model\n self.createModel()\n self.setGenerators()\n self.buildCallbacks()\n self.printParameters()\n \n # train model\n _ = self.model.fit_generator(\n generator = self.trainGen,\n validation_data = self.validateGen,\n steps_per_epoch = self.steps_per_epoch,\n validation_steps = self.validation_steps,\n epochs = self.epochs,\n use_multiprocessing = True,\n callbacks = self.callbacks)\n # clear save paths to avoid overwriting accidentaly\n self.saveName = None",
"def evaluate_model():\n\n print '\\n\\tevaluate result'\n os.system('./conlleval.pl -d \\'\\t\\' < ' + encoded_test + ' >> ' + result_file)\n print '\\t--done\\n'",
"def eval(self, logger=None):\n self.model.eval()\n self.model_DP.eval()\n logger.info(\"Successfully set the model eval mode\")",
"def eval(self):\n self.train(mode=False)",
"def set_eval(self):\n self.model.eval()",
"def run(self, data, training=False):\n # Set mode\n if training:\n self._model.train()\n else:\n self._model.eval()\n # Compute\n return self._model(data)",
"def prepare_evaluation(self):\n self.model = load_model(self.path_best_model)\n\n if not self.is_exist(f'{self.path_model_directory}evaluation_ready_sequences.data'):\n self.evaluation_dataframe = self.remove_catalogs(dataframe=self.load_evaluation_data())\n\n self.evaluation_dataframe.drop(['catalog_item_list', 'session_start_time', 'good_catalog_items', 'sequence_length'], axis=1, inplace=True)\n self.evaluation_dataframe['decoded_item_sequence'] = self.evaluation_dataframe['item_sequence'].copy(deep=True)\n\n sequences = self.evaluation_dataframe.values.tolist()\n joblib.dump(sequences, f'{self.path_model_directory}evaluation_ready_sequences.data')\n else:\n sequences = joblib.load(f'{self.path_model_directory}evaluation_ready_sequences.data')\n self.load_model_metadata()\n\n # Set the encode vector size to 1 since this model is not using any encoding for the features\n self.encoding_vector_size = 1\n self.evaluation_creator(sequences_to_evaluate=sequences, evaluation_class=Evaluator)",
"def evaluate(self):\n Logger.info('Evaluating model...', Logger.log.info)\n \n if self.default_model_eval:\n model = f'{self._props.model_path}/{self._lang}.lstm'\n self.file_prefix = \"before\"\n else:\n model = f'{ModelProperties.model_path}/font_checkpoint'\n self.file_prefix = \"after\"\n\n training_file = f'{ModelProperties.training_data}/{self._lang}.training_files.txt'\n\n if os.path.exists(training_file):\n with open(training_file) as file:\n for lstmf in file:\n with open('training.txt', 'w') as fs:\n fs.write(lstmf)\n\n process_params = [\n 'lstmeval',\n '--model', model,\n '--traineddata', f'{ModelProperties.tessdata}/{self._lang}.traineddata',\n '--eval_listfile', 'training.txt'\n ]\n process = self._proc.create_process(process_params)\n statistics = self._proc.process_output(process)\n\n os.remove('training.txt')\n font = re.split(\"[/,.]\", lstmf)[-3]\n self.eval_data.append(\n {'font': font, 'statistics': statistics}\n )",
"def evaluate():\n sess = tf.Session()\n tf.logging.info(\"Building graph...\")\n\n embeddings = load_embeddings()\n tf_data = load_batched_dataset(False, embeddings)\n it = tf_data.make_initializable_iterator()\n features, labels = it.get_next()\n\n logits = predict(False, embeddings, features[\"premise\"],\n features[\"hypothesis\"])\n accuracy, update_ops = tf.metrics.accuracy(\n tf.argmax(logits, 1, output_type=tf.int32), tf.to_int32(labels))\n\n tf.logging.info(\"Running initializers...\")\n checkpoint_file = FLAGS.checkpoint_file\n if checkpoint_file is not None:\n saver = tf.train.Saver(tf.trainable_variables())\n tf.logging.info(\"Restoring from checkpoint: \" + checkpoint_file)\n saver.restore(sess, checkpoint_file)\n else:\n tf.logging.warning(\"No checkpoint given, evaling model with random weights\")\n sess.run(tf.global_variables_initializer())\n sess.run(tf.local_variables_initializer())\n sess.run(tf.tables_initializer())\n sess.run(it.initializer)\n\n tf.logging.info(\"Starting loop....\")\n while True:\n try:\n sess.run(update_ops)\n except tf.errors.OutOfRangeError:\n break\n tf.logging.info(\"Done\")\n\n accuracy = sess.run(accuracy)\n print(\"Accuracy: %f\" % accuracy)",
"def main():\r\n # Read dataset.\r\n reader = DatasetReader\r\n train_filename = sys.argv[1]\r\n test_filename = train_filename.replace('_train_', '_dev_')\r\n term_index, tag_index, train_data, test_data = reader.ReadData(train_filename, test_filename)\r\n (train_terms, train_tags, train_lengths) = train_data\r\n (test_terms, test_tags, test_lengths) = test_data\r\n\r\n model = SequenceModel(train_tags.shape[1], len(term_index), len(tag_index))\r\n model.build_inference()\r\n model.build_training()\r\n for j in range(5):\r\n model.train_epoch(train_terms,train_tags, train_lengths)\r\n print('Finished epoch %i. Evaluating ...' % (j+1))\r\n model.evaluate(test_terms, test_tags, test_lengths)",
"def evaluate_model():\n\n # Get the processed data (in proper format to evaluate the NER model)\n data = get_json_from_file_path(PROCESSED_DATA_PATH)\n # Split the dataset for training and test as we did for training\n train_data, test_data = train_test_split(data, train_size=0.7, \n random_state=4)\n\n # Load the model trained\n try:\n ner_model = spacy.load(OUTPUT_MODEL_PATH)\n except Exception as err:\n msg = f'Could not load the model. Error: {err}'\n raise Exception(msg)\n\n # Compute evaluation scores\n print('Computing metrics...')\n scores = evaluate(ner_model, test_data)\n # General metrics of the model\n f_score = scores.get('ents_f')\n precision = scores.get('ents_p')\n recall = scores.get('ents_r')\n print('\\nScoring:')\n print(f'F-score: {f_score}')\n print(f'Precision: {precision}')\n print(f'Recall: {recall}')\n\n # Get the specific scores for each entity \n scores_per_entity = scores.get('ents_per_type')\n # Get the F-score of the entities\n f_scores_of_entities = []\n for entity_scores in scores_per_entity.values():\n f_scores_of_entities.append(entity_scores['f'])\n # Compute the macro averaged F-score\n macro_avg_f_score = sum(f_scores_of_entities)/len(f_scores_of_entities)\n print(f'Macro averaged F-score: {macro_avg_f_score}')\n \n print('\\nScores per entity;')\n print('{:<15} {:<10} {:<10} {:<10}'.format('Entity','F-score','Precision','Recall'))\n for key, value in scores_per_entity.items():\n entity = key\n f, p, r = value['f'], value['p'], value['r']\n print('{:<15} {:<10.2f} {:<10.2f} {:<10.2f}'.format(entity, f, p, r))",
"def _runModel(self, traj):\n if self.useRandomICs:\n logging.warn(\"Random initial conditions not implemented yet\")\n # get parameters of this run from pypet trajectory\n runParams = self.getParametersFromTraj(traj)\n if self.parameterSpace.star:\n runParams = flatten_nested_dict(flat_dict_to_nested(runParams)[\"parameters\"])\n\n # set the parameters for the model\n self.model.params.update(runParams)\n\n # get kwargs from Exploration.run()\n runKwargs = {}\n if hasattr(self, \"runKwargs\"):\n runKwargs = self.runKwargs\n # run it\n self.model.run(**runKwargs)\n # save outputs\n self._saveModelOutputsToPypet(traj)",
"def main():\n df = prepro_last()\n X, y = train_build(df)\n fit_store(X, y)",
"def run():\n print('*-----------------------------------*')\n print('Running main.py ...')\n model = MLPModel(CFG, name='tfds_tryout')\n print('* Model defined')\n model.load_data(method='tfds')\n print('* Data Loaded')\n print(model.datasetinfo)\n model.build()\n model.train()\n model.evaluate()\n model.save()",
"def eval_model(self, eval_data): # noqa: ignore flake8\"\n os.makedirs(self.model_dir, exist_ok=True)\n source_texts, target_texts = create_dataset(eval_data)\n logger.info(\"Evaluating the model...\")\n logger.info(\"Number of examples: {}\".format(len(source_texts)))\n\n if self.src_2_ids is None:\n self.src_2_ids = load_word_dict(self.src_vocab_path)\n self.trg_2_ids = load_word_dict(self.trg_vocab_path)\n if self.model is None:\n if os.path.exists(self.model_path):\n self.model = Seq2Seq(\n encoder_vocab_size=len(self.src_2_ids),\n decoder_vocab_size=len(self.trg_2_ids),\n embed_size=self.embed_size,\n enc_hidden_size=self.hidden_size,\n dec_hidden_size=self.hidden_size,\n dropout=self.dropout\n )\n self.load_model()\n self.model.to(device)\n else:\n raise ValueError(\"Model not found at {}\".format(self.model_path))\n self.model.eval()\n\n train_src, train_trg = one_hot(source_texts, target_texts, self.src_2_ids, self.trg_2_ids, sort_by_len=True)\n\n id_2_srcs = {v: k for k, v in self.src_2_ids.items()}\n id_2_trgs = {v: k for k, v in self.trg_2_ids.items()}\n logger.debug(f'evaluate src: {[id_2_srcs[i] for i in train_src[0]]}')\n logger.debug(f'evaluate trg: {[id_2_trgs[i] for i in train_trg[0]]}')\n eval_data = gen_examples(train_src, train_trg, self.batch_size, self.max_length)\n\n total_num_words = 0.\n total_loss = 0.\n with torch.no_grad():\n for it, (mb_x, mb_x_len, mb_y, mb_y_len) in enumerate(eval_data):\n mb_x = torch.from_numpy(mb_x).to(device).long()\n mb_x_len = torch.from_numpy(mb_x_len).to(device).long()\n mb_input = torch.from_numpy(mb_y[:, :-1]).to(device).long()\n mb_output = torch.from_numpy(mb_y[:, 1:]).to(device).long()\n mb_y_len = torch.from_numpy(mb_y_len - 1).to(device).long()\n mb_y_len[mb_y_len <= 0] = 1\n\n mb_pred, attn = self.model(mb_x, mb_x_len, mb_input, mb_y_len)\n\n mb_out_mask = torch.arange(mb_y_len.max().item(), device=device)[None, :] < mb_y_len[:, None]\n mb_out_mask = mb_out_mask.float()\n\n loss = self.loss_fn(mb_pred, mb_output, mb_out_mask)\n\n num_words = torch.sum(mb_y_len).item()\n total_loss += loss.item() * num_words\n total_num_words += num_words\n loss = total_loss / total_num_words\n logger.info(f\"Evaluation loss: {loss}\")\n return {'loss': loss}",
"def eval_model(config):\n print 'Model directory: %s' % config.model_output\n print 'Running model: %s' % config.model_type\n if config.model_type == 'fully_connected_mlp':\n from models.fully_connected_mlp import model_struct\n elif config.model_type == 'fully_connected_mlp_2l':\n from models.fully_connected_mlp_2l import model_struct\n elif config.model_type == 'fully_connected_conv':\n from models.fully_connected_conv import model_struct\n elif config.model_type == 'vgg_feature_model':\n from models.vgg_feature_model import model_struct\n else:\n raise Exception\n\n # Prepare model training\n dt_stamp = re.split(\n '\\.', str(datetime.now()))[0].\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\n dt_dataset = config.model_type + '_' + dt_stamp + '/'\n config.train_checkpoint = os.path.join(\n config.model_output, dt_dataset) # timestamp this run\n config.summary_dir = os.path.join(\n config.train_summaries, config.model_output, dt_dataset)\n dir_list = [config.train_checkpoint, config.summary_dir]\n [make_dir(d) for d in dir_list]\n\n # Prepare model inputs\n train_data = os.path.join(config.tfrecord_dir, 'train.tfrecords')\n validation_data = os.path.join(config.tfrecord_dir, 'val.tfrecords')\n feat_mean = 0 # np.mean(np.load(config.mean_file)['feat_list'])\n\n # Prepare data on CPU\n with tf.device('/cpu:0'):\n train_images, train_labels = inputs(\n tfrecord_file=train_data,\n batch_size=config.train_batch,\n num_feats=config.n_features,\n sample=config.sample['train'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n val_images, val_labels = inputs(\n tfrecord_file=validation_data,\n batch_size=1,\n num_feats=config.n_features,\n sample=config.sample['val'],\n max_pixels_per_image=config.max_pixels_per_image,\n im_size=config.resize,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n num_epochs=config.epochs,\n feat_mean_value=feat_mean)\n tf.summary.image('validation images', tf.cast(val_labels, tf.float32))\n\n # Prepare model on GPU\n with tf.device('/gpu:0'):\n with tf.variable_scope('cnn') as scope:\n\n model = model_struct()\n train_mode = tf.get_variable(name='training', initializer=True)\n model.build(\n features=train_images,\n output_categories=len(config.labels.keys()),\n train_mode=train_mode, batchnorm=config.batch_norm)\n\n # Prepare the cost function\n cost = softmax_cost(\n model.res_logits, train_labels, ratio=config.ratio,\n label_reshape=[\n config.batch_size * config.max_pixels_per_image])\n train_op = tf.train.AdamOptimizer(config.lr).minimize(cost)\n\n tf.summary.scalar(\"cost\", cost)\n\n train_score = correlation(\n model.prob, train_labels) # training accuracy\n tf.summary.scalar(\"training correlation\", train_score)\n\n # Setup validation op\n if validation_data is not False:\n scope.reuse_variables()\n # Validation graph is the same as training except no batchnorm\n val_model = model_struct()\n val_model.build(\n features=val_images,\n output_categories=len(config.labels.keys()))\n\n # Calculate validation accuracy\n val_pred = tf.cast(\n tf.reshape(\n tf.argmax(\n val_model.prob, axis=1),\n [1, config.resize[0], config.resize[1], 1]),\n tf.float32)\n tf.summary.image('validation prediction', val_pred)\n val_score = correlation(\n val_model.prob, tf.reshape(\n val_labels, [np.prod(config.resize), 1]))\n tf.summary.scalar(\"validation correlation\", val_score)\n\n # Set up summaries and saver\n saver = tf.train.Saver(\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\n summary_op = tf.summary.merge_all()\n\n # Initialize the graph\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n\n # Need to initialize both of these if supplying num_epochs to inputs\n sess.run(tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer()))\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\n\n # Set up exemplar threading\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # Start training loop\n np.save(config.train_checkpoint, config)\n step, val_max, losses = 0, 0, []\n train_acc = 0\n try:\n while not coord.should_stop():\n start_time = time.time()\n _, loss_value, train_acc = sess.run([train_op, cost, train_score])\n losses.append(loss_value)\n duration = time.time() - start_time\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\n\n if step % 100 == 0 and step % 10 == 0:\n if validation_data is not False:\n _, val_acc, val_frame = sess.run(\n [train_op, val_score, val_pred])\n\n np.save(\n os.path.join(\n config.model_output, '%s_val_image' % step),\n val_frame)\n else:\n val_acc = -1 # Store every checkpoint\n\n # Summaries\n summary_str = sess.run(summary_op)\n summary_writer.add_summary(summary_str, step)\n\n # Training status and validation accuracy\n format_str = (\n '%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training r = %s | '\n 'Validation r = %s | logdir = %s')\n print (format_str % (\n datetime.now(), step, loss_value,\n config.train_batch / duration, float(duration),\n train_acc, val_acc, config.summary_dir))\n\n # Save the model checkpoint if it's the best yet\n if val_acc > val_max:\n saver.save(\n sess, os.path.join(\n config.train_checkpoint,\n 'model_' + str(step) + '.ckpt'), global_step=step)\n\n # Store the new max validation accuracy\n val_max = val_acc\n\n else:\n # Training status\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; '\n '%.3f sec/batch) | Training F = %s')\n print (format_str % (datetime.now(), step, loss_value,\n config.train_batch / duration,\n float(duration), train_acc))\n # End iteration\n step += 1\n\n except tf.errors.OutOfRangeError:\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\n finally:\n coord.request_stop()\n\n dt_stamp = get_dt() # date-time stamp\n np.save(\n os.path.join(\n config.tfrecord_dir, '%straining_loss' % dt_stamp), losses)\n coord.join(threads)\n sess.close()",
"def _build_models(self):\n with tf.variable_scope('model'):\n meval = Model(self.hparams, mode='test')\n meval.build()\n self._saver = meval.saver\n\n self.meval = meval",
"def _train_model(self):\n self.experiment = EpisodicExperiment(self.task, self.agent)\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\n logger.debug(\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\"\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\n for i in range(n_epochs):\n logger.debug(\"RL epoch {}\".format(i))\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\n self.agent.learn()\n self.agent.reset() # reset buffers",
"def final_eval(self):\n # Test performance - Load best model\n self.load_model(self.best_model_path, model_type='best')\n logging.info(\"Loading best model after epoch: %d\" %\n self.train_info['epoch'])\n\n perf_file = path.join(self.model_dir, \"perf.json\")\n if self.slurm_id:\n parent_dir = path.dirname(path.normpath(self.model_dir))\n perf_dir = path.join(parent_dir, \"perf\")\n if not path.exists(perf_dir):\n os.makedirs(perf_dir)\n perf_file = path.join(perf_dir, self.slurm_id + \".json\")\n\n output_dict = {'model_dir': self.model_dir}\n for key, val in vars(self.args).items():\n output_dict[key] = val\n\n for split in ['dev', 'test']:\n logging.info('\\n')\n logging.info('%s' % split.capitalize())\n result_dict = self.eval_model(split, final_eval=True)\n if split != 'test':\n logging.info('Calculated F1: %.3f' % result_dict['fscore'])\n\n output_dict[split] = result_dict\n\n json.dump(output_dict, open(perf_file, 'w'), indent=2)\n\n logging.info(\"Final performance summary at %s\" % perf_file)\n sys.stdout.flush()",
"def evaluate(self, test_data):\n result = self.model.run(test_data)\n self._save_result(result)",
"def create_model():\r\n parser = argparse.ArgumentParser()\r\n parser.add_argument('--DISC_LR', type=float, default=1e-4)\r\n parser.add_argument('--GEN_LR', type=float, default=1e-3)\r\n parser.add_argument('--GEN_BETA1', type=float, default=0.9)\r\n parser.add_argument('--GEN_BETA2', type=float, default=0.999)\r\n parser.add_argument('--IMAGE_SIZE', type=int, default=None)\r\n parser.add_argument('--QUES_SIZE', type=int, default=None)\r\n parser.add_argument('--QUES_EMBED_SIZE', type=int, default=2048)\r\n parser.add_argument('--WORD_EMBED_SIZE', type=int, default=512)\r\n parser.add_argument('--VOCAB_SIZE', type=int, default=1004)\r\n args, task_args = parser.parse_known_args()\r\n override_if_not_in_args('--max_steps', '1000', task_args)\r\n override_if_not_in_args('--batch_size', '64', task_args)\r\n override_if_not_in_args('--eval_set_size', '370', task_args)\r\n override_if_not_in_args('--eval_interval_secs', '2', task_args)\r\n override_if_not_in_args('--log_interval_secs', '2', task_args)\r\n override_if_not_in_args('--min_train_eval_rate', '2', task_args)\r\n\r\n return Model(args.DISC_LR, args.GEN_LR, args.GEN_BETA1, args.GEN_BETA2,\r\n args.IMAGE_SIZE, args.QUES_EMBED_SIZE, args.WORD_EMBED_SIZE,\r\n args.QUES_SIZE, args.VOCAB_SIZE), task_args",
"def init(self):\n inputs = self.inputs()\n outputs = self.outputs(inputs)\n self.model = tf.keras.Model(inputs=inputs, outputs=outputs)\n self.model.compile(optimizer=self.optimizer() or self.config.get('optimizer'),\n loss=self.loss() or None,\n metrics=self.metrics() or None,\n loss_weights=self.loss_weights() or None,\n weighted_metrics=self.weighted_metrics() or None,\n target_tensors=self.target_tensors() or None)\n if self.config.get('debug'):\n self.model.summary()",
"def evaluate():\n log.info('Loading dev data...')\n if args.version_2:\n dev_data = SQuAD('dev', version='2.0')\n else:\n dev_data = SQuAD('dev', version='1.1')\n (_, _), (data_file_name, _) \\\n = dev_data._data_file[dev_data._version][dev_data._segment]\n dev_data_path = os.path.join(dev_data._root, data_file_name)\n\n if args.debug:\n sampled_data = [dev_data[0], dev_data[1], dev_data[2]]\n dev_data = mx.gluon.data.SimpleDataset(sampled_data)\n log.info('Number of records in dev data: %d', len(dev_data))\n\n dev_data_features = preprocess_dataset(\n tokenizer, dev_data, vocab=vocab, max_seq_length=args.max_seq_length,\n doc_stride=args.doc_stride, num_workers=args.num_workers,\n max_query_length=args.max_query_length, load_from_pickle=args.load_pickle,\n feature_file=args.dev_dataset_file)\n\n dev_data_input = convert_full_features_to_input_features(dev_data_features)\n log.info('The number of examples after preprocessing: %d', len(dev_data_input))\n\n dev_dataloader = mx.gluon.data.DataLoader(dev_data_input, batchify_fn=batchify_fn,\n num_workers=4, batch_size=args.test_batch_size,\n shuffle=False, last_batch='keep')\n\n log.info('start prediction')\n\n all_results = collections.defaultdict(list)\n\n epoch_tic = time.time()\n total_num = 0\n for (batch_id, data) in enumerate(dev_dataloader):\n data_list = list(split_and_load(data, ctx))\n for splited_data in data_list:\n example_ids, inputs, token_types, valid_length, p_mask, _, _, _ = splited_data\n total_num += len(inputs)\n outputs = net_eval(inputs, token_types, valid_length, p_mask=p_mask)\n example_ids = example_ids.asnumpy().tolist()\n for c, example_ids in enumerate(example_ids):\n result = RawResultExtended(start_top_log_probs=outputs[0][c].asnumpy().tolist(),\n start_top_index=outputs[1][c].asnumpy().tolist(),\n end_top_log_probs=outputs[2][c].asnumpy().tolist(),\n end_top_index=outputs[3][c].asnumpy().tolist(),\n cls_logits=outputs[4][c].asnumpy().tolist())\n all_results[example_ids].append(result)\n if batch_id % args.log_interval == 0:\n log.info('Batch: %d/%d', batch_id + 1, len(dev_dataloader))\n\n epoch_toc = time.time()\n log.info('Time cost=%2f s, Thoughput=%.2f samples/s', epoch_toc - epoch_tic,\n total_num / (epoch_toc - epoch_tic))\n\n log.info('Get prediction results...')\n\n all_predictions = collections.OrderedDict()\n all_nbest_json = collections.OrderedDict()\n scores_diff_json = collections.OrderedDict()\n for features in dev_data_features:\n results = all_results[features[0].example_id]\n example_qas_id = features[0].qas_id\n score_diff, best_non_null_entry, nbest_json = predict_extended(\n features=features, results=results, n_best_size=args.n_best_size,\n max_answer_length=args.max_answer_length, start_n_top=args.start_top_n,\n end_n_top=args.end_top_n)\n scores_diff_json[example_qas_id] = score_diff\n all_predictions[example_qas_id] = best_non_null_entry\n all_nbest_json[example_qas_id] = nbest_json\n\n output_prediction_file = os.path.join(args.output_dir, 'predictions.json')\n output_nbest_file = os.path.join(args.output_dir, 'nbest_predictions.json')\n output_null_log_odds_file = os.path.join(args.output_dir, 'null_odds.json')\n\n with open(output_prediction_file, 'w') as writer:\n writer.write(json.dumps(all_predictions, indent=4) + '\\n')\n with open(output_nbest_file, 'w') as writer:\n writer.write(json.dumps(all_nbest_json, indent=4) + '\\n')\n with open(output_null_log_odds_file, 'w') as writer:\n writer.write(json.dumps(scores_diff_json, indent=4) + '\\n')\n\n if os.path.exists(sys.path[0] + '/evaluate-v2.0.py'):\n arguments = [\n dev_data_path, output_prediction_file, '--na-prob-thresh',\n str(args.null_score_diff_threshold)\n ]\n if args.version_2:\n arguments += ['--na-prob-file', output_null_log_odds_file]\n subprocess.call([sys.executable, sys.path[0] + '/evaluate-v2.0.py'] + arguments)\n else:\n log.info('Please download evaluate-v2.0.py to get evaluation results for SQuAD. '\n 'Check index.rst for the detail.')",
"def train_and_eval(model_dir, model_type, train_steps, train_data, test_data, train_embeddings_file_name, test_embeddings_file_name, positive_labels, combination_method, method):\n \n index_map, weights = wvd.load(train_embeddings_file_name)\n #Get positive labels\n positive_labels = positive_labels.split(',')\n \n print(\"reading data...\")\n train_file_name = train_data \n df_train = pd.read_table(train_file_name, dtype={'node1':str, 'node2':str})\n df_train = df_train.sample(frac=1)\n\n # remove NaN elements\n df_train = df_train.dropna(how='any', axis=0)\n \n df_train[LABEL_COLUMN] = (\n df_train[\"label\"].apply(lambda x: label_func(x, positive_labels))).astype(int)\n\n model_dir = tempfile.mkdtemp() if not model_dir else model_dir\n print(\"model directory = %s\" % model_dir)\n \n train_x, _, train_y, _ = get_input(df_train, weights, index_map, combination_method)\n \n print(\"\\nBuilding model...\")\n m = build_estimator(model_dir, model_type, weights, index_map, combination_method)\n \n print(\"\\nTraining model...\")\n if model_type == \"regressor\":\n m.fit(train_x, train_y, n_epoch=train_steps, show_metric=True, snapshot_epoch=False)\n \n print(\"\\nTesting model...\")\n index_map, weights = wvd.load(test_embeddings_file_name)\n \n print(\"reading data...\")\n test_file_name = test_data\n df_test = pd.read_table(test_file_name, dtype={'node1':str, 'node2':str})\n df_test = df_test.sample(frac=1)\n\n # remove NaN elements\n df_test = df_test.dropna(how='any', axis=0)\n \n df_test[LABEL_COLUMN] = (\n df_test[\"label\"].apply(lambda x: label_func(x, positive_labels))).astype(int)\n \n if model_type == \"regressor\":\n test_x, test_original_y, test_index_y, test_original_x = get_input(df_test, weights, index_map, combination_method, data_purpose='test')\n node_sets = get_node_sets(test_original_x, test_original_y)\n \n print(\"\\nPredicting:\")\n model_predictions = m.predict(test_x)\n model_predictions = list(model_predictions)\n #Covert back to 1 and 0\n predictions = []\n model_predictions_probs = []\n for prediction in model_predictions:\n predictions.append(prediction[1]) #non-thresholded value of positve class\n model_predictions_probs.append(prediction[1])\n \n k = int(len([i for i in test_original_y if i == 1]) * 0.3)\n do_evaluations([x for x in test_original_x], [y for y in test_original_y], [p for p in predictions], k, node_sets, \n positive_labels, model=m, weights=weights, index_map=index_map, combination_method=combination_method)\n #Uncomment to log ranked links\n #log_predictions([x for x in test_original_x], [y for y in test_original_y], [p for p in predictions], k, node_sets, \n # positive_labels, model=m, weights=weights, index_map=index_map, combination_method=combination_method,\n # outfilename=combination_method, method=method)",
"def evaluate(args):\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\n dataset_params = putils.load_params(dataset_param_filepath)\n source_vocab_filepath = os.path.join(args.model, 'source.vocab')\n source_vocab = Vocab(vocab_filepath=source_vocab_filepath)\n target_vocab_filepath = os.path.join(args.model, 'target.vocab')\n target_vocab = Vocab(vocab_filepath=target_vocab_filepath)\n model_params_filepath = os.path.join(args.model, 'model.params')\n model_params = putils.load_params(model_params_filepath)\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\n if not torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location=const.DEVICE)\n elif torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath)\n elif torch.cuda.is_available() and not model_params['cuda']:\n logger.info('Loading a CPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location='cuda:0')\n else:\n logger.info('Loading a CPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath)\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\n input_size=checkpoint['encoder']['input_size'],\n hidden_size=checkpoint['encoder']['hidden_size'],\n num_layers=checkpoint['encoder']['num_layers'],\n nonlinearity=checkpoint['encoder']['nonlinearity'],\n bias=checkpoint['encoder']['bias'],\n dropout=checkpoint['encoder']['dropout'],\n bidirectional=checkpoint['encoder']['bidirectional'])\n if checkpoint['with_attention']:\n decoder = Attention(model_type=checkpoint['decoder']['model_type'],\n hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n max_seq_len=dataset_params['max_seq_len'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'],\n bidirectional=checkpoint['decoder']['bidirectional'])\n else:\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\n hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'],\n bidirectional=checkpoint['decoder']['bidirectional'])\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\n if torch.cuda.is_available():\n encoder.to(const.DEVICE)\n decoder.to(const.DEVICE)\n encoder.eval()\n decoder.eval()\n indexes = putils.index_dataset(\n args.data, source_vocab.item2idx, target_vocab.item2idx,\n dataset_params['is_character_based'], dataset_params['max_seq_len'],\n dataset_params['is_reversed'])\n if args.random > 0:\n random.shuffle(indexes)\n for seq_num in range(args.random):\n seq = indexes[seq_num]\n print('-'*80)\n print('>', ' '.join([source_vocab.idx2item[idx]\n for idx in seq[0]]))\n print('=', ' '.join([target_vocab.idx2item[idx]\n for idx in seq[1]]))\n # TODO: add support for OOV\n predicted_idx, _ = _decode(seq[0], encoder, decoder,\n checkpoint['with_attention'],\n dataset_params['max_seq_len'])\n print('<', ' '.join([target_vocab.idx2item[idx]\n for idx in predicted_idx]))\n else:\n _evaluate(indexes, encoder, decoder, target_vocab, checkpoint,\n dataset_params)",
"def main(database_filepath,model_filepath):\n X_train, X_test, y_train, y_test = load_data(database_filepath)\n \n print(X_train.shape,y_train.shape)\n \n print('Building model...')\n model = build_pipeline()\n \n print('Training model...')\n model.fit(X_train, y_train)\n \n print('Evaluating model...')\n evaluate_model(model, X_test, y_test)\n\n print('Saving model...')\n save_model(model, model_filepath)\n\n print('Trained model saved!')",
"def __train_model(self):\n logger.info(\"Training the ALS model...\")\n self.model = ALS.train(self.ratings_RDD, self.rank, seed=self.seed,\n iterations=self.iterations, lambda_=self.regularization_parameter)\n logger.info(\"ALS model built!\")",
"def __train_model(self):\n logger.info(\"Training the ALS model...\")\n self.model = ALS.train(self.ratings_RDD, self.rank, seed=self.seed,\n iterations=self.iterations, lambda_=self.regularization_parameter)\n logger.info(\"ALS model built!\")",
"def train_and_evaluate(name, model, train, test, evaluation, final_eval, output_dir):\n\n print(\"---\" * 5)\n print(\"Running pipeline for {}\".format(name))\n\n plot_dir = os.path.join(output_dir, \"plots\")\n\n pipeline = make_pipeline(model)\n\n X_train, y_train = train.drop(\n [\"PM10\"], axis=1).values, train[\"PM10\"].values\n X_test, y_test = test.drop([\"PM10\"], axis=1).values, test[\"PM10\"].values\n X_eval, y_eval = evaluation.drop(\n [\"PM10\"], axis=1).values, evaluation[\"PM10\"].values\n X_final, y_final = final_eval.drop(\n [\"PM10\"], axis=1), final_eval[\"PM10\"].values\n\n # first round - fit on train, predict on test\n print(\"Fitting pipeline on train data\")\n pipeline.fit(X_train, y_train)\n yhat = pipeline.predict(X_test)\n mae = mean_absolute_error(y_test, yhat)\n print(\"MAE: {}\".format(mae))\n plot_predictions(\n y_test, yhat, title=\"{} - Predicted vs. Actual on Test\".format(name), output_dir=plot_dir)\n\n # second round - fit on train + test, predict on evaluation\n X_train = np.concatenate([X_train, X_test])\n y_train = np.concatenate([y_train, y_test])\n print(\"Fitting pipeline on train + test data\")\n pipeline.fit(X_train,y_train)\n yhat = pipeline.predict(X_eval)\n mae = mean_absolute_error(y_eval,yhat)\n print(\"MAE: {}\".format(mae))\n plot_predictions(y_eval,yhat,title=\"{} - Predicted vs. Actual on Evaluation\".format(name),output_dir=plot_dir)\n\n # final round - fit on last X hours, by which the actual score will be measured\n X_train = np.concatenate([X_train, X_eval])\n y_train = np.concatenate([y_train, y_eval])\n print(\"Fitting pipeline on all \\\"all available data\\\"\")\n pipeline.fit(X_train, y_train)\n yhat = pipeline.predict(X_final)\n mae = mean_absolute_error(y_final, yhat)\n print(\"MAE: {}\".format(mae))\n plot_predictions(\n y_final, yhat, title=\"{} - Predicted vs. Actual\".format(name), output_dir=plot_dir)\n\n # save the model\n joblib.dump(model, os.path.join(\n output_dir, \"models\", \"{}.joblib\".format(name)))\n\n return yhat, mae",
"def _prepare_evaluate(self):\n labels = list()\n labels += ['num_procs', 'num_periods', 'is_debug', 'seed_emax', 'seed_sim']\n labels += ['num_draws_emax', 'num_agents_sim', 'num_types', 'edu_spec', 'version']\n labels += ['num_draws_prob', 'seed_prob']\n num_procs, num_periods, is_debug, seed_emax, seed_sim, num_draws_emax, num_agents_sim, \\\n num_types, edu_spec, version, num_draws_prob, seed_prob = \\\n dist_class_attributes(self.respy_base, *labels)\n\n periods_draws_emax = create_draws(num_periods, num_draws_emax, seed_emax, is_debug)\n periods_draws_sims = create_draws(num_periods, num_agents_sim, seed_sim, is_debug)\n\n disturbances = (periods_draws_emax, periods_draws_sims)\n\n # We want to maintain a pure PYTHON version for testing purposes.\n args = list()\n args += [num_periods, num_types, edu_spec['start'], edu_spec['max'], edu_spec['max'] + 1]\n state_space_info = respy_f2py.wrapper_create_state_space(*args)\n if self.mpi_setup == MISSING_INT:\n slavecomm = self.mpi_setup\n else:\n slavecomm = self.mpi_setup.py2f()\n self.set_up_baseline(periods_draws_emax, None)\n\n initial_conditions = get_initial_conditions(self.respy_base)\n\n args = (smm_sample_f2py, state_space_info, initial_conditions, disturbances, slavecomm)\n self.simulate_sample = partial(*args)",
"def evaluate(args, model, tokenizer, eval_dataset, eval_dataloader, task_name, model_type, split, step):\n model.eval()\n processor = MoralStoriesProcessor()\n results = dict()\n softmax = torch.nn.Softmax(dim=1)\n\n # Eval!\n logger.info('***** Running evaluation on the validation / test set *****')\n logger.info(' Num examples = %d', len(eval_dataset))\n logger.info(' Batch size = %d', args.eval_batch_size)\n batch_losses = list()\n eval_loss = 0.0\n micro_loss, macro_loss = 0.0, 0.0\n num_batches, num_tokens = 0, 0\n preds = None\n soft_preds = None\n out_label_ids = None\n # Perform a single evaluation step\n for batch in tqdm(eval_dataloader, desc='Evaluating', mininterval=10, ncols=100):\n batch = tuple(t.to(args.device) for t in batch)\n with torch.no_grad():\n if 'gen' not in task_name:\n inputs = {'input_ids': batch[0],\n 'attention_mask': batch[1],\n 'token_type_ids': batch[2] if model_type == 'bert' else None,\n 'labels': batch[3]}\n else:\n inputs = {'input_ids': batch[0],\n 'attention_mask': batch[1],\n 'labels': batch[3]}\n if 'gpt2' not in model_type:\n # Prepare decoder inputs and labels for enc-dec models\n inputs['labels'] = batch[3][:, 1:].contiguous() # shift\n decoder_input_ids = batch[3][:, :-1].clone() # shift\n decoder_input_ids[decoder_input_ids == -100] = tokenizer.pad_token_id # remove masking\n inputs['decoder_input_ids'] = decoder_input_ids.contiguous()\n\n outputs = model(**inputs)\n\n tmp_eval_loss, logits = outputs[:2]\n soft_logits = softmax(logits)\n eval_loss += tmp_eval_loss.mean().item()\n batch_losses.append(tmp_eval_loss.item())\n\n if 'gen' not in task_name:\n if preds is None:\n preds = logits.detach().cpu().numpy()\n soft_preds = soft_logits.detach().cpu().numpy()\n out_label_ids = inputs['labels'].detach().cpu().numpy()\n else:\n preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)\n soft_preds = np.append(soft_preds, soft_logits.detach().cpu().numpy(), axis=0)\n out_label_ids = np.append(out_label_ids, inputs['labels'].detach().cpu().numpy(), axis=0)\n else:\n # Obtain per-token loss for perplexity computation\n batch_loss = get_token_loss(args, logits, batch[3], batch[4], model_type=model_type)\n macro_loss += batch_loss.mean().item()\n micro_loss += batch_loss.sum().item()\n num_batches += 1\n num_tokens += batch_loss.view(-1).shape[0]\n\n # Compute and update evaluation metric values\n if 'gen' not in task_name:\n # Isolate model predictions\n preds = np.argmax(preds, axis=1)\n soft_preds = soft_preds.tolist()\n curr_result = compute_cls_metrics(preds, out_label_ids)\n else:\n macro_perplexity = torch.exp(torch.tensor(macro_loss / num_batches)).item()\n micro_perplexity = torch.exp(torch.tensor(micro_loss / num_tokens)).item()\n curr_result = {'macro_perplexity': macro_perplexity,\n 'micro_perplexity': micro_perplexity}\n\n if len(results.keys()) == 0:\n for k, v in curr_result.items():\n results[k] = [v]\n else:\n for k, v in curr_result.items():\n results[k].append(v)\n\n # Log metrics\n output_eval_file = os.path.join(args.output_dir, 'results_{}_{}.txt'.format(task_name, split))\n with open(output_eval_file, 'a') as writer:\n logger.info('***** Eval results *****')\n writer.write('STEP: {:s}\\n'.format(str(step)))\n for key in sorted(curr_result.keys()):\n logger.info(' %s = %s', key, str(curr_result[key]))\n writer.write('%s = %s\\n' % (key, str(curr_result[key])))\n\n # Log predictions\n if 'gen' not in task_name:\n output_pred_file = \\\n os.path.join(args.output_dir, 'predictions_{}_{}_{}.lst'.format(task_name, split, step))\n with open(output_pred_file, 'w') as writer:\n logger.info('***** Write predictions *****')\n for pred in preds:\n writer.write('{}\\n'.format(processor.get_labels()[pred]))\n\n # Maintain a single metrics file\n if os.path.exists(args.output_dir):\n with open(os.path.join(args.output_dir, 'metrics_{}_{}.json'.format(task_name, split)), 'w') as f:\n f.write(json.dumps(results))\n f.close()\n\n # Report mean dev loss\n mean_eval_loss = eval_loss / len(eval_dataloader)\n logging.info('\\n' + '*' * 10)\n logging.info('Mean development loss: {:.4f}'.format(mean_eval_loss))\n logging.info('*' * 10 + '\\n')\n\n return results, mean_eval_loss, preds, soft_preds",
"def run_step(self):\n assert self.model.training, \"[SimpleTrainer] model was changed to eval mode!\"\n start = time.perf_counter()\n \"\"\"\n If your want to do something with the data, you can wrap the dataloader.\n \"\"\"\n data = next(self._data_loader_iter)\n data_time = time.perf_counter() - start\n\n \"\"\"\n If your want to do something with the losses, you can wrap the model.\n \"\"\"\n loss_dict = self.model(data)\n losses = sum(loss for loss in loss_dict.values())\n self._detect_anomaly(losses, loss_dict)\n\n metrics_dict = loss_dict\n metrics_dict[\"data_time\"] = data_time\n self._write_metrics(metrics_dict)\n \n validation_data = next(self.validation_data_loader_iter)\n val_losses_dict = self.model(validation_data)\n val_losses = sum(loss for loss in val_losses_dict.values())\n self._detect_anomaly(val_losses, val_losses_dict)\n\n val_metrics_dict = val_losses_dict\n val_metrics_dict[\"data_time\"] = data_time\n self._write_validation_metrics(val_metrics_dict)\n\n \"\"\"\n If you need accumulate gradients or something similar, you can\n wrap the optimizer with your custom `zero_grad()` method.\n \"\"\"\n self.optimizer.zero_grad()\n losses.backward()\n\n \"\"\"\n If you need gradient clipping/scaling or other processing, you can\n wrap the optimizer with your custom `step()` method.\n \"\"\"\n self.optimizer.step()",
"def build_model():",
"def main():\n model = Calculator()",
"def create_model(self) -> None:\n self._model = create_model_with_temperature_scaling(self.config)",
"def create_model(self):\n try:\n self.model = PPO2.load(self.save_path)\n self.model.set_env(self.env)\n print(\"Loading of the latest model successful!\")\n except:\n print(\"Creating new model...\")\n self.model = PPO2(CnnPolicy, self.env, verbose=1)",
"def build(self):\n\n if self.model is not None:\n warnings.warn('Model is not empty and was already trained.\\n'\n 'Run purge method for deleting the model variable',\n Warning)\n\n self.purge()\n self.model = Sequential()\n for layer in self.layers:\n self.model.add(layer.toKerasFn())\n\n self.model.compile(optimizer=self.optimizer.toKerasFn(),\n loss=self.loss,\n metrics=self.metrics\n )",
"def build(self):\n\n if self.model is not None:\n warnings.warn('Model is not empty and was already trained.\\n'\n 'Run purge method for deleting the model variable',\n Warning)\n\n self.purge()\n self.model = Sequential()\n for layer in self.layers:\n self.model.add(layer.toKerasFn())\n\n self.model.compile(optimizer=self.optimizer.toKerasFn(),\n loss=self.loss,\n metrics=self.metrics\n )",
"def create_eval_model(model_creator, hparams, scope=None, extra_args=None):\n vocab_file = hparams.vocab_file\n graph = tf.Graph()\n\n with graph.as_default(), tf.container(scope or \"eval\"):\n vocab_table = vocab_utils.create_vocab_tables(vocab_file)[0]\n data_file_placeholder = tf.placeholder(shape=(), dtype=tf.string)\n kb_file_placeholder = tf.placeholder(shape=(), dtype=tf.string)\n data_dataset = tf.data.TextLineDataset(data_file_placeholder)\n kb_dataset = tf.data.TextLineDataset(kb_file_placeholder)\n # this is the eval_actual iterator\n eval_iterator = iterator_utils.get_iterator(\n data_dataset,\n kb_dataset,\n vocab_table,\n batch_size=hparams.batch_size,\n t1=hparams.t1.encode(),\n t2=hparams.t2.encode(),\n eod=hparams.eod,\n len_action=hparams.len_action,\n random_seed=hparams.random_seed,\n num_buckets=hparams.num_buckets,\n max_dialogue_len=hparams.max_dialogue_len)\n # this is the placeholder iterator\n handle = tf.placeholder(tf.string, shape=[])\n iterator = tf.data.Iterator.from_string_handle(\n handle, eval_iterator.output_types, eval_iterator.output_shapes)\n batched_iterator = iterator_utils.get_batched_iterator(iterator)\n\n model = model_creator(\n hparams,\n iterator=batched_iterator,\n handle=handle,\n mode=tf.estimator.ModeKeys.EVAL,\n vocab_table=vocab_table,\n scope=scope,\n extra_args=extra_args)\n\n return EvalModel(\n graph=graph,\n model=model,\n placeholder_iterator=iterator,\n placeholder_handle=handle,\n eval_iterator=eval_iterator,\n data_file_placeholder=data_file_placeholder,\n kb_file_placeholder=kb_file_placeholder)",
"def main(args):\r\n\r\n # Logging info\r\n formatter = logging.Formatter('%(asctime)s %(levelname)s - '\r\n '%(funcName)s: %(message)s',\r\n '%H:%M:%S')\r\n logger = logging.getLogger(__name__)\r\n logger.setLevel('INFO')\r\n stream = logging.StreamHandler()\r\n stream.setLevel('INFO')\r\n stream.setFormatter(formatter)\r\n logger.addHandler(stream)\r\n\r\n set_seed(args.seed)\r\n device = torch.device(\r\n 'cuda' if torch.cuda.is_available() and args.cuda else 'cpu')\r\n model_name = f'{args.name}_lr{args.lr}_z{args.latent_dim}' \\\r\n + f'_h{args.hidden_dim}_p{args.p_dropout}'\r\n model_dir = os.path.join(args.results, model_name)\r\n logger.info(f'Directory for saving and loading models: {model_dir}')\r\n\r\n if not args.eval:\r\n # Model directory\r\n new_model_dir(model_dir, logger=logger)\r\n\r\n # Dataloaders\r\n train_loader, valid_loader = get_dataloaders(\r\n args.data, args.t_hours, args.n_bins,\r\n validation=True, dynamic=args.dynamic,\r\n batch_size=args.bs, logger=logger)\r\n logger.info(\r\n f'Train {args.model_type}-{args.t_hours} ' +\r\n f'with {len(train_loader.dataset)} samples')\r\n\r\n # Load model\r\n n_tokens = len(np.load(\r\n os.path.join(\r\n args.data, '_dicts', f'{args.t_hours}_{args.n_bins}.npy'),\r\n allow_pickle=True).item())\r\n model = init_model(\r\n args.model_type, n_tokens, args.latent_dim, args.hidden_dim,\r\n p_dropout=args.p_dropout, dt=args.dt,\r\n weighted=args.weighted, dynamic=args.dynamic)\r\n logger.info(f'#params in model: {get_n_param(model)}')\r\n\r\n # Optimizer\r\n optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\r\n loss_f = BCE()\r\n model = model.to(device)\r\n\r\n # Training\r\n trainer = Trainer(\r\n model, loss_f, optimizer,\r\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\r\n trainer.train(\r\n train_loader, valid_loader,\r\n epochs=args.epochs, early_stopping=args.early_stopping)\r\n\r\n # Save model\r\n metadata = vars(args)\r\n metadata['n_tokens'] = n_tokens\r\n save_model(trainer.model, model_dir, metadata=metadata)\r\n\r\n if args.test:\r\n # Load model\r\n model = load_model(model_dir, is_gpu=args.cuda)\r\n metadata = load_metadata(model_dir)\r\n\r\n # Dataloader\r\n test_loader, _ = get_dataloaders(\r\n metadata['data'], metadata['t_hours'], metadata['n_bins'],\r\n validation=False, dynamic=metadata['dynamic'], batch_size=128,\r\n shuffle=False, logger=logger)\r\n\r\n # Evaluate\r\n loss_f = BCE()\r\n evaluator = Trainer(\r\n model, loss_f,\r\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\r\n evaluator._valid_epoch(test_loader)",
"def evaluate(args):\n dataset_param_filepath = os.path.join(args.model, 'dataset.params')\n dataset_params = putils.load_params(dataset_param_filepath)\n left_vocab_filepath = os.path.join(args.model, 'left.vocab')\n left_vocab = Vocab(vocab_filepath=left_vocab_filepath)\n right_vocab_filepath = os.path.join(args.model, 'right.vocab')\n right_vocab = Vocab(vocab_filepath=right_vocab_filepath)\n model_params_filepath = os.path.join(args.model, 'model.params')\n model_params = putils.load_params(model_params_filepath)\n checkpoint_filepath = os.path.join(args.model, 'checkpoint.tar')\n if not torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location=const.DEVICE)\n elif torch.cuda.is_available() and model_params['cuda']:\n logger.info('Loading a GPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath)\n elif torch.cuda.is_available() and not model_params['cuda']:\n logger.info('Loading a CPU-trained model on GPU')\n checkpoint = torch.load(checkpoint_filepath,\n map_location='cuda:0')\n else:\n logger.info('Loading a CPU-trained model on CPU')\n checkpoint = torch.load(checkpoint_filepath)\n if checkpoint['encoder']['model_type'] == 'transformer':\n encoder = TEncoder(input_size=checkpoint['encoder']['input_size'],\n hidden_size=checkpoint['encoder']['hidden_size'],\n num_layers=checkpoint['encoder']['num_layers'],\n dropout=checkpoint['encoder']['dropout'],\n num_attention_heads=checkpoint['encoder']['num_attention_heads'])\n else:\n encoder = Encoder(model_type=checkpoint['encoder']['model_type'],\n input_size=checkpoint['encoder']['input_size'],\n hidden_size=checkpoint['encoder']['hidden_size'],\n num_layers=checkpoint['encoder']['num_layers'],\n nonlinearity=checkpoint['encoder']['nonlinearity'],\n bias=checkpoint['encoder']['bias'],\n dropout=checkpoint['encoder']['dropout'],\n bidirectional=checkpoint['encoder']['bidirectional'])\n if checkpoint['decoder']['model_type'] == 'transformer':\n decoder = TDecoder(hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n num_layers=checkpoint['decoder']['num_layers'],\n dropout=checkpoint['decoder']['dropout'],\n num_attention_heads=checkpoint['decoder']['num_attention_heads'])\n elif checkpoint['decoder']['with_attention']:\n decoder = Attention(hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n max_seq_len=dataset_params['max_seq_len'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'])\n else:\n decoder = Decoder(model_type=checkpoint['decoder']['model_type'],\n hidden_size=checkpoint['decoder']['hidden_size'],\n output_size=checkpoint['decoder']['output_size'],\n num_layers=checkpoint['decoder']['num_layers'],\n nonlinearity=checkpoint['decoder']['nonlinearity'],\n bias=checkpoint['decoder']['bias'],\n dropout=checkpoint['decoder']['dropout'])\n encoder.load_state_dict(checkpoint['encoder_state_dict'])\n decoder.load_state_dict(checkpoint['decoder_state_dict'])\n if torch.cuda.is_available():\n encoder.to(const.DEVICE)\n decoder.to(const.DEVICE)\n encoder.eval()\n decoder.eval()\n pairs = putils.convert_to_seq_pairs(args.data)\n indexed_pairs = putils.index_pairs(pairs, left_vocab.char2idx,\n right_vocab.char2idx)\n if dataset_params['reverse']:\n indexed_pairs = [(y, x) for x, y in indexed_pairs]\n source_vocab = right_vocab\n target_vocab = left_vocab\n else:\n source_vocab = left_vocab\n target_vocab = right_vocab\n if args.random > 0:\n random.shuffle(indexed_pairs)\n for seq_num in range(args.random):\n seq = indexed_pairs[seq_num]\n print('-'*80)\n input_str = ' '.join(\n ''.join([source_vocab.idx2char[idx] for idx in seq[0] if idx\n not in [const.SOS_IDX, const.EOS_IDX]])\n .split(const.SEP))\n gold_str = ' '.join(\n ''.join([target_vocab.idx2char[idx] for idx in seq[1] if idx\n not in [const.SOS_IDX, const.EOS_IDX]])\n .split(const.SEP))\n predicted_idxx = decode(seq[0], args.itemize, encoder, decoder,\n dataset_params['max_seq_len'])\n pred_str = ' '.join(\n ''.join([target_vocab.idx2char[idx] for idx in predicted_idxx\n if idx not in [const.SOS_IDX, const.EOS_IDX]])\n .split(const.SEP))\n print('>', input_str)\n print('=', gold_str)\n print('<', pred_str)\n else:\n _evaluate(indexed_pairs, args.itemize, encoder, decoder,\n target_vocab.idx2char, dataset_params['max_seq_len'])",
"def build_model(self):\r\n self.images, self.labels = self.dataloader.get_model_inputs()\r\n\r\n model = SimpleModel(self.images, self.labels, output_dim=F.output_dim, scope='source_regressor')\r\n self.out, _ = model.get_model()\r\n self.get_loss()",
"def evaluate(X_test, y_test):\n # batch size is 16 for evaluation\n batch_size = 16\n\n # Load Model\n model = load_model('model/model.h5')\n return model.evaluate(X_test, y_test, batch_size, verbose = 1)",
"def launch_evaluations(self):\n self.report('Launching pending evaluations.')\n with self.optimizer() as opt:\n evals = {}\n evaluate_process = load_object(self.inputs.evaluate_process.value)\n for idx, inputs in opt.create_inputs().items():\n self.report('Launching evaluation {}'.format(idx))\n inputs_merged = ChainMap(inputs, self.inputs.get('evaluate', {}))\n if is_process_function(evaluate_process):\n _, node = run_get_node(evaluate_process, **inputs_merged)\n else:\n node = self.submit(evaluate_process, **inputs_merged)\n evals[self.eval_key(idx)] = node\n self.indices_to_retrieve.append(idx)\n return self.to_context(**evals)",
"def _execute(self):\n return self.model_cls.objects.create_model(**self.request_obj.data_params)",
"def __call__(self, predictor_model) -> None:\n self.save_result(self.evaluate(predictor_model))",
"def train(self):\n self.emission_model(self.train_data)\n self.transition_model(self.train_data)",
"def evaluate(model, datagen, X_test, Y_test, batch_size, save_folder_path=None):\n\n print(\"[INFO] Evaluating model...\")\n\n scores = model.evaluate_generator(\n datagen.flow(X_test, Y_test, batch_size=batch_size),\n verbose=1)\n \n print(\"[INFO] Evaluation results:\\n{0}: {1:.2f}\\n{2}: {3:.2f}\".format(model.metrics_names[0], scores[0]*100, model.metrics_names[1], scores[1]*100))\n \n if save_folder_path is not None:\n # Write results to path\n assert os.path.isdir(save_folder_path) == True, \"Unable to save evaluation results, save_folder_path is not a folder\"\n eval_results_path = save_folder_path + \"/eval_results.txt\"\n eval_handle = open(eval_results_path, 'w')\n eval_handle.write(\"Model name: {}\\n\\n\".format(MODEL_NAME))\n eval_handle.write(\"Evaluation results:\\n{0}: {1:.2f}\\n{2}: {3:.2f}\".format(model.metrics_names[0], scores[0]*100, model.metrics_names[1], scores[1]*100))\n eval_handle.close()",
"def __init__(\n self,\n model=None,\n parameterSpace=None,\n evalFunction=None,\n filename=None,\n saveAllModelOutputs=False,\n ncores=None,\n ):\n self.model = model\n if evalFunction is None and model is not None:\n self.evalFunction = self._runModel\n elif evalFunction is not None:\n self.evalFunction = evalFunction\n\n assert (evalFunction is not None) or (\n model is not None\n ), \"Either a model has to be specified or an evalFunction.\"\n\n assert parameterSpace is not None, \"No parameters to explore.\"\n\n if parameterSpace.kind == \"sequence\":\n assert model is not None, \"Model must be defined for sequential explore\"\n\n self.parameterSpace = parameterSpace\n self.exploreParameters = parameterSpace.dict()\n\n # TODO: use random ICs for every explored point or rather reuse the ones that are generated at model\n # initialization\n self.useRandomICs = False\n\n filename = filename or \"exploration.hdf\"\n self.filename = filename\n\n self.saveAllModelOutputs = saveAllModelOutputs\n\n # number of cores\n if ncores is None:\n ncores = multiprocessing.cpu_count()\n self.ncores = ncores\n logging.info(\"Number of processes: {}\".format(self.ncores))\n\n # bool to check whether pypet was initialized properly\n self.initialized = False\n self._initializeExploration(self.filename)\n\n self.results = None",
"def compile(self):\n self.train = self._make_train()\n self.loss_test = self._make_loss_test()\n self.predict = self._make_predict()",
"def run(self):\n\n self._logger.debug(\"Starting Dummy Model: modelID=%s;\" % (self._modelID))\n\n # =========================================================================\n # Initialize periodic activities (e.g., for model result updates)\n # =========================================================================\n periodic = self._initPeriodicActivities()\n\n self._optimizedMetricLabel = self._optimizeKeyPattern\n self._reportMetricLabels = [self._optimizeKeyPattern]\n\n # =========================================================================\n # Create our top-level loop-control iterator\n # =========================================================================\n if self._iterations >= 0:\n iterTracker = iter(xrange(self._iterations))\n else:\n iterTracker = iter(itertools.count())\n\n # =========================================================================\n # This gets set in the unit tests. It tells the worker to sys exit\n # the first N models. This is how we generate orphaned models\n doSysExit = False\n if self._sysExitModelRange is not None:\n modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)\n modelIDs = [x[0] for x in modelAndCounters]\n modelIDs.sort()\n (beg,end) = self._sysExitModelRange\n if self._modelID in modelIDs[int(beg):int(end)]:\n doSysExit = True\n\n if self._delayModelRange is not None:\n modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)\n modelIDs = [x[0] for x in modelAndCounters]\n modelIDs.sort()\n (beg,end) = self._delayModelRange\n if self._modelID in modelIDs[int(beg):int(end)]:\n time.sleep(10)\n \n # DEBUG!!!! infinite wait if we have 50 models\n #if len(modelIDs) >= 50:\n # jobCancel = self._jobsDAO.jobGetFields(self._jobID, ['cancel'])[0]\n # while not jobCancel:\n # time.sleep(1)\n # jobCancel = self._jobsDAO.jobGetFields(self._jobID, ['cancel'])[0]\n\n if self._errModelRange is not None:\n modelAndCounters = self._jobsDAO.modelsGetUpdateCounters(self._jobID)\n modelIDs = [x[0] for x in modelAndCounters]\n modelIDs.sort()\n (beg,end) = self._errModelRange\n if self._modelID in modelIDs[int(beg):int(end)]:\n raise RuntimeError(\"Exiting with error due to errModelRange parameter\")\n\n # =========================================================================\n # Delay, if necessary\n if self._delay is not None:\n time.sleep(self._delay)\n\n # =========================================================================\n # Run it!\n # =========================================================================\n self._currentRecordIndex = 0\n while True:\n\n # =========================================================================\n # Check if the model should be stopped\n # =========================================================================\n\n # If killed by a terminator, stop running\n if self._isKilled:\n break\n\n # If job stops or hypersearch ends, stop running\n if self._isCanceled:\n break\n\n # If model is mature, stop running ONLY IF we are not the best model\n # for the job. Otherwise, keep running so we can keep returning\n # predictions to the user\n if self._isMature:\n if not self._isBestModel:\n self._cmpReason = self._jobsDAO.CMPL_REASON_STOPPED\n break\n else:\n self._cmpReason = self._jobsDAO.CMPL_REASON_EOF\n\n # =========================================================================\n # Get the the next record, and \"write it\"\n # =========================================================================\n try:\n self._currentRecordIndex = next(iterTracker)\n except StopIteration:\n break\n\n # \"Write\" a dummy output value. This is used to test that the batched\n # writing works properly\n\n self._writePrediction(ModelResult(None, None, None, None))\n\n periodic.tick()\n\n # =========================================================================\n # Compute wait times. See if model should exit\n # =========================================================================\n\n if self.__shouldSysExit(self._currentRecordIndex):\n sys.exit(1)\n\n # Simulate computation time\n if self._busyWaitTime is not None:\n time.sleep(self._busyWaitTime)\n self.__computeWaitTime()\n\n # Asked to abort after so many iterations?\n if doSysExit:\n sys.exit(1)\n\n # Asked to raise a jobFailException?\n if self._jobFailErr:\n raise utils.JobFailException(\"E10000\",\n \"dummyModel's jobFailErr was True.\")\n\n # =========================================================================\n # Handle final operations\n # =========================================================================\n if self._doFinalize:\n if not self._makeCheckpoint:\n self._model = None\n\n # Delay finalization operation\n if self._finalDelay is not None:\n time.sleep(self._finalDelay)\n\n self._finalize()\n\n self._logger.info(\"Finished: modelID=%r \"% (self._modelID))\n\n return (self._cmpReason, None)",
"def train(self):\n self.log(f\"{self.cur_file_path}\\t\\tInfo: train method invoked!\")\n self.log(f\"{self.cur_file_path}\\t\\tInfo: training {self.model.__class__.__name__} model!\")\n\n self.model.fit(self.trainX, self.trainY)",
"def build(self):\n self.global_step = tf.train.get_or_create_global_step()\n self.build_network()\n if self.mode != tf.estimator.ModeKeys.PREDICT:\n self.build_losses()",
"def build(self):\n self.global_step = tf.train.get_or_create_global_step()\n self.build_network()\n if self.mode != tf.estimator.ModeKeys.PREDICT:\n self.build_losses()",
"def run(self, context):\n self.start()\n while not context.is_finished():\n self.update_predictions(context)\n new_results, instances = self.evaluate()\n if new_results:\n self.write_results(new_results, instances)\n self.update_plot(new_results, instances)\n\n if self.plot_file:\n self.visualizer.savefig(self.plot_file)\n if self.show_plot:\n self.visualizer.show()\n self.end()",
"def createModel(self):\n outputs, inputs = baseUNet(self.input_shape,\n self.conv_depth,\n self.n_classes,\n self.init_w,\n self.dropout)\n \n if self.regression == True:\n outputs = Lambda(getPropOfGround)(outputs)\n \n model = Model(inputs = inputs,outputs = outputs)\n \n model.compile(optimizer = self.optimizer,\n loss=self.loss_function,\n metrics=self.metrics)\n\n if self.old_weights != None:\n model.set_weights(self.old_weights)\n self.model = model",
"def main(config_json_file):\n with open(config_json_file, 'r') as config_json_obj:\n config_dict = json.load(config_json_obj)\n\n data_store = data_processor.DataStore()\n data_dict = data_store.get_data(normalize=config_dict['normalize'])\n\n train_x = data_dict['train']['data']\n train_y = data_dict['train']['labels']\n\n val_x = data_dict['val']['data']\n val_y = data_dict['val']['labels']\n\n test_x = data_dict['test']['data']\n test_y = data_dict['test']['labels']\n\n input_shape = (config_dict['batch_size'], train_x.shape[1])\n\n print(\"\\nCreating model...\")\n model = create_model_from_dict(config_dict, input_shape)\n print(\"Done.\")\n\n if model is not None:\n print(\"\\nTraining model...\")\n train_acc_list, val_acc_list = model.train(\n X=train_x,\n Y=train_y,\n lr=config_dict['learning_rate'],\n batch_size=config_dict['batch_size'],\n num_epochs=config_dict['num_epochs'],\n val_X=val_x,\n val_Y=val_y,\n print_loss=config_dict['print_acc'],\n save_dir=config_dict['save_dir']\n )\n print(\"Done.\")\n\n max_val_acc = max(val_acc_list)\n epoch_idx = val_acc_list.index(max_val_acc)\n print(\"Maximum validation accuracy is \" +\n str(max_val_acc) +\n \" at epoch #\" +\n str(epoch_idx + 1) +\n \". Training accuracy at that epoch is \" +\n str(train_acc_list[epoch_idx]))\n\n print(\"Calculating test accuracy...\")\n test_acc = util.get_accuracy(test_y, model.predict_classes(test_x))\n print(\"Test accuracy after \" +\n str(config_dict['num_epochs']) +\n \" epochs is \" +\n str(test_acc) + \".\")\n\n if config_dict['show_plot']:\n plot_train, = plt.plot(\n range(1, config_dict['num_epochs'] + 1),\n train_acc_list,\n label=\"Training Accuracy\"\n )\n plot_val, = plt.plot(\n range(1, config_dict['num_epochs'] + 1),\n val_acc_list,\n label=\"Validation Accuracy\"\n )\n plot_val.axes.set_xlabel('# Epochs')\n plot_val.axes.set_ylabel('% Accuracy')\n plt.legend(ncol=1, fancybox=True, shadow=True)\n plt.show(block=True)\n print(\"Plots have been displayed.\")",
"def train_model(self) -> Model:\n run = self.submit_experiment_run(wait_for_completion=self.wait_for_completion)\n model = run.register_model(\n model_name=self.model_name, model_path=self.model_path\n )\n return model",
"def run_defaultmodel(cls):\n\n model_params = {\n\n 'width': 200,\n\n 'height': 100,\n\n 'pop_total': 700,\n\n 'entrances': 3,\n\n 'entrance_space': 2,\n\n 'entrance_speed': .1,\n\n 'exits': 2,\n\n 'exit_space': 1,\n\n 'speed_min': .1,\n\n 'speed_desire_mean': 1,\n\n 'speed_desire_std': 1,\n\n 'separation': 2,\n\n 'batch_iterations': 900,\n\n 'do_save': True,\n\n 'do_ani': False,\n\n }\n\n # Run the model\n\n Model(model_params).batch()",
"def train(self):\n self.epoch = 0\n self.step = 0\n self.start_time = time.time()\n for self.epoch in range(self.num_epochs):\n print(\"EPOHA\")\n self.run_epoch()\n print(\"SAVE MODEL\")\n self.save_model()",
"def evaluate():\n with tf.Graph().as_default() as g:\n \n # Get hazy and clean images for SYNTHIA.\n val = FLAGS.val\n hazy_images, clean_images_ground_truth, _ = model_spec.input(val)\n\n # Build a Graph that computes the dehazed predictions from the\n # inference model.\n clean_images_predicted = model_spec.inference(hazy_images)\n\n # Calculate loss (only the data term).\n loss = model_spec.data_loss(clean_images_predicted, clean_images_ground_truth)\n\n # Restore the moving average version of the learned variables for eval.\n variable_averages = tf.train.ExponentialMovingAverage(\n model_spec.MOVING_AVERAGE_DECAY)\n variables_to_restore = variable_averages.variables_to_restore()\n saver = tf.train.Saver(variables_to_restore)\n\n # Build the summary operation based on the TF collection of Summaries.\n summary_op = tf.merge_all_summaries()\n\n summary_writer = tf.train.SummaryWriter(FLAGS.eval_dir, g)\n\n while True:\n eval_once(saver, summary_writer, loss, summary_op)\n if FLAGS.run_once:\n print('Finished one-off evaluation.')\n break\n time.sleep(FLAGS.eval_interval_secs)",
"def training_phase(self):\r\n self.train_dataloader = self.get_dataloader(\r\n hdf_path=self.train_h5_path,\r\n data_description=\"training set\"\r\n )\r\n self.valid_dataloader = self.get_dataloader(\r\n hdf_path=self.valid_h5_path,\r\n data_description=\"validation set\"\r\n )\r\n\r\n self.get_ts_properties()\r\n\r\n self.initialize_output_files()\r\n\r\n start_epoch, end_epoch = self.define_model_and_optimizer()\r\n\r\n print(\"* Beginning training.\", flush=True)\r\n n_processed_batches = 0\r\n for epoch in range(start_epoch, end_epoch):\r\n\r\n self.current_epoch = epoch\r\n n_processed_batches = self.train_epoch(n_processed_batches=n_processed_batches)\r\n\r\n # evaluate model every `sample_every` epochs (not every epoch)\r\n if epoch % self.C.sample_every == 0:\r\n self.evaluate_model()\r\n else:\r\n util.write_model_status(score=\"NA\") # score not computed\r\n\r\n self.print_time_elapsed()",
"def evaluate(self):\n self.training = False",
"def train_and_eval():\n # train_file_name = 'adult.data'\n # test_file_name = 'adult.test'\n train_file_name = 'poker-hand-testing.data'\n test_file_name = 'poker-hand-training-true.data'\n #test_file_name = maybe_download()\n df_train = pd.read_csv(\n tf.gfile.Open(\"/opt/tensor/race_result_clean.csv\"),\n names=COLUMNS,\n skipinitialspace=True,\n skiprows=1)\n df_test = pd.read_csv(\n tf.gfile.Open(\"/opt/tensor/race_result_clean.csv\"),\n names=COLUMNS,\n skipinitialspace=True,\n skiprows=1)\n\n #df_train[LABEL_COLUMN] = (df_train[\"CLASS_Poker_Hand\"].apply(lambda x: x>5)).astype(int)\n #df_test[LABEL_COLUMN] = (df_test[\"CLASS_Poker_Hand\"].apply(lambda x: x>5)).astype(int)\n\n model_dir = tempfile.mkdtemp() if not FLAGS.model_dir else FLAGS.model_dir\n print(\"model directory = %s\" % model_dir)\n m = build_estimator(model_dir)\n print(m)\n m.fit(input_fn=lambda: input_fn(df_train), steps=FLAGS.train_steps)\n results = m.evaluate(input_fn=lambda: input_fn(df_test), steps=1)\n for key in sorted(results):\n print(\"%s: %s\" % (key, results[key]))",
"def __init__(self):\n \n self.model = Net()\n\n if torch.cuda.is_available():\n map_location=torch.device('cuda')\n else:\n map_location=torch.device('cpu')\n\n # load parameters\n self.model.load_state_dict(torch.load('model.pt',\n map_location=map_location)) \n \n if torch.cuda.is_available():\n self.model.cuda()\n else:\n self.model.cpu()\n \n self.model.eval()",
"def main(args):\n # read data from disk\n X_train, X_val, X_test, Y_train, Y_val, Y_test = util_fruit.get_fruit_data()\n\n # build model\n model = get_model(model_name=\"fruit_classifier\")\n model.compile(\n loss='categorical_crossentropy',\n optimizer='adam',\n metrics=['accuracy']\n )\n # augment training and testing data\n datagen, X_train, X_val = augment_data(X_train, X_val)\n\n # save model and training history\n model_folder_path = util_fruit.make_model_folder(model_name=MODEL_NAME)\n\n # Callbacks\n callbacks=[]\n cp_callback = ModelCheckpoint(\"{}/{}_callback.hdf5\".format(model_folder_path, MODEL_NAME),\n monitor='val_loss',\n verbose=0,\n save_best_only=True,\n save_weights_only=False,\n period=10)\n callbacks.append(cp_callback)\n\n # train model and save train history \n batch_size = args.batch_size\n epochs = args.epochs\n history = train(model, X_train, X_val, Y_train, Y_val, callbacks, datagen, batch_size=batch_size, epochs=epochs)\n\n # winsound.Beep(5000, 10) # play sound after training completes\n \n \n save_model(model=model, save_folder_path=model_folder_path, model_name=MODEL_NAME, model_ext=MODEL_EXT)\n save_history(history=history, save_folder_path=model_folder_path)\n\n # evaluate model and save results-\n evaluate(model=model, datagen=datagen, X_test=X_test, Y_test=Y_test, batch_size=batch_size, save_folder_path=model_folder_path)",
"def initiate(self):\n # if self.opt.checkpoint_encoder:\n # self.load(self.opt.checkpoint_encoder, self.opt.checkpoint_decoder)\n # else:\n # start fresh.\n self.model = Transformer(\n self.opt.src_vocab_size,\n self.opt.tgt_vocab_size,\n self.opt.max_token_seq_len,\n tgt_emb_prj_weight_sharing=self.opt.proj_share_weight,\n emb_src_tgt_weight_sharing=self.opt.embs_share_weight,\n d_k=self.opt.d_k,\n d_v=self.opt.d_v,\n d_model=self.opt.d_model,\n d_word_vec=self.opt.d_word_vec,\n d_inner=self.opt.d_inner_hid,\n n_layers=self.opt.layers,\n n_head=self.opt.n_head,\n dropout=self.opt.dropout).to(self.device)\n \n for p in self.model.parameters():\n if p.dim() > 1:\n nn.init.xavier_uniform_(p)",
"def train_and_evaluate(self) -> None:\n with tf.Session() as self.sess:\n # Initialize computation graph.\n self.create_model()\n\n # Initialize variables.\n tf.global_variables_initializer().run()\n\n # Initialize summary writer.\n self.writer = tf.summary.FileWriter(logdir='conv_vis')\n\n for epoch_no in range(self.nb_epochs):\n # Train model on next batch\n batch_x, batch_y = self.mnist.train.next_batch(self.mb_size)\n results = self.train_on_batch(batch_x, batch_y, global_step=epoch_no)\n\n if epoch_no > 0 and epoch_no % self.lr_decay_time == 0:\n # Test on all samples.\n self.test_on_all()\n # Perform learning rate decay.\n self.learning_rate /= 2\n if epoch_no % 100 == 0:\n self.logger.info(\"Epoch {0}: Loss: {1[0]}, accuracy: {1[1]}\".format(epoch_no, results))\n batch_x_t, batch_y_t = self.mnist.test.next_batch(self.mb_size)\n test_results = self.test_on_batch(batch_x_t, batch_y_t)\n self.logger.info(\"(Test(batch): Loss: {0[0]}, accuracy: {0[1]}\".format(test_results))\n self.test_on_all()\n\n # Save the trained model with all valuable variables.\n saver = tf.train.Saver()\n saver.save(sess=self.sess, save_path='./saved_model', global_step=epoch_no)",
"def _on_training_start(self) -> None:\n if self.eval_freq > 0:\n self.solver.run_tests(0, draw=self.draw, verbose=self.verbose)",
"def setup(self):\n print(\"setup\")\n \n self.modelToUse = 1\n if self.train:\n print(\"train\")\n else:\n print(\"no train\")\n \n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n self.envSize = 17\n \n #init model\n if self.train or not os.path.isfile(\"my-saved-model.pt\"):\n self.logger.info(\"Setting up model from scratch.\")\n if self.modelToUse == 0:\n self.policy_net = Model_global_view(self.envSize, self.envSize, 6).to(device)\n self.model = Model_global_view(self.envSize, self.envSize, 6).to(device)\n elif self.modelToUse == 1:\n self.policy_net = Model_local_view(self.envSize, self.envSize, 6).to(device)\n self.model = Model_local_view(self.envSize, self.envSize, 6).to(device)\n else:\n self.policy_net = Model_combined_view(self.envSize, self.envSize, 6).to(device)\n self.model = Model_combined_view(self.envSize, self.envSize, 6).to(device)\n self.model.load_state_dict(self.policy_net.state_dict())\n self.model.eval()\n else:\n self.logger.info(\"Loading model from saved state.\")\n with open(\"my-saved-model.pt\", \"rb\") as file:\n if self.modelToUse == 0:\n self.model = Model_global_view(self.envSize, self.envSize, 6)\n elif self.modelToUse == 1:\n self.model = Model_local_view(self.envSize, self.envSize, 6)\n else:\n self.model = Model_combined_view(self.envSize, self.envSize, 6)\n if torch.cuda.is_available():\n self.model.load_state_dict(torch.load(file))\n self.model.to(device)\n else:\n self.model.load_state_dict(torch.load(file, map_location=device))",
"def make_model():\n m = model_class(*argv[2:-1])\n modelobj[\"model\"] = m",
"def run(self):\n # Get the checkpoint file\n print('loading checkpoint file ...')\n cp = torch.load(self.cfg.work_dir + '/latest.pth')\n print('done')\n\n print('loading state dictionary ...')\n # Initialize network first as separate modules so we can access WFCOS\n backbone = build_backbone(self.cfg.model.backbone).cuda()\n neck = build_neck(self.cfg.model.neck).cuda()\n head = build_head(self.cfg.model.bbox_head).cuda()\n\n # Load the state dicts\n backbone_state = OrderedDict()\n neck_state = OrderedDict()\n head_state = OrderedDict()\n\n for key in cp['state_dict'].keys():\n if 'backbone' in key:\n backbone_state[key.split('.', 1)[1]] = cp['state_dict'][key]\n elif 'neck' in key:\n neck_state[key.split('.', 1)[1]] = cp['state_dict'][key]\n elif 'bbox_head' in key:\n head_state[key.split('.', 1)[1]] = cp['state_dict'][key]\n\n backbone.load_state_dict(backbone_state)\n neck.load_state_dict(neck_state)\n head.load_state_dict(head_state)\n\n # Set to eval mode\n backbone.eval()\n neck.eval()\n head.eval()\n\n print('done')\n\n print('starting inference validation run ...')\n for i, (img, cls) in enumerate(self.loader):\n out = backbone(img)\n out = neck(out)\n out = head(out)\n\n img_metas = [{'img_shape': (640, 800),\n 'scale_factor': 1}]\n bboxes = head.get_bboxes(out[0], out[1], out[2], img_metas,\n self.cfg.test_cfg)\n pass\n print('done')",
"def startEvaluationMode(self):\n self.saved_dat_ref = self.data_ref",
"def run(self, **kwargs):\n self.runKwargs = kwargs\n assert self.initialized, \"Pypet environment not initialized yet.\"\n self._t_start_exploration = datetime.datetime.now()\n self.env.run(self.evalFunction)\n self._t_end_exploration = datetime.datetime.now()",
"def testing_phase(self):\r\n self.test_dataloader = self.get_dataloader(self.test_h5_path, \"test set\")\r\n self.get_ts_properties()\r\n\r\n self.restart_epoch = util.get_restart_epoch()\r\n print(f\"* Loading model from previous saved state (Epoch {self.restart_epoch}).\", flush=True)\r\n self.model = torch.load(\r\n self.C.job_dir + f\"model_restart_{self.restart_epoch}.pth\"\r\n )\r\n\r\n self.model.eval()\r\n with torch.no_grad():\r\n self.generate_graphs(n_samples=self.C.n_samples)\r\n\r\n print(\"* Evaluating model.\", flush=True)\r\n anal.evaluate_model(valid_dataloader=self.test_dataloader,\r\n train_dataloader=self.train_dataloader,\r\n nll_per_action=self.nll_per_action,\r\n model=self.model)\r\n\r\n self.print_time_elapsed()",
"def evaluate(cfg: DictConfig):\n\n # suppress TensorFlow and DALI warnings\n suppress_warnings()\n\n if cfg.USE_MULTI_GPUS.VALUE:\n # change number of visible gpus for evaluation\n set_gpus(cfg.USE_MULTI_GPUS.GPU_IDS)\n # update batch size according to available gpus\n data_generator.update_batch_size(cfg)\n\n if cfg.OPTIMIZATION.AMP:\n print(\"Enabling Automatic Mixed Precision(AMP) training\")\n policy = mixed_precision.Policy('mixed_float16')\n mixed_precision.set_global_policy(policy)\n\n if cfg.OPTIMIZATION.XLA:\n print(\"Enabling Automatic Mixed Precision(XLA) training\")\n tf.config.optimizer.set_jit(True)\n\n # create model\n strategy = None\n if cfg.USE_MULTI_GPUS.VALUE:\n # multi gpu training using tensorflow mirrored strategy\n strategy = tf.distribute.MirroredStrategy(\n cross_device_ops=tf.distribute.HierarchicalCopyAllReduce()\n )\n print('Number of visible gpu devices: {}'.format(strategy.num_replicas_in_sync))\n with strategy.scope():\n optimizer = tf.keras.optimizers.Adam(\n learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE\n ) # optimizer\n if cfg.OPTIMIZATION.AMP:\n optimizer = mixed_precision.LossScaleOptimizer(\n optimizer,\n dynamic=True\n )\n dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)\n dice_coef = tf.keras.metrics.MeanMetricWrapper(name=\"dice_coef\", fn=dice_coef)\n model = prepare_model(cfg, training=True)\n else:\n optimizer = tf.keras.optimizers.Adam(\n learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE\n ) # optimizer\n if cfg.OPTIMIZATION.AMP:\n optimizer = mixed_precision.LossScaleOptimizer(\n optimizer,\n dynamic=True\n )\n dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)\n dice_coef = tf.keras.metrics.MeanMetricWrapper(name=\"dice_coef\", fn=dice_coef)\n model = prepare_model(cfg, training=True)\n\n model.compile(\n optimizer=optimizer,\n loss=unet3p_hybrid_loss,\n metrics=[dice_coef],\n )\n\n # weights model path\n checkpoint_path = join_paths(\n cfg.WORK_DIR,\n cfg.CALLBACKS.MODEL_CHECKPOINT.PATH,\n f\"{cfg.MODEL.WEIGHTS_FILE_NAME}.hdf5\"\n )\n\n assert os.path.exists(checkpoint_path), \\\n f\"Model weight's file does not exist at \\n{checkpoint_path}\"\n\n # TODO: verify without augment it produces same results\n # load model weights\n model.load_weights(checkpoint_path, by_name=True, skip_mismatch=True)\n model.summary()\n\n # data generators\n val_generator = data_generator.get_data_generator(cfg, \"VAL\", strategy)\n validation_steps = data_generator.get_iterations(cfg, mode=\"VAL\")\n\n # evaluation metric\n evaluation_metric = \"dice_coef\"\n if len(model.outputs) > 1:\n evaluation_metric = f\"{model.output_names[0]}_dice_coef\"\n\n result = model.evaluate(\n x=val_generator,\n steps=validation_steps,\n workers=cfg.DATALOADER_WORKERS,\n return_dict=True,\n )\n\n # return computed loss, validation accuracy, and it's metric name\n return result, evaluation_metric",
"def run_model (arguments):\n if arguments.train is not None:\n # Train a new model, optionally with a certain number of epochs\n predictor = None\n if len(arguments.train) > 0:\n predictor = train(n_epochs=arguments.train[0])\n else:\n predictor = train()\n # Afterwards save it\n now = datetime.now(timezone.utc)\n predictor.to_disk(fname=f\"model_parameters_{now.strftime('%Y%m%d%H%M%S')}\")\n elif arguments.export_embeddings:\n # Load the saved predictor ...\n predictor = Predictor.from_file()\n # ... and then dump the models to disk.\n predictor.subj.export_embeddings(\"subject\")\n predictor.obj.export_embeddings(\"object\")\n print(\"Models are saved to output directory for loading with http://projector.tensorflow.org/.\")\n elif arguments.console:\n # Opens a console for prediction without training\n predictor = Predictor.from_file()\n tinker(predictor)",
"def create_model(self):\n pass",
"def create_model(self):\n pass",
"def evaluate():\n\n # seed provides the mechanism to control the shuffling which takes place reading input\n seed = tf.placeholder(tf.int64, shape=())\n \n # Generate placeholders for the images and labels.\n iterator = input_data.input_pipeline_binary(FLAGS.data_dir,\n FLAGS.batch_size,\n fake_data=FLAGS.fake_data,\n num_epochs=1,\n read_threads=FLAGS.read_threads,\n shuffle_size=FLAGS.shuffle_size,\n num_expected_examples=FLAGS.num_examples,\n seed=seed)\n image_path, label_path, images, labels = iterator.get_next()\n\n if FLAGS.verbose:\n print_op = tf.print(\"images and labels this batch: \", \n image_path, label_path, labels)\n else:\n print_op = tf.constant('No printing')\n\n if FLAGS.random_rotation:\n images, labels = harmonics.apply_random_rotation(images, labels)\n\n # Build a Graph that computes predictions from the inference model.\n logits = topology.inference(images, FLAGS.network_pattern)\n \n # Add to the Graph the Ops for loss calculation.\n loss = topology.binary_loss(logits, labels)\n \n # Set up some prediction statistics\n predicted = tf.round(tf.nn.sigmoid(logits))\n correct_pred = tf.equal(predicted, labels)\n accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n\n saver = tf.train.Saver()\n\n with tf.Session() as sess:\n \n while True:\n eval_once(sess, iterator, saver, seed, labels, loss, accuracy, predicted)\n if FLAGS.run_once:\n break\n time.sleep(FLAGS.eval_interval_secs)",
"def __init__(self, env, args):\n self.env = env\n self.args = args\n\n self.epsilon = args.epsilon\n self.decay = args.decay\n self.gamma = args.gamma\n self.batch_size = args.batch_size\n self.replay_memory_size = args.replay_memory_size\n self.update_every = args.update_every\n self.epsilon_min = args.epsilon_min\n self.savedir = args.savedir\n self.scale = args.scale\n if args.clip == 0:\n self.clip = np.inf\n else:\n self.clip = args.clip\n self.best_reward_criteria = args.best_reward_criteria # If mean reward over last 'best_reward_critera' > best_reward, save model\n\n # Get valid actions\n try:\n self.valid_actions = list(range(env.action_space.n))\n except AttributeError as e:\n print(f'Action space is not Discrete, {e}')\n\n # Logging\n self.train_logger = logging.getLogger('train')\n self.train_logger.setLevel(logging.INFO)\n formatter = logging.Formatter('%(asctime)s, %(message)s', datefmt = '%Y-%m-%d %H:%M:%S')\n file_handler = logging.FileHandler(os.path.join('experiments', args.savedir, 'training.log'))\n file_handler.setFormatter(formatter)\n self.train_logger.addHandler(file_handler)\n self.train_logger.propagate = False\n\n # Tensorboard\n self.writer = SummaryWriter(log_dir = os.path.join('experiments', self.savedir), flush_secs = 5)\n\n # Initialize model\n self.device = torch.device(\"cuda:0\" if args.cuda else \"cpu\")\n state_shape = env.observation_space.shape\n state_space_dim = state_shape[0] if len(state_shape) == 1 else state_shape\n\n self.estimator = Estimator(args.nhidden, args.nunits, state_space_dim, env.action_space.n).to(self.device)\n self.target = Estimator(args.nhidden, args.nunits, state_space_dim, env.action_space.n).to(self.device)\n\n # Optimization\n self.criterion = nn.SmoothL1Loss(reduction = 'mean')\n self.optimizer = optim.Adam(self.estimator.parameters(), lr = args.lr, betas = (args.beta1, 0.999))\n\n # If resume, load from checkpoint | otherwise initialize\n if args.resume:\n try:\n self.load_checkpoint(os.path.join('experiments', args.savedir, 'checkpoint.pt'))\n self.train_logger.info(f'INFO: Resuming from checkpoint; episode: {self.episode}')\n except FileNotFoundError:\n print('Checkpoint not found')\n\n else:\n self.replay_memory = deque(maxlen = args.replay_memory_size)\n\n # Initialize replay memory\n self.initialize_replay_memory(self.batch_size)\n\n # Set target = estimator\n self.target.load_state_dict(self.estimator.state_dict())\n\n # Training details\n self.episode = 0\n self.steps = 0\n self.best_reward = -self.clip * self.env.T * self.env.D",
"def _make_model(self):\n self._model = tf.estimator.Estimator(model_fn=self.model_fn,\n model_dir=self.model_dir,\n config=self._config,\n params=self._params,\n )",
"def _post_model_build(self):\r\n with tf.variable_scope('copy2test'):\r\n all_variables = tf.global_variables()\r\n train_vars = dict([(v.name, v) for v in all_variables\r\n if not v.name.startswith('test/')])\r\n test_vars = dict([(v.name, v) for v in all_variables\r\n if v.name.startswith('test/')])\r\n self._copy_variables_to_test_model_op = tf.tuple([\r\n test_vars['test/' + k].assign(train_vars[k]) for k in train_vars.keys()\r\n if 'test/' + k in test_vars\r\n ])\r\n\r\n # Begin testing thread\r\n self._coordinator = tf.train.Coordinator()\r\n self._thread = threading.Thread(target=self.test_job,\r\n name='%s_tester' % self.model.identifier)\r\n self._thread.daemon = True\r\n self._thread.start()\r\n\r\n # Pick tensors we need to evaluate\r\n all_tensors = dict(self.model.loss_terms['test'], **self.model.metrics['test'])\r\n self._tensors_to_evaluate = dict([(n, t) for n, t in all_tensors.items()])\r\n loss_terms_to_evaluate = dict([(n, t) for n, t in self.model.loss_terms['test'].items()\r\n if t in self._tensors_to_evaluate.values()])\r\n metrics_to_evaluate = dict([(n, t) for n, t in self.model.metrics['test'].items()\r\n if t in self._tensors_to_evaluate.values()])\r\n\r\n # Placeholders for writing summaries at end of test run\r\n self._placeholders = {}\r\n for type_, tensors in (('loss', loss_terms_to_evaluate),\r\n ('metric', metrics_to_evaluate)):\r\n for name in tensors.keys():\r\n name = '%s/test/%s' % (type_, name)\r\n placeholder = tf.placeholder(dtype=np.float32, name=name + '_placeholder')\r\n self.summary.scalar(name, placeholder)\r\n self._placeholders[name.split('/')[-1]] = placeholder",
"def train(self, request):\n model = request.get(\"model\")\n if not model:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n \"Model is not provided for Training Task\",\n )\n\n task = self._trainers.get(model)\n if not task:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n f\"Train Task is not Initialized. There is no model '{model}' available\",\n )\n\n request = copy.deepcopy(request)\n result = task(request, self.datastore())\n\n # Run all scoring methods\n if self._auto_update_scoring:\n self.async_scoring(None)\n return result",
"def main_modeling_pipeline():\n\n\n data_df = pd.read_csv('gs://aiplatformfilipegracio2020/head_train_data.csv')\n data_df = data_df[[LABEL, 'price', 'days_on_site']]\n\n class_weights = calculate_class_weights(data_df[LABEL])\n print('class weights', class_weights)\n logging.info('Data loaded and processed')\n train_ds, val_ds, test_ds = make_tf_datasets(data_df, LABEL)\n logging.info('Tensorflow datasets created')\n\n with strategy.scope():\n logging.info('Inside strategy')\n simple_feature_layer = make_simple_feature_layer(data_df)\n logging.info('Going to make model')\n simple_model = make_simple_model(simple_feature_layer)\n\n logging.info('Going fit model')\n simple_model_results, simple_model = model_fit_and_evaluate(model=simple_model,\n train_ds=train_ds,\n val_ds=val_ds,\n test_ds=test_ds,\n class_weights=class_weights,\n epochs=TRAINING_EPOCHS,\n job_name='simple_model')\n\n simple_model.save('gs://aiplatformfilipegracio2020/')",
"def main():\n training_data, validation_data, test_data = mnist.load()\n\n model = nn.NeuralNetwork([784, 100, 10], learning_rate=0.01, batch_size=50)\n\n model_training = training.EarlyStoppingRegularization(model,\n training_data,\n validation_data,\n test_data,\n max_steps_without_progression=2)\n result = model_training.train()\n\n result.save('models/mnist')",
"def run(self, task):\n params = self.params\n\n # task parameters\n self.task = task\n params.out_features = N_CLASSES[task]\n self.is_classif = task != 'STS-B'\n\n # load data\n self.data = self.load_data(task)\n if not self.data['dico'] == self._embedder.dico:\n raise Exception((\"Dictionary in evaluation data (%i words) seems different than the one \" +\n \"in the pretrained model (%i words). Please verify you used the same dictionary, \" +\n \"and the same values for max_vocab and min_count.\") % (len(self.data['dico']), len(self._embedder.dico)))\n\n # embedder\n self.embedder = copy.deepcopy(self._embedder)\n self.embedder.npu()\n\n # projection layer\n self.proj = nn.Sequential(*[\n nn.Dropout(params.dropout),\n nn.Linear(self.embedder.out_dim, params.out_features)\n ]).npu()\n\n # optimizers\n self.optimizer_e = get_optimizer(list(self.embedder.get_parameters(params.finetune_layers)), params.optimizer_e)\n self.optimizer_p = get_optimizer(self.proj.parameters(), params.optimizer_p)\n\n # train and evaluate the model\n for epoch in range(params.n_epochs):\n\n # update epoch\n self.epoch = epoch\n\n # training\n logger.info(\"GLUE - %s - Training epoch %i ...\" % (task, epoch))\n self.train()\n\n # evaluation\n logger.info(\"GLUE - %s - Evaluating epoch %i ...\" % (task, epoch))\n with torch.no_grad():\n scores = self.eval('valid')\n self.scores.update(scores)\n self.eval('test')",
"def get_model_evaluation(self):\n\n self.log(f\"{self.cur_file_path}\\t\\tInfo: model_evaluation method invoked for {self.model.__class__.__name__}!\")\n\n evaluation = ModelEvaluation(self.model, (self.trainX, self.trainY), (self.testX, self.testY))\n return evaluation.get_evaluation_report()",
"def train_main(cls):\n launcher = cls()\n launcher.launch()",
"def build(self):\n\t\n\t\tprint 'BUILDING HOMOLOGY MODELS'\n\t\tif self.procedure != 'mutator': self.get_targets()\n\t\tself.get_templates()\n\t\tif self.procedure == 'single': self.build_model_single()\n\t\telif self.procedure == 'multi': self.build_model_multi()\n\t\telif self.procedure == 'mutator': self.build_model_mutator()",
"def run(self):\n self.assign_inputs()\n self.execute()\n self.collect_outputs()",
"def start_training(self):\n self.training()\n \n images, true_labels, pred_labels, pred_probs = self.evaluate_model(proba=True)\n \n metrics = Metrics(images, true_labels, pred_labels, pred_probs, self.classes)\n\n cm = metrics.get_confusion_matrix()\n print('The confusion matrix is:\\n', cm)\n print('*'*100)\n \n cr = metrics.get_classification_report()\n print('The classification report is:\\n', cr)\n print('*'*100)"
] | [
"0.7154538",
"0.7110913",
"0.70891786",
"0.70385206",
"0.6866587",
"0.68355024",
"0.68056273",
"0.6790459",
"0.6780459",
"0.6717746",
"0.6706127",
"0.6687629",
"0.66817534",
"0.6587053",
"0.6575464",
"0.6549759",
"0.6510648",
"0.64960116",
"0.6456182",
"0.6450196",
"0.6441333",
"0.64174205",
"0.64146936",
"0.6410253",
"0.640372",
"0.6383182",
"0.6361844",
"0.62950397",
"0.6286746",
"0.6279988",
"0.6265114",
"0.6258114",
"0.62579256",
"0.6253772",
"0.62351",
"0.6216626",
"0.6216626",
"0.62132925",
"0.6209311",
"0.6182571",
"0.6182441",
"0.61811984",
"0.61725676",
"0.6159651",
"0.61469007",
"0.6141984",
"0.6141984",
"0.6136531",
"0.61299884",
"0.61297035",
"0.6128745",
"0.6127653",
"0.6127023",
"0.6108053",
"0.6107406",
"0.6106871",
"0.61030436",
"0.6102116",
"0.60987866",
"0.6086478",
"0.6076363",
"0.60666907",
"0.60666907",
"0.6063743",
"0.60586387",
"0.6053167",
"0.60523236",
"0.6051375",
"0.6047922",
"0.6040648",
"0.60391885",
"0.60333705",
"0.6026314",
"0.6024497",
"0.60212845",
"0.601901",
"0.601852",
"0.6016801",
"0.60149145",
"0.6013799",
"0.6005664",
"0.6002612",
"0.6002069",
"0.59992915",
"0.59971416",
"0.59969306",
"0.59852517",
"0.59852517",
"0.5976038",
"0.59751445",
"0.59715533",
"0.59708035",
"0.59704447",
"0.5969801",
"0.59640795",
"0.59595275",
"0.5958664",
"0.5953275",
"0.59528923",
"0.5952138",
"0.59507763"
] | 0.0 | -1 |
creates the object and overides the _class attribute setting it to the class name | def __init__(self,name:str,int,str,dex):
super(Warrior, self).__init__(name,int,str,dex)
self._class = 'Warrior' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_class(self):\n temp_class = self.temp('separated.class')\n return temp_class.format(**self.__dict__)",
"def _class(self, _class):\n\n self.__class = _class",
"def _class(self, _class):\n\n self.__class = _class",
"def create_instance(self,name):\n print \"INFO : new %s\" % name\n return self.get_class(name)()",
"def setup_class(klass):",
"def setup_class(klass):",
"def setup_class(cls):",
"def setup_class(cls):",
"def create_class_from_strings( self, module_name, class_name):\r\n if not( self.logger is None ):\r\n self.logger.debug( \"create class {module_name} {class_name}\" )\r\n\r\n# print( \"create class \" + module_name + \" \" + class_name )\r\n\r\n a_class = getattr( importlib.import_module(module_name), class_name )\r\n instance = a_class( )\r\n return instance",
"def create(self, class_name, attrs, session):",
"def __init__(self):\n self.classes = {}",
"def __class__(self, ???):",
"def __init__(self, klass, *args, **kwargs):\n self._klass = klass(*args, **kwargs)",
"def new_class(self, grp, name, class_type=\"NXcollection\"):\n sub = grp.require_group(name)\n sub.attrs[\"NX_class\"] = numpy.string_(class_type)\n return sub",
"def _class(self, class_):\r\n\r\n if class_:\r\n if hasattr(class_, '__mro__'):\r\n #this is a class\r\n return class_\r\n else:\r\n #this is an instance\r\n return type(class_)",
"def make_class(attributes, base_classes=()):\r\n \"*** YOUR CODE HERE ***\"",
"def _create_class(self, name, superclass):\n template = self._fill_template(name, superclass)\n directory = (\"controllers\" if self.type == \"controller\" else\n self.type.capitalize())\n\n path = self.module.path + os.sep + directory + os.sep\n # Check if the class name contains underscores. If it does, interpret\n # them as directory separators.\n if not name.find(\"_\") == -1:\n substrings = name.split(\"_\")\n path += os.path.join(*substrings[:-1]) + os.sep\n try:\n os.makedirs(path)\n except OSError:\n pass # The directories already exist\n name = substrings[-1]\n dest = path + name + \".php\"\n if not os.path.isfile(dest):\n dest = open(dest, \"w\")\n dest.write(template)\n dest.close()\n else:\n raise OSError(\"File exists: \" + dest)",
"def get_class(self, name: str) -> Type:\n if logger.isEnabledFor(logging.DEBUG):\n logger.debug(f'new instance of {name}')\n name = self.default_name if name is None else name\n if logger.isEnabledFor(logging.DEBUG):\n logger.debug(f'creating instance of {name}')\n class_name, params = self._class_name_params(name)\n return self._find_class(class_name)",
"def __init__(self, module_name,class_name):\n\n try:\n self.module = importlib.import_module(module_name)\n self.get_class_object = getattr(self.module,class_name)\n \n except:\n print(\"Failed to import the module {} from {}\".format(class_name,module_name))",
"def __init__(self, name: str = 'ret_val') -> None:\n self.name = name\n self.class_name = \"\"",
"def do_create(self, class_name):\n\n if not class_name:\n print(\"** class name missing **\")\n elif class_name not in HBNBCommand.class_list:\n print(\"** class doesn't exist **\")\n else:\n new_object = eval(class_name + \"()\")\n new_object.save()\n print(new_object.id)",
"def _class(self):\n return self.__class",
"def do_create(self, arg):\n if not arg:\n print('** class name missing **')\n return\n args = arg.split(\" \")\n if args[0] not in self.__classes:\n print(\"** class doesn't exist **\")\n else:\n obj = eval(args[0])()\n obj.save()\n print(obj.id)",
"def _class_default(self):\n if self.auto_create:\n return self.instance_class\n return utils.undefined",
"def __init__(self, cls):\n super().__init__()\n self._cls = cls",
"def _create_Work(classname, dataclass):\n globals()[classname] = type(classname, (Work, dataclass), {})",
"def __init__(self, inst, class_type):\n\t\tself.type = str(class_type)[7:]\n\t\tself.type = self.type[:-1]\n\t\tself.inst = inst\n\t\treturn",
"def _class(self, *args):\r\n\r\n if hasattr(args[0], '__mro__'):\r\n #this is a class\r\n return args[0]\r\n else:\r\n #this is an instance\r\n return type(args[0])",
"def setup_class(cls):\n pass",
"def setup_class(cls):\n pass",
"def setClassName(self,whichDir):\n self.className = whichDir\n self.setClassMap({whichDir : 1})",
"def do_create(self, arg):\n args = arg.split()\n if len(args) == 0:\n print(\"** class name missing **\")\n return\n if args[0] in self.class_dict:\n new = self.class_dict.get(args[0])()\n storage.save()\n print(new.id)\n else:\n print(\"** class doesn't exist **\")",
"def setup_class(self):\n pass",
"def __init__(self, class_name):\n self.class_name = class_name.lower()\n\n try:\n if _req.json is not None:\n self.parse.json = _req.json\n\n if bool(_req.form):\n self.parse.form = _req.form.to_dict(flat=False)\n\n if bool(_req.files):\n self.parse.file = _req.files.to_dict(flat=False)\n\n if bool(_req.args):\n self.parse.args = _req.args\n except AttributeError:\n pass",
"def identify_class(self, cls):",
"def upclass(self):\n # I assume that self has been loaded properly from the database\n klass = RegisteredType._reg['classes'][self.the_classid]\n \n obj = klass.objects.get(pk = self.pk) \n return obj # Ta-ta! ",
"def change_real_class(self):\r\n if not self.type:\r\n #objects was just created, set type and return\r\n self.type = self.__class__.__name__\r\n return self\r\n if self.type == self.__class__.__name__:\r\n return self\r\n #type is set, we can do actual change of the class\r\n #TODO it could be cached during creation of relevant subclasses\r\n for cls in self.subclasses():\r\n if cls.__name__ == self.type:\r\n self.__class__ = cls\r\n return self\r\n raise RuntimeError(\"Subclass not found: %s %s\", self.type, self.__class__.__name__)",
"def get_class(self, name):\n raise NotImplementedError",
"def __init__(self, name, bases, attrs):\n self.__context__ = context.cur_context\n self.__context__.className = name\n print \"Set context for \"+str(self)+\" to \"+str(self.__context__.className)",
"def _create(self, target_class, *args, **kw):\n\n raise NotImplementedError",
"def get_class(self):\n\t\treturn self.CLASS",
"def _constructor(self):\n return self.__class__",
"def register_class(obj):\r\n try:\r\n KnownClass.objects.get(module_name=obj.__module__, class_name=obj.__class__.__name__)\r\n except DoesNotExist:\r\n # Create it\r\n KnownClass(module_name = obj.__module__, class_name = obj.__class__.__name__).save()",
"def do_create(self, *args):\n \"\"\" args without commas created a tuple of 1, so I created a list with\n the tuple being split by spaces \"\"\"\n args = [ele for ele in args[0].split(' ')]\n if args[0] == '':\n print(\"** class name missing **\")\n return\n if args[0] not in self.list_classes:\n print(\"** class doesn't exist **\")\n return\n newinstance = eval(\"{}()\".format(args[0]))\n newinstance.save()\n print(newinstance.id)",
"def __constructor__(self):\n return type(self)",
"def build_class(classname, values):\n values['FIELDS'] = [x for x in values.keys()]\n return type(classname, (object,), values)",
"def setup_class(self):\n\n class SubFLRW(FLRW):\n def w(self, z):\n return super().w(z)\n\n self.cls = SubFLRW\n # H0, Om0, Ode0\n self.cls_args = (70 * u.km / u.s / u.Mpc, 0.27 * u.one, 0.689 * u.one)\n self.cls_kwargs = dict(Tcmb0=3.0 * u.K, name=self.__class__.__name__, meta={\"a\": \"b\"})",
"def create_class(self, cls):\n\n cls_name = cls.registry_name\n\n bases = [base for base in cls.__bases__ if self.valid_element_base(base)]\n if not bases:\n raise TypeError(\n 'Unexpected base class(es) in Graph.create_class'\n ' - try the declarative bases')\n\n extends = None\n if bases[0] is bases[0].decl_root:\n extends = ['V', 'E'][bases[0].decl_type]\n else:\n extends = ','.join([base.registry_name for base in bases])\n\n #if not self.client.command(\n # 'SELECT FROM ( SELECT expand( classes ) FROM metadata:schema ) WHERE name = \"{}\"'\n # .format(cls_name)):\n try:\n self.client.command(\n 'CREATE CLASS {0} EXTENDS {1}'.format(cls_name, extends))\n except pyorient.PyOrientSchemaException:\n # Class already exists\n pass\n\n db_to_element = {}\n\n props = sorted([(k,v) for k,v in cls.__dict__.items()\n if isinstance(v, Property)]\n , key=lambda p:p[1].instance_idx)\n for prop_name, prop_value in props:\n value_name = prop_value.name\n if value_name:\n db_to_element[value_name] = prop_name\n prop_name = value_name\n else:\n db_to_element[prop_name] = prop_name\n\n self.guard_reserved_words(prop_name, cls)\n\n class_prop = '{0}.{1}'.format(cls_name, prop_name)\n\n linked_to = None\n if isinstance(prop_value, LinkedClassProperty):\n type_linked_to = prop_value.linked_to\n\n linked_to = getattr(type_linked_to, 'registry_name', None)\n if not linked_to:\n link_bases = getattr(type_linked_to, '__bases__', None)\n if link_bases and \\\n isinstance(prop_value, LinkedProperty) and \\\n link_bases[0] is Property:\n linked_to = type_linked_to.__name__\n\n try:\n self.client.command(\n 'CREATE PROPERTY {0} {1} {2}'\n .format(class_prop\n , type(prop_value).__name__\n , linked_to or ''))\n except pyorient.PyOrientCommandException:\n # Property already exists\n pass\n\n if prop_value.default is not None:\n if self.server_version >= (2,1,0):\n self.client.command(\n 'ALTER PROPERTY {0} DEFAULT {1}'\n .format(class_prop,\n PropertyEncoder.encode(prop_value.default)))\n\n self.client.command(\n 'ALTER PROPERTY {0} NOTNULL {1}'\n .format(class_prop\n , str(not prop_value.nullable).lower()))\n\n self.client.command(\n 'ALTER PROPERTY {} MANDATORY {}'\n .format(class_prop\n , str(prop_value.mandatory).lower()))\n\n self.client.command(\n 'ALTER PROPERTY {} READONLY {}'\n .format(class_prop\n , str(prop_value.readonly).lower()))\n\n # TODO Add support for composite indexes\n if prop_value.indexed:\n try:\n self.client.command(\n 'CREATE INDEX {0} {1}'\n .format(class_prop\n , 'UNIQUE' if prop_value.unique\n else 'NOTUNIQUE'))\n except pyorient.PyOrientIndexException:\n # Index already exists\n pass\n\n self.props_from_db[cls] = self.create_props_mapping(db_to_element)\n self.init_broker_for_class(cls)\n self.registry[cls_name] = cls",
"def after_class_creation(cls):\n pass",
"def new(class_name:str, label:int,\n is_fixed_shape:bool=False, data_shape:tuple=()):\n\n if DG_ClassWrapper.does_class_exist(class_name, label):\n return None\n\n new_class = DG_ClassWrapper.DG_Class(class_name, label, data_size, is_fixed_size)\n\n DG_ClassWrapper.class_list.append(new_class)\n return new_class",
"def __set_name__(self, cls, name):\n pass",
"def process_class(self, parent, cls):\n if cls.typemap.flat_name in self.class_map:\n raise RuntimeError(\"process_class: class {} already exists in class_map\"\n .format(cls.typemap.flat_name))\n self.class_map[cls.typemap.flat_name] = cls\n for var in cls.variables:\n self.add_var_getter_setter(parent, cls, var)\n cls.functions = self.define_function_suffix(cls.functions)",
"def _get_classname(cls):\n return cls.__name__",
"def _get_cls(name, cls):\n return cls.get(name, None) if isinstance(cls, dict) else cls",
"def __call__(cls, *args, **kwargs):\n if cls not in cls._instance:\n cls._instance[cls] = super(Metaclass, cls).__call__(*args, **kwargs)\n return cls._instance[cls]",
"def initialize(cls):",
"def get_class(cls):\n class Foo(object):\n def __init__(self):\n pass\n x = Foo()\n x.__class__ = cls\n return x.__class__",
"def save_class(self, a, class_name):\n logging.debug(\"in save class \" + class_name)\n self.produce(\"class_name\", class_name)\n self.classes.append(class_name)\n self.begin('')",
"def __init__(self):\n super().__init__()\n self.name = '' # name of this istance (alias)\n self.type = type(self).__name__ # specific type within this class\n self.verbosity = None # verbosity level (see message handler)\n self.globalAttributes = {} # this is a dictionary that contains parameters that are set at the level of the base classes defining the types\n self._knownAttribute = [] # this is a list of strings representing the allowed attribute in the xml input for the class\n self._knownAttribute += ['name','verbosity'] # attributes that are known\n self.printTag = 'BaseType' # the tag that refers to this class in all the specific printing\n self.variableGroups = {} # the variables this class needs to be aware of\n self.metadataKeys = set() # list of registered metadata keys to expect from this entity\n self.metadataParams = {} # dictionary of registered metadata keys with repect to their indexes",
"def __init__(self, _class=None, *, policy=compat32):\n self._class = _class\n self.policy = policy",
"def do_create(self, args):\n if not args:\n print(\"** class name missing **\")\n elif args in HBNBCommand.class_check:\n\n lists = args.split()\n obj = eval(\"{}()\".format(lists[0]))\n obj.save()\n print(obj.id)\n storage.reload()\n\n else:\n print(\"** class doesn't exist **\")",
"def cls(self):\n return self.__class__.__name__",
"def __new__(metacls, name, bases, classdict):\n # classdict is not always a dict wtf\n if not isinstance(classdict, dict):\n classdict = dict(classdict)\n\n for (key, value) in iteritems(classdict):\n if isinstance(value, TraitType):\n value.name = key\n elif inspect.isclass(value):\n if issubclass(value, TraitType):\n value_inst = value()\n value_inst.name = key\n classdict[key] = value_inst\n\n return super(MetaModel, metacls).__new__(metacls, name, bases, classdict)",
"def __init__(self):\n self.__name = 'name'",
"def create(cls, _):\n return cls",
"def _declaring_class(obj):\n name = _qualname(obj)\n return name[:name.rfind('.')]",
"def _create_concept(self, name, sco, cgi):\n\n # now define the class\n new_class = type(name, sco, {})\n\n self.name_mapping[name] = new_class\n self.new_classes.append(new_class)\n self.concepts.append(new_class)\n\n if cgi:\n # store that property in the class-object (available for look-up of child classes)\n self.cas_set(key=(new_class, \"X_createGenericIndividual\"), value=True)\n\n # create the generic individual:\n gi_name = f\"i{name}\"\n gi = new_class(name=gi_name)\n self.individuals.append(gi)\n self.name_mapping[gi_name] = gi\n\n return new_class",
"def do_create(self, arg):\n\n args = shlex.split(arg)\n if len(args) == 0:\n print(\"** class name missing **\")\n\n elif args[0] in models.classes:\n new_instance = models.classes[args[0]]()\n print(new_instance.id)\n \"\"\"saves it (to the JSON file) \"\"\"\n models.storage.save()\n\n else:\n print(\"** class doesn't exist **\")",
"def do_create(self, arg):\n args = shlex.split(arg)\n if len(args) == 0:\n print(\"** class name missing **\")\n return False\n if args[0] in class_type:\n new_inst = class_type[args[0]]()\n else:\n print(\"** class doesn't exist **\")\n return False\n print(new_inst.id)\n new_inst.save()",
"def setup_class(self):\n class SubCosmology(Cosmology):\n\n H0 = Parameter(unit=u.km / u.s / u.Mpc)\n Tcmb0 = Parameter(unit=u.K)\n\n def __init__(self, H0, Tcmb0=0*u.K, name=None, meta=None):\n super().__init__(name=name, meta=meta)\n self._H0 = H0\n self._Tcmb0 = Tcmb0\n\n self.cls = SubCosmology\n self.cls_args = (70 * (u.km / u.s / u.Mpc), 2.7 * u.K)\n self.cls_kwargs = dict(name=self.__class__.__name__, meta={\"a\": \"b\"})",
"def get_class(cls):\n return '{}.{}'.format(cls.__module__, cls.__name__)",
"def do_create(self, args):\n args = shlex.split(args)\n if not args:\n print(\"** class name missing **\")\n elif not args[0] in name_of_class:\n print(\"** class doesn't exist **\")\n else:\n new_obj = eval(args[0])()\n new_obj.save()\n print(new_obj.id)",
"def _instrument_class(self, cls):\n newcls = type('InstrumentedClass', (cls, MapRedBase), {})\n return newcls",
"def do_create(self, args):\n\n if len(args) == 0:\n print(\"** class name missing **\")\n return\n token = args.split()\n\n try:\n nwInstance = eval(token[0])()\n nwInstance.save()\n print(nwInstance.id)\n except:\n print(\"** class doesn't exist **\")",
"def __init__(self, engine: Engine, class_id: int):\n\n self.engine = engine\n\n # initialize base-class data\n self.data = engine.get_class(class_id)\n self.media = engine.get_class_media(class_id)\n assert self.data is not None\n assert self.media is not None\n self.icon = self.media[\"assets\"][0][\"value\"]\n\n self.name = self.data[\"name\"]\n self.to_serialize = {\n \"name\": self.name,\n \"slug\": self.name.lower().replace(\" \", \"_\"),\n \"icon\": self.icon,\n }\n\n # initialize specialization data\n self.specs = {}\n for spec_idx_data in self.data[\"specializations\"]:\n spec = Specialization(self.engine, spec_idx_data[\"id\"])\n self.specs[spec_idx_data[\"name\"].lower()] = spec\n\n self.to_serialize[\"specs\"] = []\n for spec in self.specs.values():\n self.to_serialize[\"specs\"].append(spec.to_serialize)",
"def object_creator(object_name):\n obj = TemplateClass()\n print(f\"Name of object:{obj.get_object_name()}\")\n obj.set_object_name(\"NewObjectName\")\n print(f\"This is the new object name: {obj.get_object_name()}\")",
"def __new__(meta, classname, bases, classDict):\n obj = super(TestMetaClass, meta).__new__(meta, classname, bases, classDict)\n print(('TestMetaClass.__new__ called. got new obj id=0x%x' % id(obj)))\n return obj",
"def _replicate_class(self, **kwargs):\n return Posterior(**kwargs)",
"def __init__(self, name):\n self.type_cls = None\n\n self.name = name\n self.description = None\n self.updated = None\n self.notes = None\n self.properties = {}",
"def __init_subclass__(cls, name, **kwargs):\n super().__init_subclass__(**kwargs)\n cls._factorizations[name.lower()] = cls\n cls._name = name",
"def __init_subclass__(cls, name, **kwargs):\n super().__init_subclass__(**kwargs)\n cls._factorizations[name.lower()] = cls\n cls._name = name",
"def classname(cls):\n return cls.__name__.lower()",
"def do_create(self, arg):\n if not arg:\n print(\"** class name missing **\")\n return\n if arg not in HBNBCommand.class_list:\n print(\"** class doesn't exist **\")\n return\n obj = eval(arg + \"()\")\n obj.save()\n print(obj.id)",
"def __init__(self, name):\n\n self.__name = name\n\n return",
"def create_class(name, attr_defs):\r\n meta = {'metaclass': Class }\r\n def update(clsdic):\r\n for att, val in attr_defs.items():\r\n clsdic[att] = val\r\n return types.new_class(name, kwds=meta, exec_body=update)",
"def __init__(self, is_low_memory=False):\n self.is_low_memory = is_low_memory\n if is_low_memory:\n test_suffix = 'ForLowMemoryDevice'\n else:\n test_suffix = 'ForRegularDevice'\n class_name = self.__class__.__name__\n self.qualified_name = '%s.%s' % (class_name, test_suffix)\n self.tagged_name = self.qualified_name",
"def do_create(self, args):\n args = shlex.split(args)\n if len(args) == 0:\n print(\"** class name missing **\")\n return False\n if args[0] in classes:\n instance = eval(args[0])()\n else:\n print(\"** class doesn't exist **\")\n return False\n print(instance.id)\n instance.save()",
"def __init__(self, owner, uid, clsName, tag):\r\n Interface.__init__(self, owner, uid, tag)\r\n\r\n self._clsName = clsName",
"def __init__(self, name):\r\n self.name = name",
"def new_object(self):\r\n\t\tpass",
"def __init__(self, name: str):\n self.__name = name",
"def do_create(self, argv):\n if argv in self.__names:\n new_instance = self.__names[argv]()\n new_instance.save()\n print(\"{}\".format(new_instance.id))\n elif len(argv) is 0:\n print(\"** class name missing **\")\n elif argv is not \"BaseModel\":\n print(\"** class doesn't exist **\")",
"def __init__(self, aClass):\n if _py2to3.is_old_style_instance(aClass):\n aClass = aClass.__class__\n self.aClass = aClass",
"def __call__(cls, *args, **kwargs):\n if cls not in cls._instances:\n instance = super().__call__(*args, **kwargs)\n cls._instances[cls] = instance\n return cls._instances[cls]",
"def cls(self):\n return self._cls",
"def __init__(self, name): \n self.name = name",
"def create(cls, **dictionary):\n if cls.__name__ == \"Rectangle\":\n new_class = cls(1, 2)\n else:\n new_class = cls(1)\n new_class.update(**dictionary)\n return new_class",
"def do_create(self, line):\n try:\n tokens = split(line)\n except ValueError:\n return None\n if len(tokens) < 1:\n print(\"** class name missing **\")\n else:\n cls = models.getmodel(tokens[0])\n if cls is None:\n print(\"** class doesn't exist **\")\n else:\n instance = cls()\n models.storage.save()\n print(instance.id)",
"def __create_classname(self, fullname):\n return PACKAGE_NAME + \".\" + fullname",
"def do_create(self, args):\n args = args.split()\n l = len(args)\n if l < 1:\n print(\"** class name missing **\")\n else:\n if args[0] in HBNBCommand.valid_classes.keys():\n if l == 1:\n new_obj = HBNBCommand.valid_classes[args[0]]()\n else:\n result = self.__create_help(args[1:])\n if result is None:\n print(\"** Object fails **\")\n return\n new_obj = HBNBCommand.valid_classes[args[0]](**result)\n print(new_obj.id)\n new_obj.save()\n else:\n print(\"** class doesn't exist **\")",
"def to_object(self, class_name=None, **qwargs):\n if \"TYPE\" not in self.list_nodes() and class_name is None:\n raise ValueError(\"Objects can be only recovered from hdf5 if TYPE is given\")\n elif class_name is not None and class_name != self.get(\"TYPE\"):\n raise ValueError(\n \"Object type in hdf5-file must be identical to input parameter\"\n )\n class_name = class_name or self.get(\"TYPE\")\n class_path = class_name.split(\"<class '\")[-1].split(\"'>\")[0]\n class_convert_dict = { # Fix backwards compatibility\n \"pyiron_base.generic.datacontainer.DataContainer\": \"pyiron_base.storage.datacontainer.DataContainer\",\n \"pyiron_base.generic.inputlist.InputList\": \"pyiron_base.storage.inputlist.InputList\",\n \"pyiron_base.generic.flattenedstorage.FlattenedStorage\": \"pyiron_base.storage.flattenedstorage.FlattenedStorage\",\n }\n if class_path in class_convert_dict.keys():\n class_name_new = \"<class '\" + class_convert_dict[class_path] + \"'>\"\n class_object = self.import_class(class_name_new)\n elif not class_path.startswith(\"abc.\"):\n class_object = self.import_class(class_name)\n else:\n class_object = class_constructor(cp=JOB_DYN_DICT[class_path.split(\".\")[-1]])\n\n # Backwards compatibility since the format of TYPE changed\n if class_name != str(class_object):\n self[\"TYPE\"] = str(class_object)\n\n obj = self.create_instance(class_object, **qwargs)\n obj.from_hdf(hdf=self.open(\"..\"), group_name=self.h5_path.split(\"/\")[-1])\n return obj"
] | [
"0.74641377",
"0.70764786",
"0.70764786",
"0.69768584",
"0.69163984",
"0.69163984",
"0.6843871",
"0.6843871",
"0.6836091",
"0.67553884",
"0.6748268",
"0.67406183",
"0.6720988",
"0.66912264",
"0.6678298",
"0.66541386",
"0.65925103",
"0.6580715",
"0.65422446",
"0.6518123",
"0.65116984",
"0.64891124",
"0.6482327",
"0.645305",
"0.64518404",
"0.6451299",
"0.64505655",
"0.64341456",
"0.64308876",
"0.64308876",
"0.6422252",
"0.6415883",
"0.63984233",
"0.63863325",
"0.6334761",
"0.6334064",
"0.6321889",
"0.63166195",
"0.63034225",
"0.63009256",
"0.62931234",
"0.6292301",
"0.62620926",
"0.6242871",
"0.62192273",
"0.62055904",
"0.6201086",
"0.6193603",
"0.61826736",
"0.617905",
"0.6178567",
"0.61745864",
"0.616889",
"0.616238",
"0.61550546",
"0.61530995",
"0.6147671",
"0.6145387",
"0.6140042",
"0.6138292",
"0.61300224",
"0.6124201",
"0.6111763",
"0.6109009",
"0.6101485",
"0.6101124",
"0.60812795",
"0.6081201",
"0.607189",
"0.6070589",
"0.6069478",
"0.60535747",
"0.6047768",
"0.60359997",
"0.6026313",
"0.60207695",
"0.6015241",
"0.59995663",
"0.5989203",
"0.5986635",
"0.5986635",
"0.5982043",
"0.59614885",
"0.5960648",
"0.5959056",
"0.59540194",
"0.5948716",
"0.5933849",
"0.59335375",
"0.59273577",
"0.5927033",
"0.5923951",
"0.59175473",
"0.59149784",
"0.59049773",
"0.58991796",
"0.58976555",
"0.5895287",
"0.58951086",
"0.5887077",
"0.5883558"
] | 0.0 | -1 |
the basic attack which scales with lvl and the classes primary attribute(Strength) | def _attack(self,target):
damage = self.get_strength() * self.get_lvl()
target.receive_damage(damage) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_hp_for_higher_level(chosen_class,level):\n #Checks to see if your character is level 4,8,12,etc.\n def upgradedAbilityAt4(level):\n if level % 4 == 0:\n upgraded_ability = raw_input(\"Level \"+str(level)+\"!\\n Which two abilities would you like to upgrade? (Adds +1 to ability)\\n Please input two from str/dex/con/int/wis/cha with a space in between.\\n (ex: cha dex) \").split(' ')\n print\n #To write:\n #if either ability pushes ability score over 20, redo input\n\n \n for i in upgraded_ability:\n self.stealthUpdate(i,1)\n #class specific HP calculations\n if chosen_class == 'barbarian': \n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,12) + self.con + self.classMods[6]\n elif chosen_class == 'cleric':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,8) + self.con + self.classMods[6]\n elif chosen_class == 'druid':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,8) + self.con + self.classMods[6]\n elif chosen_class == 'fighter':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,10) + self.con + self.classMods[6]\n elif chosen_class == 'monk':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,8) + self.con + self.classMods[6]\n elif chosen_class == 'paladin':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,10) + self.con + self.classMods[6]\n elif chosen_class == 'ranger':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,10) + self.con + self.classMods[6]\n elif chosen_class == 'rogue':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,6) + self.con + self.classMods[6]\n elif chosen_class == 'wizard':\n for i in range(2,self.level+1):\n upgradedAbilityAt4(i)\n self.hp += r.randint(1,6) + self.con + self.classMods[6]",
"def strength(self) -> float:\n ...",
"def attack(self):\n if random.random() < self.chance_critical:\n return self.strength * 2\n return self.strength",
"def __init__(self, name, attack_strength):\n\n self.name = name\n self.attack_strength = attack_strength",
"def attack_bonus_on_level(self, level):\n raise NotImplementedError",
"def __init__(self, ai, color, bling):\n Base.__init__(self,ai, color, bling)\n self.name = \"Max\"\n self.desc = \"Strong tanks, weak artillery.\"\n self.level1 = 50\n self.level2 = 100\n self.WeaponBonus = 1.2",
"def __init__(self, denoiser_strength): \n self._strength = denoiser_strength",
"def __init__(self, strength, constitution, dexterity,\r\n intelligence, wisdom, charisma):\r\n super().__init__(strength, constitution, dexterity,\r\n intelligence, wisdom, charisma)\r\n if self.constitution < 13:\r\n self.constitution = 13\r\n self.hp = (12 + self.conMod)",
"def heavy_attack(self, enemy):\n #Generate damage\n damage = random.randint(0, 50)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All heavy attacks will appear at index 1 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[1] + \".\")\n\n #Dealt no damage\n if damage < 10:\n print(\"The attack missed!!!\")\n else:\n print(\"It dealt \" + str(damage) + \" damage.\")\n #Deal the damage to the enemy\n enemy.current_health -= damage",
"def ability_4(self,target):\r\n damage = (self.get_strength()*3)\r\n target.receive_damage(damage)",
"def ability_1(self,target):\r\n damage = (self.get_strength()+2)\r\n target.receive_damage(damage)",
"def attackSpeedModifier(self):\n return 0",
"def ability_2(self,target):\r\n damage1 = (self.get_lvl()+self.get_strength())\r\n target.receive_damage(damage1)",
"def __init__(self, name, loot, strength):\n self.name = name\n self.x = 0\n self.y = 0\n self.health = 10\n self.strength = strength\n self.loot = loot\n self.is_alive = True\n self.MAX_HEALTH = 15\n self.magic_key = False\n logging.debug(\"{0} created with health of {1} and strength of {2}\"\n .format(self.name, self.health, self.strength))\n \"\"\" Test Results Part A:\n When increasing MAX_HEATH to 100, rounds tended to go on.\n When decreasing MAX_HEATH to 0.05, rounds end very quickly.\n This is expected because the Sprites will be easier or harder \n to defeat depending on how high their health can get. It will \n take more attacks to defeat a Sprite with more health and less\n attacks to defeat a Sprite with less health. \n \n Test Results Part B:\n Test: change strength of Enemy to 20 (higher than Avatar)\n Prediction: the Enemy should win most/all of the time because the player \n with more strength has a harder attack.\n Results: The Enemy won during all trials. If the roles were switched, the \n same could be said about Avatar.\n \n Test: set health of Avatar to 5\n Prediction: the Avatar will die more often than the Enemy because it can \n receive less attacks\n Results: The Avatar died during most trials. \n \n Test: set MAX_HEALTH for Enemy to 5\n Prediction: Enemy will be able to have less health, so it will be defeated\n more often than the Avatar\n Results: The enemy died in almost all trials\n \"\"\"",
"def attack(health_meter):\n hit_list = 4 * ['igrac'] + 6 * ['neprijatelj']\n injured_unit = random.choice(hit_list)\n hit_points = health_meter[injured_unit]\n injury = random.randint(10, 15)\n health_meter[injured_unit] = max(hit_points - injury, 0)\n print(\"NAPAD! \", end='')\n show_health(health_meter)",
"def __init__(self, attacker, damage):\n self.attacker = attacker\n self.damage = damage",
"def attack(self):\n total_amnt_attack = 0\n for new_attack in self.abilities:\n total_amnt_attack += new_attack.attack()\n return total_amnt_attack",
"def light_attack(self, enemy):\n #Generate damage\n damage = random.randint(15, 25)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All light attacks will appear at index 0 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[0] + \".\")\n print(\"It dealt \" + str(damage) + \" damage.\")\n\n #Deal damage to the enemy\n enemy.current_health -= damage",
"def stealthUpdate(self,ability,amount):\n \n if ability == 'str':\n self.str += amount\n elif ability == 'dex':\n self.dex += amount \n elif ability == 'con':\n self.con += amount\n elif ability == 'int':\n self.int += amount\n elif ability == 'wis':\n self.wis += amount\n elif ability == 'cha':\n self.cha += amount\n elif ability == 'hp':\n self.hp += amount",
"def ability_3(self,target):\r\n damage = (self.get_dexterity()+self.get_strength())\r\n target.receive_damage(damage)",
"def attack(health_meter):\n hit_list = 4 * ['player'] + 6 * ['enemy']\n injured_unit = random.choice(hit_list)\n hit_points = health_meter[injured_unit]\n injury = random.randint(10, 15)\n health_meter[injured_unit] = max(hit_points - injury, 0)\n print(\"ATTACK! \", end='')\n show_health(health_meter)",
"def attack(self):\n\n lowest_attack = int(self.attack_strength)// 2\n attack_strength = random.randint(lowest_attack, int(self.attack_strength))\n return attack_strength",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between\n # half of max_damage and max_damage\n print(\"max damage of \" + self.name + \" is \")\n print(str(self.attack_strength))\n min_damage = self.attack_strength // 2\n weapon_attack_value = random.randint(min_damage, self.attack_strength)\n return weapon_attack_value",
"def __init__(self, strength, health, name, chance_dodge, chance_critical):\n self._health = health\n self.strength = strength\n self.name = name\n self.chance_dodge = chance_dodge\n self.chance_critical = chance_critical",
"def applyClassAttributes(player, classid): \r\n\r\n Classes = character.classes.Classes\r\n \r\n player.stats[ATTACKS] = Classes[classid].attacks\r\n player.stats[ATTKSKILL] = Classes[classid].attkSkill\r\n player.stats[MAXDAMAGE] = Classes[classid].maxDamage\r\n player.stats[MINDAMAGE] = Classes[classid].minDamage\r\n player.weaponText[YOUHIT] = Classes[classid].weaponText[YOUHIT]\r\n player.weaponText[YOUMISS] = Classes[classid].weaponText[YOUMISS]\r\n player.weaponText[VICTIMHIT] = Classes[classid].weaponText[VICTIMHIT]\r\n player.weaponText[VICTIMMISS] = Classes[classid].weaponText[VICTIMMISS]\r\n player.weaponText[ROOMHIT] = Classes[classid].weaponText[ROOMHIT]\r\n player.weaponText[ROOMMISS] = Classes[classid].weaponText[ROOMMISS]\r\n player.weaponText[BS_HIT_YOU] = Classes[classid].weaponText[BS_HIT_YOU]\r\n player.weaponText[BS_HIT_VICTIM] = Classes[classid].weaponText[BS_HIT_VICTIM]\r\n player.weaponText[BS_HIT_ROOM] = Classes[classid].weaponText[BS_HIT_ROOM]\r\n player.stats[MAXHP] = Classes[classid].maxhp\r\n player.stats[HP] = Classes[classid].maxhp\r\n player.stats[STEALTH] = Classes[classid].stealth\r\n player.stats[CRITICAL] = Classes[classid].critical\r\n player.stats[DODGE] = Classes[classid].dodge\r\n player.classid = Classes[classid].classid\r\n player.stats[BS_MULTIPLIER] = Classes[classid].bsmultiplier\r\n player.playerclass = Classes[classid].name",
"def attack(self):\n return random.randint(0, self.attack_strength)",
"def strength(self, strength):\n self._characterStrength = intToStrength[strength]\n if self._characterStrength == 'Health': self.characterHealth = 100\n elif self._characterStrength == 'Power': self.characterPower = 15\n elif self._characterStrength == 'Smarts': self.characterSmarts = 20",
"def get_strength(self):\n return 10 - self.get_agility()",
"def LevelUpPlayer(self):\n self.lvl += 1\n self.skillPts += 1\n percent = 0.5\n if self.lvl > 8:\n percent = 0.45 # reduce how much xp is added once higher level\n elif self.lvl > 16:\n percent = 0.4\n elif self.lvl > 25:\n percent = 0.3\n self.xpNeeded = floor(self.xpNeeded + self.xpNeeded * percent)",
"def attack(self):\n\t if self.damage == 0:\n\t\treturn None\n\t elif self.name == \"die\":\n\t roll = random.randint(1,20)\n\t if roll == 1:\n\t return 0\n\t else:\n\t return 1\n\t elif self.damage == 1 or self.damage == 2:\n\t\treturn self.damage\n\t elif self.damage == 3:\n\t\treturn random.randint(3,5)\n\t elif self.damage == -4:\n\t return 4\n\t elif self.damage == 10:\n\t\trandomInt = random.randint(1,4)\n\t\tif randomInt == 1:\n\t\t return 10\n\t\telse:\n\t\t return 0\n\t else:\n\t return self.damage",
"def increase(self,player):\n\n if self.level is not None:\n increase_roll = (random.randint(0,player.level))\n\n if skill.level < (player.level/2):\n bonus_threshold = .5\n else:\n bonus_threshold = .75\n\n if increase_roll/player.level >= bonus_threshold:\n skill.level +=2\n else:\n skill.level +=1\n\n return skill.level\n\n else:\n return None",
"def __init__(self, Strength:int, Defense:int):\n if (Strength + Defense) <= 7:\n if Strength <= 5:\n if Defense <= 5:\n self.Strength = Strength\n self.Defense = Defense\n else:\n raise ValueError(\"Total Power is over 7\")",
"def __init__(self, caster,\r\n mp_cost=2, damage=2, alias='大力戳', key='A2'):\r\n super(Skill_attack2, self)\\\r\n .__init__(caster=caster, mp_cost=mp_cost, damage=damage, alias=alias, key=key)",
"def attack(self):\n return random.randint(self.max_damage//2, self.max_damage)",
"def gainLevelUp(self, statsOnly=True):\n # Gain stats\n roundUpStrength = sumRollsOver(self._baseStrength, self.levelupStrength)\n self._baseStrength += self.levelupStrength\n displayStrengthGain = int(math.floor(self.levelupStrength))\n if roundUpStrength:\n displayStrengthGain += 1\n\n roundUpDexterity = sumRollsOver(self._baseDexterity, self.levelupDexterity)\n self._baseDexterity += self.levelupDexterity\n displayDexterityGain = int(math.floor(self.levelupDexterity))\n if roundUpDexterity:\n displayDexterityGain += 1\n\n roundUpCunning = sumRollsOver(self._baseCunning, self.levelupCunning)\n self._baseCunning += self.levelupCunning\n displayCunningGain = int(math.floor(self.levelupCunning))\n if roundUpCunning:\n displayCunningGain += 1\n\n roundUpSorcery = sumRollsOver(self._baseSorcery, self.levelupSorcery)\n self._baseSorcery += self.levelupSorcery\n displaySorceryGain = int(math.floor(self.levelupSorcery))\n if roundUpSorcery:\n displaySorceryGain += 1\n\n roundUpPiety = sumRollsOver(self._basePiety, self.levelupPiety)\n self._basePiety += self.levelupPiety\n displayPietyGain = int(math.floor(self.levelupPiety))\n if roundUpPiety:\n displayPietyGain += 1\n\n roundUpConstitution = sumRollsOver(self._baseConstitution, self.levelupConstitution)\n self._baseConstitution += self.levelupConstitution\n displayConstitutionGain = int(math.floor(self.levelupConstitution))\n if roundUpConstitution:\n displayConstitutionGain += 1\n\n self._baseHP += self.levelupHP\n self._baseMP += self.levelupMP\n\n self.HP = self.totalHP\n self.MP = self.totalMP",
"def update_strength(self, strength):\n\n self.strength = strength\n self.right_leg.strength = strength\n self.finite_leg.strength = strength\n self.left_leg.strength = strength",
"def weaponValue(self, level):\n if level == 1:\n bonus = 2\n elif level == 2:\n bonus = 4\n elif level == 3:\n bonus = 6\n elif level == 4:\n bonus = 8\n else:\n bonus = 0\n\n return bonus",
"def show_strength(self):\n print(self.name, \"has a strength of\", str(self.strength))",
"def attack(self, other):\n print(self.name, \"attacks\", other.name)\n damage = self.strenght*(1.-other.defense)\n print(\"damage: \", damage)\n other.hp -= damage\n print(other.name+\"'s remaining health: \", other.hp,)\n print(\"----------\")",
"def takeHit(self, amount, type, enemyShip):\n if type == 'energy':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount\n amount = 0\n else:\n amount -= self.currentSP\n self.currentSP = 0\n # go through armor next\n if self.currentAP > 0 and amount > 0:\n # set experience only if shot goes through shields\n if self.typeAP == 'energy':\n if self.currentAP >= (amount * globals.reflectiveArmorModifier):\n self.currentAP -= (amount * globals.reflectiveArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.reflectiveArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n elif type == 'impact':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount/2\n amount = amount/2\n else:\n amount -= self.currentSP\n self.currentSP = 0\n \n # now goto armor\n if self.currentAP > 0 and amount > 0:\n if self.typeAP == 'impact':\n if self.currentAP >= (amount * globals.impactArmorModifier):\n self.currentAP -= (amount * globals.impactArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.impactArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n \n # now that shields and armor are taken care of transfer remaining damage to internal components\n self.myParent.setExperience(amount, enemyShip)\n componentDamage = 0\n if amount > 0 and self.components != {}:\n while amount > 0:\n keyList = funcs.sortStringList(self.components.keys())\n componentDamage = 1\n for componentID in keyList:\n component = self.components[componentID]\n if component.currentHP > amount:\n component.currentHP -= amount\n amount = 0\n break\n elif component.currentHP > 0:\n # remove component\n amount -= component.currentHP\n del self.components[componentID]\n \n # check if all components destroyed, or damage absorbed\n if self.components == {} or amount == 0:\n break\n \n if componentDamage == 1:\n self.setMyStatus()\n self.myParent.setMyStatus()\n \n if amount > 0:\n if self.myParent.currentISP > amount:\n self.myParent.currentISP -= amount\n self.myParent.setMyStatus()\n amount = 0\n else:\n self.myParent.destroyMe()\n amount = 0\n \n self.myParent.updateAllGUIValues()",
"def update_strength(self, strength):\n\n self.strength = strength\n self.right_leg.strength = strength\n self.front_leg.strength = strength\n self.left_leg.strength = strength\n self.back_leg.strength = strength",
"def zombie_attack(self):\n cast = self.cast\n walls = cast['walls']\n hero = cast['hero']\n tower = cast['tower']\n counter = 0\n counter += 1 \n if counter != 30:\n pass\n else:\n for wall in walls:\n if self.collides_with_sprite(wall):\n wall.get_hit()\n self.velocity = (0,0)\n #TODO create strength attribute for each class. \n #TODO lower strength of zombie & stop zombie when collides with hero",
"def use_skill(self, g, i, x, y):\n # @ param g a reference to the game engine\n # @ param i the index of the skill (basically what skill)\n # @ param x the x target coordinate in game pixels\n # @ param y the y target coordinate in game pixels\n if self.attackTimer < self.attackDelay:\n print(\"attack on CD\")\n return\n \n if self.skill[i].skillAttr == 0:\n g.fire_skill_sound.play()\n elif self.skill[i].skillAttr == 1:\n g.ice_skill_sound.play()\n elif self.skill[i].skillAttr == 2:\n g.lightning_skill_sound.play()\n elif self.skill[i].skillAttr == 3:\n g.poison_skill_sound.play()\n \n \n if self.skill[i].skillKey == 0: #Aura\n #turn the aura on/off\n if self.skill[i].active == False:\n #print(\"aura on\")\n self.skill[i].active = True\n else:\n self.skill[i].active = False\n #print(\"aura off\")\n \n elif self.skill[i].skillKey == 1: #Missile\n if self.mana[0] > self.skill[i].skillCost:\n self.mana[0] -= self.skill[i].skillCost\n self.attackTimer = 0\n target = Target(x, y)\n center_x = self.rect.x + (self.rect.width / 2)\n center_y = self.rect.y + (self.rect.height / 2)\n #bullet types: fire 5, ice 6, lightning 7\n #skill types: fire 0, ice 1, lightning 2\n g.bullets.append(self.bulletFactory.createBullet(g, self.skill[i].skillAttr + 5, 0, self.attack, 1024, target, center_x, center_y))\n #print(\"missile\")\n\n elif self.skill[i].skillKey == 2: #Breath\n #for each creep in the AoE cone, do damage.\n if self.mana[0] > self.skill[i].skillCost:\n self.mana[0] -= self.skill[i].skillCost\n self.attackTimer = 0\n #get low and high angle (-45 degrees and +45 degrees from player -> point angle)\n lowAngle = math.atan2(y - self.rect.centery, x - self.rect.centerx) - 3.1415 / 2.0\n highAngle = math.atan2(y - self.rect.centery, x - self.rect.centerx) + 3.1415 / 2.0\n for creep in g.creeps:\n #get angle to creep\n creepAngle = math.atan2(creep.rect.centery - self.rect.centery, creep.rect.centerx - self.rect.centerx)\n \n #if angle to the creep is between the two angles\n if creepAngle > lowAngle and creepAngle < highAngle:\n #and the distance to the creep is below the skill's range\n if ( (creep.rect.centerx - self.rect.centerx) ** 2 + (creep.rect.centery - self.rect.centery) ** 2 ) ** 0.5 < 4 * 24:\n creep.take_damage( self.attack )\n #print(\"breath\")\n #apply debuffs, based on type\n if self.skill[i].skillAttr == 0: #fire\n creep.applyBurning()\n elif self.skill[i].skillAttr == 1: #frost\n creep.applyChilled()\n elif self.skill[i].skillAttr == 2: #lightning\n creep.applyShocked()",
"def calculate_hit(self, armor_list, inventory):\n armor_power = 0\n for armor in armor_list:\n armor_power += inventory[armor]['power']\n max_strength = max(1, (self.level * 5) - armor_power)\n min_strength = 0\n return random.randint(min_strength, max_strength)",
"def attackProcess(attack: \"Attack\", attacker: \"PlayerCharacter or Monster\", enemies: list, targetID: int):\n hits, target, ail = 1, [targetID], None\n damageRange, critChance, critMultiplier = (95, 105), 0.1, 2\n if (attack.special):\n hits = attack.special[\"HITS\"] if \"HITS\" in attack.special.keys() else 1\n target = attack.special[\"TARGET\"] if \"TARGET\" in attack.special.keys() else target\n ail = attack.special[\"INFLICT\"] if \"INFLICT\" in attack.special.keys() else None\n damageRange = attack.special[\"DAMAGE RANGE\"] if \"DAMAGE RANGE\" in attack.special.keys() else damageRange\n critChance = attack.special[\"CRIT CHANCE\"] if \"CRIT CHANCE\" in attack.special.keys() else critChance\n critMultiplier = attack.special[\"CRIT MULTIPLIER\"] if \"CRIT MULTIPLIER\" in attack.special.keys() else critMultiplier\n target = targeting(len(enemies), target, hits)\n if attack.category == \"MAGICAL\":\n attackerPower = attacker.stats[\"MAGIC\"]\n attackerPower *= 0.6 if \"MUDDLE\" in attacker.conditions.keys() else 1\n else:\n attackerPower = attacker.stats[\"STRENGTH\"]\n attackerPower *= 0.6 if \"BURN\" in attacker.conditions.keys() else 1\n attackerPower *= 0.8 if \"LETHARGY\" in attacker.conditions.keys() else 1\n power = attack.power * attackerPower\n for i in target:\n roll = random.random()\n targetSpeed = 1 if \"STUN\" in enemies[i].conditions.keys() else enemies[i].stats[\"SPEED\"]\n hitChance = ((attacker.stats[\"SPEED\"] + attackerPower/10) / targetSpeed)\n hitChance *= 0.6 if \"BLIND\" in attacker.conditions.keys() else 1\n hitCheck = roll < hitChance\n if hitCheck:\n critCheck = roll < critChance\n resist = enemies[i].resist[attack.element] if attack.element in enemies[i].resist.keys() else 1\n damage = power * resist * (random.randint(damageRange[0], damageRange[1])/100)\n if critCheck:\n damage *= critMultiplier\n print(\"Critical hit!\")\n damage /= 2 if enemies[i].defend else 1\n damage //= enemies[i].stats[\"DEFENSE\"] if attack.category == \"PHYSICAL\" else enemies[i].stats[\"RESISTANCE\"]\n enemies[i].hp -= damage\n if enemies[i].hp < 0:\n enemies[i].ko = True\n enemies[i].hp = 0\n print(f\"\\n{attacker.name}'s {attack.name} dealt {damage} damage to {enemies[i].name}!\")\n print(f\"{enemies[i].name} {enemies[i].hp}/{enemies[i].stats['MAXHP']}\\n\")\n if ail and not enemies[i].ko:\n inflict(ail, enemies[i])\n else:\n print(f\"\\n{attacker.name} missed!\")\n attacker.wait = attack.wait * (100 - (1 if \"STUN\" in attacker.conditions.keys() else attacker.stats[\"SPEED\"])) // 1000",
"def addStrength(self):\n\t\tself.strength += 1\n\t\tif self.strength > 10:\n\t\t\tself.strength = 10",
"def calculate_hit(self):\n weapon = self.game_data['player inventory']['equipped weapon']\n weapon_power = self.game_data['player inventory'][weapon]['power']\n max_strength = weapon_power\n min_strength = max_strength - 7\n return random.randint(min_strength, max_strength)",
"def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res",
"def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum",
"def Attack_Weapon(self, bonus=0):\n bonus = str(bonus);\n if (bonus == \"0\"):\n return \"\".join((\"[[1d20+\", self.Attribute_Power(\"attack\"), \"]] vs \", self.Attribute_Power(\"def\")));\n else:\n return \"\".join((\"[[1d20+\", self.Attribute_Power(\"attack\"), \"+\", bonus, \"]] vs \", self.Attribute_Power(\"def\")));",
"def SADamageFunction(\n skill: AdventurerSkill | None,\n adventurer: \"Adventurer\",\n enemy: \"Enemy\",\n memboost: dict[str, int | float],\n combo: int,\n saRng: float,\n) -> int:\n if skill is None:\n return 0\n\n # lowercase everything\n target = skill.target.lower()\n tempBoostName = skill.tempBoost.lower()\n powerCoefficientName = skill.powerCoefficient.lower()\n powerCoefficient = 1.0\n\n if tempBoostName == \"none\":\n tempBoost = 1.0\n elif \"normal\" in tempBoostName:\n tempBoost = 1.4\n else:\n tempBoost = 1.7\n\n if skill.target == \"foe\":\n match powerCoefficientName:\n case \"low\" | \"lo\":\n powerCoefficient = 1.5\n case \"mid\" | \"medium\":\n powerCoefficient = 1.7\n case \"high\":\n powerCoefficient = 1.9\n case \"super\":\n powerCoefficient = 2.1\n case \"ultra\":\n powerCoefficient = 4.0\n else:\n match powerCoefficientName:\n case \"low\" | \"lo\":\n powerCoefficient = 1.1\n case \"mid\" | \"medium\":\n powerCoefficient = 1.15\n case \"high\":\n powerCoefficient = 1.2\n case \"super\":\n powerCoefficient = 1.4\n case \"ultra\":\n powerCoefficient = 3.6\n\n if \"physical\" in skill.type:\n stat_key = \"strength\"\n resist_key = \"physical\"\n else:\n stat_key = \"magic\"\n resist_key = \"magic\"\n\n tempPower = adventurer.stats[stat_key]\n tempPowerBoostAdv = adventurer.statsBoostAdv[stat_key]\n tempPowerBoostAst = adventurer.statsBoostAst[stat_key]\n tempMemBoost = memboost[stat_key]\n\n tempTypeResistDownBase = enemy.typeResistDownBase[resist_key]\n tempTypeResistDownAdv = enemy.typeResistDownAdv[resist_key]\n tempTypeResistDownAst = enemy.typeResistDownAst[resist_key]\n # check enemy buffs p/m resist\n tempTypeResistBuff = enemy.get_buff_mod(f\"{resist_key}_resist\")\n\n # get strength/magic debuff\n powerDebuff = adventurer.get_boostCheckAdv(False, stat_key)\n tempPowerBoostDebuff = 0.0\n if powerDebuff is not None:\n tempPowerBoostDebuff = abs(powerDebuff.modifier)\n else:\n tempPowerBoostDebuff = 0\n\n if len(skill.index_to) != 0:\n tempPower = 0\n tempPowerBoostAdv = 0.0\n tempPowerBoostAst = 0.0\n tempMemBoost = 0\n powerCoefficient = powerCoefficient * 1.96\n for index_to_attributes in skill.index_to:\n tempPower += adventurer.stats[index_to_attributes]\n tempPowerBoostAdv += adventurer.statsBoostAdv[index_to_attributes]\n tempPowerBoostAst += adventurer.statsBoostAst[index_to_attributes]\n tempMemBoost += memboost[index_to_attributes]\n tempElementBoostDebuff = 0.0\n if skill.element != \"\" and skill.noType != 1:\n # elementResistDownBase\n tempElementResistDownBase = enemy.elementResistDownBase[skill.element]\n # elementResistDownAdv\n tempElementResistDownAdv = enemy.elementResistDownAdv[skill.element]\n # elementResistDownAst\n tempElementResistDownAst = enemy.elementResistDownAst[skill.element]\n # elementDamageBoostAdv[location]\n\n tempElementDamageBoostAdv = adventurer.elementDamageBoostAdv[skill.element]\n if memboost.get(f\"{skill.element}_attack\") is not None:\n tempElementDamageBoostAdv += memboost[f\"{skill.element}_attack\"]\n # elemental damage boost from weapon\n if adventurer.stats.get(skill.element) is not None:\n tempElementDamageBoostAdv += cast(float, adventurer.stats[skill.element])\n # elementDamageBoostAst[location]\n tempElementDamageBoostAst = adventurer.elementDamageBoostAst[skill.element]\n # element debuff\n tempEleDebuff = adventurer.get_boostCheckAdv(False, f\"{skill.element}_attack\")\n if tempEleDebuff is not None:\n tempElementBoostDebuff = abs(tempEleDebuff.modifier)\n else:\n tempElementResistDownBase = 0.0\n tempElementResistDownAdv = 0.0\n tempElementResistDownAst = 0.0\n tempElementDamageBoostAdv = 0.0\n tempElementDamageBoostAst = 0.0\n\n if target == \"foe\":\n temptargetResistDownAdv = enemy.targetResistDownAdv[\"st\"]\n temptargetResistDownAst = enemy.targetResistDownAst[\"st\"]\n # foes\n else:\n temptargetResistDownAdv = enemy.targetResistDownAdv[\"aoe\"]\n temptargetResistDownAst = enemy.targetResistDownAst[\"aoe\"]\n\n temp_enemy_end = enemy.stats\n\n tempDamage = (\n (\n max(\n 2\n * tempPower\n * tempBoost\n * (\n 1\n + tempPowerBoostAdv\n + tempPowerBoostAst\n + tempMemBoost\n - tempPowerBoostDebuff\n )\n - temp_enemy_end[\"endurance\"],\n 0,\n )\n )\n * (\n 1\n - tempElementResistDownBase\n - tempElementResistDownAdv\n - tempElementResistDownAst\n - tempTypeResistDownBase\n - tempTypeResistDownAdv\n - tempTypeResistDownAst\n - tempTypeResistBuff\n )\n * (\n 1\n + tempElementDamageBoostAdv\n + tempElementDamageBoostAst\n - tempElementBoostDebuff\n )\n * (1 + adventurer.critPenBoost + 0.06)\n * (1 - temptargetResistDownAdv - temptargetResistDownAst)\n * powerCoefficient\n * 1.5\n * (skill.extraBoost)\n * (0.8 + combo * 0.2)\n * saRng\n )\n return int(tempDamage)",
"def gain(self, target_attr, attr, debug=False):\n current_entropy = self.entropy(target_attr)[0]\n # print\n # print attr\n\n gain = current_entropy - self.remainder(target_attr=target_attr, attr=attr)\n if debug is True:\n print attr, \": \", gain\n return gain",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between half of max_damage and max_damage\n \n weapon_attack_value = random.randint(self.max_damage//2, self.max_damage)\n return weapon_attack_value",
"def Attack_Skill(self, bonus=0):\n bonus = str(bonus);\n if (bonus == \"0\"):\n return \"\".join((\"[[1d20+\", Attribute(\"halflevel\"), \"[level/2]+\", self.Attribute_Power(\"mod\"), \"+\", self.Attribute_Power(\"attack-misc\"), \"]] vs \", self.Attribute_Power(\"def\")));\n else:\n return \"\".join((\"[[1d20+\", Attribute(\"halflevel\"), \"[level/2]+\", self.Attribute_Power(\"mod\"), \"+\", self.Attribute_Power(\"attack-misc\"), \"+\", bonus, \"]] vs \", self.Attribute_Power(\"def\")));",
"def weapon_strength(weapon):\n weapon_strength_int = WEAPON_STRENGTHS[weapon]\n #print weapon_strength_int\n return weapon_strength_int",
"def testrandom(self):\n for i in range(100):\n WeaponAbility()",
"def __attack(self, target):\n attack_difference = (Warrior.attack(self, target))\n if attack_difference > 5:\n print(\"Second attack with ANGRY!\")\n Warrior.attack(self, target)\n return None",
"def attack(self, enemies):\n return super().attack(enemies, self.range, self.in_range, self.damage, 16)",
"def attack_success(self) -> float:\n return (0.5 * (1 + self.health / 100) *\n random.randint(50 + self.experience, 100) / 100)",
"def difficulty_for_level(level):\n return 0 if level==\"easy\" else (1 if level==\"medium\" else 2)",
"def get_weapon_stats(attack_level):\n if attack_level >= 60:\n # Dragon scimitar\n return (67, 66)\n elif attack_level >= 40:\n # Rune scimitar\n return (45, 44)\n elif attack_level >= 30:\n # Adamant scimitar\n return (29, 28)\n elif attack_level >= 20:\n # Mithril scimitar\n return (21, 20)\n elif attack_level >= 10:\n # Black scimitar\n return (19, 14)\n elif attack_level >= 5:\n # Steel scimitar\n return (15, 14)\n else:\n # Iron scimitar\n return (10, 9)",
"def attack(self, *args, **kwargs):\n return self(AbilityId.ATTACK, *args, **kwargs)",
"def attack(self, character):\n\n character.hp -= max(0, (self.atk - character.defense))",
"def trump(self):\n attack = None\n other = self.enemy.enemy_trump(self.other_hand.get_hand())\n me = self.player.player_trump(self.my_hand.get_hand())\n if other == None and me != None:\n attack = 0\n else:\n if other != None and me == None:\n attack = 1\n else:\n if other == None and me == None:\n attack = randint(0, 1)\n else:\n if other.weight < me.weight:\n attack = 1\n else:\n attack = 0\n return attack",
"def bless_advanced(unit):\n return {DAMAGE: unit.maximum_damage + 1}",
"def compute_strength(self):\n for card in self._deck.cards:\n self._strength = self._strength + card.attack",
"def checkhealth(currentstrength, currenthunger):\n global HUNGER\n global STRENGTH\n flash = False\n grizzly_text = \"\"\n\n if currentstrength <= 0:\n if FIGHT:\n if GRIZZLY_BEAR:\n grizzly_text = \"grizzly \"\n printmessage(\"The %sbear has killed you.\" % grizzly_text, 7, MAGENTA, 2)\n else:\n printmessage(\"You have died from severe exhaustion.\", 5, RED, 2)\n die('tooweak')\n\n for i in range(0, 5): \n strengthrange = (79, 59, 39, 19, 0)\n if currentstrength in range(strengthrange[i], strengthrange[i] + 20):\n STRENGTH = STRENGTH_TEXT[i]\n if currentstrength > 99:\n STRENGTH = STRENGTH_TEXT[0]\n if currentstrength <= 19: \n flash = True\n update_strength(flash)\n flash = False # Make sure flash isnt incorrectly set for hunger too\n\n if currenthunger <= 0:\n printmessage(\"You have died from malnutrition.\", 5, RED, 2)\n die('starved')\n\n for i in range(0, 5): \n hungerrange = (79, 59, 39, 19, 0)\n if currenthunger in range(hungerrange[i], hungerrange[i] + 20): \n HUNGER = HUNGER_TEXT[i]\n if currenthunger > 99:\n HUNGER = HUNGER_TEXT[0]\n if currenthunger <= 19: \n flash = True\n update_hunger(flash)",
"def attributes(c):\n global cfg # pylint: disable=global-variable-not-assigned\n if int(c['xp01']) >= cfg['card']['xp_limit']:\n return 'evolve'\n else:\n return 'level'",
"def attack(attacker, defender):\n if randint(1, 100) < attacker['rage']:\n defender['health'] -= randint(attacker['damage high'],\n attacker['damage low'])\n attacker['rage'] = 0\n else:\n defender['health'] -= randint(attacker['damage high'],\n attacker['damage low'])\n attacker['rage'] += 15",
"def calc_tohit(attr, level):\n return level + calc_attr_mod(attr)",
"def setAssaultStrength(self, ratio):\n assaultStrength = int(float(self.maxAssault) * ratio)\n if self.isAssault == 1:\n self.assaultStrength = assaultStrength\n else:\n self.assaultStrength = assaultStrength + self.getPersonStrength()",
"def test_strength(self):\n\n self.sold.health = 0.7\n self.sold.experience = 10\n self.assertEqual(self.sold.strength, 0.9)",
"def enemyrawdmg(self):\n\n enemystr = globalvalues.ai.getstatus()[3]\n # rngfactor will ensure that regular mobs won't absolutely crush you\n rngfactor = float(float(random.randint(45, 65)) / 100)\n level = (\n globalvalues.p1.getlevel()\n - globalvalues.ai.getstatus()[0]\n )\n lvlfactor = float(1 - level * 0.05)\n\n return int((enemystr) * 102 * 0.12 * rngfactor * lvlfactor)",
"def assign(self,player,hcp):\n\n # Higher hcp = higher bonus potention (max 100)\n assert hcp <= 100, 'Skill handicap cannot be >100 hcp : {0}'.format(\n hcp)\n\n if self.level is not None:\n base,bonus = RandomRoll(player,self,hcp)\n\n if base and bonus:\n self.level += random.randint(3)+1\n elif base:\n self.level += random.randint(2)",
"def updateScore(self,ability,amount):\n abilities = {'str':'strength','dex':'dexterity',\n 'con':'constitution','int':'intelligence',\n 'wis':'wisdom','cha':'charisma',\n 'hp':'hit points'}\n if ability == 'str':\n self.str += amount\n print \"You added {0} point(s) to the {1} stat.\".format(amount,abilities[ability])\n elif ability == 'dex':\n self.dex += amount\n print \"You added {0} point(s) to the {1} stat.\".format(amount,abilities[ability])\n elif ability == 'con':\n self.con += amount\n print \"You added {0} point(s) to the {1} stat.\".format(amount,abilities[ability])\n elif ability == 'int':\n self.int += amount\n print \"You added {0} point(s) to the {1} stat.\".format(amount,abilities[ability])\n elif ability == 'wis':\n self.wis += amount\n print \"You added {0} point(s) to the {1} stat.\".format(amount,abilities[ability])\n elif ability == 'cha':\n self.cha += amount\n print \"You added {0} point(s) to the {1} stat.\".format(amount,abilities[ability])\n elif ability == 'hp':\n self.hp += amount\n print \"You added {0} point(s) to the {1} stat.\".format(amount,abilities[ability])\n else:\n print \"Please use 'str','dex','con','int','wis', or 'cha' as input.\"",
"def attack1(self, command):\n\n if random.randint(1,3) == 1 or random.randint(1,3) == 3:\n p.health -= self.weapon[0].damage\n print(\"You've been hit! \\nHealth at \" + str(p.health))\n else:\n print('Enemy tried to attack, missed!')",
"def setMyStrength(self):\n ispRatio = float(self.currentISP/self.myShipHull.maxISP)\n myComponents = 0\n designComponents = 0\n for position, myQuad in self.quads.iteritems():\n myComponents += len(myQuad.components)\n for position, myQuad in self.myDesign.quads.iteritems():\n designComponents += len(myQuad.components)\n\n self.strength = (ispRatio * float(myComponents)/float(designComponents))*100.0",
"def addLevel(self, amount):\r\n debug.write(\"[SourceRPG] Handling addLevel\", 1)\r\n self.player['level'] += amount\r\n \r\n \"\"\" If turbo mode is on multipliy the credits received \"\"\"\r\n if currentTurboMode:\r\n self.player['credits'] += int( amount * int(creditsReceived) * float(turboCreditMultiplier))\r\n else:\r\n self.player['credits'] += amount * int(creditsReceived)\r\n \r\n \"\"\" Check if the level has reached the limit \"\"\"\r\n if int(maxLevel) and self.player['level'] > int(maxLevel):\r\n debug.write(\"Maximum level reached, ensure that resetSkills\", 1)\r\n \"\"\" If we want to reset the skills, reset them \"\"\"\r\n if int(maxLevelReset):\r\n self.resetSkills()\r\n tell(self.userid, 'maximum level reached')\r\n debug.write(\"Levels Reset\", 1)\r\n else:\r\n \"\"\" Othewise assign the level and XP to the maximum possible \"\"\"\r\n self.player['level'] = int(maxLevel)\r\n self.player['xp'] = (self.player['level'] - 1) * int(xpIncrement) + int(startXp) - 1\r\n debug.write(\"Assigned XP to maximum value\", 1)\r\n else: \r\n \"\"\" The level is okay, check for bots and play the message etc \"\"\"\r\n if not self.player.isbot:\r\n debug.write(\"Player is not a bot\", 2)\r\n \"\"\" Only do the following for humans \"\"\"\r\n if not int(levelUp):\r\n tokens = {}\r\n tokens['level'] = self.player['level']\r\n tokens['xp'] = self.player['xp']\r\n tokens['nextxp'] = (self.player['level'] - 1) * int(xpIncrement) + int(startXp) - self.player['xp']\r\n tell( self.userid, 'level gained private', tokens )\r\n \r\n if self.player['popup']:\r\n debug.write(\"Building skill menu\", 1)\r\n buildSkillMenu(self.userid)\r\n \r\n else:\r\n \"\"\" Player is a bot, check for the maximum possible level for a bot \"\"\"\r\n debug.write(\"Bot leveled up, choose a random skill\", 2)\r\n if int(botMaxLevel) and self.player['level'] > int(botMaxLevel):\r\n debug.write(\"Reset bot's skills, maximum level achieved\", 2)\r\n self.resetSkills()\r\n else:\r\n \"\"\" Upgrade a random skill if possible \"\"\"\r\n while True:\r\n \"\"\" Loop until we manually break \"\"\"\r\n possibleChoices = []\r\n credits = self.player['credits']\r\n for skill in skills:\r\n \"\"\" \r\n Iterate through all loaded skills and if the bot\r\n can afford the skill, append it to the possible choices\r\n \"\"\"\r\n if credits >= self.player[skill.name] * skill.creditIncrement + skill.startCredit:\r\n if self.player[skill.name] < skill.maxLevel:\r\n possibleChoices.append(skill.name)\r\n if not possibleChoices:\r\n \"\"\" \r\n The bot cannot afford any skills or has maxed out\r\n the skills, the manually break\r\n \"\"\"\r\n break\r\n \r\n \"\"\" \r\n Finally call the checkSkillForUpgrading function passing\r\n the arguments manually rather than letting a popup do it\r\n \"\"\"\r\n debug.write(\"Checking to update a skill\", 2)\r\n checkSkillForUpgrading(self.userid, random.choice(possibleChoices), None, False )\r\n \r\n if int(levelUp):\r\n tokens = {}\r\n tokens['name'] = self.player.name\r\n tokens['level'] = self.player['level']\r\n tokens['xp'] = self.player['xp']\r\n tokens['nextxp'] = (self.player['level'] - 1) * int(xpIncrement) + int(startXp)\r\n \r\n for userid in filter( lambda x: not es.isbot(x), es.getUseridList()):\r\n tell(userid, 'level gained global', tokens)\r\n \r\n if str(levelupSound):\r\n es.emitsound('player', self.userid, str(levelupSound), 0.7, 0.5 )\r\n \r\n \"\"\" Create and fire the levelup event \"\"\"\r\n values = {}\r\n values[\"userid\"] = (\"setint\", self.userid)\r\n values[\"newlevel\"] = (\"setint\", self.player['level'])\r\n values[\"oldlevel\"] = (\"setint\", self.player['level'] - amount)\r\n values[\"amount\"] = (\"setint\", amount)\r\n values[\"xp\"] = (\"setint\", self.player['xp'])\r\n values[\"xpneeded\"] = (\"setint\", (self.player['level'] - 1) * int(xpIncrement) + int(startXp))\r\n gamethread.delayed(0, fireEvent, (\"sourcerpg_levelup\", values))\r\n debug.write(\"[SourceRPG] Handled addLevel\", 1)",
"def upgrade(self):\n if self.level < len(self.tower_images):\n self.level_up_animation = True\n self.level += 1\n self.base_damage += 3\n self.damage = self.base_damage\n\n #Since level does not upgrade in menu we have to manually do it here\n self.menu.tower_level += 1",
"def damageSubtractor(self, damage, target, caller):\n # Build the target av objects\n target_shield_value = target.db.shield_value # Applied conditionally\n target_armor = target.db.armor\n target_tough = target.db.tough\n target_armor_specialist = target.db.armor_specialist\n\n # Apply damage in order\n if target_shield_value:\n # Get value of shield damage to check if it's under 0. Need to pass\n # this on to armor\n shield_damage = target_shield_value - damage\n if shield_damage < 0:\n # Check if damage would make shield go below 0\n damage = abs(shield_damage)\n # Set shield_value to 0\n target.db.shield_value = 0\n # Recalc and set av with new shield value\n else:\n target.db.shield_value = shield_damage\n damage = 0\n\n if target_armor_specialist and damage:\n # Get value of damage\n armor_specialist_damage = target_armor_specialist - damage\n if armor_specialist_damage < 0:\n damage = abs(armor_specialist_damage)\n target.db.armor_specialist = 0\n else:\n target.db.armor_specialist = armor_specialist_damage\n damage = 0\n\n if target_armor and damage:\n # Get value of damage\n armor_damage = target_armor - damage\n if armor_damage < 0:\n damage = abs(armor_damage)\n target.db.armor = 0\n else:\n target.db.armor = armor_damage\n damage = 0\n\n if target_tough and damage:\n tough_damage = target_tough - damage\n if tough_damage < 0:\n damage = abs(tough_damage)\n target.db.tough = 0\n else:\n target.db.tough = tough_damage\n damage = 0\n else:\n self.deathSubtractor(damage, target, caller)\n\n new_av = self.updateArmorValue(target.db.shield_value, target.db.armor, target.db.tough, target.db.armor_specialist)\n\n return new_av",
"def apply_ex(player: Player) -> None:\n getattr(combat_effects, \"inflict_ex_\" + player.character_class)",
"def do_normal(self, game, elfDict):\n self.normal_update(game, elfDict)\n self.aggressive.update_attack_portals(game)\n\n self.portals.dumb_portal_defense(PORTAL_SELF_DEFENSE_MANA_CAP)\n self.normal_defense() # defend the castle (if there are enemies in range)\n self.aggressive.build_portals(game, elfDict) # build the flanking poratls, might need to be in\n self.start.do_start(game, elfDict) # maintain defense portals and fountains\n\n self.normal_elf_defendcastle(elfDict) # destroy buildings in range of defense radius(CASTLE_DEFENSE)\n\n # drain enemy mana if our mana is above our set limite\n self.new_mana_bait(LAVA_DRAIN_MANA_LIMIT)\n #self.normal_portal_defense(self.game.get_my_portals()) # test dis mojo\n\n\n # if self.game.get_enemy_mana() < ENEMY_LOW_MANA_ATTACK and self.game.get_my_mana() > NORMAL_ATTACK_MODE_MANA_CAP: # attack more? might be used more\n # self.normal_attack_lowMana(self.attackDict) # become more aggresive in normal if the enemy is low on\n # on mana and we have enough.",
"def penalty(self):\n return 0",
"def Troll(self):\n self.type = \"Troll\"\n self.image = pygame.image.load(\"Troll.gif\")\n self.cost = 4\n self.health = 60\n self.max_health = self.health\n self.base_damage = 6 \n self.damagedice = (3,2)\n self.base_defense = 2\n self.defensedice = (3,1)\n self.color = TEAL\n self.activate()",
"def attack(self):\n # load data (CIFAR10)\n train_dataset, test_dataset = data.dataset_downloader()\n input_shape = [32, 32, 3]\n\n # count of shadow training sets\n amount_sets = 6\n\n # set ratio and size for unbalanced data sets\n size_set = 1500\n property_num_elements_per_classes = {0: 500, 1: 1000}\n\n # create shadow training sets. Half unbalanced (property_num_elements_per_classes), half balanced\n (\n property_training_sets,\n neg_property_training_sets,\n property_num_elements_per_classes,\n neg_property_num_elements_per_classes,\n ) = self.create_shadow_training_set(\n test_dataset, amount_sets, size_set, property_num_elements_per_classes\n )\n\n # create shadow classifiers with trained models, half on unbalanced data set, half with balanced data set\n (\n shadow_classifiers_property,\n shadow_classifiers_neg_property,\n accuracy_prop,\n accuracy_neg,\n ) = self.train_shadow_classifiers(\n property_training_sets,\n neg_property_training_sets,\n property_num_elements_per_classes,\n neg_property_num_elements_per_classes,\n input_shape,\n )\n\n # create meta training set\n meta_features, meta_labels = self.create_meta_training_set(\n shadow_classifiers_property, shadow_classifiers_neg_property\n )\n\n # create meta classifier\n meta_classifier = self.train_meta_classifier(meta_features, meta_labels)\n\n # extract features of target model\n feature_extraction_target_model = self.feature_extraction(self.target_model)\n\n # get prediction\n prediction = self.perform_prediction(\n meta_classifier, feature_extraction_target_model\n )\n return prediction",
"def passive(self,target):\r\n target.shield_increase(200,buff_type = \"temp\")",
"def init2(self):\n self.skill_points = self.count_skill_points()\n self.count_saves()\n self.lives = self.count_lives()\n self.base_attack = fetch_data.get_base_attack(self.BASE_ATTACK_LVLS, self.lvl)",
"def __attackDamage(self, attack, suit=0):\n if suit:\n for dmg in attack[SUIT_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0\n else:\n for dmg in attack[TOON_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0",
"def attack(self, target, friendly):\n self.on_attack(target, friendly)\n dmg = self.on_deal_dmg(target, friendly)\n self.death_remove(friendly)\n # May remove other minions in special cases\n # ... \n\n return dmg",
"def __init__(self, strength, xc, yc):\n self.strength = strength\n self.xc, self.yc = xc, yc",
"def normal_defense(self):\n if self.game.get_my_mana() > DEFENSE_MANA_CAP:\n self.portals.dumb_castle_defense(DEFENSE_MANA_CAP)\n self.portals.dumb_portal_defense(PORTAL_SELF_DEFENSE_MANA_CAP)",
"def set_damage():\n\n global character\n character['Damage'] = randint(1, 6)",
"def getWeightsAttack(self, gameState, action):\r\n return {'minDistToFood': -1,'getFood': 100}",
"def ai_w_level(gstate: TicTacToe, game_tree, level=3):\n assert isinstance(level, int), \"`level` must be `int`\"\n assert 0 <= level <= 4, \"level values must be from 0 to 4\"\n\n seed = random.random()\n logging.debug(f\"seed value: {seed:.3f}\")\n\n if level == 0:\n ai_func = ai_derp\n elif level == 1:\n ai_func = ai_derp if seed <= 0.3 else ai_strategy1\n elif level == 2:\n ai_func = ai_derp if seed <= 0.2 else ai_strategy2\n elif level == 3:\n ai_func = ai_derp if seed <= 0.1 else ai_strategy3\n elif level == 4:\n ai_func = ai_strategy3\n\n return ai_func(gstate, game_tree)",
"def punch(self, a_fighter):\n points = int(uniform(0.7,1.0)*10*self.get_strength()/a_fighter.get_agility())\n a_fighter.__health_points = a_fighter.get_health_points() - points\n return a_fighter.__health_points",
"def __init__(self,player,skill,difficulty):\n\n # Lowest possible skill roll == skill lvl - player lvl (or 0)\n lower_bound = max(0,skill.level - player.level)\n\n # Highest possible skill roll == skill lvl + 2*player level\n upper_bound = skill.level + (2*player.level)\n\n # Sets critical range (upper percentile to be considered crit)\n crit_range = player.crit_level / 100\n\n self.roll = random.randint(lower_bound,upper_bound)\n if (self.roll/upper_bound) > (1-crit_range):\n self.crit=True\n else:\n self.crit=False\n\n if self.roll >= difficulty:\n self.hit=True\n else:\n self.hit=False\n\n return self.hit, self.crit",
"def ability_bonus_on_level(self, level):\n raise NotImplementedError",
"def take_damage(self, damage):\n attack = damage - (0.05 + self.__experience / 1000)\n self.set_health(self.get_health - attack)",
"def applyDamage(state, damage) :\n newState = copy.deepcopy(state)\n # If the enemy does not have HP information, returns the same state\n if 'hp' not in state['enemy'] :\n return newState\n # Reduces HP by damage, min HP being 0\n newState['enemy']['hp'] = max(newState['enemy']['hp'] - damage, 0)\n return newState",
"def coreDamage(self, user, target):\n scale = self.getScale()\n \n damage = super(DamageScaleDelegate, self).coreDamage(user, target)-2\n damage = damage*scale\n return damage + 2"
] | [
"0.6896016",
"0.6808988",
"0.67308813",
"0.6669321",
"0.6659467",
"0.64936537",
"0.6413358",
"0.64063555",
"0.6402597",
"0.6393012",
"0.6375738",
"0.6367276",
"0.63427234",
"0.63154703",
"0.63153607",
"0.6273395",
"0.6247666",
"0.6247239",
"0.62429374",
"0.6231652",
"0.62159884",
"0.6192132",
"0.6175165",
"0.61726296",
"0.61662",
"0.6157003",
"0.60487795",
"0.6036952",
"0.60323167",
"0.60148674",
"0.60070646",
"0.60056335",
"0.5924221",
"0.59146816",
"0.59102625",
"0.5909895",
"0.5902518",
"0.5897706",
"0.58811",
"0.5864392",
"0.58556145",
"0.58374375",
"0.5835738",
"0.5835201",
"0.58199394",
"0.5793579",
"0.5786042",
"0.57831746",
"0.5762639",
"0.57484555",
"0.5745819",
"0.5734965",
"0.57339966",
"0.5726482",
"0.5724174",
"0.5714089",
"0.5703177",
"0.56994873",
"0.5698582",
"0.56959784",
"0.56948864",
"0.56706214",
"0.56537235",
"0.5650753",
"0.56459165",
"0.56446725",
"0.56430304",
"0.5634094",
"0.56163466",
"0.56005025",
"0.5598968",
"0.5595898",
"0.55950606",
"0.5580534",
"0.5576509",
"0.55722886",
"0.5566909",
"0.55555385",
"0.555212",
"0.55517286",
"0.5545474",
"0.55341864",
"0.5528998",
"0.5519198",
"0.5506516",
"0.5497085",
"0.5489825",
"0.5486897",
"0.54868096",
"0.54856247",
"0.5469955",
"0.54621994",
"0.5451281",
"0.5439431",
"0.54357135",
"0.54347444",
"0.54239726",
"0.54167193",
"0.54093677",
"0.5406709"
] | 0.65988123 | 5 |
ability that deals damage to the target | def ability_1(self,target):
damage = (self.get_strength()+2)
target.receive_damage(damage) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ability_3(self,target):\r\n damage = (self.get_dexterity()+self.get_strength())\r\n target.receive_damage(damage)",
"def ability_4(self,target):\r\n damage = (self.get_strength()*3)\r\n target.receive_damage(damage)",
"def ability_2(self,target):\r\n damage1 = (self.get_lvl()+self.get_strength())\r\n target.receive_damage(damage1)",
"def _attack(self,target):\r\n damage = self.get_strength() * self.get_lvl()\r\n target.receive_damage(damage)",
"def attack(self, target, friendly):\n self.on_attack(target, friendly)\n dmg = self.on_deal_dmg(target, friendly)\n self.death_remove(friendly)\n # May remove other minions in special cases\n # ... \n\n return dmg",
"def deal_damage(self, target):\n if hasattr(target, \"hp\"):\n dmg = random.randrange(self.atk + 1)\n target.take_damage(dmg)\n return dmg",
"def on_deal_dmg(self, target, friendly):\n if self.hurt:\n self.dfs -= target.atk\n if self.dfs <= 0 or target.poison:\n self.dead = True\n if target.hurt:\n target.dfs -= self.atk\n if target.dfs <= 0 or self.poison:\n target.dead = True\n\n # some special events may take place here\n # ... \n return self.atk",
"def on_attack(self, target, friendly):\n # Get buff from Dread Admiral Eliza\n if self.race == 'pirate' or self.race == 'all':\n eliza_buff_atk, eliza_buff_dfs = friendly.friendly_eliza_buff\n for each in friendly.minions:\n each.get_buff(eliza_buff_atk, eliza_buff_dfs)\n\n # If divine shield, not getting hurt\n if not self.divine_shield:\n self.hurt = True\n if not target.divine_shield:\n target.hurt = True",
"def damage(self, dmg_value):\n if self.can_take_damage():\n # here we'll add if it's affected by negative buffs\n self.health -= dmg_value",
"def deal_dmg(self):\n return self.damage",
"def can_take_damage(self):\n result = True\n if self.side_effects[\"shield\"] > 0:\n result = False\n return result",
"def damageSubtractor(self, damage, target, caller):\n # Build the target av objects\n target_shield_value = target.db.shield_value # Applied conditionally\n target_armor = target.db.armor\n target_tough = target.db.tough\n target_armor_specialist = target.db.armor_specialist\n\n # Apply damage in order\n if target_shield_value:\n # Get value of shield damage to check if it's under 0. Need to pass\n # this on to armor\n shield_damage = target_shield_value - damage\n if shield_damage < 0:\n # Check if damage would make shield go below 0\n damage = abs(shield_damage)\n # Set shield_value to 0\n target.db.shield_value = 0\n # Recalc and set av with new shield value\n else:\n target.db.shield_value = shield_damage\n damage = 0\n\n if target_armor_specialist and damage:\n # Get value of damage\n armor_specialist_damage = target_armor_specialist - damage\n if armor_specialist_damage < 0:\n damage = abs(armor_specialist_damage)\n target.db.armor_specialist = 0\n else:\n target.db.armor_specialist = armor_specialist_damage\n damage = 0\n\n if target_armor and damage:\n # Get value of damage\n armor_damage = target_armor - damage\n if armor_damage < 0:\n damage = abs(armor_damage)\n target.db.armor = 0\n else:\n target.db.armor = armor_damage\n damage = 0\n\n if target_tough and damage:\n tough_damage = target_tough - damage\n if tough_damage < 0:\n damage = abs(tough_damage)\n target.db.tough = 0\n else:\n target.db.tough = tough_damage\n damage = 0\n else:\n self.deathSubtractor(damage, target, caller)\n\n new_av = self.updateArmorValue(target.db.shield_value, target.db.armor, target.db.tough, target.db.armor_specialist)\n\n return new_av",
"def apply_ability_effects(ability: dict, target: Player, self: Player) -> None:\n for effect in ability[\"effects\"]:\n if effect[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=target\n )\n elif effect[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=self\n )",
"def use(target, name):\n out = target.damage() + \"\\n\"\n return out + \"You swing the \" + name + \" at \" + target.name",
"def ship_took_damage(self, damage: Damage):\n pass",
"def take_damage(self, dmg, dtype = 1):\n self.game.hit_sound.play()\n \n #DR% = 1 - (100 / x). \n damageMultiplier = 100.0 / float(self.defense)\n #Apply defense buffs/debuffs\n #calculate damage:\n dmg -= self.absorbtion\n dmg *= damageMultiplier\n #apply damage\n self.hp[0] -= dmg",
"def doDamage(self, owner, messages):\n self.damageDelegate.doDamage(owner, owner, None)\n messages.append(self.hurtItself)",
"def passive(self,target):\r\n target.shield_increase(200,buff_type = \"temp\")",
"def passive(self,target):\r\n target.dmg_increase(self.__dmg_increase,buff_type = \"permanent\")",
"def Hit(self, damage):\n self.health -= damage",
"def CombatAttack(self):\n self.attacker.Attack(target=self.defender)",
"def attack(self, attack_name, pokemon_to_hit):\n attack = next(attack for attack in self.attacks if attack.name == attack_name)\n if pokemon_to_hit.weakness == self.type:\n pokemon_to_hit.hp -= attack.damage * 2\n else:\n pokemon_to_hit.hp -= attack.damage",
"def deal_damage(self, damage):\n # Another cool trick\n self.current_health = max(\n 0,\n self.current_health-damage\n )",
"def __attack(self, target):\n attack_difference = (Warrior.attack(self, target))\n if attack_difference > 5:\n print(\"Second attack with ANGRY!\")\n Warrior.attack(self, target)\n return None",
"def coreDamage(self, user, target):\n scale = self.getScale()\n \n damage = super(DamageScaleDelegate, self).coreDamage(user, target)-2\n damage = damage*scale\n return damage + 2",
"def damage(self):\n if not self.damage_mode and not self.attack_mode and not self.death_mode:\n self.damage_mode = True\n self.cut_frame_update = 0",
"def attack(self, enemy):\n damage_dealt = self.damage - enemy.armor\n if damage_dealt < 1:\n damage_dealt = 1\n enemy.hit_points -= damage_dealt",
"async def use(self):\n\n # init\n await self.caster.posture.change_posture(\"attacking\")\n\n move = Move_displayer()\n calculator = Damage_calculator(self.caster, self.target)\n checker = Effect_checker(self.target)\n\n # get the damage\n damage = randint(self.caster.damage.physical_min, self.caster.damage.physical_max)\n damage = await calculator.physical_damage(\n damage,\n critable = True,\n dodgable = True\n )\n\n # define move info\n _move = await move.get_new_move()\n\n _move[\"name\"] = self.name\n _move[\"icon\"] = self.icon\n _move[\"damage\"] = damage[\"calculated\"]\n _move[\"critical\"] = damage[\"critical\"]\n _move[\"dodge\"] = damage[\"dodge\"]\n _move[\"physical\"] = True\n\n _move = await move.offensive_move(_move)\n\n # inflict damage\n await self.target.receive_damage(damage[\"calculated\"])\n\n return(_move)",
"def take_damage(self, damage):\n if self.hp - damage <= 0:\n self.hp = 0\n self.die()\n else:\n self.hp -= damage",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def take_damage(self, damage):\n attack = damage - (0.05 + self.__experience / 1000)\n self.set_health(self.get_health - attack)",
"def damage(self, damage):\n return self.damage",
"def heal(self):\n self.infected = False",
"def heavy_attack(self, enemy):\n #Generate damage\n damage = random.randint(0, 50)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All heavy attacks will appear at index 1 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[1] + \".\")\n\n #Dealt no damage\n if damage < 10:\n print(\"The attack missed!!!\")\n else:\n print(\"It dealt \" + str(damage) + \" damage.\")\n #Deal the damage to the enemy\n enemy.current_health -= damage",
"def take_damage(self, damage):\n if random.random() < self.chance_dodge:\n self.set_health(self.health - damage)\n return True\n return False",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount",
"def passive(self,target):\r\n target.temp[\"cannot_act\"][\"temp\"] = True",
"def attack(self, other):\n print(self.name, \"attacks\", other.name)\n damage = self.strenght*(1.-other.defense)\n print(\"damage: \", damage)\n other.hp -= damage\n print(other.name+\"'s remaining health: \", other.hp,)\n print(\"----------\")",
"def attack(self):\n\t if self.damage == 0:\n\t\treturn None\n\t elif self.name == \"die\":\n\t roll = random.randint(1,20)\n\t if roll == 1:\n\t return 0\n\t else:\n\t return 1\n\t elif self.damage == 1 or self.damage == 2:\n\t\treturn self.damage\n\t elif self.damage == 3:\n\t\treturn random.randint(3,5)\n\t elif self.damage == -4:\n\t return 4\n\t elif self.damage == 10:\n\t\trandomInt = random.randint(1,4)\n\t\tif randomInt == 1:\n\t\t return 10\n\t\telse:\n\t\t return 0\n\t else:\n\t return self.damage",
"def take_damage(self, damage):\n if damage <= 0: return\n self.hit_points[0] -= damage\n if self.hit_points[0] <= 0: self.die()",
"def attackProcess(attack: \"Attack\", attacker: \"PlayerCharacter or Monster\", enemies: list, targetID: int):\n hits, target, ail = 1, [targetID], None\n damageRange, critChance, critMultiplier = (95, 105), 0.1, 2\n if (attack.special):\n hits = attack.special[\"HITS\"] if \"HITS\" in attack.special.keys() else 1\n target = attack.special[\"TARGET\"] if \"TARGET\" in attack.special.keys() else target\n ail = attack.special[\"INFLICT\"] if \"INFLICT\" in attack.special.keys() else None\n damageRange = attack.special[\"DAMAGE RANGE\"] if \"DAMAGE RANGE\" in attack.special.keys() else damageRange\n critChance = attack.special[\"CRIT CHANCE\"] if \"CRIT CHANCE\" in attack.special.keys() else critChance\n critMultiplier = attack.special[\"CRIT MULTIPLIER\"] if \"CRIT MULTIPLIER\" in attack.special.keys() else critMultiplier\n target = targeting(len(enemies), target, hits)\n if attack.category == \"MAGICAL\":\n attackerPower = attacker.stats[\"MAGIC\"]\n attackerPower *= 0.6 if \"MUDDLE\" in attacker.conditions.keys() else 1\n else:\n attackerPower = attacker.stats[\"STRENGTH\"]\n attackerPower *= 0.6 if \"BURN\" in attacker.conditions.keys() else 1\n attackerPower *= 0.8 if \"LETHARGY\" in attacker.conditions.keys() else 1\n power = attack.power * attackerPower\n for i in target:\n roll = random.random()\n targetSpeed = 1 if \"STUN\" in enemies[i].conditions.keys() else enemies[i].stats[\"SPEED\"]\n hitChance = ((attacker.stats[\"SPEED\"] + attackerPower/10) / targetSpeed)\n hitChance *= 0.6 if \"BLIND\" in attacker.conditions.keys() else 1\n hitCheck = roll < hitChance\n if hitCheck:\n critCheck = roll < critChance\n resist = enemies[i].resist[attack.element] if attack.element in enemies[i].resist.keys() else 1\n damage = power * resist * (random.randint(damageRange[0], damageRange[1])/100)\n if critCheck:\n damage *= critMultiplier\n print(\"Critical hit!\")\n damage /= 2 if enemies[i].defend else 1\n damage //= enemies[i].stats[\"DEFENSE\"] if attack.category == \"PHYSICAL\" else enemies[i].stats[\"RESISTANCE\"]\n enemies[i].hp -= damage\n if enemies[i].hp < 0:\n enemies[i].ko = True\n enemies[i].hp = 0\n print(f\"\\n{attacker.name}'s {attack.name} dealt {damage} damage to {enemies[i].name}!\")\n print(f\"{enemies[i].name} {enemies[i].hp}/{enemies[i].stats['MAXHP']}\\n\")\n if ail and not enemies[i].ko:\n inflict(ail, enemies[i])\n else:\n print(f\"\\n{attacker.name} missed!\")\n attacker.wait = attack.wait * (100 - (1 if \"STUN\" in attacker.conditions.keys() else attacker.stats[\"SPEED\"])) // 1000",
"def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res",
"def attack(self):\n if random.random() < self.chance_critical:\n return self.strength * 2\n return self.strength",
"def collide_with_damage_source(self, source):\n self.bounceAgainst(source)\n source.bounceAgainst(self)",
"def is_damaged(self):\n return self.damaged",
"def light_attack(self, enemy):\n #Generate damage\n damage = random.randint(15, 25)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All light attacks will appear at index 0 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[0] + \".\")\n print(\"It dealt \" + str(damage) + \" damage.\")\n\n #Deal damage to the enemy\n enemy.current_health -= damage",
"def attack(self, robot):\n pass",
"def applyEffect(self, user, target, environment):\n pkmn = self.getEffectedPokemon(user, target)\n self.affectPkmn(pkmn)",
"def attack1(self, command):\n\n if random.randint(1,3) == 1 or random.randint(1,3) == 3:\n p.health -= self.weapon[0].damage\n print(\"You've been hit! \\nHealth at \" + str(p.health))\n else:\n print('Enemy tried to attack, missed!')",
"def apply_enhancements(ability: dict, target: Player, self: Player) -> None:\n self.status_effects.append([\"enhancement_sickness\", 1])\n\n for enhancement in ability[\"enhancements\"]:\n if enhancement[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=target\n )\n elif enhancement[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=self\n )",
"def deal_damage(self, modifier: int, critical_hit: bool) -> int:\r\n if critical_hit:\r\n damage_dice = self.critical_hit()\r\n else:\r\n damage_dice = self.damage\r\n damage = dice.roll(damage_dice)[0] + modifier\r\n return damage",
"def attack(self, character):\n\n character.hp -= max(0, (self.atk - character.defense))",
"def deathSubtractor(self, damage, target, caller):\n target_body = target.db.body\n target_bleed_points = target.db.bleed_points\n target_death_points = target.db.death_points\n\n if target_body and damage:\n body_damage = target_body - damage\n if body_damage < 0:\n damage = abs(body_damage)\n target.db.body = 0\n else:\n target.db.body = body_damage\n damage = 0\n\n if target_bleed_points and damage:\n bleed_damage = target_bleed_points - damage\n if bleed_damage < 0:\n damage = abs(bleed_damage)\n target.db.bleed_points = 0\n target.db.weakness = 1\n else:\n target.db.bleed_points = bleed_damage\n damage = 0\n target.db.weakness = 1\n\n target.msg(\"|430You are bleeding profusely from many wounds and can no longer use any active martial skills.\\n|n\")\n target.location.msg_contents(f\"{target.key} |025is bleeding profusely from many wounds and will soon lose consciousness.|n\")\n\n\n if target_death_points and damage:\n death_damage = target_death_points - damage\n if death_damage < 0:\n damage = abs(death_damage)\n target.db.death_points = 0\n else:\n target.db.death_points = death_damage\n damage = 0\n\n target.msg(\"|300You are unconscious and can no longer move of your own volition.|n\")\n target.location.msg_contents(f\"{target.key} |025does not seem to be moving.|n\")\n\n else:\n pass",
"def direct_damage(self, pokemon, damage):\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n pokemon.hp -= damage\n if pokemon.hp <= 0:\n self.faint(pokemon, Cause.DIRECT)",
"def takeHit(self, amount, type, enemyShip):\n if type == 'energy':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount\n amount = 0\n else:\n amount -= self.currentSP\n self.currentSP = 0\n # go through armor next\n if self.currentAP > 0 and amount > 0:\n # set experience only if shot goes through shields\n if self.typeAP == 'energy':\n if self.currentAP >= (amount * globals.reflectiveArmorModifier):\n self.currentAP -= (amount * globals.reflectiveArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.reflectiveArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n elif type == 'impact':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount/2\n amount = amount/2\n else:\n amount -= self.currentSP\n self.currentSP = 0\n \n # now goto armor\n if self.currentAP > 0 and amount > 0:\n if self.typeAP == 'impact':\n if self.currentAP >= (amount * globals.impactArmorModifier):\n self.currentAP -= (amount * globals.impactArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.impactArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n \n # now that shields and armor are taken care of transfer remaining damage to internal components\n self.myParent.setExperience(amount, enemyShip)\n componentDamage = 0\n if amount > 0 and self.components != {}:\n while amount > 0:\n keyList = funcs.sortStringList(self.components.keys())\n componentDamage = 1\n for componentID in keyList:\n component = self.components[componentID]\n if component.currentHP > amount:\n component.currentHP -= amount\n amount = 0\n break\n elif component.currentHP > 0:\n # remove component\n amount -= component.currentHP\n del self.components[componentID]\n \n # check if all components destroyed, or damage absorbed\n if self.components == {} or amount == 0:\n break\n \n if componentDamage == 1:\n self.setMyStatus()\n self.myParent.setMyStatus()\n \n if amount > 0:\n if self.myParent.currentISP > amount:\n self.myParent.currentISP -= amount\n self.myParent.setMyStatus()\n amount = 0\n else:\n self.myParent.destroyMe()\n amount = 0\n \n self.myParent.updateAllGUIValues()",
"def getDefense(self):\n\t\treturn(self.maneuverability * self.protection)",
"def attack(self):\n return random.randint(self.max_damage//2, self.max_damage)",
"def take_damage(self, dmg):\n self._ensure_is_alive()\n\n self._hit_points -= dmg\n\n if self.hit_points <= 0:\n self._hit_points = 0",
"def attack(self, victim):\n assert victim.is_alive, \"Cannot attack, victim is already dead\"\n # if attacker is stronger than victim, the victim's health is reduced by (0, 15)\n if victim.strength < self.strength:\n victim.health -= random.randint(0, 15)\n logging.debug(\"{0} is stronger\".format(self.name))\n else: # otherwise, reduce by only (0, 5)\n victim.health -= random.randint(0, 5)\n logging.debug(\"{0} is stronger\".format(victim.name))\n print(self.name, \"attacks\", victim.name)\n victim.show_health()\n\n # if the victim dies, transfer their loot to attacker and set them to dead\n if victim.health < 0:\n self.loot += victim.loot\n victim.loot = 0",
"def action_normal(self):\n obs = self.observation\n shoot = False\n eb = self.__class__.enemy_base\n \n ammopacks = filter(lambda x: x[2] == \"Ammo\", obs.objects)\n if ammopacks:\n self.updateAllAmmoSpots(ammopacks)\n # Walk to ammo\n if obs.ammo < SUFFICIENT_AMMO:\n self.goal = self.getClosestLocation(ammopacks)\n self.motivation = MOTIVATION_AMMO\n self.debugMsg(\"*> Recharge (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''if (obs.ammo > 0 and obs.foes):\n self.goal = self.getClosestLocation(obs.foes)\n self.debugMsg(\"*> Go to enemy (%d,%d)\" % self.goal)\n # If the enemy is within range, shoot.\n if(point_dist(self.goal, obs.loc) < self.settings.max_range\n and not line_intersects_grid(obs.loc, self.goal, self.grid, self.settings.tilesize)):\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #if self.goal not in obs.friends:\n self.motivation = MOTIVATION_SHOOT_TARGET\n shoot = True'''\n \n # Attack strategy 1\n #########################\n # 1) Shoot live enemies #\n #########################\n # Aim at the closest enemy outside the enemy base\n if obs.ammo > 0 and obs.foes:\n living = filter(lambda x: point_dist(x[0:2], eb) > ENEMY_BASE_RANGE, obs.foes)\n self.debugMsg(\"Living: %s\" % (living,))\n if living:\n self.debugMsg(1)\n self.goal = min(living, key=lambda x: point_dist(obs.loc, x[0:2]))[0:2]\n self.motivation = MOTIVATION_SHOOT_TARGET\n self.debugMsg(2)\n # Check if enemy in fire range\n if (\n point_dist(self.goal, obs.loc) < self.settings.max_range and\n not line_intersects_grid(\n obs.loc, \n self.goal, \n self.grid, \n self.settings.tilesize\n )\n ):\n self.debugMsg(3)\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #return self.getActionTriple(True,None,0) ###?? SHOULD WE STOP MOVING WHEN WE SHOOT?\n return self.getActionTriple(True)\n else:\n self.debugMsg(4)\n return self.getActionTriple()\n self.debugMsg(5)\n \n # Walk to an enemy CP\n if self.goal is None and len(self.friendlyCPs) < 2:\n self.goal = self.getClosestLocation(self.getQuietEnemyCPs())\n if self.goal:\n self.debugMsg(\"Crowded location: %d\" % self.getCrowdedValue(self.goal))\n self.motivation = MOTIVATION_CAPTURE_CP\n self.debugMsg(\"*> Capture (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''# If you can't think of anything to do\n # at least walk to a friendly control point\n if self.goal is None:\n self.goal = self.getClosestLocation(self.getQuietRestlessFriendlyCPs())\n if self.goal:\n self.motivation = MOTIVATION_GUARD_CP\n self.debugMsg(\"*> Guard (%d,%d)\" % (self.goal[0],self.goal[1]))'''\n \n if self.goal is None:\n self.goal = max(\n self.__class__.ammoSpots,\n key=lambda x: point_dist(x, obs.loc),\n )\n self.debugMsg(\"Going to ammospot far away (%d, %d)\" % (self.goal[0],self.goal[1]))\n self.motivation = MOTIVATION_STAY_PUT\n \n\n if self.goal:\n return self.getActionTriple(shoot)\n else:\n return self.getActionTriple(shoot)",
"def take_damage(self, damage):\n list_operators_experience = [i.get_experience / 1000 for i in\n self.operators]\n damage -= 0.1 + sum(list_operators_experience)\n # 60% of damage will receive a vehicle\n self.set_health(self.get_health - damage * 0.6)\n # A random operator, who will receive 20% of damage.\n random_operator = random.randint(0, len(self.operators) - 1)\n j = 0\n while j < len(self.operators):\n if j == random_operator:\n self.operators[j].take_damage(damage * 0.2)\n else:\n self.operators[j].take_damage(damage * 0.1)\n j += 1",
"def passive(self,target):\r\n target.hp_increase(self.__hp_increase,buff_type = \"permanent\")",
"def damage(self):\n out = (self.blurbs[self.state][\"damage\"])\n self.next_state(\"damage\")\n return out",
"def __attackDamage(self, attack, suit=0):\n if suit:\n for dmg in attack[SUIT_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0\n else:\n for dmg in attack[TOON_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0",
"def normal_defense(self):\n if self.game.get_my_mana() > DEFENSE_MANA_CAP:\n self.portals.dumb_castle_defense(DEFENSE_MANA_CAP)\n self.portals.dumb_portal_defense(PORTAL_SELF_DEFENSE_MANA_CAP)",
"def attack(self, target, bonusToAttackRoll=0):\n targetAC = target.AC\n attackRoll = self.roll()\n if attackRoll==1:\n # a natural 1 always miss\n return TH0_MISS_CRITICAL\n\n if self.character.stealth and not target.canSeeHiddenCharacter(self.character):\n surpriseAttack = True\n else:\n surpriseAttack = False\n\n if attackRoll==20:\n # a natural 20 always hit\n if surpriseAttack:\n return TH0_HIT_SURPRISE_CRITICAL\n return TH0_HIT_CRITICAL\n\n if surpriseAttack:\n bonusToAttackRoll+=4\n\n attackRoll = attackRoll + bonusToAttackRoll\n\n if attackRoll>=targetAC:\n if surpriseAttack:\n return TH0_SURPRISE_HIT\n return TH0_HIT\n \n return TH0_MISS",
"def damage(self, pokemon, damage, cause, source=None, attacker=None, drain_pct=None):\n if pokemon.is_fainted():\n if __debug__:\n log.w('Tried to damage fainted pokemon %s: cause: %s, source: %s, attacker: %s',\n pokemon, cause, source, attacker)\n return 0\n\n assert pokemon is not attacker\n assert pokemon.side.active_pokemon is pokemon\n assert pokemon.is_active\n assert damage >= 0\n assert ((isinstance(attacker, BattlePokemon) and isinstance(source, Move)) if\n cause is Cause.MOVE else True)\n\n if damage == 0:\n if __debug__: log.w('Battle.damage called with damage=0') # this shouldn't happen\n return 0\n\n if cause is Cause.WEATHER and pokemon.is_immune_to(source):\n if __debug__: log.i('Weather immunity: %s / %s', pokemon, source)\n return 0\n\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n damage = pokemon.accumulate_effect('on_damage',\n pokemon, cause, source, self, damage, failfast=True)\n if damage is FAIL:\n return FAIL\n\n pokemon.hp -= damage\n if __debug__: log.i('%s took %s (%.1f%%) damage from %s: %s; hp=%d/%d' %\n (pokemon, damage, 100*float(damage)/pokemon.max_hp, cause, source,\n pokemon.hp, pokemon.max_hp))\n if pokemon.hp <= 0:\n damage += pokemon.hp\n\n if drain_pct and not attacker.is_fainted():\n self.heal(attacker, int(math.ceil(damage * drain_pct / 100.0)), cause=Cause.DRAIN,\n foe=pokemon)\n\n if cause is Cause.MOVE:\n pokemon.activate_effect('on_after_move_damage', self, pokemon, damage, source, attacker)\n\n if pokemon.hp <= 0:\n self.faint(pokemon, cause, source, attacker)\n\n return damage",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount * self.DMG_TO_VEHICLE\n rnd_operator = random.choice(self.__operators)\n rnd_operator.get_damage(amount * self.DMG_TO_ONE_OPER)\n for operator in self.__operators:\n if operator != rnd_operator:\n operator.get_damage(amount * self.DMG_TO_OPER)\n self.estimate_total_health()\n self.check_is_alive()",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between\n # half of max_damage and max_damage\n print(\"max damage of \" + self.name + \" is \")\n print(str(self.attack_strength))\n min_damage = self.attack_strength // 2\n weapon_attack_value = random.randint(min_damage, self.attack_strength)\n return weapon_attack_value",
"def attack(self):\n\n if not self.attacking:\n self.attacking = True",
"def attack_bonus_on_level(self, level):\n raise NotImplementedError",
"def apply_ex(player: Player) -> None:\n getattr(combat_effects, \"inflict_ex_\" + player.character_class)",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between half of max_damage and max_damage\n \n weapon_attack_value = random.randint(self.max_damage//2, self.max_damage)\n return weapon_attack_value",
"def counter_attack(self, other):\n other.take_damage(self.damage/2)",
"def applyDamage(state, damage) :\n newState = copy.deepcopy(state)\n # If the enemy does not have HP information, returns the same state\n if 'hp' not in state['enemy'] :\n return newState\n # Reduces HP by damage, min HP being 0\n newState['enemy']['hp'] = max(newState['enemy']['hp'] - damage, 0)\n return newState",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n attacker_fx = await self.get_user_effects(attacker)\n\n if 'knocked_out' in attacker_fx:\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_sloth_profile = await self.get_sloth_profile(target.id)\n if not target_sloth_profile:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_sloth_profile[1] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n target_fx = await self.get_user_effects(target)\n\n if 'protected' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if 'hacked' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n if ctx.invoked_with == 'mirror':\n mirrored_skill = await self.get_skill_action_by_user_id_and_skill_type(user_id=attacker.id, skill_type='mirror')\n if not mirrored_skill:\n return await ctx.send(f\"**Something went wrong with this, {attacker.mention}!**\")\n else:\n _, exists = await Player.skill_on_cooldown(skill=Skill.ONE).predicate(ctx)\n\n try:\n current_timestamp = await utils.get_timestamp()\n # Don't need to store it, since it is forever\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n if ctx.invoked_with != 'mirror':\n if exists:\n await self.update_user_skill_ts(attacker.id, Skill.ONE, current_timestamp)\n else:\n await self.insert_user_skill_cooldown(attacker.id, Skill.ONE, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")\n else:\n if 'reflect' in target_fx:\n await self.reflect_attack(ctx, attacker, target, 'hack')",
"def attack(self):\n total_amnt_attack = 0\n for new_attack in self.abilities:\n total_amnt_attack += new_attack.attack()\n return total_amnt_attack",
"def turn_effects(self):\n if self.side_effects[\"shield\"] > 0:\n self.side_effects[\"shield\"] -= 1",
"def test_get_damage_out_of_limit(self):\n self.veh.health = 0.24\n for op in self.veh.operators:\n op.health = 0.1\n self.veh.get_damage(0.5)\n self.assertEqual(self.veh.health, 0)\n self.assertEqual(self.veh.operators[0].health, 0.05)\n self.assertEqual(self.veh.operators[1].health, 0.05)",
"def active(self,target):\r\n if target.current_hp == target.hp:\r\n raise ItemError(\"Cannot consume if health is at maximum!\")\r\n\r\n target.hp_increase(self.__hp_increase)",
"def can_throw(life):\n\treturn can_hold_item(life)",
"def attack(self, *args, **kwargs):\n return self(AbilityId.ATTACK, *args, **kwargs)",
"def attack(self, other):\n if other is not self:\n other.take_damage(self.damage)\n other.counter_attack(self)",
"def take_damage(self, damage_amt):\n\n self.health -= damage_amt\n if self.health <= 0:\n self.deaths += 1",
"def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum",
"def dealdamage(self, pokemon, movedata):\n mod = getmodifier(movedata['type'].lower(), pokemon.types)\n if movedata['category'].lower() == 'physical':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['ATK']/pokemon.currentStats['DEF'])/50+2)*mod\n if movedata['category'].lower() == 'special':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['SPATK']/pokemon.currentStats['SPDEF'])/50+2)*mod\n print(f\"HP: {pokemon.currentStats['HP']}, Damage: {damage}\")\n pokemon.takedamage(damage)\n if mod == 0:\n return [0, damage]\n if mod == 0.25:\n return [1, damage]\n if mod == 0.5:\n return [2, damage]\n if mod == 1:\n return [3, damage]\n if mod == 2:\n return [4, damage]\n if mod == 4:\n return [5, damage]",
"def updateCurrentBehavior(self, gameState, action):\n self.behavior = \"attack\"",
"def take_damage(self, damage):\n damage /= len(self.__units)\n for i in self.__units:\n i.take_damage(damage)",
"def __applyToonAttackDamages(self, toonId, hpbonus=0, kbbonus=0):\n # now be sure to adjust the damage to the suit, but only\n # if the track of the attack is not 0, meaning it is not\n # a heal, if it's a heal, then the damage is applied as\n # a plus to the target's health and we don't handle adjusting\n # toon health here (additionally attack 1 is a trap attacks,\n # doesn't cause damage directly but only in conjunction with a\n # lure attack)\n totalDamages = 0\n if not self.APPLY_HEALTH_ADJUSTMENTS:\n return totalDamages\n assert(self.battle.toonAttacks.has_key(toonId))\n attack = self.battle.toonAttacks[toonId]\n track = self.__getActualTrack(attack)\n if (track != NO_ATTACK and track != SOS and\n track != TRAP and track != NPCSOS):\n # first create a list of targets based on group or\n # single target designation for this particular attack\n targets = self.__getToonTargets(attack)\n for position in range(len(targets)):\n if hpbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_HPBONUS_COL]\n else:\n damageDone = 0\n elif kbbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_KBBONUS_COL][position]\n else:\n damageDone = 0\n else:\n assert(position < len(attack[TOON_HP_COL]))\n damageDone = attack[TOON_HP_COL][position]\n if damageDone <= 0 or self.immortalSuits:\n # suit at this position was not hit\n continue\n if (track == HEAL or track == PETSOS):\n # target of toon attack was another toon, we\n # don't want to apply any damage yet\n currTarget = targets[position]\n assert(self.toonHPAdjusts.has_key(currTarget))\n if self.CAP_HEALS:\n # make sure to bound the toon's health to its\n # max health\n toonHp = self.__getToonHp(currTarget)\n toonMaxHp = self.__getToonMaxHp(currTarget)\n if toonHp + damageDone > toonMaxHp:\n damageDone = toonMaxHp - toonHp\n attack[TOON_HP_COL][position] = damageDone\n self.toonHPAdjusts[currTarget] += damageDone\n totalDamages = totalDamages + damageDone\n continue\n\n # we should only get here if the target is a suit and\n # at least 1hp of damage was done\n currTarget = targets[position]\n assert isinstance(currTarget,\n DistributedSuitBaseAI.DistributedSuitBaseAI), \\\n targets\n currTarget.setHP(currTarget.getHP() - damageDone)\n targetId = currTarget.getDoId()\n if self.notify.getDebug():\n if hpbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from HP-Bonus\")\n elif kbbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from KB-Bonus\")\n else:\n self.notify.debug(str(targetId) + \": suit takes \" +\n str(damageDone) + \" damage\")\n totalDamages = totalDamages + damageDone\n\n # if the suit died from this or a previous\n # attack, make sure to set the 'died' field for\n # the target to 1, indicating to the higher-ups\n # that this suit has died\n if currTarget.getHP() <= 0:\n if currTarget.getSkeleRevives() >= 1:\n currTarget.useSkeleRevive()\n attack[SUIT_REVIVE_COL] = \\\n attack[SUIT_REVIVE_COL] | (1 << position)\n else:\n self.suitLeftBattle(targetId)\n attack[SUIT_DIED_COL] = \\\n attack[SUIT_DIED_COL] | (1 << position)\n if self.notify.getDebug():\n self.notify.debug(\"Suit\" + str(targetId) +\n \"bravely expired in combat\")\n\n return totalDamages",
"def take_damage(self, value, type_=None):\n if type_ in self.resistances:\n taken = math.floor(value / 2)\n # TODO (phillip): event log should show that damage was reduced\n elif type_ in self.vulnerabilities:\n taken = value * 2\n else:\n taken = value\n\n # Only used to return at the end\n actual_taken = min(self.hp, taken)\n\n self.hp -= taken\n if self.hp < -self.max_hp:\n # TODO (phillip): Implement creature death\n pass\n\n self.hp = max(0, self.hp)\n return actual_taken",
"def test_get_damage_out_of_limit(self):\n self.sold.health = 0.2\n self.sold.get_damage(0.32)\n self.assertEqual(self.sold.health, 0)",
"def spell_attack(self, caster, spell_name, targets, cost, **kwargs):\n spell_msg = \"%s casts %s!\" % (caster, spell_name)\n\n atkname_single = \"The spell\"\n atkname_plural = \"spells\"\n min_damage = 10\n max_damage = 20\n accuracy = 0\n attack_count = 1\n\n # Retrieve some variables from kwargs, if present\n if \"attack_name\" in kwargs:\n atkname_single = kwargs[\"attack_name\"][0]\n atkname_plural = kwargs[\"attack_name\"][1]\n if \"damage_range\" in kwargs:\n min_damage = kwargs[\"damage_range\"][0]\n max_damage = kwargs[\"damage_range\"][1]\n if \"accuracy\" in kwargs:\n accuracy = kwargs[\"accuracy\"]\n if \"attack_count\" in kwargs:\n attack_count = kwargs[\"attack_count\"]\n\n to_attack = []\n # If there are more attacks than targets given, attack first target multiple times\n if len(targets) < attack_count:\n to_attack = to_attack + targets\n extra_attacks = attack_count - len(targets)\n for n in range(extra_attacks):\n to_attack.insert(0, targets[0])\n else:\n to_attack = to_attack + targets\n\n # Set up dictionaries to track number of hits and total damage\n total_hits = {}\n total_damage = {}\n for fighter in targets:\n total_hits.update({fighter: 0})\n total_damage.update({fighter: 0})\n\n # Resolve attack for each target\n for fighter in to_attack:\n attack_value = randint(1, 100) + accuracy # Spell attack roll\n defense_value = self.get_defense(caster, fighter)\n if attack_value >= defense_value:\n spell_dmg = randint(min_damage, max_damage) # Get spell damage\n total_hits[fighter] += 1\n total_damage[fighter] += spell_dmg\n\n for fighter in targets:\n # Construct combat message\n if total_hits[fighter] == 0:\n spell_msg += \" The spell misses %s!\" % fighter\n elif total_hits[fighter] > 0:\n attack_count_str = atkname_single + \" hits\"\n if total_hits[fighter] > 1:\n attack_count_str = \"%i %s hit\" % (total_hits[fighter], atkname_plural)\n spell_msg += \" %s %s for %i damage!\" % (\n attack_count_str,\n fighter,\n total_damage[fighter],\n )\n\n caster.db.mp -= cost # Deduct MP cost\n\n caster.location.msg_contents(spell_msg) # Message the room with spell results\n\n for fighter in targets:\n # Apply damage\n self.apply_damage(fighter, total_damage[fighter])\n # If fighter HP is reduced to 0 or less, call at_defeat.\n if fighter.db.hp <= 0:\n self.at_defeat(fighter)\n\n if self.is_in_combat(caster): # Spend action if in combat\n self.spend_action(caster, 1, action_name=\"cast\")",
"def is_attack(self):\n\n return self.purpose == 'attack'",
"def apply_skill_effects(self, behavior):\n b_type = type(behavior)\n if issubclass(b_type, ESAttackUp):\n if b_type == ESAttackUPRemainingEnemies \\\n and behavior.enemy_count is not None \\\n and self.enemies > behavior.enemy_count:\n return False\n if self.enraged is None:\n if b_type == ESAttackUPCooldown and behavior.turn_cooldown is not None:\n self.enraged = -behavior.turn_cooldown + 1\n return False\n else:\n self.enraged = behavior.turns\n return True\n else:\n if self.enraged == 0:\n self.enraged = behavior.turns\n return True\n else:\n return False\n elif b_type == ESDamageShield:\n if self.damage_shield == 0:\n self.damage_shield = behavior.turns\n return True\n else:\n return False\n elif b_type == ESStatusShield:\n if self.status_shield == 0:\n self.status_shield = behavior.turns\n return True\n else:\n return False\n return True",
"def get_attack_damage(self, by: str):\n if by == 'spell':\n if self.spells:\n # get the spell with the maximum damage that we have enough mana for\n available_spells = [spell for spell in self.spells if self._mana >= spell.mana_cost]\n if not available_spells:\n return None\n\n spell = max(available_spells, key= lambda spell: spell.damage) # type: Spell\n if spell:\n return spell\n else:\n print('{} does not know any spells.'.format(self.name))\n return None\n else:\n return self.weapon.damage",
"def attack(self, enemies):\n return super().attack(enemies, self.range, self.in_range, self.damage, 16)",
"def _reward(self, action):\n raise NotImplementedError",
"def attack(self, enemy):\r\n best_weapon = None\r\n max_damage = 0\r\n # Searches your inventory for your highest damaging weapon\r\n for i in self._inventory:\r\n if isinstance(i, items.Weapon):\r\n if i._damage > max_damage:\r\n best_weapon = i\r\n max_damage = i._damage\r\n\r\n print(\"You use {} against {}!\".format(best_weapon._name, enemy._name))\r\n enemy._health_points -= best_weapon._damage\r\n if not enemy.is_alive():\r\n print(\"You've killed {}!\".format(enemy._name))\r\n\r\n else:\r\n print(\"The {} isn't dead yet. It has {} health remaining. Keep fighting!\".format(enemy._name, enemy._health_points))",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n if await self.is_user_knocked_out(attacker.id):\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_currency = await self.get_user_currency(target.id)\n if not target_currency:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_currency[7] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n if await self.is_user_protected(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if await self.is_user_hacked(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n await self.check_cooldown(user_id=attacker.id, skill_number=1)\n\n try:\n current_timestamp = await self.get_timestamp()\n # Don't need to store it, since it is forever\n await self.update_user_is_hacked(target.id, 1)\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n await self.update_user_action_skill_ts(attacker.id, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n msg = await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")"
] | [
"0.7999557",
"0.7960427",
"0.79067296",
"0.7736732",
"0.7559663",
"0.75042886",
"0.73485667",
"0.69856614",
"0.6954562",
"0.68673724",
"0.6778077",
"0.67357415",
"0.66850173",
"0.6644636",
"0.6638605",
"0.662029",
"0.6539297",
"0.65386426",
"0.65321666",
"0.65184796",
"0.65008146",
"0.6496057",
"0.6479794",
"0.6462085",
"0.6440297",
"0.64162344",
"0.6388051",
"0.63838446",
"0.6383606",
"0.6367558",
"0.6367558",
"0.6353072",
"0.63491184",
"0.6341149",
"0.62979174",
"0.6283066",
"0.6280401",
"0.62739074",
"0.62733066",
"0.6268356",
"0.62564576",
"0.6244335",
"0.6229594",
"0.62261",
"0.62221265",
"0.62062085",
"0.6198498",
"0.61962956",
"0.61946404",
"0.61925095",
"0.61889863",
"0.6186729",
"0.6184047",
"0.61670655",
"0.61589444",
"0.6141316",
"0.6126803",
"0.61222",
"0.6118753",
"0.61061203",
"0.6103459",
"0.610009",
"0.60851514",
"0.6067181",
"0.606224",
"0.60566694",
"0.6040522",
"0.603953",
"0.60370547",
"0.6027466",
"0.6021367",
"0.60086644",
"0.5995696",
"0.5967911",
"0.5965284",
"0.59649885",
"0.5960138",
"0.5958327",
"0.59544295",
"0.59489006",
"0.5947135",
"0.5946535",
"0.5945641",
"0.59453267",
"0.5928747",
"0.5886637",
"0.58859384",
"0.5885854",
"0.5880612",
"0.5880575",
"0.5875484",
"0.58734626",
"0.5869462",
"0.58632183",
"0.5851432",
"0.5850708",
"0.5847332",
"0.5831628",
"0.58238983",
"0.58220804"
] | 0.81057763 | 0 |
ability that deals damage to the target | def ability_2(self,target):
damage1 = (self.get_lvl()+self.get_strength())
target.receive_damage(damage1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ability_1(self,target):\r\n damage = (self.get_strength()+2)\r\n target.receive_damage(damage)",
"def ability_3(self,target):\r\n damage = (self.get_dexterity()+self.get_strength())\r\n target.receive_damage(damage)",
"def ability_4(self,target):\r\n damage = (self.get_strength()*3)\r\n target.receive_damage(damage)",
"def _attack(self,target):\r\n damage = self.get_strength() * self.get_lvl()\r\n target.receive_damage(damage)",
"def attack(self, target, friendly):\n self.on_attack(target, friendly)\n dmg = self.on_deal_dmg(target, friendly)\n self.death_remove(friendly)\n # May remove other minions in special cases\n # ... \n\n return dmg",
"def deal_damage(self, target):\n if hasattr(target, \"hp\"):\n dmg = random.randrange(self.atk + 1)\n target.take_damage(dmg)\n return dmg",
"def on_deal_dmg(self, target, friendly):\n if self.hurt:\n self.dfs -= target.atk\n if self.dfs <= 0 or target.poison:\n self.dead = True\n if target.hurt:\n target.dfs -= self.atk\n if target.dfs <= 0 or self.poison:\n target.dead = True\n\n # some special events may take place here\n # ... \n return self.atk",
"def on_attack(self, target, friendly):\n # Get buff from Dread Admiral Eliza\n if self.race == 'pirate' or self.race == 'all':\n eliza_buff_atk, eliza_buff_dfs = friendly.friendly_eliza_buff\n for each in friendly.minions:\n each.get_buff(eliza_buff_atk, eliza_buff_dfs)\n\n # If divine shield, not getting hurt\n if not self.divine_shield:\n self.hurt = True\n if not target.divine_shield:\n target.hurt = True",
"def damage(self, dmg_value):\n if self.can_take_damage():\n # here we'll add if it's affected by negative buffs\n self.health -= dmg_value",
"def deal_dmg(self):\n return self.damage",
"def can_take_damage(self):\n result = True\n if self.side_effects[\"shield\"] > 0:\n result = False\n return result",
"def damageSubtractor(self, damage, target, caller):\n # Build the target av objects\n target_shield_value = target.db.shield_value # Applied conditionally\n target_armor = target.db.armor\n target_tough = target.db.tough\n target_armor_specialist = target.db.armor_specialist\n\n # Apply damage in order\n if target_shield_value:\n # Get value of shield damage to check if it's under 0. Need to pass\n # this on to armor\n shield_damage = target_shield_value - damage\n if shield_damage < 0:\n # Check if damage would make shield go below 0\n damage = abs(shield_damage)\n # Set shield_value to 0\n target.db.shield_value = 0\n # Recalc and set av with new shield value\n else:\n target.db.shield_value = shield_damage\n damage = 0\n\n if target_armor_specialist and damage:\n # Get value of damage\n armor_specialist_damage = target_armor_specialist - damage\n if armor_specialist_damage < 0:\n damage = abs(armor_specialist_damage)\n target.db.armor_specialist = 0\n else:\n target.db.armor_specialist = armor_specialist_damage\n damage = 0\n\n if target_armor and damage:\n # Get value of damage\n armor_damage = target_armor - damage\n if armor_damage < 0:\n damage = abs(armor_damage)\n target.db.armor = 0\n else:\n target.db.armor = armor_damage\n damage = 0\n\n if target_tough and damage:\n tough_damage = target_tough - damage\n if tough_damage < 0:\n damage = abs(tough_damage)\n target.db.tough = 0\n else:\n target.db.tough = tough_damage\n damage = 0\n else:\n self.deathSubtractor(damage, target, caller)\n\n new_av = self.updateArmorValue(target.db.shield_value, target.db.armor, target.db.tough, target.db.armor_specialist)\n\n return new_av",
"def apply_ability_effects(ability: dict, target: Player, self: Player) -> None:\n for effect in ability[\"effects\"]:\n if effect[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=target\n )\n elif effect[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=self\n )",
"def use(target, name):\n out = target.damage() + \"\\n\"\n return out + \"You swing the \" + name + \" at \" + target.name",
"def ship_took_damage(self, damage: Damage):\n pass",
"def take_damage(self, dmg, dtype = 1):\n self.game.hit_sound.play()\n \n #DR% = 1 - (100 / x). \n damageMultiplier = 100.0 / float(self.defense)\n #Apply defense buffs/debuffs\n #calculate damage:\n dmg -= self.absorbtion\n dmg *= damageMultiplier\n #apply damage\n self.hp[0] -= dmg",
"def doDamage(self, owner, messages):\n self.damageDelegate.doDamage(owner, owner, None)\n messages.append(self.hurtItself)",
"def passive(self,target):\r\n target.shield_increase(200,buff_type = \"temp\")",
"def passive(self,target):\r\n target.dmg_increase(self.__dmg_increase,buff_type = \"permanent\")",
"def Hit(self, damage):\n self.health -= damage",
"def CombatAttack(self):\n self.attacker.Attack(target=self.defender)",
"def attack(self, attack_name, pokemon_to_hit):\n attack = next(attack for attack in self.attacks if attack.name == attack_name)\n if pokemon_to_hit.weakness == self.type:\n pokemon_to_hit.hp -= attack.damage * 2\n else:\n pokemon_to_hit.hp -= attack.damage",
"def deal_damage(self, damage):\n # Another cool trick\n self.current_health = max(\n 0,\n self.current_health-damage\n )",
"def __attack(self, target):\n attack_difference = (Warrior.attack(self, target))\n if attack_difference > 5:\n print(\"Second attack with ANGRY!\")\n Warrior.attack(self, target)\n return None",
"def coreDamage(self, user, target):\n scale = self.getScale()\n \n damage = super(DamageScaleDelegate, self).coreDamage(user, target)-2\n damage = damage*scale\n return damage + 2",
"def damage(self):\n if not self.damage_mode and not self.attack_mode and not self.death_mode:\n self.damage_mode = True\n self.cut_frame_update = 0",
"def attack(self, enemy):\n damage_dealt = self.damage - enemy.armor\n if damage_dealt < 1:\n damage_dealt = 1\n enemy.hit_points -= damage_dealt",
"async def use(self):\n\n # init\n await self.caster.posture.change_posture(\"attacking\")\n\n move = Move_displayer()\n calculator = Damage_calculator(self.caster, self.target)\n checker = Effect_checker(self.target)\n\n # get the damage\n damage = randint(self.caster.damage.physical_min, self.caster.damage.physical_max)\n damage = await calculator.physical_damage(\n damage,\n critable = True,\n dodgable = True\n )\n\n # define move info\n _move = await move.get_new_move()\n\n _move[\"name\"] = self.name\n _move[\"icon\"] = self.icon\n _move[\"damage\"] = damage[\"calculated\"]\n _move[\"critical\"] = damage[\"critical\"]\n _move[\"dodge\"] = damage[\"dodge\"]\n _move[\"physical\"] = True\n\n _move = await move.offensive_move(_move)\n\n # inflict damage\n await self.target.receive_damage(damage[\"calculated\"])\n\n return(_move)",
"def take_damage(self, damage):\n if self.hp - damage <= 0:\n self.hp = 0\n self.die()\n else:\n self.hp -= damage",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def take_damage(self, damage):\n attack = damage - (0.05 + self.__experience / 1000)\n self.set_health(self.get_health - attack)",
"def damage(self, damage):\n return self.damage",
"def heal(self):\n self.infected = False",
"def heavy_attack(self, enemy):\n #Generate damage\n damage = random.randint(0, 50)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All heavy attacks will appear at index 1 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[1] + \".\")\n\n #Dealt no damage\n if damage < 10:\n print(\"The attack missed!!!\")\n else:\n print(\"It dealt \" + str(damage) + \" damage.\")\n #Deal the damage to the enemy\n enemy.current_health -= damage",
"def take_damage(self, damage):\n if random.random() < self.chance_dodge:\n self.set_health(self.health - damage)\n return True\n return False",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount",
"def passive(self,target):\r\n target.temp[\"cannot_act\"][\"temp\"] = True",
"def attack(self, other):\n print(self.name, \"attacks\", other.name)\n damage = self.strenght*(1.-other.defense)\n print(\"damage: \", damage)\n other.hp -= damage\n print(other.name+\"'s remaining health: \", other.hp,)\n print(\"----------\")",
"def attack(self):\n\t if self.damage == 0:\n\t\treturn None\n\t elif self.name == \"die\":\n\t roll = random.randint(1,20)\n\t if roll == 1:\n\t return 0\n\t else:\n\t return 1\n\t elif self.damage == 1 or self.damage == 2:\n\t\treturn self.damage\n\t elif self.damage == 3:\n\t\treturn random.randint(3,5)\n\t elif self.damage == -4:\n\t return 4\n\t elif self.damage == 10:\n\t\trandomInt = random.randint(1,4)\n\t\tif randomInt == 1:\n\t\t return 10\n\t\telse:\n\t\t return 0\n\t else:\n\t return self.damage",
"def take_damage(self, damage):\n if damage <= 0: return\n self.hit_points[0] -= damage\n if self.hit_points[0] <= 0: self.die()",
"def attackProcess(attack: \"Attack\", attacker: \"PlayerCharacter or Monster\", enemies: list, targetID: int):\n hits, target, ail = 1, [targetID], None\n damageRange, critChance, critMultiplier = (95, 105), 0.1, 2\n if (attack.special):\n hits = attack.special[\"HITS\"] if \"HITS\" in attack.special.keys() else 1\n target = attack.special[\"TARGET\"] if \"TARGET\" in attack.special.keys() else target\n ail = attack.special[\"INFLICT\"] if \"INFLICT\" in attack.special.keys() else None\n damageRange = attack.special[\"DAMAGE RANGE\"] if \"DAMAGE RANGE\" in attack.special.keys() else damageRange\n critChance = attack.special[\"CRIT CHANCE\"] if \"CRIT CHANCE\" in attack.special.keys() else critChance\n critMultiplier = attack.special[\"CRIT MULTIPLIER\"] if \"CRIT MULTIPLIER\" in attack.special.keys() else critMultiplier\n target = targeting(len(enemies), target, hits)\n if attack.category == \"MAGICAL\":\n attackerPower = attacker.stats[\"MAGIC\"]\n attackerPower *= 0.6 if \"MUDDLE\" in attacker.conditions.keys() else 1\n else:\n attackerPower = attacker.stats[\"STRENGTH\"]\n attackerPower *= 0.6 if \"BURN\" in attacker.conditions.keys() else 1\n attackerPower *= 0.8 if \"LETHARGY\" in attacker.conditions.keys() else 1\n power = attack.power * attackerPower\n for i in target:\n roll = random.random()\n targetSpeed = 1 if \"STUN\" in enemies[i].conditions.keys() else enemies[i].stats[\"SPEED\"]\n hitChance = ((attacker.stats[\"SPEED\"] + attackerPower/10) / targetSpeed)\n hitChance *= 0.6 if \"BLIND\" in attacker.conditions.keys() else 1\n hitCheck = roll < hitChance\n if hitCheck:\n critCheck = roll < critChance\n resist = enemies[i].resist[attack.element] if attack.element in enemies[i].resist.keys() else 1\n damage = power * resist * (random.randint(damageRange[0], damageRange[1])/100)\n if critCheck:\n damage *= critMultiplier\n print(\"Critical hit!\")\n damage /= 2 if enemies[i].defend else 1\n damage //= enemies[i].stats[\"DEFENSE\"] if attack.category == \"PHYSICAL\" else enemies[i].stats[\"RESISTANCE\"]\n enemies[i].hp -= damage\n if enemies[i].hp < 0:\n enemies[i].ko = True\n enemies[i].hp = 0\n print(f\"\\n{attacker.name}'s {attack.name} dealt {damage} damage to {enemies[i].name}!\")\n print(f\"{enemies[i].name} {enemies[i].hp}/{enemies[i].stats['MAXHP']}\\n\")\n if ail and not enemies[i].ko:\n inflict(ail, enemies[i])\n else:\n print(f\"\\n{attacker.name} missed!\")\n attacker.wait = attack.wait * (100 - (1 if \"STUN\" in attacker.conditions.keys() else attacker.stats[\"SPEED\"])) // 1000",
"def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res",
"def attack(self):\n if random.random() < self.chance_critical:\n return self.strength * 2\n return self.strength",
"def collide_with_damage_source(self, source):\n self.bounceAgainst(source)\n source.bounceAgainst(self)",
"def is_damaged(self):\n return self.damaged",
"def light_attack(self, enemy):\n #Generate damage\n damage = random.randint(15, 25)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All light attacks will appear at index 0 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[0] + \".\")\n print(\"It dealt \" + str(damage) + \" damage.\")\n\n #Deal damage to the enemy\n enemy.current_health -= damage",
"def attack(self, robot):\n pass",
"def applyEffect(self, user, target, environment):\n pkmn = self.getEffectedPokemon(user, target)\n self.affectPkmn(pkmn)",
"def attack1(self, command):\n\n if random.randint(1,3) == 1 or random.randint(1,3) == 3:\n p.health -= self.weapon[0].damage\n print(\"You've been hit! \\nHealth at \" + str(p.health))\n else:\n print('Enemy tried to attack, missed!')",
"def apply_enhancements(ability: dict, target: Player, self: Player) -> None:\n self.status_effects.append([\"enhancement_sickness\", 1])\n\n for enhancement in ability[\"enhancements\"]:\n if enhancement[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=target\n )\n elif enhancement[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=self\n )",
"def deal_damage(self, modifier: int, critical_hit: bool) -> int:\r\n if critical_hit:\r\n damage_dice = self.critical_hit()\r\n else:\r\n damage_dice = self.damage\r\n damage = dice.roll(damage_dice)[0] + modifier\r\n return damage",
"def attack(self, character):\n\n character.hp -= max(0, (self.atk - character.defense))",
"def deathSubtractor(self, damage, target, caller):\n target_body = target.db.body\n target_bleed_points = target.db.bleed_points\n target_death_points = target.db.death_points\n\n if target_body and damage:\n body_damage = target_body - damage\n if body_damage < 0:\n damage = abs(body_damage)\n target.db.body = 0\n else:\n target.db.body = body_damage\n damage = 0\n\n if target_bleed_points and damage:\n bleed_damage = target_bleed_points - damage\n if bleed_damage < 0:\n damage = abs(bleed_damage)\n target.db.bleed_points = 0\n target.db.weakness = 1\n else:\n target.db.bleed_points = bleed_damage\n damage = 0\n target.db.weakness = 1\n\n target.msg(\"|430You are bleeding profusely from many wounds and can no longer use any active martial skills.\\n|n\")\n target.location.msg_contents(f\"{target.key} |025is bleeding profusely from many wounds and will soon lose consciousness.|n\")\n\n\n if target_death_points and damage:\n death_damage = target_death_points - damage\n if death_damage < 0:\n damage = abs(death_damage)\n target.db.death_points = 0\n else:\n target.db.death_points = death_damage\n damage = 0\n\n target.msg(\"|300You are unconscious and can no longer move of your own volition.|n\")\n target.location.msg_contents(f\"{target.key} |025does not seem to be moving.|n\")\n\n else:\n pass",
"def direct_damage(self, pokemon, damage):\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n pokemon.hp -= damage\n if pokemon.hp <= 0:\n self.faint(pokemon, Cause.DIRECT)",
"def takeHit(self, amount, type, enemyShip):\n if type == 'energy':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount\n amount = 0\n else:\n amount -= self.currentSP\n self.currentSP = 0\n # go through armor next\n if self.currentAP > 0 and amount > 0:\n # set experience only if shot goes through shields\n if self.typeAP == 'energy':\n if self.currentAP >= (amount * globals.reflectiveArmorModifier):\n self.currentAP -= (amount * globals.reflectiveArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.reflectiveArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n elif type == 'impact':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount/2\n amount = amount/2\n else:\n amount -= self.currentSP\n self.currentSP = 0\n \n # now goto armor\n if self.currentAP > 0 and amount > 0:\n if self.typeAP == 'impact':\n if self.currentAP >= (amount * globals.impactArmorModifier):\n self.currentAP -= (amount * globals.impactArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.impactArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n \n # now that shields and armor are taken care of transfer remaining damage to internal components\n self.myParent.setExperience(amount, enemyShip)\n componentDamage = 0\n if amount > 0 and self.components != {}:\n while amount > 0:\n keyList = funcs.sortStringList(self.components.keys())\n componentDamage = 1\n for componentID in keyList:\n component = self.components[componentID]\n if component.currentHP > amount:\n component.currentHP -= amount\n amount = 0\n break\n elif component.currentHP > 0:\n # remove component\n amount -= component.currentHP\n del self.components[componentID]\n \n # check if all components destroyed, or damage absorbed\n if self.components == {} or amount == 0:\n break\n \n if componentDamage == 1:\n self.setMyStatus()\n self.myParent.setMyStatus()\n \n if amount > 0:\n if self.myParent.currentISP > amount:\n self.myParent.currentISP -= amount\n self.myParent.setMyStatus()\n amount = 0\n else:\n self.myParent.destroyMe()\n amount = 0\n \n self.myParent.updateAllGUIValues()",
"def getDefense(self):\n\t\treturn(self.maneuverability * self.protection)",
"def attack(self):\n return random.randint(self.max_damage//2, self.max_damage)",
"def take_damage(self, dmg):\n self._ensure_is_alive()\n\n self._hit_points -= dmg\n\n if self.hit_points <= 0:\n self._hit_points = 0",
"def attack(self, victim):\n assert victim.is_alive, \"Cannot attack, victim is already dead\"\n # if attacker is stronger than victim, the victim's health is reduced by (0, 15)\n if victim.strength < self.strength:\n victim.health -= random.randint(0, 15)\n logging.debug(\"{0} is stronger\".format(self.name))\n else: # otherwise, reduce by only (0, 5)\n victim.health -= random.randint(0, 5)\n logging.debug(\"{0} is stronger\".format(victim.name))\n print(self.name, \"attacks\", victim.name)\n victim.show_health()\n\n # if the victim dies, transfer their loot to attacker and set them to dead\n if victim.health < 0:\n self.loot += victim.loot\n victim.loot = 0",
"def action_normal(self):\n obs = self.observation\n shoot = False\n eb = self.__class__.enemy_base\n \n ammopacks = filter(lambda x: x[2] == \"Ammo\", obs.objects)\n if ammopacks:\n self.updateAllAmmoSpots(ammopacks)\n # Walk to ammo\n if obs.ammo < SUFFICIENT_AMMO:\n self.goal = self.getClosestLocation(ammopacks)\n self.motivation = MOTIVATION_AMMO\n self.debugMsg(\"*> Recharge (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''if (obs.ammo > 0 and obs.foes):\n self.goal = self.getClosestLocation(obs.foes)\n self.debugMsg(\"*> Go to enemy (%d,%d)\" % self.goal)\n # If the enemy is within range, shoot.\n if(point_dist(self.goal, obs.loc) < self.settings.max_range\n and not line_intersects_grid(obs.loc, self.goal, self.grid, self.settings.tilesize)):\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #if self.goal not in obs.friends:\n self.motivation = MOTIVATION_SHOOT_TARGET\n shoot = True'''\n \n # Attack strategy 1\n #########################\n # 1) Shoot live enemies #\n #########################\n # Aim at the closest enemy outside the enemy base\n if obs.ammo > 0 and obs.foes:\n living = filter(lambda x: point_dist(x[0:2], eb) > ENEMY_BASE_RANGE, obs.foes)\n self.debugMsg(\"Living: %s\" % (living,))\n if living:\n self.debugMsg(1)\n self.goal = min(living, key=lambda x: point_dist(obs.loc, x[0:2]))[0:2]\n self.motivation = MOTIVATION_SHOOT_TARGET\n self.debugMsg(2)\n # Check if enemy in fire range\n if (\n point_dist(self.goal, obs.loc) < self.settings.max_range and\n not line_intersects_grid(\n obs.loc, \n self.goal, \n self.grid, \n self.settings.tilesize\n )\n ):\n self.debugMsg(3)\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #return self.getActionTriple(True,None,0) ###?? SHOULD WE STOP MOVING WHEN WE SHOOT?\n return self.getActionTriple(True)\n else:\n self.debugMsg(4)\n return self.getActionTriple()\n self.debugMsg(5)\n \n # Walk to an enemy CP\n if self.goal is None and len(self.friendlyCPs) < 2:\n self.goal = self.getClosestLocation(self.getQuietEnemyCPs())\n if self.goal:\n self.debugMsg(\"Crowded location: %d\" % self.getCrowdedValue(self.goal))\n self.motivation = MOTIVATION_CAPTURE_CP\n self.debugMsg(\"*> Capture (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''# If you can't think of anything to do\n # at least walk to a friendly control point\n if self.goal is None:\n self.goal = self.getClosestLocation(self.getQuietRestlessFriendlyCPs())\n if self.goal:\n self.motivation = MOTIVATION_GUARD_CP\n self.debugMsg(\"*> Guard (%d,%d)\" % (self.goal[0],self.goal[1]))'''\n \n if self.goal is None:\n self.goal = max(\n self.__class__.ammoSpots,\n key=lambda x: point_dist(x, obs.loc),\n )\n self.debugMsg(\"Going to ammospot far away (%d, %d)\" % (self.goal[0],self.goal[1]))\n self.motivation = MOTIVATION_STAY_PUT\n \n\n if self.goal:\n return self.getActionTriple(shoot)\n else:\n return self.getActionTriple(shoot)",
"def take_damage(self, damage):\n list_operators_experience = [i.get_experience / 1000 for i in\n self.operators]\n damage -= 0.1 + sum(list_operators_experience)\n # 60% of damage will receive a vehicle\n self.set_health(self.get_health - damage * 0.6)\n # A random operator, who will receive 20% of damage.\n random_operator = random.randint(0, len(self.operators) - 1)\n j = 0\n while j < len(self.operators):\n if j == random_operator:\n self.operators[j].take_damage(damage * 0.2)\n else:\n self.operators[j].take_damage(damage * 0.1)\n j += 1",
"def passive(self,target):\r\n target.hp_increase(self.__hp_increase,buff_type = \"permanent\")",
"def damage(self):\n out = (self.blurbs[self.state][\"damage\"])\n self.next_state(\"damage\")\n return out",
"def __attackDamage(self, attack, suit=0):\n if suit:\n for dmg in attack[SUIT_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0\n else:\n for dmg in attack[TOON_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0",
"def normal_defense(self):\n if self.game.get_my_mana() > DEFENSE_MANA_CAP:\n self.portals.dumb_castle_defense(DEFENSE_MANA_CAP)\n self.portals.dumb_portal_defense(PORTAL_SELF_DEFENSE_MANA_CAP)",
"def attack(self, target, bonusToAttackRoll=0):\n targetAC = target.AC\n attackRoll = self.roll()\n if attackRoll==1:\n # a natural 1 always miss\n return TH0_MISS_CRITICAL\n\n if self.character.stealth and not target.canSeeHiddenCharacter(self.character):\n surpriseAttack = True\n else:\n surpriseAttack = False\n\n if attackRoll==20:\n # a natural 20 always hit\n if surpriseAttack:\n return TH0_HIT_SURPRISE_CRITICAL\n return TH0_HIT_CRITICAL\n\n if surpriseAttack:\n bonusToAttackRoll+=4\n\n attackRoll = attackRoll + bonusToAttackRoll\n\n if attackRoll>=targetAC:\n if surpriseAttack:\n return TH0_SURPRISE_HIT\n return TH0_HIT\n \n return TH0_MISS",
"def damage(self, pokemon, damage, cause, source=None, attacker=None, drain_pct=None):\n if pokemon.is_fainted():\n if __debug__:\n log.w('Tried to damage fainted pokemon %s: cause: %s, source: %s, attacker: %s',\n pokemon, cause, source, attacker)\n return 0\n\n assert pokemon is not attacker\n assert pokemon.side.active_pokemon is pokemon\n assert pokemon.is_active\n assert damage >= 0\n assert ((isinstance(attacker, BattlePokemon) and isinstance(source, Move)) if\n cause is Cause.MOVE else True)\n\n if damage == 0:\n if __debug__: log.w('Battle.damage called with damage=0') # this shouldn't happen\n return 0\n\n if cause is Cause.WEATHER and pokemon.is_immune_to(source):\n if __debug__: log.i('Weather immunity: %s / %s', pokemon, source)\n return 0\n\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n damage = pokemon.accumulate_effect('on_damage',\n pokemon, cause, source, self, damage, failfast=True)\n if damage is FAIL:\n return FAIL\n\n pokemon.hp -= damage\n if __debug__: log.i('%s took %s (%.1f%%) damage from %s: %s; hp=%d/%d' %\n (pokemon, damage, 100*float(damage)/pokemon.max_hp, cause, source,\n pokemon.hp, pokemon.max_hp))\n if pokemon.hp <= 0:\n damage += pokemon.hp\n\n if drain_pct and not attacker.is_fainted():\n self.heal(attacker, int(math.ceil(damage * drain_pct / 100.0)), cause=Cause.DRAIN,\n foe=pokemon)\n\n if cause is Cause.MOVE:\n pokemon.activate_effect('on_after_move_damage', self, pokemon, damage, source, attacker)\n\n if pokemon.hp <= 0:\n self.faint(pokemon, cause, source, attacker)\n\n return damage",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount * self.DMG_TO_VEHICLE\n rnd_operator = random.choice(self.__operators)\n rnd_operator.get_damage(amount * self.DMG_TO_ONE_OPER)\n for operator in self.__operators:\n if operator != rnd_operator:\n operator.get_damage(amount * self.DMG_TO_OPER)\n self.estimate_total_health()\n self.check_is_alive()",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between\n # half of max_damage and max_damage\n print(\"max damage of \" + self.name + \" is \")\n print(str(self.attack_strength))\n min_damage = self.attack_strength // 2\n weapon_attack_value = random.randint(min_damage, self.attack_strength)\n return weapon_attack_value",
"def attack(self):\n\n if not self.attacking:\n self.attacking = True",
"def attack_bonus_on_level(self, level):\n raise NotImplementedError",
"def apply_ex(player: Player) -> None:\n getattr(combat_effects, \"inflict_ex_\" + player.character_class)",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between half of max_damage and max_damage\n \n weapon_attack_value = random.randint(self.max_damage//2, self.max_damage)\n return weapon_attack_value",
"def counter_attack(self, other):\n other.take_damage(self.damage/2)",
"def applyDamage(state, damage) :\n newState = copy.deepcopy(state)\n # If the enemy does not have HP information, returns the same state\n if 'hp' not in state['enemy'] :\n return newState\n # Reduces HP by damage, min HP being 0\n newState['enemy']['hp'] = max(newState['enemy']['hp'] - damage, 0)\n return newState",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n attacker_fx = await self.get_user_effects(attacker)\n\n if 'knocked_out' in attacker_fx:\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_sloth_profile = await self.get_sloth_profile(target.id)\n if not target_sloth_profile:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_sloth_profile[1] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n target_fx = await self.get_user_effects(target)\n\n if 'protected' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if 'hacked' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n if ctx.invoked_with == 'mirror':\n mirrored_skill = await self.get_skill_action_by_user_id_and_skill_type(user_id=attacker.id, skill_type='mirror')\n if not mirrored_skill:\n return await ctx.send(f\"**Something went wrong with this, {attacker.mention}!**\")\n else:\n _, exists = await Player.skill_on_cooldown(skill=Skill.ONE).predicate(ctx)\n\n try:\n current_timestamp = await utils.get_timestamp()\n # Don't need to store it, since it is forever\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n if ctx.invoked_with != 'mirror':\n if exists:\n await self.update_user_skill_ts(attacker.id, Skill.ONE, current_timestamp)\n else:\n await self.insert_user_skill_cooldown(attacker.id, Skill.ONE, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")\n else:\n if 'reflect' in target_fx:\n await self.reflect_attack(ctx, attacker, target, 'hack')",
"def attack(self):\n total_amnt_attack = 0\n for new_attack in self.abilities:\n total_amnt_attack += new_attack.attack()\n return total_amnt_attack",
"def turn_effects(self):\n if self.side_effects[\"shield\"] > 0:\n self.side_effects[\"shield\"] -= 1",
"def test_get_damage_out_of_limit(self):\n self.veh.health = 0.24\n for op in self.veh.operators:\n op.health = 0.1\n self.veh.get_damage(0.5)\n self.assertEqual(self.veh.health, 0)\n self.assertEqual(self.veh.operators[0].health, 0.05)\n self.assertEqual(self.veh.operators[1].health, 0.05)",
"def active(self,target):\r\n if target.current_hp == target.hp:\r\n raise ItemError(\"Cannot consume if health is at maximum!\")\r\n\r\n target.hp_increase(self.__hp_increase)",
"def can_throw(life):\n\treturn can_hold_item(life)",
"def attack(self, *args, **kwargs):\n return self(AbilityId.ATTACK, *args, **kwargs)",
"def attack(self, other):\n if other is not self:\n other.take_damage(self.damage)\n other.counter_attack(self)",
"def take_damage(self, damage_amt):\n\n self.health -= damage_amt\n if self.health <= 0:\n self.deaths += 1",
"def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum",
"def dealdamage(self, pokemon, movedata):\n mod = getmodifier(movedata['type'].lower(), pokemon.types)\n if movedata['category'].lower() == 'physical':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['ATK']/pokemon.currentStats['DEF'])/50+2)*mod\n if movedata['category'].lower() == 'special':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['SPATK']/pokemon.currentStats['SPDEF'])/50+2)*mod\n print(f\"HP: {pokemon.currentStats['HP']}, Damage: {damage}\")\n pokemon.takedamage(damage)\n if mod == 0:\n return [0, damage]\n if mod == 0.25:\n return [1, damage]\n if mod == 0.5:\n return [2, damage]\n if mod == 1:\n return [3, damage]\n if mod == 2:\n return [4, damage]\n if mod == 4:\n return [5, damage]",
"def updateCurrentBehavior(self, gameState, action):\n self.behavior = \"attack\"",
"def take_damage(self, damage):\n damage /= len(self.__units)\n for i in self.__units:\n i.take_damage(damage)",
"def __applyToonAttackDamages(self, toonId, hpbonus=0, kbbonus=0):\n # now be sure to adjust the damage to the suit, but only\n # if the track of the attack is not 0, meaning it is not\n # a heal, if it's a heal, then the damage is applied as\n # a plus to the target's health and we don't handle adjusting\n # toon health here (additionally attack 1 is a trap attacks,\n # doesn't cause damage directly but only in conjunction with a\n # lure attack)\n totalDamages = 0\n if not self.APPLY_HEALTH_ADJUSTMENTS:\n return totalDamages\n assert(self.battle.toonAttacks.has_key(toonId))\n attack = self.battle.toonAttacks[toonId]\n track = self.__getActualTrack(attack)\n if (track != NO_ATTACK and track != SOS and\n track != TRAP and track != NPCSOS):\n # first create a list of targets based on group or\n # single target designation for this particular attack\n targets = self.__getToonTargets(attack)\n for position in range(len(targets)):\n if hpbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_HPBONUS_COL]\n else:\n damageDone = 0\n elif kbbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_KBBONUS_COL][position]\n else:\n damageDone = 0\n else:\n assert(position < len(attack[TOON_HP_COL]))\n damageDone = attack[TOON_HP_COL][position]\n if damageDone <= 0 or self.immortalSuits:\n # suit at this position was not hit\n continue\n if (track == HEAL or track == PETSOS):\n # target of toon attack was another toon, we\n # don't want to apply any damage yet\n currTarget = targets[position]\n assert(self.toonHPAdjusts.has_key(currTarget))\n if self.CAP_HEALS:\n # make sure to bound the toon's health to its\n # max health\n toonHp = self.__getToonHp(currTarget)\n toonMaxHp = self.__getToonMaxHp(currTarget)\n if toonHp + damageDone > toonMaxHp:\n damageDone = toonMaxHp - toonHp\n attack[TOON_HP_COL][position] = damageDone\n self.toonHPAdjusts[currTarget] += damageDone\n totalDamages = totalDamages + damageDone\n continue\n\n # we should only get here if the target is a suit and\n # at least 1hp of damage was done\n currTarget = targets[position]\n assert isinstance(currTarget,\n DistributedSuitBaseAI.DistributedSuitBaseAI), \\\n targets\n currTarget.setHP(currTarget.getHP() - damageDone)\n targetId = currTarget.getDoId()\n if self.notify.getDebug():\n if hpbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from HP-Bonus\")\n elif kbbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from KB-Bonus\")\n else:\n self.notify.debug(str(targetId) + \": suit takes \" +\n str(damageDone) + \" damage\")\n totalDamages = totalDamages + damageDone\n\n # if the suit died from this or a previous\n # attack, make sure to set the 'died' field for\n # the target to 1, indicating to the higher-ups\n # that this suit has died\n if currTarget.getHP() <= 0:\n if currTarget.getSkeleRevives() >= 1:\n currTarget.useSkeleRevive()\n attack[SUIT_REVIVE_COL] = \\\n attack[SUIT_REVIVE_COL] | (1 << position)\n else:\n self.suitLeftBattle(targetId)\n attack[SUIT_DIED_COL] = \\\n attack[SUIT_DIED_COL] | (1 << position)\n if self.notify.getDebug():\n self.notify.debug(\"Suit\" + str(targetId) +\n \"bravely expired in combat\")\n\n return totalDamages",
"def take_damage(self, value, type_=None):\n if type_ in self.resistances:\n taken = math.floor(value / 2)\n # TODO (phillip): event log should show that damage was reduced\n elif type_ in self.vulnerabilities:\n taken = value * 2\n else:\n taken = value\n\n # Only used to return at the end\n actual_taken = min(self.hp, taken)\n\n self.hp -= taken\n if self.hp < -self.max_hp:\n # TODO (phillip): Implement creature death\n pass\n\n self.hp = max(0, self.hp)\n return actual_taken",
"def test_get_damage_out_of_limit(self):\n self.sold.health = 0.2\n self.sold.get_damage(0.32)\n self.assertEqual(self.sold.health, 0)",
"def spell_attack(self, caster, spell_name, targets, cost, **kwargs):\n spell_msg = \"%s casts %s!\" % (caster, spell_name)\n\n atkname_single = \"The spell\"\n atkname_plural = \"spells\"\n min_damage = 10\n max_damage = 20\n accuracy = 0\n attack_count = 1\n\n # Retrieve some variables from kwargs, if present\n if \"attack_name\" in kwargs:\n atkname_single = kwargs[\"attack_name\"][0]\n atkname_plural = kwargs[\"attack_name\"][1]\n if \"damage_range\" in kwargs:\n min_damage = kwargs[\"damage_range\"][0]\n max_damage = kwargs[\"damage_range\"][1]\n if \"accuracy\" in kwargs:\n accuracy = kwargs[\"accuracy\"]\n if \"attack_count\" in kwargs:\n attack_count = kwargs[\"attack_count\"]\n\n to_attack = []\n # If there are more attacks than targets given, attack first target multiple times\n if len(targets) < attack_count:\n to_attack = to_attack + targets\n extra_attacks = attack_count - len(targets)\n for n in range(extra_attacks):\n to_attack.insert(0, targets[0])\n else:\n to_attack = to_attack + targets\n\n # Set up dictionaries to track number of hits and total damage\n total_hits = {}\n total_damage = {}\n for fighter in targets:\n total_hits.update({fighter: 0})\n total_damage.update({fighter: 0})\n\n # Resolve attack for each target\n for fighter in to_attack:\n attack_value = randint(1, 100) + accuracy # Spell attack roll\n defense_value = self.get_defense(caster, fighter)\n if attack_value >= defense_value:\n spell_dmg = randint(min_damage, max_damage) # Get spell damage\n total_hits[fighter] += 1\n total_damage[fighter] += spell_dmg\n\n for fighter in targets:\n # Construct combat message\n if total_hits[fighter] == 0:\n spell_msg += \" The spell misses %s!\" % fighter\n elif total_hits[fighter] > 0:\n attack_count_str = atkname_single + \" hits\"\n if total_hits[fighter] > 1:\n attack_count_str = \"%i %s hit\" % (total_hits[fighter], atkname_plural)\n spell_msg += \" %s %s for %i damage!\" % (\n attack_count_str,\n fighter,\n total_damage[fighter],\n )\n\n caster.db.mp -= cost # Deduct MP cost\n\n caster.location.msg_contents(spell_msg) # Message the room with spell results\n\n for fighter in targets:\n # Apply damage\n self.apply_damage(fighter, total_damage[fighter])\n # If fighter HP is reduced to 0 or less, call at_defeat.\n if fighter.db.hp <= 0:\n self.at_defeat(fighter)\n\n if self.is_in_combat(caster): # Spend action if in combat\n self.spend_action(caster, 1, action_name=\"cast\")",
"def is_attack(self):\n\n return self.purpose == 'attack'",
"def apply_skill_effects(self, behavior):\n b_type = type(behavior)\n if issubclass(b_type, ESAttackUp):\n if b_type == ESAttackUPRemainingEnemies \\\n and behavior.enemy_count is not None \\\n and self.enemies > behavior.enemy_count:\n return False\n if self.enraged is None:\n if b_type == ESAttackUPCooldown and behavior.turn_cooldown is not None:\n self.enraged = -behavior.turn_cooldown + 1\n return False\n else:\n self.enraged = behavior.turns\n return True\n else:\n if self.enraged == 0:\n self.enraged = behavior.turns\n return True\n else:\n return False\n elif b_type == ESDamageShield:\n if self.damage_shield == 0:\n self.damage_shield = behavior.turns\n return True\n else:\n return False\n elif b_type == ESStatusShield:\n if self.status_shield == 0:\n self.status_shield = behavior.turns\n return True\n else:\n return False\n return True",
"def get_attack_damage(self, by: str):\n if by == 'spell':\n if self.spells:\n # get the spell with the maximum damage that we have enough mana for\n available_spells = [spell for spell in self.spells if self._mana >= spell.mana_cost]\n if not available_spells:\n return None\n\n spell = max(available_spells, key= lambda spell: spell.damage) # type: Spell\n if spell:\n return spell\n else:\n print('{} does not know any spells.'.format(self.name))\n return None\n else:\n return self.weapon.damage",
"def attack(self, enemies):\n return super().attack(enemies, self.range, self.in_range, self.damage, 16)",
"def _reward(self, action):\n raise NotImplementedError",
"def attack(self, enemy):\r\n best_weapon = None\r\n max_damage = 0\r\n # Searches your inventory for your highest damaging weapon\r\n for i in self._inventory:\r\n if isinstance(i, items.Weapon):\r\n if i._damage > max_damage:\r\n best_weapon = i\r\n max_damage = i._damage\r\n\r\n print(\"You use {} against {}!\".format(best_weapon._name, enemy._name))\r\n enemy._health_points -= best_weapon._damage\r\n if not enemy.is_alive():\r\n print(\"You've killed {}!\".format(enemy._name))\r\n\r\n else:\r\n print(\"The {} isn't dead yet. It has {} health remaining. Keep fighting!\".format(enemy._name, enemy._health_points))",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n if await self.is_user_knocked_out(attacker.id):\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_currency = await self.get_user_currency(target.id)\n if not target_currency:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_currency[7] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n if await self.is_user_protected(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if await self.is_user_hacked(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n await self.check_cooldown(user_id=attacker.id, skill_number=1)\n\n try:\n current_timestamp = await self.get_timestamp()\n # Don't need to store it, since it is forever\n await self.update_user_is_hacked(target.id, 1)\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n await self.update_user_action_skill_ts(attacker.id, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n msg = await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")"
] | [
"0.81057763",
"0.7999557",
"0.7960427",
"0.7736732",
"0.7559663",
"0.75042886",
"0.73485667",
"0.69856614",
"0.6954562",
"0.68673724",
"0.6778077",
"0.67357415",
"0.66850173",
"0.6644636",
"0.6638605",
"0.662029",
"0.6539297",
"0.65386426",
"0.65321666",
"0.65184796",
"0.65008146",
"0.6496057",
"0.6479794",
"0.6462085",
"0.6440297",
"0.64162344",
"0.6388051",
"0.63838446",
"0.6383606",
"0.6367558",
"0.6367558",
"0.6353072",
"0.63491184",
"0.6341149",
"0.62979174",
"0.6283066",
"0.6280401",
"0.62739074",
"0.62733066",
"0.6268356",
"0.62564576",
"0.6244335",
"0.6229594",
"0.62261",
"0.62221265",
"0.62062085",
"0.6198498",
"0.61962956",
"0.61946404",
"0.61925095",
"0.61889863",
"0.6186729",
"0.6184047",
"0.61670655",
"0.61589444",
"0.6141316",
"0.6126803",
"0.61222",
"0.6118753",
"0.61061203",
"0.6103459",
"0.610009",
"0.60851514",
"0.6067181",
"0.606224",
"0.60566694",
"0.6040522",
"0.603953",
"0.60370547",
"0.6027466",
"0.6021367",
"0.60086644",
"0.5995696",
"0.5967911",
"0.5965284",
"0.59649885",
"0.5960138",
"0.5958327",
"0.59544295",
"0.59489006",
"0.5947135",
"0.5946535",
"0.5945641",
"0.59453267",
"0.5928747",
"0.5886637",
"0.58859384",
"0.5885854",
"0.5880612",
"0.5880575",
"0.5875484",
"0.58734626",
"0.5869462",
"0.58632183",
"0.5851432",
"0.5850708",
"0.5847332",
"0.5831628",
"0.58238983",
"0.58220804"
] | 0.79067296 | 3 |
ability that deals damage to the target | def ability_3(self,target):
damage = (self.get_dexterity()+self.get_strength())
target.receive_damage(damage) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ability_1(self,target):\r\n damage = (self.get_strength()+2)\r\n target.receive_damage(damage)",
"def ability_4(self,target):\r\n damage = (self.get_strength()*3)\r\n target.receive_damage(damage)",
"def ability_2(self,target):\r\n damage1 = (self.get_lvl()+self.get_strength())\r\n target.receive_damage(damage1)",
"def _attack(self,target):\r\n damage = self.get_strength() * self.get_lvl()\r\n target.receive_damage(damage)",
"def attack(self, target, friendly):\n self.on_attack(target, friendly)\n dmg = self.on_deal_dmg(target, friendly)\n self.death_remove(friendly)\n # May remove other minions in special cases\n # ... \n\n return dmg",
"def deal_damage(self, target):\n if hasattr(target, \"hp\"):\n dmg = random.randrange(self.atk + 1)\n target.take_damage(dmg)\n return dmg",
"def on_deal_dmg(self, target, friendly):\n if self.hurt:\n self.dfs -= target.atk\n if self.dfs <= 0 or target.poison:\n self.dead = True\n if target.hurt:\n target.dfs -= self.atk\n if target.dfs <= 0 or self.poison:\n target.dead = True\n\n # some special events may take place here\n # ... \n return self.atk",
"def on_attack(self, target, friendly):\n # Get buff from Dread Admiral Eliza\n if self.race == 'pirate' or self.race == 'all':\n eliza_buff_atk, eliza_buff_dfs = friendly.friendly_eliza_buff\n for each in friendly.minions:\n each.get_buff(eliza_buff_atk, eliza_buff_dfs)\n\n # If divine shield, not getting hurt\n if not self.divine_shield:\n self.hurt = True\n if not target.divine_shield:\n target.hurt = True",
"def damage(self, dmg_value):\n if self.can_take_damage():\n # here we'll add if it's affected by negative buffs\n self.health -= dmg_value",
"def deal_dmg(self):\n return self.damage",
"def can_take_damage(self):\n result = True\n if self.side_effects[\"shield\"] > 0:\n result = False\n return result",
"def damageSubtractor(self, damage, target, caller):\n # Build the target av objects\n target_shield_value = target.db.shield_value # Applied conditionally\n target_armor = target.db.armor\n target_tough = target.db.tough\n target_armor_specialist = target.db.armor_specialist\n\n # Apply damage in order\n if target_shield_value:\n # Get value of shield damage to check if it's under 0. Need to pass\n # this on to armor\n shield_damage = target_shield_value - damage\n if shield_damage < 0:\n # Check if damage would make shield go below 0\n damage = abs(shield_damage)\n # Set shield_value to 0\n target.db.shield_value = 0\n # Recalc and set av with new shield value\n else:\n target.db.shield_value = shield_damage\n damage = 0\n\n if target_armor_specialist and damage:\n # Get value of damage\n armor_specialist_damage = target_armor_specialist - damage\n if armor_specialist_damage < 0:\n damage = abs(armor_specialist_damage)\n target.db.armor_specialist = 0\n else:\n target.db.armor_specialist = armor_specialist_damage\n damage = 0\n\n if target_armor and damage:\n # Get value of damage\n armor_damage = target_armor - damage\n if armor_damage < 0:\n damage = abs(armor_damage)\n target.db.armor = 0\n else:\n target.db.armor = armor_damage\n damage = 0\n\n if target_tough and damage:\n tough_damage = target_tough - damage\n if tough_damage < 0:\n damage = abs(tough_damage)\n target.db.tough = 0\n else:\n target.db.tough = tough_damage\n damage = 0\n else:\n self.deathSubtractor(damage, target, caller)\n\n new_av = self.updateArmorValue(target.db.shield_value, target.db.armor, target.db.tough, target.db.armor_specialist)\n\n return new_av",
"def apply_ability_effects(ability: dict, target: Player, self: Player) -> None:\n for effect in ability[\"effects\"]:\n if effect[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=target\n )\n elif effect[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=self\n )",
"def use(target, name):\n out = target.damage() + \"\\n\"\n return out + \"You swing the \" + name + \" at \" + target.name",
"def ship_took_damage(self, damage: Damage):\n pass",
"def take_damage(self, dmg, dtype = 1):\n self.game.hit_sound.play()\n \n #DR% = 1 - (100 / x). \n damageMultiplier = 100.0 / float(self.defense)\n #Apply defense buffs/debuffs\n #calculate damage:\n dmg -= self.absorbtion\n dmg *= damageMultiplier\n #apply damage\n self.hp[0] -= dmg",
"def doDamage(self, owner, messages):\n self.damageDelegate.doDamage(owner, owner, None)\n messages.append(self.hurtItself)",
"def passive(self,target):\r\n target.shield_increase(200,buff_type = \"temp\")",
"def passive(self,target):\r\n target.dmg_increase(self.__dmg_increase,buff_type = \"permanent\")",
"def Hit(self, damage):\n self.health -= damage",
"def CombatAttack(self):\n self.attacker.Attack(target=self.defender)",
"def attack(self, attack_name, pokemon_to_hit):\n attack = next(attack for attack in self.attacks if attack.name == attack_name)\n if pokemon_to_hit.weakness == self.type:\n pokemon_to_hit.hp -= attack.damage * 2\n else:\n pokemon_to_hit.hp -= attack.damage",
"def deal_damage(self, damage):\n # Another cool trick\n self.current_health = max(\n 0,\n self.current_health-damage\n )",
"def __attack(self, target):\n attack_difference = (Warrior.attack(self, target))\n if attack_difference > 5:\n print(\"Second attack with ANGRY!\")\n Warrior.attack(self, target)\n return None",
"def coreDamage(self, user, target):\n scale = self.getScale()\n \n damage = super(DamageScaleDelegate, self).coreDamage(user, target)-2\n damage = damage*scale\n return damage + 2",
"def damage(self):\n if not self.damage_mode and not self.attack_mode and not self.death_mode:\n self.damage_mode = True\n self.cut_frame_update = 0",
"def attack(self, enemy):\n damage_dealt = self.damage - enemy.armor\n if damage_dealt < 1:\n damage_dealt = 1\n enemy.hit_points -= damage_dealt",
"async def use(self):\n\n # init\n await self.caster.posture.change_posture(\"attacking\")\n\n move = Move_displayer()\n calculator = Damage_calculator(self.caster, self.target)\n checker = Effect_checker(self.target)\n\n # get the damage\n damage = randint(self.caster.damage.physical_min, self.caster.damage.physical_max)\n damage = await calculator.physical_damage(\n damage,\n critable = True,\n dodgable = True\n )\n\n # define move info\n _move = await move.get_new_move()\n\n _move[\"name\"] = self.name\n _move[\"icon\"] = self.icon\n _move[\"damage\"] = damage[\"calculated\"]\n _move[\"critical\"] = damage[\"critical\"]\n _move[\"dodge\"] = damage[\"dodge\"]\n _move[\"physical\"] = True\n\n _move = await move.offensive_move(_move)\n\n # inflict damage\n await self.target.receive_damage(damage[\"calculated\"])\n\n return(_move)",
"def take_damage(self, damage):\n if self.hp - damage <= 0:\n self.hp = 0\n self.die()\n else:\n self.hp -= damage",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def take_damage(self, damage):\n attack = damage - (0.05 + self.__experience / 1000)\n self.set_health(self.get_health - attack)",
"def damage(self, damage):\n return self.damage",
"def heal(self):\n self.infected = False",
"def heavy_attack(self, enemy):\n #Generate damage\n damage = random.randint(0, 50)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All heavy attacks will appear at index 1 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[1] + \".\")\n\n #Dealt no damage\n if damage < 10:\n print(\"The attack missed!!!\")\n else:\n print(\"It dealt \" + str(damage) + \" damage.\")\n #Deal the damage to the enemy\n enemy.current_health -= damage",
"def take_damage(self, damage):\n if random.random() < self.chance_dodge:\n self.set_health(self.health - damage)\n return True\n return False",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount",
"def passive(self,target):\r\n target.temp[\"cannot_act\"][\"temp\"] = True",
"def attack(self, other):\n print(self.name, \"attacks\", other.name)\n damage = self.strenght*(1.-other.defense)\n print(\"damage: \", damage)\n other.hp -= damage\n print(other.name+\"'s remaining health: \", other.hp,)\n print(\"----------\")",
"def attack(self):\n\t if self.damage == 0:\n\t\treturn None\n\t elif self.name == \"die\":\n\t roll = random.randint(1,20)\n\t if roll == 1:\n\t return 0\n\t else:\n\t return 1\n\t elif self.damage == 1 or self.damage == 2:\n\t\treturn self.damage\n\t elif self.damage == 3:\n\t\treturn random.randint(3,5)\n\t elif self.damage == -4:\n\t return 4\n\t elif self.damage == 10:\n\t\trandomInt = random.randint(1,4)\n\t\tif randomInt == 1:\n\t\t return 10\n\t\telse:\n\t\t return 0\n\t else:\n\t return self.damage",
"def take_damage(self, damage):\n if damage <= 0: return\n self.hit_points[0] -= damage\n if self.hit_points[0] <= 0: self.die()",
"def attackProcess(attack: \"Attack\", attacker: \"PlayerCharacter or Monster\", enemies: list, targetID: int):\n hits, target, ail = 1, [targetID], None\n damageRange, critChance, critMultiplier = (95, 105), 0.1, 2\n if (attack.special):\n hits = attack.special[\"HITS\"] if \"HITS\" in attack.special.keys() else 1\n target = attack.special[\"TARGET\"] if \"TARGET\" in attack.special.keys() else target\n ail = attack.special[\"INFLICT\"] if \"INFLICT\" in attack.special.keys() else None\n damageRange = attack.special[\"DAMAGE RANGE\"] if \"DAMAGE RANGE\" in attack.special.keys() else damageRange\n critChance = attack.special[\"CRIT CHANCE\"] if \"CRIT CHANCE\" in attack.special.keys() else critChance\n critMultiplier = attack.special[\"CRIT MULTIPLIER\"] if \"CRIT MULTIPLIER\" in attack.special.keys() else critMultiplier\n target = targeting(len(enemies), target, hits)\n if attack.category == \"MAGICAL\":\n attackerPower = attacker.stats[\"MAGIC\"]\n attackerPower *= 0.6 if \"MUDDLE\" in attacker.conditions.keys() else 1\n else:\n attackerPower = attacker.stats[\"STRENGTH\"]\n attackerPower *= 0.6 if \"BURN\" in attacker.conditions.keys() else 1\n attackerPower *= 0.8 if \"LETHARGY\" in attacker.conditions.keys() else 1\n power = attack.power * attackerPower\n for i in target:\n roll = random.random()\n targetSpeed = 1 if \"STUN\" in enemies[i].conditions.keys() else enemies[i].stats[\"SPEED\"]\n hitChance = ((attacker.stats[\"SPEED\"] + attackerPower/10) / targetSpeed)\n hitChance *= 0.6 if \"BLIND\" in attacker.conditions.keys() else 1\n hitCheck = roll < hitChance\n if hitCheck:\n critCheck = roll < critChance\n resist = enemies[i].resist[attack.element] if attack.element in enemies[i].resist.keys() else 1\n damage = power * resist * (random.randint(damageRange[0], damageRange[1])/100)\n if critCheck:\n damage *= critMultiplier\n print(\"Critical hit!\")\n damage /= 2 if enemies[i].defend else 1\n damage //= enemies[i].stats[\"DEFENSE\"] if attack.category == \"PHYSICAL\" else enemies[i].stats[\"RESISTANCE\"]\n enemies[i].hp -= damage\n if enemies[i].hp < 0:\n enemies[i].ko = True\n enemies[i].hp = 0\n print(f\"\\n{attacker.name}'s {attack.name} dealt {damage} damage to {enemies[i].name}!\")\n print(f\"{enemies[i].name} {enemies[i].hp}/{enemies[i].stats['MAXHP']}\\n\")\n if ail and not enemies[i].ko:\n inflict(ail, enemies[i])\n else:\n print(f\"\\n{attacker.name} missed!\")\n attacker.wait = attack.wait * (100 - (1 if \"STUN\" in attacker.conditions.keys() else attacker.stats[\"SPEED\"])) // 1000",
"def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res",
"def attack(self):\n if random.random() < self.chance_critical:\n return self.strength * 2\n return self.strength",
"def collide_with_damage_source(self, source):\n self.bounceAgainst(source)\n source.bounceAgainst(self)",
"def is_damaged(self):\n return self.damaged",
"def light_attack(self, enemy):\n #Generate damage\n damage = random.randint(15, 25)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All light attacks will appear at index 0 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[0] + \".\")\n print(\"It dealt \" + str(damage) + \" damage.\")\n\n #Deal damage to the enemy\n enemy.current_health -= damage",
"def attack(self, robot):\n pass",
"def applyEffect(self, user, target, environment):\n pkmn = self.getEffectedPokemon(user, target)\n self.affectPkmn(pkmn)",
"def attack1(self, command):\n\n if random.randint(1,3) == 1 or random.randint(1,3) == 3:\n p.health -= self.weapon[0].damage\n print(\"You've been hit! \\nHealth at \" + str(p.health))\n else:\n print('Enemy tried to attack, missed!')",
"def apply_enhancements(ability: dict, target: Player, self: Player) -> None:\n self.status_effects.append([\"enhancement_sickness\", 1])\n\n for enhancement in ability[\"enhancements\"]:\n if enhancement[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=target\n )\n elif enhancement[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=self\n )",
"def deal_damage(self, modifier: int, critical_hit: bool) -> int:\r\n if critical_hit:\r\n damage_dice = self.critical_hit()\r\n else:\r\n damage_dice = self.damage\r\n damage = dice.roll(damage_dice)[0] + modifier\r\n return damage",
"def attack(self, character):\n\n character.hp -= max(0, (self.atk - character.defense))",
"def deathSubtractor(self, damage, target, caller):\n target_body = target.db.body\n target_bleed_points = target.db.bleed_points\n target_death_points = target.db.death_points\n\n if target_body and damage:\n body_damage = target_body - damage\n if body_damage < 0:\n damage = abs(body_damage)\n target.db.body = 0\n else:\n target.db.body = body_damage\n damage = 0\n\n if target_bleed_points and damage:\n bleed_damage = target_bleed_points - damage\n if bleed_damage < 0:\n damage = abs(bleed_damage)\n target.db.bleed_points = 0\n target.db.weakness = 1\n else:\n target.db.bleed_points = bleed_damage\n damage = 0\n target.db.weakness = 1\n\n target.msg(\"|430You are bleeding profusely from many wounds and can no longer use any active martial skills.\\n|n\")\n target.location.msg_contents(f\"{target.key} |025is bleeding profusely from many wounds and will soon lose consciousness.|n\")\n\n\n if target_death_points and damage:\n death_damage = target_death_points - damage\n if death_damage < 0:\n damage = abs(death_damage)\n target.db.death_points = 0\n else:\n target.db.death_points = death_damage\n damage = 0\n\n target.msg(\"|300You are unconscious and can no longer move of your own volition.|n\")\n target.location.msg_contents(f\"{target.key} |025does not seem to be moving.|n\")\n\n else:\n pass",
"def direct_damage(self, pokemon, damage):\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n pokemon.hp -= damage\n if pokemon.hp <= 0:\n self.faint(pokemon, Cause.DIRECT)",
"def takeHit(self, amount, type, enemyShip):\n if type == 'energy':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount\n amount = 0\n else:\n amount -= self.currentSP\n self.currentSP = 0\n # go through armor next\n if self.currentAP > 0 and amount > 0:\n # set experience only if shot goes through shields\n if self.typeAP == 'energy':\n if self.currentAP >= (amount * globals.reflectiveArmorModifier):\n self.currentAP -= (amount * globals.reflectiveArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.reflectiveArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n elif type == 'impact':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount/2\n amount = amount/2\n else:\n amount -= self.currentSP\n self.currentSP = 0\n \n # now goto armor\n if self.currentAP > 0 and amount > 0:\n if self.typeAP == 'impact':\n if self.currentAP >= (amount * globals.impactArmorModifier):\n self.currentAP -= (amount * globals.impactArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.impactArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n \n # now that shields and armor are taken care of transfer remaining damage to internal components\n self.myParent.setExperience(amount, enemyShip)\n componentDamage = 0\n if amount > 0 and self.components != {}:\n while amount > 0:\n keyList = funcs.sortStringList(self.components.keys())\n componentDamage = 1\n for componentID in keyList:\n component = self.components[componentID]\n if component.currentHP > amount:\n component.currentHP -= amount\n amount = 0\n break\n elif component.currentHP > 0:\n # remove component\n amount -= component.currentHP\n del self.components[componentID]\n \n # check if all components destroyed, or damage absorbed\n if self.components == {} or amount == 0:\n break\n \n if componentDamage == 1:\n self.setMyStatus()\n self.myParent.setMyStatus()\n \n if amount > 0:\n if self.myParent.currentISP > amount:\n self.myParent.currentISP -= amount\n self.myParent.setMyStatus()\n amount = 0\n else:\n self.myParent.destroyMe()\n amount = 0\n \n self.myParent.updateAllGUIValues()",
"def getDefense(self):\n\t\treturn(self.maneuverability * self.protection)",
"def attack(self):\n return random.randint(self.max_damage//2, self.max_damage)",
"def take_damage(self, dmg):\n self._ensure_is_alive()\n\n self._hit_points -= dmg\n\n if self.hit_points <= 0:\n self._hit_points = 0",
"def attack(self, victim):\n assert victim.is_alive, \"Cannot attack, victim is already dead\"\n # if attacker is stronger than victim, the victim's health is reduced by (0, 15)\n if victim.strength < self.strength:\n victim.health -= random.randint(0, 15)\n logging.debug(\"{0} is stronger\".format(self.name))\n else: # otherwise, reduce by only (0, 5)\n victim.health -= random.randint(0, 5)\n logging.debug(\"{0} is stronger\".format(victim.name))\n print(self.name, \"attacks\", victim.name)\n victim.show_health()\n\n # if the victim dies, transfer their loot to attacker and set them to dead\n if victim.health < 0:\n self.loot += victim.loot\n victim.loot = 0",
"def action_normal(self):\n obs = self.observation\n shoot = False\n eb = self.__class__.enemy_base\n \n ammopacks = filter(lambda x: x[2] == \"Ammo\", obs.objects)\n if ammopacks:\n self.updateAllAmmoSpots(ammopacks)\n # Walk to ammo\n if obs.ammo < SUFFICIENT_AMMO:\n self.goal = self.getClosestLocation(ammopacks)\n self.motivation = MOTIVATION_AMMO\n self.debugMsg(\"*> Recharge (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''if (obs.ammo > 0 and obs.foes):\n self.goal = self.getClosestLocation(obs.foes)\n self.debugMsg(\"*> Go to enemy (%d,%d)\" % self.goal)\n # If the enemy is within range, shoot.\n if(point_dist(self.goal, obs.loc) < self.settings.max_range\n and not line_intersects_grid(obs.loc, self.goal, self.grid, self.settings.tilesize)):\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #if self.goal not in obs.friends:\n self.motivation = MOTIVATION_SHOOT_TARGET\n shoot = True'''\n \n # Attack strategy 1\n #########################\n # 1) Shoot live enemies #\n #########################\n # Aim at the closest enemy outside the enemy base\n if obs.ammo > 0 and obs.foes:\n living = filter(lambda x: point_dist(x[0:2], eb) > ENEMY_BASE_RANGE, obs.foes)\n self.debugMsg(\"Living: %s\" % (living,))\n if living:\n self.debugMsg(1)\n self.goal = min(living, key=lambda x: point_dist(obs.loc, x[0:2]))[0:2]\n self.motivation = MOTIVATION_SHOOT_TARGET\n self.debugMsg(2)\n # Check if enemy in fire range\n if (\n point_dist(self.goal, obs.loc) < self.settings.max_range and\n not line_intersects_grid(\n obs.loc, \n self.goal, \n self.grid, \n self.settings.tilesize\n )\n ):\n self.debugMsg(3)\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #return self.getActionTriple(True,None,0) ###?? SHOULD WE STOP MOVING WHEN WE SHOOT?\n return self.getActionTriple(True)\n else:\n self.debugMsg(4)\n return self.getActionTriple()\n self.debugMsg(5)\n \n # Walk to an enemy CP\n if self.goal is None and len(self.friendlyCPs) < 2:\n self.goal = self.getClosestLocation(self.getQuietEnemyCPs())\n if self.goal:\n self.debugMsg(\"Crowded location: %d\" % self.getCrowdedValue(self.goal))\n self.motivation = MOTIVATION_CAPTURE_CP\n self.debugMsg(\"*> Capture (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''# If you can't think of anything to do\n # at least walk to a friendly control point\n if self.goal is None:\n self.goal = self.getClosestLocation(self.getQuietRestlessFriendlyCPs())\n if self.goal:\n self.motivation = MOTIVATION_GUARD_CP\n self.debugMsg(\"*> Guard (%d,%d)\" % (self.goal[0],self.goal[1]))'''\n \n if self.goal is None:\n self.goal = max(\n self.__class__.ammoSpots,\n key=lambda x: point_dist(x, obs.loc),\n )\n self.debugMsg(\"Going to ammospot far away (%d, %d)\" % (self.goal[0],self.goal[1]))\n self.motivation = MOTIVATION_STAY_PUT\n \n\n if self.goal:\n return self.getActionTriple(shoot)\n else:\n return self.getActionTriple(shoot)",
"def take_damage(self, damage):\n list_operators_experience = [i.get_experience / 1000 for i in\n self.operators]\n damage -= 0.1 + sum(list_operators_experience)\n # 60% of damage will receive a vehicle\n self.set_health(self.get_health - damage * 0.6)\n # A random operator, who will receive 20% of damage.\n random_operator = random.randint(0, len(self.operators) - 1)\n j = 0\n while j < len(self.operators):\n if j == random_operator:\n self.operators[j].take_damage(damage * 0.2)\n else:\n self.operators[j].take_damage(damage * 0.1)\n j += 1",
"def passive(self,target):\r\n target.hp_increase(self.__hp_increase,buff_type = \"permanent\")",
"def damage(self):\n out = (self.blurbs[self.state][\"damage\"])\n self.next_state(\"damage\")\n return out",
"def __attackDamage(self, attack, suit=0):\n if suit:\n for dmg in attack[SUIT_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0\n else:\n for dmg in attack[TOON_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0",
"def normal_defense(self):\n if self.game.get_my_mana() > DEFENSE_MANA_CAP:\n self.portals.dumb_castle_defense(DEFENSE_MANA_CAP)\n self.portals.dumb_portal_defense(PORTAL_SELF_DEFENSE_MANA_CAP)",
"def attack(self, target, bonusToAttackRoll=0):\n targetAC = target.AC\n attackRoll = self.roll()\n if attackRoll==1:\n # a natural 1 always miss\n return TH0_MISS_CRITICAL\n\n if self.character.stealth and not target.canSeeHiddenCharacter(self.character):\n surpriseAttack = True\n else:\n surpriseAttack = False\n\n if attackRoll==20:\n # a natural 20 always hit\n if surpriseAttack:\n return TH0_HIT_SURPRISE_CRITICAL\n return TH0_HIT_CRITICAL\n\n if surpriseAttack:\n bonusToAttackRoll+=4\n\n attackRoll = attackRoll + bonusToAttackRoll\n\n if attackRoll>=targetAC:\n if surpriseAttack:\n return TH0_SURPRISE_HIT\n return TH0_HIT\n \n return TH0_MISS",
"def damage(self, pokemon, damage, cause, source=None, attacker=None, drain_pct=None):\n if pokemon.is_fainted():\n if __debug__:\n log.w('Tried to damage fainted pokemon %s: cause: %s, source: %s, attacker: %s',\n pokemon, cause, source, attacker)\n return 0\n\n assert pokemon is not attacker\n assert pokemon.side.active_pokemon is pokemon\n assert pokemon.is_active\n assert damage >= 0\n assert ((isinstance(attacker, BattlePokemon) and isinstance(source, Move)) if\n cause is Cause.MOVE else True)\n\n if damage == 0:\n if __debug__: log.w('Battle.damage called with damage=0') # this shouldn't happen\n return 0\n\n if cause is Cause.WEATHER and pokemon.is_immune_to(source):\n if __debug__: log.i('Weather immunity: %s / %s', pokemon, source)\n return 0\n\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n damage = pokemon.accumulate_effect('on_damage',\n pokemon, cause, source, self, damage, failfast=True)\n if damage is FAIL:\n return FAIL\n\n pokemon.hp -= damage\n if __debug__: log.i('%s took %s (%.1f%%) damage from %s: %s; hp=%d/%d' %\n (pokemon, damage, 100*float(damage)/pokemon.max_hp, cause, source,\n pokemon.hp, pokemon.max_hp))\n if pokemon.hp <= 0:\n damage += pokemon.hp\n\n if drain_pct and not attacker.is_fainted():\n self.heal(attacker, int(math.ceil(damage * drain_pct / 100.0)), cause=Cause.DRAIN,\n foe=pokemon)\n\n if cause is Cause.MOVE:\n pokemon.activate_effect('on_after_move_damage', self, pokemon, damage, source, attacker)\n\n if pokemon.hp <= 0:\n self.faint(pokemon, cause, source, attacker)\n\n return damage",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount * self.DMG_TO_VEHICLE\n rnd_operator = random.choice(self.__operators)\n rnd_operator.get_damage(amount * self.DMG_TO_ONE_OPER)\n for operator in self.__operators:\n if operator != rnd_operator:\n operator.get_damage(amount * self.DMG_TO_OPER)\n self.estimate_total_health()\n self.check_is_alive()",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between\n # half of max_damage and max_damage\n print(\"max damage of \" + self.name + \" is \")\n print(str(self.attack_strength))\n min_damage = self.attack_strength // 2\n weapon_attack_value = random.randint(min_damage, self.attack_strength)\n return weapon_attack_value",
"def attack(self):\n\n if not self.attacking:\n self.attacking = True",
"def attack_bonus_on_level(self, level):\n raise NotImplementedError",
"def apply_ex(player: Player) -> None:\n getattr(combat_effects, \"inflict_ex_\" + player.character_class)",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between half of max_damage and max_damage\n \n weapon_attack_value = random.randint(self.max_damage//2, self.max_damage)\n return weapon_attack_value",
"def counter_attack(self, other):\n other.take_damage(self.damage/2)",
"def applyDamage(state, damage) :\n newState = copy.deepcopy(state)\n # If the enemy does not have HP information, returns the same state\n if 'hp' not in state['enemy'] :\n return newState\n # Reduces HP by damage, min HP being 0\n newState['enemy']['hp'] = max(newState['enemy']['hp'] - damage, 0)\n return newState",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n attacker_fx = await self.get_user_effects(attacker)\n\n if 'knocked_out' in attacker_fx:\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_sloth_profile = await self.get_sloth_profile(target.id)\n if not target_sloth_profile:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_sloth_profile[1] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n target_fx = await self.get_user_effects(target)\n\n if 'protected' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if 'hacked' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n if ctx.invoked_with == 'mirror':\n mirrored_skill = await self.get_skill_action_by_user_id_and_skill_type(user_id=attacker.id, skill_type='mirror')\n if not mirrored_skill:\n return await ctx.send(f\"**Something went wrong with this, {attacker.mention}!**\")\n else:\n _, exists = await Player.skill_on_cooldown(skill=Skill.ONE).predicate(ctx)\n\n try:\n current_timestamp = await utils.get_timestamp()\n # Don't need to store it, since it is forever\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n if ctx.invoked_with != 'mirror':\n if exists:\n await self.update_user_skill_ts(attacker.id, Skill.ONE, current_timestamp)\n else:\n await self.insert_user_skill_cooldown(attacker.id, Skill.ONE, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")\n else:\n if 'reflect' in target_fx:\n await self.reflect_attack(ctx, attacker, target, 'hack')",
"def attack(self):\n total_amnt_attack = 0\n for new_attack in self.abilities:\n total_amnt_attack += new_attack.attack()\n return total_amnt_attack",
"def turn_effects(self):\n if self.side_effects[\"shield\"] > 0:\n self.side_effects[\"shield\"] -= 1",
"def test_get_damage_out_of_limit(self):\n self.veh.health = 0.24\n for op in self.veh.operators:\n op.health = 0.1\n self.veh.get_damage(0.5)\n self.assertEqual(self.veh.health, 0)\n self.assertEqual(self.veh.operators[0].health, 0.05)\n self.assertEqual(self.veh.operators[1].health, 0.05)",
"def active(self,target):\r\n if target.current_hp == target.hp:\r\n raise ItemError(\"Cannot consume if health is at maximum!\")\r\n\r\n target.hp_increase(self.__hp_increase)",
"def can_throw(life):\n\treturn can_hold_item(life)",
"def attack(self, *args, **kwargs):\n return self(AbilityId.ATTACK, *args, **kwargs)",
"def attack(self, other):\n if other is not self:\n other.take_damage(self.damage)\n other.counter_attack(self)",
"def take_damage(self, damage_amt):\n\n self.health -= damage_amt\n if self.health <= 0:\n self.deaths += 1",
"def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum",
"def dealdamage(self, pokemon, movedata):\n mod = getmodifier(movedata['type'].lower(), pokemon.types)\n if movedata['category'].lower() == 'physical':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['ATK']/pokemon.currentStats['DEF'])/50+2)*mod\n if movedata['category'].lower() == 'special':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['SPATK']/pokemon.currentStats['SPDEF'])/50+2)*mod\n print(f\"HP: {pokemon.currentStats['HP']}, Damage: {damage}\")\n pokemon.takedamage(damage)\n if mod == 0:\n return [0, damage]\n if mod == 0.25:\n return [1, damage]\n if mod == 0.5:\n return [2, damage]\n if mod == 1:\n return [3, damage]\n if mod == 2:\n return [4, damage]\n if mod == 4:\n return [5, damage]",
"def updateCurrentBehavior(self, gameState, action):\n self.behavior = \"attack\"",
"def take_damage(self, damage):\n damage /= len(self.__units)\n for i in self.__units:\n i.take_damage(damage)",
"def __applyToonAttackDamages(self, toonId, hpbonus=0, kbbonus=0):\n # now be sure to adjust the damage to the suit, but only\n # if the track of the attack is not 0, meaning it is not\n # a heal, if it's a heal, then the damage is applied as\n # a plus to the target's health and we don't handle adjusting\n # toon health here (additionally attack 1 is a trap attacks,\n # doesn't cause damage directly but only in conjunction with a\n # lure attack)\n totalDamages = 0\n if not self.APPLY_HEALTH_ADJUSTMENTS:\n return totalDamages\n assert(self.battle.toonAttacks.has_key(toonId))\n attack = self.battle.toonAttacks[toonId]\n track = self.__getActualTrack(attack)\n if (track != NO_ATTACK and track != SOS and\n track != TRAP and track != NPCSOS):\n # first create a list of targets based on group or\n # single target designation for this particular attack\n targets = self.__getToonTargets(attack)\n for position in range(len(targets)):\n if hpbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_HPBONUS_COL]\n else:\n damageDone = 0\n elif kbbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_KBBONUS_COL][position]\n else:\n damageDone = 0\n else:\n assert(position < len(attack[TOON_HP_COL]))\n damageDone = attack[TOON_HP_COL][position]\n if damageDone <= 0 or self.immortalSuits:\n # suit at this position was not hit\n continue\n if (track == HEAL or track == PETSOS):\n # target of toon attack was another toon, we\n # don't want to apply any damage yet\n currTarget = targets[position]\n assert(self.toonHPAdjusts.has_key(currTarget))\n if self.CAP_HEALS:\n # make sure to bound the toon's health to its\n # max health\n toonHp = self.__getToonHp(currTarget)\n toonMaxHp = self.__getToonMaxHp(currTarget)\n if toonHp + damageDone > toonMaxHp:\n damageDone = toonMaxHp - toonHp\n attack[TOON_HP_COL][position] = damageDone\n self.toonHPAdjusts[currTarget] += damageDone\n totalDamages = totalDamages + damageDone\n continue\n\n # we should only get here if the target is a suit and\n # at least 1hp of damage was done\n currTarget = targets[position]\n assert isinstance(currTarget,\n DistributedSuitBaseAI.DistributedSuitBaseAI), \\\n targets\n currTarget.setHP(currTarget.getHP() - damageDone)\n targetId = currTarget.getDoId()\n if self.notify.getDebug():\n if hpbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from HP-Bonus\")\n elif kbbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from KB-Bonus\")\n else:\n self.notify.debug(str(targetId) + \": suit takes \" +\n str(damageDone) + \" damage\")\n totalDamages = totalDamages + damageDone\n\n # if the suit died from this or a previous\n # attack, make sure to set the 'died' field for\n # the target to 1, indicating to the higher-ups\n # that this suit has died\n if currTarget.getHP() <= 0:\n if currTarget.getSkeleRevives() >= 1:\n currTarget.useSkeleRevive()\n attack[SUIT_REVIVE_COL] = \\\n attack[SUIT_REVIVE_COL] | (1 << position)\n else:\n self.suitLeftBattle(targetId)\n attack[SUIT_DIED_COL] = \\\n attack[SUIT_DIED_COL] | (1 << position)\n if self.notify.getDebug():\n self.notify.debug(\"Suit\" + str(targetId) +\n \"bravely expired in combat\")\n\n return totalDamages",
"def take_damage(self, value, type_=None):\n if type_ in self.resistances:\n taken = math.floor(value / 2)\n # TODO (phillip): event log should show that damage was reduced\n elif type_ in self.vulnerabilities:\n taken = value * 2\n else:\n taken = value\n\n # Only used to return at the end\n actual_taken = min(self.hp, taken)\n\n self.hp -= taken\n if self.hp < -self.max_hp:\n # TODO (phillip): Implement creature death\n pass\n\n self.hp = max(0, self.hp)\n return actual_taken",
"def test_get_damage_out_of_limit(self):\n self.sold.health = 0.2\n self.sold.get_damage(0.32)\n self.assertEqual(self.sold.health, 0)",
"def spell_attack(self, caster, spell_name, targets, cost, **kwargs):\n spell_msg = \"%s casts %s!\" % (caster, spell_name)\n\n atkname_single = \"The spell\"\n atkname_plural = \"spells\"\n min_damage = 10\n max_damage = 20\n accuracy = 0\n attack_count = 1\n\n # Retrieve some variables from kwargs, if present\n if \"attack_name\" in kwargs:\n atkname_single = kwargs[\"attack_name\"][0]\n atkname_plural = kwargs[\"attack_name\"][1]\n if \"damage_range\" in kwargs:\n min_damage = kwargs[\"damage_range\"][0]\n max_damage = kwargs[\"damage_range\"][1]\n if \"accuracy\" in kwargs:\n accuracy = kwargs[\"accuracy\"]\n if \"attack_count\" in kwargs:\n attack_count = kwargs[\"attack_count\"]\n\n to_attack = []\n # If there are more attacks than targets given, attack first target multiple times\n if len(targets) < attack_count:\n to_attack = to_attack + targets\n extra_attacks = attack_count - len(targets)\n for n in range(extra_attacks):\n to_attack.insert(0, targets[0])\n else:\n to_attack = to_attack + targets\n\n # Set up dictionaries to track number of hits and total damage\n total_hits = {}\n total_damage = {}\n for fighter in targets:\n total_hits.update({fighter: 0})\n total_damage.update({fighter: 0})\n\n # Resolve attack for each target\n for fighter in to_attack:\n attack_value = randint(1, 100) + accuracy # Spell attack roll\n defense_value = self.get_defense(caster, fighter)\n if attack_value >= defense_value:\n spell_dmg = randint(min_damage, max_damage) # Get spell damage\n total_hits[fighter] += 1\n total_damage[fighter] += spell_dmg\n\n for fighter in targets:\n # Construct combat message\n if total_hits[fighter] == 0:\n spell_msg += \" The spell misses %s!\" % fighter\n elif total_hits[fighter] > 0:\n attack_count_str = atkname_single + \" hits\"\n if total_hits[fighter] > 1:\n attack_count_str = \"%i %s hit\" % (total_hits[fighter], atkname_plural)\n spell_msg += \" %s %s for %i damage!\" % (\n attack_count_str,\n fighter,\n total_damage[fighter],\n )\n\n caster.db.mp -= cost # Deduct MP cost\n\n caster.location.msg_contents(spell_msg) # Message the room with spell results\n\n for fighter in targets:\n # Apply damage\n self.apply_damage(fighter, total_damage[fighter])\n # If fighter HP is reduced to 0 or less, call at_defeat.\n if fighter.db.hp <= 0:\n self.at_defeat(fighter)\n\n if self.is_in_combat(caster): # Spend action if in combat\n self.spend_action(caster, 1, action_name=\"cast\")",
"def is_attack(self):\n\n return self.purpose == 'attack'",
"def apply_skill_effects(self, behavior):\n b_type = type(behavior)\n if issubclass(b_type, ESAttackUp):\n if b_type == ESAttackUPRemainingEnemies \\\n and behavior.enemy_count is not None \\\n and self.enemies > behavior.enemy_count:\n return False\n if self.enraged is None:\n if b_type == ESAttackUPCooldown and behavior.turn_cooldown is not None:\n self.enraged = -behavior.turn_cooldown + 1\n return False\n else:\n self.enraged = behavior.turns\n return True\n else:\n if self.enraged == 0:\n self.enraged = behavior.turns\n return True\n else:\n return False\n elif b_type == ESDamageShield:\n if self.damage_shield == 0:\n self.damage_shield = behavior.turns\n return True\n else:\n return False\n elif b_type == ESStatusShield:\n if self.status_shield == 0:\n self.status_shield = behavior.turns\n return True\n else:\n return False\n return True",
"def get_attack_damage(self, by: str):\n if by == 'spell':\n if self.spells:\n # get the spell with the maximum damage that we have enough mana for\n available_spells = [spell for spell in self.spells if self._mana >= spell.mana_cost]\n if not available_spells:\n return None\n\n spell = max(available_spells, key= lambda spell: spell.damage) # type: Spell\n if spell:\n return spell\n else:\n print('{} does not know any spells.'.format(self.name))\n return None\n else:\n return self.weapon.damage",
"def attack(self, enemies):\n return super().attack(enemies, self.range, self.in_range, self.damage, 16)",
"def _reward(self, action):\n raise NotImplementedError",
"def attack(self, enemy):\r\n best_weapon = None\r\n max_damage = 0\r\n # Searches your inventory for your highest damaging weapon\r\n for i in self._inventory:\r\n if isinstance(i, items.Weapon):\r\n if i._damage > max_damage:\r\n best_weapon = i\r\n max_damage = i._damage\r\n\r\n print(\"You use {} against {}!\".format(best_weapon._name, enemy._name))\r\n enemy._health_points -= best_weapon._damage\r\n if not enemy.is_alive():\r\n print(\"You've killed {}!\".format(enemy._name))\r\n\r\n else:\r\n print(\"The {} isn't dead yet. It has {} health remaining. Keep fighting!\".format(enemy._name, enemy._health_points))",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n if await self.is_user_knocked_out(attacker.id):\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_currency = await self.get_user_currency(target.id)\n if not target_currency:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_currency[7] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n if await self.is_user_protected(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if await self.is_user_hacked(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n await self.check_cooldown(user_id=attacker.id, skill_number=1)\n\n try:\n current_timestamp = await self.get_timestamp()\n # Don't need to store it, since it is forever\n await self.update_user_is_hacked(target.id, 1)\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n await self.update_user_action_skill_ts(attacker.id, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n msg = await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")"
] | [
"0.81057763",
"0.7960427",
"0.79067296",
"0.7736732",
"0.7559663",
"0.75042886",
"0.73485667",
"0.69856614",
"0.6954562",
"0.68673724",
"0.6778077",
"0.67357415",
"0.66850173",
"0.6644636",
"0.6638605",
"0.662029",
"0.6539297",
"0.65386426",
"0.65321666",
"0.65184796",
"0.65008146",
"0.6496057",
"0.6479794",
"0.6462085",
"0.6440297",
"0.64162344",
"0.6388051",
"0.63838446",
"0.6383606",
"0.6367558",
"0.6367558",
"0.6353072",
"0.63491184",
"0.6341149",
"0.62979174",
"0.6283066",
"0.6280401",
"0.62739074",
"0.62733066",
"0.6268356",
"0.62564576",
"0.6244335",
"0.6229594",
"0.62261",
"0.62221265",
"0.62062085",
"0.6198498",
"0.61962956",
"0.61946404",
"0.61925095",
"0.61889863",
"0.6186729",
"0.6184047",
"0.61670655",
"0.61589444",
"0.6141316",
"0.6126803",
"0.61222",
"0.6118753",
"0.61061203",
"0.6103459",
"0.610009",
"0.60851514",
"0.6067181",
"0.606224",
"0.60566694",
"0.6040522",
"0.603953",
"0.60370547",
"0.6027466",
"0.6021367",
"0.60086644",
"0.5995696",
"0.5967911",
"0.5965284",
"0.59649885",
"0.5960138",
"0.5958327",
"0.59544295",
"0.59489006",
"0.5947135",
"0.5946535",
"0.5945641",
"0.59453267",
"0.5928747",
"0.5886637",
"0.58859384",
"0.5885854",
"0.5880612",
"0.5880575",
"0.5875484",
"0.58734626",
"0.5869462",
"0.58632183",
"0.5851432",
"0.5850708",
"0.5847332",
"0.5831628",
"0.58238983",
"0.58220804"
] | 0.7999557 | 1 |
ability that deals damage to the target | def ability_4(self,target):
damage = (self.get_strength()*3)
target.receive_damage(damage) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ability_1(self,target):\r\n damage = (self.get_strength()+2)\r\n target.receive_damage(damage)",
"def ability_3(self,target):\r\n damage = (self.get_dexterity()+self.get_strength())\r\n target.receive_damage(damage)",
"def ability_2(self,target):\r\n damage1 = (self.get_lvl()+self.get_strength())\r\n target.receive_damage(damage1)",
"def _attack(self,target):\r\n damage = self.get_strength() * self.get_lvl()\r\n target.receive_damage(damage)",
"def attack(self, target, friendly):\n self.on_attack(target, friendly)\n dmg = self.on_deal_dmg(target, friendly)\n self.death_remove(friendly)\n # May remove other minions in special cases\n # ... \n\n return dmg",
"def deal_damage(self, target):\n if hasattr(target, \"hp\"):\n dmg = random.randrange(self.atk + 1)\n target.take_damage(dmg)\n return dmg",
"def on_deal_dmg(self, target, friendly):\n if self.hurt:\n self.dfs -= target.atk\n if self.dfs <= 0 or target.poison:\n self.dead = True\n if target.hurt:\n target.dfs -= self.atk\n if target.dfs <= 0 or self.poison:\n target.dead = True\n\n # some special events may take place here\n # ... \n return self.atk",
"def on_attack(self, target, friendly):\n # Get buff from Dread Admiral Eliza\n if self.race == 'pirate' or self.race == 'all':\n eliza_buff_atk, eliza_buff_dfs = friendly.friendly_eliza_buff\n for each in friendly.minions:\n each.get_buff(eliza_buff_atk, eliza_buff_dfs)\n\n # If divine shield, not getting hurt\n if not self.divine_shield:\n self.hurt = True\n if not target.divine_shield:\n target.hurt = True",
"def damage(self, dmg_value):\n if self.can_take_damage():\n # here we'll add if it's affected by negative buffs\n self.health -= dmg_value",
"def deal_dmg(self):\n return self.damage",
"def can_take_damage(self):\n result = True\n if self.side_effects[\"shield\"] > 0:\n result = False\n return result",
"def damageSubtractor(self, damage, target, caller):\n # Build the target av objects\n target_shield_value = target.db.shield_value # Applied conditionally\n target_armor = target.db.armor\n target_tough = target.db.tough\n target_armor_specialist = target.db.armor_specialist\n\n # Apply damage in order\n if target_shield_value:\n # Get value of shield damage to check if it's under 0. Need to pass\n # this on to armor\n shield_damage = target_shield_value - damage\n if shield_damage < 0:\n # Check if damage would make shield go below 0\n damage = abs(shield_damage)\n # Set shield_value to 0\n target.db.shield_value = 0\n # Recalc and set av with new shield value\n else:\n target.db.shield_value = shield_damage\n damage = 0\n\n if target_armor_specialist and damage:\n # Get value of damage\n armor_specialist_damage = target_armor_specialist - damage\n if armor_specialist_damage < 0:\n damage = abs(armor_specialist_damage)\n target.db.armor_specialist = 0\n else:\n target.db.armor_specialist = armor_specialist_damage\n damage = 0\n\n if target_armor and damage:\n # Get value of damage\n armor_damage = target_armor - damage\n if armor_damage < 0:\n damage = abs(armor_damage)\n target.db.armor = 0\n else:\n target.db.armor = armor_damage\n damage = 0\n\n if target_tough and damage:\n tough_damage = target_tough - damage\n if tough_damage < 0:\n damage = abs(tough_damage)\n target.db.tough = 0\n else:\n target.db.tough = tough_damage\n damage = 0\n else:\n self.deathSubtractor(damage, target, caller)\n\n new_av = self.updateArmorValue(target.db.shield_value, target.db.armor, target.db.tough, target.db.armor_specialist)\n\n return new_av",
"def apply_ability_effects(ability: dict, target: Player, self: Player) -> None:\n for effect in ability[\"effects\"]:\n if effect[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=target\n )\n elif effect[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + effect[\"effect\"])(\n value=effect[\"value\"], player=self\n )",
"def use(target, name):\n out = target.damage() + \"\\n\"\n return out + \"You swing the \" + name + \" at \" + target.name",
"def ship_took_damage(self, damage: Damage):\n pass",
"def take_damage(self, dmg, dtype = 1):\n self.game.hit_sound.play()\n \n #DR% = 1 - (100 / x). \n damageMultiplier = 100.0 / float(self.defense)\n #Apply defense buffs/debuffs\n #calculate damage:\n dmg -= self.absorbtion\n dmg *= damageMultiplier\n #apply damage\n self.hp[0] -= dmg",
"def doDamage(self, owner, messages):\n self.damageDelegate.doDamage(owner, owner, None)\n messages.append(self.hurtItself)",
"def passive(self,target):\r\n target.shield_increase(200,buff_type = \"temp\")",
"def passive(self,target):\r\n target.dmg_increase(self.__dmg_increase,buff_type = \"permanent\")",
"def Hit(self, damage):\n self.health -= damage",
"def CombatAttack(self):\n self.attacker.Attack(target=self.defender)",
"def attack(self, attack_name, pokemon_to_hit):\n attack = next(attack for attack in self.attacks if attack.name == attack_name)\n if pokemon_to_hit.weakness == self.type:\n pokemon_to_hit.hp -= attack.damage * 2\n else:\n pokemon_to_hit.hp -= attack.damage",
"def deal_damage(self, damage):\n # Another cool trick\n self.current_health = max(\n 0,\n self.current_health-damage\n )",
"def __attack(self, target):\n attack_difference = (Warrior.attack(self, target))\n if attack_difference > 5:\n print(\"Second attack with ANGRY!\")\n Warrior.attack(self, target)\n return None",
"def coreDamage(self, user, target):\n scale = self.getScale()\n \n damage = super(DamageScaleDelegate, self).coreDamage(user, target)-2\n damage = damage*scale\n return damage + 2",
"def damage(self):\n if not self.damage_mode and not self.attack_mode and not self.death_mode:\n self.damage_mode = True\n self.cut_frame_update = 0",
"def attack(self, enemy):\n damage_dealt = self.damage - enemy.armor\n if damage_dealt < 1:\n damage_dealt = 1\n enemy.hit_points -= damage_dealt",
"async def use(self):\n\n # init\n await self.caster.posture.change_posture(\"attacking\")\n\n move = Move_displayer()\n calculator = Damage_calculator(self.caster, self.target)\n checker = Effect_checker(self.target)\n\n # get the damage\n damage = randint(self.caster.damage.physical_min, self.caster.damage.physical_max)\n damage = await calculator.physical_damage(\n damage,\n critable = True,\n dodgable = True\n )\n\n # define move info\n _move = await move.get_new_move()\n\n _move[\"name\"] = self.name\n _move[\"icon\"] = self.icon\n _move[\"damage\"] = damage[\"calculated\"]\n _move[\"critical\"] = damage[\"critical\"]\n _move[\"dodge\"] = damage[\"dodge\"]\n _move[\"physical\"] = True\n\n _move = await move.offensive_move(_move)\n\n # inflict damage\n await self.target.receive_damage(damage[\"calculated\"])\n\n return(_move)",
"def take_damage(self, damage):\n if self.hp - damage <= 0:\n self.hp = 0\n self.die()\n else:\n self.hp -= damage",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def effectOnMiss(self, user, target):\n return self.stopCharge(user)",
"def take_damage(self, damage):\n attack = damage - (0.05 + self.__experience / 1000)\n self.set_health(self.get_health - attack)",
"def damage(self, damage):\n return self.damage",
"def heal(self):\n self.infected = False",
"def heavy_attack(self, enemy):\n #Generate damage\n damage = random.randint(0, 50)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All heavy attacks will appear at index 1 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[1] + \".\")\n\n #Dealt no damage\n if damage < 10:\n print(\"The attack missed!!!\")\n else:\n print(\"It dealt \" + str(damage) + \" damage.\")\n #Deal the damage to the enemy\n enemy.current_health -= damage",
"def take_damage(self, damage):\n if random.random() < self.chance_dodge:\n self.set_health(self.health - damage)\n return True\n return False",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount",
"def passive(self,target):\r\n target.temp[\"cannot_act\"][\"temp\"] = True",
"def attack(self, other):\n print(self.name, \"attacks\", other.name)\n damage = self.strenght*(1.-other.defense)\n print(\"damage: \", damage)\n other.hp -= damage\n print(other.name+\"'s remaining health: \", other.hp,)\n print(\"----------\")",
"def attack(self):\n\t if self.damage == 0:\n\t\treturn None\n\t elif self.name == \"die\":\n\t roll = random.randint(1,20)\n\t if roll == 1:\n\t return 0\n\t else:\n\t return 1\n\t elif self.damage == 1 or self.damage == 2:\n\t\treturn self.damage\n\t elif self.damage == 3:\n\t\treturn random.randint(3,5)\n\t elif self.damage == -4:\n\t return 4\n\t elif self.damage == 10:\n\t\trandomInt = random.randint(1,4)\n\t\tif randomInt == 1:\n\t\t return 10\n\t\telse:\n\t\t return 0\n\t else:\n\t return self.damage",
"def take_damage(self, damage):\n if damage <= 0: return\n self.hit_points[0] -= damage\n if self.hit_points[0] <= 0: self.die()",
"def attackProcess(attack: \"Attack\", attacker: \"PlayerCharacter or Monster\", enemies: list, targetID: int):\n hits, target, ail = 1, [targetID], None\n damageRange, critChance, critMultiplier = (95, 105), 0.1, 2\n if (attack.special):\n hits = attack.special[\"HITS\"] if \"HITS\" in attack.special.keys() else 1\n target = attack.special[\"TARGET\"] if \"TARGET\" in attack.special.keys() else target\n ail = attack.special[\"INFLICT\"] if \"INFLICT\" in attack.special.keys() else None\n damageRange = attack.special[\"DAMAGE RANGE\"] if \"DAMAGE RANGE\" in attack.special.keys() else damageRange\n critChance = attack.special[\"CRIT CHANCE\"] if \"CRIT CHANCE\" in attack.special.keys() else critChance\n critMultiplier = attack.special[\"CRIT MULTIPLIER\"] if \"CRIT MULTIPLIER\" in attack.special.keys() else critMultiplier\n target = targeting(len(enemies), target, hits)\n if attack.category == \"MAGICAL\":\n attackerPower = attacker.stats[\"MAGIC\"]\n attackerPower *= 0.6 if \"MUDDLE\" in attacker.conditions.keys() else 1\n else:\n attackerPower = attacker.stats[\"STRENGTH\"]\n attackerPower *= 0.6 if \"BURN\" in attacker.conditions.keys() else 1\n attackerPower *= 0.8 if \"LETHARGY\" in attacker.conditions.keys() else 1\n power = attack.power * attackerPower\n for i in target:\n roll = random.random()\n targetSpeed = 1 if \"STUN\" in enemies[i].conditions.keys() else enemies[i].stats[\"SPEED\"]\n hitChance = ((attacker.stats[\"SPEED\"] + attackerPower/10) / targetSpeed)\n hitChance *= 0.6 if \"BLIND\" in attacker.conditions.keys() else 1\n hitCheck = roll < hitChance\n if hitCheck:\n critCheck = roll < critChance\n resist = enemies[i].resist[attack.element] if attack.element in enemies[i].resist.keys() else 1\n damage = power * resist * (random.randint(damageRange[0], damageRange[1])/100)\n if critCheck:\n damage *= critMultiplier\n print(\"Critical hit!\")\n damage /= 2 if enemies[i].defend else 1\n damage //= enemies[i].stats[\"DEFENSE\"] if attack.category == \"PHYSICAL\" else enemies[i].stats[\"RESISTANCE\"]\n enemies[i].hp -= damage\n if enemies[i].hp < 0:\n enemies[i].ko = True\n enemies[i].hp = 0\n print(f\"\\n{attacker.name}'s {attack.name} dealt {damage} damage to {enemies[i].name}!\")\n print(f\"{enemies[i].name} {enemies[i].hp}/{enemies[i].stats['MAXHP']}\\n\")\n if ail and not enemies[i].ko:\n inflict(ail, enemies[i])\n else:\n print(f\"\\n{attacker.name} missed!\")\n attacker.wait = attack.wait * (100 - (1 if \"STUN\" in attacker.conditions.keys() else attacker.stats[\"SPEED\"])) // 1000",
"def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res",
"def attack(self):\n if random.random() < self.chance_critical:\n return self.strength * 2\n return self.strength",
"def collide_with_damage_source(self, source):\n self.bounceAgainst(source)\n source.bounceAgainst(self)",
"def is_damaged(self):\n return self.damaged",
"def light_attack(self, enemy):\n #Generate damage\n damage = random.randint(15, 25)\n \n #All pykemon will have a list moves = [light, heavy, restore, special]\n #All light attacks will appear at index 0 in the list moves\n #This attribute will be initialized in the child class\n print(\"Pykemon \" + self.name + \" used \" + self.moves[0] + \".\")\n print(\"It dealt \" + str(damage) + \" damage.\")\n\n #Deal damage to the enemy\n enemy.current_health -= damage",
"def attack(self, robot):\n pass",
"def applyEffect(self, user, target, environment):\n pkmn = self.getEffectedPokemon(user, target)\n self.affectPkmn(pkmn)",
"def attack1(self, command):\n\n if random.randint(1,3) == 1 or random.randint(1,3) == 3:\n p.health -= self.weapon[0].damage\n print(\"You've been hit! \\nHealth at \" + str(p.health))\n else:\n print('Enemy tried to attack, missed!')",
"def apply_enhancements(ability: dict, target: Player, self: Player) -> None:\n self.status_effects.append([\"enhancement_sickness\", 1])\n\n for enhancement in ability[\"enhancements\"]:\n if enhancement[\"target\"] == \"target\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=target\n )\n elif enhancement[\"target\"] == \"self\":\n getattr(combat_effects, \"inflict_\" + enhancement[\"effect\"])(\n value=enhancement[\"value\"], player=self\n )",
"def deal_damage(self, modifier: int, critical_hit: bool) -> int:\r\n if critical_hit:\r\n damage_dice = self.critical_hit()\r\n else:\r\n damage_dice = self.damage\r\n damage = dice.roll(damage_dice)[0] + modifier\r\n return damage",
"def attack(self, character):\n\n character.hp -= max(0, (self.atk - character.defense))",
"def deathSubtractor(self, damage, target, caller):\n target_body = target.db.body\n target_bleed_points = target.db.bleed_points\n target_death_points = target.db.death_points\n\n if target_body and damage:\n body_damage = target_body - damage\n if body_damage < 0:\n damage = abs(body_damage)\n target.db.body = 0\n else:\n target.db.body = body_damage\n damage = 0\n\n if target_bleed_points and damage:\n bleed_damage = target_bleed_points - damage\n if bleed_damage < 0:\n damage = abs(bleed_damage)\n target.db.bleed_points = 0\n target.db.weakness = 1\n else:\n target.db.bleed_points = bleed_damage\n damage = 0\n target.db.weakness = 1\n\n target.msg(\"|430You are bleeding profusely from many wounds and can no longer use any active martial skills.\\n|n\")\n target.location.msg_contents(f\"{target.key} |025is bleeding profusely from many wounds and will soon lose consciousness.|n\")\n\n\n if target_death_points and damage:\n death_damage = target_death_points - damage\n if death_damage < 0:\n damage = abs(death_damage)\n target.db.death_points = 0\n else:\n target.db.death_points = death_damage\n damage = 0\n\n target.msg(\"|300You are unconscious and can no longer move of your own volition.|n\")\n target.location.msg_contents(f\"{target.key} |025does not seem to be moving.|n\")\n\n else:\n pass",
"def direct_damage(self, pokemon, damage):\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n pokemon.hp -= damage\n if pokemon.hp <= 0:\n self.faint(pokemon, Cause.DIRECT)",
"def takeHit(self, amount, type, enemyShip):\n if type == 'energy':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount\n amount = 0\n else:\n amount -= self.currentSP\n self.currentSP = 0\n # go through armor next\n if self.currentAP > 0 and amount > 0:\n # set experience only if shot goes through shields\n if self.typeAP == 'energy':\n if self.currentAP >= (amount * globals.reflectiveArmorModifier):\n self.currentAP -= (amount * globals.reflectiveArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.reflectiveArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n elif type == 'impact':\n # go through shields in quadrant first\n if self.currentSP > 0:\n if self.currentSP >= amount:\n self.currentSP -= amount/2\n amount = amount/2\n else:\n amount -= self.currentSP\n self.currentSP = 0\n \n # now goto armor\n if self.currentAP > 0 and amount > 0:\n if self.typeAP == 'impact':\n if self.currentAP >= (amount * globals.impactArmorModifier):\n self.currentAP -= (amount * globals.impactArmorModifier)\n amount = 0\n else:\n amount -= (self.currentAP/globals.impactArmorModifier)\n self.currentAP = 0\n else:\n if self.currentAP >= amount:\n self.currentAP -= amount\n amount = 0\n else:\n amount -= self.currentAP\n self.currentAP = 0\n \n # now that shields and armor are taken care of transfer remaining damage to internal components\n self.myParent.setExperience(amount, enemyShip)\n componentDamage = 0\n if amount > 0 and self.components != {}:\n while amount > 0:\n keyList = funcs.sortStringList(self.components.keys())\n componentDamage = 1\n for componentID in keyList:\n component = self.components[componentID]\n if component.currentHP > amount:\n component.currentHP -= amount\n amount = 0\n break\n elif component.currentHP > 0:\n # remove component\n amount -= component.currentHP\n del self.components[componentID]\n \n # check if all components destroyed, or damage absorbed\n if self.components == {} or amount == 0:\n break\n \n if componentDamage == 1:\n self.setMyStatus()\n self.myParent.setMyStatus()\n \n if amount > 0:\n if self.myParent.currentISP > amount:\n self.myParent.currentISP -= amount\n self.myParent.setMyStatus()\n amount = 0\n else:\n self.myParent.destroyMe()\n amount = 0\n \n self.myParent.updateAllGUIValues()",
"def getDefense(self):\n\t\treturn(self.maneuverability * self.protection)",
"def attack(self):\n return random.randint(self.max_damage//2, self.max_damage)",
"def take_damage(self, dmg):\n self._ensure_is_alive()\n\n self._hit_points -= dmg\n\n if self.hit_points <= 0:\n self._hit_points = 0",
"def attack(self, victim):\n assert victim.is_alive, \"Cannot attack, victim is already dead\"\n # if attacker is stronger than victim, the victim's health is reduced by (0, 15)\n if victim.strength < self.strength:\n victim.health -= random.randint(0, 15)\n logging.debug(\"{0} is stronger\".format(self.name))\n else: # otherwise, reduce by only (0, 5)\n victim.health -= random.randint(0, 5)\n logging.debug(\"{0} is stronger\".format(victim.name))\n print(self.name, \"attacks\", victim.name)\n victim.show_health()\n\n # if the victim dies, transfer their loot to attacker and set them to dead\n if victim.health < 0:\n self.loot += victim.loot\n victim.loot = 0",
"def action_normal(self):\n obs = self.observation\n shoot = False\n eb = self.__class__.enemy_base\n \n ammopacks = filter(lambda x: x[2] == \"Ammo\", obs.objects)\n if ammopacks:\n self.updateAllAmmoSpots(ammopacks)\n # Walk to ammo\n if obs.ammo < SUFFICIENT_AMMO:\n self.goal = self.getClosestLocation(ammopacks)\n self.motivation = MOTIVATION_AMMO\n self.debugMsg(\"*> Recharge (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''if (obs.ammo > 0 and obs.foes):\n self.goal = self.getClosestLocation(obs.foes)\n self.debugMsg(\"*> Go to enemy (%d,%d)\" % self.goal)\n # If the enemy is within range, shoot.\n if(point_dist(self.goal, obs.loc) < self.settings.max_range\n and not line_intersects_grid(obs.loc, self.goal, self.grid, self.settings.tilesize)):\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #if self.goal not in obs.friends:\n self.motivation = MOTIVATION_SHOOT_TARGET\n shoot = True'''\n \n # Attack strategy 1\n #########################\n # 1) Shoot live enemies #\n #########################\n # Aim at the closest enemy outside the enemy base\n if obs.ammo > 0 and obs.foes:\n living = filter(lambda x: point_dist(x[0:2], eb) > ENEMY_BASE_RANGE, obs.foes)\n self.debugMsg(\"Living: %s\" % (living,))\n if living:\n self.debugMsg(1)\n self.goal = min(living, key=lambda x: point_dist(obs.loc, x[0:2]))[0:2]\n self.motivation = MOTIVATION_SHOOT_TARGET\n self.debugMsg(2)\n # Check if enemy in fire range\n if (\n point_dist(self.goal, obs.loc) < self.settings.max_range and\n not line_intersects_grid(\n obs.loc, \n self.goal, \n self.grid, \n self.settings.tilesize\n )\n ):\n self.debugMsg(3)\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #return self.getActionTriple(True,None,0) ###?? SHOULD WE STOP MOVING WHEN WE SHOOT?\n return self.getActionTriple(True)\n else:\n self.debugMsg(4)\n return self.getActionTriple()\n self.debugMsg(5)\n \n # Walk to an enemy CP\n if self.goal is None and len(self.friendlyCPs) < 2:\n self.goal = self.getClosestLocation(self.getQuietEnemyCPs())\n if self.goal:\n self.debugMsg(\"Crowded location: %d\" % self.getCrowdedValue(self.goal))\n self.motivation = MOTIVATION_CAPTURE_CP\n self.debugMsg(\"*> Capture (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''# If you can't think of anything to do\n # at least walk to a friendly control point\n if self.goal is None:\n self.goal = self.getClosestLocation(self.getQuietRestlessFriendlyCPs())\n if self.goal:\n self.motivation = MOTIVATION_GUARD_CP\n self.debugMsg(\"*> Guard (%d,%d)\" % (self.goal[0],self.goal[1]))'''\n \n if self.goal is None:\n self.goal = max(\n self.__class__.ammoSpots,\n key=lambda x: point_dist(x, obs.loc),\n )\n self.debugMsg(\"Going to ammospot far away (%d, %d)\" % (self.goal[0],self.goal[1]))\n self.motivation = MOTIVATION_STAY_PUT\n \n\n if self.goal:\n return self.getActionTriple(shoot)\n else:\n return self.getActionTriple(shoot)",
"def take_damage(self, damage):\n list_operators_experience = [i.get_experience / 1000 for i in\n self.operators]\n damage -= 0.1 + sum(list_operators_experience)\n # 60% of damage will receive a vehicle\n self.set_health(self.get_health - damage * 0.6)\n # A random operator, who will receive 20% of damage.\n random_operator = random.randint(0, len(self.operators) - 1)\n j = 0\n while j < len(self.operators):\n if j == random_operator:\n self.operators[j].take_damage(damage * 0.2)\n else:\n self.operators[j].take_damage(damage * 0.1)\n j += 1",
"def passive(self,target):\r\n target.hp_increase(self.__hp_increase,buff_type = \"permanent\")",
"def damage(self):\n out = (self.blurbs[self.state][\"damage\"])\n self.next_state(\"damage\")\n return out",
"def __attackDamage(self, attack, suit=0):\n if suit:\n for dmg in attack[SUIT_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0\n else:\n for dmg in attack[TOON_HP_COL]:\n if (dmg > 0):\n return dmg\n return 0",
"def normal_defense(self):\n if self.game.get_my_mana() > DEFENSE_MANA_CAP:\n self.portals.dumb_castle_defense(DEFENSE_MANA_CAP)\n self.portals.dumb_portal_defense(PORTAL_SELF_DEFENSE_MANA_CAP)",
"def attack(self, target, bonusToAttackRoll=0):\n targetAC = target.AC\n attackRoll = self.roll()\n if attackRoll==1:\n # a natural 1 always miss\n return TH0_MISS_CRITICAL\n\n if self.character.stealth and not target.canSeeHiddenCharacter(self.character):\n surpriseAttack = True\n else:\n surpriseAttack = False\n\n if attackRoll==20:\n # a natural 20 always hit\n if surpriseAttack:\n return TH0_HIT_SURPRISE_CRITICAL\n return TH0_HIT_CRITICAL\n\n if surpriseAttack:\n bonusToAttackRoll+=4\n\n attackRoll = attackRoll + bonusToAttackRoll\n\n if attackRoll>=targetAC:\n if surpriseAttack:\n return TH0_SURPRISE_HIT\n return TH0_HIT\n \n return TH0_MISS",
"def damage(self, pokemon, damage, cause, source=None, attacker=None, drain_pct=None):\n if pokemon.is_fainted():\n if __debug__:\n log.w('Tried to damage fainted pokemon %s: cause: %s, source: %s, attacker: %s',\n pokemon, cause, source, attacker)\n return 0\n\n assert pokemon is not attacker\n assert pokemon.side.active_pokemon is pokemon\n assert pokemon.is_active\n assert damage >= 0\n assert ((isinstance(attacker, BattlePokemon) and isinstance(source, Move)) if\n cause is Cause.MOVE else True)\n\n if damage == 0:\n if __debug__: log.w('Battle.damage called with damage=0') # this shouldn't happen\n return 0\n\n if cause is Cause.WEATHER and pokemon.is_immune_to(source):\n if __debug__: log.i('Weather immunity: %s / %s', pokemon, source)\n return 0\n\n if damage < 1:\n damage = 1 # always do at least 1 damage\n else:\n damage = int(damage)\n\n damage = pokemon.accumulate_effect('on_damage',\n pokemon, cause, source, self, damage, failfast=True)\n if damage is FAIL:\n return FAIL\n\n pokemon.hp -= damage\n if __debug__: log.i('%s took %s (%.1f%%) damage from %s: %s; hp=%d/%d' %\n (pokemon, damage, 100*float(damage)/pokemon.max_hp, cause, source,\n pokemon.hp, pokemon.max_hp))\n if pokemon.hp <= 0:\n damage += pokemon.hp\n\n if drain_pct and not attacker.is_fainted():\n self.heal(attacker, int(math.ceil(damage * drain_pct / 100.0)), cause=Cause.DRAIN,\n foe=pokemon)\n\n if cause is Cause.MOVE:\n pokemon.activate_effect('on_after_move_damage', self, pokemon, damage, source, attacker)\n\n if pokemon.hp <= 0:\n self.faint(pokemon, cause, source, attacker)\n\n return damage",
"def get_damage(self, amount: float) -> None:\n self.health = self.health - amount * self.DMG_TO_VEHICLE\n rnd_operator = random.choice(self.__operators)\n rnd_operator.get_damage(amount * self.DMG_TO_ONE_OPER)\n for operator in self.__operators:\n if operator != rnd_operator:\n operator.get_damage(amount * self.DMG_TO_OPER)\n self.estimate_total_health()\n self.check_is_alive()",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between\n # half of max_damage and max_damage\n print(\"max damage of \" + self.name + \" is \")\n print(str(self.attack_strength))\n min_damage = self.attack_strength // 2\n weapon_attack_value = random.randint(min_damage, self.attack_strength)\n return weapon_attack_value",
"def attack(self):\n\n if not self.attacking:\n self.attacking = True",
"def attack_bonus_on_level(self, level):\n raise NotImplementedError",
"def apply_ex(player: Player) -> None:\n getattr(combat_effects, \"inflict_ex_\" + player.character_class)",
"def attack(self):\n # TODO: Use integer division to find half of the max_damage value\n # then return a random integer between half of max_damage and max_damage\n \n weapon_attack_value = random.randint(self.max_damage//2, self.max_damage)\n return weapon_attack_value",
"def counter_attack(self, other):\n other.take_damage(self.damage/2)",
"def applyDamage(state, damage) :\n newState = copy.deepcopy(state)\n # If the enemy does not have HP information, returns the same state\n if 'hp' not in state['enemy'] :\n return newState\n # Reduces HP by damage, min HP being 0\n newState['enemy']['hp'] = max(newState['enemy']['hp'] - damage, 0)\n return newState",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n attacker_fx = await self.get_user_effects(attacker)\n\n if 'knocked_out' in attacker_fx:\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_sloth_profile = await self.get_sloth_profile(target.id)\n if not target_sloth_profile:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_sloth_profile[1] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n target_fx = await self.get_user_effects(target)\n\n if 'protected' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if 'hacked' in target_fx:\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n if ctx.invoked_with == 'mirror':\n mirrored_skill = await self.get_skill_action_by_user_id_and_skill_type(user_id=attacker.id, skill_type='mirror')\n if not mirrored_skill:\n return await ctx.send(f\"**Something went wrong with this, {attacker.mention}!**\")\n else:\n _, exists = await Player.skill_on_cooldown(skill=Skill.ONE).predicate(ctx)\n\n try:\n current_timestamp = await utils.get_timestamp()\n # Don't need to store it, since it is forever\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n if ctx.invoked_with != 'mirror':\n if exists:\n await self.update_user_skill_ts(attacker.id, Skill.ONE, current_timestamp)\n else:\n await self.insert_user_skill_cooldown(attacker.id, Skill.ONE, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")\n else:\n if 'reflect' in target_fx:\n await self.reflect_attack(ctx, attacker, target, 'hack')",
"def attack(self):\n total_amnt_attack = 0\n for new_attack in self.abilities:\n total_amnt_attack += new_attack.attack()\n return total_amnt_attack",
"def turn_effects(self):\n if self.side_effects[\"shield\"] > 0:\n self.side_effects[\"shield\"] -= 1",
"def test_get_damage_out_of_limit(self):\n self.veh.health = 0.24\n for op in self.veh.operators:\n op.health = 0.1\n self.veh.get_damage(0.5)\n self.assertEqual(self.veh.health, 0)\n self.assertEqual(self.veh.operators[0].health, 0.05)\n self.assertEqual(self.veh.operators[1].health, 0.05)",
"def active(self,target):\r\n if target.current_hp == target.hp:\r\n raise ItemError(\"Cannot consume if health is at maximum!\")\r\n\r\n target.hp_increase(self.__hp_increase)",
"def can_throw(life):\n\treturn can_hold_item(life)",
"def attack(self, *args, **kwargs):\n return self(AbilityId.ATTACK, *args, **kwargs)",
"def attack(self, other):\n if other is not self:\n other.take_damage(self.damage)\n other.counter_attack(self)",
"def take_damage(self, damage_amt):\n\n self.health -= damage_amt\n if self.health <= 0:\n self.deaths += 1",
"def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum",
"def dealdamage(self, pokemon, movedata):\n mod = getmodifier(movedata['type'].lower(), pokemon.types)\n if movedata['category'].lower() == 'physical':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['ATK']/pokemon.currentStats['DEF'])/50+2)*mod\n if movedata['category'].lower() == 'special':\n damage = (((2*self.level/5+2)*movedata['power']*self.currentStats['SPATK']/pokemon.currentStats['SPDEF'])/50+2)*mod\n print(f\"HP: {pokemon.currentStats['HP']}, Damage: {damage}\")\n pokemon.takedamage(damage)\n if mod == 0:\n return [0, damage]\n if mod == 0.25:\n return [1, damage]\n if mod == 0.5:\n return [2, damage]\n if mod == 1:\n return [3, damage]\n if mod == 2:\n return [4, damage]\n if mod == 4:\n return [5, damage]",
"def updateCurrentBehavior(self, gameState, action):\n self.behavior = \"attack\"",
"def take_damage(self, damage):\n damage /= len(self.__units)\n for i in self.__units:\n i.take_damage(damage)",
"def __applyToonAttackDamages(self, toonId, hpbonus=0, kbbonus=0):\n # now be sure to adjust the damage to the suit, but only\n # if the track of the attack is not 0, meaning it is not\n # a heal, if it's a heal, then the damage is applied as\n # a plus to the target's health and we don't handle adjusting\n # toon health here (additionally attack 1 is a trap attacks,\n # doesn't cause damage directly but only in conjunction with a\n # lure attack)\n totalDamages = 0\n if not self.APPLY_HEALTH_ADJUSTMENTS:\n return totalDamages\n assert(self.battle.toonAttacks.has_key(toonId))\n attack = self.battle.toonAttacks[toonId]\n track = self.__getActualTrack(attack)\n if (track != NO_ATTACK and track != SOS and\n track != TRAP and track != NPCSOS):\n # first create a list of targets based on group or\n # single target designation for this particular attack\n targets = self.__getToonTargets(attack)\n for position in range(len(targets)):\n if hpbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_HPBONUS_COL]\n else:\n damageDone = 0\n elif kbbonus:\n # handle applying the hp-bonus if this target\n # was actually hit by this attack\n if targets[position] in \\\n self.__createToonTargetList(toonId):\n damageDone = attack[TOON_KBBONUS_COL][position]\n else:\n damageDone = 0\n else:\n assert(position < len(attack[TOON_HP_COL]))\n damageDone = attack[TOON_HP_COL][position]\n if damageDone <= 0 or self.immortalSuits:\n # suit at this position was not hit\n continue\n if (track == HEAL or track == PETSOS):\n # target of toon attack was another toon, we\n # don't want to apply any damage yet\n currTarget = targets[position]\n assert(self.toonHPAdjusts.has_key(currTarget))\n if self.CAP_HEALS:\n # make sure to bound the toon's health to its\n # max health\n toonHp = self.__getToonHp(currTarget)\n toonMaxHp = self.__getToonMaxHp(currTarget)\n if toonHp + damageDone > toonMaxHp:\n damageDone = toonMaxHp - toonHp\n attack[TOON_HP_COL][position] = damageDone\n self.toonHPAdjusts[currTarget] += damageDone\n totalDamages = totalDamages + damageDone\n continue\n\n # we should only get here if the target is a suit and\n # at least 1hp of damage was done\n currTarget = targets[position]\n assert isinstance(currTarget,\n DistributedSuitBaseAI.DistributedSuitBaseAI), \\\n targets\n currTarget.setHP(currTarget.getHP() - damageDone)\n targetId = currTarget.getDoId()\n if self.notify.getDebug():\n if hpbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from HP-Bonus\")\n elif kbbonus:\n self.notify.debug(str(targetId) +\n \": suit takes \" +\n str(damageDone) +\n \" damage from KB-Bonus\")\n else:\n self.notify.debug(str(targetId) + \": suit takes \" +\n str(damageDone) + \" damage\")\n totalDamages = totalDamages + damageDone\n\n # if the suit died from this or a previous\n # attack, make sure to set the 'died' field for\n # the target to 1, indicating to the higher-ups\n # that this suit has died\n if currTarget.getHP() <= 0:\n if currTarget.getSkeleRevives() >= 1:\n currTarget.useSkeleRevive()\n attack[SUIT_REVIVE_COL] = \\\n attack[SUIT_REVIVE_COL] | (1 << position)\n else:\n self.suitLeftBattle(targetId)\n attack[SUIT_DIED_COL] = \\\n attack[SUIT_DIED_COL] | (1 << position)\n if self.notify.getDebug():\n self.notify.debug(\"Suit\" + str(targetId) +\n \"bravely expired in combat\")\n\n return totalDamages",
"def take_damage(self, value, type_=None):\n if type_ in self.resistances:\n taken = math.floor(value / 2)\n # TODO (phillip): event log should show that damage was reduced\n elif type_ in self.vulnerabilities:\n taken = value * 2\n else:\n taken = value\n\n # Only used to return at the end\n actual_taken = min(self.hp, taken)\n\n self.hp -= taken\n if self.hp < -self.max_hp:\n # TODO (phillip): Implement creature death\n pass\n\n self.hp = max(0, self.hp)\n return actual_taken",
"def test_get_damage_out_of_limit(self):\n self.sold.health = 0.2\n self.sold.get_damage(0.32)\n self.assertEqual(self.sold.health, 0)",
"def spell_attack(self, caster, spell_name, targets, cost, **kwargs):\n spell_msg = \"%s casts %s!\" % (caster, spell_name)\n\n atkname_single = \"The spell\"\n atkname_plural = \"spells\"\n min_damage = 10\n max_damage = 20\n accuracy = 0\n attack_count = 1\n\n # Retrieve some variables from kwargs, if present\n if \"attack_name\" in kwargs:\n atkname_single = kwargs[\"attack_name\"][0]\n atkname_plural = kwargs[\"attack_name\"][1]\n if \"damage_range\" in kwargs:\n min_damage = kwargs[\"damage_range\"][0]\n max_damage = kwargs[\"damage_range\"][1]\n if \"accuracy\" in kwargs:\n accuracy = kwargs[\"accuracy\"]\n if \"attack_count\" in kwargs:\n attack_count = kwargs[\"attack_count\"]\n\n to_attack = []\n # If there are more attacks than targets given, attack first target multiple times\n if len(targets) < attack_count:\n to_attack = to_attack + targets\n extra_attacks = attack_count - len(targets)\n for n in range(extra_attacks):\n to_attack.insert(0, targets[0])\n else:\n to_attack = to_attack + targets\n\n # Set up dictionaries to track number of hits and total damage\n total_hits = {}\n total_damage = {}\n for fighter in targets:\n total_hits.update({fighter: 0})\n total_damage.update({fighter: 0})\n\n # Resolve attack for each target\n for fighter in to_attack:\n attack_value = randint(1, 100) + accuracy # Spell attack roll\n defense_value = self.get_defense(caster, fighter)\n if attack_value >= defense_value:\n spell_dmg = randint(min_damage, max_damage) # Get spell damage\n total_hits[fighter] += 1\n total_damage[fighter] += spell_dmg\n\n for fighter in targets:\n # Construct combat message\n if total_hits[fighter] == 0:\n spell_msg += \" The spell misses %s!\" % fighter\n elif total_hits[fighter] > 0:\n attack_count_str = atkname_single + \" hits\"\n if total_hits[fighter] > 1:\n attack_count_str = \"%i %s hit\" % (total_hits[fighter], atkname_plural)\n spell_msg += \" %s %s for %i damage!\" % (\n attack_count_str,\n fighter,\n total_damage[fighter],\n )\n\n caster.db.mp -= cost # Deduct MP cost\n\n caster.location.msg_contents(spell_msg) # Message the room with spell results\n\n for fighter in targets:\n # Apply damage\n self.apply_damage(fighter, total_damage[fighter])\n # If fighter HP is reduced to 0 or less, call at_defeat.\n if fighter.db.hp <= 0:\n self.at_defeat(fighter)\n\n if self.is_in_combat(caster): # Spend action if in combat\n self.spend_action(caster, 1, action_name=\"cast\")",
"def is_attack(self):\n\n return self.purpose == 'attack'",
"def apply_skill_effects(self, behavior):\n b_type = type(behavior)\n if issubclass(b_type, ESAttackUp):\n if b_type == ESAttackUPRemainingEnemies \\\n and behavior.enemy_count is not None \\\n and self.enemies > behavior.enemy_count:\n return False\n if self.enraged is None:\n if b_type == ESAttackUPCooldown and behavior.turn_cooldown is not None:\n self.enraged = -behavior.turn_cooldown + 1\n return False\n else:\n self.enraged = behavior.turns\n return True\n else:\n if self.enraged == 0:\n self.enraged = behavior.turns\n return True\n else:\n return False\n elif b_type == ESDamageShield:\n if self.damage_shield == 0:\n self.damage_shield = behavior.turns\n return True\n else:\n return False\n elif b_type == ESStatusShield:\n if self.status_shield == 0:\n self.status_shield = behavior.turns\n return True\n else:\n return False\n return True",
"def get_attack_damage(self, by: str):\n if by == 'spell':\n if self.spells:\n # get the spell with the maximum damage that we have enough mana for\n available_spells = [spell for spell in self.spells if self._mana >= spell.mana_cost]\n if not available_spells:\n return None\n\n spell = max(available_spells, key= lambda spell: spell.damage) # type: Spell\n if spell:\n return spell\n else:\n print('{} does not know any spells.'.format(self.name))\n return None\n else:\n return self.weapon.damage",
"def attack(self, enemies):\n return super().attack(enemies, self.range, self.in_range, self.damage, 16)",
"def _reward(self, action):\n raise NotImplementedError",
"def attack(self, enemy):\r\n best_weapon = None\r\n max_damage = 0\r\n # Searches your inventory for your highest damaging weapon\r\n for i in self._inventory:\r\n if isinstance(i, items.Weapon):\r\n if i._damage > max_damage:\r\n best_weapon = i\r\n max_damage = i._damage\r\n\r\n print(\"You use {} against {}!\".format(best_weapon._name, enemy._name))\r\n enemy._health_points -= best_weapon._damage\r\n if not enemy.is_alive():\r\n print(\"You've killed {}!\".format(enemy._name))\r\n\r\n else:\r\n print(\"The {} isn't dead yet. It has {} health remaining. Keep fighting!\".format(enemy._name, enemy._health_points))",
"async def hack(self, ctx, target: discord.Member = None) -> None:\n\n attacker = ctx.author\n\n if ctx.channel.id != bots_and_commands_channel_id:\n return await ctx.send(f\"**{attacker.mention}, you can only use this command in {self.bots_txt.mention}!**\")\n\n if await self.is_user_knocked_out(attacker.id):\n return await ctx.send(f\"**{attacker.mention}, you can't use your skill, because you are knocked-out!**\")\n\n if not target:\n return await ctx.send(f\"**Please, inform a target member, {attacker.mention}!**\")\n\n if attacker.id == target.id:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack yourself!**\")\n\n if target.bot:\n return await ctx.send(f\"**{attacker.mention}, you cannot hack a bot!**\")\n\n target_currency = await self.get_user_currency(target.id)\n if not target_currency:\n return await ctx.send(f\"**You cannot hack someone who doesn't have an account, {attacker.mention}!**\")\n\n if target_currency[7] == 'default':\n return await ctx.send(f\"**You cannot hack someone who has a `default` Sloth class, {attacker.mention}!**\")\n\n if await self.is_user_protected(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is protected, you can't hack them!**\")\n\n if await self.is_user_hacked(target.id):\n return await ctx.send(f\"**{attacker.mention}, {target.mention} is already hacked!**\")\n\n confirmed = await ConfirmSkill(f\"**{attacker.mention}, are you sure you want to hack {target.mention}?**\").prompt(ctx)\n if not confirmed:\n return await ctx.send(\"**Not hacking them, then!**\")\n\n await self.check_cooldown(user_id=attacker.id, skill_number=1)\n\n try:\n current_timestamp = await self.get_timestamp()\n # Don't need to store it, since it is forever\n await self.update_user_is_hacked(target.id, 1)\n await self.insert_skill_action(\n user_id=attacker.id, skill_type=\"hack\", skill_timestamp=current_timestamp,\n target_id=target.id, channel_id=ctx.channel.id\n )\n await self.update_user_action_skill_ts(attacker.id, current_timestamp)\n # Updates user's skills used counter\n await self.update_user_skills_used(user_id=attacker.id)\n hack_embed = await self.get_hack_embed(\n channel=ctx.channel, perpetrator_id=attacker.id, target_id=target.id)\n msg = await ctx.send(embed=hack_embed)\n except Exception as e:\n print(e)\n return await ctx.send(f\"**Something went wrong and your `Hack` skill failed, {attacker.mention}!**\")"
] | [
"0.81057763",
"0.7999557",
"0.79067296",
"0.7736732",
"0.7559663",
"0.75042886",
"0.73485667",
"0.69856614",
"0.6954562",
"0.68673724",
"0.6778077",
"0.67357415",
"0.66850173",
"0.6644636",
"0.6638605",
"0.662029",
"0.6539297",
"0.65386426",
"0.65321666",
"0.65184796",
"0.65008146",
"0.6496057",
"0.6479794",
"0.6462085",
"0.6440297",
"0.64162344",
"0.6388051",
"0.63838446",
"0.6383606",
"0.6367558",
"0.6367558",
"0.6353072",
"0.63491184",
"0.6341149",
"0.62979174",
"0.6283066",
"0.6280401",
"0.62739074",
"0.62733066",
"0.6268356",
"0.62564576",
"0.6244335",
"0.6229594",
"0.62261",
"0.62221265",
"0.62062085",
"0.6198498",
"0.61962956",
"0.61946404",
"0.61925095",
"0.61889863",
"0.6186729",
"0.6184047",
"0.61670655",
"0.61589444",
"0.6141316",
"0.6126803",
"0.61222",
"0.6118753",
"0.61061203",
"0.6103459",
"0.610009",
"0.60851514",
"0.6067181",
"0.606224",
"0.60566694",
"0.6040522",
"0.603953",
"0.60370547",
"0.6027466",
"0.6021367",
"0.60086644",
"0.5995696",
"0.5967911",
"0.5965284",
"0.59649885",
"0.5960138",
"0.5958327",
"0.59544295",
"0.59489006",
"0.5947135",
"0.5946535",
"0.5945641",
"0.59453267",
"0.5928747",
"0.5886637",
"0.58859384",
"0.5885854",
"0.5880612",
"0.5880575",
"0.5875484",
"0.58734626",
"0.5869462",
"0.58632183",
"0.5851432",
"0.5850708",
"0.5847332",
"0.5831628",
"0.58238983",
"0.58220804"
] | 0.7960427 | 2 |
Returns distance matrix for the texts | def tfIdf(texts):
vect = TfidfVectorizer(min_df=1)
tfidf = vect.fit_transform([tt.lower() for tt in texts])
aa=(tfidf * tfidf.T).A
return aa | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __build_distance_matrix(self):\n for i in range(0, len(self.__corpus)):\n doc_i = self.__corpus[i]\n for j in range(i + 1, len(self.__corpus)):\n doc_j = self.__corpus[j]\n distance = doc_i.calc_distance(doc_j)\n self.__distance_matrix.append(distance)",
"def cal_distances(embeddings):\n # calculate\n dist = np.zeros([len(embeddings), len(embeddings)], dtype=float)\n for ii in xrange(len(embeddings)):\n for jj in xrange(ii + 1, len(embeddings)):\n dist[ii, jj] = np.linalg.norm(embeddings[ii] - embeddings[jj])\n dist[jj, ii] = dist[ii, jj] \n \n # return\n return dist",
"def calc_dist_matrix(self):\n\n self.dist_matrix = spatial.distance.squareform(spatial.distance.pdist(self.data_vector,metric=\"hamming\"))\n\n self.dist_frame = pd.DataFrame(self.dist_matrix,\n index = self.seq_strings,\n columns = self.seq_strings)",
"def distance_matrix (sim,polymer_text,teq,tsample,threshold=2.5) :\n u = sim.u\n polymer = u.select_atoms (polymer_text)\n N = polymer.n_atoms\n nslice = mbt.traj_nslice (u,teq,tsample)\n d = np.zeros((N,N))\n for i,ts in enumerate(u.trajectory[teq::tsample]) :\n this_d = distance_array(polymer.positions,\n polymer.positions,\n box=ts.dimensions)\n d = mbt.new_average(i,d,this_d)\n return d",
"def format_distance_matrix(labels, data):\r\n return format_matrix(data, labels, labels)",
"def get_alphabet_similarity_matrix(self):\n distance_matrix = numpy.zeros((len(self.alphabet), len(self.alphabet)))\n numpy.fill_diagonal(distance_matrix, 0)\n for index_one, descriptor_one in enumerate(self.descriptors):\n for index_two, descriptor_two in enumerate(self.descriptors):\n distance = descriptor_one - descriptor_two\n squared_distance = numpy.dot(distance, distance)\n distance_matrix[index_one, index_two] = squared_distance\n distance_matrix /= 2. * (self.sigma_amino_acid ** 2)\n return numpy.exp(-distance_matrix)",
"def get_distance_matrix(self):\n names = self.get_named_leaves()\n num_names = len(names)\n dist_mat = np.zeros((num_names, num_names), dtype='float')\n for i, j in itertools.combinations(range(num_names), 2):\n node1, node2 = self.node_names[names[i]], self.node_names[names[j]]\n dist = self.node_distance(node1, node2)\n dist_mat[i,j] = dist\n dist_mat[j,i] = dist\n return names, dist_mat",
"def _distance_matrix(self):\n\n # Log the type of metric being used in Sequencing\n logger.info('Using {} Distance'.format(self.measure))\n\n # Convert the nodal coordinate tuples to a np.array\n coords = np.vstack(map(np.array, self.coords.values()))\n \n if self.measure == 'haversine':\n # Partially applied haversine function that takes a coord and computes the vector distances for all coords\n haversine = lambda coord: get_hav_distance(coords[:, 0], coords[:, 1], *coord) \n # Map the partially applied function over all coordinates, and stack to a matrix\n return np.vstack(map(haversine, coords))\n\n # Partially applied haversine function that takes a coord and computes the vector distances for all coords\n euclidean = lambda coord: get_euclidean_dist(coords, coord)\n # Map the partially applied function over all coordinates, and stack to a matrix\n return np.vstack(map(euclidean, coords))",
"def get_distances(self):\n N = len(self.cells) # Number of cells\n distances = np.zeros([N, N]) # distances between cells\n positions = self.position_matrix() # positions of cells \n \n # get distances between cells (exploit symmetry between upper and lower triangular form)\n for i, position in enumerate(positions[:-1, :]): # Iterate matrix except the last one\n directions = positions[i+1:, :] - position # direction from i to j > i\n distances[i, i+1:] = np.linalg.norm(directions, axis=1) # length of directions\n \n return distances + distances.T # Add lower triangle of matrix to upper ",
"def get_semantic_dist_matrix(target_words: List[str],\n word2onehot: Dict[str, int], \n matrices: Matrices\n ) -> np.ndarray:\n n = len(target_words)\n distance_matrix = np.zeros(shape=(n, n))\n for i in range(n):\n for j in range(i, n):\n vec1 = matrices.embedding[word2onehot[target_words[i]]]\n vec2 = matrices.embedding[word2onehot[target_words[j]]]\n distance = cosine_sim(\n vec1, vec2\n )\n distance_matrix[i][j] = distance\n distance_matrix[j][i] = distance\n return distance_matrix",
"def text_to_matrix(text):\n matrix = []\n for i in range(0, 8, 2):\n matrix.append([int(text[i] + text[i+1], 16), int(text[i+8] + text[i+9], 16),\n int(text[i+16] + text[i+17], 16), int(text[i+24] + text[i+25], 16)])\n return matrix",
"def build_distance_matrix(path_to_embeddings):\n\n embed_df = pd.read_csv(path_to_embeddings)\n print (\"length is: \", len(embed_df))\n columns = list(embed_df)\n\n \n distances = euclidean_distances(embed_df.iloc[:, 1:], embed_df.iloc[:, 1:])\n embed_df = embed_df.set_index([columns[0]])\n # format distance matrix\n distances_df = pd.DataFrame(distances)\n distances_df.columns = list(embed_df.index)\n distances_df.index = list(embed_df.index)\n\n print (\"finished building the distance matrix ...\")\n\n print (\"///////////////////\")\n print (len(distances_df))\n\n return distances_df",
"def sentence_distance(sentence_a, sentence_b):\n \n sent_a = np.sum([projections[word_ids.get(word, 0)] \n if word in word_ids else [0] \n for word in sentence_a+bigrams(sentence_a)+trigrams(sentence_a)], axis=0)\n sent_b = np.sum([projections[word_ids.get(word, 0)] \n if word in word_ids else [0] \n for word in sentence_b+bigrams(sentence_b)+trigrams(sentence_b)], axis=0)\n \n \n return float(cosine(sent_a, sent_b))",
"def distances(self):",
"def distance_matrix(self, x, y, keyboard_weight=None):\r\n # create distance matrix\r\n size_x = len(x) + 1\r\n size_y = len(y) + 1\r\n dist_matrix = np.zeros((size_x, size_y))\r\n for i in range(size_x):\r\n dist_matrix[i, 0] = i\r\n for j in range(size_y):\r\n dist_matrix[0, j] = j\r\n\r\n ## fill distance matrix\r\n # no keyboard weight\r\n if not keyboard_weight:\r\n for i in range(1, size_x):\r\n for j in range(1, size_y):\r\n # if letters are same\r\n if x[i-1] == y[j-1]:\r\n dist_matrix[i, j] = dist_matrix[i-1, j-1]\r\n # if letters are different\r\n else:\r\n subs = dist_matrix[i-1, j-1] + 1\r\n delete = dist_matrix[i-1, j] + 1\r\n insert = dist_matrix[i, j-1] + 1 \r\n dist_matrix[i, j] = min(subs, delete, insert)\r\n # manhattan keyboard weight\r\n elif keyboard_weight == \"manhattan\":\r\n for i in range(1, size_x):\r\n for j in range(1, size_y):\r\n # if letters are same\r\n if x[i-1] == y[j-1]:\r\n dist_matrix[i, j] = dist_matrix[i-1, j-1]\r\n # if letters are different\r\n else:\r\n dist = self.key_distance(x[i-1], y[j-1], keyboard_weight)\r\n subs_weight = dist * self.manhattan_coef\r\n subs = dist_matrix[i-1, j-1] + subs_weight\r\n delete = dist_matrix[i-1, j] + 1\r\n insert = dist_matrix[i, j-1] + 1 \r\n dist_matrix[i, j] = min(subs, delete, insert)\r\n # euclidean keyboard weight\r\n elif keyboard_weight == \"euclidean\":\r\n for i in range(1, size_x):\r\n for j in range(1, size_y):\r\n # if letters are same\r\n if x[i-1] == y[j-1]:\r\n dist_matrix[i, j] = dist_matrix[i-1, j-1]\r\n # if letters are different\r\n else:\r\n dist = self.key_distance(x[i-1], y[j-1], keyboard_weight)\r\n subs_weight = dist * self.euclidean_coef\r\n subs = dist_matrix[i-1, j-1] + subs_weight\r\n delete = dist_matrix[i-1, j] + 1\r\n insert = dist_matrix[i, j-1] + 1 \r\n dist_matrix[i, j] = min(subs, delete, insert)\r\n \r\n return dist_matrix",
"def getDistanceMatrix(self):\n v = self.getVectors()\n vLis = v.keys()\n N = len(v.keys())\n D = np.zeros([N, N], dtype=np.float32)\n print(N)\n for i in range(N):\n print(\"%d/%d\" %(i, N))\n D[i, i] = 1\n for j in range(i + 1, N):\n dist = self.cosin_sim_pairs(v[vLis[i]], v[vLis[j]])\n D[i, j] = dist\n D[j, i] = dist\n return D",
"def calculate_dist_mat(embeddings: np.ndarray, norm: int) -> np.ndarray:\n kwargs = {'p': norm}\n condensed_dist = pdist(embeddings, metric='minkowski', **kwargs)\n dist_mat = squareform(condensed_dist)\n return dist_mat",
"def distance_matrix(sequences, substitution_mat):\n distance_mat = numpy.empty((len(sequences), len(sequences)), dtype='float')\n\n print(\"Building distance matrix\")\n # Get similarity score\n for i, seqA in enumerate(sequences):\n sys.stdout.write(\"\\r%.f%%\" % (float(i+1)/len(sequences)*100))\n sys.stdout.flush()\n for j, seqB in enumerate(sequences[i:], start=i):\n score = substitution_score(substitution_mat, seqA, seqB)\n distance_mat[i, j] = score\n distance_mat[j, i] = score\n print(\"\")\n # Set equal the diagonal\n diag_mini = numpy.min(distance_mat.diagonal())\n for i in range(len(sequences)):\n distance_mat[i, i] = diag_mini\n # Convert similarity score into a distance\n mini = numpy.min(distance_mat)\n maxi = numpy.max(distance_mat)\n return 1 - (distance_mat + abs(mini))/(maxi - mini)",
"def getDistanceMatrix(self, alignedSequences):\n\t\tif not alignedSequences:\n\t\t\traise ValueError(\"alignedSequences must not be empty\")\n\t\tdominantAlignedSequence = alignedSequences[0]\n\t\tsubdominantAlignedSequences = alignedSequences[1:]\n\t\tdistanceMatrix = []\n\t\tfor seq in subdominantAlignedSequences:\n\t\t\tdistanceMatrix.append(len(seq) - self._getNumberOfSpaces(seq) - self._getNumberOfAlignedNucleotides(dominantAlignedSequence, seq))\n\t\treturn distanceMatrix",
"def getDistanceMatrix(self):\n return self.distmat.as_matrix()",
"def calc_dist_matrix(self,verbose=False):\n\n print(\"Calculating distance matrix.\"); sys.stdout.flush()\n\n nrow = self.data_vector.shape[0]\n self.dist_matrix = np.zeros((nrow, nrow),dtype=float)\n for i in range(nrow):\n if verbose:\n if i % 1000 == 0:\n print(\"Row\",i,\"of\",nrow)\n sys.stdout.flush()\n\n for j in range(i + 1, nrow):\n self.dist_matrix[i,j] = self._pairwise_dist(self.data_vector[i],self.data_vector[j])\n self.dist_matrix[j,i] = self.dist_matrix[i,j]\n \n self.dist_frame = pd.DataFrame(self.dist_matrix,\n index = self.seq_strings,\n columns = self.seq_strings)",
"def nm_dist_mat(self):\n mat = np.zeros([self.N, self.M])\n for n in range(self.N):\n for m in range(self.M):\n mat[n, m] = distance(self.N_coords[n], self.M_coords[m])\n return mat",
"def distance_matrix(sunspots1, sunspots2):\n \n N1 = len(sunspots1)\n N2 = len(sunspots2)\n\n distance_matrix = np.zeros((N1, N2))\n\n for i in list(range(N1)):\n for j in list(range(N2)):\n\n distance_matrix[i, j] = euclidean_dist(sunspots1[i], sunspots2[j])\n\n return distance_matrix",
"def DistanceMatrices(self):\r\n return self._dms",
"def computeWordMatrix( Docs, Keywords ) :\n\n w2vec_count = CountVectorizer( ngram_range=(1, 4), vocabulary=Keywords )\n X_Count = w2vec_count.fit_transform( Docs )\n\n return X_Count",
"def text_to_matrix(fname, seed_sentiments):\n dependency_result = load_id_dependencies(config.data_path + fname + '_parsed.txt')\n seed_features = set()\n options = {}\n\n opinion_set, feature_set = run_double_propagation(\n dependency_result,\n seed_sentiments,\n seed_features,\n options)\n\n labeled_corpus = load_manual_reviews(config.data_path + fname + '_id.txt')\n \n true_features = get_features_from_reviews(labeled_corpus)\n true_opinions = get_opinions_from_reviews(labeled_corpus)\n\n all_features = set(feature_set.keys()) | set(true_features)\n all_opinions = set(opinion_set.keys()) | set(true_opinions)\n\n feature_idx = dict(zip(all_features , range(len(all_features))))\n opinion_idx = dict(zip(all_opinions, range(len(all_opinions))))\n \n rule_feature, rule_opinion = construct_rule_word_matrices(feature_set, opinion_set, feature_idx, opinion_idx)\n feature_label, opinion_label = construct_ground_truth_vector(true_features, true_opinions, feature_idx, opinion_idx)\n \n feature_x = rule_feature.transpose().todense()\n feature_y = feature_label\n opinion_x = rule_opinion.transpose().todense()\n opinion_y = opinion_label\n\n return feature_x, feature_y, opinion_x, opinion_y",
"def text_extractor(course_desc,query,doc_term_TF_matrix,terms,vectorizer):\n query = query.lower()\n query_vec = vectorizer.transform(pd.Series(query))\n sentences = sent_tokenize(course_desc)\n sentences_vec = [vectorizer.transform(pd.Series(sentence)) for sentence in sentences]\n\n tfidf_transformer = TfidfTransformer(smooth_idf=True, use_idf=True)\n tfidf_transformer.fit(doc_term_TF_matrix)\n\n tf_idf_desc = tfidf_transformer.transform(query_vec)\n tf_idf_sentences = [tfidf_transformer.transform(sentence) for sentence in sentences_vec]\n\n sim_array = np.zeros(len(sentences_vec)) # array of similarity scores\n\n array_1 = tf_idf_desc\n for i in range(len(sentences_vec)):\n array_2 = tf_idf_sentences[i]\n sim_array[i] = cosine_similarity(array_1, array_2)\n print(course_desc)\n print(\"Most:\",sentences[np.argmax(sim_array)])",
"def dist_matrix(self, group1, group2):\n \n tmps = []\n for i in group2:\n tmps.append([])\n for j in group1:\n mi, label = self.distance(i, j)\n tmps[-1].append(mi)\n return tmps",
"def distance(self, features, targets):\n cost_matrix = np.zeros((len(targets), len(features)))\n for i, target in enumerate(targets):\n cost_matrix[i, :] = self._metric(self.samples[target], features)\n return cost_matrix",
"def distance(self, features, targets):\n cost_matrix = np.zeros((len(targets), len(features)))\n for i, target in enumerate(targets):\n cost_matrix[i, :] = self._metric(self.samples[target], features)\n return cost_matrix",
"def _data_labels_distance(self, samples, tfidf_dict, distance_metric='cosine'):\n \n def distance_fn(x):\n return sklearn.metrics.pairwise.pairwise_distances(\n x, x[0], metric=distance_metric).ravel() * 100\n\n base_doc_vector = np.fromiter(tfidf_dict.values(),float)\n base_doc_keys = list(tfidf_dict.keys())\n vectors = [base_doc_vector]\n for sample in samples:\n sample_vector = np.zeros(len(base_doc_keys))\n for token in sample.split():\n token_index = base_doc_keys.index(token)\n sample_vector[token_index] = base_doc_vector[token_index]\n vectors.append(sample_vector)\n\n\n distances = distance_fn(sp.sparse.csr_matrix(vectors))\n return np.array(vectors), distances",
"def distance_matrix(dnas: Collection[str], metric=hamming_distance, relative=True, as_ndarray=False):\n n = len(dnas)\n result = [[0] * n for _ in range(n)]\n for pair in itertools.combinations(zip(range(n), dnas), r=2):\n (idx1, dna1), (idx2, dna2) = pair\n distance = metric(dna1, dna2)\n distance = distance / max(len(dna1), len(dna2)) if relative else distance\n result[idx1][idx2] = distance\n result[idx2][idx1] = distance\n if as_ndarray:\n result = np.asarray(result)\n return result",
"def sax_table_dist(self,other, alphabet):\n distance_matrix = np.array([[0],[0]])\n distance_matrix = alphabet.get_distance_matrix(other.cardinality)\n return distance_matrix[self.sax_character][other.sax_character]",
"def distance_matrix(data):\n D = numpy.zeros( (data.shape[0], data.shape[0]) )\n for i in xrange(data.shape[0]):\n for j in xrange(i):\n D[i,j] = numpy.linalg.norm(data[i,:]-data[j,:])\n D[j,i] = D[i,j]\n\n return D",
"def get_dist_mat(self):\n n_site = self.status.give(keyword=\"n_site\")\n sites = self.status.give(keyword=\"sites\")\n dist_mat = [[0.0 for j in xrange(n_site)] for i in xrange(n_site)]\n for i in xrange(n_site):\n for j in xrange(n_site):\n ri = sites[i].pos\n rj = sites[j].pos\n dist_mat[i][j] = np.linalg.norm(ri-rj)\n # print ri, rj\n return dist_mat",
"def word_similarity(self):\n y_true = []\n y_pred = []\n for i in open(\"data/word_sim_dataset.txt\").read().split('\\n'):\n i = self.preprocessor(i)\n w1 = i.split()[-1]\n w2 = i.split()[-2] \n st = float(i.split()[-3]) / 4 #dataset has scale from 0 to 4\n \n try:\n w1 = self.embeddings_index[w1] \n w2 = self.embeddings_index[w2] \n w1 = w1 / np.linalg.norm(w1)\n w2 = w2 / np.linalg.norm(w2)\n y_pred.append(np.dot(w1,w2))\n y_true.append(st)\n except:\n pass\n if y_true == []:\n return 1.0\n return mean_squared_error(y_true, y_pred, squared=False)",
"def _get_edit_distance_matrix(x: str, y: str) -> list:\n matrix = [[-1 for _ in range(len(y) + 1)] for _ in range(len(x) + 1)]\n\n for j in range(len(matrix[0])):\n matrix[0][j] = j\n\n for i, _ in enumerate(matrix):\n matrix[i][0] = i\n\n return matrix",
"def dist_matrix(self):\n return self.__dist_matrix",
"def get_dct_dtmatrix(nlp, sops):\n corpus = [sop.split() for sop in map(lambda x: preprocess(nlp, x), sops)]\n# phrases = Phrases(corpus, min_count = 1, threshold = 1)\n# bigram = Phraser(phrases)\n# corpus = bigram(corpus)\n dictionary = corpora.Dictionary(corpus)\n doc_term_matrix = [dictionary.doc2bow(doc) for doc in corpus]\n return doc_term_matrix, corpus, dictionary",
"def get_mismatch_matrix(k,m):\n words = get_words(k)\n N = len(words)\n\n mismatch_matrix = np.zeros((N, N))\n for i in range(N):\n for j in range(i, N):\n if Levenshtein.hamming(words[i], words[j]) <= m:\n mismatch_matrix[i,j] = 1/2\n mismatch_matrix[j,i] = 1/2\n\n return mismatch_matrix",
"def cosineDistanceMatrix():\n\n\tmatrix = movieMatrix()\n\tsimilarity = np.dot(matrix, matrix.T)\n\tsquareMag = np.diag(similarity)\n\tinvSquareMag = 1/squareMag\n\tinvSquareMag[np.isinf(invSquareMag)]=0\n\tinvMag = np.sqrt(invSquareMag)\n\tcosine = similarity * invMag\n\tcosine = cosine.T * invMag\n\treturn cosine",
"def test_compute_distance_matrix_from_metadata_int(self):\r\n exp_out = array(\r\n [[0, 0, 92, 9096, 9992, 9894, 18898, 18898, 18898], [0, 0, 92, 9096, 9992, 9894, 18898, 18898, 18898],\r\n [92, 92, 0, 9188, 10084, 9986, 18990, 18990, 18990], [9096,\r\n 9096, 9188, 0, 896, 798, 9802, 9802, 9802],\r\n [9992, 9992, 10084, 896, 0, 98, 8906, 8906, 8906], [9894,\r\n 9894, 9986, 798, 98, 0, 9004, 9004, 9004],\r\n [18898, 18898, 18990, 9802, 8906, 9004, 0, 0,\r\n 0], [18898, 18898, 18990, 9802, 8906, 9004, 0, 0, 0],\r\n [18898, 18898, 18990, 9802, 8906, 9004, 0, 0, 0]])\r\n\r\n res_out = compute_distance_matrix_from_metadata(self.DOB)\r\n assert_almost_equal(exp_out, res_out)",
"def compute_similarity(self, text1, text2):\n\n text1_dist = self.predict(text1)[0]\n text2_dist = self.predict(text2)[0]\n return jensenshannon(text1_dist, text2_dist)",
"def wordSimilarityRatio(sent_1,sent_2):",
"def _create_distance_matrix(mesh):\n l = len(mesh.faces)\n\n faces = polygons(mesh.faces, mesh.vertices, mesh.face_normals, mesh.area_faces)\n # map from edge-key to adjacent faces\n adj_faces_map = {}\n # find adjacent faces by iterating edges\n for index, face in enumerate(faces):\n for edge in face.edge_keys:\n if (edge[0] > edge[1]):\n new_edge = (edge[1], edge[0])\n else:\n new_edge = (edge[0], edge[1])\n if new_edge in adj_faces_map:\n adj_faces_map[new_edge].append(index) # 一对多\n else:\n adj_faces_map[new_edge] = [index]\n\n # helping vectors to create sparse matrix later on\n row_indices = []\n col_indices = []\n Gval = [] # values for matrix of angular distances\n Aval = [] # values for matrix of geodesic distances\n # iterate adjacent faces and calculate distances\n for edge, adj_faces in adj_faces_map.items():\n if len(adj_faces) == 2:\n i = adj_faces[0]\n j = adj_faces[1]\n # 一条边连接的两个面\n Gtemp = _geodesic_distance(mesh, faces[i], faces[j], edge) # 测地距离\n Atemp = _angular_distance(mesh, faces[i], faces[j]) # 角距离 # 其实是余弦距离\n Gval.append(Gtemp)\n Aval.append(Atemp)\n row_indices.append(i)\n col_indices.append(j)\n # add symmetric entry\n Gval.append(Gtemp)\n Aval.append(Atemp)\n row_indices.append(j)\n col_indices.append(i)\n\n elif len(adj_faces) > 2:\n print(\"Edge with more than 2 adjacent faces: \" + str(adj_faces) + \"!\")\n\n Gval = numpy.array(Gval)\n Aval = numpy.array(Aval)\n # delta是去全局变量，外部传入的\n values = delta * Gval / numpy.mean(Gval) + \\\n (1.0 - delta) * Aval / numpy.mean(Aval)\n\n # create sparse matrix\n distance_matrix = scipy.sparse.csr_matrix(\n (values, (row_indices, col_indices)), shape=(l, l))\n return distance_matrix",
"def compute_tfidf_matrix(text, remove_stopwords=0, to_gensim=0, compute_cos_similarity=0):\n\tstp = set(stopwords.words('portuguese') + list(punctuation))\n\n\tlist_1 = list(text['text'])\n\tlist_2 = list(text['response'])\n\n\tcorpus = list_1 + list_2\n\tcorpus[::2] = list_1\n\tcorpus[1::2] = list_2\n\n\tif remove_stopwords == 0:\n\t\tvectorizer = TfidfVectorizer(stop_words=None, min_df=0, max_features=None)\n\telse:\n\t\tvectorizer = TfidfVectorizer(stop_words=stp, min_df=0, max_features=None)\n\n\ttfidf_matrix = vectorizer.fit_transform(corpus)\n\n\tfeature_names = vectorizer.get_feature_names()\n\n\t#word2tfidf = dict(zip(vectorizer.get_feature_names(), vectorizer.idf_))\n\n\t#for word, score in word2tfidf.items():\n\t\t#print(word, score)\n\n\tif to_gensim:\n\t\ttfidf_matrix_list = list(Sparse2Corpus(tfidf_matrix, documents_columns=False))\n\n\t\t#convert gensim format to list\n\t\ttemp_tfidf_matrix_list = []\n\t\tfor sentence in tfidf_matrix_list:\n\n\t\t\ttemp_sentence = []\n\t\t\tfor word in sentence:\n\t\t\t\ttemp_word = feature_names[word[0]]\n\t\t\t\ttemp_pair = (temp_word, word[1])\n\n\t\t\t\ttemp_sentence.append(temp_pair)\n\t\t\ttemp_tfidf_matrix_list.append(dict(temp_sentence))\n\n\t\ttfidf_matrix_list = temp_tfidf_matrix_list\n\n\t\treturn tfidf_matrix_list\n\n\tif compute_cos_similarity:\n\t\ttfidf_matrix_list = list(Sparse2Corpus(tfidf_matrix, documents_columns=False))\n\n\t\t#convert gensim format to list\n\t\ttemp_tfidf_matrix_list = []\n\t\tfor sentence in tfidf_matrix_list:\n\n\t\t\ttemp_sentence = []\n\t\t\tfor word in sentence:\n\t\t\t\ttemp_pair = word[1]\n\n\t\t\t\ttemp_sentence.append(temp_pair)\n\t\t\ttemp_tfidf_matrix_list.append(temp_sentence)\n\n\t\ttfidf_matrix_list = temp_tfidf_matrix_list\n\n\t\tsimilarity_m = []\n\n\t\tfor i in range(0, len(tfidf_matrix_list), 2):\n\t\t\tif len(tfidf_matrix_list[i]) > len(tfidf_matrix_list[i+1]):\n\t\t\t\tdifference_in_length = len(tfidf_matrix_list[i]) - len(tfidf_matrix_list[i+1])\n\t\t\t\ttfidf_matrix_list[i+1].extend([0] * difference_in_length)\n\t\t\telif len(tfidf_matrix_list[i]) < len(tfidf_matrix_list[i+1]):\n\t\t\t\tdifference_in_length = len(tfidf_matrix_list[i+1]) - len(tfidf_matrix_list[i])\n\t\t\t\ttfidf_matrix_list[i].extend([0] * difference_in_length)\n\n\t\t\tsimilarity = cosine_similarity([tfidf_matrix_list[i]], [tfidf_matrix_list[i+1]])\n\t\t\tsimilarity_m.append(similarity[0][0])\n\n\t\treturn similarity_m\n\n\treturn tfidf_matrix",
"def _derive_euclidean_dm(self, cat_mat, dim):\r\n res_mat = []\r\n\r\n for i in range(dim):\r\n res_mat.append([0 for k in range(dim)])\r\n for j in range(i):\r\n res_mat[i][j] = self._vector_dist(cat_mat[i], cat_mat[j])\r\n res_mat[j][i] = res_mat[i][j]\r\n\r\n return DistanceMatrix(res_mat, self.DistanceMatrices[0].ids)",
"def calcDistance(self):\n # Initialize the distance matrix\n arr = np.repeat(0, self.num_col)\n result_mat = np.repeat(arr, self.num_col)\n result_mat = np.reshape(result_mat, (self.num_col, self.num_col))\n trinary_mat = self.df_trinary.values\n for left_val in TRINARY_VALUES:\n left_func = lambda v: 1 if v==left_val else 0\n left_mat = np.transpose(np.vectorize(left_func)(trinary_mat))\n for right_val in TRINARY_VALUES:\n if left_val == right_val:\n continue\n right_func = lambda v: 1 if v==right_val else 0\n right_mat = np.vectorize(right_func)(trinary_mat)\n # Count the number of occurrences of this combination of values\n # by doing a matrix multiply\n new_mat = np.matmul(left_mat, right_mat)\n # Multiply by the squared distance between the values\n squared_distance = (left_val - right_val)**2\n new_mat = new_mat*squared_distance\n # Accumulate the result\n result_mat = result_mat + new_mat\n # Convert to dataframe\n result_mat = np.vectorize(lambda v: np.sqrt(v)) (result_mat)\n self.df_distance = pd.DataFrame(result_mat, columns=self.columns,\n index=self.columns)",
"def test_matrix_distance(self):\n # note that the score matrix must contain 'diagonal' elements m[i][i]\n # to avoid failure when the sequences match.\n m = {\"U\": {\"U\": 0, \"C\": 1, \"A\": 5}, \"C\": {\"C\": 0, \"A\": 2, \"G\": 4}}\n self.assertEqual(self.RNA(\"UUUCCC\").matrix_distance(\"UCACGG\", m), 14)\n self.assertEqual(self.RNA(\"UUUCCC\").matrix_distance(\"\", m), 0)\n self.assertEqual(self.RNA(\"UUU\").matrix_distance(\"CAC\", m), 7)\n self.assertRaises(KeyError, self.RNA(\"UUU\").matrix_distance, \"CAG\", m)",
"def compute_distance(self, transpose=False):\n\n # Calculate distance matrix\n if transpose:\n distance_matrix = pdist(self.matrix.T, self.distance)\n else:\n distance_matrix = pdist(self.matrix, self.distance)\n\n # Remove NaNs\n distance_matrix[np.isnan(distance_matrix)] = 1.0\n\n return distance_matrix",
"def createMatrices(file, word2Idx, maxSentenceLen=100):\n labels = []\n positionMatrix1 = []\n positionMatrix2 = []\n tokenMatrix = []\n \n for line in open(file):\n splits = line.strip().split('\\t')\n \n label = splits[0]\n pos1 = splits[1]\n pos2 = splits[2]\n sentence = splits[3]\n tokens = sentence.split(\" \")\n \n \n \n \n tokenIds = np.zeros(maxSentenceLen)\n positionValues1 = np.zeros(maxSentenceLen)\n positionValues2 = np.zeros(maxSentenceLen)\n \n for idx in range(0, min(maxSentenceLen, len(tokens))):\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\n \n distance1 = idx - int(pos1)\n distance2 = idx - int(pos2)\n \n if distance1 in distanceMapping:\n positionValues1[idx] = distanceMapping[distance1]\n elif distance1 <= minDistance:\n positionValues1[idx] = distanceMapping['LowerMin']\n else:\n positionValues1[idx] = distanceMapping['GreaterMax']\n \n if distance2 in distanceMapping:\n positionValues2[idx] = distanceMapping[distance2]\n elif distance2 <= minDistance:\n positionValues2[idx] = distanceMapping['LowerMin']\n else:\n positionValues2[idx] = distanceMapping['GreaterMax']\n \n tokenMatrix.append(tokenIds)\n positionMatrix1.append(positionValues1)\n positionMatrix2.append(positionValues2)\n \n labels.append(labelsMapping[label])\n \n\n \n return np.array(labels, dtype='int32'), np.array(tokenMatrix, dtype='int32'), np.array(positionMatrix1, dtype='int32'), np.array(positionMatrix2, dtype='int32'),",
"def test_format_distance_matrix(self):\r\n a = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\r\n labels = [11, 22, 33]\r\n res = format_distance_matrix(labels, a)\r\n self.assertEqual(res,\r\n '\\t11\\t22\\t33\\n11\\t1\\t2\\t3\\n22\\t4\\t5\\t6\\n33\\t7\\t8\\t9')\r\n self.assertRaises(ValueError, format_distance_matrix, labels[:2], a)",
"def getDistancesWithNames(twoDList):\n matrix = []\n for i in range(0,len(twoDList)):\n for j in range(len(twoDList) - len(twoDList) + i):\n SD = determineIdenticalBases(data[i][1], data[j][1])\n temp = []\n if SD[1] != 0:\n p = calculateP(SD[0]+SD[1], SD[1])\n temp.append(data[i][0])\n temp.append(data[j][0]) \n temp.append(estimateMutationsPerSite(p))\n matrix.append(temp)\n return matrix",
"def prepare_data_matrix():\n # create matrix X and list of languages\n\n lds = {}\n for fn in listdir(\"clustering\"):\n if fn.lower().endswith(\".txt\"):\n with open(join(\"clustering\", fn), encoding=\"utf8\") as f:\n text = f.read()\n nter = terke(text, n=3)\n lds[fn] = nter\n #print(lds.keys())\n \n #lds is a dictionary of dictionaries: {\"slovenian.txt\": {\"abc\":3,\"efg\":4...}, \"macedonian.txt\":{\"efg\":6...},...}\n l=listOfTuples(lds) #list of strings\n #print(l[:100])\n languages = list(lds.keys()) # ['Slo', 'Mac', ]\n # which language represents row number i: languages[i]\n # which row does language s represent: languagues.index(s)\n X=np.zeros([len(languages),100])\n for i in range(len(languages)):\n #print(languages[i])\n count = 0\n for j in range(100):\n if l[j] in lds[languages[i]]:\n X[i,j]=lds[languages[i]][l[j]]\n count += 1\n # print(count)\n\n #print([sum(x) for x in X])\n \n return X, languages\n # X, languages = prepare_data_matrix()",
"def distance_matrix(d1, d2=None):\n if d2 is None:\n dists = np.zeros(shape=(d1.shape[0], d1.shape[0]))\n for i in range(dists.shape[0]):\n dists[i] = (((d1 - d1[i]) ** 2).sum(axis=1)) ** 0.5\n else:\n dists = np.zeros(shape=(d1.shape[0], d2.shape[0]))\n for i in range(d1.shape[0]):\n dists[i] = (((d2 - d1[i]) ** 2).sum(axis=1)) ** 0.5\n return dists",
"def test_distances(self):\n distances = self.vectors.distances('dog.n.01', ['mammal.n.01', 'dog.n.01'])\n self.assertTrue(np.allclose(distances, [4.5278745, 0]))\n\n distances = self.vectors.distances('dog.n.01')\n self.assertEqual(len(distances), len(self.vectors.vocab))\n self.assertTrue(np.allclose(distances[-1], 10.04756))",
"def get_distance_matrix():\n df_afstandn2 = get_dataframe(\"\"\"SELECT *\n FROM proj_afval_netwerk.afv_poi_afstand\n WHERE afstand < 1000\n \"\"\")\n return df_afstandn2",
"def compute_distance_matrix_from_metadata(column_data):\r\n data_row = array(column_data)\r\n data_col = reshape(data_row, (1, len(data_row)))\r\n dist_mtx = abs(data_row - data_col.T)\r\n\r\n return dist_mtx",
"def _pairwise_dist(self,seq1,seq2):\n \n return jf.damerau_levenshtein_distance(str(seq1), str(seq2))",
"def get_distance_matrix(visits: List[str], distances: Dict[Tuple[str, str], float]) -> List[List[float]]:\n\n return [[distances[i,j] for j in visits] for i in visits]",
"def get_distance_matrix(self, points):\n return points[:, :, np.newaxis, :]-points[:, np.newaxis, :, :]",
"def getDistanceMatrix(self):\n return self.pointcloud.distmat",
"def doc_term_matrix(text, vectorizer = 'CV', stop_words = 'english'):\n\n\tfrom sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n\timport pandas as pd\n\n\tif vectorizer == 'CV':\n\t vec = CountVectorizer(stop_words = stop_words)\n\telif vectorizer == 'TFIDF':\n\t vec = TfidfVectorizer(stop_words = stop_words)\n\n\tfit = vec.fit_transform(text)\n\tdf = pd.DataFrame(fit.toarray(), columns = vec.get_feature_names())\n\treturn df",
"def similarity_sort(texts: List[str]) -> List[str]:\n df = cluster_text(texts, n=len(texts) // 2)\n return df[\"text\"].tolist()",
"def get_similarity(df):\n count = CountVectorizer()\n count_matrix = count.fit_transform(df[\"bag_of_words\"])\n cosine_sim = cosine_similarity(count_matrix, count_matrix)\n return cosine_sim",
"def distance_matrix(cities):\n\n return [[city1.distance(city2) for city2 in cities]\n for city1 in cities]",
"def create_dist_matrix(matrix):\n #Convert input data matrix to numpy matrix\n matrix = np.array(matrix)\n n = matrix.shape[0]\n \n #Iterate through number of samples to create distance matrix\n for i in range(n):\n dist_array = euclidean_distance(matrix[i,:], matrix)\n if i == 0:\n dist_matrix = dist_array\n else:\n dist_matrix = np.concatenate((dist_matrix, dist_array), axis = 1)\n return dist_matrix",
"def by_distance_vectors(self, string_1, string_2):\n string_1 = self.kywrds.by_frequency(string_1)\n string_2 = self.kywrds.by_frequency(string_2)\n model = self.doc2vec_model[0]\n doc_vec_1 = model.infer_vector(string_1)\n doc_vec_2 = model.infer_vector(string_2)\n return spatial.distance.cosine(doc_vec_1, doc_vec_2)",
"def get_distance_metrics(source_embeddings, target_embeddings):\n cosine_avg, euclidean_avg = 0.0, 0.0\n for i in range(len(source_embeddings)):\n cosine_avg += cosine(source_embeddings[i], target_embeddings[i])\n euclidean_avg += euclidean(source_embeddings[i], target_embeddings[i])\n return (cosine_avg / len(source_embeddings)), (euclidean_avg / len(source_embeddings))",
"def ComputeDistMatrix(dict_alignedSequences):\r\n \r\n # check if dictionary with keys as tuples containing integers and values as tuples containing strings\r\n check = True \r\n #1 Check Input is dict\r\n if isinstance(dict_alignedSequences, dict) == False:\r\n check = False\r\n \r\n #2 Check are the keys and values tuples. Do the keys only contain integers and the vlaues only strings\r\n i = 0\r\n while len(dict_alignedSequences) > i:\r\n #checking for keys and values as tuples\r\n if isinstance(list(dict_alignedSequences.keys())[i], tuple) == False or isinstance(list(dict_alignedSequences.values())[i], tuple) == False:\r\n check = False\r\n break\r\n #checking keys for integers\r\n if isinstance(list(dict_alignedSequences.keys())[i][0], int) == False or isinstance(list(dict_alignedSequences.keys())[i][1], int) == False:\r\n check = False\r\n break\r\n #checking values for strings\r\n if isinstance(list(dict_alignedSequences.values())[i][0], str) == False or isinstance(list(dict_alignedSequences.values())[i][1], str) == False:\r\n check = False\r\n break\r\n \r\n #increment the counter for while loop\r\n i += 1\r\n \r\n #3 Check sequences contain aligned DNA and are of equal length\r\n for key in dict_alignedSequences:\r\n if is_aligned_dna(dict_alignedSequences[key][0]) == False or is_aligned_dna(dict_alignedSequences[key][1]) == False:\r\n check = False\r\n break\r\n if len(dict_alignedSequences[key][0]) != len(dict_alignedSequences[key][1]):\r\n check = False\r\n break\r\n \r\n #final evalauation if data is usable\r\n if check == False:\r\n raise TypeError ('malformed input')\r\n \r\n #get number of sequences\r\n matrixdim = howmany_sequences(dict_alignedSequences)\r\n #initialize dist matrix\r\n distMatrix = init_Dist_Matrix(matrixdim)\r\n \r\n \r\n for i in dict_alignedSequences.keys():\r\n # useing the key i to get the corisponding aligned sequences \r\n seq = dict_alignedSequences[i]\r\n #calculate distances between the sequences\r\n distance = calculate_distance(seq[0],seq[1])\r\n #markdown result at the corrsiponding place in the distmatrix\r\n distMatrix[i[0]][i[1]] = distance\r\n distMatrix[i[1]][i[0]] = distance\r\n \r\n return(distMatrix)",
"def distancematrix(vec1, vec2):\n v1, v2 = np.meshgrid(vec1, vec2)\n return np.abs(v1 - v2)",
"def lemmatization(texts):\r\n texts_out = []\r\n for sent in texts:\r\n x=analyzer.analyze(sent)[0][0]\r\n if (x.pos==\"Unk\"):\r\n texts_out.append(analyzer.lemmatize(sent)[0][1][0])\r\n else:\r\n texts_out.append(x.lemma)\r\n return texts_out",
"def plot_MDS():\n lds = {} #lds is a dictionary of dictionaries: {\"slovenian.txt\": {\"abc\":3,\"efg\":4...}, \"macedonian.txt\":{\"abc\":5,\"efg\":6...},...}\n for fn in listdir(\"clustering\"):\n if fn.lower().endswith(\".txt\"):\n with open(join(\"clustering\", fn), encoding=\"utf8\") as f:\n text = f.read()\n nter = terke(text, n=3)\n lds[fn] = nter\n \n distances={} #a dictionary of dictionaries that saves the distances between a language and all other languages\n \n for x in lds.keys():\n distances[x]={}\n for y in lds.keys():\n if x == y: distances[x][y]=0.0\n else: distances[x][y]=cosine_dist(lds[x],lds[y])\n\n dst=np.zeros([len(lds.keys()), len(lds.keys())])\n i=0\n j=0\n for x in lds.keys():\n j=0\n for y in lds.keys():\n dst[i,j]=distances[x][y]\n j+=1\n i+=1\n\n X, languages = prepare_data_matrix()\n\n transformer = MDS(n_components=2, dissimilarity='precomputed')\n transformed = transformer.fit_transform(dst)\n\n plt.scatter(transformed [:,0], transformed [:,1])\n for i in range(len(transformed)):\n plt.text(transformed[i,0], transformed[i,1], languages[i][:3])\n plt.show()",
"def compute_dist_matrix(X1, X2, distance):\n N, M = X1.shape[0], X2.shape[0]\n dist_matrix = np.zeros((N, M))\n for i in range(N):\n for j in range(M):\n dist_matrix[i][j] = dist(X1[i], X2[j], distance=distance)\n return dist_matrix",
"def compute_l2_distance_matrix(features_queries, features_dataset):\n sx = np.sum(features_queries ** 2, axis=1, keepdims=True)\n sy = np.sum(features_dataset ** 2, axis=1, keepdims=True)\n\n return np.sqrt(-2 * features_queries.dot(features_dataset.T) + sx + sy.T)",
"def calculateDistances(df):\n return",
"def _computeDistances(self) -> None:\n length = len(self.data)\n for i, sequenceOne in enumerate(self.data):\n print(f\"[SeqCluBaselineOffline] Computing distances is at iteration {i} of {length}.\")\n for j, sequenceTwo in enumerate(self.data):\n if i == j:\n self.distances[i][j] = 0\n continue\n distance = self.distanceMeasure.calculateDistance(sequenceOne, sequenceTwo)\n self.distances[i][j] = distance\n self.distances[j][i] = distance",
"def doc_doc_similarity(matrix_a, matrix_b):\n assert matrix_a.shape[1] == matrix_b.shape[0], \"Mismatched shape between matrix A and matrix B\"\n numerator = np.dot(matrix_a, matrix_b)\n assert numerator.shape == (matrix_a.shape[0], matrix_b.shape[1]), numerator.shape\n denominator = np.sqrt(np.sum(matrix_a ** 2, axis=1))[:, np.newaxis] * np.sqrt(\n np.sum(matrix_b.T ** 2, axis=1))[:, np.newaxis].T\n assert (denominator > 0).all(), \"Denominator is zero {}\".format(denominator)\n similarity_matrix = np.multiply(numerator, 1 / denominator)\n return similarity_matrix",
"def distances(self):\n self._sort_measurements()\n return self._distances",
"def build_matrix(self):\n self.lb_make = LabelEncoder()\n self.lb_make.fit(self.Y_train)\n tokenizer = Tokenizer(num_words=2000)\n x_array_train = numpy.asarray(self.train['text'])\n x_array_test = numpy.asarray(self.test['text'])\n tokenizer.fit_on_texts(x_array_train)\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\n y_train_numbers = self.lb_make.transform(self.Y_train)\n y_test_numbers = self.lb_make.transform(self.Y_test)\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\n self.tokenizer = tokenizer\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix",
"def levenshteinDistance(s1, s2):\n singleLetterMapping = {DOWNLEFT: '1', DOWN:'2', DOWNRIGHT:'3',\n LEFT:'4', RIGHT:'6',\n UPLEFT:'7', UP:'8', UPRIGHT:'9'}\n\n len1 = len([singleLetterMapping[letter] for letter in s1])\n len2 = len([singleLetterMapping[letter] for letter in s2])\n\n matrix = list(range(len1 + 1)) * (len2 + 1)\n for i in range(len2 + 1):\n matrix[i] = list(range(i, i + len1 + 1))\n for i in range(len2):\n for j in range(len1):\n if s1[j] == s2[i]:\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j])\n else:\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j] + 1)\n return matrix[len2][len1]",
"def test_parse_distmat(self):\r\n lines = \"\"\"\\ta\\tb\\tc\r\na\\t0\\t1\\t2\r\nb\\t1\\t0\\t3.5\r\nc\\t1\\t3.5\\t0\r\n\"\"\".splitlines()\r\n exp = (['a', 'b', 'c'], array([[0, 1, 2], [1, 0, 3.5], [1, 3.5, 0]]))\r\n obs = parse_distmat(lines)\r\n self.assertEqual(obs[0], exp[0])\r\n assert_almost_equal(obs[1], exp[1])",
"def distances(self) -> ndarray:\n return self._distances",
"def abstract_words_matrix( corpus, cooccurrence_only = True, ignore_words = Ignore_words ) :\n return words_matrix( corpus, 'AB', cooccurrence_only, ignore_words )",
"def calculate_distance_matrix(atomlist):\n distlist = []\n for atom in atomlist:\n atomdict = {}\n for partner in atomlist:\n if not str(int(partner[0][1])) in atomdict.keys():\n atomdict[str(int(partner[0][1]))] = []\n atomdict[str(int(partner[0][1]))].append(np.linalg.norm(atom[1] - partner[1]))\n else:\n atomdict[str(int(partner[0][1]))].append(np.linalg.norm(atom[1] - partner[1]))\n atomdict[str(int(partner[0][1]))].sort()\n\n distlist.append(atomdict)\n\n return distlist",
"def matrix_dist(self):\n matrix_dic = {}\n for clus in self.clusters:\n for other_clus in self.clusters:\n if clus.samples[0].s_id > other_clus.samples[0].s_id: # avoid duplicates\n matrix_dic[(clus.samples[0].s_id, other_clus.samples[0].s_id)] = clus.samples[0]\\\n .compute_euclidean_distance(other_clus.samples[0])\n return matrix_dic",
"def compute_distances(self, X):\n #print(X.shape, self.Xtr.shape)\n dists = np.zeros((X.shape[0], self.Xtr.shape[0]))\n for i in range(X.shape[0]):\n X_r = np.tile(X[i], (self.Xtr.shape[0], 1))\n dists[i] = np.sqrt(np.sum(np.square(self.Xtr - X_r), axis = 1))\n #print(dists.shape)\n return dists",
"def get_topic_matrix(self):\n print('get topic matrix')\n\n topic_words_dict = self.config['topic_words']\n\n topic_matrix = np.empty((0, self.wordvec.embedding_dim))\n\n topic_id = 0\n for topic in topic_words_dict.keys():\n topic_words = topic_words_dict[topic]\n topic_vector = self.wordvec.avg_words_vector(topic_words)\n\n topic_matrix = np.append(topic_matrix, topic_vector, axis=0)\n\n self.id2topic[str(topic_id)] = topic\n topic_id += 1\n\n return topic_matrix",
"def create_adjacency_matrix(self, edges):\n matrix = np.zeros([self.max_words, self.max_words * self.edge_types * 2])\n for edge in edges:\n src = edge[0]\n e_type = edge[1]\n dest = edge[2]\n self.set_matrix(matrix, src, dest, e_type, 1)\n return matrix",
"def wordMoversDistance(model, document1, document2):\n # If pyemd C extension is available, import it.\n # If pyemd is attempted to be used, but isn't installed, ImportError will be raised in wmdistance\n from pyemd import emd\n # Remove out-of-vocabulary words.\n len_pre_oov1 = len(document1)\n len_pre_oov2 = len(document2)\n document1 = [token for token in document1 if token in model]\n document2 = [token for token in document2 if token in model]\n diff1 = len_pre_oov1 - len(document1)\n diff2 = len_pre_oov2 - len(document2)\n if diff1 > 0 or diff2 > 0:\n print('Remove ' + str(diff1) + ' and ' + str(diff2) + ' OOV words from document 1 and 2 ('\n 'respectively).')\n return float('inf')\n\n if not document1 or not document2:\n print(\"At least one of the documents had no words that were in the vocabulary. Aborting (returning \"\n \"inf).\")\n return float('inf')\n\n dictionary = Dictionary(documents=[document1, document2])\n vocab_len = len(dictionary)\n\n if vocab_len == 1:\n # Both documents are composed by a single unique token\n return 0.0\n\n # Sets for faster look-up.\n docset1 = set(document1)\n docset2 = set(document2)\n\n # Compute distance matrix.\n distance_matrix = zeros((vocab_len, vocab_len), dtype=double)\n for i, t1 in dictionary.items():\n if t1 not in docset1:\n continue\n\n for j, t2 in dictionary.items():\n if t2 not in docset2 or distance_matrix[i, j] != 0.0:\n continue\n\n # Compute Euclidean distance between word vectors.\n distance_matrix[i, j] = distance_matrix[j, i] = sqrt(np_sum((model[t1] - model[t2]) ** 2))\n\n if np_sum(distance_matrix) == 0.0:\n # `emd` gets stuck if the distance matrix contains only zeros.\n print('The distance matrix is all zeros. Aborting (returning inf).')\n return float('inf')\n\n def nbow(document):\n d = zeros(vocab_len, dtype=double)\n nbow = dictionary.doc2bow(document) # Word frequencies.\n doc_len = len(document)\n for idx, freq in nbow:\n d[idx] = freq / float(doc_len) # Normalized word frequencies.\n return d\n\n # Compute nBOW representation of documents.\n d1 = nbow(document1)\n d2 = nbow(document2)\n\n # Compute WMD.\n return emd(d1, d2, distance_matrix)",
"def _generate_distance_kernel_matrix(self):\n with self._rw_lock.read_lock():\n # Create matrix whose elements are the distances between all row\n # permutations\n fmat = self._feature_mat # shorter name\n num_rows = fmat.shape[0]\n\n # distance kernel is a square matrix based on feature samples\n dist_kernel = np.mat(np.ndarray((num_rows,)*2))\n self._log.info(\"Creating distance kernel with shape %s\",\n dist_kernel.shape)\n\n timer_log = logging.getLogger('.'.join((self.__module__,\n self.__class__.__name__,\n \"SimpleTimer\")))\n\n for i in xrange(num_rows - 1):\n with SimpleTimer('computing distances from row %d to [%d-%d]'\n % (i, i+1, num_rows-1), timer_log):\n dist_kernel[i, i] = 1.0\n for j in xrange(i + 1, num_rows):\n dist = self._histogram_intersection_distance(fmat[i],\n fmat[j])\n dist_kernel[i, j] = dist_kernel[j, i] = dist\n dist_kernel[-1, -1] = 1.0\n return dist_kernel",
"def get_general_distance_and_relationship_matrix(path_to_embeddings,image_level_embed_file_name, study=None):\n\n if study == None:\n images_info = pd.read_csv(os.path.join(DATA_DIR,STUDY,\"human_ISH_info.csv\"))\n else:\n images_info = pd.read_csv(os.path.join(DATA_DIR, study, \"human_ISH_info.csv\"))\n\n\n dist_matrix_df = build_distance_matrix(os.path.join(path_to_embeddings, image_level_embed_file_name))\n\n dist_matrix_rows = list(dist_matrix_df.index) # list of image IDs\n dist_matrix_columns = list(dist_matrix_df) # list of image IDs\n\n # --- sanity check -------------\n if dist_matrix_rows != dist_matrix_columns:\n print (\"Something is wrong, the number and order of image IDs in distance matrix's rows and columns should the same.\")\n return None\n # ------------------------------\n\n\n genes = images_info[images_info['image_id'].isin(dist_matrix_rows)]['gene_symbol']\n\n low_to_high_map = pd.DataFrame(list(zip(dist_matrix_rows, genes))) # create a 2-column df of image IDs and genes\n relationship_df = create_diagonal_mask(low_to_high_map, target_value=1)\n\n\n # --- check to see if rows and columns of dist matrix match the relationship matrix. ---------------------\n # if they don't re-arrange them in the relationship matrix to match the dist matrix\n\n dist_matrix_df, relationship_df = match_matrices(dist_matrix_df, relationship_df)\n\n # ---------------------------------------------------------------------------------------------------------\n\n return dist_matrix_df,relationship_df",
"def compute_distances(self):\n if self.df is None:\n return\n\n self.origdist = []\n self.transdist = []\n for i in range(len(self.df)):\n for j in range(i+1, len(self.df)):\n self.origdist.append(distance(self.df['LPsol'].iloc[i], self.df['LPsol'].iloc[j]))\n self.transdist.append(distance(self.df[['x', 'y']].iloc[i], self.df[['x', 'y']].iloc[j]))",
"def _compute_pairwise_distance(self, column: List[List[Token]]) -> np.array:\n pairwise = NeedlemanWunschAligner()\n l = len(column)\n distances = np.empty((l, l))\n for u in range(l):\n # compute only half of the distances\n for v in range(u, l):\n au, av = pairwise.align([column[u], column[v]]) # get aligned\n distances[u][v] = distances[v][u] = self.distance.compute(au, av)\n\n return distances",
"def test_distance(self):\n for emb_vals, point, dist_gt in self.DISTANCE_EXAMPLES:\n print(emb_vals, point, dist_gt)\n emb = to_emb(emb_vals)\n dist = emb.distance(point)\n assert np.allclose(dist, dist_gt), \\\n (\"Wrong distance for point {}: expected {} but was {};\"\n \"\\nembedding:\\n{}\").format(point, dist_gt, dist, str(emb))",
"def word_analogy(self):\n data = open(\"data/word_analogy_subset.en.ar.txt\").read().split('\\n')\n data = [x for x in data if len(x.split()) == 4]\n cnt = 0\n keys = list(self.embeddings_index.keys())\n vectors = np.array(list(self.embeddings_index.values()))\n norms = np.linalg.norm(vectors, axis=1)\n for i in data:\n i = self.preprocessor(i).split()\n try:\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\n except:\n continue\n unit = v / np.linalg.norm(v)\n dists = np.dot(vectors, unit) / norms\n best = np.argpartition(-dists, 10)[:10 + 1]\n best = best.take(np.argsort((-dists).take(best)))\n result = [(keys[sim], float(dists[sim]))\n for sim in best]\n sbv = result[:10]\n for j in sbv:\n if j[0] == i[3]:\n cnt += 1\n return cnt/ len(data)",
"def Distmatrix(self):\n self.Dismatrix = np.zeros((self.nodenum, self.nodenum))\n for i in range(len(self.Dismatrix)):\n for j in range(len(self.Dismatrix)):\n self.Dismatrix[i, j] = sf.dist(self.y[i], self.x[i], self.y[j], self.x[j])\n self.Dismatrix[j, i] = self.Dismatrix[i, j]",
"def distance_between_pattern_and_strings(pattern, dna):\n\n k = len(pattern)\n distance = 0\n\n for text in dna:\n hamming_distance = 1000000\n for i in range(len(text) - k + 1):\n if hamming_distance > compute_hamming_distance(pattern, text[i:i + k]):\n hamming_distance = compute_hamming_distance(pattern, text[i:i + k])\n distance = distance + hamming_distance\n return distance",
"def calculate_distance_matrix(played_decks: Union[List[FuzzyDeck], List[Deck]], measure: str):\n deck_data = np.array(played_decks).reshape(len(played_decks), 1)\n if measure == \"jaccard\":\n dist = pdist(deck_data, lambda u, v: u[0].jaccard_distance(v[0]))\n elif measure == \"euclidean\":\n dist = pdist(deck_data, lambda u, v: u[0].euclidean_distance(v[0]))\n else:\n raise ValueError(\"Unknown distance measure {}. \".format(measure) +\n \"Please choose one of the following distance measures ['euclidean','jaccard']\")\n\n return dist",
"def _calculate_distances(boxes, homography):\n pos_markers = []\n pix_markers = []\n for box in boxes:\n (pt1_w, pt1_h), (pt2_w, pt2_h) = box\n\n pix_marker = ((pt1_w + pt2_w) // 2, max(pt1_h, pt2_h))\n pix_markers.append(pix_marker)\n\n pos_marker = np.array(pix_marker).reshape(\n 1, 1, 2).astype(\"float32\")\n pos_marker = cv2.perspectiveTransform(\n pos_marker, homography).squeeze()\n pos_markers.append(pos_marker)\n\n if len(pos_markers) <= 1:\n return np.array([]), np.array([])\n\n distances = pdist(np.array(pos_markers))\n return pix_markers, distances",
"def tldr_matrix(article, lang):\r\n article = re.sub(r\"[^\\w\\s\\.]\", \" \", article).lower()\r\n sentences = sent_tokenize(article, language=lang)\r\n stemmed_sentences = [sentence_stem(sentence, lang) for sentence in sentences]\r\n\r\n bagofwords_matrix = CountVectorizer().fit_transform(stemmed_sentences)\r\n # normalize with TF-IDF\r\n bagofwords_matrix = TfidfTransformer().fit_transform(bagofwords_matrix)\r\n\r\n # mirror the matrix onto itself to get the similarity edges between sentences\r\n similarity_matrix = bagofwords_matrix * bagofwords_matrix.T\r\n similarity_graph = nx.from_scipy_sparse_matrix(similarity_matrix)\r\n\r\n scores = nx.nx.pagerank_scipy(similarity_graph)\r\n scored_sentences = [(i, s, scores[i]) for i, s in enumerate(sentences)]\r\n\r\n return sorted(scored_sentences, key=lambda x: x[2])"
] | [
"0.7323501",
"0.66943216",
"0.66371775",
"0.6623149",
"0.64143485",
"0.6409224",
"0.64084244",
"0.6405972",
"0.6359847",
"0.6322712",
"0.6210911",
"0.61276406",
"0.60897166",
"0.6088725",
"0.6085393",
"0.60802317",
"0.6077521",
"0.60503525",
"0.60271037",
"0.6016799",
"0.59837985",
"0.5970025",
"0.59308946",
"0.5906707",
"0.59010774",
"0.58922267",
"0.58864874",
"0.58110136",
"0.5803373",
"0.5803373",
"0.579679",
"0.575971",
"0.575935",
"0.5758158",
"0.57549024",
"0.5723599",
"0.57180834",
"0.5716499",
"0.5709117",
"0.57073915",
"0.56980103",
"0.5690907",
"0.56679755",
"0.5648669",
"0.5640698",
"0.56333864",
"0.5624712",
"0.56241953",
"0.5619496",
"0.5617901",
"0.5615086",
"0.56128454",
"0.56093955",
"0.56092024",
"0.5604488",
"0.5596448",
"0.5593858",
"0.55798876",
"0.55763423",
"0.5573968",
"0.55707026",
"0.55665225",
"0.55582154",
"0.5552189",
"0.5546726",
"0.5539383",
"0.5528573",
"0.5515382",
"0.5503144",
"0.5496373",
"0.5489539",
"0.5488765",
"0.547953",
"0.5473385",
"0.54580253",
"0.54574233",
"0.54545563",
"0.54520833",
"0.5450852",
"0.54476196",
"0.54407287",
"0.5433142",
"0.54307914",
"0.54270923",
"0.5424197",
"0.5422719",
"0.54174554",
"0.54155433",
"0.5403647",
"0.5396636",
"0.5396435",
"0.5396162",
"0.53899896",
"0.53889203",
"0.5382099",
"0.53704107",
"0.5368763",
"0.5351341",
"0.5349543",
"0.53486896",
"0.53441733"
] | 0.0 | -1 |
Return the path of the ocamlmerlin binary." | def merlin_bin():
user_settings = sublime.load_settings("Merlin.sublime-settings")
merlin_path = user_settings.get('ocamlmerlin_path')
if merlin_path:
return merlin_path
# For Mac OS X, add the path for homebrew
if "/usr/local/bin" not in os.environ['PATH'].split(os.pathsep):
os.environ['PATH'] += os.pathsep + "/usr/local/bin"
opam_process = subprocess.Popen('opam config var bin', stdout=subprocess.PIPE, shell=True)
opam_bin_path = opam_process.stdout.read().decode('utf-8').rstrip() + '/ocamlmerlin'
if os.path.isfile(opam_bin_path) and os.access(opam_bin_path, os.X_OK):
return opam_bin_path
else:
return 'ocamlmerlin' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bin_dir():\n return os.path.abspath(os.path.join(get_root_dir(), 'bin/'))",
"def dir_bin():\n return abspath('bin')",
"def binary_location(cmd, USE_PATH=False):\n return os.path.join(BIN_PREFIX, cmd)",
"def get_golem_path():\r\n return os.path.abspath(os.path.join(os.path.dirname(__file__), \"../\"))",
"def binpath(self):\n return self._query_config()['binpath']",
"def binpath(self):\n return self.__bin",
"def get_reference_binary():\n return \"./Binary/linux-x64/astcenc\"",
"def bin_path(self) -> Path:\n return self._root_path / \"stefan-on-software-api-client\" / \"bin\"",
"def getBinary():\n binary = shutil.which(_ROCKETLOGGER_BINARY)\n\n if not os.path.exists(binary):\n raise FileNotFoundError(f\"Could not find RocketLogger CLI binary! [{binary}]\")\n return os.path.abspath(binary)",
"def bin_root(self):\n return os.path.join(self.build_dir, self.build, \"stage0\")",
"def module_path():\n return os.path.dirname(unicode(__file__, sys.getfilesystemencoding( )))",
"def get_target_binary():\n file_location = prompt_base(\"where is the file located?\")\n file_location = os.path.abspath(file_location)\n return file_location",
"def path_to_program_dir(self):\n\tpath = sys.argv[0]\n\n\tif not os.path.isdir(path):\n\t path = os.path.dirname(path)\n\n\tif not path: return '.'\n\n\treturn path",
"def binary_location(cmd, USE_PATH=False):\n if USE_PATH:\n return cmd\n else:\n return os.path.join(BIN_PREFIX, cmd)",
"def get_executable(self) -> str:\n ...",
"def get_directory(self):\n mypath = mlblocks.get_primitives_paths()[-1]\n return mypath",
"def get_test_binary():\n return \"./Source/astcenc\"",
"def get_path() -> str:\n return os.path.dirname(os.path.realpath(__file__))",
"def GetLauncherPath(self):\n return os.path.dirname(__file__)",
"def GetLauncherPath(self):\n return os.path.dirname(__file__)",
"def _getCodeFolder(self):\n if getattr(sys, 'frozen', False):\n # we are running in a bundle (frozen)\n bundle_dir = sys._MEIPASS\n else:\n # we are running in a normal Python environment\n bundle_dir = os.path.dirname(os.path.abspath(__file__))\n return bundle_dir",
"def get_installdir(self):\n import mewlo\n path = os.path.dirname(os.path.realpath(mewlo.__file__))\n return path",
"def module_path():\r\n if hasattr(sys, \"frozen\"):\r\n return os.path.dirname(sys.executable)\r\n return os.path.dirname(__file__)",
"def bootstrap_binary(self):\n return os.path.join(self.build_dir, \"bootstrap\", \"debug\", \"bootstrap\")",
"def get_output_path():\n return os.getcwd() + \"/output/\"",
"def get_mtad_linter_path():\n return os.path.expandvars(os.path.join(\n \"%PROGRAMFILES(X86)%\", \"MEDITECH\", \"M-AT Tools\", \"M-AT_Code_Checker\"))",
"def get_vernissagecmd_path():\n return vernissagecmd_path",
"def _get_R_script_path(self):\r\n return join(self._get_R_script_dir(), self._R_script)",
"def _get_path(): # THIS IS JUST FOR GETTING THE FILE\n return os.path.dirname(os.path.abspath(__file__)) + '/'",
"def getFmeExePath(self):\n \n tmp = self.__fmepath.rstrip(\"\\\\/\")\n return tmp",
"def bundle_path(self, app):\n return (\n self.platform_path / self.output_format / safe_formal_name(app.formal_name)\n )",
"def module_path():\n try:\n this_file_path = __file__\n except NameError:\n # inside an interpreter, we can use the stack to find the file\n # path.\n tbs = traceback.extract_stack()\n this_file_path = tbs[0][0]\n # move back up to rfm directory\n dev_root = os.path.dirname(this_file_path)\n\n return dev_root",
"def _get_R_script_path(self):\r\n return join(self._get_R_script_dir(), self._r_script)",
"def _get_R_script_path(self):\r\n return join(self._get_R_script_dir(), self._r_script)",
"def get_root():\n\n return 'data/simulators/mg1'",
"def this_folder():\n if getattr(sys, 'frozen', False):\n # The application is frozen\n return os.path.dirname(sys.executable)\n else:\n # The application is not frozen\n return os.path.dirname(__file__)",
"def runner_path():\n git_base = os.popen('git rev-parse --show-toplevel').read().strip()\n return os.path.join(git_base, RUNNER_SCRIPT_BASENAME)",
"def getRootPath()->str:\n if '--develop' in sys.argv:\n return eel._get_real_path('public') + '/'\n\n return eel._get_real_path('build') + '/'",
"def program_dir():\n if (Win32() and (hasattr(sys, 'frozen') or imp.is_frozen('__main__'))):\n # running from exe generated by py2exe\n return os.path.dirname(sys.executable)\n else:\n return sys.path[0]\n # return os.path.dirname(os.path.abspath(sys.argv[0]))",
"def thisdir():\n if getattr(sys, 'frozen', False):\n # The application is frozen\n return os.path.dirname(sys.executable)\n else:\n # The application is not frozen\n # Change this bit to match where you store your data files:\n return os.path.dirname(__file__)",
"def shared_binary_location(cmd=\"shared\"):\n return os.path.join(BIN_PREFIX, cmd)\n return binary_location(cmd, SHARED_USE_PATH)",
"def get_kernel_path():\n path = \"/\".join(os.path.dirname(os.path.realpath(__file__)).split('/')[:-1])\n return path+'/src/'",
"def getScriptPath():\n\treturn os.path.dirname(os.path.realpath(sys.argv[0]))",
"def GetPackageDirectory():\n return os.path.dirname(__file__)",
"def go_mod_path(self):\n return self.full_path() + \"/go.mod\"",
"def get_condor_bin_dir(config):\n condor_root = config['condor-root']\n if condor_root:\n return osp.join(condor_root, 'bin')\n else:\n return ''",
"def systemdir():\n if platform == 'windows':\n return os.path.join(os.environ['ProgramFiles'], 'automaton')\n else:\n return \"/etc/automaton/\"",
"def get_installation_path():\n file_abs_path = os.path.abspath(__file__)\n real_file_abs_path = os.path.realpath(file_abs_path)\n return real_file_abs_path[:real_file_abs_path.find('/node')]",
"def get_model_path():\n misc_path = pkg_resources.resource_filename('sst', 'misc/')\n return os.path.abspath(os.path.join(misc_path, 'model.pickle'))",
"def OutputPath(self):\n return os.path.join(self._module.workspace, \n \"broc_out\", \n self._module.module_cvspath,\n \"output\")",
"def module_path(self):\n return self.config['cwd']",
"def _spdr_engine_location():\n return os.path.realpath(__file__).rpartition('/')[0]",
"def get_output_path():\n\n path = rs.DocumentPath()\n name = rs.DocumentName()\n \n if gc.operating_system == \"mac\":\n\n path = path[:-len(name)] + \"_system.dat\"\n\n elif gc.operating_system == \"win\":\n\n i = path.rfind(\"\\\\\")\n\n path = path[:i] + \"/_system.dat\" \n\n return path",
"def path_to_calib_dir_src_custom(self):\n return cp.calib_dir_src.value()",
"def exepath(filename):\r\n return os.path.abspath(os.path.join(os.path.dirname(sys._getframe(1).f_code.co_filename), filename))",
"def GetBinDirectory(self, *args):\n return _gmat_py.FileManager_GetBinDirectory(self, *args)",
"def machine_learning_path(self) -> str:\n return join(self.directory_path, 'machinelearning')",
"def get_executable_path(py_binary_name):\n\n if os.name == 'nt':\n py_binary_name += '.exe'\n manifest_file = os.path.join(FLAGS.test_srcdir, 'MANIFEST')\n workspace_name = os.environ['TEST_WORKSPACE']\n manifest_entry = '{}/{}'.format(workspace_name, py_binary_name)\n with open(manifest_file, 'r') as manifest_fd:\n for line in manifest_fd:\n tokens = line.strip().split(' ')\n if len(tokens) != 2:\n continue\n if manifest_entry == tokens[0]:\n return tokens[1]\n raise RuntimeError(\n 'Cannot locate executable path for {}, MANIFEST file: {}.'.format(\n py_binary_name, manifest_file))\n else:\n # NOTE: __file__ may be .py or .pyc, depending on how the module was\n # loaded and executed.\n path = __file__\n\n # Use the package name to find the root directory: every dot is\n # a directory, plus one for ourselves.\n for _ in range(__name__.count('.') + 1):\n path = os.path.dirname(path)\n\n root_directory = path\n return os.path.join(root_directory, py_binary_name)",
"def getRootPath():\n return '/'.join(__file__.split('/')[:-4]) # Path of this file with pagebot/__init__.py(c) removed.",
"def _get_reporoot():\n from os import path\n import acorn\n medpath = path.abspath(acorn.__file__)\n return path.dirname(path.dirname(medpath))",
"def get_path():\n return path.abspath(path.dirname(path.dirname(__file__)))",
"def sublime_haskell_package_path():\n return os.path.dirname(os.path.realpath(__file__))",
"def getmp_mpdir():\n return os.path.join(getmp_rootdir(), 'lib', 'python', 'mod_python')",
"def scratch(bin_lid,suffix=''):\n return os.path.join(SCRATCH,bin_lid,suffix)",
"def CoreDirectory():\n thisDir=WindowsPath(__file__).parent.resolve()\n # print(f\"this dir {thisDir}\")\n coreDir=thisDir.parent/\"MacroSystem/core\"\n return coreDir",
"def get_exec_path():\n if hasattr(sys, \"frozen\"): # compiled by py2exe\n return os.path.dirname(sys.executable)\n else:\n return os.path.dirname(sys.path[0]) # should be path to /fpdb",
"def cellml_1_0(filename):\n return os.path.join(check.CELLML_1_0_DIR, filename)",
"def cellml_2_0(filename):\n return os.path.join(check.CELLML_2_0_DIR, filename)",
"def path_to_calib_dir_custom(self):\n return cp.calib_dir.value()",
"def getFmeWorkbenchPath(self):\n \n tmp = self.__fmeworkbenchpath.rstrip(\"\\\\/\")\n return tmp",
"def get_exec_path(self):\n bin_name = 'test_hint_time'\n # Look for in place build\n script_dir = os.path.dirname(os.path.realpath(__file__))\n bin_path = os.path.join(script_dir, '.libs', bin_name)\n if not os.path.exists(bin_path):\n # Look for out of place build from using apps/build_func.sh\n int_dir = os.path.dirname(script_dir)\n bin_path_op = os.path.join(int_dir, 'build/integration/test/.libs', bin_name)\n if not os.path.exists(bin_path_op):\n msg = 'Could not find application binary, tried \\n \"{}\"\\n \"{}\"'.format(\n bin_path, bin_path_op)\n raise RuntimeError(msg)\n bin_path = bin_path_op\n return bin_path",
"def p(path):\n import os\n from os.path import abspath, dirname\n return dirname(abspath(sys.argv[0])).replace('library.zip', '') + os.sep \\\n + path",
"def _executable(self) -> str:\n return sys.executable",
"def get_enry_dir() -> str:\n return os.path.abspath(os.path.join(os.path.dirname(__file__), \"build\"))",
"def directory(self):\r\n return conf.lib.clang_CompileCommand_getDirectory(self.cmd)",
"def output_path(self):\r\n return '%s/%s' % (os.path.abspath(os.path.dirname(__file__) + 'outputs'),\r\n self.identifier)",
"def find_tool():\n return shutil.which('dump')",
"def output_dir(self):\n return self.c.build_dir.join(self.c.build_config_fs)",
"def cmdpath(self):\n return os.system('pwd')",
"def path(self):\n path = os.path.join(self.base_dir, self.store().replace(' ', '_'), self.package_name())\n return os.path.abspath(path)",
"def find_tool():\n return shutil.which('readelf')",
"def _pickle_path(self) -> Path:\r\n return self.output_path / \"pickles\"",
"def get_main_dir():\n return os.path.dirname(os.getcwd())",
"def test_llvm_bin_dir(self):\n self.assertEqual(\n self.ndk.llvm_bin_dir,\n f\"/opt/android/android-ndk/toolchains/llvm/prebuilt/{self.ndk.host_tag}/bin\",\n )",
"def get_sphinx():\n return path.join(TaskCreator.bin_dir, \"sphinx\")",
"def lightPath(self):\n\t\treturn mfl.mayaFile( self._path + '/lights.ma' )",
"def get_python():\n return path.join(TaskCreator.bin_dir, \"python\")",
"def outputdir():\n return __OUTPUT_DIR__",
"def get_bitstream_path():\n\n env = get_env()\n\n # Derive destination path\n cache_dir = os.getenv(\"VTA_CACHE_PATH\", os.path.join(os.getenv(\"HOME\"), \".vta_cache/\"))\n cache_dir = os.path.join(cache_dir, env.TARGET)\n cache_dir = os.path.join(cache_dir, env.HW_VER.replace(\".\", \"_\"))\n # Create the directory if it didn't exist\n if not os.path.exists(cache_dir):\n os.makedirs(cache_dir)\n bit_path = os.path.join(cache_dir, env.BITSTREAM) + \".bit\"\n\n return bit_path",
"def get_script_directory():\n return os.path.dirname(__file__)",
"def get_install_dir(self):\n return EventGenerator.get_install_dir(self) + \"/madgraph4/src\"",
"def get_axebindir():\n import sys\n\n if 'axesrc' in sys.modules:\n modfile = sys.modules['axesrc'].__file__\n axebindir = os.path.abspath(os.path.join(os.path.dirname(modfile),'../bin/'))\n\n else:\n from pyraf import iraf\n\n # just read all variables\n all_variables = iraf.getVarDict()\n\n arch = all_variables['arch']\n stsdas = all_variables['stsdas']\n # compose the bin directory\n axebindir = os.path.join(stsdas, 'bin'+arch)\n #axe = all_variables['axe']\n #axebindir = all_variables['axebin']\n\n # compose the bin directory\n #axebindir = os.path.join(axe, 'bin')\n\n # return the path\n return axebindir",
"def mayapy_executable():\n process_path = sys.executable\n maya_dir = os.path.dirname(process_path)\n\n if os.name == 'nt':\n return os.path.join(maya_dir, 'mayapy.exe')\n else:\n # todo: OSX/Linux support\n raise NotImplemented()",
"def _get_module_path():\n\n return os.path.dirname(os.path.realpath(__file__))",
"def root_dir():\n return dirname(dirname(__file__))",
"def find_path():\n __dir_path__ = os.path.dirname(os.path.realpath(__file__))\n return __dir_path__",
"def scriptpath(self, code) -> str:\n return ''",
"def OutputRoot(self):\n return os.path.join(self._module.workspace, 'broc_out')",
"def location(self):\n\n p = os.path.abspath(__file__)\n pathSP = os.path.split(p)\n return pathSP",
"def executable():\n return sys.executable"
] | [
"0.682036",
"0.6652295",
"0.65895194",
"0.6584268",
"0.6460019",
"0.64083457",
"0.63974833",
"0.6339136",
"0.6329058",
"0.63127565",
"0.6281566",
"0.6236012",
"0.6232723",
"0.62326777",
"0.6230347",
"0.61885166",
"0.6138241",
"0.61246544",
"0.6089618",
"0.6089618",
"0.60891604",
"0.6067412",
"0.60656154",
"0.6032475",
"0.6023596",
"0.6005696",
"0.59991974",
"0.59912395",
"0.5980514",
"0.59742695",
"0.59724283",
"0.5959657",
"0.59116983",
"0.59116983",
"0.5900881",
"0.5900239",
"0.5888726",
"0.5874622",
"0.5874246",
"0.58733857",
"0.5859068",
"0.5842803",
"0.5817162",
"0.5801924",
"0.57993734",
"0.57981706",
"0.5797708",
"0.57939947",
"0.579257",
"0.5784197",
"0.5782672",
"0.57665163",
"0.57607216",
"0.5759113",
"0.575828",
"0.5750003",
"0.57346493",
"0.57283944",
"0.57197344",
"0.57137144",
"0.5712906",
"0.57111484",
"0.57107985",
"0.57021177",
"0.56980467",
"0.56979275",
"0.5693652",
"0.56799394",
"0.5678421",
"0.56772685",
"0.5676847",
"0.5670819",
"0.56672424",
"0.56554556",
"0.5649154",
"0.5645815",
"0.5641834",
"0.5641257",
"0.563862",
"0.5635873",
"0.5633799",
"0.5631946",
"0.5622377",
"0.5621239",
"0.56033623",
"0.5600863",
"0.5600307",
"0.55971545",
"0.5594062",
"0.55882007",
"0.55880535",
"0.5581804",
"0.5580008",
"0.5578353",
"0.55626357",
"0.55599153",
"0.5558654",
"0.55578643",
"0.5555704",
"0.5554733"
] | 0.7753057 | 0 |
Check if the current view is an OCaml source code. | def is_ocaml(view):
ocaml = 'source.ocaml'
mlfi = 'source.mlfi'
location = view.sel()[0].begin()
return view.match_selector(location, ocaml) or view.match_selector(location, mlfi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_non_js_source(self):\n self.view.set_syntax_file(\"Packages/Python/Python.tmLanguage\")\n\n actual = is_js_source(self.view)\n\n self.assertFalse(actual)",
"def test_js_source(self):\n actual = is_js_source(self.view)\n\n self.assertTrue(actual)",
"def is_authoring_source(view):\n if view.match_selector(0, \"text.hyperhelp.help\"):\n return not view.is_read_only()\n\n return False",
"def test_source(self):\n with open(__file__, 'r') as f:\n contents = f.read()\n\n lexer = syntax_highlighting.fetch_lexer(contents)\n self.assertIn(lexer.__class__.__name__, PYTHON_LEXER_CLASS_NAMES)",
"def has_code_module(self) -> bool:\n return self.module_info is not None",
"def has_source(self):\n return any(map(utils.assert_package_is_source, self.pkg_arguments))",
"def has_source_file( self ):\n return self._source_file is not None",
"def iscode(object):\r\n return isinstance(object, types.CodeType)",
"def menu_check_source_with_pychecker(self, event=None):\n if self.app.children:\n self.app.childActive.check_source_with_pychecker()",
"def only_ocaml(func):\n\n @functools.wraps(func)\n def wrapper(self, view, *args, **kwargs):\n if is_ocaml(view):\n return func(self, view, *args, **kwargs)\n\n return wrapper",
"def detect_rust(src):\n lines = []\n in_code_block = False\n start_of_code_block = 0\n\n for i, line in enumerate(src.splitlines()):\n if '```rust' in line:\n start_of_code_block = i\n in_code_block = True\n elif '```' in line and in_code_block:\n lines.append((start_of_code_block + 1, i - 1))\n in_code_block = False\n\n return lines",
"def is_local(self) -> bool:\n if not self.source:\n return False\n\n if self.source.master_name.startswith(MODULE_NAME):\n return True\n\n if self.is_type_defs():\n return True\n\n return False",
"def is_code(self) -> bool:\n return any(seg.is_code for seg in self.segments)",
"def is_scala(self):\r\n return self.has_label('scala')",
"def has_debug_view(name=None):\r\n for view in sublime.active_window().views():\r\n if is_debug_view(view):\r\n if name is not None:\r\n if view.name() == name:\r\n return True\r\n else:\r\n return True\r\n return False",
"def isrst(filename):\n return filename[-4:] == '.rst'",
"def is_builtins(self) -> bool:\n return self.source.startswith(self.builtins_import_string)",
"def is_codegen(self):\r\n return self.has_label('codegen')",
"def test_link_to_source(\n self,\n _needs_unindent,\n _is_source_requested,\n _get_source_code_from_object,\n ):\n _needs_unindent.return_value = False\n _is_source_requested.return_value = True\n _get_source_code_from_object.return_value = \"\"\n\n data = (\n os.path.join(\n _CURRENT_DIRECTORY,\n \"fake_project\",\n \"_modules\",\n \"fake_project\",\n \"basic.html\",\n ),\n \"MyKlass.get_method\",\n )\n content = self._get_fake_project_method()\n nodes = self._get_nodes(data, content) # pylint: disable=no-value-for-parameter\n\n self.assertEqual(2, len(nodes))\n self.assertTrue(any(node for node in nodes if isinstance(\n node,\n extension._SourceCodeHyperlink, # pylint: disable=protected-access\n )))",
"def is_module_object(self, obj):\n if not isinstance(obj, BaseException):\n try:\n c = obj.__class__\n source_file = inspect.getsourcefile(c)\n except (TypeError, AttributeError):\n pass\n else:\n if source_file and source_file.startswith(self.path):\n return True\n\n return False",
"def can_compile(src):\n src = src if src.endswith(\"\\n\") else src + \"\\n\"\n src = transform_command(src, show_diff=False)\n src = src.lstrip()\n try:\n XSH.execer.compile(src, mode=\"single\", glbs=None, locs=XSH.ctx)\n rtn = True\n except SyntaxError:\n rtn = False\n except Exception:\n rtn = True\n return rtn",
"def is_debug_view(view):\r\n return view.name() == TITLE_WINDOW_BREAKPOINT or view.name() == TITLE_WINDOW_CONTEXT or view.name() == TITLE_WINDOW_STACK or view.name() == TITLE_WINDOW_WATCH",
"def test_readme_text_directly(readme_path):\n code = []\n code_block = False\n\n with open(readme_path, 'r') as f:\n for line in f:\n if line.endswith(\"```\\n\"):\n code_block = False\n\n # Add all code lines except for the viz function.\n if code_block and not line.startswith('viz_neighbors_imgs'):\n code.append(line)\n\n if line.startswith(\"```python\"):\n code_block = True\n\n exec(('\\n').join(code))",
"def is_snippet(abbr, doc_type = 'html'):\n\treturn get_snippet(doc_type, abbr) and True or False",
"def isSource(self):\n return (len(self.parents()) == 0)",
"def can_trace_source(self, filename: str) -> bool:\n path = Path(filename)\n if not path.is_file():\n return False\n\n extension = path.suffix\n if extension in self.registered_compilers:\n compiler = self.registered_compilers[extension]\n if compiler.supports_source_tracing:\n return True\n\n # We are not able to get coverage for this file.\n return False",
"def is_python(self):\r\n return self.has_label('python')",
"def is_viewable(miscobj):\n return misctype_byname(miscobj.filetype).viewable",
"def _is_vim_object(self, module):\n return isinstance(module, vim.Vim)",
"def in_function_code(self):\n return self.lscope is not None and self.sscope is None",
"def test_mime_type_python(self):\n lexer = syntax_highlighting.fetch_lexer(\n '',\n mime_type='application/x-python'\n )\n self.assertIn(lexer.__class__.__name__, PYTHON_LEXER_CLASS_NAMES)",
"def is_view(self):\n return self._base is not None",
"def runsource(self, source, filename=\"<input>\", symbol=\"single\"):\n try:\n code = self.compile(source, filename, symbol)\n except (OverflowError, SyntaxError, ValueError):\n # Case 1\n self.showsyntaxerror(filename)\n return None\n\n if code is None:\n # Case 2\n return True\n\n # Case 3\n # We store the code source and object so that threaded shells and\n # custom exception handlers can access all this info if needed.\n self.code_to_run_src = source\n self.code_to_run = code\n # now actually execute the code object\n if self.runcode(code) == 0:\n return False\n else:\n return None",
"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 in_method_code(self):\n return self.mscope is not None",
"def source_code(obj):\n print(inspect.getsource(obj))",
"def is_viewvc(self):\n if self.path == '/' + options.script_alias:\n return 1\n if self.path[:len(options.script_alias)+2] == \\\n '/' + options.script_alias + '/':\n return 1\n if self.path[:len(options.script_alias)+2] == \\\n '/' + options.script_alias + '?':\n return 1\n return 0",
"def view_source_js(fn): #py:view_source_js\n RUR._view_source_js_(fn)",
"def show_source(request, game_id):\n\n #get the game object\n game = Game.objects.get(id=game_id)\n if game is None:\n raise Exception(\"In show_source: Wrong game_id given\")\n\n #get the language\n lang = game.judge_lang\n \n #get the source code of judge\n judge = game.judge_source_file\n line = judge.readline()\n source = []\n while line:\n line = line[:-1] #get rid of \\n char\n parsed_line = parse_line(line, lang)\n\n source.append(parsed_line)\n line = judge.readline()\n\n #parse code according to language rules\n #find key words\n\n #find comments\n\n #find strings\n\n #find procedure names\n\n return render_to_response('gaming/show_source.html',\n {\n 'source':source,\n },\n context_instance=RequestContext(request))",
"def is_code(self, address):\n return self.is_address_of_type(address, MemoryType.Code)",
"def findsource(obj):\n filename = inspect.getsourcefile(obj)\n if filename:\n linecache.checkcache(filename)\n return inspect.findsource(obj)",
"def is_code_section(addr):\n # The image file is considered all instructions, it is just a raw binary\n # image starting at 0.\n for section_addr, section_name in section_addrs.items(): \n if (section_name == '.text') or (\n section_name == 'image') or (\n section_name == 'reset') or (\n section_name == '.init'):\n code_start = section_addr\n code_bytes = int(section_bytes[section_name])\n code_end = code_start + code_bytes\n if code_start <= addr < code_end:\n return True\n\n return False",
"def get_as_source(self):\n if self.as_source:\n return True\n if self.allow_source_from_get and self.request.GET.get('src', False):\n return True\n if self.allow_source_from_post and self.request.POST.get('src', False):\n return True\n return False",
"def get_code():\n return inspect.getsource(is_palindrome)",
"def is_public(self) -> bool:\n # Here we'll do the most common logic, and let specific constructs that\n # can be public do special logic.\n if self.node.location.file.name.endswith(\".h\"):\n return True\n\n return False",
"def ismodule(object):\r\n return isinstance(object, types.ModuleType)",
"def isLibSBMLCompiledWith(*args):\n return _libsbml.isLibSBMLCompiledWith(*args)",
"def isCode(self, lineData, column):\n return self._getTextType(lineData, column) == ' '",
"def is_python_file(path):\n valid = False\n\n if os.path.isfile(path) and path.endswith('.py'):\n valid = True\n\n return valid",
"def is_valid_python(code: str) -> bool:\n try:\n ast.parse(code)\n except SyntaxError:\n return False\n return True",
"def editor_is_executable(editor):\n\teditor_split = util.shlex_split(editor)\n\tif not editor_split:\n\t\treturn False\n\tfilename = editor_split[0]\n\tif not os.path.isabs(filename):\n\t\treturn find_binary(filename) is not None\n\treturn os.access(filename, os.X_OK) and os.path.isfile(filename)",
"def _coconut_compile(self, source, *args, **kwargs):\n if source.endswith(\"\\n\\n\"):\n return True\n elif should_indent(source):\n return None\n else:\n return True",
"async def source(self, ctx):\n \"\"\" Check out my source code <3 \"\"\"\n # Do not remove this command, this has to stay due to the GitHub LICENSE.\n # TL:DR, you have to disclose source according to MIT.\n # Reference: https://github.com/AlexFlipnote/discord_bot.py/blob/master/LICENSE\n await ctx.send(f\"**{ctx.bot.user}** is powered by this source code:\\nhttps://github.com/AlexFlipnote/discord_bot.py With modifications by user: snow-blade\")",
"def source(self):\n return self._source_code",
"def check_source(self,source): \n\n kind = None\n if os.path.exists(source):\n if os.path.isfile(source):\n kind = \"file\"\n elif os.path.isdir(source):\n kind = \"dir\"\n else:\n print(\" Source path : \\n{}\\n Does not exist...\\n\".format(source))\n #print(\" Sys.exit() called by : {}\".format())\n sys.exit()\n\n return kind",
"def _read_code(self):\n\n if self.fileType == FTPythonCompiled:\n # It's a pyc file; just read it directly.\n pycVfile = vfs.getFile(self.filename, False)\n if pycVfile:\n return self._loadPyc(pycVfile, None)\n return None\n\n elif self.fileType == FTCompiledModule:\n return None\n\n # It's a .py file (or an __init__.py file; same thing). Read\n # the .pyc file if it is available and current; otherwise read\n # the .py file and compile it.\n pycFilename = Filename(self.filename)\n pycFilename.setExtension(pycExtension)\n pycVfile = vfs.getFile(pycFilename, False)\n t_pyc = None\n if pycVfile:\n t_pyc = pycVfile.getTimestamp()\n\n code = None\n if t_pyc and t_pyc >= self.timestamp:\n code = self._loadPyc(pycVfile, self.timestamp)\n\n if not code:\n source = self._read_source()\n filename = Filename(self.filename)\n filename.setExtension('py')\n code = self._compile(filename, source)\n\n return code",
"def code(self):\n code = self._code\n if code is None:\n raise IOError('source code not available')\n return code",
"def code(self):\n code = self._code\n if code is None:\n raise IOError('source code not available')\n return code",
"def is_view_and_comment(self):\n return self._tag == 'view_and_comment'",
"def is_enabled_haskell_command(view = None, must_be_project=True, must_be_main=False, must_be_file = False):\n window, view, file_shown_in_view = get_haskell_command_window_view_file_project(view)\n\n if not window or not view:\n return False\n\n if must_be_file and not file_shown_in_view:\n return False\n\n syntax_file_for_view = view.settings().get('syntax').lower()\n if 'haskell' not in syntax_file_for_view:\n return False\n\n if not must_be_project:\n return True\n\n cabal_project_dir = get_cabal_project_dir_of_view(view)\n if not cabal_project_dir:\n return False\n return True",
"def doGetPageSource(self, timeout=10.0):\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\n \n ret = True\n cmdId = self.getPageSource()\n rsp = self.hasSource(timeout=timeout, commandId=cmdId)\n if rsp is None:\n ret = False\n else:\n elementVall = rsp.get('GUI', 'value')\n ret = elementVall.get('value') # code source of the window\n return ret",
"def __is_file_eligible_to_scan(cls, path_to_test):\n return path_to_test.endswith(\".md\")",
"def has_path_source(self) -> bool:\n\n return any(self.is_path_type(x) for x in self.parameters)",
"def in_struct_code(self):\n return self.mscope is None and self.sscope is not None",
"def isHandled(self, actionType, source):\n handledActions = {\"modified\", \"created\"}\n return actionType in handledActions\\\n and source.startswith(self.projectPath)\\\n and os.path.isfile(source)",
"def is_py_script(item: str):\n is_it_py_script : bool = False\n ext : str = \".py\"\n if ext in item:\n is_it_py_script = True\n ...\n\n return is_it_py_script\n ...",
"def _source_type(self):\n pass",
"def GoogleCode_Exists(wikifier, wikipage):\n path = os.path.join(wikifier.srcdir, \"%s.wiki\" % wikipage)\n if os.path.exists(path):\n return True\n return False",
"def preprocess_python_source(self, module, source):\n\n return source",
"def _is_sql_lab_pvm(self, pvm: PermissionView) -> bool:\n return (pvm.permission.name, pvm.view_menu.name) in self.SQLLAB_PERMISSION_VIEWS",
"def looks_like_a_filename(kernel_source):\n result = False\n if isinstance(kernel_source, str):\n result = True\n #test if not too long\n if len(kernel_source) > 250:\n result = False\n #test if not contains special characters\n for c in \"();{}\\\\\":\n if c in kernel_source:\n result = False\n #just a safeguard for stuff that looks like code\n for s in [\"__global__ \", \"__kernel \", \"void \", \"float \"]:\n if s in kernel_source:\n result = False\n #string must contain substring \".c\", \".opencl\", or \".F\"\n result = result and any([s in kernel_source for s in (\".c\", \".opencl\", \".F\")])\n return result",
"def _in_ipython(self):\n import graphlab.canvas.target\n return isinstance(graphlab.canvas.get_target(), graphlab.canvas.target.IPythonTarget)",
"def is_devel(self):\r\n\r\n return self.is_debug()",
"def isbuiltin(object):\n if inspect.isbuiltin(object):\n return True\n\n return getattr(object, '__module__', None) == 'builtins'",
"def isPublic(self, code) -> bool:\n return True",
"def is_module(obj):\n return type(obj) is types.ModuleType",
"async def source(ctx, command: Option(str, \"The command to view the source code for\", required=False)):\n source_url = 'https://github.com/Pycord-Development/robocord'\n branch = 'main'\n view = discord.ui.View()\n if command is None:\n url = source_url\n label = \"Source code for entire bot\"\n else:\n command_split = command.split()\n index = 0\n obj = discord.utils.get(bot.application_commands.values(), name=command_split[index])\n while isinstance(obj, SlashCommandGroup):\n if index + 1 > len(command_split):\n return await ctx.respond(\"Error: Command is a group. You must choose a subcommand from it.\")\n obj = discord.utils.get(obj.subcommands, name=command_split[index])\n if not isinstance(obj, SlashCommand):\n return await ctx.respond(\"Error: Command could not be found\")\n # noinspection PyUnresolvedReferences\n src = obj.callback.__code__\n filename = src.co_filename\n lines, firstlineno = inspect.getsourcelines(src)\n location = os.path.relpath(filename).replace('\\\\', '/')\n\n url = f'{source_url}/blob/{branch}/{location}#L{firstlineno}-L{firstlineno + len(lines) - 1}'\n content = await discord.ext.commands.clean_content(escape_markdown=True).convert(ctx, command)\n label = f'Source code for command \"{content}\"'\n view.add_item(discord.ui.Button(label=\"View Code\", url=url))\n await ctx.respond(label, view=view)",
"def _validate_built_in(self, tipo):\n\n self.source_type = False\n self.source_file = \"builtin\"\n return tipo in self.c_built_ins or self._match_array(tipo, self.c_built_in_array_types)",
"def python_module(self) -> ModuleType:\n if self._python_module is None:\n # See: https://github.com/linkml/linkml/issues/1219\n src = self.schemaview.schema.source_file\n if not src:\n src = self.schemaview.schema\n pygen = PythonGenerator(src)\n self._python_module = pygen.compile_module()\n return self._python_module",
"def is_candidate(line):\n line = line.lower()\n line = prepare_text_line(line)\n return (has_content(line) and any(s in line for s in copyrights_hint.statement_markers))",
"def in_global_code(self):\n return self.sscope is None and self.lscope is None",
"def is_cpp(benchmark):\n return get_language(benchmark) == 'c++'",
"def include_source_files(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"include_source_files\")",
"def _check_scene_open(self):\n return self._engine.current_file_path() is not None",
"def is_in_studio(self):\n return getattr(self.xmodule_runtime, 'is_author_mode', False)",
"def is_source_prefix_mangled(self):\n return self._source_prefix_mangled",
"def is_embedded(request):\n hx_current_url = request.headers.get('HX-Current-URL', None)\n if not hx_current_url:\n return False\n return request.path != urlparse(hx_current_url).path",
"def is_cpp(filename: Path) -> bool:\n from fnmatch import fnmatch\n\n return any(fnmatch(os.path.basename(filename), p) for p in CPP_PATTERNS)",
"def is_view_loaded(view):\n\n if not G.AGENT:\n return\n if not G.AGENT.joined_workspace:\n return\n if view.is_loading():\n return\n\n buf = get_buf(view)\n if not buf or buf.get('buf') is None:\n return\n\n return buf",
"def is_source_prefix_mangled(self):\n return False",
"def is_votable(source):\n if isinstance(source, str):\n source = os.path.expanduser(source)\n try:\n with iterparser.get_xml_iterator(source) as iterator:\n for start, tag, d, pos in iterator:\n if tag != \"xml\":\n return False\n break\n\n for start, tag, d, pos in iterator:\n if tag != \"VOTABLE\":\n return False\n break\n\n return True\n except ValueError:\n return False",
"def source(self):\n return some.dap.source(py.path.local(self.co_filename))",
"def _filter(self, path):\n return path.endswith('.py')",
"def IsPackage(path):\n init_base_path = os.path.join(path, '__init__.py')\n return (os.path.isfile(init_base_path) or\n os.path.isfile(init_base_path + 'c') or\n os.path.isfile(init_base_path + 'o'))",
"def test_0_check_xc_docstring(self):\n self.banner(\"Checking the docstring on your extra credit.\") \n filename = self.find_file('project9_xc.py')\n self.check_docstring(filename)",
"def startPythonEditor(py_filename, *args, **kwargs):\n log_func.info(u'GTK library version: %s' % gi.__version__)\n\n result = False\n win = None\n try:\n win = iqStartPyWindow()\n win.py_filename = py_filename\n new_title = _(u'Python module') + ' <%s>' % os.path.basename(py_filename)\n win.getGtkTopObject().set_title(new_title)\n win.init()\n win.getGtkTopObject().show_all()\n result = True\n except:\n log_func.fatal(u'Error open window <start_py_window>')\n\n gi.repository.Gtk.main()\n\n if win and win.getGtkTopObject() is not None:\n win.getGtkTopObject().destroy()\n return result",
"def has_sources(self, extension=None):\r\n # TODO(John Sirois): track down the reason for this hack and kill or explain better.\r\n return extension is None",
"def isprogram(self):\n return True",
"def exists(_env):\n detector = DetectCompiler()\n if detector['icx'] is None:\n return False\n return True",
"def cppdef(src):\n with _stderr_capture() as err:\n errcode = gbl.gInterpreter.Declare(src)\n if not errcode:\n raise SyntaxError('Failed to parse the given C++ code%s' % err.err)\n return True"
] | [
"0.67141247",
"0.61287296",
"0.59936684",
"0.59469485",
"0.59078604",
"0.5851658",
"0.5787282",
"0.5709476",
"0.5676872",
"0.5662873",
"0.56603956",
"0.55736876",
"0.5511895",
"0.5484196",
"0.5424797",
"0.54031396",
"0.53450185",
"0.53424245",
"0.52996314",
"0.5279858",
"0.525761",
"0.5245247",
"0.52412075",
"0.52340233",
"0.51985896",
"0.51962364",
"0.51931393",
"0.5138563",
"0.51350427",
"0.5131118",
"0.5115699",
"0.51125604",
"0.5098941",
"0.5097969",
"0.5092805",
"0.50584334",
"0.5051037",
"0.50497717",
"0.5026958",
"0.5006792",
"0.49856567",
"0.49677134",
"0.49590176",
"0.4947269",
"0.49463698",
"0.49446672",
"0.49414185",
"0.49301845",
"0.49262297",
"0.49248263",
"0.49229118",
"0.49223334",
"0.49153495",
"0.4907612",
"0.4903625",
"0.48855093",
"0.48697147",
"0.48697147",
"0.4868047",
"0.48650798",
"0.48628086",
"0.4853646",
"0.4849645",
"0.48437512",
"0.4828753",
"0.4809873",
"0.48050123",
"0.48002353",
"0.4789693",
"0.47896194",
"0.4780407",
"0.47797015",
"0.47795856",
"0.47793788",
"0.47718832",
"0.4767632",
"0.47388446",
"0.4731879",
"0.47291768",
"0.47187206",
"0.47168875",
"0.47160563",
"0.47159457",
"0.47058177",
"0.47013626",
"0.46998173",
"0.46960202",
"0.4692209",
"0.46900165",
"0.46876642",
"0.46835607",
"0.4671412",
"0.46673745",
"0.46628317",
"0.4662411",
"0.4653587",
"0.46438736",
"0.46424752",
"0.4641466",
"0.4638949"
] | 0.69519085 | 0 |
Execute the given function if we are in an OCaml source code only. | def only_ocaml(func):
@functools.wraps(func)
def wrapper(self, view, *args, **kwargs):
if is_ocaml(view):
return func(self, view, *args, **kwargs)
return wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main_code():\n pass",
"def in_function_code(self):\n return self.lscope is not None and self.sscope is None",
"def runsource(self, source, filename=\"<input>\", symbol=\"single\"):\n try:\n code = self.compile(source, filename, symbol)\n except (OverflowError, SyntaxError, ValueError):\n # Case 1\n self.showsyntaxerror(filename)\n return None\n\n if code is None:\n # Case 2\n return True\n\n # Case 3\n # We store the code source and object so that threaded shells and\n # custom exception handlers can access all this info if needed.\n self.code_to_run_src = source\n self.code_to_run = code\n # now actually execute the code object\n if self.runcode(code) == 0:\n return False\n else:\n return None",
"def aFunction():\n return True",
"def main(source):\n pass",
"def code():",
"def Exec_Python(code):\n # pylint: disable=exec-used\n try:\n exec(code, globals())\n # pylint: disable=broad-except\n # pylint: disable=bare-except\n except:\n _LOGGER.error('Execution of following code has failed %s', code)\n return False\n return True",
"def _test():\n if sys.argv[1:]:\n if sys.argv[2:]:\n sys.stderr.write(\"usage: python dis.py [-|file]\\n\")\n sys.exit(2)\n fn = sys.argv[1]\n if not fn or fn == \"-\":\n fn = None\n else:\n fn = None\n if fn is None:\n f = sys.stdin\n else:\n f = open(fn)\n source = f.read()\n if fn is not None:\n f.close()\n else:\n fn = \"<stdin>\"\n code = compile(source, fn, \"exec\")\n dis(code)",
"def gen_function(self, function):\n if function.body:\n self.gen_function_def(function)",
"def test_readme_text_directly(readme_path):\n code = []\n code_block = False\n\n with open(readme_path, 'r') as f:\n for line in f:\n if line.endswith(\"```\\n\"):\n code_block = False\n\n # Add all code lines except for the viz function.\n if code_block and not line.startswith('viz_neighbors_imgs'):\n code.append(line)\n\n if line.startswith(\"```python\"):\n code_block = True\n\n exec(('\\n').join(code))",
"def _func_only(func):\n if inspect.isfunction(func):\n return\n else:\n raise Exception(\"Only functions can be tasks\")",
"def test_blockly_callback(code):\n #\n module = types.ModuleType(\"module\")\n # compile into ast (use <string> as a filename)\n ast = compile(code, filename=\"<string>\", mode=\"exec\")\n # execute the code in the context of the module\n exec(ast, module.__dict__)\n # call the function\n result = module.callback()\n assert result == \"callback called\"",
"def visit_Python(self, node):\n py_code = compile(node.py_ast, self.filename, mode='exec')\n bp_code = Code.from_code(py_code)\n # Skip the SetLineo and ReturnValue codes\n self.code_ops.extend(bp_code.code[1:-2])",
"def my_function():\n pass",
"def my_function():\n pass",
"def my_function():\n pass",
"def my_function():\n pass",
"def my_function():\n pass",
"def my_function():\n pass",
"def my_function():\n pass",
"def my_function():\n pass",
"def is_function(self):\n line = self.line.strip()\n if line.startswith('fu'):\n if line.startswith('function') is False:\n return True",
"def get_function_code(f):\n assert isinstance(f, types.FunctionType)\n function_name = f.__code__.co_name\n assert isinstance(function_name, str)\n\n if in_jupyter_notebook() or in_google_colab():\n return extract_function_code(function_name, get_jupyter_raw_code(function_name))\n else:\n return extract_function_code(function_name, dill.source.getsource(f))",
"def my_func():\n pass",
"def ignore_builtin_verification():\n return not current_space().skip_builtin_verification",
"def get_code(func):\n import inspect\n\n raw = \"\".join(inspect.getsource(func))\n found = re.findall(\"(k = .*)\", raw)\n\n if any(found):\n code = found[0]\n return code\n else:\n return \"\"",
"def my_function():\n\tpass",
"def print_code(func):\n print(inspect.getsource(func))",
"def automain(self, function):\n captured = self.main(function)\n if function.__module__ == '__main__':\n self.run_commandline()\n return captured",
"def python_code_markdown(func: Callable) -> str:\n return \"\"\"\n ```python\n \"\"\" + inspect.getsource(func) + \"\"\"\n ```\n \"\"\"",
"def my_fuction():\n pass",
"def somefunc():",
"def my_function1():\n \n ## Your code here\n ## Add comments to clarify what the code is doing",
"def func():\n pass",
"def exec_function(self, args):\n raise NotImplementedError()",
"def isLibSBMLCompiledWith(*args):\n return _libsbml.isLibSBMLCompiledWith(*args)",
"def source_to_code(self, data, path):\n\t\treturn _call_with_frames_removed(compile, data, path, 'exec', dont_inherit=True)",
"def does_it_run(func, args):\n \n if args is None:\n func()\n else:\n func(*args)",
"def aFunction2():\n return True",
"def isFunction(self, *args):\n return _libsbml.ASTBasePlugin_isFunction(self, *args)",
"def cppdef(src):\n with _stderr_capture() as err:\n errcode = gbl.gInterpreter.Declare(src)\n if not errcode:\n raise SyntaxError('Failed to parse the given C++ code%s' % err.err)\n return True",
"def debuggable(f):\n \n debugging = f.func_globals.get(\"DEBUGGING\",False)\n if debugging: return f\n\n f.func_code = __transform_codeobjects__(f.func_code,__debuggable__)\n return f",
"def can_compile(src):\n src = src if src.endswith(\"\\n\") else src + \"\\n\"\n src = transform_command(src, show_diff=False)\n src = src.lstrip()\n try:\n XSH.execer.compile(src, mode=\"single\", glbs=None, locs=XSH.ctx)\n rtn = True\n except SyntaxError:\n rtn = False\n except Exception:\n rtn = True\n return rtn",
"def test_all_functions_implemented():\n code_lines = inspect.getsource(s7)\n FUNCS_IMPL = True\n for c in CHECK_FOR_FUNCT_IMPL:\n if c not in code_lines:\n print(c)\n FUNCS_IMPL = False\n break\n assert FUNCS_IMPL is True, 'You forgot to implement all functions! Try again!'",
"def my_function():\n\treturn 42",
"def is_function_program(item):\n return find_by_layering(\n item,\n [syntax.PROGRAM, [TOP_LEVEL, syntax.EXPR_SEQ], syntax.FUNCTION_DEF]) is not None",
"def example_function_in_example_module():\n pass",
"def exec_(_code_, _globs_=None, _locs_=None):\n if _globs_ is None:\n frame = sys._getframe(1)\n _globs_ = frame.f_globals\n if _locs_ is None:\n _locs_ = frame.f_locals\n del frame\n elif _locs_ is None:\n _locs_ = _globs_\n exec(\"\"\"exec _code_ in _globs_, _locs_\"\"\")",
"def exec_(_code_, _globs_=None, _locs_=None):\n if _globs_ is None:\n frame = sys._getframe(1)\n _globs_ = frame.f_globals\n if _locs_ is None:\n _locs_ = frame.f_locals\n del frame\n elif _locs_ is None:\n _locs_ = _globs_\n exec(\"\"\"exec _code_ in _globs_, _locs_\"\"\")",
"def exec_(_code_, _globs_=None, _locs_=None):\n if _globs_ is None:\n frame = sys._getframe(1)\n _globs_ = frame.f_globals\n if _locs_ is None:\n _locs_ = frame.f_locals\n del frame\n elif _locs_ is None:\n _locs_ = _globs_\n exec(\"\"\"exec _code_ in _globs_, _locs_\"\"\")",
"def main():\n pass\n\n if __name__ == \"__main)__\":\n main()",
"def main():\n parser = ArgumentParser(description=__doc__,\n formatter_class=RawTextHelpFormatter)\n parser.add_argument('code', help='Python code to execute')\n group = parser.add_mutually_exclusive_group()\n group.add_argument('-3', action='store_const', dest='python',\n const='python3', help='Explicitly use Python 3')\n group.add_argument('-2', action='store_const', dest='python',\n const='python2', help='Explicitly use Python 2')\n group.add_argument('-p', '--python', help='Specify python interpreter')\n args = parser.parse_args()\n if args.python is not None:\n call([args.python, __file__, args.code])\n else:\n InteractiveInterpreter(LocalsImportDict()).runsource(args.code)",
"def function_is_noop(function_node: ast.FunctionDef) -> bool:\n return all(node_is_noop(n) for n in function_node.body)",
"def lua_test():\n pass",
"def evaluateCode(lang, code):",
"def _compile(self, source: str, filename: str) -> CodeType:\n return compile(source, filename, \"exec\") # type: ignore",
"def exec_(_code_, _globs_=None, _locs_=None):\r\n if _globs_ is None:\r\n frame = sys._getframe(1)\r\n _globs_ = frame.f_globals\r\n if _locs_ is None:\r\n _locs_ = frame.f_locals\r\n del frame\r\n elif _locs_ is None:\r\n _locs_ = _globs_\r\n exec(\"\"\"exec _code_ in _globs_, _locs_\"\"\")",
"def exec_(_code_, _globs_=None, _locs_=None):\r\n if _globs_ is None:\r\n frame = sys._getframe(1)\r\n _globs_ = frame.f_globals\r\n if _locs_ is None:\r\n _locs_ = frame.f_locals\r\n del frame\r\n elif _locs_ is None:\r\n _locs_ = _globs_\r\n exec(\"\"\"exec _code_ in _globs_, _locs_\"\"\")",
"def exec_(_code_, _globs_=None, _locs_=None):\r\n if _globs_ is None:\r\n frame = sys._getframe(1)\r\n _globs_ = frame.f_globals\r\n if _locs_ is None:\r\n _locs_ = frame.f_locals\r\n del frame\r\n elif _locs_ is None:\r\n _locs_ = _globs_\r\n exec(\"\"\"exec _code_ in _globs_, _locs_\"\"\")",
"def Cpp_test():\n pass",
"def main_function():\n return 1",
"def dummy_code_block() -> CodeBlock:\n return make_dummy_code_block()",
"def _is_function(self, words):\n if words[0] == 'function':\n if len(words) != 3:\n raise SyntaxError(\"File line {}: Invalid number of arguments for C_FUNCTION command.\".format(self._file_line))\n return True\n else:\n return False",
"def foo():\r\n pass",
"def psource(*functions):\n source_code = '\\n\\n'.join(getsource(fn) for fn in functions)\n try:\n from pygments.formatters import HtmlFormatter\n from pygments.lexers import PythonLexer\n from pygments import highlight\n\n display(HTML(highlight(source_code, PythonLexer(), HtmlFormatter(full=True))))\n\n except ImportError:\n print(source_code)",
"def foo():\n pass",
"def foo():\n pass",
"def visit_Python(self, node):\n # This compiles the given Python ast into a Python code object\n # then disassembles it into a byteplay code object. This allows\n # us to interleave the instructions with those generated for\n # the rest of the module and then compile a single unified \n # code object.\n py_code = compile(node.py_ast, self.filename, mode='exec')\n bpc = Code.from_code(py_code)\n # Skip the SetLineo and ReturnValue codes\n self.code_ops.extend(bpc.code[1:-2])",
"def A(arg1, arg2):\n # +++your code here+++\n return None",
"def aFunction3():\n return True",
"def deferrable(function):\n\n def pseudocore(*args, **kwargs):\n yield function(*args, **kwargs)\n\n return function if isinstance(function, Routine) else routine(pseudocore)",
"def executeIf(tree,file):\n if(evalBoolean(tree.children[0])):\n explore(tree.children[1],file)",
"def get_code(self, fullmodname):\n submodname, is_package, fullpath, source = self._get_source(fullmodname)\n return compile(source, fullpath, 'exec')",
"def process_module(self, node):\n code = node.file_stream.read()\n\n try:\n tree = compile(code, node.file, \"exec\", ast.PyCF_ONLY_AST)\n except SyntaxError:\n # Pylint would have already failed\n return\n\n McCabeChecker.max_complexity = self.max_complexity\n results = McCabeChecker(tree, node.file).run()\n for lineno, _, text, _ in results:\n text = text[5:]\n self.add_message('C0901', line=lineno, args=text)",
"def exec_builtin(self, cmd):\r\n func = Builtin.builtins.get(cmd[0])\r\n if func is None:\r\n return False\r\n func(self, cmd)\r\n return True",
"def create_test_function(source, output, lang):\n with open(source) as f:\n snippet = f.read()\n with open(output) as f:\n res = f.read()\n\n def tst_func(slf):\n slf.do(snippet, res, lang=lang)\n\n return tst_func",
"def __def_function__():\n pass",
"def test_non_js_source(self):\n self.view.set_syntax_file(\"Packages/Python/Python.tmLanguage\")\n\n actual = is_js_source(self.view)\n\n self.assertFalse(actual)",
"def fixupFunctionBody(program: ghidra.program.model.listing.Program, func: ghidra.program.model.listing.Function, monitor: ghidra.util.task.TaskMonitor) -> bool:\n ...",
"def preprocess_python_source(self, module, source):\n\n return source",
"def _coconut_compile(self, source, *args, **kwargs):\n if source.endswith(\"\\n\\n\"):\n return True\n elif should_indent(source):\n return None\n else:\n return True",
"def test_86_entry_point(self):\n\t\tinput = \"\"\"function main():boolean; begin return true; end\"\"\"\n\t\texpect = \"No entry point\"\n\t\tself.assertTrue(TestChecker.test(input,expect,486))",
"def is_function(self):\n return False",
"def run_function(function_id):\n\n language = sys.modules[__name__] # to be used by the getattr\n\n global funcs\n funcName = funcs[function_id][1] # get the function name from the global dictionary funcs\n getattr(language, funcName)() #execute the chosen function",
"def has_code_module(self) -> bool:\n return self.module_info is not None",
"def call_function( function_name: str ) -> None:\n log.debug( f'function_name, ```{function_name}```' )\n checker = OpenTextbookChecker()\n safe_dispatcher = { 'build_keys': build_keys, 'check_opentextbook': checker.check_opentextbook }\n try:\n safe_dispatcher[function_name]()\n except:\n raise Exception( 'invalid function' )\n return",
"def readin(pythonfilename):\n with open(pythonfilename) as f:\n code = f.read()\n FuncLister().visit(ast.parse(code))",
"def mandatory_source_file(func):\n\n @click.argument(\n \"source_file\", nargs=1, required=True,\n type=click.Path(exists=True, resolve_path=True, file_okay=True, dir_okay=False, )\n )\n @wraps(func)\n def wrapped(*args, **kwargs):\n return func(*args, **kwargs)\n return wrapped",
"def get_source(f):\n\n if isinstance(f, types.FunctionType):\n\n # lambda function?\n # use inspect module\n # need to clean out lambda...\n if f.__name__ == '<lambda>':\n # interpreter in interactive mode or not?\n # beware jupyter notebook also returns true for interactive mode!\n if is_in_interactive_mode() and not in_jupyter_notebook() and not in_google_colab():\n\n # import here, avoids also trouble with jupyter notebooks\n from tuplex.utils.interactive_shell import TuplexShell\n\n # for this to work, a dummy shell has to be instantiated\n # through which all typing occurs. Thus, the history can\n # be properly captured for source code lookup.\n # shell is a borg object, i.e. singleton alike behaviour\n shell = TuplexShell()\n return shell.get_lambda_source(f)\n else:\n # does lambda have globals?\n # if yes, then extract won't work IFF there's more than one lambda per line!\n # => display warning then.\n # => change hashing method...\n f_globs = get_globals(f)\n f_filename = f.__code__.co_filename\n f_lineno = f.__code__.co_firstlineno\n f_colno = f.__code__.co_firstcolno if hasattr(f.__code__, 'co_firstcolno') else None\n\n src_info = inspect.getsourcelines(f)\n\n vault.extractAndPutAllLambdas(src_info,\n f_filename,\n f_lineno,\n f_colno,\n f_globs)\n return vault.get(f, f_filename, f_lineno, f_colno, f_globs)\n else:\n # works always, because functions can be only defined on a single line!\n return get_function_code(f)\n else:\n\n # TODO: for constants, create dummy source code, i.e. lambda x: 20\n # when desired to retrieve a constant or so!\n\n return ''",
"def is_glsl_block_function(op):\n return isinstance(op, GlslBlockFunction)",
"def test_31_if(self):\n\t\tinput = \"\"\"procedure main(); var x:integer; begin x:=foo(); end\n\t\tfunction foo():integer; var a:real; begin\n\t\tif a>0 then return 0;\n\t\tend\"\"\"\n\t\texpect = \"Function foo Not Return\"\n\t\tself.assertTrue(TestChecker.test(input,expect,431))",
"def preprocess_for_clml(mod):\n\n for _var in mod.get_global_vars():\n if _var.name_hint == \"main\":\n continue\n fn = mod[_var.name_hint]\n if \"Compiler\" in fn.attrs.keys() and fn.attrs[\"Compiler\"] == \"clml\":\n new_fn = fn.body\n clml_mod = tvm.IRModule.from_expr(new_fn)\n with tvm.transform.PassContext(opt_level=3):\n clml_mod = preprocess_module(clml_mod)\n new_body = clml_mod[\"main\"].body\n mod[_var.name_hint] = _function.Function(\n fn.params, new_body, fn.ret_type, fn.type_params, fn.attrs\n )\n return mod",
"def is_codegen(self):\r\n return self.has_label('codegen')",
"def execute(self, source):\n tree = ast.parse(source=source)\n self._execute(body=tree.body[:-1], mode=\"exec\")\n self._execute(body=tree.body[-1:], mode=\"single\")",
"def test_module_doc():\r\n\r\n for fname in os.listdir('.'):\r\n if fname.endswith('.py'):\r\n f = fname.split('.')[0]\r\n print 'Executing ', fname\r\n execfile(fname, locals())",
"def __call__(fun_name):",
"def is_mod_function(mod, func):\n \n return inspect.isfunction(func) and inspect.getmodule(func) == mod",
"def isec(tree, known_ecs):\n return type(tree) is Call and getname(tree.func, accept_attr=False) in known_ecs",
"def test_noop_function_call(self) -> None:\n before = after = \"\"\"\n for line in xreadlines(r):\n print(line)\n \"\"\"\n self.assertCodemod(before, after)",
"def get_code():\n return inspect.getsource(is_palindrome)"
] | [
"0.61175025",
"0.59589654",
"0.5907236",
"0.57341886",
"0.57255304",
"0.5646994",
"0.5632915",
"0.55879843",
"0.55784357",
"0.5551663",
"0.55419976",
"0.5538157",
"0.5525979",
"0.54997593",
"0.54997593",
"0.54997593",
"0.54997593",
"0.54997593",
"0.54997593",
"0.54997593",
"0.54997593",
"0.5472104",
"0.5470877",
"0.5450619",
"0.5448971",
"0.5446835",
"0.5441624",
"0.5441549",
"0.5398603",
"0.5385526",
"0.53832096",
"0.53676575",
"0.53669375",
"0.53666073",
"0.5353917",
"0.5330323",
"0.5327949",
"0.5314259",
"0.5312998",
"0.53025514",
"0.52990705",
"0.52886",
"0.5281608",
"0.5281083",
"0.52683645",
"0.52673733",
"0.5266324",
"0.52600855",
"0.52600855",
"0.52600855",
"0.52594936",
"0.5251562",
"0.52366436",
"0.5232704",
"0.52313274",
"0.5230106",
"0.5225846",
"0.5225846",
"0.5225846",
"0.52253944",
"0.5206944",
"0.52060527",
"0.52000546",
"0.51854503",
"0.5178073",
"0.5177452",
"0.5177452",
"0.51739854",
"0.517277",
"0.51718193",
"0.51540905",
"0.5151546",
"0.51401234",
"0.5131731",
"0.51255673",
"0.5114737",
"0.5113718",
"0.50992405",
"0.5096642",
"0.5088363",
"0.5068899",
"0.506514",
"0.50505",
"0.50457156",
"0.50407064",
"0.50324047",
"0.5031383",
"0.50292623",
"0.5023925",
"0.5020944",
"0.502015",
"0.5017331",
"0.5015321",
"0.5013758",
"0.50136065",
"0.5003223",
"0.50011915",
"0.4995495",
"0.4993735",
"0.4992011"
] | 0.6008382 | 1 |
Convert a position returned by Merlin to a Sublime text point. Sublime uses character positions and starts each file at line 0. | def merlin_pos(view, pos):
return view.text_point(pos['line'] - 1, pos['col']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_position(tu, file, line, column):\r\n return conf.lib.clang_getLocation(tu, file, line, column)",
"def point2pos(self, point):\n row = self._vim.eval('byte2line({})'.format(point))\n col = self._vim.eval('{} - line2byte({})'.format(point, row))\n return (int(row), int(col))",
"def getPos(level):\n return str(STARTING_POS[level-1][0]) + \", \" + str(STARTING_POS[level-1][1])",
"def updatePosition(char, position):\n line, col = position\n return (line + 1, 1) if (char == '\\n') else (line, col + 1)",
"def get_cursor_pos(self):\n return (self.text_maker.pos[0] + 9, self.text_maker.pos[1] + 120 + 8)",
"def set_position():\n\n global character\n return character['Position']",
"def spot_coords(self,spot):\n if spot == '1':\n return (330 - 60 ,335 - 15)\n if spot == '2':\n return (419 - 60, 335 - 15)\n if spot == '3':\n return (591 - 60, 159 - 15)\n if spot == '4':\n return (588 - 60, 248 - 15)",
"def parsenwspt(text):\n lat = int(text[0:4]) / 100\n lon = int(text[4:])\n if lon < 1000:\n lon += 10000\n return (lon / -100, lat)",
"def GetSelection(self):\n # STC HELL\n # Translate the UTF8 byte offsets to unicode\n start, end = super(EditraBaseStc, self).GetSelection()\n utf8_txt = self.GetTextUTF8()\n if start != 0:\n start = len(ed_txt.DecodeString(utf8_txt[0:start], 'utf-8'))\n if end != 0:\n end = len(ed_txt.DecodeString(utf8_txt[0:end], 'utf-8'))\n del utf8_txt\n return start, end",
"def subl(filepath = None, line_number = 1, dirpath_lwc_root = None):\n if dirpath_lwc_root is None:\n dirpath_lwc_root = da.lwc.discover.path(key = 'root')\n\n filepath_subl = da.lwc.env.cli_path(\n dependency_id = 'subl',\n application_name = 'sublime_text',\n dirpath_lwc_root = dirpath_lwc_root)\n\n if filepath is None:\n logging.debug('Run sublime text')\n return _subprocess_call([filepath_subl])\n\n # The stack trace that is retrieved during the\n # handling of an Exception thrown from within\n # one of PyRun's built-in libraries may have\n # a stack trace that contains filenames of the\n # form \"<pyrun>/filename.py\". It is not possible\n # to open such files in the editor.\n #\n # Although this is an anomalous condition, we\n # do not expect the developer to take any\n # remedial action when it is encountered. We\n # therefore refrain from throwing an exception\n # and instead simply log the fact that it has\n # occurred and return normally.\n #\n # It is conceivable that other similar conditions\n # may be encountered, so as a piece of defensive\n # programming, we also take the same action if\n # the filepath parameter does not indicate a\n # valid file.\n if filepath.startswith('<pyrun>') or not os.path.isfile(filepath):\n logging.warning('Cannot open file: \"%s\"', filepath)\n return 1\n\n argument = '{filepath}:{line_number}'.format(\n filepath = filepath,\n line_number = line_number)\n logging.debug('Open file in sublime text: %s', argument)\n return _subprocess_call([filepath_subl, '-a', argument])",
"def get_position(self, position):",
"def sunpos(*args):\n return _sunpos.sunpos(*args)",
"def location_to_pos(self,row, col):\r\n\r\n pos_row = str(row + 1)\r\n pos_col = chr(col + 97)\r\n return pos_col + pos_row",
"def get_single_location(chrom, pos):\n return CHROMOSOME_TO_CODE[chrom] * int(1e9) + pos",
"def get_position():\n\n return character['Position']",
"def _map_extlit(self, l):\n\n v = abs(l)\n\n if v in self.vmap.e2i:\n return int(copysign(self.vmap.e2i[v], l))\n else:\n self.topv += 1\n\n self.vmap.e2i[v] = self.topv\n self.vmap.i2e[self.topv] = v\n\n return int(copysign(self.topv, l))",
"def _format_point(self, point):\n return (point + self.draw_offset).intify()",
"def pos(self, x, y):\n\n if isinstance(x, float):\n x = int(x)\n\n self.screen.write(colorama.Cursor.POS(x, y), ansi=True)\n self.x = x\n self.y = y\n\n return x, y",
"def position(self):\n return pm.datatypes.Point(self.transform.getTranslation(ws=True))",
"def _get_point_source_location(element):\n pos = element.find('%s/%s/%s' %\n (NRML04_POINT_GEOMETRY, gml.GML_POINT, gml.GML_POS))\n pos = pos.text.split()\n\n return float(pos[0]), float(pos[1])",
"def __convert_position(self, row_position: int = None, col_position: int = None) -> int:\n if row_position is None or col_position is None:\n return self.__row_position * len(self.__labyrinth[0]) + self.__col_position\n\n return row_position * len(self.__labyrinth[0]) + col_position",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def getPosition(*args):",
"def test_word_positions_in_file(self):\n pass",
"def get_pos(x, y):\r\n return normalize(x) // 2, normalize(y) // 4",
"def _position_to_offset(self, position: Position) -> int:\n return self._line_offsets[position.line] + position.character",
"def parse_file(line, position):\n movement = line.split(\" \")\n if movement[0] == \"SUS\":\n position[\"x\"] += float(movement[1])\n elif movement[0] == \"JOS\":\n position[\"x\"] -= float(movement[1])\n elif movement[0] == \"STANGA\":\n position[\"y\"] -= float(movement[1])\n elif movement[0] == \"DREAPTA\":\n position[\"y\"] += float(movement[1])\n else:\n print(\"Incorrect input\")",
"def fix_location(in_text):\n prompt = ConversionPrompt(\n 'I', 'O',\n (\"lenox ma\", \"Lenox, MA\"),\n (\"london\", \"London, U.K.\"),\n (\"chicago\", \"Chicago, IL\"),\n (\"dallas, tx\", \"Dallas, TX\"),\n engine='babbage'\n )\n return prompt.convert(in_text)",
"def cmd_position(self, n, e, d, heading):\n pass",
"def get_position(filestring, position):\n lines = filestring.split(\"\\n\")\n line_number, place, count = 0, 0, 0\n #print \"Number of lines: \", len(lines)\n \n while line_number < len(lines):\n line = lines[line_number]\n new_count = count + len(line) #+ 1 # +1 nes dar newline pridedame\n if position <= new_count:\n place = position - count\n break\n count = new_count # +1 nes dar newline pridedame\n line_number += 1\n \n print \"\\n\".join([\"%s:%s\" % ((\"===> \" if i==line_number else \"\") + str(i), lines[i]) for i in xrange(len(lines))])\n return (line_number, place)",
"def unl_to_pos(self, c2, for_p, bookmark=False):\n\n if isinstance(c2, str):\n # c2 is an UNL indicating where to insert\n full_path = c2\n path, unl = full_path.split('#', 1)\n c2 = g.openWithFileName(path, old_c=self.c)\n self.c.bringToFront(c2=self.c)\n maxp = g.findAnyUnl(unl, c2)\n if maxp:\n if not bookmark and (for_p == maxp or for_p.isAncestorOf(maxp)):\n g.es(\"Invalid move\")\n return None, None\n nd = maxp.insertAsNthChild(0)\n else:\n g.es(\"Could not find '%s'\" % full_path)\n self.c.bringToFront(c2=self.c)\n return None, None\n else:\n # c2 is an outline, insert at top\n nd = c2.rootPosition().insertAfter()\n nd.copy().back().moveAfter(nd)\n\n return c2, nd",
"def ind_pos(position, ind, current_geno, chr_starts, chr_ends):\n ind_starts = chr_starts[ind]\n ind_ends = chr_ends[ind]\n #print [position, ind, current_geno, ind_starts, ind_ends]\n in_interval = False\n for interval in range(len(ind_starts)):\n if position > int(ind_starts[interval]) and position < int(ind_ends[interval]):\n in_interval = True\n break\n if in_interval:\n return(current_geno)\n else:\n return(\"./.\")",
"def get_text_positions(self, node, padded):\n # type: (AstNode, bool) -> Tuple[Tuple[int, int], Tuple[int, int]]\n raise NotImplementedError",
"def get(self, offset: int) -> Position:\n line = bisect_right(self.line_starts, offset) - 1\n character = offset - self.line_starts[line]\n return Position(line=line, character=character)",
"def loc(y,x):\n return '\\033[%s;%sH' % (str(y),str(x))",
"def sunposf(*args):\n return _sunpos.sunposf(*args)",
"def geo2cell(geofile, posfile):",
"def to_pygame(point):\n return int(point.x), int(-point.y+500)",
"def offset_point(self,base, offset):\r\n return (base[0] + offset[0], base[1] + offset[1])",
"def relativeToAbsolute(text, start = 0, changes = None):\n tokenizer = ly.tokenize.MusicTokenizer()\n tokens = tokenizer.tokens(text)\n \n # Walk through not-selected text, to track the state and the \n # current pitch language.\n if start:\n for token in tokens:\n if token.end >= start:\n break\n \n if changes is None:\n changes = ly.tokenize.ChangeList(text)\n \n def newPitch(token, pitch, lastPitch):\n \"\"\"\n Writes a new pitch with all parts except the octave taken from the\n token. The octave is set using lastPitch.\n \"\"\"\n pitch.absolute(lastPitch)\n changes.replaceToken(token,\n token.step + ly.pitch.octaveToString(pitch.octave) + token.cautionary)\n \n class gen(object):\n \"\"\"\n Advanced generator of tokens, discarding whitespace and comments,\n and automatically detecting \\relative blocks and places where a new\n LilyPond parsing context is started, like \\score inside \\markup.\n \"\"\"\n def __iter__(self):\n return self\n \n def next(self):\n token = next(tokens)\n while isinstance(token, (tokenizer.Space, tokenizer.Comment)):\n token = next(tokens)\n if token == \"\\\\relative\":\n relative(token.pos)\n token = next(tokens)\n elif isinstance(token, tokenizer.MarkupScore):\n absolute()\n token = next(tokens)\n return token\n \n source = gen()\n \n def consume():\n \"\"\" Consume tokens till the level drops (we exit a construct). \"\"\"\n depth = tokenizer.depth()\n for token in source:\n yield token\n if tokenizer.depth() < depth:\n return\n \n def absolute():\n \"\"\" Consume tokens while not doing anything. \"\"\"\n for token in consume():\n pass\n \n def relative(start):\n \"\"\"\n Called when a \\\\relative command is encountered.\n start is the position of the \\\\relative token, to remove it later.\n \"\"\"\n # find the pitch after the \\relative command\n lastPitch = None\n token = next(source)\n if isinstance(token, tokenizer.Pitch):\n lastPitch = Pitch.fromToken(token, tokenizer)\n token = next(source)\n if not lastPitch:\n lastPitch = Pitch.c1()\n \n # remove the \\relative <pitch> tokens\n changes.remove(start, token.pos)\n \n # eat stuff like \\new Staff == \"bla\" \\new Voice \\notes etc.\n while True:\n if token in ('\\\\new', '\\\\context'):\n next(source) # skip context type\n token = next(source)\n if token == '=':\n next(source) # skip context name\n token = next(source)\n elif isinstance(token, (tokenizer.ChordMode, tokenizer.NoteMode)):\n token = next(source)\n else:\n break\n \n # now convert the relative expression to absolute\n if isinstance(token, tokenizer.OpenDelimiter):\n # Handle full music expression { ... } or << ... >>\n for token in consume():\n # skip commands with pitches that do not count\n if token in ('\\\\key', '\\\\transposition'):\n next(source)\n elif token == '\\\\transpose':\n next(source)\n next(source)\n elif token == '\\\\octaveCheck':\n start = token.pos\n token = next(source)\n if isinstance(token, tokenizer.Pitch):\n p = Pitch.fromToken(token, tokenizer)\n if p:\n lastPitch = p\n changes.remove(start, token.end)\n elif isinstance(token, tokenizer.OpenChord):\n # handle chord\n chord = [lastPitch]\n for token in source:\n if isinstance(token, tokenizer.CloseChord):\n lastPitch = chord[:2][-1] # same or first\n break\n elif isinstance(token, tokenizer.Pitch):\n p = Pitch.fromToken(token, tokenizer)\n if p:\n newPitch(token, p, chord[-1])\n chord.append(p)\n elif isinstance(token, tokenizer.Pitch):\n p = Pitch.fromToken(token, tokenizer)\n if p:\n newPitch(token, p, lastPitch)\n lastPitch = p\n elif isinstance(token, tokenizer.OpenChord):\n # Handle just one chord\n for token in source:\n if isinstance(token, tokenizer.CloseChord):\n break\n elif isinstance(token, tokenizer.Pitch):\n p = Pitch.fromToken(token, tokenizer)\n if p:\n newPitch(token, p, lastPitch)\n lastPitch = p\n elif isinstance(token, tokenizer.Pitch):\n # Handle just one pitch\n p = Pitch.fromToken(token, tokenizer)\n if p:\n newPitch(token, p, lastPitch)\n \n # Do it!\n for token in source:\n pass\n return changes",
"def lammps_pos_text(structure, species):\n\n pos_text = \"\\n\"\n for count, (pos, spec) in enumerate(zip(structure.positions, species)):\n pos_text += f\"{count+1} {spec} {pos[0]} {pos[1]} {pos[2]}\\n\"\n return pos_text",
"def pyr_point_translator(x, y, org_l, dest_l):\n dest_x = (2.0 ** (org_l - dest_l)) * x\n dest_y = (2.0 ** (org_l - dest_l)) * y\n return np.array([dest_x, dest_y]).transpose()",
"def Pos(row, col):\n return ESC + str(row) + ';' + str(col) + 'H'",
"def rl_get_point() -> int: # pragma: no cover\n if rl_type == RlType.GNU:\n return ctypes.c_int.in_dll(readline_lib, \"rl_point\").value\n\n elif rl_type == RlType.PYREADLINE:\n return int(readline.rl.mode.l_buffer.point)\n\n else:\n return 0",
"def fixture_coord():\n\tEXAMPLE_FILE_FOLDER = str(MODULE_DIR) + \"/data/nail1/\"\n\tcoord_x, coord_y, coord = read.load_coord(EXAMPLE_FILE_FOLDER)\n\treturn coord",
"def normalize_simple(line):\n first = find_next_comma_newline(line,0)\n #print \"first: %d\" % first\n second = find_next_comma_newline(line,first+1)\n #print \"second: %d\" % second\n third = find_next_comma_newline(line,second+1)\n #print \"third: %d\" % third\n if third == -1:\n lon = float(line[second+1:])\n else:\n lon = float(line[second+1:third])\n return int(line[0:first]),float(line[first+1:second]),lon",
"def get_location(line):\n line = line.split('\\t')\n for char in line:\n if ',' in char and line.index(char) != 0:\n char_index = line.index(char)\n return line[char_index]",
"def nextCharLowerLeft(self):\n pmodel = self.model.pos * self.transform.scale\n x, y, _ = self.transform.pos + pmodel\n y += ((self.font.table['ascent'] + self.y_sign * self._labelHeight)\n * self.transform.scale[1])\n x += self._string_metric[-1][2][0] * self.transform.scale[0]\n return x, y",
"def get_start_loc(self) -> Tuple[int, int]:\n assert self.pos_marker\n return self.pos_marker.working_loc",
"def cursor_coordinates(self):\n text = self.getText()\n lines = text.split(\"\\n\")\n pos = self.getCursorPos()\n if pos == 0:\n return (0, 0)\n i = 0\n cursor_row = -1\n cursor_col = -1\n for row, line in enumerate(lines):\n i += len(line) + 1 # we need to include \"\\n\"\n if pos < i:\n cursor_row = row\n cursor_col = pos - i + len(line) + 1\n break\n return (cursor_col, cursor_row)",
"def selection_pos(self):\n buff = self._vim.current.buffer\n beg = buff.mark('<')\n end = buff.mark('>')\n return beg, end",
"def getXPos(self, tline, x):\n # Find the TWord object\n words = tline.twords\n j = 0 # word index\n imax = len(words) - 1\n for w in words:\n # Find out if the point is in this word -\n # need to include half the space width after the word, if there\n # is a following word.\n x0 = w.getX()\n x1 = x0 + w.getWidth()\n if (j == imax): break\n x2 = words[j+1].getX()\n spw = (x2 - x1)/2\n if (x < x1 + spw): break\n j += 1\n\n word = words[j]\n\n # Then the character\n xvec = word.getOffsets()\n\n k = 0\n if xvec:\n xo = x - x0 # xo is x relative to word start\n p0 = 0.0\n for p in xvec:\n p1 = xvec[k]\n if (xo < (p0 + p1)/2): break\n k += 1\n p0 = p1\n\n return (word, k)",
"def handle_position(data: bytes) -> Tuple[bytes, str]:\n x, y, z = struct.unpack('fff', data[0:3 * 4])\n return data[20:], f'Current Position (x,y,z): {x} {y} {z}'",
"def _strip_position(line: str) -> str:\n line = \".py\".join(line.split(\".py:\")[1:])\n line = \" \".join(line.split(\" \")[1:])\n return line",
"def _(event):\n buffer = event.current_buffer\n\n if buffer.document.is_cursor_at_the_end_of_line:\n buffer.cursor_position += buffer.document.get_start_of_line_position(after_whitespace=False)\n else:\n buffer.cursor_position += buffer.document.get_end_of_line_position()",
"def position(file_, pattern):\n pattern = pattern[1:-1]\n pattern = pattern.replace('(', '\\(')\n pattern = pattern.replace(')', '\\)')\n file_obj = open(file_, 'rU')\n for line_number, line in enumerate(file_obj):\n m = re.search(pattern, line)\n if m is not None:\n return line_number, m.pos\n file_obj.close()\n return 0, 0",
"def xx(self, line=''):\r\n ## line in this context is one ipython line which may have line breaks in it\r\n line = self.xxFixLine(line)\r\n return self.shell.getoutput(line)",
"def getCoords(file):\n global demag\n name = file.split('.')[0]\n name = name.split('_')\n x = int(name[2])//demag\n y = int(name[3])//demag\n return(int(x),int(y))",
"def set_cursor_coordinates(self, x, y):\n text = self.getText()\n lines = text.split(\"\\n\")\n i = 0\n for row, line in enumerate(lines):\n if row == y:\n break\n i += len(line) + 1 # we need to include \"\\n\"\n if \"\\r\" in line: # and also \"\\r\"\n i -= 1\n pos = i + x\n if pos > len(text):\n pos = len(text)\n self.setCursorPos(pos)",
"def transform_point(self, pt):\r\n\r\n x, y = pt\r\n return (x - self.xoffset, (y - self.yoffset) * self.yscale)",
"def parse_pos(self, pos):\r\n\r\n column = ord(pos[0]) - 97\r\n if len(pos) == 2:\r\n row = ord(pos[1]) - 49\r\n else:\r\n row = 9\r\n return [row, column]",
"def position(x, y):\n command([x + 0x80, y + 0x40])",
"def convert_coordinates(x):\n \n long = x.replace('.',',')\n rep = re.sub('(,[^,]*),', r'\\1', long)\n rep = rep.replace(',','.')\n return rep",
"def getStartPos(peptide, seq, subst=None):\n return getStartPosMapper(seq, subst)(peptide)",
"def __getpos__(self, num):\n return self.num_to_pos[num]",
"def get_position(pos):\n if type(pos) is str:\n return list(map(lambda x: float(x),pos.split(\",\")))\n return pos",
"def pos(self) -> str:\n return self._pos",
"def current_area(self, value=None):\n my_area = self.my_text.index(INSERT)\n str(my_area)\n for x in range(0, len(my_area)):\n if my_area[x] == \".\":\n my_y = my_area[0:x]\n my_x = my_area[x + 1:]\n my_new_area = \"Ln: \" + my_y + \" | Col: \" + my_x\n self.my_location.config(text=my_new_area)",
"def parse_position(chrom_pos: str):\n chrom, pos = chrom_pos.split('_')\n return chrom, int(pos)",
"def get_coords_from_position(position, file):\n line_counter = 1\n column_counter = 1\n try:\n with open(file, 'r') as source:\n string = source.read()\n except:\n #unable to open file -> 3\n error.ThrowError(3)\n i = 0\n j = position\n while j > 0:\n if string[i] == '\\n':\n line_counter += 1\n column_counter = 1\n else:\n column_counter += 1\n i += 1\n j -= 1\n return Coords(line_counter, column_counter, position)",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def setPosition(*args):",
"def open_and_raise(filename, line, col):\n\n buffer = GPS.EditorBuffer.get(GPS.File(filename))\n GPS.MDI.get_by_child(buffer.current_view()).raise_window()\n buffer.current_view().goto(buffer.at(line, col))",
"def test_mine_count_coordinates(self):\n pg.font.init()\n font = utils.FONT.render(\"test\", True, utils.FONT_COLOUR)\n mine_count_text_coords = utils.mine_count_coords(font, (10, 10))\n self.assertIsInstance(mine_count_text_coords, tuple)",
"def getSelectedPosition(*args):",
"def locus_start(self):\n return int(open(self.locus_file).read().split('\\t')[3])",
"def highlight_source(linenumber, index, lines, offset=None):\n # The following if statements are left-over diagnostic\n # from the hack to integrate into Idle.\n # they are harmless tests which could potentially be useful.\n if lines is None:\n return \"\", \"\"\n if index is None:\n print(\"problem in highlight_source(): index is None\")\n index = 0\n\n # The weird index arithmetic below is based on the information returned\n # by Python's inspect.getinnerframes()\n\n new_lines = []\n problem_line = \"\"\n nb_digits = len(str(linenumber + index))\n no_mark = \" {:%d}: \" % nb_digits\n with_mark = \" -->{:%d}: \" % nb_digits\n if offset is not None:\n offset_mark = \" \" * (8 + nb_digits + offset) + \"^\"\n i = linenumber - index\n\n for line in lines:\n if i == linenumber:\n num = with_mark.format(i)\n problem_line = line\n new_lines.append(num + line.rstrip())\n if offset is not None:\n new_lines.append(offset_mark)\n break\n else:\n num = no_mark.format(i)\n new_lines.append(num + line.rstrip())\n i += 1\n return \"\\n\".join(new_lines), problem_line",
"def start(self) -> global___Pos:",
"def print_pos(pos):\n # TO DO: EXCLUDE FIRST LINE\n s = \"%BLOCK POSITIONS_FRAC\\n\" + str(pos) + \"\\n%ENDBLOCK POSITIONS_FRAC\"\n return s",
"def calcSegmentCoordinates(self, segment):\n # Write the cpptraj infile\n segment_name_string = segment.getNameString()\n \n coordinates = self.calcCoordinatesOfFile(\"{jn}-run/{namestring}.rst7\".format(jn=self.jobname, \n namestring = segment_name_string))\n # set coordinates in segment\n segment.setCoordinates(coordinates)\n return coordinates",
"def goto_position(editor, pos):\n cursor = editor.textCursor()\n editor.moveCursor(cursor.End)\n cursor.setPosition(pos)\n editor.setTextCursor(cursor)",
"def to_position(self, x, y, i, j):\n return (x * self.SIZE + i, y * self.SIZE + j)"
] | [
"0.59632206",
"0.5889241",
"0.56616706",
"0.56562984",
"0.54250014",
"0.5352155",
"0.524134",
"0.52322143",
"0.5227591",
"0.52061164",
"0.5179411",
"0.5161949",
"0.51547635",
"0.507839",
"0.5063059",
"0.5035226",
"0.5024355",
"0.50153136",
"0.5005417",
"0.50020736",
"0.4999571",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.4988853",
"0.49882215",
"0.497939",
"0.49524558",
"0.49517885",
"0.4942579",
"0.4936656",
"0.49339014",
"0.49326926",
"0.49128538",
"0.488568",
"0.48843607",
"0.48752624",
"0.48721173",
"0.48674354",
"0.48607185",
"0.48526055",
"0.48372495",
"0.48369643",
"0.48236576",
"0.48077744",
"0.48060644",
"0.4806053",
"0.48028108",
"0.48003662",
"0.47985905",
"0.47975984",
"0.47947174",
"0.47805145",
"0.4778109",
"0.47735256",
"0.47723353",
"0.47675762",
"0.4760927",
"0.4759193",
"0.47590646",
"0.47580364",
"0.47507358",
"0.47337413",
"0.47281435",
"0.47274846",
"0.47239912",
"0.47165757",
"0.47129473",
"0.4704919",
"0.47040948",
"0.470264",
"0.46911412",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.46909854",
"0.4689984",
"0.46898395",
"0.46892512",
"0.46875313",
"0.46865338",
"0.468379",
"0.46827388",
"0.46764132",
"0.46699086",
"0.46664503"
] | 0.6376156 | 0 |
Replace sequence of whitespaces by a single space | def clean_whitespace(text):
return text
#return re.sub(r'\r\n|\n', "\t", text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def removeMultipleSpaces(self) -> None:\n self.text = re.sub('\\s+', ' ', self.text)",
"def normalize_whitespace(text):\n return NORMALIZE_WHITESPACE_REGEX.sub(' ', text)",
"def replace_whitespace(s, rep=' '):\n s = re.sub(r'\\s+', rep, s)\n return s",
"def normalize_space (text):\n return RE_WS.sub (' ', text.strip ())",
"def removeSingleChars(self) -> None:\n self.text = re.sub('\\s[^\\n\\s]\\s', ' ', self.text)",
"def add_spaces(text):\n return \" \".join(text)",
"def _despace(statement):\n return re.sub(r' +', ' ', statement)",
"def replace_spaces_with_pluses(self, sample):\r\n changed = list(sample)\r\n for i, c in enumerate(changed):\r\n if(c == ' ' or c ==' ' or c ==' ' or c=='\\n' or c=='\\n\\n'):\r\n changed[i] = '+'\r\n return ''.join(changed)",
"def remove_repeated_spaces(text: str) -> str:\n\n return _repeated_spaces.sub(' ', text)",
"def clean_text_from_multiple_consecutive_whitespaces(text):\n multi_space_regex = re.compile(r\"\\s+\", re.IGNORECASE)\n return re.sub(multi_space_regex, ' ', text)",
"def _squeeze_whitespace(text):\n return re.sub(r'\\s+', ' ', text)",
"def insert_spaces(word):\n new_word = \"\"\n for c in word:\n new_word += c + \" \" \n return new_word",
"def remove_space(text):\n for space in spaces:\n text = text.replace(space, ' ')\n text = text.strip()\n text = re.sub('\\s+', ' ', text)\n return text",
"def remove_space(text):\n for space in spaces:\n text = text.replace(space, ' ')\n text = text.strip()\n text = re.sub('\\s+', ' ', text)\n return text",
"def normalise_whitespace(strg):\n return re.sub(r\"\\s+\", \" \", strg).strip()",
"def reduce_spaces(tweet):\r\n text = tweet.strip()\r\n text = \" \".join(text.split())\r\n return re.sub(' +', ' ', text)",
"def normalizeSpaces(strText, bDouble=False):\n if bDouble:\n strText = re.sub(r\"[ ]+\", r\" \", strText, flags=re.UNICODE)\n # Remove double spaces from groups\n return re.sub(r\"([(|]) ([|)])\", r\"\\g<1> \\g<2>\", strText, flags=re.UNICODE)\n\n return re.sub(r\"[ ]+\", r\" \", strText, flags=re.UNICODE)",
"def remove_extra_space(text):\n return re.sub(' +', ' ', text)",
"def removeExtraSpaces(text):\n\tone_space = re.sub(r'\\s+',' ', text)\n\treturn one_space",
"def normalize_space(text):\n return re.sub(r\"\\s+\", \" \", text.strip(), flags=re.UNICODE)",
"def strip_space():\n pass",
"def remove_extra_middle_spaces(x):\n\n return \" \".join(x.split())",
"def spacify(string):\n return \" \" + \" \".join(string.splitlines(True))",
"def normalize_whitespace(text):\n text = str(text)\n return re.sub(white_space_regex, ' ', text).strip()",
"def replace_newline_with_space(text):\n return re.sub(\"[\\n\\r]\", \" \", text)",
"def del_whitespace(selfs, text):\n\t\treturn text.replace(' ', '')",
"def condense_whitespace(css):\n log.debug(\"Condensing all unnecessary white spaces.\")\n return re.sub(r\"\\s+\", \" \", css)",
"def normalize_whitespace(text):\n return RE_NONBREAKING_SPACE.sub(\" \", RE_LINEBREAK.sub(r\"\\n\", text)).strip()",
"def replace_whitespace(input: str, *, replace_str: str = '') -> str:\n return WHITESPACE_REGEX.sub(replace_str, input)",
"def myreplace(old, new, s):\r\n if old.isspace(): # If a weird guy set \"old\" only have space(s)\r\n old = None\r\n return new.join(s.split(old))",
"def collapse(s):\n return ' '.join(s.split()).strip()",
"def removeExtraSpaces(self, words):\n\t\treturn re.sub(r'\\s+', ' ', words.strip()).strip()",
"def strip_space(string):\n return string.replace(' ', '')",
"def convert_spaces(msg_list):\n new_list = []\n for str in msg_list:\n new_list.append(str.replace(' ', '+'))\n return (new_list)",
"def shrink_whitespace(data: pd.Series) -> pd.Series:\n data = data.replace(r'\\s+', value=' ', regex=True)\n return data.str.strip()",
"def comma_for_space(x):\n x = strip_stoich_wrapper(x)\n x = x.replace(\" \", \",\")\n return x",
"def remove_space(user_inputs):\r\n return user_inputs.replace(\" \", \"\")",
"def _remove_whitespaces(self, text: str) -> str:\n return \" \".join(re.sub(\"\\xa0\", \" \", str(text)).split())",
"def remove_white_space(ls):\r\n for i in range(len(ls)):\r\n ls[i] = re.sub(r'\\s+', '', ls[i])\r\n\r\n return ls",
"def _clean(s):\n return re.sub(r'\\s+', ' ', s.strip())",
"def RemoveWhiteSpace(value):\n return \"\".join(value.split())",
"def _remove_extra_whitespaces(self, text: str) -> str:\n return re.sub(\" +\", \" \", text)",
"def replace_non_break_space(str):\n non_break_space = u'\\xa0'\n str = str.replace(non_break_space, \" \")\n return str",
"def fill_with_spaces(line: string, width: int) -> string:\n size = len(line)\n spaces_left = width - size\n return line + (' ' * spaces_left)",
"def _removeWhitespaces(self, s):\n return s.translate({ord(c): None for c in string.whitespace})",
"def test_remove_multiple_spaces():\n questions_parser = QuestionsParser()\n assert questions_parser.remove_multiple_spaces('Sentence with multiple spaces') == 'Sentence with multiple spaces'",
"def unscorize(s):\n return s.replace(\" \", \"_\")",
"def remove_extra_space(text):\n text = \" \".join(text.split())\n return text",
"def remove_excess_white_space(lines: str):\n two_plus_white_space = r\"\\s{2,}\"\n return re.sub(two_plus_white_space, \"\", lines)",
"def format_sequence(s):\n\n # Add spaces around punctuation\n s = re.sub(\n r'(?<=[^\\s])(?=[“”!\\\"#$%&()*+,./:;<=>?@[\\]^_`{|}~\\t\\n])|(?=[^\\s])(?<=[“”!\\\"#$%&()*+,./:;<=>?@[\\]^_`{|}~\\t\\n])', r' ', s)\n\n # Remove double spaces\n s = re.sub(r'\\s\\s', ' ', s)\n return s",
"def cleanup_sentence(s):\n return re.sub(\"\\s+\", \" \", s.replace(\"\\t\", \"\").strip())",
"def html_space(text):\r\n return cgi.escape(text).replace('\\t', ' ').replace(' ', ' ')",
"def remove_white_spaces(input_string):\n return re.sub(r'\\s+', ' ', input_string).strip()",
"def compress_whitespace(cls, s):\n # Cast to string\n s = str(s).strip()\n\n # Sanity check\n if (len(s) == 0):\n return ''\n\n s = re.sub(r'\\s', ' ', s)\n s = re.sub(r' +', ' ', s)\n\n return s.strip()",
"def new_line_to_whitespace(str):\n str = str.replace(\"\\n\", \" \")\n return str",
"def clean_whitespaces(text):\n length = len(text)\n i = 0\n prev_char = None\n while i < length:\n curr_char = text[i]\n return_char = curr_char if curr_char not in string.whitespace else \" \"\n\n if not (prev_char == \" \" and return_char == \" \"):\n yield return_char\n\n prev_char = return_char\n i += 1",
"def underscore_and_slash_to_space(data: pd.Series) -> pd.Series:\n return data.replace(r'[\\_/-]', value=' ', regex=True)",
"def shrink_space(data):\n # remove leading and trailing spaces\n data = data.strip()\n # collapse multiple lines to one single line\n data = re.sub(\"\\n+\",\"\\n\",data)\n\n return data",
"def fix_whitespace(lines: Sequence[str], eol: str, ends_with_eol: bool) -> str:\n lines = _strip(lines)\n lines = [i.expandtabs(4) for i in lines]\n result = eol.join(lines)\n if ends_with_eol:\n result += eol\n return result",
"def spacelist(listtospace, spacechar=\" \"):\n output = ''\n space = ''\n output += str(listtospace[0])\n space += spacechar\n for listnum in range(1, len(listtospace)):\n output += space\n output += str(listtospace[listnum])\n return output",
"def remove_space(line):\n split_line = line.split()\n return \"\".join(split_line)",
"def normalize_whitespace(text):\n text = text.replace('\"', '').replace(\"'\", '')\n return ' '.join(text.split())",
"def preserve_whitespace(v, quote=True):\n if quote:\n v = html_quote(v)\n v = v.replace('\\n', '<br>\\n')\n v = re.sub(r'()( +)', _repl_nbsp, v)\n v = re.sub(r'(\\n)( +)', _repl_nbsp, v)\n v = re.sub(r'^()( +)', _repl_nbsp, v)\n return '<code>%s</code>' % v",
"def space_strip(string):\n string= re.sub(\"(?m)^\\s+\", \"\", string)\n return re.sub(\"(?m)\\s+$\", \"\", string)",
"def beautify(text):\n text = re.sub('\\n{3,}', '\\n\\n', text)\n text = re.sub('\\n+$', '\\n', text)\n return text",
"def whitespace_sorter(sentence):\r\n sentence_copy = str(sentence)\r\n sentence_copy = sentence_copy.strip() #Remove leading and trailing whitespace (/s)\r\n sentence_copy = re.sub(\" +\", \" \", sentence_copy) #Coerces all multiple /s characters into a single /s\r\n #It identifies a /s followed by any nonzero number of /s and replaces this with a single /s \r\n return sentence_copy",
"def simplify(text, whitespace=string.whitespace, delete=\"\"):\n result = []\n word = \"\"\n for char in text:\n if char in delete:\n continue\n elif char in whitespace:\n if word:\n result.append(word)\n word = \"\"\n else:\n word += char\n if word:\n result.append(word)\n return \" \".join(result)",
"def readjustSpacesInString(string):\n\n return ' '.join([x for x in string.split(' ') if x])",
"def replace_empty(s):\n if s == \"\":\n return \" \"\n else:\n return s",
"def Space(num):\n return String(num, \" \")",
"def remove_whitespace(text):\n text = text.strip()\n return \" \".join(text.split())",
"def preprocess_nmt(text):\n def no_space(char, prev_char):\n return char in set(',.!?') and prev_char != ' '\n\n # Replace non-breaking space with space, and convert uppercase letters to\n # lowercase ones\n text = text.replace('\\u202f', ' ').replace('\\xa0', ' ').lower()\n # Insert space between words and punctuation marks\n out = [' ' + char if i > 0 and no_space(char, text[i - 1]) else char\n for i, char in enumerate(text)]\n return ''.join(out)",
"def NormalizeWhitespace (text, preserve=False, replace=False, collapse=False):\n if preserve:\n return text\n text = __TabCRLF_re.sub(' ', text)\n if replace:\n return text\n if collapse:\n return __MultiSpace_re.sub(' ', text).strip()\n # pyxb not imported here; could be.\n raise Exception('NormalizeWhitespace: No normalization specified')",
"def clean_up_tokenization_spaces(out_string):\n out_string = out_string.replace('<unk>', '')\n out_string = out_string.replace(' .', '.').replace(' ?', '?').replace(' !', '!').replace(' ,', ','\n ).replace(\" ' \", \"'\").replace(\" n't\", \"n't\").replace(\" 'm\", \"'m\").replace(\" do not\", \" don't\"\n ).replace(\" 's\", \"'s\").replace(\" 've\", \"'ve\").replace(\" 're\", \"'re\")\n return out_string",
"def reformat_search_for_spaces(self):\r\n self.yt_search_key = self.yt_search_key.rstrip().replace(' ', '+')",
"def parse_text(text):\n return re.sub(r'\\s+', \" \", text)",
"def _clean(self, string):\n return re.sub('\\s+', ' ', string).strip()",
"def normalize(s):\n return s.strip(inline_whitespace)",
"def make_spaces_ascii(artist_str):\n while artist_str.find(' ') != -1:\n artist_str = artist_str.replace(' ', '%20')\n return artist_str",
"def TRIM(text):\n return _trim_re.sub(' ', text.strip())",
"def remove_whitespaces(text: str) -> str:\n return text.lstrip().rstrip()",
"def prepseq(self, seq):\n\n wtf = re.sub(r'\\*$', '', seq)\n return wtf",
"def _process_replacements(input_text):\n original_input = list(input_text) # Immutable\n replaced = list(input_text)\n for index, char in enumerate(original_input):\n if char.isalpha() or char.isdigit():\n replacement = helpers.get_character(char)\n if replacement:\n replaced[index] = ' ' + replacement + ' '\n return helpers.remove_excess_spaces(''.join(replaced))",
"def delete_whitespace(text: str) -> str:\n return re.sub(r'\\s+', '', text).strip()",
"def _preprocess(self, sent: str) -> str:\n sent = sent.replace(\" \", \"▁\")\n return \" \".join([c for c in sent])",
"def test_space_replacements(self):\n testString = sanitize(' a b c d ', '_')\n self.assertEqual(testString, '__a_b_c_d___')",
"def remove_whitespace_rarity(s, i):\n text = s.replace(' ', '')\n if os.linesep.join([s for s in text.splitlines() if s]) == '':\n return('None')\n else:\n return(os.linesep.join([s for s in text.splitlines() if s]))",
"def _standardize_str(s):\n memory = []\n s = s.replace(\",\", \" \")\n res = \"\"\n for c in s:\n if c != \" \":\n res += c\n memory = []\n elif not memory:\n res += c\n memory.append(\" \")\n return res",
"def cleaner(self, w_old):\n w_new = re.sub('[\\(\\)]', '', w_old)\n w_new = re.sub('[^А-Яа-яЁё ]', 'ъ', w_new)\n w_new = re.sub(' ', ' ', w_new)\n return w_new",
"def html_space(n):\n return \" \" * n",
"def _to_space_separated_string(l):\n s = '';\n for x in l:\n if len(s)>0: s += ' '\n s += repr(x)\n return s",
"def _remove_left_padded_special_chars(self, text: str) -> str:\n pattern = re.compile(\"\\ +[^A-Za-z0-9\\n]\")\n text = re.sub(pattern, \" \", text)\n return text",
"def wrapspace(text, token):\n\n # Wildcards have no whitespace. Need special case since * is also multiply which does have whitespace.\n if token in [\"*\"] and (not text or text.endswith((\" \", \"(\"))):\n return token\n\n # Operator whitespace\n if Token.isoperator(token) or Token.islogicseparator(token) or token.lower() in [\"in\"]:\n return f\" {token} \" if not text.endswith(\" \") else f\"{token} \"\n\n # Comma whitespace\n if Token.isseparator(token):\n return f\"{token} \"\n\n # No whitespace if any of the following is True\n if not text or text.endswith((\" \", \"(\", \"[\")) or token in [\"(\", \"[\", \")\", \"]\"] or token.startswith(\".\"):\n return token\n\n # Default is to add leading whitespace\n return f\" {token}\"",
"def clean_white_spaces(string):\n try:\n # in case it is in byte value\n string = string.decode('utf-8')\n except:\n pass\n\n res = ''\n words = string.split()\n for word in words:\n res = res + str(word)\n return res",
"def filter_blanks(user, str):\n return re.sub(r'\\n{2}\\n+', '\\n', str)",
"def despace(txt):\n pre, c = splitdefines(txt)\n pre = \"\\n\".join(pre)\n txt = \" \".join(c)\n txt = txt.replace(\"\\t\", \" \")\n txt = re.sub(r\"\\s+\", \" \", txt, flags=re.S)\n txt = re.sub(r\"([a-zA-Z0-9_])\\s+([^a-zA-Z0-9_\\s])\", r\"\\1\\2\", txt, flags=re.S)\n txt = re.sub(r\"([^a-zA-Z0-9_\\s])\\s+([a-zA-Z0-9_])\", r\"\\1\\2\", txt, flags=re.S)\n txt = re.sub(r\"([^a-zA-Z0-9_\\s])\\s+([^a-zA-Z0-9_\\s])\", r\"\\1\\2\", txt, flags=re.S)\n txt = re.sub(r\"([^a-zA-Z0-9_\\s])\\s+([^a-zA-Z0-9_\\s])\", r\"\\1\\2\", txt, flags=re.S)\n return pre + \"\\n\" + txt",
"def fixing(self, x):\n x = x.replace(' ', '') # remove space\n for spec in ['if', 'else', 'for', 'in']:\n x = x.replace(spec, ' {} '.format(spec))\n x = x.replace('lambda_', 'lambda _')\n x = x.replace('jo in ', 'join')\n return x",
"def masked_word(self):\n for i in range(0,len(self._word)):\n if self._word[i] == ' ':\n self.new_string.append(' ')\n else:\n self.new_string.append('__ ')\n\n return self.print_new_word(self.new_string)",
"def myreplace(old, new, s):\n\n s = s.split()\n s = \" \".join(s)\n\n return new.join(s.split(old))",
"def compact_spaces(st: str) -> str:\n st = st.strip()\n ret = ''\n in_quotes = False\n added_space = False\n for x in st:\n if x == '\"':\n in_quotes = not in_quotes\n added_space = False\n ret += x\n elif in_quotes:\n ret += x\n elif x in ('\\t', '\\n', '\\r', ' '):\n if not added_space:\n ret += ' '\n added_space = True\n else:\n added_space = False\n ret += x\n\n return ret"
] | [
"0.7690094",
"0.7357652",
"0.73225224",
"0.72260857",
"0.7153848",
"0.7132321",
"0.70644516",
"0.7048768",
"0.70468843",
"0.7003004",
"0.6987875",
"0.69768345",
"0.6918292",
"0.6918292",
"0.68797535",
"0.6837561",
"0.6772368",
"0.676568",
"0.676431",
"0.6750295",
"0.67097074",
"0.66768557",
"0.6667913",
"0.66576445",
"0.665106",
"0.6638085",
"0.6590818",
"0.65805304",
"0.65643585",
"0.6416864",
"0.6397628",
"0.6379495",
"0.63585037",
"0.63452417",
"0.6338684",
"0.63285434",
"0.63149196",
"0.63118666",
"0.63076794",
"0.6300274",
"0.6293818",
"0.62886286",
"0.627249",
"0.626645",
"0.624375",
"0.62393963",
"0.623666",
"0.62317574",
"0.62305266",
"0.6206576",
"0.62042505",
"0.61769956",
"0.612088",
"0.611593",
"0.6096483",
"0.60603523",
"0.60591197",
"0.6035926",
"0.6030684",
"0.60304683",
"0.60075396",
"0.5997429",
"0.59749514",
"0.5951066",
"0.5935307",
"0.5929763",
"0.59271365",
"0.5918773",
"0.59182394",
"0.5909749",
"0.58969134",
"0.5893423",
"0.58880574",
"0.58753705",
"0.58695257",
"0.5856092",
"0.5848076",
"0.58348316",
"0.5820291",
"0.58140856",
"0.5797473",
"0.5795296",
"0.57866794",
"0.5778564",
"0.577552",
"0.57687074",
"0.5758367",
"0.5751077",
"0.5748847",
"0.57407457",
"0.5729494",
"0.5712425",
"0.5709615",
"0.57036597",
"0.5696151",
"0.56890446",
"0.5685519",
"0.5661709",
"0.5659024",
"0.56528586"
] | 0.62447345 | 44 |
.first_name will return the correct first name | def test_first_name(self):
john_starks = Athlete(first_name="John", last_name="Starks", sport="NBA", recommendation="a")
self.assertEqual(john_starks.first_name, "John") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_first_name(self) -> str:\n return self.first_name",
"def first_name(self, instance):\r\n return instance.user.first_name",
"def get_first_name(self):\n return self._first_name",
"def firstname(self):\n return self._firstname",
"def firstname(self):\n return self._firstname",
"def first_name(self):\n return self._first_name",
"def first_name(self):\n return self._first_name",
"def first_name(self):\n return self._first_name",
"def getFirstName(self):\r\n return self.firstName",
"def first_name(self) -> str:\n return self._first_name",
"def getFirstName(self):\n\t\treturn self.FirstName",
"def first_name(self):\n\n return self._first_name",
"def first_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"first_name\")",
"def first_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"first_name\")",
"def get_short_name(self):\r\n return self.first_name",
"def full_name(self,first_name):\n full_name = self.first_name + ' ' + self.last_name\n return full_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def get_short_name(self):\n return self.first_name",
"def pref_first_name(self):\n return self.known_as if self.known_as else self.first_name",
"def test_get_short_name_should_return_first_name(self):\n email = 'example@example.com'\n password = 'password'\n first_name = 'Example'\n last_name = 'User'\n user = MyUser(\n email=email,\n password=password,\n first_name=first_name,\n last_name=last_name\n )\n short_name = user.get_short_name()\n self.assertEqual(short_name, first_name)",
"def test_first_name(self) :\n\t\tformatted_name = get_formatted_name('janis','joplin')\n\t\tself.assertEqual(formatted_name,'Janis Joplin')",
"def ldap_get_firstname(self, user):\n result = super(Auth42, self)._search_not_empty(user)\n if result is not None:\n firstname = result.get(\"first-name\")[0]\n return firstname\n\n return None",
"def resolve_first_name(obj, _):\n return obj.first_name.decode()",
"def get_first_name(self):\n element = self.driver.find_element(*self.firstname_textbox_selector)\n return element.get_attribute(\"value\")",
"def first_last_name(obj):\n return '%s %s' % (obj.first_name, obj.last_name)",
"def test_last_name_first_name(self):\n current_resume = resume.objects.first()\n expected = 'Bielinski, Nicholas'\n case = current_resume.last_name_first_name()\n self.assertEqual(case, expected)",
"def get_short_name(self):\n\n return self.first_name",
"def first_name(self, name):\n self._first_name = name",
"def get_short_name(self) -> str:\n return self.first_name",
"def first_name_and_initial(self):\n return u\"{} {}\".format(self.pref_first_name(), self.last_name[0])",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_short_name(self):\n return f\"{self.first_name} {self.last_name[:1]}\" if self.first_name else self.username",
"def get_short_name(self):\n last_name = self.last_name\n first_name = self.first_name\n if (not (last_name and not last_name.isspace())):\n \"\"\" If last name is empty or none then return first name\"\"\"\n return first_name\n else:\n return last_name",
"def test_first_last_name(self):\n\t\tformatted_name = get_formatted_name('janos', 'jk')\n\t\tself.assertEqual(formatted_name, 'Janos Jk')",
"def FirstName(self, reg_first_name = VALUE_NOT_SET):\n if reg_first_name != VALUE_NOT_SET:\n self.__reg_first_name = reg_first_name\n try:\n self.__contact.AdditionalInfo().FirstName(self.__reg_first_name)\n except:\n pass\n else:\n if not self.__reg_first_name:\n self.__reg_first_name = None\n return self.__reg_first_name",
"def get_full_name(self):\n return \"{0} {1}\".format(self.first_name, self.last_surname)",
"def get_full_name(self):\n return self.last_name + self.first_name",
"def full_name(self):\n \tif self.first_name and self.last_name:\n \t\treturn \"{} {}\".format(self.first_name, self.last_name)",
"def test_first_last_name(self):\n formatted_name = get_formatted_name('janis', 'joplin')\n self.assertEqual(formatted_name, 'Janis Joplin')",
"def test_first_last_name(self):\n formatted_name = get_formatted_name('janis', 'joplin')\n self.assertEqual(formatted_name, 'Janis Joplin')",
"def get_user_firstname():\n if not is_authenticated() or 'samlUserdata' not in session:\n return None\n\n first_name = session.get('samlUserdata', {}).get(SAML_ATTRIBUTES.get('first_name', None), False)\n\n return first_name[0] if first_name else not_found('first_name')\n return None",
"def test_first_last_name(self):\n formatted_name = get_formatted_name('jimi', 'hendrix')\n self.assertEqual(formatted_name, 'Jimi Hendrix')",
"def get_full_name(self):\n return self.first_name+\" \"+self.last_name",
"def clean_first_name(self):\n\n if self.cleaned_data['first_name'] == 'Steve':\n raise ValidationError(\"Steve is a terrible name.\")\n\n return self.cleaned_data['first_name']",
"def test_first_last_name(self):\n formatted_name = get_formatted_name('janis', 'joplin')\n # Asserting that formatted_name equals 'Janis Joplin'\n self.assertEqual(formatted_name, 'Janis Joplin')",
"def get_full_name(self):\n return self.first_name + ' ' + self.last_name",
"def get_given_name(self):\n return self.given_name",
"def get_short_name(self):\n # The user is identified by their email address\n return self.first_name",
"def get_full_name(self):\n return self.name+self.last_name",
"def set_first_name(self, first_name):\n self.first_name = first_name",
"def full_name(self):\n return self.first_name + \" \" + self.last_name",
"def get_full_name(self):\n full_name = \"%s %s\" % (self.firstname, self.lastname)\n return full_name.strip()",
"def get_full_name(self):\n full_name = f'{self.first_name} {self.last_name}' if self.first_name and self.last_name else self.username\n return full_name.strip()",
"def get_user_firstname_lastname(self, record):\n lower_first_name, lower_last_name = self.clean_user_names(record)\n\n #No first name and last name check email\n if lower_first_name is None and lower_last_name is None:\n\n lower_first_name, lower_last_name = \\\n self.extract_name_from_email(record)\n\n return lower_first_name, lower_last_name",
"def get_full_name(self):\n\t\tfull_name = '%s %s' % (self.first_name, self.last_name)\n\t\treturn full_name.strip()",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def first_name(self, first_name):\n\n self._first_name = first_name",
"def test_first_last_name(self):\n formatted_name = get_formatted_name('david', 'Malan')\n self.assertEqual(formatted_name, 'David Malan')",
"def get_full_name(self):\n return f\"{self.first_name} {self.last_name}\"",
"def get_full_name(self):\n return f\"{self.first_name} {self.last_name}\"",
"def _get_contact_first_name(app):\n name = app.get(CONTACT_NAME_KEY)\n if name:\n return ' {}'.format(name.split(' ')[0])",
"def get_full_name(self):\n # The user is identified by their email address\n return self.first_name+' '+self.last_name",
"def firstname(self, firstname):\n\n self._firstname = firstname",
"def firstname(self, firstname):\n\n self._firstname = firstname",
"def get_full_name(self):\r\n full_name = '%s %s' % (self.first_name, self.last_name)\r\n return full_name.strip()",
"def get_full_name(self):\r\n full_name = '%s %s' % (self.first_name, self.last_name)\r\n return full_name.strip()",
"def get_full_name(self):\n return f'{self.first_name} {self.last_name}'",
"def test_first_name(self, unromanized, romanized, expected):\n with mute_signals(post_save):\n profile = ExamProfileFactory(\n profile__first_name=unromanized,\n profile__romanized_first_name=romanized,\n )\n assert CDDWriter.first_name(profile) == expected",
"def get_full_name(self) -> str:\n return f\"{self.first_name} {self.last_name}\"",
"def full_name(self):\n return f\"{self.first_name} {self.last_name}\"",
"def full_name(self):\n return f\"{self.first_name} {self.last_name}\"",
"def full_name(self):\n return f\"{self.first_name} {self.last_name}\"",
"def test_get_full_name_should_return_first_name_plus_last_name(self):\n email = 'example@example.com'\n password = 'password'\n first_name = 'Example'\n last_name = 'User'\n user = MyUser(\n email=email,\n password=password,\n first_name=first_name,\n last_name=last_name\n )\n full_name = user.get_full_name()\n self.assertEqual(full_name, first_name+\" \"+last_name)",
"def get_full_name(self):\n return \"{} {}\".format(self.first_name, self.last_name)",
"def get_full_name(self):\n full_name = '{} {}'.format(self.first_name, self.last_name)\n return full_name.strip()",
"def __str__(self):\n return self.user.first_name",
"def get_name(self):\r\n return ('%s %s' % ( self.first_name, self.last_name ))",
"def setFirstName(self, firstName):\r\n self.firstName = firstName"
] | [
"0.861615",
"0.84696996",
"0.8462464",
"0.8350101",
"0.8350101",
"0.83253694",
"0.83253694",
"0.83253694",
"0.83061045",
"0.8267587",
"0.8145835",
"0.8013964",
"0.7967768",
"0.7967768",
"0.7913839",
"0.7835207",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.77401644",
"0.7734872",
"0.7733252",
"0.7723309",
"0.7688042",
"0.7676038",
"0.7668229",
"0.76529676",
"0.7617979",
"0.75920105",
"0.7577096",
"0.7573333",
"0.7557959",
"0.75339234",
"0.7512905",
"0.75100213",
"0.7502872",
"0.7438488",
"0.74253684",
"0.74199843",
"0.7384119",
"0.73709047",
"0.73709047",
"0.7366533",
"0.73592407",
"0.73558617",
"0.733182",
"0.7318626",
"0.7316236",
"0.7313408",
"0.7290654",
"0.7288264",
"0.728204",
"0.72777665",
"0.7252648",
"0.7239126",
"0.7204984",
"0.719707",
"0.7189808",
"0.7189808",
"0.7189808",
"0.7189808",
"0.7189808",
"0.7189808",
"0.7189808",
"0.7189808",
"0.7189808",
"0.7182608",
"0.7172876",
"0.7172876",
"0.71676713",
"0.71623874",
"0.71597576",
"0.71597576",
"0.71419364",
"0.71419364",
"0.7138903",
"0.7130323",
"0.7123409",
"0.7116093",
"0.7116093",
"0.7116093",
"0.7113488",
"0.7087689",
"0.7075038",
"0.706234",
"0.7048567",
"0.7044058"
] | 0.0 | -1 |
.last_name will return the correct last name | def test_last_name(self):
john_starks = Athlete(first_name="John", last_name="Starks", sport="NBA", recommendation="a")
self.assertEqual(john_starks.last_name, "Starks") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_last_name(self) -> str:\n return self.last_name",
"def last_name(self, instance):\r\n return instance.user.last_name",
"def get_last_name(self):\n return self._last_name",
"def getLastname(self):\n return self.lastname",
"def lastname(self):\n return self._lastname",
"def last_name(self):\n return self._last_name",
"def last_name(self):\n return self._last_name",
"def last_name(self):\n return self._last_name",
"def last_name(self):\n return self._last_name",
"def last_name(self) -> str:\n return self._last_name",
"def last_name():\r\n\r\n return surnames()",
"def getLastName(self):\n\t\treturn self.LastName",
"def getLastName(self):\n return self.lastName",
"def getLastName(self):\n return self.lastName",
"def getLastName(self):\n return self.lastName",
"def getLastName(self):\n return self.lastName",
"def getLastName(self):\n return self.lastName",
"def last_name(self):\n\n return self._last_name",
"def last_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"last_name\")",
"def last_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"last_name\")",
"def last_name():\n return dice.choice(names.lastname)",
"def get_last_name(self):\n element = self.driver.find_element(*self.lastname_textbox_selector)\n return element.get_attribute(\"value\")",
"def ldap_get_lastname(self, user):\n result = super(Auth42, self)._search_not_empty(user)\n if result is not None:\n lastname = result.get(\"last-name\")[0]\n return lastname\n\n return None",
"def test_last_name_first_name(self):\n current_resume = resume.objects.first()\n expected = 'Bielinski, Nicholas'\n case = current_resume.last_name_first_name()\n self.assertEqual(case, expected)",
"def LastName(self, reg_last_name = VALUE_NOT_SET):\n if reg_last_name != VALUE_NOT_SET:\n self.__reg_last_name = reg_last_name\n try:\n self.__contact.AdditionalInfo().LastName(self.__reg_last_name)\n except:\n pass\n else:\n if not self.__reg_last_name:\n self.__reg_last_name = None\n return self.__reg_last_name",
"def resolve_last_name(obj, _):\n return obj.last_name.decode()",
"def get_last_name(people, individual):\n surname = people[individual]['NAME'].split()\n return surname[1]",
"def get_full_name(self):\n return self.name+self.last_name",
"def first_last_name(obj):\n return '%s %s' % (obj.first_name, obj.last_name)",
"def get_short_name(self):\n return self.last_name",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def last_name(self, name):\n self._last_name = name",
"def get_user_lastname():\n if not is_authenticated() or 'samlUserdata' not in session:\n return None\n\n lastname = session.get('samlUserdata', {}).get(SAML_ATTRIBUTES.get('last_name', None), False)\n\n return lastname[0] if lastname else not_found('lastname')\n return None",
"def get_name(self):\r\n return ('%s %s' % ( self.first_name, self.last_name ))",
"def get_full_name(self):\n return self.last_name + self.first_name",
"def get_random_lastname_nameson ():\n name = db.get_database(DB_LAST_NAMESON).random_pop()\n if not name:\n return get_random_lastname_simple()\n if name.endswith('s'):\n if coinflip():\n return name\n else:\n return \"%son\" % name\n return \"%sson\" % name",
"def get_full_name(self):\n\t\tfull_name = '%s %s' % (self.first_name, self.last_name)\n\t\treturn full_name.strip()",
"def _last_name(self, full_name):\n name_partition = full_name.partition(u',')\n no_suffix = name_partition[0].strip()\n suffix = name_partition[2].strip()\n name_parts = no_suffix.split()\n part_count = len(name_parts)\n if part_count == 1 or part_count == 2:\n return name_parts[-1], suffix\n else:\n assert part_count > 2\n if name_parts[-2].islower():\n return u' '.join(name_parts[-2:]), suffix\n else:\n return name_parts[-1], suffix",
"def get_user_firstname_lastname(self, record):\n lower_first_name, lower_last_name = self.clean_user_names(record)\n\n #No first name and last name check email\n if lower_first_name is None and lower_last_name is None:\n\n lower_first_name, lower_last_name = \\\n self.extract_name_from_email(record)\n\n return lower_first_name, lower_last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def last_name(self, last_name):\n\n self._last_name = last_name",
"def get_full_name(self):\n return self.first_name+\" \"+self.last_name",
"def get_short_name(self):\n last_name = self.last_name\n first_name = self.first_name\n if (not (last_name and not last_name.isspace())):\n \"\"\" If last name is empty or none then return first name\"\"\"\n return first_name\n else:\n return last_name",
"def get_full_name(self):\r\n full_name = '%s %s' % (self.first_name, self.last_name)\r\n return full_name.strip()",
"def get_full_name(self):\r\n full_name = '%s %s' % (self.first_name, self.last_name)\r\n return full_name.strip()",
"def name(self):\n return \"%s %s\" % (self.first_name, self.last_name)",
"def set_last_name(self, last_name):\n self.last_name = last_name",
"def get_full_name(self):\n return self.first_name + ' ' + self.last_name",
"def test_last_name(self, unromanized, romanized, expected):\n with mute_signals(post_save):\n profile = ExamProfileFactory(\n profile__last_name=unromanized,\n profile__romanized_last_name=romanized,\n )\n assert CDDWriter.last_name(profile) == expected",
"def full_name(self):\n \tif self.first_name and self.last_name:\n \t\treturn \"{} {}\".format(self.first_name, self.last_name)",
"def get_name(self):\n return \"%s %s\" % (\n self.first_name,\n self.last_name\n )",
"def get_full_name(self):\n full_name = f'{self.first_name} {self.last_name}' if self.first_name and self.last_name else self.username\n return full_name.strip()",
"def test_first_last_name(self):\n\t\tformatted_name = get_formatted_name('janos', 'jk')\n\t\tself.assertEqual(formatted_name, 'Janos Jk')",
"def get_full_name(self):\n return \"{0} {1}\".format(self.first_name, self.last_surname)",
"def lastname(self, lastname):\n\n self._lastname = lastname",
"def get_full_name(self):\n full_name = '{} {}'.format(self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n # The user is identified by their email address\n return self.first_name+' '+self.last_name",
"def full_name(self):\n return self.first_name + \" \" + self.last_name",
"def full_name(self,first_name):\n full_name = self.first_name + ' ' + self.last_name\n return full_name",
"def get_full_name(self):\n\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def get_full_name(self):\n\n full_name = '%s %s' % (self.first_name, self.last_name)\n return full_name.strip()",
"def test_first_last_name(self):\n formatted_name = get_formatted_name('jimi', 'hendrix')\n self.assertEqual(formatted_name, 'Jimi Hendrix')",
"def name_last_first(name):\n parsed_name = HumanName(name) # this is a smart parser that digests human names\n name = parsed_name.last+\", \"+parsed_name.first\n if(parsed_name.middle != \"\"):\n name = name+\" \"+parsed_name.middle\n return name",
"def get_full_name(self):\n return f'{self.first_name} {self.last_name}'",
"def get_full_name(self):\n return f\"{self.first_name} {self.last_name}\"",
"def get_full_name(self):\n return f\"{self.first_name} {self.last_name}\""
] | [
"0.86927557",
"0.86003095",
"0.85996276",
"0.8470737",
"0.8462683",
"0.84567153",
"0.84567153",
"0.84567153",
"0.84567153",
"0.84528154",
"0.8397316",
"0.8331911",
"0.8289265",
"0.8289265",
"0.8289265",
"0.8289265",
"0.8289265",
"0.8217353",
"0.82091343",
"0.82091343",
"0.8117021",
"0.79138285",
"0.78673995",
"0.7856519",
"0.7850201",
"0.7810443",
"0.77550465",
"0.773645",
"0.7649126",
"0.75946176",
"0.7520684",
"0.7510546",
"0.7464615",
"0.7429497",
"0.74026036",
"0.73865116",
"0.73674625",
"0.7322669",
"0.7317582",
"0.7314646",
"0.7314646",
"0.7314646",
"0.7314646",
"0.7314646",
"0.7314646",
"0.7314646",
"0.7314646",
"0.7314646",
"0.7314646",
"0.73029083",
"0.7301819",
"0.7295123",
"0.7295123",
"0.72683245",
"0.72444546",
"0.72336316",
"0.72336173",
"0.72170067",
"0.72099775",
"0.7206828",
"0.720516",
"0.7202401",
"0.7196774",
"0.71852195",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71844137",
"0.71217376",
"0.7121073",
"0.7120854",
"0.7111524",
"0.7111524",
"0.710437",
"0.7092115",
"0.7080191",
"0.7077294",
"0.7077294"
] | 0.0 | -1 |
.sport will return the correct sport | def test_sport(self):
john_starks = Athlete(first_name="John", last_name="Starks", sport="NBA", recommendation="a")
self.assertEqual(john_starks.sport, "NBA") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sport_lookup(sport):\n sport = sport.title()\n app.sport = sport\n return sport",
"def associate_sport(self, database):\n sport = Sport()\n if self.name.lower() in ['indoor_cycling', 'indoor cycling', 'virtual_ride', 'cycling', 'road_biking', 'outdoor_cycling', 'road cycling', 'cross cycling', 'offroad cycling', 'mountain_biking', 'mountain biking']:\n sport.name = \"Cycling\"\n elif self.name.lower() in ['running', 'Trail Running', 'Street Running', 'treadmill_running', 'treadmill running', 'trail_running', 'trail running']:\n sport.name = \"Running\"\n elif self.name.lower() in ['lap_swimming', 'pool swimming', 'swimming', 'open water swimming']:\n sport.name = 'Swimming'\n elif self.name.lower() in ['cardio', 'indoor_cardio']:\n sport.name = 'Cardio'\n elif self.name.lower() in ['strength_training', 'strength']:\n sport.name = 'Strength'\n elif self.name.lower() in ['hiking']:\n sport.name = 'Hiking'\n elif self.name.lower() in ['yoga']:\n sport.name = 'Yoga'\n elif self.name.lower() in ['inline_skating', 'inline hockey']:\n sport.name = 'Inline Skating'\n elif self.name.lower() in ['multi_sport', 'triathlon']:\n sport.name = 'Triathlon'\n elif self.name.lower() in ['wakeboarding']:\n sport.name = 'Wakeboarding'\n elif self.name.lower() in ['surfing']:\n sport.name = 'Surfing'\n elif self.name.lower() in ['other']:\n sport.name = 'Other'\n else:\n sport.name = self.name\n\n sport.add(database)\n self.sport_id = sport.id",
"def tournament(self):\n pass",
"def test_sport_id(self):\n result = self.test_client.sport_id\n\n assert result == \"1\"",
"def get_teams():",
"def seasonStats(personId,type = 'gameLog',group = 'hitting'):\n\n #playerInfo = get('people', {'personIds':personId})\n\n\n teamStats = get('person',{ 'ver':'v1' , 'personId':personId,'hydrate':['stats(group={},type={})'.format(group,type),'currentTeam']})\n return teamStats\n #iterate of stats and find the right player id\n #career stats broken\n #fix the season :2019\n #make function to get team id",
"def sport_locations(conn, sport):\r\n get_sport_code = \"SELECT code FROM sports WHERE name = (%s)\"\r\n #location_select = 'SELECT code FROM locations WHERE name = (?)'\r\n get_locations_id_code = 'SELECT id, code FROM locations'\r\n cursor = conn.cursor()\r\n cursor.execute(get_sport_code, sport)\r\n retrieved_list = cursor.fetchall()\r\n sport_code = retrieved_list[0][0]\r\n cursor.execute(get_locations_id_code)\r\n locs_param_list = []\r\n for item in cursor.fetchall():\r\n locs_param = dict()\r\n locs_param[\"id\"] = item[0]\r\n locs_param[\"code\"] = item[1]\r\n locs_param_list.append(locs_param)\r\n cursor.close()\r\n return (sport_code, locs_param_list)",
"def parse_sport(meta):\n sport_sids = []\n try:\n sport_sid = meta.get('sport').get('id')\n except Exception as e:\n sports = meta.get('sports')\n if len(sports) != 1:\n logger.info('number of sports returned is: %s', len(sports))\n for sport in sports:\n sport_sid = sport.get('id')\n sport_sids.append(sport_sid)\n logger.debug('sport_sid: %s', sport_sid)\n return sport_sids",
"def showSports():\n\n sports = session.query(Sport).order_by(asc(Sport.sportName))\n items = session.query(Item).order_by(desc(Item.id))\n return render_template('sports.html', sports=sports, items=items)",
"def get_people(team):",
"def cleanup_sportstype(self, workout):\n if self.name.lower() in ['indoor_cycling', 'virtual_ride']:\n self.name = 'Indoor Cycling'\n elif self.name.lower() in ['cycling', 'road_biking']:\n self.name = 'Road Cycling'\n elif self.name.lower() in ['mountain_biking']:\n self.name = 'Mountain Biking'\n elif self.name.lower() in ['running']:\n self.name = 'Running'\n elif self.name.lower() in ['treadmill_running']:\n self.name = 'Treadmill Running'\n elif self.name.lower() in ['trail_running']:\n self.name = 'Trail Running'\n elif self.name.lower() in ['lap_swimming', 'swimming']:\n self.name = 'Pool Swimming'\n elif self.name.lower() in ['open_water_swimming']:\n self.name = 'Open Water Swimming'\n elif self.name.lower() in ['cardio', 'indoor_cardio']:\n self.name = 'Cardio'\n elif self.name.lower() in ['strength_training']:\n self.name = 'Strength'\n elif self.name.lower() in ['hiking']:\n self.name = 'Hiking'\n elif self.name.lower() in ['yoga']:\n self.name = 'Yoga'\n elif self.name.lower() in ['inline_skating', 'inline hockey']:\n self.name = 'Inline Skating'\n elif self.name.lower() in ['multi_sport']:\n self.name = 'Triathlon'\n elif self.name.lower() in ['wakeboarding']:\n self.name = 'Wakeboarding'\n elif self.name.lower() in ['surfing']:\n self.name = 'Surfing'\n elif self.name.lower() in ['other']:\n if workout.name:\n if workout.name == 'Yoga':\n self.name = 'Yoga'\n if workout.name == 'Inline Hockey':\n self.name = 'Inline Skating'\n if workout.name == 'Radfahren':\n self.name = 'Road Cycling'\n else:\n self.name = 'Other'",
"def fetch_template_params_for(sport_name=\"aeronautics\"):\n data = get_image_data()\n postfix = '.png'\n try:\n item = list(filter(lambda x: sport_name + postfix in x, data))[0]\n except IndexError:\n print(\"No Sport Found by that name. Returning the default sport.\")\n item = list(filter(lambda x: \"aeronautics\" + postfix in x, data))[0]\n return item",
"async def get_league_players(season): \n if season == '2021-22':\n get_epl = 2021\n if season == '2020-21':\n get_epl = 2020\n if season == '2019-20':\n get_epl = 2019\n async with aiohttp.ClientSession() as session:\n understat = Understat(session)\n player = await understat.get_league_players(\"epl\", get_epl)\n # print(json.dumps(player))\n return player",
"def return_football_season(date=datetime.datetime.today()):\n date_aux = subtract_months(date, 6)\n beginning_year = str(date_aux.year)\n ending_year = date_aux.year + 1\n ending_year = str(ending_year)[-2:]\n season = ''.join([beginning_year, '-', ending_year])\n return season",
"def test_search_season(self):\n self.assertEquals(\n len(self.t['Scrubs'][1].search(\"First\")),\n 3\n )",
"def season(self, seasonnum, order='aired'):\n if order=='aired':\n seasons = self.seasons\n elif order == 'dvd':\n seasons = self.dvd_seasons\n try:\n return seasons[seasonnum]\n except KeyError:\n raise SeasonNotFoundError(\n 'Season no %s does not exists' % seasonnum\n ), None, sys.exc_info()[2]",
"def sentientPlanets():\n planet_list = []\n url = 'https://swapi-api.hbtn.io/api/species'\n while url is not None:\n data = requests.get(url).json()\n for species in data['results']:\n if ((species['designation'] == 'sentient'\n or species['designation'] == 'reptilian')):\n if species['homeworld'] is not None:\n hw = requests.get(species['homeworld']).json()\n planet_list.append(hw['name'])\n url = data['next']\n return planet_list",
"def tournament(self, name):\n self.name = name\n q = Query()\n data = TinyDB('app/data/db_tournaments.json').table('tournaments')\n\n self.search_result = data.search(\n (q.name == self.name) |\n (q.place == self.name)\n )\n\n if len(self.search_result) == 0:\n v_menu.View().search('tournament_none')\n return 'None'\n\n elif len(self.search_result) == 1:\n v_menu.View().search_tournaments(\n 'find_tournament',\n self.search_result[0]['name'],\n self.search_result[0]['place'],\n self.search_result[0]['start']\n )\n return self.search_result[0]['id']\n\n elif len(self.search_result) >= 2:\n for i in range(len(self.search_result)):\n v_menu.View().search_tournaments(\n 'find_tournaments',\n self.search_result[i]['name'],\n self.search_result[i]['place'],\n self.search_result[i]['start'], i+1\n )\n\n self.player_number = c_input.Input().select_menu_number(\n len(self.search_result))\n\n return self.search_result[self.player_number-1]['id']",
"def sentientPlanets():\n\n url = \"https://swapi-api.hbtn.io/api/species/\"\n planets = []\n while url is not None:\n r = requests.get(url)\n results = r.json()[\"results\"]\n for specie in results:\n if (specie[\"designation\"] == \"sentient\" or\n specie[\"classification\"] == \"sentient\"):\n\n planet_url = specie[\"homeworld\"]\n if planet_url is not None:\n p = requests.get(planet_url).json()\n planets.append(p[\"name\"])\n url = r.json()[\"next\"]\n return planets",
"def getTeam(self):\n return [\"The A-Team\", \"some other bloke\"]",
"def scrape():\n league_year = Config.get_property(\"league_year\")\n\n # Create table\n season_data = client.season_schedule(league_year)\n season_data = br_enum_to_string(season_data)\n return season_data",
"def test_basketballteams_get(self):\n pass",
"def getseason(data):\n ## Season key is the most reliable\n season = data.get(\"season\")\n if season:\n ## Season key is an integer formatted \"YYS\" and is 2000-based (i.e.- 171 == 2017-Winter)\n season = str(season)\n year = int(f\"20{season[:2]}\")\n ## Anichart Season key is 1-indexed\n season = int(season[2]) - 1\n ## This should normally pass; if it consistently does not, we'll have to investigate why\n try: return SeasonCharts.buildseason(season,year)\n ## If something goes wrong, we'll try another method\n except: print(f\"Failed to parse season: {data['season']}\")\n ## Next, we'll iterate over rankings to try to determine the season/year\n ## There are multiple types of rankings based on season, year, and both combined,\n ## so we'll piece it together based on whatever we come across first\n season,year = None,None\n for ranking in data.get(\"rankings\",list()):\n ## Quicker exit (without just making this loop its own function)\n if season and year: continue\n ## We'll ignore stuff we've already gotten and assume that nothing in\n ## rankings contradicts eachother\n if not season:\n ## Defaults to None one way or another if it's not supplied\n season = ranking.get(\"season\")\n if not year: year = ranking.get(\"year\")\n ## Check if we made it\n if season and year:\n ## As above, this should always work out-of-the-box\n try: return SeasonCharts.buildseason(season,year)\n except: print(season,year)\n ## Welp, we're stumped...\n return None",
"def distributeSeason(self):\n i = 1\n for day in self.daylist:\n if i >= monthbeg[5] and i < monthbeg[9]: #june through SEpt as per SCE\n day.season = 'summer' #https://www.sce.com/residential/rates/Time-Of-Use-Residential-Rate-Plans\n i = i + 1\n else:\n day.season = 'winter'\n i = i+1",
"def yield_team(self) -> str: # pragma: no cover",
"def get_team_roster(league):\n pass",
"def season_series(game_id, pref_team, other_team, last_season=False):\n\n # Init empty dictionaries and lists\n games_against = list()\n pref_toi = dict()\n pref_goals = dict()\n pref_assists = dict()\n pref_points = dict()\n pref_record = {\"wins\": 0, \"losses\": 0, \"ot\": 0}\n roster_player = True\n\n # If this is the first game of the season, we can set the 'last_season' flag to enable the\n # season series function to check last year's season series between the two teams.\n if not last_season:\n season_start = str(game_id)[0:4]\n season_end = str(int(season_start) + 1)\n yesterday = datetime.now() - timedelta(days=1)\n # yesterday = datetime.now() + timedelta(days=50)\n # schedule_url = (\n # f\"/schedule?teamId={pref_team.team_id}\"\n # f\"&expand=schedule.broadcasts,schedule.teams&startDate=\"\n # f\"{season_start}-08-01&endDate={yesterday:%Y-%m-%d}\"\n # )\n schedule_url = (\n f\"/schedule?teamId={pref_team.team_id}\"\n f\"&expand=schedule.broadcasts,schedule.teams\"\n f\"&season={season_start}{season_end}\"\n )\n else:\n season_start = int(str(game_id)[0:4]) - 1\n season_end = str(int(season_start) + 1)\n yesterday = datetime.now() - timedelta(days=1)\n # yesterday = datetime.now() + timedelta(days=50)\n # schedule_url = (\n # f\"/schedule?teamId={pref_team.team_id}\"\n # f\"&expand=schedule.broadcasts,schedule.teams&startDate=\"\n # f\"{season_start}-08-01&endDate={season_end}-06-01\"\n # )\n schedule_url = (\n f\"/schedule?teamId={pref_team.team_id}\"\n f\"&expand=schedule.broadcasts,schedule.teams\"\n f\"&season={season_start}{season_end}\"\n )\n\n schedule = api.nhl_api(schedule_url).json()\n dates = schedule[\"dates\"]\n\n # Loop through scheduled to get previously played games against\n for date in dates:\n game = date[\"games\"][0]\n game_type = game[\"gameType\"]\n game_id = game[\"gamePk\"]\n game_team_home = game[\"teams\"][\"home\"][\"team\"][\"name\"]\n game_team_away = game[\"teams\"][\"away\"][\"team\"][\"name\"]\n teams = [game_team_away, game_team_home]\n game_status = game[\"status\"][\"abstractGameState\"]\n if game_type == \"R\" and game_status == \"Final\" and other_team.team_name in teams:\n game_feed = f\"/game/{game_id}/feed/live\"\n games_against.append(game_feed)\n\n # If the two teams haven't played yet, just exit this function\n if not games_against:\n return None, None, None\n\n # Loop through newly created games_against list to get each stats\n for feed in games_against:\n game = api.nhl_api(feed).json()\n game_data = game[\"gameData\"]\n home_team_name = game_data[\"teams\"][\"home\"][\"name\"]\n pref_homeaway = \"home\" if home_team_name == pref_team.team_name else \"away\"\n other_homeaway = \"away\" if home_team_name == pref_team.team_name else \"home\"\n\n # Get season series\n end_period = game[\"liveData\"][\"linescore\"][\"currentPeriod\"]\n extra_time = True if end_period > 3 else False\n pref_score = game[\"liveData\"][\"linescore\"][\"teams\"][pref_homeaway][\"goals\"]\n other_score = game[\"liveData\"][\"linescore\"][\"teams\"][other_homeaway][\"goals\"]\n if pref_score > other_score:\n pref_record[\"wins\"] += 1\n elif other_score > pref_score and extra_time:\n pref_record[\"ot\"] += 1\n else:\n pref_record[\"losses\"] += 1\n\n season_series_str = f\"Series: {pref_record['wins']}-\" f\"{pref_record['losses']}-{pref_record['ot']}\"\n\n # Get stats leaders\n # pref_teamstats = game[\"liveData\"][\"boxscore\"][\"teams\"][pref_homeaway][\"teamStats\"]\n pref_playerstats = game[\"liveData\"][\"boxscore\"][\"teams\"][pref_homeaway][\"players\"]\n for id, player in pref_playerstats.items():\n try:\n # Calculate TOI\n player_toi_str = player[\"stats\"][\"skaterStats\"][\"timeOnIce\"]\n player_toi_minutes = int(player_toi_str.split(\":\")[0])\n player_toi_seconds = int(player_toi_str.split(\":\")[1])\n player_toi = (player_toi_minutes * 60) + player_toi_seconds\n pref_toi[id] = pref_toi.get(id, 0) + player_toi\n\n # Point Totals\n player_goal_str = player[\"stats\"][\"skaterStats\"][\"goals\"]\n pref_goals[id] = pref_goals.get(id, 0) + int(player_goal_str)\n player_assist_str = player[\"stats\"][\"skaterStats\"][\"assists\"]\n pref_assists[id] = pref_assists.get(id, 0) + int(player_assist_str)\n player_points = int(player_goal_str) + int(player_assist_str)\n pref_points[id] = pref_points.get(id, 0) + int(player_points)\n\n except KeyError:\n pass\n\n # Calculate Stats Leaders\n sorted_toi = sorted(pref_toi.values(), reverse=True)\n leader_toi = sorted_toi[0]\n\n sorted_points = sorted(pref_points.values(), reverse=True)\n leader_points = sorted_points[0]\n\n # Get TOI leader\n for id in pref_toi.keys():\n if pref_toi[id] == leader_toi:\n player_name = roster.player_attr_by_id(pref_team.roster, id, \"fullName\")\n if player_name is None:\n roster_player = False\n player_id_only = id.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n leader_toi_avg = leader_toi / len(games_against)\n m, s = divmod(leader_toi_avg, 60)\n toi_m = int(m)\n toi_s = int(s)\n toi_s = \"0{}\".format(toi_s) if toi_s < 10 else toi_s\n toi_avg = \"{}:{}\".format(toi_m, toi_s)\n player_short_name = f\"{player_name[0]}. {' '.join(player_name.split()[1:])}\"\n toi_leader_str = \"TOI Leader: {} with {} / game.\".format(player_short_name, toi_avg)\n\n # Handle tied points leaders\n point_leaders = list()\n for id in pref_points.keys():\n if pref_points[id] == leader_points:\n point_leaders.append(id)\n\n if leader_points == 0:\n points_leader_str = \"Points Leader: None (all players have 0 points).\"\n\n elif len(point_leaders) == 1:\n leader = point_leaders[0]\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \"fullName\")\n # If the player is no longer on the team, get their information (change string here?)\n if player_name is None:\n roster_player = False\n player_id_only = leader.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n player_goals = pref_goals[leader]\n player_assists = pref_assists[leader]\n if not roster_player:\n points_leader_str = (\n f\"Points Leader: {player_name} with {leader_points} points \"\n f\"({player_goals}G {player_assists}A) \"\n )\n else:\n points_leader_str = \"Points Leader: {} with {} ({}G {}A).\".format(\n player_name, leader_points, player_goals, player_assists\n )\n\n elif len(point_leaders) > 3:\n point_leaders_with_attrs = list()\n for leader in point_leaders:\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \"fullName\")\n if player_name is None:\n player_id_only = leader.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n player_goals = pref_goals[leader]\n player_assists = pref_assists[leader]\n player_short_name = f\"{player_name[0]}. {' '.join(player_name.split()[1:])}\"\n point_leaders_with_attrs.append(player_short_name)\n\n point_leaders_joined = \", \".join(point_leaders_with_attrs[0:3])\n leftover_leaders = len(point_leaders) - 3\n points_leader_str = (\n f\"Points Leaders: {point_leaders_joined} & {leftover_leaders} others ({leader_points} each).\"\n )\n\n else:\n point_leaders_with_attrs = list()\n for leader in point_leaders:\n player_name = roster.player_attr_by_id(pref_team.roster, leader, \"fullName\")\n if player_name is None:\n player_id_only = leader.replace(\"ID\", \"\")\n player_name = roster.nonroster_player_attr_by_id(player_id_only, \"fullName\")\n player_goals = pref_goals[leader]\n player_assists = pref_assists[leader]\n player_short_name = f\"{player_name[0]}. {' '.join(player_name.split()[1:])}\"\n player_str = f\"{player_short_name} ({player_goals}G {player_assists}A)\"\n point_leaders_with_attrs.append(player_str)\n\n point_leaders_joined = (\n f\", \".join(point_leaders_with_attrs[:-1]) + f\" & {point_leaders_with_attrs[-1]}\"\n )\n points_leader_str = \"Points Leaders: {} with {} each.\".format(point_leaders_joined, leader_points)\n\n return season_series_str, points_leader_str, toi_leader_str",
"def test_retrieve_team(self):\n pass",
"def get_game(self, game_id):\n \n session = requests.session()\n response = session.get(self.baseURL + str(game_id), headers=self.headers)\n soup = BeautifulSoup(response.text)\n \n #get teams\n defeated_by = False \n game_header = soup.find_all(text=re.compile('defeats'))\n \n if len(game_header) == 0:\n game_header = soup.find_all(text=re.compile('defeated by'))\n \n if (len(game_header)) == 0:\n game_header = soup.find_all(text=re.compile('defeat'))\n \n if (len(game_header)) == 0:\n game_header = soup.find_all(text=re.compile('drew'))\n defeated_by = True \n else:\n defeated_by = True \n\n if defeated_by: \n teams = self.remove_long_names(game_header[1]).replace('\\n', '')\n home_team = teams.split(' ')[0]\n away_team = teams.split(' ')[3]\n else:\n teams = self.remove_long_names(game_header[1]).replace('\\n', '')\n home_team = teams.split(' ')[0]\n away_team = teams.split(' ')[2]\n \n date_string = game_header[0].split(' ')\n date_string_find = [date.lower() for date in date_string]\n \n venue = date_string[date_string_find.index('at') + 1]\n \n #get round\n round_num = None\n \n try:\n date_string_find.remove('')\n except:\n pass\n \n try:\n round_num = int(date_string[date_string_find.index('round') + 1])\n except:\n try:\n round_num = date_string_find[date_string_find.index('final') - 1] + ' final'\n except:\n round_num = date_string_find[date_string_find.index('semi-final')]\n \n date = date_string[-3:]\n date = ' '.join(date) \n date = parser.parse(date)\n \n #get attendance\n attend = soup.find_all(text=re.compile('Attendance'))\n attendance = 0\n \n if (len(attend) > 3):\n attendance = int(attend[1].split(' ')[-1])\n \n #get stats \n away_stats = {}\n home_stats = {}\n \n for stat in stats:\n stat_row = soup.find_all('td', text=stat)[0].find_parent('tr')\n elements = stat_row.find_all('td')\n \n if elements[0].text == '-':\n home_stats[stat] = None\n else:\n home_stats[stat] = elements[0].text\n \n if elements[0].text == '-':\n away_stats[stat] = None\n else:\n away_stats[stat] = elements[2].text\n \n return Game(game_id, home_team, away_team, venue, round_num, date, attendance, home_stats, away_stats)",
"def getOpposition(self, team):\n if team.lower() == self.homeTeam['name']:\n return self.awayTeam['name']\n elif team.lower() == self.awayTeam['name']:\n return self.homeTeam['name']\n else:\n return None",
"def get_info_from_api(team_name):\n if \"-\" in team_name:\n team_name = team_name.replace(\"-\", \"+\")\n if \"brighton\" in team_name: # some teams has different names than in sofa-score\n team_name = \"brighton\"\n if \"leicester\" in team_name:\n team_name = \"leicester\"\n if \"norwich\" in team_name:\n team_name = \"norwich\"\n if \"mallorca\" in team_name:\n team_name = \"mallorca\"\n if \"parma\" in team_name:\n team_name = \"parma+calcio\"\n if \"bayern\" in team_name:\n team_name = \"bayern\"\n if \"koln\" in team_name:\n team_name = \"fc+koln\"\n if \"union+berlin\" in team_name:\n team_name = \"union+berlin\"\n if \"fsv+mainz\" in team_name:\n team_name = \"mainz\"\n if \"hoffenheim\" in team_name:\n team_name = \"hoffenheim\"\n if \"mgladbach\" in team_name:\n team_name = \"borussia+monchengladbach\"\n if \"schalke\" in team_name:\n team_name = \"schalke\"\n if \"leverkusen\" in team_name:\n team_name = \"leverkusen\"\n if \"paderborn\" in team_name:\n team_name = \"paderborn\"\n print(team_name)\n response = requests.get(cfg.API_URL + team_name)\n team_data = json.loads(response.text)\n return team_data['teams'][0]",
"def get_final_coach_for_each_season(self):\n self.final_coach_for_season = (\n self.num_days_coach_for_season\n .groupby(['Season','TeamID'])\n .agg({\"CoachName\":\"count\"})\n .reset_index()\n .rename(columns={\"CoachName\":\"coach_counts\"})\n .merge(self.num_days_coach_for_season,how='left',on=['Season','TeamID'])\n .pipe(lambda x:x.assign(final_coach = np.where(x.num_season >= 0.5, x.CoachName, \"ignore\")))\n [['Season','TeamID','final_coach']]\n )",
"def test_seasons(self):\n response = Tmdb.season(tmdb_show_id = 69740, season_number = 1)\n self.assertTrue(int(response.status_code) == 200)\n data = response.json()\n self.assertTrue(isinstance(data['episodes'], list))\n # TODO check if all the shows are in the good format (can be from_dict/to_dict)",
"def __init__(self, player):\n self.player = player\n player.career.seasons.append(self)\n self.team = player.team\n self.league = self.team.league\n self.year = self.team.cosmos.year",
"def get_driver(sport=\"football/nfl\", sleep=1.5):\n\n driver = base_driver()\n driver.get(ROOT_URL + \"sports/\" + sport)\n\n if sleep:\n time.sleep(sleep)\n\n return driver",
"def get_name_of_same_named_teams(sname, sid):\n\n if sname == 'Zamora':\n if sid == 9404:\n return 'Zamora FC' # Venezuela\n elif sid == 26394:\n return 'Zamora CF' # Spain\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Atromitos':\n if sid == 9849:\n return 'Atromitos A.' # Greece\n elif sid == 2953:\n return 'Atromitos Yeroskipou' # Cyprus\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Atromitos/H.': # sid 9842\n return None\n elif sname == 'Libertas':\n if sid == 11019:\n return 'Libertas Novska' # Croatia\n elif sid == 19357:\n return 'A.C Libertas' # San Marino\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Irtysh':\n if sid == 4000:\n return 'Irtysh Omsk' # Russia\n elif sid == 11058:\n return 'Irtysh Pavlodar' # Kazakstan\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Linense':\n if sid == 7812:\n return 'Atletico Linense' # Brazil\n elif sid == 26006:\n return 'Real Balompedica Linense' # SPain\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n elif sname == 'Sorrento':\n if sid == 10773:\n return 'Sorrento FC' # Australia\n elif sid == 24305:\n return 'F.C. Sorrento' # Italy\n else:\n logger.error('Sportmonk ids for same named teams \"%s\" have changed', sname)\n return sname\n else:\n return sname",
"def season_game_logs(team, year):\n\n # Check year value\n if year > 2019 or year < 1950:\n raise ValueError('Year Value Incorrect')\n\n # Rename teams that moved\n team = scrape_utils.rename_team(team, year)\n\n # Get HTML content\n url = 'http://www.basketball-reference.com/teams/%s/%s/gamelog' % (team, year)\n r = requests.get(url)\n soup = BeautifulSoup(r.content, \"html.parser\")\n season_stats = soup.find(id='tgl_basic')\n games = season_stats.find('tbody')\n\n # MongoDB Collection\n m = mongo.Mongo()\n\n # To find opponent statistics\n opponent = re.compile('^opp_.*$')\n\n # Loop through every game in a team's season\n for game in games.find_all('tr', {'class': None}):\n\n curr_team = {'team': team}\n opp_team = {}\n\n # Loop through each stat\n for stat in game.find_all('td'):\n\n stat_name = stat['data-stat']\n\n # These are opponent stats\n if re.match(opponent, stat_name):\n opp_team[stat_name[4:]] = scrape_utils.stat_parse(stat_name, stat.string)\n else:\n curr_team[stat_name] = scrape_utils.stat_parse(stat_name, stat.string)\n\n # Remove unnecessary information\n del curr_team['game_season']\n del curr_team['x']\n\n # Rename relocated teams\n curr_team['team'] = scrape_utils.rename_team(team)\n opp_team['team'] = scrape_utils.rename_team(opp_team.pop('id'))\n\n # Use the same ID as basketball reference\n result = {'date': datetime.strptime(curr_team.pop('date_game'), \"%Y-%m-%d\"),\n 'season': year,\n 'result': scrape_utils.determine_home_win(curr_team['game_location'], curr_team.pop('game_result')),\n '_id': game.find('a')['href'][-17:-5]}\n\n # Place the teams in the correct spot depending on who is the home team\n if curr_team.pop('game_location') == 0:\n result['home'] = curr_team\n result['away'] = opp_team\n else:\n result['home'] = opp_team\n result['away'] = curr_team\n\n # Insert into database\n m.insert('game_log', result)",
"def fa_finder(league_no, team_name):\n ros_proj_b_list = BatterProjection.objects.all()\n ros_proj_p_list = PitcherProjection.objects.all()\n player_comp = {}\n pitching_fa_list = yahoo_players(league_no, \"P\")\n batting_fa_list = yahoo_players(LEAGUE_NO, \"B\")\n avail_pitching_fas = rate_avail_players(pitching_fa_list, ros_proj_p_list)\n yahoo_team = get_single_yahoo_team(league_no, team_name)\n team_pitching_values = rate_team(yahoo_team, ros_proj_p_list)\n avail_batting_fas = rate_avail_players(batting_fa_list, ros_proj_b_list)\n team_batting_values = rate_team(yahoo_team, ros_proj_b_list)\n\n player_comp['Team Name'] = yahoo_team['team_name']\n player_comp['Pitching FAs'] = avail_pitching_fas\n player_comp['Pitching Team'] = team_pitching_values\n player_comp['Batting FAs'] = avail_batting_fas\n player_comp['Batting Team'] = team_batting_values\n\n return player_comp",
"def season_games(year):\n\tLOG.debug('Getting season %d', year)\n\tdata = read_html(io=season_games_url(year),\n\t\t\t\t\t attrs={'id': 'games'},\n\t\t\t\t\t infer_types=False,\n\t\t\t\t\t header=0)\n\tif len(data) != 1:\n\t\traise CantFindTheRightTable\n\tdata = data.pop()\n\n\t# Cleaning.\n\tdel data[\"Unnamed: 3\"]\n\t# The code below issues \"UserWarning: \" So we catch UserWarnings.\n\twith warnings.catch_warnings():\n\t\twarnings.filterwarnings(action='ignore', category=UserWarning,\n\t\t\t\t\t\t\t\tmodule=r'pandas\\.core\\.frame',\n\t\t\t\t\t\t\t\tmessage=(r\"Boolean Series key will be reindexed\"\n\t\t\t\t\t\t\t\t\t\t r\" to match DataFrame index\\.\"))\n\t\t# These rows are mid-table header rows.\n\t\tdata = data[data.Week != \"Week\"][data.Week != \"nan\"]\n\n\tdata['week'] = (data.Week\n\t\t\t\t\t.replace(\"WildCard\", \"wild-card\")\n\t\t\t\t\t.replace(\"Division\", \"divisional\")\n\t\t\t\t\t.replace(\"ConfChamp\", \"conference\")\n\t\t\t\t\t.replace(\"SuperBowl\", \"super-bowl\")\n\t\t\t\t\t.apply(\n\t\t\t\t\t\tlambda s: (int(s)\n\t\t\t\t\t\t\t\t if all(c in '1234567890' for c in s)\n\t\t\t\t\t\t\t\t else s)))\n\tdel data['Week']\n\n\tdata['season'] = year\n\tdata['game_date'] = pd.to_datetime(\n\t\tdata.Date\n\t\t.replace(r\"$\", r\", %d\" % year, regex=True)\n\t\t.replace(r\"^(January|February) (\\d+), \\d+$\", r\"\\1 \\2, %d\" % (year + 1),\n\t\t\t\t regex=True))\n\tdel data['Date']\n\n\tfor column in \"PtsW\", \"PtsL\", \"YdsW\", \"TOW\", \"YdsL\", \"TOL\":\n\t data[column] = data[column].apply(int)\n\n\tdata['WatL'] = data['Unnamed: 5'].apply(lambda x: x == '@')\n\tdel data['Unnamed: 5']\n\tdata['hometeam'] = (~data.WatL * data['Winner/tie'] +\n\t\t\t\t\t\tdata.WatL * data['Loser/tie'])\n\tdata['awayteam'] = (data.WatL * data['Winner/tie'] +\n\t\t\t\t\t\t~data.WatL * data['Loser/tie'])\n\tdata['winner'] = data['Winner/tie']\n\tfor column in 'Winner/tie', 'Loser/tie', \"WatL\":\n\t\tdel data[column]\n\tfor column in 'hometeam', 'awayteam', 'winner':\n\t\tdata[column] = data[column].apply(lambda s: s.split()[-1].lower())\n\n\treturn data",
"def get_current_player_season(self):\n return self.get_player_season(\"current\")",
"def game_from_team_name(games, team_name, verbose=False):\n for game in games:\n teams = teams_from_game(game)\n if team_name in teams:\n if verbose:\n print(f\"found {team_name} game\")\n return game\n if verbose:\n print(f\"{team_name} game NOT found\")\n return None",
"def get_competition_season_type(season):\n default_type = games.models.CompetitionSeason.winter\n try:\n season_name = season.name\n if season_name.find(\"/\") == -1:\n return games.models.CompetitionSeason.summer\n return default_type\n except Exception as e:\n return default_type",
"def test_get_teams(self):\n pass",
"def test_get_teams(self):\n pass",
"def __init__(self, team):\n # Set basic attributes\n self.team = team\n team.season = self\n team.history.seasons.append(self)\n self.league = team.league\n self.year = team.cosmos.year\n # Record city, nickname, and organization, since this could change later (i.e.,\n # we can't rely on accessing these attributes of the franchise itself)\n self.city = team.city\n self.nickname = team.nickname\n self.organization = team.organization\n self.owner = team.owner\n self.manager = team.manager\n self.scout = team.scout\n self.players = team.players\n # Prepare attributes\n self.games = []\n # Prepare award attributes\n self.championship = None\n self.pennant = None\n self.division_title = None\n self.wild_card_berth = None",
"def get_team(self):\n if self.team:\n return self.team\n return None",
"def get_season_no(token, url):\n headers = {'Accept': 'application/json', 'Authorization': token}\n r = requests.get(url, headers=headers)\n json_data = json.loads(r.text).get('data')\n high_season = 1\n for episode in json_data:\n if episode.get('airedSeason') > high_season:\n high_season = episode.get('airedSeason')\n return high_season",
"def getTeam(self):\n return self.team",
"def get_teams(self):\n url = 'teams'\n result = self.get(url)\n return result.get('teams', result)",
"def tournament():\n return min(sample(population, sample_size)).chromosome[:]",
"def clubs(self):\n catalog = getToolByName(self.context, 'portal_catalog')\n\n return [dict(url=club.getURL(), title=club.Title, sport=club.Sport,\n address=club.Description) for club in\n catalog({'object_provides': IClub.__identifier__,\n 'path': dict(query='/'.join(self.context.getPhysicalPath()),\n depth=1), 'sort_on': 'sortable_title'})]",
"def from_id(self, id_):\n return next((season for season in self._seasons if season.id == id_), None)",
"def get_player_stats_from_game(team, year, week):",
"def with_season(title, season):\n videos = list(mythVideo.searchVideos(title = title, season = season))\n\n for video in videos:\n video.label = video.title + \" - \" + video.subtitle\n video.url = \"/videos/\" + video.title + \"/\" + video.hash\n\n videos = sorted(videos, key = lambda video: video.episode)\n return render_template('list.html', items = videos, page_title = title + \" Season \" + str(season))",
"def swissPairings():\n standings_before_pairing = self.playerStandings()\n\n print \"Standings: \" , repr(standings_before_pairing), \" \", dir(standings_before_pairing)\n #print standings_before_pairing\n return standings_before_pairing",
"def getshowsbyseason(season,year, session = None):\n url = APIURL.format(season=season, year = year)\n headers = {\"X-CSRF-TOKEN\":session.cookies['X-CSRF-TOKEN']}\n data = alrequests.GET_json(url,session = session, headers=headers)\n return {cat:[Show(**show) for show in shows] for cat,shows in data.items()}",
"def get_season_url(\n base_url: str, year: Optional[int] = None, season: Optional[str] = None\n) -> str:\n if year is None or season is None:\n return f\"{base_url}/season\"\n return f\"{base_url}/season/{year}/{season.lower()}\"",
"def findAirport(state):\n if state == \"NSW\":\n airport = \"Sydney Airport\"\n elif state == \"VIC\":\n airport = \"Melbourne Airport\"\n elif state == \"QLD\":\n airport = \"Brisbane Airport\"\n elif state == \"TAS\":\n airport = \"Hobart Airport\"\n elif state == \"WA\":\n airport = \"Perth Airport\"\n elif state == \"SA\":\n airport = \"Adelaide Airport\"\n elif state == \"NT\":\n airport = \"Darwin Airport\"\n return airport",
"def create_instance(raw_game, game_acbid, season, competition_phase,round_phase=None):\n # There are two different statistics table in acb.com. I assume they created the new one to introduce the +/- stat.\n estadisticas_tag = '.estadisticasnew' if re.search(r'<table class=\"estadisticasnew\"', raw_game) else '.estadisticas'\n\n doc = pq(raw_game)\n game_dict = dict()\n\n \"\"\"\n Each game has an unique id in acb.com. The id has 5 digits, where the first two digits are the season code (the\n oldest season in 1956 has code 1) and the three last are the number of the game (a simple counter since the beginning\n of the season).\n\n This id can be used to access the concrete game within the link 'http://www.acb.com/fichas/LACBXXYYY.php'\n \"\"\"\n game_dict['game_acbid'] = game_acbid\n game_dict['season'] = season.season\n game_dict['competition_phase'] = competition_phase\n game_dict['round_phase'] = round_phase\n\n\n # Information about the teams.\n info_teams_data = doc(estadisticas_tag).eq(1)\n home_team_name = None\n away_team_name = None\n\n \"\"\"\n We only have the names of the teams (text) within the doc. We will look for its associated id by looking in our teamname table, where\n we have all the historical official names for each team and season. However the ACB sometimes doesn't agree in the names\n and writes them in different ways depending on the game (sometimes taking older names or making small changes).\n For instance VALENCIA BASKET CLUB instead of VALENCIA BASKET.\n So if there is not such a direct correspondance we will take the closest match.\n \"\"\"\n for i in [0, 2]:\n team_data = info_teams_data('.estverde').eq(i)('td').eq(0).text()\n team_name = re.search(\"(.*) [0-9]\", team_data).groups()[0]\n\n try: ## In case the name of the team is exactly the same as one stated in our database for a season\n team_acbid = TeamName.get(TeamName.name == team_name).team_id.team_acbid\n team = Team.get(Team.team_acbid == team_acbid)\n\n except TeamName.DoesNotExist: ## In case there is not an exact correspondance within our database, let's find the closest match.\n query = TeamName.select(TeamName.team_id, TeamName.name)\n teams_names_ids = dict()\n for q in query:\n teams_names_ids[q.name] = q.team_id.id\n\n most_likely_team = difflib.get_close_matches(team_name, teams_names_ids.keys(), 1, 0.4)[0]\n team = Team.get(Team.id == teams_names_ids[most_likely_team])\n\n if most_likely_team not in season.mismatched_teams: # debug info to check the correctness.\n season.mismatched_teams.append(most_likely_team)\n logger.info('Season {} -> {} has been matched to: {}'.format(season.season, team_name, most_likely_team))\n\n # TeamName.get_or_create(**{'team': team, 'name': team_name, 'season': season.season})\n game_dict['team_home_id' if i == 0 else 'team_away_id'] = team\n home_team_name = team_name if i == 0 else home_team_name\n away_team_name = team_name if i != 0 else away_team_name\n\n # Information about the game.\n info_game_data = doc(estadisticas_tag).eq(0)\n\n scheduling_data = info_game_data('.estnegro')('td').eq(0).text()\n scheduling_data = scheduling_data.split(\"|\")\n journey, date, time, venue, attendance = list(map(lambda x: x.strip(), scheduling_data)) # Remove extra spaces.\n\n if date and time:\n day, month, year = list(map(int, date.split(\"/\")))\n hour, minute = list(map(int, time.split(\":\")))\n game_dict['kickoff_time'] = datetime.datetime(year=year, month=month, day=day, hour=hour, minute=minute)\n\n if attendance:\n try:\n game_dict['attendance'] = int(attendance.split(\":\")[1])\n except ValueError:\n pass\n\n if venue:\n game_dict['venue'] = venue\n\n if journey:\n game_dict['journey'] = journey.split(\" \")[1]\n\n if competition_phase=='cup':\n if int(journey.split(\" \")[1])==1:\n game_dict['round_phase'] =\"quarter_final\"\n elif int(journey.split(\" \")[1])==2:\n game_dict['round_phase'] =\"semi_final\"\n elif int(journey.split(\" \")[1])==3:\n game_dict['round_phase'] =\"final\"\n\n for i in range(2, 7):\n score_home_attribute = ''\n score_away_attribute = ''\n if i == 2:\n score_home_attribute = 'score_home_first'\n score_away_attribute = 'score_away_first'\n elif i == 3:\n score_home_attribute = 'score_home_second'\n score_away_attribute = 'score_away_second'\n elif i == 4:\n score_home_attribute = 'score_home_third'\n score_away_attribute = 'score_away_third'\n elif i == 5:\n score_home_attribute = 'score_home_fourth'\n score_away_attribute = 'score_away_fourth'\n elif i == 6:\n score_home_attribute = 'score_home_extra'\n score_away_attribute = 'score_away_extra'\n\n quarter_data = info_game_data('.estnaranja')('td').eq(i).text()\n if quarter_data:\n try:\n game_dict[score_home_attribute], game_dict[score_away_attribute] = list(\n map(int, quarter_data.split(\"|\")))\n except ValueError:\n pass\n\n referees_data = info_game_data('.estnaranja')('td').eq(0).text()\n if referees_data:\n referees = referees_data.split(\":\")[1].strip().split(\",\")\n referees = list(filter(None, referees))\n referees = list(map(lambda x: x.strip(), referees))\n n_ref = 1\n for referee in referees:\n game_dict['referee_'+str(n_ref)] = referee\n n_ref+=1\n\n try:\n game = Game.get(Game.game_acbid == game_dict['game_acbid'])\n except:\n game = Game.create(**game_dict)\n return game",
"def spreads(lines, sport):\n value = []\n for game in lines:\n combos = it.product(game['away_odds'].items(), game['home_odds'].items())\n try:\n value.extend([f'{sport} {game[\"game\"]} {combo[0][0]}: {combo[0][1][0]} {combo[0][1][1]} and '\n f'{combo[1][0]}: {combo[1][1][0]} {combo[1][1][1]}\\n\\n' for combo in combos\n if combo[0][1][0] + combo[1][1][0] >= 0 and combo[0][1][1] + combo[1][1][1] >= 0])\n except TypeError:\n print(combos)\n\n return value",
"def get_smmry_data(soup, game_dict):\n\n # Get date and time data.\n try:\n date_soup = soup.find(\"div\", {\"class\": \"spielbericht_tipp_status\"})\n league = date_soup.div.span.text\n date_string = date_soup.div.text\n date = re.search(r'\\d{2}.\\d{2}.\\d{2}', date_string).group(0)\n time = re.search(r'\\d{2}:\\d{2}', date_string).group(0)\n matchday = re.search(r'[|]\\d+', date_string).group(0)[1:]\n\n game_dict[\"league\"] = league\n game_dict[\"fb_date\"] = date\n game_dict[\"fb_time\"] = time\n game_dict[\"matchday\"] = matchday\n except AttributeError:\n pass\n\n # Get game result.\n try:\n result = soup.find(\"div\", {\"class\": \"stand\"}).text\n game_dict[\"result\"] = result\n except AttributeError:\n pass\n\n # Try to get the referee name.\n try:\n referee = soup.find(\"span\", {\"class\": \"schiri_link\"}).text\n game_dict[\"referee\"] = referee\n except AttributeError:\n pass\n\n # Get team, club name and repective url by team.\n try:\n smmry_soup = soup.find(\n \"div\", {\"class\": \"spielbericht_ergebnis_wrapper\"})\n club_title = smmry_soup.find_all(\"img\")\n team_title = smmry_soup.findAll(\"div\", {\"class\": \"teaminfo\"})\n\n # Loop through teams.\n for j, team in enumerate([\"home_\", \"away_\"]):\n game_dict[team + \"team\"] = team_title[j].a[\"title\"]\n game_dict[team + \"team_url\"] = team_title[j].a[\"href\"]\n game_dict[team + \"club\"] = club_title[j][\"title\"]\n except (AttributeError, TypeError):\n pass\n\n return game_dict",
"async def roster(\n self, ctx: commands.Context, season: Optional[YearFinder] = None, *, search: HockeyTeams\n ) -> None:\n season_str = None\n season_url = \"\"\n if season:\n if season.group(3):\n if (int(season.group(3)) - int(season.group(1))) > 1:\n return await ctx.send(_(\"Dates must be only 1 year apart.\"))\n if (int(season.group(3)) - int(season.group(1))) <= 0:\n return await ctx.send(_(\"Dates must be only 1 year apart.\"))\n if int(season.group(1)) > datetime.now().year:\n return await ctx.send(_(\"Please select a year prior to now.\"))\n season_str = f\"{season.group(1)}{season.group(3)}\"\n else:\n if int(season.group(1)) > datetime.now().year:\n return await ctx.send(_(\"Please select a year prior to now.\"))\n year = int(season.group(1)) + 1\n season_str = f\"{season.group(1)}{year}\"\n if season:\n season_url = f\"?season={season_str}\"\n if search is None:\n return await ctx.send(_(\"You must provide a valid current team.\"))\n rosters = {}\n players = []\n teams = [team for team in TEAMS if search.lower() in team.lower()]\n if teams != []:\n for team in teams:\n url = f\"{BASE_URL}/api/v1/teams/{TEAMS[team]['id']}/roster{season_url}\"\n async with self.session.get(url) as resp:\n data = await resp.json()\n if \"roster\" in data:\n for player in data[\"roster\"]:\n players.append(player[\"person\"][\"id\"])\n else:\n return await ctx.send(_(\"No team name was provided.\"))\n\n if players:\n await BaseMenu(\n source=PlayerPages(pages=players, season=season_str),\n cog=self,\n delete_message_after=False,\n clear_reactions_after=True,\n timeout=60,\n ).start(ctx=ctx)\n else:\n if season:\n year = _(\" in the {season} season\").format(\n season=f\"{season.group(1)}-{season.group(3)}\"\n )\n else:\n year = \"\"\n await ctx.send(\n _(\"I could not find a roster for the {team}{year}.\").format(team=team, year=year)\n )",
"def team_season_stats(team):\n\n # Get HTML Content\n url = 'http://www.basketball-reference.com/teams/%s/stats_per_game_totals.html' % team\n r = requests.get(url)\n soup = BeautifulSoup(r.content, \"html.parser\")\n\n # MongoDB Collection\n m = mongo.Mongo()\n\n # Team's yearly stats are displayed in a table\n season_stats = soup.find(id='stats').find('tbody')\n\n # Iterate through each year\n for year in season_stats.find_all('tr', {'class': None}):\n\n season_year = year.find('th').text[0:4]\n season_year = int(season_year) + 1\n season = {'year': season_year}\n\n # Loop through each stat\n for stat in year.find_all('td'):\n season[stat['data-stat']] = stat.string\n\n # Rename relocated teams\n season['team_id'] = scrape_utils.rename_team(season['team_id'])\n season['_id'] = season['team_id'] + '_' + str(season_year)\n\n # Remove unwanted stats\n to_remove = ['rank_team', 'foo', 'g', 'mp_per_g']\n for k in to_remove:\n season.pop(k, None)\n\n # Add to MongoDB\n m.insert('team_season', season)",
"def test_basketballteams_id_get(self):\n pass",
"def find_players_for_team(self, team, src='roster', season=None):\n # creating class wide variable to hold current team\n if type(team) is str:\n team = Team.find(team)\n\n print(\"+ Searching %s players for %s\" % (src, team))\n\n if src == 'roster':\n players = self.get_roster_players_via_api(team, season)\n elif src == 'system':\n players = self.get_system_players(team)\n elif src == 'contract':\n players = self.get_contracted_players(team)\n\n return players",
"def test_season_iter(self):\n self.assertEquals(\n len(\n [episode for episode in self.t['Life on Mars'][1]]\n ),\n 8\n )",
"def get_league_goalie_boxcars(league, seasons):\n\n if len(set(seasons))==1:\n scraped_season_list = str(seasons)\n elif len(set(seasons))>2:\n scraped_season_list = str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[:-1]).replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"\") + \", and \" + str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[-1])\n else:\n scraped_season_list = str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[:-1]).replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"\") + \" and \" + str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[-1])\n \n \n global hidden_patrick\n hidden_patrick = 0\n global error\n error = 0\n \n output = pd.DataFrame()\n \n if type(seasons) == str:\n single = getgoalies(league, seasons)\n output = output.append(single)\n print(\"Scraping \" + league + \" data is complete. You scraped goalie data from \" + seasons + \".\")\n return(output)\n \n elif ((type(seasons) == tuple) or (type(seasons) == list)):\n \n for i in range(0, len(seasons)):\n try:\n single = getgoalies(league, seasons[i])\n output = output.append(single)\n except KeyboardInterrupt as e:\n hidden_patrick = 4\n error = e\n return output\n except (ConnectionError,\n HTTPError,\n ReadTimeout,\n ConnectTimeout) as e:\n hidden_patrick = 5\n error = e\n return output\n \n print(\"Scraping \" + league + \" data is complete. You scraped goalie data from \" + scraped_season_list + \".\") \n return(output)",
"def test_data_source_soaps_id_team_get(self):\n pass",
"def get_companies_and_people(team):",
"def _rotofind(searchname, ridsonly=False):\n\n pn = urllib.quote(searchname) # quote the name.\n url = b64decode('aHR0cDovL3d3dy5yb3Rvd29ybGQuY29tL2NvbnRlbnQvcGxheWVyc2VhcmNoLmFzcHg/') + \"searchname=\" + pn + \"&sport=nfl\"\n # do our request.\n try:\n req = urllib2.Request(url)\n r = urllib2.urlopen(req)\n html = r.read()\n except Exception, e:\n print \"ERROR: _rotofind: in HTTP request: {0}\".format(e)\n return None\n # output container.\n output = []\n # process.\n if 'Search Results for:' in html: # usually not a good sign.\n soup = BeautifulSoup(html)\n table = soup.find('table', attrs={'id':'cp1_tblSearchResults'})\n if table: # this means we found more than one person.\n rows = table.findAll('tr')[2:]\n for row in rows:\n tds = row.findAll('td')\n pname = tds[0].getText()\n pid = tds[0].find('a')['href'].split('/')[3]\n ppos = tds[1].getText()\n pteam = tds[2].getText()\n if ridsonly:\n output.append(pid)\n else:\n output.append(\"{0} {1} {2} {3}\".format(pname, pid, ppos, pteam))\n else: # didn't find anything.\n return None\n #print \"I did not find any results for {0}\".format(searchname)\n else: # this means we found a person.\n soup = BeautifulSoup(html)\n playername = soup.find('div', attrs={'class':'playername'})\n playerid = soup.find('div', attrs={'class':'fb-like'})['data-href']\n playerid = playerid.split('/')[5]\n playertable = soup.find('table', attrs={'id':'cp1_ctl00_tblPlayerDetails'}).findAll('td')[1]\n if ridsonly:\n output.append(playerid)\n else:\n output.append(\"{0} {1} {2}\".format(playername.getText(), playerid, playertable.getText()))\n # now return.\n return output",
"def get_team(team):\n if team == \"left\":\n return \"0\"\n elif team == \"right\":\n return \"1\"\n elif team == \"spec\":\n return \"-1\"",
"def get_leagues_and_countries(source=utils.get_native_source):\n if not isinstance(source, games.models.Source):\n # If I used source=native_source() or if native_source was a global variable then\n # during db initialization (running command initialize) you would get an error since\n # it gets its value when the database is empty.\n source = source()\n logger.info(\"getting leagues and countries from source %s...\", source)\n if not source:\n return [], []\n data, meta, status_code = sportmonks.countries.all(include='leagues.seasons')\n if not data:\n # if the status code is not 200 data and meta are None\n return [], []\n # with open('sportmonks/response_texts/aws_01.txt', 'w') as outfile:\n # json.dump(meta, outfile, indent=4)\n # json.dump(data, outfile, indent=4)\n\n pre_countries, pre_competitions = [], []\n\n try:\n # Notice that only the first supported sport will be processed (currently this is is acceptable since we only\n # support football and so the first supported sport will always be football)\n sport_sids = parse_sport(meta)\n sports = []\n for sport_sid in sport_sids:\n sport = games.models.Sport.by_sid(sid=sport_sid, source=source)\n if not sport:\n logger.info(\"Sport contained in the response with sid {} is not supported\".format(sport_sid))\n continue\n sports.append(sport)\n if not sports:\n logger.error(\"No supported sport in the response\")\n return [], []\n football_gname = games.naming.sport_names.get('football', None)\n football = games.models.Sport.objects.get(name=football_gname)\n if football not in sports:\n logger.info(\"Football is not in response\")\n return [], []\n # logger.debug(\"Trying to get sport from source: %s and sid: %s\", source, sport_sid)\n sport_gname = football_gname\n for item in data:\n try:\n country_sid = item.get('id')\n # logger.debug('country_sid: %s', country_sid)\n country_sname = item.get('name')\n # logger.debug('country_sname: %s', country_sname)\n extra = item.get('extra')\n # logger.debug('extra: %s', extra)\n leagues = item.get('leagues').get('data')\n # logger.debug('leagues: %s', leagues)\n try:\n fifa_code = extra.get('fifa') # some countries might lack extra information\n except AttributeError:\n fifa_code = None\n except Exception as e:\n logger.data_error('%s', e)\n continue\n pre_country = pre_models.PreCountry(source=source, sname=country_sname, sid=country_sid, fifa_code=fifa_code)\n pre_countries.append(pre_country)\n for league in leagues:\n try:\n # sportmonks uses sgname for leagues. I use this sgname as an sname (comp_season_specific name)\n competition_sname = league.get('name')\n # logger.debug('competition_sname: %s', competition_sname)\n sid = league.get('id')\n # logger.debug('sid: %s', sid)\n seasons = league.get('seasons').get('data')\n # logger.debug('seasons: %s', seasons)\n except Exception as e:\n logger.data_error('%s', e)\n continue\n competition_season_utils = []\n # comp_seas_sids = []\n for season in seasons:\n try:\n season_name = season.get('name')\n # logger.debug('season_name: %s', season_name)\n # season_name = seasons_special_treatment(season_name)\n competition_season_sid = season.get('id')\n # logger.debug('competition_season_sid: %s', competition_season_sid)\n is_current_season = season.get('is_current_season', False)\n # logger.debug('is_current_season: %s', is_current_season)\n except Exception as e:\n logger.data_error('%s', e)\n continue\n # comp_seas_sids.append(competition_season_sid)\n zak_season_name = games.models.Season.zakandify_season_string(season_name)\n season = zakanda.utils.season_from_season_name(zak_season_name)\n competition_season_type = get_competition_season_type(season)\n competition_season_util = pre_models.CompetitionSeasonUtil(season, competition_season_sid, competition_sname, competition_season_type)\n competition_season_utils.append(competition_season_util)\n # logger.debug(\"competition season sids: %s\", comp_seas_sids)\n pre_competition = pre_models.PreCompetition(\n source=source, sname=competition_sname, sid=sid, sport_name=sport_gname,\n competition_season_utils=competition_season_utils, pre_country=pre_country)\n pre_competitions.append(pre_competition)\n\n except Exception as e:\n logger.error('%s Unexpected problem with sportmonks.countries.all from source %s', e, source)\n logger.info(\"%s pre countries and %s pre competitions were created\", len(pre_countries), len(pre_competitions))\n return pre_countries, pre_competitions",
"def team(self):\n return self._team",
"def scrape(self):\n self._validate_date_range(self.start_date, self.end_date)\n self._validate_team()\n self._cache_source()\n soup = self.season_raw_cache[self.start_date.year]\n df = self._parse_raw(soup)\n return self._apply_filters(df)",
"def get_player_season(self, season_id):\n return self._pubg.player_season(self.player_id, season_id, self.shard)",
"def get_season(\n current_date: date, hemisphere: str, season_tracking_type: str\n) -> str | None:\n\n if hemisphere == \"equator\":\n return None\n\n if season_tracking_type == TYPE_ASTRONOMICAL:\n spring_start = ephem.next_equinox(str(current_date.year)).datetime()\n summer_start = ephem.next_solstice(str(current_date.year)).datetime()\n autumn_start = ephem.next_equinox(spring_start).datetime()\n winter_start = ephem.next_solstice(summer_start).datetime()\n else:\n spring_start = datetime(2017, 3, 1).replace(year=current_date.year)\n summer_start = spring_start.replace(month=6)\n autumn_start = spring_start.replace(month=9)\n winter_start = spring_start.replace(month=12)\n\n if spring_start <= current_date < summer_start:\n season = STATE_SPRING\n elif summer_start <= current_date < autumn_start:\n season = STATE_SUMMER\n elif autumn_start <= current_date < winter_start:\n season = STATE_AUTUMN\n elif winter_start <= current_date or spring_start > current_date:\n season = STATE_WINTER\n\n # If user is located in the southern hemisphere swap the season\n if hemisphere == NORTHERN:\n return season\n return HEMISPHERE_SEASON_SWAP.get(season)",
"def getSeasonStats(self):\n df_season_agg = self.toSeasonAggFormat()\n\n # Calculate Possessions for each game\n df_season_agg['possessions'] = 0.5 * (df_season_agg['FGA'] + 0.475 * df_season_agg['FTA'] - df_season_agg['OR'] + df_season_agg['TO']) \\\n + 0.5 * (df_season_agg['OppFGA'] + 0.475 * df_season_agg['OppFTA'] - df_season_agg['OppOR'] + df_season_agg['OppTO'])\n\n # Aggregate to Season Summary Level\n season_stats = df_season_agg.groupby(['TeamID', 'Season']).sum()\n\n season_stats = season_stats.rename(columns={'Win':'wins'})\n\n # Season Advanced Stats\n season_stats['o_eff'] = season_stats['Score'] / season_stats['possessions'] * 100\n season_stats['d_eff'] = season_stats['OppScore'] / season_stats['possessions'] * 100\n season_stats['net_eff'] = season_stats['o_eff'] - season_stats['d_eff']\n\n season_stats.drop('DayNum', axis=1, inplace=True)\n season_stats.drop('OppTeamID', axis=1, inplace=True)\n season_stats.drop('rand', axis=1, inplace=True)\n\n return season_stats",
"def current_season():\n td = datetime.datetime.today()\n if td.month > 8:\n return td.year\n return td.year - 1",
"def getStatForTeam(self, team, stat):\n if stat.lower() in self.matchStats.keys():\n value = self.getHomeAwayValue(team)\n return self.matchStats[stat.lower()][value] if value is not None else None\n return None",
"def get_championship_won_for_each_coach(self):\n self.championship_team = (\n self.raw_data_postseason\n .merge(self.season_max_days,how='left',on=['Season'])\n .query(\"DayNum == season_max_days\")\n .groupby(['Season','WTeamID'])\n .agg({\"NumOT\":\"count\"})\n .reset_index()\n .rename(columns={\"NumOT\":\"is_champion\",\"WTeamID\":\"TeamID\"})\n )",
"def by_season(self, season):\n return self.get_queryset().filter(season=season)",
"def standings_by_season(season):\n season = int(season) + 1\n scoreboard = nba_py.Scoreboard(month=7,\n day=1,\n year=season)\n east_standings = scoreboard.east_conf_standings_by_day()\n west_standings = scoreboard.west_conf_standings_by_day()\n\n return render_template(\"standings.html\",\n title=\"standings\",\n east_standings=enumerate(east_standings, 1),\n west_standings=enumerate(west_standings, 1),\n team=CITY_TO_TEAM)",
"def get_team_alliance(event: str, match: int, team: int) -> typing.Optional[str]:\n \n if team in get_match_alliances(event, match)['red']:\n return 'red'\n elif team in get_match_alliances(event, match)['blue']:\n return 'blue'\n else:\n return None",
"def get_team(self, game_state):\n if self.red:\n return game_state.get_red_team_indices()\n else:\n return game_state.get_blue_team_indices()",
"def getSuit(self):\r\n return self.suit",
"def review(self):\n # Compile standings\n self.standings = COMPOSE_LEAGUE_STANDINGS(season=self)\n # Name a champion\n self.champion = self._name_champion()\n self.league.history.champions_timeline[self.year] = self.champion\n print \"THE {} HAVE WON THE {} {} CHAMPIONSHIP!\".format(\n self.champion.team.name.upper(), self.year, self.league.name.upper()\n )\n # Compile league leaders\n # self.league_leaders = COMPOSE_LEAGUE_LEADERS(season=self)\n # Have each team review its season, as well\n for team_season in self.teams:\n team_season.review()\n # Send the league into the offseason\n self.league.season = None",
"def show_players_specific_tournament(self) -> None:\n id_choice = check.request_id(TOURNAMENTS)\n tournament_data = TOURNAMENTS.get(doc_id=id_choice)\n if tournament_data.get(\"players\") == {}:\n print(\"\\n This tournaments has no players yet\")\n else:\n players_list = tournament_data.get(\"players\")\n deserialized_player_list = []\n for player_data in players_list:\n deserialized_player = Player(**json.loads(player_data))\n deserialized_player_list.append(deserialized_player)\n utils.clear_terminal()\n print(\n \"Do you want the list of players by alphabetical order or by ranking ? \\n\"\n \"1 - Ranking players list \\n\"\n \"2 - Alphabetical players list\"\n )\n choice = check.request_selection_with_number(\"alphabetical\", \"ranking\", \"None\")\n if choice == \"alphabetical\":\n utils.clear_terminal()\n deserialized_player_list = sorted(deserialized_player_list, key=lambda player: player.first_name)\n for deserialized_player in deserialized_player_list:\n print(deserialized_player)\n elif choice == \"ranking\":\n utils.clear_terminal()\n deserialized_player_list = sorted(deserialized_player_list, key=lambda player: player.ranking)\n for deserialized_player in deserialized_player_list:\n print(deserialized_player)",
"def get_team_list(sport_type, exclude=[]):\n url = ESPN_API_PREFIX + Sport.get_resource_url(sport_type) + \"/teams\"\n params = {\"region\": \"us\",\n \"lang\": \"en\",\n \"contentorigin\": \"espn\",\n \"limit\": \"99\"}\n r = requests.get(url=url, params=params)\n data = r.json()\n team_list = [team[\"team\"] for team in data[\"sports\"][0][\"leagues\"][0][\"teams\"]]\n team_objects_list = []\n excluded_teams = [team.id for team in exclude if team.sport == sport_type]\n for team in team_list:\n if team[\"id\"] not in excluded_teams:\n team_objects_list.append(Team(team[\"id\"], team[\"displayName\"], team[\"abbreviation\"],\n sport_type, team[\"logos\"][0][\"href\"]))\n return team_objects_list",
"def get_team_game_preview(self, team, date):\n abbr = convert_name(team, how='abbr')\n return self._db.Games.find({'date' : date,\n '$or' : [{'home' : abbr},\n {'away' : abbr}]})",
"def showCatalog(sport_id):\n\n sport = session.query(Sport).filter_by(id=sport_id).one()\n items = session.query(Item).filter_by(sport_id=sport_id).all()\n return render_template('catalog.html', sport=sport, items=items)",
"def __init__(self, api_key, season, week):\n\n self._ak = api_key\n self._base_url = 'https://api.sportsdata.io/v3/nfl/'\n self.season = season\n self.week = week\n self._player_dict = filter_players(load_players_file(), position='QB')",
"def getTeamStat(self, year = 2014):\r\n \r\n year_next = (year % 100) + 1\r\n season = str(year) + '-' + str(year_next)\r\n \r\n stat_url = 'http://stats.nba.com/stats/leaguedashteamstats?Conference=&'\\\r\n 'DateFrom=&DateTo=&Division=&GameScope=&GameSegment=&'\\\r\n 'LastNGames=0&LeagueID=00&Location=&MeasureType=Base&'\\\r\n 'Month=0&OpponentTeamID=0&Outcome=&PORound=0&PaceAdjust=N&'\\\r\n 'PerMode=PerGame&Period=0&PlayerExperience=&PlayerPosition=&'\\\r\n 'PlusMinus=N&Rank=N&Season=' + season + '&SeasonSegment=&'\\\r\n 'SeasonType=Regular+Season&ShotClockRange=&StarterBench=&'\\\r\n 'TeamID=0&VsConference=&VsDivision='\r\n \r\n response = requests.get(stat_url)\r\n data = json.loads(response.text)\r\n \r\n headers = data['resultSets'][0]['headers']\r\n stat_data = data['resultSets'][0]['rowSet']\r\n df = pd.DataFrame(stat_data,columns=headers) \r\n \r\n team_df = df[[\"TEAM_ID\",\"TEAM_NAME\",\"GP\",\"W\",\"L\",\"W_PCT\",\"MIN\",\"FGM\",\r\n \"FGA\",\"FG_PCT\",\"FG3M\",\"FG3A\",\"FG3_PCT\",\"FTM\",\"FTA\",\"FT_PCT\",\r\n \"OREB\",\"DREB\",\"REB\",\"AST\",\"TOV\",\"STL\",\"BLK\",\"BLKA\",\"PF\",\r\n \"PFD\",\"PTS\",\"PLUS_MINUS\"]]\r\n \r\n return team_df",
"def second_way(person_to_clubs: Dict[str, List[str]], \n club_to_person: Dict[str, List[str]], \n person: str, club: str) -> int:\n score = 0\n if person not in person_to_clubs:\n return score\n for member in club_to_person[club]:\n for diff_clubs in person_to_clubs[member]:\n if diff_clubs != club and diff_clubs in person_to_clubs[person]:\n score += 1\n return score",
"def get_winner(game):\n return game['winner']",
"def get_player_data(soup, game_dict):\n\n # Loop through teams to store information by team.\n for i, team in enumerate([\"home\", \"away\"]):\n try:\n plyrs_soup = soup.findAll(\n \"div\", {\"class\": \"aufstellung_ausgabe_block {}side\".format(team)})[0]\n plyr_data = plyrs_soup.findAll(\"a\", {\"class\": \"spieler_linkurl\"})\n\n # Loop through players by team.\n for j, plyr in enumerate(plyr_data):\n try:\n game_dict[\"{}_plyr_{}\".format(team, j)] = plyr.text\n game_dict[\"{}_plyr_url_{}\".format(team, j)] = plyr[\"href\"]\n except AttributeError:\n pass\n except (AttributeError, IndexError):\n pass\n\n return game_dict",
"def _add_season(self, ep, dvd=False):\n if dvd:\n snum = ep['dvd_season']\n seasons = self.dvd_seasons\n else:\n snum = ep['seasonnumber']\n seasons = self.seasons\n if seasons.has_key(snum):\n return seasons[snum]\n else:\n s = Season(\n sasonnumber=snum,\n seasonid=ep['seasonid'],\n seriesid=ep['seriesid']\n )\n s.series = self\n seasons[snum] = s\n return s",
"def __getitem__(self, index):\n return self._games[index]",
"def collect_team(year, abbreviation):\n\n team = Team.objects.filter(year=year, abbreviation=abbreviation)[0]\n team = {\n 'id': abbreviation,\n 'team': team,\n }\n return team",
"def get_league_skater_boxcars(league, seasons):\n\n if len(set(seasons))==1:\n scraped_season_list = str(seasons)\n elif len(set(seasons))>2:\n scraped_season_list = str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[:-1]).replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"\") + \", and \" + str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[-1])\n else:\n scraped_season_list = str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[:-1]).replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"\") + \" and \" + str(((str(tuple(sorted(tuple(set(seasons))))).replace(\"'\", \"\").replace(\"(\", \"\").replace(\")\", \"\").replace(\"[\", \"\").replace(\"]\", \"\"))).split(\", \")[-1])\n \n \n global hidden_patrick\n hidden_patrick = 0\n global error\n error = 0\n \n output = pd.DataFrame()\n \n if type(seasons) == str:\n single = getskaters(league, seasons)\n output = output.append(single)\n print(\"Scraping \" + league + \" data is complete. You scraped skater data from \" + seasons + \".\")\n return(output)\n \n elif ((type(seasons) == tuple) or (type(seasons) == list)):\n \n for i in range(0, len(seasons)):\n try:\n single = getskaters(league, seasons[i])\n output = output.append(single)\n except KeyboardInterrupt as e:\n hidden_patrick = 4\n error = e\n return output\n except (ConnectionError,\n HTTPError,\n ReadTimeout,\n ConnectTimeout) as e:\n hidden_patrick = 5\n error = e\n return output\n \n print(\"Scraping \" + league + \" data is complete. You scraped skater data from \" + scraped_season_list + \".\") \n return(output)",
"def _get_profile(self, season, player):\n try:\n try:\n player = int(player)\n except ValueError:\n player = player.lower()\n player_list = season.get_season_data()[\"proPlayers\"]\n for p in player_list:\n if p[\"id\"] == player:\n return p\n if p[\"name\"].lower() == player:\n return p\n except Exception as e:\n error_msg = (\"Failed to retrieve player profile data: {}\"\n \"\".format(str(e)))\n raise PlayerDataException(error_msg)"
] | [
"0.7500355",
"0.66461325",
"0.63443124",
"0.61862314",
"0.61821485",
"0.6069046",
"0.5974852",
"0.595481",
"0.5868784",
"0.583944",
"0.58001155",
"0.56890136",
"0.56505454",
"0.5541518",
"0.5468677",
"0.5466211",
"0.54574645",
"0.5456159",
"0.5432092",
"0.54250246",
"0.542327",
"0.54098135",
"0.5403194",
"0.5373436",
"0.5341333",
"0.531213",
"0.527643",
"0.5275149",
"0.5273867",
"0.5260957",
"0.5260317",
"0.52442706",
"0.52420986",
"0.5238755",
"0.5211861",
"0.5209855",
"0.5189012",
"0.51722115",
"0.514929",
"0.51230085",
"0.51178646",
"0.5117006",
"0.5112656",
"0.5112656",
"0.5107751",
"0.5103446",
"0.51033777",
"0.5097471",
"0.5096112",
"0.50830644",
"0.50827533",
"0.5077214",
"0.5072578",
"0.5063196",
"0.50609845",
"0.50574297",
"0.50571233",
"0.5057019",
"0.504425",
"0.5039737",
"0.50385964",
"0.5038105",
"0.5034886",
"0.5029722",
"0.50282073",
"0.50269413",
"0.5011031",
"0.50082225",
"0.5004082",
"0.50023735",
"0.5000885",
"0.49944326",
"0.4990991",
"0.49823833",
"0.49747416",
"0.4974289",
"0.49671927",
"0.49563468",
"0.49523988",
"0.49521276",
"0.49469012",
"0.49448258",
"0.49344337",
"0.492592",
"0.49233097",
"0.49204054",
"0.4918439",
"0.49161595",
"0.4915509",
"0.49077803",
"0.49030355",
"0.4899805",
"0.48934594",
"0.4893207",
"0.48877102",
"0.4884859",
"0.48797292",
"0.48779967",
"0.48764673",
"0.48709732"
] | 0.58140707 | 10 |
.recommendation will return the correct recommendation choice | def test_recommendation(self):
john_starks = Athlete(first_name="John", last_name="Starks", sport="NBA", recommendation="a")
self.assertEqual(john_starks.recommendation, "a") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_recommendation(fav_product,model_knn=model_knn,\n data=csr_matrix(df_product_features.values),\n\n mapper=products_to_idx,\n n_recommendations=6):\n # fit\n model_knn.fit(data)\n # get input movie index\n #print('You have input product:', fav_product)\n idx = fuzzy_matching(mapper, fav_product, verbose=True)\n if idx is None:\n return []\n #print('Recommendation system start to make inference')\n #print('......\\n')\n distances, indices = model_knn.kneighbors(data[idx], n_neighbors=n_recommendations + 1)\n\n raw_recommends = sorted(list(zip(indices.squeeze().tolist(), distances.squeeze().tolist())), key=lambda x: x[1])[\n :0:-1]\n\n # get reverse mapper\n #print(raw_recommends)\n reverse_mapper = {v: k for k, v in mapper.items()}\n # print recommendations\n #print('Recommendations for {}:'.format(fav_product))\n filter = []\n for i, (idx, dist) in enumerate(raw_recommends):\n #print('{0}: {1}, with distance of {2}'.format(i + 1, reverse_mapper[idx], dist))\n filter.append(reverse_mapper[idx])\n\n\n newproduct = pd.read_sql_query(\"\"\"SELECT p.*\n ,(SELECT img.url FROM image img WHERE p.id=img.product_id limit 1) as image\n ,(SELECT cate.cate_name FROM categories cate WHERE p.category_id=cate.id) as cateName\n FROM products p where p.name IN %s \"\"\", conn,params=(tuple(filter),))\n\n return newproduct.reset_index().to_json(orient='records')",
"def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\n #print \"--------------------------------------------------\"\n #print \"calculate_recommendations\"\n #print \"--------------------------------------------------\"\n\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\n\n # U = np.array('users')\n # D = np.array('video_games')\n\n # R = |U| cross |D|\n\n # We want to discover K latent features\n\n # Find\n # P(a | |U| corss K matrix)\n # Q(a | |D| cross K matrix)\n # Such that their product approximates R\n # R approx= P cross transpose(Q) = hat(R)\n #\n\n # r[i][j] = transpose(p)[i] * q[j]\n # = sum( 1..k, p[i][k] * q[k][j] )\n\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\n # squared error, estimated rating can be either higher or lower than the real thing\n\n # find the gradient\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\n\n # update rules\n # alpha = settings.alpha # learning_rate\n # alpha = 0.0002 # learning_rate\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\n\n # training data\n # T = (u[i], d[j], r[i][j])\n # np.array()\n\n # iterate until convergance\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\n # - sum(1..k, p[i][k]*q[k][j]))**2\n\n # regularization\n # beta = 0.02\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\n #\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\n\n data = np.array(vote_list)\n\n encoder = OneHotEncoder()\n\n users = data[:,0]\n unique_users = list(set(users))\n for i in range(len(users)):\n users[i] = unique_users.index(users[i])\n\n video_games = data[:,1]\n unique_games = list(set(video_games))\n for i in range(len(video_games)):\n video_games[i] = unique_games.index(video_games[i])\n\n ratings = data[:,2]\n M = len(set(video_games))\n N = len(set(users))\n R = np.zeros((N,M))\n for i in range(len(users)):\n user = users[i]\n game = video_games[i]\n rating = ratings[i]\n R[user][game] = rating\n\n K = 2\n\n P = np.random.rand(N,K)\n Q = np.random.rand(M,K)\n\n nP, nQ = self.matrix_factorization(R, P, Q, K)\n nR = np.dot(nP, nQ.T)\n\n itemMatch = {}\n for i in range(N):\n user = unique_users[i]\n itemMatch[user] = []\n for j in range(M):\n if R[i][j] == 0:\n video_game = unique_games[j]\n recommendation = (video_game, nR[i][j])\n itemMatch[user].append(recommendation)\n itemMatch[None] = []\n print 'pmf recommendations', itemMatch.items()\n print '\\n'\n recommendations = itemMatch.items()\n\n # returns\n # [\n # (<user1>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # (<user2>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # ]\n\n return recommendations",
"def make_recommendation(model_knn, data, mapper, fav_parks, n_recommendations):\n # fit\n model_knn.fit(data)\n # get input park index\n #print('You have input movie:', fav_parks)\n idx = fuzzy_matching(mapper, fav_parks, verbose=True)\n \n #print('Recommendation system start to make inference')\n #print('......\\n')\n distances, indices = model_knn.kneighbors(data[idx], n_neighbors=n_recommendations+1)\n \n raw_recommends = \\\n sorted(list(zip(indices.squeeze().tolist(), distances.squeeze().tolist())), key=lambda x: x[1])[:0:-1]\n # get reverse mapper\n reverse_mapper = {v: k for k, v in mapper.items()}\n # print recommendations\n allrecs = []\n for i, (idx, dist) in enumerate(raw_recommends):\n allrecs.append([reverse_mapper[idx], dist])\n return allrecs",
"def handle_recommendation(request):\n ticker = request.get_slot_value(slot_name=\"stockTicker\").upper()\n recommendation = Analyst(ticker).recommendation()\n\n logger.info(\n f\"recommendationMean for {ticker} is {recommendation}\")\n\n # pick right response based on recommendation mean rating\n if recommendation is None:\n message = strings.INTENT_RCMD_NO_RCMD\n elif _in_interval(recommendation, 1, 1.8):\n message = strings.INTENT_RCMD_STRONG_BUY\n elif _in_interval(recommendation, 1.8, 2.2):\n message = strings.INTENT_RCMD_BUY\n elif _in_interval(recommendation, 2.2, 2.8):\n message = strings.INTENT_RCMD_OPT_HOLD\n elif _in_interval(recommendation, 2.8, 3.2):\n message = strings.INTENT_RCMD_HOLD\n elif _in_interval(recommendation, 3.2, 3.8):\n message = strings.INTENT_RCMD_PES_HOLD\n elif _in_interval(recommendation, 3.8, 4.2):\n message = strings.INTENT_RCMD_SELL\n elif _in_interval(recommendation, 4.2, 5):\n message = strings.INTENT_RCMD_STRONG_SELL\n\n response = ResponseBuilder.create_response(request, message=message)\n reprompt_message = strings.INTENT_GENERAL_REPROMPT\n\n return response.with_reprompt(reprompt_message)",
"def build_recommendations(sc, myRatings, model):\n #myRatedMovieIds = set([x[1] for x in myRatings])\n uid = get_uid_from_ratings(myRatings)\n #print \"uid:\", uid\n myRatedMovieIds = set([x[1] for x in myRatings.collect()])\n #print \"myRatedMovieIds:\", myRatedMovieIds\n candidates = sc.parallelize([m for m in movies if m not in myRatedMovieIds]).cache()\n #print candidates\n predictions = model.predictAll(candidates.map(lambda x: (uid, x))).collect()\n #print predictions\n recommendations = sorted(predictions, key = lambda x: x.product)\n return recommendations",
"def mainRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n print(\"***************************************************\\n Recomendaciones principales\\n\"\r\n \"***************************************************\")\r\n pareja = ParejaRecommendation(dict, matcher)\r\n apps = likingdatingapps(dict, matcher)\r\n dificultad = difficultydates(dict, matcher)\r\n importancia = samehobbies(dict, matcher)\r\n imp = study(dict, matcher)\r\n gusto = musictaste(dict, matcher)\r\n region = sameregion(dict, matcher)\r\n gustoDif = different(dict, matcher)\r\n Habits = habits(dict, matcher)\r\n goals = goalsRecommendation(dict, matcher)\r\n prof = profesionalRecommendation(dict, matcher)\r\n similar = similarRecommendation(dict, matcher)\r\n\r\n listaopciones = [pareja, apps, dificultad, importancia, imp, gusto, region, gustoDif, Habits, goals, prof, similar]\r\n\r\n Prospectos = {}\r\n for option in listaopciones:\r\n for element in option:\r\n if Prospectos.has_key(element[\"nombre\"]):\r\n Prospectos[element[\"nombre\"]] = 1\r\n else:\r\n Prospectos[element[\"nombre\"]] = Prospectos[element[\"nombre\"]] + 1",
"def check_recommendation_part(self, result):\n assert \"recommendation\" in result, \"Can not find the 'recommendation' node.\"\n recommendation = result[\"recommendation\"]\n assert recommendation == {} or \"component-analyses\" in recommendation, \\\n \"Wrong content of recommendation node\"\n if \"component_analyses\" in recommendation:\n self.check_component_analyses_recommendation(recommendation)",
"def recommend(self, u):\n\n sims = {} #similarities\n recommendation = \"\"\n topScore = None\n start = time.time()\n for movie_id, rating in enumerate(u):\n if rating != 0:\n sims[movie_id] = {}\n for r_id, movie in enumerate(self.ratings):\n sims[movie_id][r_id] = self.distance(movie,self.ratings[movie_id])\n # print time.time() - start, \"distance time\"\n\n start = time.time()\n for i, movieRating in enumerate(self.ratings):\n iPrediction = 0\n for movieName in self.ratedMovieList:\n j = self.titlesOnly.index(movieName)\n iPrediction += sims[j][i]*1.0 * self.userRatingVector[j]\n if topScore is None or iPrediction > topScore:\n movie = self.titlesOnly[i]\n if movie not in self.ratedMovieList and movie not in self.recommendedMovies:\n # print(\"prediction score for %s is %.5f\" % (movie, iPrediction))\n topScore = iPrediction\n recommendation = movie\n # print time.time() - start, \"recommendation time\"\n self.recommendedMovies.append(recommendation)\n\n articlePattern = re.match('(.*), (the|a|an|el|la)', recommendation)\n if articlePattern is not None:\n recommendation = articlePattern.group(2) + \" \" + articlePattern.group(1)\n\n return recommendation",
"def test_recommender(self):\n\n self._build_sample_graph()\n\n # set skill sa score to 1.0 and skill sb score to 0.5\n measure_sa = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sa.id)\n measure_sa.add_score(1.0)\n measure_sa.save()\n measure_sb = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sb.id)\n measure_sb.add_score(0.0)\n measure_sb.add_score(1.0)\n measure_sb.save()\n\n # verify that the proficient skill list equals [sa]\n # verify that the recommended skill list equals [sb, sc]\n skill_map = SkillMap.load(self.course, self.user_id)\n recommender = SkillRecommender.instance(skill_map)\n recommended, learned = recommender.recommend()\n self.assertEqual(1, len(learned))\n self.assertEqual(2, len(recommended))\n self.assertEqual(self.sb.id, recommended[0].id)\n self.assertEqual(self.sc.id, recommended[1].id)\n assert learned[0].competency_measure.last_modified\n\n # add second successful attempt for skill b and:\n # verify that the proficient skill list equals [sa, sb]\n # verify that the recommended skill list equals [sc, sd]\n measure_sb = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sb.id)\n measure_sb.add_score(1.0)\n assert measure_sb.proficient\n measure_sb.save()\n skill_map = SkillMap.load(self.course, self.user_id)\n recommender = SkillRecommender.instance(skill_map)\n recommended, proficient = recommender.recommend()\n self.assertEqual(2, len(proficient))\n self.assertEqual(2, len(recommended))\n self.assertEqual(self.sc.id, recommended[0].id)\n self.assertEqual(self.sd.id, recommended[1].id)",
"def test_find_recommendation_by_id_and_type(self):\n query_id = 1\n query_type = Type.UP_SELL\n recommendations = [Recommendation(product_id = query_id, recommendation_product_id = 2, relationship = query_type),\n Recommendation(product_id = query_id, recommendation_product_id = 10, relationship = query_type), \n Recommendation(product_id = query_id, recommendation_product_id = 15, relationship = Type.ACCESSORY)]\n\n for recommendation in recommendations:\n recommendation.create()\n logging.debug(recommendations)\n\n # find the 2nd recommendation in the list\n results = Recommendation.find_by_id_and_type(query_id, Type.UP_SELL)\n for recommendation in results:\n self.assertIsNot(recommendation, None)\n self.assertEqual(recommendation.product_id, query_id)\n self.assertEqual(recommendation.relationship, query_type)",
"def graphlab_recommendations(aData, user, needed_param, n = 10, cv_ratio = 0.7):\n # change the data into SFrame and the user data into SArray\n import preprocessing\n aData.rename(columns = {needed_param['user_id']:'user_id', needed_param['item_id']: 'item_id', \n needed_param['ratings']: 'ratings'}, inplace = True)\n aData = gl.SFrame(aData)\n train, test= preprocessing.graphlab_split_data(aData, cv_ratio)\n user = gl.SArray([user])\n \n # make models\n methods = ['matrix_factorization', 'linear_model', 'item_similarity', 'popularity', 'item_means']\n sim_type = ['jaccard', 'cosine', 'pearson']\n models = []\n for aMethod in methods:\n print aMethod\n if(aMethod != 'item_similarity'):\n model = gl.recommender.create(observation_data = train, user_id = 'user_id', \n item_id = 'item_id', target = 'ratings', method = aMethod)\n models.append(model)\n else:\n for aSim in sim_type:\n print aSim\n sim_model = gl.recommender.create(observation_data = train, user_id = 'user_id', \n item_id = 'item_id', target = 'ratings', method = aMethod, similarity_type = aSim)\n models.append(sim_model)\n \n # generate results for models as well as the rmse results\n recommended = []\n rmse = []\n for model in models:\n aResult = model.recommend(users = user, k = n)\n recommended.append(aResult)\n aRMSE = gl.evaluation.rmse(test['ratings'], model.predict(test))\n rmse.append(aRMSE)\n \n # create DataFrame\n df = pd.DataFrame({'models':models, 'recommended':recommended, 'rmse':rmse})\n # find the model that gives k least square errors\n df = df.sort('rmse', ascending = True).iloc[0:2]\n df.index = range(0,2)\n \n colnames = df['recommended'].loc[0].column_names()\n results = pd.DataFrame(columns = colnames)\n \n for aResult in df['recommended']:\n aResult = aResult.to_dataframe()\n results = results.append(aResult)\n \n results = results.sort('score', ascending = False)\n\n return results.sort('score', ascending=False), 'item_id'",
"def svd_recommend_new(row):\n actual = new_purchase_row(row)\n recommended = svd_rec.recommend_new(u_dict[row[\"user_id\"]], N=10)\n recommended = [p_dict[r[0]] for r in recommended]\n return f1(actual, recommended)",
"def _get_recommend(self, user):\n return self.user_cf.calculate(target_user_id=user, user_n=self.user_n,\n item_n=self.item_n, type=2)",
"def test_recommendation_evaluation_6(model):\n assert recommendation_evaluation(model, cn_test_users=None, k=2, n_pos_interactions=None, novelty=True) == \\\n {'HitRatio@2': 0.0, 'NDCG@2': 0.0, 'Precision@2': 0.0, 'Recall@2': 0.0}",
"def test_create_a_recommendation(self):\n recommendation = Recommendation(product_id=1, recommendation_product_id=2, relationship=Type.UP_SELL)\n self.assertTrue(recommendation != None)\n self.assertEquals(recommendation.relationship, Type.UP_SELL)\n self.assertEquals(recommendation.product_id, 1)\n self.assertEquals(recommendation.recommendation_product_id, 2)",
"def get_recommendations(name, data):\r\n #sorts preferences in alphabetical order\r\n #do this to make it easier to compare\r\n for key in data:\r\n data[key] = selection_sort(data[key])\r\n most_similar_key = \"\"\r\n max_matches = 0\r\n for key in data:\r\n if not(key[-1] == \"$\" or data[key] == data[name]):\r\n \"\"\"if the person is not private or does not have the same data\"\"\"\r\n matches = num_matches(data[key], data[name])\r\n if matches > max_matches:\r\n most_similar_key = key\r\n max_matches = matches\r\n if most_similar_key == \"\":\r\n print(\"No recommendations available at this time\")\r\n return 1\r\n else:\r\n final_recommendations = []\r\n for x in data[most_similar_key]:\r\n if x not in data[name]:\r\n final_recommendations += [x]\r\n return final_recommendations",
"def get_recommendations(self):\n\n try:\n recommendations = Recommendations.objects.get(user_id=self.id)\n except DoesNotExist:\n print \"No recommendation object found. Creating one now.\"\n recommendations = Recommendations(user_id=self.id)\n recommendations.save()\n\n return recommendations",
"def test_find_recommendation_type(self):\n recommendations = RecommendationFactory.create_batch(1)\n for recommendation in recommendations:\n recommendation.create()\n logging.debug(recommendations)\n\n # find the recommendation in the list\n recommendation = Recommendation.find(recommendations[0].product_id, recommendations[0].recommendation_product_id)\n self.assertIsNot(recommendation, None)\n self.assertEqual(recommendation.product_id, recommendations[0].product_id)\n self.assertEqual(recommendation.recommendation_product_id, recommendations[0].recommendation_product_id)\n self.assertEqual(recommendation.relationship, recommendations[0].relationship)",
"def recommend(self):\n\t\t\n\t\titems = self.unique_biz_id.items()\n\n\t\t# business id is essentially restaurant id, replace the naming \n\t\tfor rest1, i1 in items:\n\t\t\tfor rest2, i2 in items:\n\t\t\t\tif i1 < i2:\n\t\t\t\t\tsim, nsup = self.calculate_similarity( rest1 = rest1, rest2 = rest2 )\n\t\t\t\t\tself.database_sim[i1][i2] = sim\n\t\t\t\t\tself.database_sim[i2][i1] = sim\n\t\t\t\t\tself.database_sup[i1][i2] = nsup\n\t\t\t\t\tself.database_sup[i2][i1] = nsup\n\t\t\t\telif i1 == i2:\n\t\t\t\t\tnsup = self.df[ self.df['business_id'] == rest1 ]['user_id'].count()\n\t\t\t\t\tself.database_sim[i1][i1] = 1.0\n\t\t\t\t\tself.database_sup[i1][i1] = nsup",
"def test_get_scored_recommendations_post(self):\n pass",
"def predict_intent():\n\n start_time = time()\n request.json[\"request_id\"] = uuid.uuid4().hex\n app.logger.info(f\"Request: {request.json['request_id']}. Processing request '/recommend': {request.json}\")\n\n # Prime filters\n uniq_id = request.json.get('uniq_id')\n if not uniq_id:\n message = f'Request: {request.json[\"request_id\"]}. Missing uniq_id in request'\n delta = time() - start_time\n app.logger.error(f\"{message} Elapsed time: {delta} secs\")\n return jsonify(message=message), 404\n \n\n result, code = recommender.get_recommendation(uniq_id)\n\n delta = time() - start_time\n app.logger.info(f\"Request: {request.json['request_id']}. Endpoint response '/recommend': {result}. Elapsed time: {delta} secs\")\n return jsonify(result), code",
"def recommendations(self, **kwargs):\n\n path = self._get_movie_id_path('recommendations')\n resp = self._get_method(path, kwargs)\n return resp",
"def get_recommendations(soup_recipe):\n ratings = soup_recipe.find(\"meta\", {\"itemprop\": \"ratingValue\"})[\"content\"]\n ratings_count = soup_recipe.find(\"meta\", {\"itemprop\": \"ratingCount\"})[\"content\"]\n if ratings == 0:\n return None, None\n return ratings, ratings_count",
"def measure(self, recommender):\n similarity = 0\n items_shown = recommender.items_shown\n if items_shown.size == 0:\n # at the beginning of the simulation, there are no recommendations yet\n self.observe(None)\n return\n\n for pair in self.pairs:\n itemset_1 = set(items_shown[pair[0], :])\n itemset_2 = set(items_shown[pair[1], :])\n common = len(itemset_1.intersection(itemset_2))\n union = len(itemset_1.union(itemset_2))\n similarity += common / union / len(self.pairs)\n self.observe(similarity)",
"def test_recommendation_evaluation_18(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=None,\n novelty=False, ignore_low_predictions_threshold=2) == \\\n {'HitRatio@2': 0.0167, 'NDCG@2': 0.0189, 'Precision@2': 0.02, 'Recall@2': 0.0167}",
"def sorted_recommended_products(self):\n return [\n r.recommendation\n for r in self.primary_recommendations.select_related(\"recommendation\").all()\n ]",
"def test_recommendation_value(self):\n john_starks = Athlete(first_name=\"John\", last_name=\"Starks\", sport=\"NBA\", recommendation=\"a\")\n self.assertEqual(john_starks.get_recommendation_display(), \"Hire Joe IMMEDIATELY!\")",
"def test_set_scored_recommendations_post(self):\n pass",
"def test_recommendation_evaluation_4(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=None,\n novelty=False, n_test_users=10) == \\\n {'HitRatio@2': 0.0333, 'NDCG@2': 0.0585, 'Precision@2': 0.05, 'Recall@2': 0.0333}",
"def test_recommendation_evaluation_1(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=[1, 5, 10],\n n_pos_interactions=None, novelty=False, verbose=False) == \\\n {'HitRatio@1': 0.0, 'HitRatio@10': 0.0507, 'HitRatio@5': 0.0283, 'NDCG@1': -0.0003, 'NDCG@10': 0.0329,\n 'NDCG@5': 0.0223, 'Precision@1': 0.0, 'Precision@10': 0.016, 'Precision@5': 0.016, 'Recall@1': 0.0,\n 'Recall@10': 0.0507, 'Recall@5': 0.0283}",
"def get_recommendations(self):\n endpoints = '/user/recs'\n return self.get_request(endpoints)",
"def recommend(user, course):\n start_time = time.time()\n\n # query all ratings from database:\n course_rating_qs = CourseRating.objects.all()\n course_rating_df = read_frame(course_rating_qs, verbose=False)\n\n # get filtered numpy arrays:\n X, y_diff, y_wl = filter_data(course_rating_df)\n\n # create algorithms and train them:\n algo_diff = KNNWithAllUsersThresoledBias(k=ALG_K,\n min_support=ALG_MIN_SUPPORT,\n bias_weight=ALG_DIFF_BIAS_WEIGHT,\n bias_threshold=ALG_DIFF_BIAS_THRESHOLD)\n algo_wl = KNNWithAllUsersThresoledBias(k=ALG_K,\n min_support=ALG_MIN_SUPPORT,\n bias_weight=ALG_WL_BIAS_WEIGHT,\n bias_threshold=ALG_WL_BIAS_THRESHOLD)\n\n algo_diff.train(X, y_diff)\n algo_wl.train(X, y_wl)\n\n calc_time = time.time() - start_time\n\n return algo_diff.predict((user, course)), algo_wl.predict((user, course)), calc_time",
"def GetRecommendation(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")",
"def test_recommendation_evaluation_7(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=None,\n novelty=False, interaction_threshold=2) == \\\n {'HitRatio@2': 0.0069, 'NDCG@2': 0.0116, 'Precision@2': 0.0104, 'Recall@2': 0.0069}",
"def test_recommendation_evaluation_3(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=1,\n novelty=False) == \\\n {'HitRatio@2': 0.02, 'NDCG@2': 0.0179, 'Precision@2': 0.01, 'Recall@2': 0.02}",
"def test_recommendation_evaluation_9(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=[2, 3], n_pos_interactions=None,\n novelty=False, metrics=[NDCG(), HitRatio()], verbose=False) == \\\n {'HitRatio@2': 0.0167, 'HitRatio@3': 0.0233, 'NDCG@2': 0.0189, 'NDCG@3': 0.022}",
"def popular_recommend(row):\n actual = new_purchase_row(row)\n return f1(actual, popular_products)",
"def recommend(user_id, ratings, movie_names, n_neighbors=10, n_recomm=5):\n \n # convert long to wide\n ratings_wide = ratings.pivot(index='user', columns='movie', values='rating')\n\n # all the items a user has not rated, that can be recommended\n all_items = ratings_wide.loc[user_id,:]\n unrated_items = all_items.loc[all_items.isnull()]\n \n # convert the index with item ids into Series values\n unrated_items = unrated_items.index.to_series(name='item_ids').reset_index(drop=True)\n print('User {} has {} unrated items.'.format(user_id, len(unrated_items)))\n \n # compute user similarities\n similarities = compute_similarities(user_id, ratings_wide)\n \n # generate predictions for unseen items based on the user similarity data\n predictions = unrated_items.apply(lambda d: predict_rating(d, ratings_wide, similarities, N=n_neighbors))\n \n # sort items by highest predicted rating\n predictions = predictions.sort_values(ascending=False)\n \n # recommend top N items\n recommends = predictions.head(n_recomm)\n \n # reformat the result\n recommends = recommends.to_frame(name='predicted_rating')\n recommends = recommends.rename_axis('movie_id')\n recommends = recommends.reset_index()\n \n recommends['name'] = recommends.movie_id.apply(lambda d: movie_names[d])\n \n return recommends",
"def __insertandretrieve_recommendation(self, userid=None, itemid=None):\n def recommendation2rec(recommendationsip=None):\n recs = []\n for recommendation in recommendationsip:\n recs.append(self.__itemidx2id[recommendation[0]])\n return recs\n userid = str(userid)\n itemid = str(itemid)\n if userid in list(self.__userid2idx.keys()):\n useridx = self.__userid2idx[userid]\n recommendations = self.__recommender.recommend(useridx, self.__useritem, N=self._num_recommendations)\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n if itemid in list(self.__itemid2idx.keys()):\n itemidx = self.__itemid2idx[itemid]\n recommendations = self.__recommender.similar_items(itemidx, N=self._num_recommendations)\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n recommendations = list(self.__itemid2idx.keys())\n random.shuffle(recommendations)\n recommendations = recommendations[:self._num_recommendations]\n return recommendations",
"def getRecommendations(prefs,person,similarity=sim_pearson):\n weighted_similarities = dict((\n (other, similarity(prefs, person, other)) \n for other in prefs.keys() if other != person))\n # Eliminate critics with negative correlation (I'm not sure why\n # this is a good idea)\n for critic, sim in weighted_similarities.items():\n if sim <= 0:\n del weighted_similarities[critic]\n sum_ratings = defaultdict(int) # int() initializes to 0\n sum_weights = defaultdict(int)\n for other, weight in weighted_similarities.items():\n for movie, rating in prefs[other].items():\n sum_ratings[movie] += rating * weight\n sum_weights[movie] += weight\n recommendations = [(sum_ratings[movie]/sum_weights[movie], movie)\n for movie in sum_ratings.keys()\n if movie not in prefs[person].keys()]\n recommendations.sort()\n recommendations.reverse()\n return recommendations",
"def test_recommendation_evaluation_15(model, interactions_ds):\n try:\n recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=-1, n_pos_interactions=None,\n novelty=False, metrics=[NDCG(), HitRatio()], verbose=False)\n assert False\n except Exception as e:\n assert str(e) == 'k (-1) should be > 0.'",
"def calc_recommendation(df_train: pd.DataFrame, df_target: pd.DataFrame) -> pd.DataFrame:\n lookup_series = get_lookup_series(df_train)\n df_tc = df_target.copy()\n df_tc['item_recommendations'] = df_tc.apply(lambda x: sort_by_interaction(x, lookup_series), axis=1)\n df_out = df_tc[['user_id', 'session_id', 'timestamp', 'step', 'item_recommendations']]\n return df_out",
"def personalization(prediction, n):\n # prediction\n # n top n recommendation\n\n top_n = get_top_n(prediction, n)\n\n rec_dict = {}\n for uid, user_ratings in top_n.items():\n rec_dict[uid] = [iid for (iid, _) in user_ratings]\n\n rec_user_ls = [pred[0] for pred in prediction]\n rec_item_ls = [pred[1] for pred in prediction]\n\n unique_rec_user_ls = np.unique(rec_user_ls)\n unique_rec_item_ls = np.unique(rec_item_ls)\n\n # assign each item with index number\n unique_rec_item_dict = {item: ind for ind,\n item in enumerate(unique_rec_item_ls)}\n\n n_unique_rec_user = len(unique_rec_user_ls)\n n_unique_rec_item = len(unique_rec_item_ls)\n\n # recommended user item matrix\n rec_matrix = np.zeros(shape=(n_unique_rec_user, n_unique_rec_item))\n\n # represent recommended item for each user as binary 0/1\n for user in range(n_unique_rec_user):\n # get userid\n user_id = unique_rec_user_ls[user]\n # get rec item list\n item_ls = rec_dict[user_id]\n\n for item_id in item_ls:\n # get item index\n item = unique_rec_item_dict[item_id]\n rec_matrix[user, item] = 1\n\n # calculate cosine similarity matrix across all user recommendations\n similarity = cosine_similarity(X=rec_matrix, dense_output=False)\n # calculate average of upper triangle of cosine matrix\n upper_right = np.triu_indices(similarity.shape[0], k=1)\n # personalization is 1-average cosine similarity\n score = 1 - np.mean(similarity[upper_right])\n return score",
"def recommend_cosim():\n pass",
"def recommend(self, request):\n log.debug(\"Received recommendation request data (request.data): {}\".format(request.data))\n # validate request serializer\n serializer = ActivityRecommendationRequestSerializer(\n data=request.data,\n )\n if not serializer.is_valid():\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n # get learner (creation of learner is supported here if learner does not already exist)\n learner, created = Learner.objects.get_or_create(**serializer.data['learner'])\n\n # get collection\n collection = serializer.validated_data['collection']\n\n # parse sequence data\n sequence_data = serializer.validated_data['sequence']\n sequence = []\n for activity_data in sequence_data:\n try:\n sequence.append(Activity.objects.get(url=activity_data['url']))\n except Activity.DoesNotExist:\n log.error(\"Unknown activity found in sequence data: {}\".format(activity_data))\n log.debug(\"Parsed sequence: {}\".format(sequence))\n # get recommendation from engine\n recommended_activity = get_engine().recommend(learner, collection, sequence)\n\n # construct response data\n if recommended_activity:\n recommendation_data = ActivityRecommendationSerializer(recommended_activity).data\n recommendation_data['complete'] = False\n else:\n # Indicate that learner is done with sequence\n recommendation_data = dict(\n collection=collection.collection_id,\n url=None,\n complete=True,\n )\n\n return Response(recommendation_data)",
"def _choose_best_option(self):",
"def item_based_recommendation(\n self, test_dataRDD,\n item_based_dict_bd, itembased_sim_pair_dict_bd, item_info_bd):\n return test_dataRDD.map(\n lambda line: self.item_based_prediction(\n line, item_based_dict_bd,\n itembased_sim_pair_dict_bd, item_info_bd))",
"def check_recommendation_in_result(context):\n json_data = context.response.json()\n result = json_data[\"recommendation\"]\n assert result == {}",
"def recommend_nmf():\n pass",
"def __insertandretrieve_recommendation(self, userid=None, itemid=None):\n def recommendation2rec(recommendationsip=None):\n recs = []\n for recommendation in recommendationsip:\n recs.append(self.__itemidx2id[recommendation[0]])\n return recs\n userid = str(userid)\n itemid = str(itemid)\n if userid in list(self.__userid2idx.keys()):\n useridx = self.__userid2idx[userid]\n userarray = numpy.asarray([useridx, ] * len(self.__itemidx2id.keys()))\n itemarray = numpy.asarray(list(self.__itemidx2id.keys()))\n predicted_ratings = self.__recommender1.predict([userarray, itemarray], batch_size=10, verbose=0)\n item_rating = {}\n for item, pr in zip(itemarray, predicted_ratings):\n item_rating[item] = pr[0]\n recommendations = sorted(item_rating.items(), key=lambda value: value[1], reverse=True)[:self._num_recommendations]\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n if itemid in list(self.__itemid2idx.keys()):\n itemidx = self.__itemid2idx[itemid]\n recommendations = self.__recommender2.similar_items(itemidx, N=self._num_recommendations)\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n recommendations = list(self.__itemid2idx.keys())\n random.shuffle(recommendations)\n recommendations = recommendations[:self._num_recommendations]\n return recommendations",
"def recommendations_similarity(aData, needed_param, user, products, n = 10, simfunc = sim_cosine):\n table_CF = preproc.make_CF_table(aData, needed_param)\n sim_measures_table = simfunc(table_CF) \n \n scores = sim_measures_table.dot(table_CF)\n mean_scores = np.array(np.sum(sim_measures_table, axis=1).T)\n mean_scores = pd.DataFrame(np.tile(mean_scores, (scores.shape[1],1))).T\n predicted_ratings = np.divide(scores, np.absolute(mean_scores))\n \n ratings = predicted_ratings[user].order(ascending= False)\n ratings = ratings[0:n]\n \n return (ratings.index[ratings.index.isin(products)==False])",
"def taketurn(self):\n # get my options from the game\n opts = self.game.options()\n rec_opt = self._primestrat.recommend(opts, self.board)\n if rec_opt is not None:\n self.implementstrategy(rec_opt)\n else:\n super().taketurn()",
"def recommend_joke(self,preds_df,already_rated):\n\t\t#already rated is a list which shows which all jokes he has rated\n\t\t#all the jokes which aren't rated will have 0s in them\n\n\t\tunrated_ind = []\n\t\tfor i in range(len(already_rated)):\n\n\t\t\tif already_rated[i]==0:\n\t\t\t\tunrated_ind.append(i)\n\n\t\t#now we have all the indices of jokes user has not rated\n\n\t\t#get the last line\n\t\tlast_row = preds_df.iloc[[len(preds_df)-1]].values[0]\n\t\tbest_rating = -100\n\t\tjoke_num = -1\n\n\t\t#iterate over the last row to get the best rating\n\t\tfor i in unrated_ind:\n\n\t\t\tif last_row[i] > best_rating:\n\t\t\t\tbest_rating = last_row[i]\n\t\t\t\tjoke_num = i\n\n\t\tjokes_list = sorted(set(self.data_final['JokeID']))\n\t\t#jokes_list = self.data_final['JokeID'].unique().tolist()\n\t\tjoke_index = jokes_list[joke_num]\n\n\t\trecommended_joke = self.data_jokes[self.data_jokes['JokeID'] == joke_index].values[0][1]\n\n\t\treturn recommended_joke, joke_num",
"def spark_recommendations(filename, user, products, separator = '\\t', n = 10):\n sc = pyspark.SparkContext('loc', 'pyspark_rec')\n aData = sc.textFile(filename)\n data = aData.map(lambda line: np.array([float(x) for x in line.split(separator)])) \n # to do this, it assumes that each line of the file consists of [user, product, rating]\n \n numIterations = 20\n aModel = pyspark.mllib.recommendation.ALS.train(data, n, numIterations)\n aRDDresults = aModel.predict(user, products)\n\n return aModel, aRDDresults",
"def test_recommendation_evaluation_14(model, interactions_ds):\n try:\n recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=0, n_pos_interactions=None,\n novelty=False, metrics=[NDCG(), HitRatio()], verbose=False)\n assert False\n except Exception as e:\n assert str(e) == 'k (0) should be > 0.'",
"def compute_recommendations_and_qii(sc, dataset, user_id):\n # TODO avoid retraining?\n print \"Training the model, rank:\", rank, \"numIter:\", numIter,\\\n \"lmbda:\", lmbda\n start_recommend_time = time.time()\n model = ALS.train(dataset, rank, numIter, lmbda)\n\n print \"Computing recommendations/QII for user: \", user_id\n myRatings = get_ratings_from_uid(dataset, user_id)\n #print \"User ratings: \", list(myRatings.collect())\n\n # make personalized recommendations\n recommendations = build_recommendations(sc, myRatings, model)\n end_recommend_time = time.time()\n rec_time = end_recommend_time - start_recommend_time\n print \"Time it took to create recommendations:\", rec_time\n\n if recommendations_to_print > 0:\n print \"Movies recommended for you:\"\n print_top_recommendations(recommendations, recommendations_to_print)\n\n local_influence = compute_local_influence(sc, user_id, recommendations,\n dataset, rank, lmbda, numIter, qii_iters)\n\n print \"Local influence:\"\n t = PrettyTable([\"Movie ID\", \"Local Influence\"])\n for mid, minf in sorted(local_influence.items(), key = lambda x: -x[1]):\n if print_movie_names:\n t.add_row([movies[mid], minf])\n else:\n t.add_row([mid, minf])\n print t\n\n return recommendations, local_influence",
"def recommend(self,\n user_id: int,\n number_of_recommendation: int,\n selected_algorithm: KNNBaseline or SVD) -> pd.DataFrame:\n # Creating the surprise models for reader and dataset\n # rating_scale indicates the range of given ratings\n reader = Reader(rating_scale=(1, 5))\n data = Dataset.load_from_df(self.ratings_df[['userId', 'movieId', 'rating']], reader)\n\n # Building whole trainset to train the algorithm\n train_dataset = data.build_full_trainset()\n # Building a test set from remaining part of tha dataset\n test_dataset = train_dataset.build_anti_testset()\n # Train and test the model\n recommendations = selected_algorithm.fit(train_dataset).test(test_dataset)\n # Store the accuracy of model with Root Mean Sqared Error\n rmse = accuracy.rmse(recommendations, verbose=False)\n print('Root Mean Squared Error is {}'.format(rmse))\n # Convert the recommendations into pd.Dataframe data type\n recommendations = pd.DataFrame(recommendations, columns=['userId', 'movieId', 'trueRating', 'estimatedRating', 'USELESS COLUMN']).drop(columns='USELESS COLUMN')\n # Merge the recommendations with self.movies_df in order to get additional informations of movie title and genres\n # Sort the values in descending ortder in order to show the most similar recommendations on the top\n recommendations = pd.merge(left=recommendations[recommendations['userId'] == user_id].sort_values(by='estimatedRating', ascending=False, ignore_index=True), right=self.movies_df, on='movieId')\n return recommendations.head(number_of_recommendation)",
"def measure(self, recommender):",
"def test_recommendation_evaluation_8(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=None,\n novelty=False, metrics=[NDCG(), HitRatio()]) == \\\n {'HitRatio@2': 0.0167, 'NDCG@2': 0.0189}",
"def make_first_recommendation() -> str:\r\n available_tanks = tank_search()\r\n fermentation_tanks = available_tanks[0]\r\n conditioning_tanks = available_tanks[1]\r\n fermentation_advice = available_tanks[2]\r\n conditioning_advice = available_tanks[3]\r\n more_beer = available_tanks[4]\r\n return render_template(\"make_first_recommendation.html\",\r\n fermentation_string=fermentation_tanks,\r\n conditioning_string=conditioning_tanks,\r\n first_advice=fermentation_advice,\r\n second_advice=conditioning_advice,\r\n next_page=more_beer)",
"def list_recommendations(\n self, marketplace_id=None, recommendation_category=None, next_token=None\n ):\n return self.make_request(\n \"ListRecommendations\",\n {\n \"MarketplaceId\": marketplace_id,\n \"RecommendationCategory\": recommendation_category,\n },\n method=\"POST\",\n )",
"def test_prioritize_recommendation(self, mocker):\n mocker.patch(\n 'saana_lib.recommendation.PrioritizeIngredients.all',\n new_callable=mocker.PropertyMock,\n return_value={\"onion\": 0, \"flax\": 2}\n )\n get_ingr_mock = mocker.patch(\n 'saana_lib.recommendation.Recommendation.get_or_create_ingredient'\n )\n _ = PrioritizeRecommendation(patient_id()).as_list()\n\n assert_equal_objects(\n [arg[0][0] for arg in get_ingr_mock.call_args_list],\n [\"onion\", \"flax\"]\n )",
"def test_recommendation_evaluation_16(model, interactions_ds):\n try:\n recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=5, n_pos_interactions=None,\n novelty=False, metrics={}, verbose=False)\n assert False\n except Exception as e:\n assert str(e) == 'Expected \"metrics\" argument to be a list and found <class \\'dict\\'>. ' \\\n 'Should contain instances of RankingMetricABC.'",
"def recommend(self, u):\n # Implement a recommendation function that takes a user vector u\n # and outputs a list of movies recommended by the chatbot\n rec_list = []\n for i, movie in enumerate(self.ratings):\n rxi = 0.0\n for tup in u:\n j = tup[0]\n rxj = tup[1]\n if i == j: # Skip movies in user_vec\n continue\n sij = self.distance(self.ratings[i], self.ratings[j])\n rxi += (rxj * sij)\n movie_rank = [i, rxi] # Store movie index and rating\n rec_list.append(movie_rank)\n rec_list = sorted(rec_list, key=lambda x:x[1], reverse = True) \n return rec_list",
"def _compute_n_recommendations(self, listings_dict, target, n):\n recommended_listings = []\n # check if dict already contains target\n if target.id not in listings_dict:\n # add it\n listings_dict[target.id] = [\n target.longitude, target.latitude, self.map_rt(target.room_type), target.price,\n target.min_nights, target.num_of_reviews, target. availability\n ]\n # need to keep track of id and index\n id_list = list(listings_dict.keys())\n target_idx = id_list.index(target.id)\n # we need a listing set of least n+1 to compute n recommendations (the listing itself is the +1)\n if len(id_list) >= n + 1:\n # scale rows between [0,1]\n scaled_rows = MinMaxScaler().fit_transform(list(listings_dict.values()))\n # compute euclidean distance of each row to target\n [self._euclidean_distance(row, scaled_rows[target_idx]) for row in scaled_rows]\n # compute recommendations: We want to compute more recommendations and then randomly sample a subset\n # first element is target itself, therefore we compute one additional rec.\n k = n * 4 + 1\n if k > len(listings_dict):\n # k must not exceed number of listings\n k = len(listings_dict)\n # compute recommendations and save their indices\n rec_idx = NearestNeighbors(n_neighbors=k, algorithm='ball_tree') \\\n .fit(scaled_rows) \\\n .kneighbors([scaled_rows[target_idx]], k, return_distance=False)\n # gather index of recommendations\n rec_ids = [id_list[rec] for rec in rec_idx[0]]\n # randomly sample n (excluding the target itself)\n recommended_listings = random.sample(rec_ids[1:], n)\n\n return recommended_listings",
"def _recommend_movie(user_id, movie_id, number_movies):\n #get the recommended movie ids from pickled model\n rec_movies = sparkrecommender.movie_recomendation(user_id,movie_id,number_movies)\n #get a list of movies ids used in model\n moviesdf = pd.read_csv('movies.csv',index_col='movieId')\n \n #build list of lists with [[imdb ID, movie title, post img link]]\n rec_movies_list = []\n for movie_id in rec_movies:\n temp_list = []\n imdbid_ = str(get_imdbId(movie_id))\n temp_list.append(imdbid_)\n temp_list.append(moviesdf.loc[movie_id,'title'])\n temp_list.append('http://img.omdbapi.com/?apikey=ae550a04&i=tt'+str(imdbid_))\n rec_movies_list.append(temp_list)\n return rec_movies_list",
"def test_recommendation_evaluation_17(model, interactions_ds):\n fun = lambda x: 1\n try:\n recommendation_evaluation(model, interactions_ds[1], n_test_users=None, k=5, n_pos_interactions=None,\n novelty=False, metrics=[fun], verbose=False)\n assert False\n except Exception as e:\n assert str(e) == f'Expected metric {fun} to be an instance of type RankingMetricABC.'",
"def test_update_a_recommendation(self):\n recommendation = RecommendationFactory()\n logging.debug(recommendation)\n recommendation.create()\n logging.debug(recommendation)\n logging.debug(type(recommendation.relationship.name))\n recommendation.relationship = Type.CROSS_SELL\n recommendation.update()\n self.assertIsNot(recommendation, None)\n self.assertEqual(recommendation.relationship.name, 'CROSS_SELL')\n recommendations = recommendation.all()\n self.assertEqual(len(recommendations), 1)\n self.assertEqual(recommendations[0].product_id, recommendation.product_id)\n self.assertEqual(recommendations[0].recommendation_product_id, recommendation.recommendation_product_id)\n self.assertEqual(recommendations[0].relationship, recommendation.relationship)",
"def recommend(self, user):\n K = self.n_sim_user\n N = self.n_rec_movie\n rank = dict()\n watched_movies = self.trainset[user]\n\n # v=similar user, wuv=similarity factor\n for v, wuv in sorted(self.user_sim_mat[user].items(),\n key=itemgetter(1), reverse=True)[0:K]:\n for movie in self.trainset[v]:\n if movie in watched_movies:\n continue\n # predict the user's \"interest\" for each movie\n rank.setdefault(movie, 0)\n rank[movie] += wuv\n # return the N best movies\n return sorted(rank.items(), key=itemgetter(1), reverse=True)[0:N]",
"def get_recommendations_for_user(self, user_id):\r\n\r\n sql_command = \"\"\"\r\n SELECT event_id, score\r\n FROM UserRecommendations\r\n WHERE user_id = '{0}'\r\n ORDER BY score\r\n \"\"\".format(user_id)\r\n self.controller.execute(sql_command)\r\n\r\n return self.controller.fetchall()",
"def recommend_by_event(self, event = None):\n pass",
"def classical_recommendation(self, user, rank, quantum_format=True):\n # Make sure the user and rank are ok\n self._validate_user(user)\n self._validate_rank(rank)\n\n # Do the classical SVD\n _, _, vmat = np.linalg.svd(self.matrix, full_matrices=True)\n\n # Do the projection\n recommendation = np.zeros_like(user, dtype=np.float64)\n for ii in range(rank):\n recommendation += np.dot(np.conj(vmat[ii]), user) * vmat[ii]\n\n if np.allclose(recommendation, np.zeros_like(recommendation)):\n raise RankError(\"Given rank is smaller than the rank of the preference matrix. Recommendations \"\n \"cannot be made for all users.\")\n\n # Return the squared values for probabilities\n probabilities = (recommendation / np.linalg.norm(recommendation, ord=2))**2\n\n # Return the vector if quantum_format is False\n if not quantum_format:\n return probabilities\n\n # Format the same as the quantum recommendation\n prods = []\n probs = []\n for (ii, p) in enumerate(probabilities):\n if p > 0:\n prods.append(ii)\n probs.append(p)\n return prods, probs",
"def get_recommendations(df,song_title, similarity_score, num_recommends = 5):\r\n indices = pd.Series(df.index, index = df['track_name']).drop_duplicates()\r\n idx = indices[song_title]\r\n sim_scores = list(enumerate(similarity_score[idx]))\r\n sim_scores = sorted(sim_scores, key = lambda x: x[1],reverse = True)\r\n top_scores = sim_scores[1:num_recommends+1]\r\n song_indices = [i[0] for i in top_scores]\r\n return df[\"track_name\"].iloc[song_indices]",
"def recommend(self, user_id, N=10):\n scores = self.user_factors[user_id] @ self.product_factors.T\n best = np.argpartition(scores, -N)[-N:]\n return sorted(zip(best, scores[best]), key=lambda x: -x[1])",
"def get_recommendations(prefs, person, similarity=sim_pearson):\n totals = {}\n similarity_sums = {}\n\n for other in prefs:\n if other == person:\n continue\n\n sim = similarity(prefs, person, other)\n\n if sim <= 0:\n continue\n\n for item in prefs[other]:\n if item not in prefs[person] or prefs[person][item] == 0:\n totals.setdefault(item, 0)\n totals[item] += prefs[other][item] * sim\n similarity_sums.setdefault(item, 0)\n similarity_sums[item] += sim\n\n # Normalized list\n rankings = [(total / similarity_sums[item], item)\n for item, total in totals.items()]\n\n # Returns normalized score, not an r that would be between -1 and 1\n rankings.sort()\n rankings.reverse()\n return rankings",
"def recommendation_and_reason(recent_low,recent_high,latest_close):\n if float(latest_close) < 1.2*float(recent_low) and float(latest_close) > 0.8*float(recent_high):\n recommendation = \"NO RECOMMENDATION\"\n reasoning = \"CANNOT ACCURATELY ESTIMATE IF STOCK IS UNDERVALUED OR OVERVALUED. LATEST CLOSING PRICE IS WITHIN 20% OF THE RECENT HIGH AND LOW.\" \n elif float(latest_close) < 1.2*float(recent_low):\n recommendation = \"BUY!\"\n reasoning = \"THE STOCK IS LIKELY TO BE UNDERVALUED (THE CLOSING PRICE IS WITHIN 20% OF THE STOCK'S RECENT LOW)\"\n elif float(latest_close) > 0.8*float(recent_high):\n recommendation = \"SELL!\"\n reasoning = \"THE STOCK IS LIKELY TO BE OVERVALUED (THE CLOSING PRICE IS WITHIN 20% OF THE STOCK'S RECENT HIGH)\"\n else:\n recommendation = \"NO RECOMMENDATION\"\n reasoning = \"NO SPECIFIC DATA TO ESTIMATE FUTURE PERFORMANCE\"\n recommendation_reasoning = [recommendation, reasoning]\n return recommendation_reasoning",
"def recommend(self, user: torch.tensor, k:int = 10) -> torch.tensor:\n self.model.eval()\n\n u_embed_one = self.model.pred_model.user_embeddings(user)\n u_embed_one_reshaped = u_embed_one.reshape((\n 1, u_embed_one.shape[0]))\n m_embed = self.model.pred_model.item_embeddings.weight\n u_bias_one = self.model.pred_model.user_biases(user)\n u_bias_one_reshaped = u_bias_one.reshape((\n 1, u_bias_one.shape[0]))\n m_bias = self.model.pred_model.item_biases.weight\n\n bias_sum = u_bias_one_reshaped + m_bias\n bias_sum = bias_sum.reshape((bias_sum.shape[1],\n bias_sum.shape[0]))\n\n preds = torch.matmul(u_embed_one_reshaped, m_embed.t())+bias_sum\n\n sorted_preds = preds.squeeze().argsort().tolist()\n items_seen = self.seen_items_dct[user.item()]\n sorted_preds = [x for x in sorted_preds if x not in items_seen]\n return sorted_preds[::-1][:k]",
"def train_best_model_generate_ratings_test(self, ratings_set, test_set):\n if ratings_set and test_set:\n print(\"Training the best model and generating the ratings for the test data set\")\n self.LOG_HANDLE.info(\"Training the best model and generating the ratings for the test data set\")\n\n algo = KNNWithMeans(**model_params.knn_means_best_params)\n algo.fit(ratings_set)\n\n predictions = algo.test(test_set)\n return predictions",
"def start_recommender(self, numRecs=None):\n if numRecs is not None:\n self._num_recommendations = numRecs\n self.__useritem = self.__itemuser.T.tocsr()",
"def start_recommender(self, numRecs=None):\n if numRecs is not None:\n self._num_recommendations = numRecs\n self.__useritem = self.__itemuser.T.tocsr()",
"def _generate_recommendation(self,\n query_analysis,\n db_name,\n collection_name):\n index_rec = '{'\n for query_field in query_analysis['analyzedFields']:\n if query_field['fieldType'] is EQUIV_TYPE:\n if len(index_rec) is not 1:\n index_rec += ', '\n index_rec += '\"' + query_field['fieldName'] + '\": 1'\n for query_field in query_analysis['analyzedFields']:\n if query_field['fieldType'] is SORT_TYPE:\n if len(index_rec) is not 1:\n index_rec += ', '\n index_rec += '\"' + query_field['fieldName'] + '\": 1'\n for query_field in query_analysis['analyzedFields']:\n if query_field['fieldType'] is RANGE_TYPE:\n if len(index_rec) is not 1:\n index_rec += ', '\n index_rec += '\"' + query_field['fieldName'] + '\": 1'\n index_rec += '}'\n\n # RECOMMENDATION\n return OrderedDict([('index',index_rec),\n ('shellCommand', self.generate_shell_command(collection_name, index_rec))])",
"def get_recommendations(self, payload):\n\n session = Session()\n\n event_category_vector = self._load_interest_vector(payload['user_id'],\n 'event_categories')\n event_types_vector = self._load_interest_vector(payload['user_id'],\n 'event_types')\n\n categories_sum = sum(event_category_vector.values())\n types_sum = sum(event_types_vector.values())\n\n all_events_query = session.query(Event).filter(\n Event.event_time >= datetime.utcnow()\n )\n total_events_num = all_events_query.count()\n\n result_query = session.query.filter(False)\n\n for category, category_score in event_category_vector.items():\n category_percent = category_score / categories_sum\n\n category_events_query = all_events_query.filter(\n Event.categories.any(EventCategory.id == category)\n )\n\n for event_type, event_type_score in event_types_vector.items():\n type_percent = event_type_score / types_sum\n limit = total_events_num * category_percent * type_percent\n\n filtered_query = category_events_query.filter(\n Event.event_type_id == event_type\n ).limit(limit)\n\n result_query = result_query.union(filtered_query)\n\n result_query = result_query.order_by(Event.event_time)\n\n Session.remove()\n\n # TODO: check if it will be sent over RabbitMQ\n return result_query",
"def _generate_recommendation(self,\r\n query_analysis,\r\n db_name,\r\n collection_name):\r\n index_rec = '{'\r\n for query_field in query_analysis['analyzedFields']:\r\n if query_field['fieldType'] is EQUIV_TYPE:\r\n if len(index_rec) is not 1:\r\n index_rec += ', '\r\n index_rec += '\"' + query_field['fieldName'] + '\": 1'\r\n for query_field in query_analysis['analyzedFields']:\r\n if query_field['fieldType'] is SORT_TYPE:\r\n if len(index_rec) is not 1:\r\n index_rec += ', '\r\n index_rec += '\"' + query_field['fieldName'] + '\": 1'\r\n for query_field in query_analysis['analyzedFields']:\r\n if query_field['fieldType'] is RANGE_TYPE:\r\n if len(index_rec) is not 1:\r\n index_rec += ', '\r\n index_rec += '\"' + query_field['fieldName'] + '\": 1'\r\n index_rec += '}'\r\n\r\n # RECOMMENDATION\r\n return OrderedDict([('index',index_rec),\r\n ('shellCommand', self.generate_shell_command(collection_name, index_rec))])",
"def print_recommendations(self):\n\n rec_vector = self.generate_recommendation()\n\n print(\"Recommendations for user {} \".format(self.username))\n\n for ranking, subreddit_name in enumerate(rec_vector, 1):\n print(\"{}.: {}\".format(ranking, subreddit_name))\n\n if ranking%10 == 0 and ranking!=0:\n check_if_move_on = True\n print(\"\\nType c and press enter for the next 10 subreddits.\\n\")\n print(\"Type q and press enter to return to main menu.\\n\")\n\n while check_if_move_on:\n choice = input()\n\n if choice == 'c':\n break\n\n elif choice == 'q':\n break\n\n else:\n print(\"Not a valid entry, please enter again.\")\n\n # break the whole thing if they want to quit\n if choice == 'q':\n break",
"def check_for_recommendation_result_report(context):\n json_data = context.response.json()\n if \"recommendation\" in json_data:\n check_recommendation_in_result(context)\n else:\n look_for_other_attributes(context)\n check_vulnerability_in_result(context)",
"def item_based_recommend(user_id, user_item_time_dict, item2item_sim, sim_item_topk, recall_item_num, item_topk_click):\n \n # fetch the user's history clicks\n hist_items = user_item_time_dict[user_id]\n user_hist_items = []\n for (item_list, click_time) in hist_items:\n user_hist_items.extend(item_list)\n user_hist_items_ = {item_id for item_id in user_hist_items}\n \n item_rank = {}\n for item in user_hist_items:\n try:\n for another_item, wij in sorted(item2item_sim[item].items(), key=lambda x: x[1], reverse=True)[:sim_item_topk]:\n if another_item in user_hist_items_:\n continue\n\n item_rank.setdefault(another_item, 0)\n item_rank[another_item] += wij\n except:\n continue\n \n # fill the item_rank if the number of news in item_rank is less than recall_item_num\n if len(item_rank) < recall_item_num:\n for i, item in enumerate(item_topk_click):\n if item in item_rank.items():\n continue\n item_rank[item] = - i - 100 # set a random negative number\n if len(item_rank) == recall_item_num:\n break\n \n item_rank = sorted(item_rank.items(), key=lambda x: x[1], reverse=True)[:recall_item_num]\n \n return item_rank",
"def next_choice(self, opponent: 'Player') -> str:\n\n if self.adaptive_ai:\n # this is an adaptive_ai player, so see if it has collected\n # enough stats about the current opponent yet:\n if sum(self.opponent_choices[opponent.name].values()) > 5:\n # has enough samples to start adapting to the opponent\n print(' {} is trying to guess the opponent\\'s choice...'.format(self.name))\n\n # AI algorithm 1:\n # simply find the most-frequent selection by the opponent and\n # choose its killer.\n\n guess = self.opponent_choices[opponent.name].most_common(1)[0][0]\n ai_choice = weapon_to_beat(guess)\n print(' ', opponent.name, 'most often chose', guess, 'so he/she chose', ai_choice)\n return ai_choice\n\n # use the standard tendency distribution to choose a weapon:\n n = randint(1, self.randmax)\n if n <= self.tendency[0]:\n return 'rock'\n elif n <= self.tendency[0] + self.tendency[1]:\n return 'paper'\n else:\n return 'scissors'",
"def _do_estimate(recommendation_type: str, pipfile: Pipfile) -> None:",
"def predictRating(toPredict, candidateList):\n\n ratingRelevantCandidates = []\n\n #Remove candidates with no rating specified\n for candidate in candidateList:\n currentCandidate = candidate[1]\n\n if float(currentCandidate['vote_avg']) > 0:\n ratingRelevantCandidates.append((float(currentCandidate['vote_avg']), candidate))\n\n #print(\"ratings::::::::\",currentCandidate['vote_avg'])\n\n #Remove outlier candidates based on rating\n ratingMean = np.mean([x[0] for x in ratingRelevantCandidates])\n print(\"ratingMean\", ratingMean)\n ratingSD = np.std([x[0] for x in ratingRelevantCandidates])\n print(\"ratingSD\", ratingSD)\n\n finalRatings = [x for x in ratingRelevantCandidates if (float(x[0]) < ratingMean + ratingSD)]#1.5 *\n finalRatings = [x for x in finalRatings if (float(x[0]) > ratingMean - ratingSD)]#.75 *\n\n finalRatingCandidatesWithWeight = []\n\n #Weight each candidate based on vote count, direct and actor popularity and matching score from part 1\n for candidate in finalRatings:\n directorPoints = compareDirectorPoints(toPredict['director'], candidate[1][1]['director'])\n actorPoints = compareActorPoints(toPredict['cast'], candidate[1][1]['cast'])\n voteCountPoints = int(candidate[1][1]['vote_count'])\n matchPoints = candidate[1][0] / np.max([float(x[1][0]) for x in finalRatings]) * 100\n candidateWeight = PREDICTION_MATCHPOINTS_WEIGHT * matchPoints \\\n + PREDICTION_ACTOR_WEIGHT * actorPoints \\\n + PREDICTION_DIRECTOR_WEIGHT * directorPoints \\\n + PREDICTION_VOTECOUNT_WEIGHT * voteCountPoints\n\n finalRatingCandidatesWithWeight.append((candidateWeight, candidate[0]))\n\n #Calculate the prediction\n sumRatingCandidateWeights = np.sum([float(x[0]) for x in finalRatingCandidatesWithWeight])\n sumRatingTimesCandidateWeight = np.sum([float(x[0]) * float(x[1]) for x in finalRatingCandidatesWithWeight])\n\n ratingPrediction = float(sumRatingTimesCandidateWeight / sumRatingCandidateWeights)\n\n return ratingPrediction",
"def choose_action(self, active_behaviors):\n winning_behavior = active_behaviors[0]\n for behavior in active_behaviors:\n print('Checking behavior:', behavior, 'with weight:', behavior.weight)\n if behavior.weight > winning_behavior.weight:\n winning_behavior = behavior\n print(\"Winning behavior is\", winning_behavior, \"and recommends:\", str(winning_behavior.motor_recommendation))\n return winning_behavior.motor_recommendation",
"def update_recommendation_pool(self):\n for k in self.recommendation_pool.keys():\n self.recommendation_pool[k]['final_similarity'] = 0.0\n\n if 'title_similarity' in self.recommendation_pool[k]:\n self.recommendation_pool[k]['final_similarity'] += \\\n self.recommendation_pool[k]['title_similarity']\n\n if 'genres_similarity' in self.recommendation_pool[k]:\n self.recommendation_pool[k]['final_similarity'] += \\\n self.recommendation_pool[k]['genres_similarity']\n\n if 'tags_similarity' in self.recommendation_pool[k]:\n self.recommendation_pool[k]['final_similarity'] += \\\n self.recommendation_pool[k]['tags_similarity']\n\n self.recommendation_pool = OrderedDict(\n sorted(\n self.recommendation_pool.items(),\n key=lambda x: x[1]['final_similarity'],\n reverse=True\n )\n )",
"def make_third_recommendation() -> str:\r\n requirement_mappings = {\r\n \"Organic Red Helles\": 0,\r\n \"Organic Pilsner\": 0,\r\n \"Organic Dunkel\": 0}\r\n helles_info = bottles_required(\"Organic Red Helles\")\r\n pilsner_info = bottles_required(\"Organic Pilsner\")\r\n dunkel_info = bottles_required(\"Organic Dunkel\")\r\n\r\n requirement_mappings[\"Organic Red Helles\"] = helles_info[2]\r\n requirement_mappings[\"Organic Pilsner\"] = pilsner_info[2]\r\n requirement_mappings[\"Organic Dunkel\"] = dunkel_info[2]\r\n most_needed_recipe = max(requirement_mappings, key=requirement_mappings.get)\r\n\r\n return render_template(\"make_third_recommendation.html\",\r\n helles_display=helles_info,\r\n pilsner_display=pilsner_info,\r\n dunkel_display=dunkel_info,\r\n most_needed_display=most_needed_recipe)",
"def show_recommendation_pool(self, top_n=None):\n i = 0\n if top_n is None:\n top_n = self.number_of_recommendations\n\n for _, rdata in self.recommendation_pool.items():\n print(\"\\n{R.movie_id} - {R.title} - {R.genres}\".format(\n R=rdata['movie_obj']))\n\n if 'title_similarity' in rdata:\n print(\" Title Similarity: {} - ({})\".format(\n rdata['title_similarity'], rdata['movie_obj'].title))\n\n if 'genres_similarity' in rdata:\n print(\" Genres Similarity: {} - ({})\".format(\n rdata['genres_similarity'], rdata['movie_obj'].genres))\n\n if 'tags_similarity' in rdata:\n print(\" Tags Similarity: {} - ({})\".format(\n rdata['tags_similarity'], rdata['tags']))\n\n if 'final_similarity' in rdata:\n print(\" -> Final Similarity: {}\".format(\n rdata['final_similarity']))\n\n i += 1\n if top_n and i >= top_n:\n break",
"def recommend():\n try:\n user_id = int(bottle.request.query.user_id)\n except ValueError as uid_faliure:\n msg = \"Invalid user_id ({}) passed in API call.\".format(bottle.request.query.user_id)\n logging.error(msg)\n bottle.abort(400, \"Check the log for details.\")\n\n # If API will get sent this info below, we need the lines to grab them and validate the info\n if helper.is_valid_lang(bottle.request.query.lang):\n lang = bottle.request.query.lang\n\n else:\n msg = \"Invalid language identifier ({}) for origin language.\".format(bottle.request.query.lang)\n logging.error(msg)\n bottle.abort(400, msg)\n\n try:\n level = int(bottle.request.query.level)\n except ValueError as uid_faliure:\n msg = \"Invalid level ({}) passed in API call.\".format(bottle.request.query.level)\n logging.error(msg)\n bottle.abort(400, \"Check the log for details.\")\n\n try:\n rate = int(bottle.request.query.rate)\n except ValueError as uid_faliure:\n msg = \"Invalid rate ({}) passed in API call.\".format(bottle.request.query.rate)\n logging.error(msg)\n bottle.abort(400, \"Check the log for details.\")\n\n db = helper.connect_to_db(dbconf)\n cursor = db.cursor(mariadb.cursors.DictCursor)\n\n query1 = \"SELECT user_settings.origin_lang_id, language_tag.instance_id, user_settings.target_lang_id, \\\n language_tag.instance_id, `language`.instance_text, concept_id.lang_concept_tag \\\n FROM user_settings, `language`, language_tag, lang_concept_tag \\\n JOIN lang_concept ON lang_concept_data.concept_id=lang_concept.concept_id \\\n JOIN `language` ON lang_concept.chunk_id=`language`.chunk_id \\\n JOIN language_media ON `language`.instance_id=language_media.instance_id\\\n WHERE user_settings.user_id = %s\".format(bottle.request.query.user_id)\n\n\n if helper.is_injection(query1) == False:\n try:\n cursor.execute(query1, (user_id,))\n query1_result = cursor.fetchall()\n msg = \"Query1 {} executed successfully.\".format(query1)\n logging.info(msg)\n db.close()\n return json.dumps(query1_result)\n except mariadb.Error as query1_error:\n msg = \"Recommend query1 failed: {}\".format(query1_error)\n logging.error(msg)\n db.close()",
"def get_rec(self):\n\n #to address cold start problem: checks if user activity is above 5 or so lessons\n # if yes returns recs based on user2user_similarity\n # else returns recs based on item2item_similarity\n pass",
"def recommend_me_team(self, user_id: int, user_ids_per_group: list, n_recommendations: int):\n res_arr = np.array([self.user_similarity.loc[user_id, group_ids].mean() for group_ids in user_ids_per_group])\n res_inds = np.argsort(res_arr)[::-1][:n_recommendations]\n return res_inds, res_arr[res_inds]",
"def measure(self, recommender):\n items_shown = recommender.items_shown\n if items_shown.size == 0:\n # at beginning of simulation, there are no recommendations,\n # so we log a `None` value\n self.observe(None)\n return\n\n recommended_item_attr = recommender.items_hat.value[:, items_shown]\n\n afsr = np.mean(\n recommended_item_attr.max(axis=(0, 2)) - recommended_item_attr.min(axis=(0, 2))\n )\n\n self.observe(afsr)",
"def find_predictions(actives, train_rdd_gbitem_dict, train_rdd_gbuser_dict, num_items):\n active_user = actives[0][0]\n active_item = actives[0][1]\n\n # -----------------------------------\n # train_rdd_gbitem_dict = (item, ([(user,r),(user,r)...],avg_of_item))\n # train_rdd_gbuser_dict = (user, [(item,r),(item,r)...]\n\n if active_user not in train_rdd_gbuser_dict and active_item not in train_rdd_gbitem_dict:\n return (active_user, active_item), 2.5\n\n # all user, ratings that have rated active_item\n if active_item in train_rdd_gbitem_dict:\n active_item_avg = train_rdd_gbitem_dict[active_item][1]\n active_item_dict = dict(train_rdd_gbitem_dict[active_item][0]) # {user: rating, user: rating, ...}\n else:\n # item not found in training set\n # new item problem.\n average_of_user_list = train_rdd_gbuser_dict[active_user]\n average_of_user = sum([x[1] for x in average_of_user_list]) / len(average_of_user_list)\n return (active_user, active_item), average_of_user\n\n # user rated items - all (item, ratings) that the user has rated\n if active_user in train_rdd_gbuser_dict:\n active_user_rated_items = train_rdd_gbuser_dict[active_user] # [(item, rating), (item, rating), ...]\n else:\n # user not found in training set\n # new user problem.\n return (active_user, active_item), train_rdd_gbitem_dict[active_item][1]\n\n similarity_list = []\n for item, rating in active_user_rated_items:\n item_dict = dict(train_rdd_gbitem_dict[item][0])\n item_avg = train_rdd_gbitem_dict[item][1]\n similarity = find_similarity(dict(active_item_dict), active_item_avg, dict(item_dict), item_avg)\n similarity_list.append((rating, similarity))\n\n # Have obtained similarity list for active item and item from the above code.\n # Filter according to a top 'N' items and then take avg rating.\n # similarity_list.sort(key=lambda x: x[1], reverse=True)\n # similarity_list = similarity_list[:len(similarity_list) // 4]\n # similarity_list = [(x[0], x[1]*abs(x[1])**1.5) for x in similarity_list]\n # print(similarity_list)\n pred_rating = find_weighted_average(similarity_list, num_items)\n\n # for i in similarity_list:\n # print(i)\n # print(\"Pred-rating: \", pred_rating)\n\n return (active_user, active_item), pred_rating",
"def recommend(r ,username, users):\r\n # first find nearest neighbor\r\n nearest = computeNearestNeighbor(r, username, users)[0][1]\r\n recommendations = []\r\n # now find bands neighbor rated that user didn't\r\n neighborRatings = users[nearest]\r\n userRatings = users[username]\r\n for artist in neighborRatings:\r\n if not artist in userRatings:\r\n recommendations.append((artist, neighborRatings[artist]))\r\n # using the fn sorted for variety - sort is more efficient\r\n return sorted(recommendations, key=lambda artistTuple: artistTuple[1], reverse = True)",
"def test_recommendation_evaluation_11(model, interactions_ds):\n try:\n recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=[1, 2], n_pos_interactions=None,\n novelty=False, n_test_users=-1, metrics=[NDCG(), HitRatio()], verbose=False)\n assert False\n except Exception as e:\n assert str(e) == 'The number of test users (-1) should be > 0.'"
] | [
"0.7014981",
"0.6732272",
"0.67240196",
"0.67228717",
"0.6716435",
"0.66226876",
"0.6558151",
"0.6556826",
"0.65179765",
"0.6490736",
"0.64453816",
"0.64409184",
"0.64403695",
"0.6433087",
"0.6419716",
"0.64082474",
"0.6397704",
"0.6388307",
"0.6380065",
"0.63798374",
"0.6301499",
"0.62908393",
"0.6287212",
"0.6230368",
"0.61849725",
"0.61821055",
"0.61751354",
"0.61745596",
"0.6172848",
"0.61725706",
"0.6137392",
"0.6121985",
"0.60846096",
"0.60766214",
"0.60740477",
"0.6071819",
"0.60709393",
"0.60476017",
"0.60054195",
"0.6001642",
"0.59991974",
"0.5987954",
"0.59829044",
"0.5971015",
"0.59629977",
"0.5961361",
"0.591807",
"0.59086275",
"0.5893342",
"0.5885975",
"0.5878394",
"0.5872006",
"0.5871038",
"0.58689135",
"0.58569854",
"0.58514243",
"0.5850231",
"0.5832959",
"0.58303726",
"0.58289987",
"0.5818425",
"0.5808315",
"0.58030367",
"0.5799037",
"0.57879686",
"0.5776337",
"0.57696366",
"0.576887",
"0.5766624",
"0.5760903",
"0.57598466",
"0.5749743",
"0.5716557",
"0.5715062",
"0.57100755",
"0.5701886",
"0.5684569",
"0.56833357",
"0.5681233",
"0.5681233",
"0.5676594",
"0.5676573",
"0.5674511",
"0.5674029",
"0.5669227",
"0.5663559",
"0.5658916",
"0.5655567",
"0.5650132",
"0.56466454",
"0.5645387",
"0.56415486",
"0.5637158",
"0.5632617",
"0.5622812",
"0.56203",
"0.56131256",
"0.5613115",
"0.5581446",
"0.5578223"
] | 0.56750447 | 82 |
.get_recommendation_display() will return the correct value of the recommendation choice | def test_recommendation_value(self):
john_starks = Athlete(first_name="John", last_name="Starks", sport="NBA", recommendation="a")
self.assertEqual(john_starks.get_recommendation_display(), "Hire Joe IMMEDIATELY!") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n if self.recommend:\n review = 'recommended by {}: {}'.format(self.reviewer, self.comments)\n else:\n review = 'not recommended by {}: {}'.format(self.reviewer, self.comments)\n\n return review",
"def handle_recommendation(request):\n ticker = request.get_slot_value(slot_name=\"stockTicker\").upper()\n recommendation = Analyst(ticker).recommendation()\n\n logger.info(\n f\"recommendationMean for {ticker} is {recommendation}\")\n\n # pick right response based on recommendation mean rating\n if recommendation is None:\n message = strings.INTENT_RCMD_NO_RCMD\n elif _in_interval(recommendation, 1, 1.8):\n message = strings.INTENT_RCMD_STRONG_BUY\n elif _in_interval(recommendation, 1.8, 2.2):\n message = strings.INTENT_RCMD_BUY\n elif _in_interval(recommendation, 2.2, 2.8):\n message = strings.INTENT_RCMD_OPT_HOLD\n elif _in_interval(recommendation, 2.8, 3.2):\n message = strings.INTENT_RCMD_HOLD\n elif _in_interval(recommendation, 3.2, 3.8):\n message = strings.INTENT_RCMD_PES_HOLD\n elif _in_interval(recommendation, 3.8, 4.2):\n message = strings.INTENT_RCMD_SELL\n elif _in_interval(recommendation, 4.2, 5):\n message = strings.INTENT_RCMD_STRONG_SELL\n\n response = ResponseBuilder.create_response(request, message=message)\n reprompt_message = strings.INTENT_GENERAL_REPROMPT\n\n return response.with_reprompt(reprompt_message)",
"def show_recommendation_pool(self, top_n=None):\n i = 0\n if top_n is None:\n top_n = self.number_of_recommendations\n\n for _, rdata in self.recommendation_pool.items():\n print(\"\\n{R.movie_id} - {R.title} - {R.genres}\".format(\n R=rdata['movie_obj']))\n\n if 'title_similarity' in rdata:\n print(\" Title Similarity: {} - ({})\".format(\n rdata['title_similarity'], rdata['movie_obj'].title))\n\n if 'genres_similarity' in rdata:\n print(\" Genres Similarity: {} - ({})\".format(\n rdata['genres_similarity'], rdata['movie_obj'].genres))\n\n if 'tags_similarity' in rdata:\n print(\" Tags Similarity: {} - ({})\".format(\n rdata['tags_similarity'], rdata['tags']))\n\n if 'final_similarity' in rdata:\n print(\" -> Final Similarity: {}\".format(\n rdata['final_similarity']))\n\n i += 1\n if top_n and i >= top_n:\n break",
"def _get_recommend(self, user):\n return self.user_cf.calculate(target_user_id=user, user_n=self.user_n,\n item_n=self.item_n, type=2)",
"def mainRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n print(\"***************************************************\\n Recomendaciones principales\\n\"\r\n \"***************************************************\")\r\n pareja = ParejaRecommendation(dict, matcher)\r\n apps = likingdatingapps(dict, matcher)\r\n dificultad = difficultydates(dict, matcher)\r\n importancia = samehobbies(dict, matcher)\r\n imp = study(dict, matcher)\r\n gusto = musictaste(dict, matcher)\r\n region = sameregion(dict, matcher)\r\n gustoDif = different(dict, matcher)\r\n Habits = habits(dict, matcher)\r\n goals = goalsRecommendation(dict, matcher)\r\n prof = profesionalRecommendation(dict, matcher)\r\n similar = similarRecommendation(dict, matcher)\r\n\r\n listaopciones = [pareja, apps, dificultad, importancia, imp, gusto, region, gustoDif, Habits, goals, prof, similar]\r\n\r\n Prospectos = {}\r\n for option in listaopciones:\r\n for element in option:\r\n if Prospectos.has_key(element[\"nombre\"]):\r\n Prospectos[element[\"nombre\"]] = 1\r\n else:\r\n Prospectos[element[\"nombre\"]] = Prospectos[element[\"nombre\"]] + 1",
"def get_recommendations(soup_recipe):\n ratings = soup_recipe.find(\"meta\", {\"itemprop\": \"ratingValue\"})[\"content\"]\n ratings_count = soup_recipe.find(\"meta\", {\"itemprop\": \"ratingCount\"})[\"content\"]\n if ratings == 0:\n return None, None\n return ratings, ratings_count",
"def make_second_recommendation() -> str:\r\n growth_rate_info = highest_growth_rate()\r\n rate_strings = growth_rate_info[0]\r\n most_demand_string = growth_rate_info[1]\r\n return render_template(\"make_second_recommendation.html\",\r\n display_rates=rate_strings,\r\n most_demand_display=most_demand_string)",
"def get_recommendations(name, data):\r\n #sorts preferences in alphabetical order\r\n #do this to make it easier to compare\r\n for key in data:\r\n data[key] = selection_sort(data[key])\r\n most_similar_key = \"\"\r\n max_matches = 0\r\n for key in data:\r\n if not(key[-1] == \"$\" or data[key] == data[name]):\r\n \"\"\"if the person is not private or does not have the same data\"\"\"\r\n matches = num_matches(data[key], data[name])\r\n if matches > max_matches:\r\n most_similar_key = key\r\n max_matches = matches\r\n if most_similar_key == \"\":\r\n print(\"No recommendations available at this time\")\r\n return 1\r\n else:\r\n final_recommendations = []\r\n for x in data[most_similar_key]:\r\n if x not in data[name]:\r\n final_recommendations += [x]\r\n return final_recommendations",
"def print_recommendations(self):\n\n rec_vector = self.generate_recommendation()\n\n print(\"Recommendations for user {} \".format(self.username))\n\n for ranking, subreddit_name in enumerate(rec_vector, 1):\n print(\"{}.: {}\".format(ranking, subreddit_name))\n\n if ranking%10 == 0 and ranking!=0:\n check_if_move_on = True\n print(\"\\nType c and press enter for the next 10 subreddits.\\n\")\n print(\"Type q and press enter to return to main menu.\\n\")\n\n while check_if_move_on:\n choice = input()\n\n if choice == 'c':\n break\n\n elif choice == 'q':\n break\n\n else:\n print(\"Not a valid entry, please enter again.\")\n\n # break the whole thing if they want to quit\n if choice == 'q':\n break",
"def _choose_best_option(self):",
"def get_recommendations(self):\n endpoints = '/user/recs'\n return self.get_request(endpoints)",
"def make_third_recommendation() -> str:\r\n requirement_mappings = {\r\n \"Organic Red Helles\": 0,\r\n \"Organic Pilsner\": 0,\r\n \"Organic Dunkel\": 0}\r\n helles_info = bottles_required(\"Organic Red Helles\")\r\n pilsner_info = bottles_required(\"Organic Pilsner\")\r\n dunkel_info = bottles_required(\"Organic Dunkel\")\r\n\r\n requirement_mappings[\"Organic Red Helles\"] = helles_info[2]\r\n requirement_mappings[\"Organic Pilsner\"] = pilsner_info[2]\r\n requirement_mappings[\"Organic Dunkel\"] = dunkel_info[2]\r\n most_needed_recipe = max(requirement_mappings, key=requirement_mappings.get)\r\n\r\n return render_template(\"make_third_recommendation.html\",\r\n helles_display=helles_info,\r\n pilsner_display=pilsner_info,\r\n dunkel_display=dunkel_info,\r\n most_needed_display=most_needed_recipe)",
"def graphlab_recommendations(aData, user, needed_param, n = 10, cv_ratio = 0.7):\n # change the data into SFrame and the user data into SArray\n import preprocessing\n aData.rename(columns = {needed_param['user_id']:'user_id', needed_param['item_id']: 'item_id', \n needed_param['ratings']: 'ratings'}, inplace = True)\n aData = gl.SFrame(aData)\n train, test= preprocessing.graphlab_split_data(aData, cv_ratio)\n user = gl.SArray([user])\n \n # make models\n methods = ['matrix_factorization', 'linear_model', 'item_similarity', 'popularity', 'item_means']\n sim_type = ['jaccard', 'cosine', 'pearson']\n models = []\n for aMethod in methods:\n print aMethod\n if(aMethod != 'item_similarity'):\n model = gl.recommender.create(observation_data = train, user_id = 'user_id', \n item_id = 'item_id', target = 'ratings', method = aMethod)\n models.append(model)\n else:\n for aSim in sim_type:\n print aSim\n sim_model = gl.recommender.create(observation_data = train, user_id = 'user_id', \n item_id = 'item_id', target = 'ratings', method = aMethod, similarity_type = aSim)\n models.append(sim_model)\n \n # generate results for models as well as the rmse results\n recommended = []\n rmse = []\n for model in models:\n aResult = model.recommend(users = user, k = n)\n recommended.append(aResult)\n aRMSE = gl.evaluation.rmse(test['ratings'], model.predict(test))\n rmse.append(aRMSE)\n \n # create DataFrame\n df = pd.DataFrame({'models':models, 'recommended':recommended, 'rmse':rmse})\n # find the model that gives k least square errors\n df = df.sort('rmse', ascending = True).iloc[0:2]\n df.index = range(0,2)\n \n colnames = df['recommended'].loc[0].column_names()\n results = pd.DataFrame(columns = colnames)\n \n for aResult in df['recommended']:\n aResult = aResult.to_dataframe()\n results = results.append(aResult)\n \n results = results.sort('score', ascending = False)\n\n return results.sort('score', ascending=False), 'item_id'",
"def test_recommendation_evaluation_6(model):\n assert recommendation_evaluation(model, cn_test_users=None, k=2, n_pos_interactions=None, novelty=True) == \\\n {'HitRatio@2': 0.0, 'NDCG@2': 0.0, 'Precision@2': 0.0, 'Recall@2': 0.0}",
"def make_first_recommendation() -> str:\r\n available_tanks = tank_search()\r\n fermentation_tanks = available_tanks[0]\r\n conditioning_tanks = available_tanks[1]\r\n fermentation_advice = available_tanks[2]\r\n conditioning_advice = available_tanks[3]\r\n more_beer = available_tanks[4]\r\n return render_template(\"make_first_recommendation.html\",\r\n fermentation_string=fermentation_tanks,\r\n conditioning_string=conditioning_tanks,\r\n first_advice=fermentation_advice,\r\n second_advice=conditioning_advice,\r\n next_page=more_beer)",
"def check_recommendation_part(self, result):\n assert \"recommendation\" in result, \"Can not find the 'recommendation' node.\"\n recommendation = result[\"recommendation\"]\n assert recommendation == {} or \"component-analyses\" in recommendation, \\\n \"Wrong content of recommendation node\"\n if \"component_analyses\" in recommendation:\n self.check_component_analyses_recommendation(recommendation)",
"def recommend(self, u):\n\n sims = {} #similarities\n recommendation = \"\"\n topScore = None\n start = time.time()\n for movie_id, rating in enumerate(u):\n if rating != 0:\n sims[movie_id] = {}\n for r_id, movie in enumerate(self.ratings):\n sims[movie_id][r_id] = self.distance(movie,self.ratings[movie_id])\n # print time.time() - start, \"distance time\"\n\n start = time.time()\n for i, movieRating in enumerate(self.ratings):\n iPrediction = 0\n for movieName in self.ratedMovieList:\n j = self.titlesOnly.index(movieName)\n iPrediction += sims[j][i]*1.0 * self.userRatingVector[j]\n if topScore is None or iPrediction > topScore:\n movie = self.titlesOnly[i]\n if movie not in self.ratedMovieList and movie not in self.recommendedMovies:\n # print(\"prediction score for %s is %.5f\" % (movie, iPrediction))\n topScore = iPrediction\n recommendation = movie\n # print time.time() - start, \"recommendation time\"\n self.recommendedMovies.append(recommendation)\n\n articlePattern = re.match('(.*), (the|a|an|el|la)', recommendation)\n if articlePattern is not None:\n recommendation = articlePattern.group(2) + \" \" + articlePattern.group(1)\n\n return recommendation",
"def check_recommendation_in_result(context):\n json_data = context.response.json()\n result = json_data[\"recommendation\"]\n assert result == {}",
"def popular_recommend(row):\n actual = new_purchase_row(row)\n return f1(actual, popular_products)",
"def next_choice(self, opponent: 'Player') -> str:\n\n if self.adaptive_ai:\n # this is an adaptive_ai player, so see if it has collected\n # enough stats about the current opponent yet:\n if sum(self.opponent_choices[opponent.name].values()) > 5:\n # has enough samples to start adapting to the opponent\n print(' {} is trying to guess the opponent\\'s choice...'.format(self.name))\n\n # AI algorithm 1:\n # simply find the most-frequent selection by the opponent and\n # choose its killer.\n\n guess = self.opponent_choices[opponent.name].most_common(1)[0][0]\n ai_choice = weapon_to_beat(guess)\n print(' ', opponent.name, 'most often chose', guess, 'so he/she chose', ai_choice)\n return ai_choice\n\n # use the standard tendency distribution to choose a weapon:\n n = randint(1, self.randmax)\n if n <= self.tendency[0]:\n return 'rock'\n elif n <= self.tendency[0] + self.tendency[1]:\n return 'paper'\n else:\n return 'scissors'",
"def __str__(self):\n return str(self.get_rating())",
"def test_get_scored_recommendations_post(self):\n pass",
"def measure(self, recommender):\n similarity = 0\n items_shown = recommender.items_shown\n if items_shown.size == 0:\n # at the beginning of the simulation, there are no recommendations yet\n self.observe(None)\n return\n\n for pair in self.pairs:\n itemset_1 = set(items_shown[pair[0], :])\n itemset_2 = set(items_shown[pair[1], :])\n common = len(itemset_1.intersection(itemset_2))\n union = len(itemset_1.union(itemset_2))\n similarity += common / union / len(self.pairs)\n self.observe(similarity)",
"def measure(self, recommender):",
"def recommended_action(self) -> str:\n return pulumi.get(self, \"recommended_action\")",
"def svd_recommend_new(row):\n actual = new_purchase_row(row)\n recommended = svd_rec.recommend_new(u_dict[row[\"user_id\"]], N=10)\n recommended = [p_dict[r[0]] for r in recommended]\n return f1(actual, recommended)",
"def GetRecommendation(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")",
"def classical_recommendation(self, user, rank, quantum_format=True):\n # Make sure the user and rank are ok\n self._validate_user(user)\n self._validate_rank(rank)\n\n # Do the classical SVD\n _, _, vmat = np.linalg.svd(self.matrix, full_matrices=True)\n\n # Do the projection\n recommendation = np.zeros_like(user, dtype=np.float64)\n for ii in range(rank):\n recommendation += np.dot(np.conj(vmat[ii]), user) * vmat[ii]\n\n if np.allclose(recommendation, np.zeros_like(recommendation)):\n raise RankError(\"Given rank is smaller than the rank of the preference matrix. Recommendations \"\n \"cannot be made for all users.\")\n\n # Return the squared values for probabilities\n probabilities = (recommendation / np.linalg.norm(recommendation, ord=2))**2\n\n # Return the vector if quantum_format is False\n if not quantum_format:\n return probabilities\n\n # Format the same as the quantum recommendation\n prods = []\n probs = []\n for (ii, p) in enumerate(probabilities):\n if p > 0:\n prods.append(ii)\n probs.append(p)\n return prods, probs",
"def get_optimal_term_and_amortization_type(self):\n assert self.instance.ownership_time, \"ownership_time missing value.\"\n logger.info('SCENARIO-RECOMMENDATION: %s', self.instance.ownership_time)\n\n return self.SCENARIO_RECOMMENDATION[self.instance.ownership_time]",
"def sorted_recommended_products(self):\n return [\n r.recommendation\n for r in self.primary_recommendations.select_related(\"recommendation\").all()\n ]",
"def make_recommendation(fav_product,model_knn=model_knn,\n data=csr_matrix(df_product_features.values),\n\n mapper=products_to_idx,\n n_recommendations=6):\n # fit\n model_knn.fit(data)\n # get input movie index\n #print('You have input product:', fav_product)\n idx = fuzzy_matching(mapper, fav_product, verbose=True)\n if idx is None:\n return []\n #print('Recommendation system start to make inference')\n #print('......\\n')\n distances, indices = model_knn.kneighbors(data[idx], n_neighbors=n_recommendations + 1)\n\n raw_recommends = sorted(list(zip(indices.squeeze().tolist(), distances.squeeze().tolist())), key=lambda x: x[1])[\n :0:-1]\n\n # get reverse mapper\n #print(raw_recommends)\n reverse_mapper = {v: k for k, v in mapper.items()}\n # print recommendations\n #print('Recommendations for {}:'.format(fav_product))\n filter = []\n for i, (idx, dist) in enumerate(raw_recommends):\n #print('{0}: {1}, with distance of {2}'.format(i + 1, reverse_mapper[idx], dist))\n filter.append(reverse_mapper[idx])\n\n\n newproduct = pd.read_sql_query(\"\"\"SELECT p.*\n ,(SELECT img.url FROM image img WHERE p.id=img.product_id limit 1) as image\n ,(SELECT cate.cate_name FROM categories cate WHERE p.category_id=cate.id) as cateName\n FROM products p where p.name IN %s \"\"\", conn,params=(tuple(filter),))\n\n return newproduct.reset_index().to_json(orient='records')",
"def recommendation_and_reason(recent_low,recent_high,latest_close):\n if float(latest_close) < 1.2*float(recent_low) and float(latest_close) > 0.8*float(recent_high):\n recommendation = \"NO RECOMMENDATION\"\n reasoning = \"CANNOT ACCURATELY ESTIMATE IF STOCK IS UNDERVALUED OR OVERVALUED. LATEST CLOSING PRICE IS WITHIN 20% OF THE RECENT HIGH AND LOW.\" \n elif float(latest_close) < 1.2*float(recent_low):\n recommendation = \"BUY!\"\n reasoning = \"THE STOCK IS LIKELY TO BE UNDERVALUED (THE CLOSING PRICE IS WITHIN 20% OF THE STOCK'S RECENT LOW)\"\n elif float(latest_close) > 0.8*float(recent_high):\n recommendation = \"SELL!\"\n reasoning = \"THE STOCK IS LIKELY TO BE OVERVALUED (THE CLOSING PRICE IS WITHIN 20% OF THE STOCK'S RECENT HIGH)\"\n else:\n recommendation = \"NO RECOMMENDATION\"\n reasoning = \"NO SPECIFIC DATA TO ESTIMATE FUTURE PERFORMANCE\"\n recommendation_reasoning = [recommendation, reasoning]\n return recommendation_reasoning",
"def test_recommendation_evaluation_18(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=None,\n novelty=False, ignore_low_predictions_threshold=2) == \\\n {'HitRatio@2': 0.0167, 'NDCG@2': 0.0189, 'Precision@2': 0.02, 'Recall@2': 0.0167}",
"def check_for_recommendation_result_report(context):\n json_data = context.response.json()\n if \"recommendation\" in json_data:\n check_recommendation_in_result(context)\n else:\n look_for_other_attributes(context)\n check_vulnerability_in_result(context)",
"def compute_default_choice(self):\n\n choices = self.choices\n\n if len(choices) == 0:\n return None\n\n high_choice = max(choices, key=lambda choice: choice.performance)\n self.redis.hset(EXPERIMENT_REDIS_KEY_TEMPLATE % self.name, \"default-choice\", high_choice.name)\n self.refresh()\n return high_choice",
"def measure(self, recommender):\n items_shown = recommender.items_shown\n if items_shown.size == 0:\n # at beginning of simulation, there are no recommendations,\n # so we log a `None` value\n self.observe(None)\n return\n\n recommended_item_attr = recommender.items_hat.value[:, items_shown]\n\n afsr = np.mean(\n recommended_item_attr.max(axis=(0, 2)) - recommended_item_attr.min(axis=(0, 2))\n )\n\n self.observe(afsr)",
"def test_recommender(self):\n\n self._build_sample_graph()\n\n # set skill sa score to 1.0 and skill sb score to 0.5\n measure_sa = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sa.id)\n measure_sa.add_score(1.0)\n measure_sa.save()\n measure_sb = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sb.id)\n measure_sb.add_score(0.0)\n measure_sb.add_score(1.0)\n measure_sb.save()\n\n # verify that the proficient skill list equals [sa]\n # verify that the recommended skill list equals [sb, sc]\n skill_map = SkillMap.load(self.course, self.user_id)\n recommender = SkillRecommender.instance(skill_map)\n recommended, learned = recommender.recommend()\n self.assertEqual(1, len(learned))\n self.assertEqual(2, len(recommended))\n self.assertEqual(self.sb.id, recommended[0].id)\n self.assertEqual(self.sc.id, recommended[1].id)\n assert learned[0].competency_measure.last_modified\n\n # add second successful attempt for skill b and:\n # verify that the proficient skill list equals [sa, sb]\n # verify that the recommended skill list equals [sc, sd]\n measure_sb = competency.SuccessRateCompetencyMeasure.load(\n self.user_id, self.sb.id)\n measure_sb.add_score(1.0)\n assert measure_sb.proficient\n measure_sb.save()\n skill_map = SkillMap.load(self.course, self.user_id)\n recommender = SkillRecommender.instance(skill_map)\n recommended, proficient = recommender.recommend()\n self.assertEqual(2, len(proficient))\n self.assertEqual(2, len(recommended))\n self.assertEqual(self.sc.id, recommended[0].id)\n self.assertEqual(self.sd.id, recommended[1].id)",
"def beer_reccomendations(data: pd.DataFrame):\n # Add written review polarity and subjectivity using TextBlob sentiment analysis\n data = utils.add_review_polarity_subjectivity(data)\n\n # Get best beeres by indexing beer ID with top review polarity and review overall\n best_beers = data['beer_beerId'].loc[ (data['review_polarity'] >= 0.85) & (data['review_overall']==5) ]\n\n print(f\"These three beer reccomendations have 5 star reviews and top positive scores based on written reviews: {best_beers[0:3]}\")",
"def build_recommendations(sc, myRatings, model):\n #myRatedMovieIds = set([x[1] for x in myRatings])\n uid = get_uid_from_ratings(myRatings)\n #print \"uid:\", uid\n myRatedMovieIds = set([x[1] for x in myRatings.collect()])\n #print \"myRatedMovieIds:\", myRatedMovieIds\n candidates = sc.parallelize([m for m in movies if m not in myRatedMovieIds]).cache()\n #print candidates\n predictions = model.predictAll(candidates.map(lambda x: (uid, x))).collect()\n #print predictions\n recommendations = sorted(predictions, key = lambda x: x.product)\n return recommendations",
"def make_recommendation(model_knn, data, mapper, fav_parks, n_recommendations):\n # fit\n model_knn.fit(data)\n # get input park index\n #print('You have input movie:', fav_parks)\n idx = fuzzy_matching(mapper, fav_parks, verbose=True)\n \n #print('Recommendation system start to make inference')\n #print('......\\n')\n distances, indices = model_knn.kneighbors(data[idx], n_neighbors=n_recommendations+1)\n \n raw_recommends = \\\n sorted(list(zip(indices.squeeze().tolist(), distances.squeeze().tolist())), key=lambda x: x[1])[:0:-1]\n # get reverse mapper\n reverse_mapper = {v: k for k, v in mapper.items()}\n # print recommendations\n allrecs = []\n for i, (idx, dist) in enumerate(raw_recommends):\n allrecs.append([reverse_mapper[idx], dist])\n return allrecs",
"def display_rating(instance, args):\r\n raw_rating = instance.rating(args)\r\n # Do string conversion here\r\n if not raw_rating:\r\n str_rating = 'N/A'\r\n else:\r\n str_rating = \"{0:.2f}\".format(raw_rating)\r\n return str_rating",
"def get_recommendations(self):\n\n try:\n recommendations = Recommendations.objects.get(user_id=self.id)\n except DoesNotExist:\n print \"No recommendation object found. Creating one now.\"\n recommendations = Recommendations(user_id=self.id)\n recommendations.save()\n\n return recommendations",
"def test_find_recommendation_type(self):\n recommendations = RecommendationFactory.create_batch(1)\n for recommendation in recommendations:\n recommendation.create()\n logging.debug(recommendations)\n\n # find the recommendation in the list\n recommendation = Recommendation.find(recommendations[0].product_id, recommendations[0].recommendation_product_id)\n self.assertIsNot(recommendation, None)\n self.assertEqual(recommendation.product_id, recommendations[0].product_id)\n self.assertEqual(recommendation.recommendation_product_id, recommendations[0].recommendation_product_id)\n self.assertEqual(recommendation.relationship, recommendations[0].relationship)",
"def get_recommendations_for_user(self, user_id):\r\n\r\n sql_command = \"\"\"\r\n SELECT event_id, score\r\n FROM UserRecommendations\r\n WHERE user_id = '{0}'\r\n ORDER BY score\r\n \"\"\".format(user_id)\r\n self.controller.execute(sql_command)\r\n\r\n return self.controller.fetchall()",
"def print_top_recommendations(recommendations, n):\n top_recommendations = sorted(recommendations, key=lambda x: x.rating,\n reverse=True)[:n]\n table = PrettyTable([\"Rank\", \"Movie\", \"Estimated rating\"])\n for i in xrange(len(top_recommendations)):\n table.add_row([\n i+1,\n movies[top_recommendations[i].product] if print_movie_names\\\n else top_recommendations[i].product,\n top_recommendations[i].rating,\n ])\n print table",
"def recommend_nmf():\n pass",
"def recall(self, option='average'):\n\t\tif option == 'classwise':\treturn self.class_recall_\n\t\telif option == 'average':\treturn self.avg_recall_",
"def get_recommendations(df,song_title, similarity_score, num_recommends = 5):\r\n indices = pd.Series(df.index, index = df['track_name']).drop_duplicates()\r\n idx = indices[song_title]\r\n sim_scores = list(enumerate(similarity_score[idx]))\r\n sim_scores = sorted(sim_scores, key = lambda x: x[1],reverse = True)\r\n top_scores = sim_scores[1:num_recommends+1]\r\n song_indices = [i[0] for i in top_scores]\r\n return df[\"track_name\"].iloc[song_indices]",
"def getRecommendations(prefs,person,similarity=sim_pearson):\n weighted_similarities = dict((\n (other, similarity(prefs, person, other)) \n for other in prefs.keys() if other != person))\n # Eliminate critics with negative correlation (I'm not sure why\n # this is a good idea)\n for critic, sim in weighted_similarities.items():\n if sim <= 0:\n del weighted_similarities[critic]\n sum_ratings = defaultdict(int) # int() initializes to 0\n sum_weights = defaultdict(int)\n for other, weight in weighted_similarities.items():\n for movie, rating in prefs[other].items():\n sum_ratings[movie] += rating * weight\n sum_weights[movie] += weight\n recommendations = [(sum_ratings[movie]/sum_weights[movie], movie)\n for movie in sum_ratings.keys()\n if movie not in prefs[person].keys()]\n recommendations.sort()\n recommendations.reverse()\n return recommendations",
"def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\n #print \"--------------------------------------------------\"\n #print \"calculate_recommendations\"\n #print \"--------------------------------------------------\"\n\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\n\n # U = np.array('users')\n # D = np.array('video_games')\n\n # R = |U| cross |D|\n\n # We want to discover K latent features\n\n # Find\n # P(a | |U| corss K matrix)\n # Q(a | |D| cross K matrix)\n # Such that their product approximates R\n # R approx= P cross transpose(Q) = hat(R)\n #\n\n # r[i][j] = transpose(p)[i] * q[j]\n # = sum( 1..k, p[i][k] * q[k][j] )\n\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\n # squared error, estimated rating can be either higher or lower than the real thing\n\n # find the gradient\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\n\n # update rules\n # alpha = settings.alpha # learning_rate\n # alpha = 0.0002 # learning_rate\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\n\n # training data\n # T = (u[i], d[j], r[i][j])\n # np.array()\n\n # iterate until convergance\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\n # - sum(1..k, p[i][k]*q[k][j]))**2\n\n # regularization\n # beta = 0.02\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\n #\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\n\n data = np.array(vote_list)\n\n encoder = OneHotEncoder()\n\n users = data[:,0]\n unique_users = list(set(users))\n for i in range(len(users)):\n users[i] = unique_users.index(users[i])\n\n video_games = data[:,1]\n unique_games = list(set(video_games))\n for i in range(len(video_games)):\n video_games[i] = unique_games.index(video_games[i])\n\n ratings = data[:,2]\n M = len(set(video_games))\n N = len(set(users))\n R = np.zeros((N,M))\n for i in range(len(users)):\n user = users[i]\n game = video_games[i]\n rating = ratings[i]\n R[user][game] = rating\n\n K = 2\n\n P = np.random.rand(N,K)\n Q = np.random.rand(M,K)\n\n nP, nQ = self.matrix_factorization(R, P, Q, K)\n nR = np.dot(nP, nQ.T)\n\n itemMatch = {}\n for i in range(N):\n user = unique_users[i]\n itemMatch[user] = []\n for j in range(M):\n if R[i][j] == 0:\n video_game = unique_games[j]\n recommendation = (video_game, nR[i][j])\n itemMatch[user].append(recommendation)\n itemMatch[None] = []\n print 'pmf recommendations', itemMatch.items()\n print '\\n'\n recommendations = itemMatch.items()\n\n # returns\n # [\n # (<user1>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # (<user2>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # ]\n\n return recommendations",
"def test_recommendation_evaluation_4(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=None,\n novelty=False, n_test_users=10) == \\\n {'HitRatio@2': 0.0333, 'NDCG@2': 0.0585, 'Precision@2': 0.05, 'Recall@2': 0.0333}",
"def get_recommended_formations(opponent_formation, league, limit):\n\n cursor = mc.get_db_cursor(mc.DB_NAME)\n select_query = \"\"\"SELECT formation_1 FROM recom_formation\n WHERE formation_2 = %s\n AND league = %s\n ORDER BY formation_points DESC limit %s\"\"\"\n insert_value = (opponent_formation, league, limit)\n cursor.execute(select_query, insert_value)\n formations = cursor.fetchall()\n\n # initializes a dictionary for storing the recom formations\n result_dict = {\n \"recoms\": []\n }\n # save all the formations in the dictionary\n for formation in formations:\n result_dict[\"recoms\"].append(formation[0])\n return result_dict",
"def recommendations(self, **kwargs):\n\n path = self._get_movie_id_path('recommendations')\n resp = self._get_method(path, kwargs)\n return resp",
"def get_display_value(self):\n\n\t\treturn self.__display_value",
"def test_recommendation_evaluation_7(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=None,\n novelty=False, interaction_threshold=2) == \\\n {'HitRatio@2': 0.0069, 'NDCG@2': 0.0116, 'Precision@2': 0.0104, 'Recall@2': 0.0069}",
"def print_result(best_instance):\n\n print('Best instance: ')\n print('Generation: ' + str(best_instance.generation))\n print('Instance: ' + str(best_instance.instance))\n print('Fitness: ' + str(round(best_instance.value, 2)))\n print('Phenotype: ' + str(best_instance.phenotype))",
"def test_recommendation_evaluation_1(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=[1, 5, 10],\n n_pos_interactions=None, novelty=False, verbose=False) == \\\n {'HitRatio@1': 0.0, 'HitRatio@10': 0.0507, 'HitRatio@5': 0.0283, 'NDCG@1': -0.0003, 'NDCG@10': 0.0329,\n 'NDCG@5': 0.0223, 'Precision@1': 0.0, 'Precision@10': 0.016, 'Precision@5': 0.016, 'Recall@1': 0.0,\n 'Recall@10': 0.0507, 'Recall@5': 0.0283}",
"def describeRestaurant(self):\n print (f\"{self.name} has the best {self.cuisineType}\")",
"def test_create_a_recommendation(self):\n recommendation = Recommendation(product_id=1, recommendation_product_id=2, relationship=Type.UP_SELL)\n self.assertTrue(recommendation != None)\n self.assertEquals(recommendation.relationship, Type.UP_SELL)\n self.assertEquals(recommendation.product_id, 1)\n self.assertEquals(recommendation.recommendation_product_id, 2)",
"def test_recommendation_evaluation_9(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=[2, 3], n_pos_interactions=None,\n novelty=False, metrics=[NDCG(), HitRatio()], verbose=False) == \\\n {'HitRatio@2': 0.0167, 'HitRatio@3': 0.0233, 'NDCG@2': 0.0189, 'NDCG@3': 0.022}",
"def als_recommend(user_row, Y):\r\n\tWu = (user_row > 0).astype(int)\r\n\tlambda_ = 10\r\n\tn_factors = len(Y)\r\n\tXu = np.linalg.solve(np.dot(Y, np.dot(np.diag(Wu), Y.T)) + lambda_ * np.eye(n_factors),\r\n\t np.dot(Y, np.dot(np.diag(Wu), user_row.T))).T\r\n\tpredicted_row = np.dot(Xu, Y)\r\n\trecommendations = np.argsort(-np.multiply(predicted_row, (1 - Wu)))\r\n\t# Print the names?\r\n\treturn predicted_row, recommendations",
"def get_results():\n try:\n firstbeer = int(request.form['beerchoice1'])\n secondbeer = int(request.form['beerchoice2'])\n except:\n traceback.print_exc()\n logger.warning(\"Not able to display recommendations, error page returned\")\n return render_template('error-noselection.html')\n try:\n listbeers = db.session.query(Top_Ten_Beers).filter_by(Type=beertype)\n logger.debug(\"Top Ten Beers Query Accessed\")\n except:\n traceback.print_exc()\n logger.warning(\"Not able to display recommendations, error page returned\")\n if firstbeer==secondbeer:\n return render_template('error-samebeers.html')\n names, data = query_to_list(listbeers)\n top10df = pd.DataFrame.from_records(data, columns=names)\n usercomb = top10df.iloc[[firstbeer, secondbeer],:]\n try:\n allcomb = db.session.query(User_Combinations).filter_by(Type=beertype)\n logger.debug(\"Recommendation Query Accessed\")\n except:\n traceback.print_exc()\n logger.warning(\"Not able to display recommendations, error page returned\")\n names, data = query_to_list(allcomb)\n allcombdf = pd.DataFrame.from_records(data, columns=names)\n probablerows = allcombdf[allcombdf['Beer_ID'].isin(usercomb['Beer_ID'].values)]\n realrows = probablerows.groupby(['ID']).count()\n ID = realrows[realrows['Beer_ID']==2].index[0]\n try:\n preds = db.session.query(User_Predictions).filter_by(Type=beertype, ID=ID)\n logger.debug(\"Recommendation Results Query Accessed\")\n return render_template('results.html', beertype=beertype, preds=preds)\n except:\n traceback.print_exc()\n logger.warning(\"Not able to display beers, error page returned\")\n return render_template('error-noselection.html')",
"def test_find_recommendation_by_id_and_type(self):\n query_id = 1\n query_type = Type.UP_SELL\n recommendations = [Recommendation(product_id = query_id, recommendation_product_id = 2, relationship = query_type),\n Recommendation(product_id = query_id, recommendation_product_id = 10, relationship = query_type), \n Recommendation(product_id = query_id, recommendation_product_id = 15, relationship = Type.ACCESSORY)]\n\n for recommendation in recommendations:\n recommendation.create()\n logging.debug(recommendations)\n\n # find the 2nd recommendation in the list\n results = Recommendation.find_by_id_and_type(query_id, Type.UP_SELL)\n for recommendation in results:\n self.assertIsNot(recommendation, None)\n self.assertEqual(recommendation.product_id, query_id)\n self.assertEqual(recommendation.relationship, query_type)",
"def suggested_display_precision(self) -> int | None:\n if hasattr(self, \"_attr_suggested_display_precision\"):\n return self._attr_suggested_display_precision\n if hasattr(self, \"entity_description\"):\n return self.entity_description.suggested_display_precision\n return None",
"def list_recommendations(\n self, marketplace_id=None, recommendation_category=None, next_token=None\n ):\n return self.make_request(\n \"ListRecommendations\",\n {\n \"MarketplaceId\": marketplace_id,\n \"RecommendationCategory\": recommendation_category,\n },\n method=\"POST\",\n )",
"def disp_score():",
"def get_interactive_match(self, choices, query):\n if query in self.SKIP_KEYWORDS:\n return None\n results = process.extract(query, choices, limit=10) # fuzzy string matching\n best_match = results[0]\n second_best_match = results[1]\n if best_match[1] == second_best_match[1] or best_match[1] < 50: # if inconclusive or low score\n self.print(\"Couldn't find a conclusive match for '%s'. Best matches:\" % (query))\n i = 0\n for result in results:\n i += 1\n print(\" [%i] %s\" % (i, result[0]))\n answer = input(\"Choose one or specify a less ambiguous query: \")\n self.clear_lines(2 + len(results))\n if answer.isdigit() and int(answer) <= len(results):\n return results[int(answer) - 1][0]\n else:\n return self.get_interactive_match(choices, answer)\n else:\n return best_match[0]",
"def get_recommendations(prefs, person, similarity=sim_pearson):\n totals = {}\n similarity_sums = {}\n\n for other in prefs:\n if other == person:\n continue\n\n sim = similarity(prefs, person, other)\n\n if sim <= 0:\n continue\n\n for item in prefs[other]:\n if item not in prefs[person] or prefs[person][item] == 0:\n totals.setdefault(item, 0)\n totals[item] += prefs[other][item] * sim\n similarity_sums.setdefault(item, 0)\n similarity_sums[item] += sim\n\n # Normalized list\n rankings = [(total / similarity_sums[item], item)\n for item, total in totals.items()]\n\n # Returns normalized score, not an r that would be between -1 and 1\n rankings.sort()\n rankings.reverse()\n return rankings",
"def personalization(prediction, n):\n # prediction\n # n top n recommendation\n\n top_n = get_top_n(prediction, n)\n\n rec_dict = {}\n for uid, user_ratings in top_n.items():\n rec_dict[uid] = [iid for (iid, _) in user_ratings]\n\n rec_user_ls = [pred[0] for pred in prediction]\n rec_item_ls = [pred[1] for pred in prediction]\n\n unique_rec_user_ls = np.unique(rec_user_ls)\n unique_rec_item_ls = np.unique(rec_item_ls)\n\n # assign each item with index number\n unique_rec_item_dict = {item: ind for ind,\n item in enumerate(unique_rec_item_ls)}\n\n n_unique_rec_user = len(unique_rec_user_ls)\n n_unique_rec_item = len(unique_rec_item_ls)\n\n # recommended user item matrix\n rec_matrix = np.zeros(shape=(n_unique_rec_user, n_unique_rec_item))\n\n # represent recommended item for each user as binary 0/1\n for user in range(n_unique_rec_user):\n # get userid\n user_id = unique_rec_user_ls[user]\n # get rec item list\n item_ls = rec_dict[user_id]\n\n for item_id in item_ls:\n # get item index\n item = unique_rec_item_dict[item_id]\n rec_matrix[user, item] = 1\n\n # calculate cosine similarity matrix across all user recommendations\n similarity = cosine_similarity(X=rec_matrix, dense_output=False)\n # calculate average of upper triangle of cosine matrix\n upper_right = np.triu_indices(similarity.shape[0], k=1)\n # personalization is 1-average cosine similarity\n score = 1 - np.mean(similarity[upper_right])\n return score",
"def get_choice(choice):\r\n return {\r\n '0': ('Extraversion', 0.07),\r\n '1': ('Neuroticism', 0.27),\r\n '2': ('Agreeableness', 0.11),\r\n '3': ('Conscientiousness', 0.09),\r\n '4': ('Openness', 0.45)\r\n }.get(choice, (None, None))",
"def showRecommendations(self):\n\t\t#rn_im_index = np.where( df_index == 10561)[0][0] #similar color but no similar shape\n\t\t\n\t\t#rn_im_index = np.where( df_index == 22472)[0][0] # similar color but no similar shape\n\t\t\"\"\"\n\t\tOutput shape\n\t\t[(61706, 0.16241728944546732), (94073, 0.15613203034271395), (61836, 0.15494992784841455), (61835, 0.15494992784841452), (61825, 0.15163383319000062), (61745, 0.15031672266647675), (26848, 0.14479933826475058), (61760, 0.14353241349060006)]\n\n\t\tOutput Color\n\t\t[(22492, 0.72863097869032856), (22482, 0.66834821692729429), (3351, 0.45135804324105538), (29982, 0.40733726762782918), (85603, 0.40595375826379132), (22502, 0.38204339162468243), (29913, 0.36735985661014864), (29581, 0.3669268043422747)]\n\n\t\t\"\"\"\n\t\t\n\t\t#rn_im_index = np.where( df_index == 26746)[0][0] #Similar shape and similar color\n\n\t\t\"\"\"\n\t\tOutput shape\n\t\t[(27380, 0.1817530749164192), (29457, 0.1353165149065198), (1336, 0.12885937891206711), (27355, 0.12241573468787358), (29704, 0.12009259771972887), (29603, 0.11196184515165516), (29594, 0.11196184515165516), (26809, 0.11097441686854403)]\n\n\t\tOutput Color\n\t\t[(26809, 0.80634030626051745), (27380, 0.79789790693763663), (27355, 0.79542468562323521), (27018, 0.74331190002098657), (27197, 0.73454915804315535), (26913, 0.73410853271216192), (26905, 0.73410853271216192), (27617, 0.73098284820738935)]\n\n\t\t\"\"\"\n\n\t\t#rn_im_index = np.where( df_index == 27288)[0][0] #blurry image\n\t\t#rn_im_index = np.where( df_index == 27294)[0][0] # Similar Color and similar shape\n\t\t\"\"\"\n\t\tOutput shape\n\t\t[(27133, 0.35485652442453264), (27128, 0.32115384345167203), (27151, 0.25627343126278629), (27145, 0.25366123246450772), (27237, 0.25131923154633229), (27303, 0.22385072157466906), (27139, 0.22229444866797674), (27299, 0.22049959456469045)]\n\n\t\tOutput Color\n\t\t[(27133, 0.96240728970715483), (27128, 0.96009243888171958), (27145, 0.94268324228267275), (27303, 0.93286490646887354), (27139, 0.9244608465512546), (27237, 0.87199166625029467), (27049, 0.86531150055386774), (27066, 0.86139090244063599)]\n\n\t\t\"\"\"\n\n\t\t#rn_im_index = np.where( df_index == 52528)[0][0] # some have similar shape and some have similar color\n\t\t\"\"\"\n\t\tOutput shape\n\t\t[(93975, 0.31989999912901967), (61835, 0.31528273207820834), (61836, 0.31528273207820828), (61745, 0.31261425625988493), (61825, 0.31226105280375738), (61706, 0.31006537435901937), (61760, 0.29497111365575518), (94073, 0.28643748527418661)]\n\t\t\n\t\tOutput Color\n\t\t[(52542, 0.7633360888150692), (27402, 0.7582411610565466), (59301, 0.71242045321505865), (27329, 0.69968585913071302), (52539, 0.6996578131078881), (27335, 0.69215065941368603), (52469, 0.69152133535379212), (52473, 0.68799897765402473)]\n\n\t\tOutput c2d\n\t\t[(85620, 39705.292103093299), (52469, 38947.56038916672), (93975, 37706.480789897578), (52542, 37604.001320837888), (27402, 36709.321927197598), (27118, 36164.067396937884), (63718, 35906.648243400079), (63709, 35906.648243400079)]\n\t\n\n\t\t\"\"\"\n\t\t# Similar in color but dissimilar in shape\n\t\t#rn_im_index = np.where( df_index == 94380)[0][0] # Similar with color. Similar with shape. Very good with shape. Good Recommendations 52469(Shape) 94383 (color)\n\t\t\n\t\t\"\"\"\n\t\tOutput shape\n\t\t[(52469, 0.22380221768394279), (61836, 0.17343131445222859), (61835, 0.17343131445222859), (61825, 0.1713416617900273), (61745, 0.16700001977657994), (35922, 0.16614680579871874), (61715, 0.16380442450621885), (61706, 0.16194776280945139)]\n\t\t\n\t\tOutput Color\n\t\t[(94383, 0.69238692936637536), (26960, 0.58939898313472816), (26957, 0.58939898313472816), (29412, 0.58436143235370375), (29371, 0.58436143235370375), (29453, 0.5745231714319865), (29616, 0.57270906625007156), (29970, 0.57018718322031081)]\n\n\t\tOutput c2d\n\t\t[(94383, 37226.57203206882), (52558, 37007.251051234598), (26960, 36448.333956681076), (26957, 36448.333956681076), (1441, 36380.413117473567), (50197, 35994.006084886816), (94057, 35671.971168930344), (27533, 35061.385308567049)]\n\t\n\t\t\"\"\"\n\n\t\t#rn_im_index = np.where( df_index == 94080)[0][0] # some have similar shape and some have similar color\n\t\t\"\"\"\n\t\tOutput c2d\n\t\t[(57755, 29305.613736454678), (61797, 28828.064153886309), (61731, 28828.064153886309), (29417, 27874.375538422293), (63771, 27596.578857622582), (63765, 27596.578857622582), (63758, 27442.936837903482), (63750, 27442.936837903482)]\n\n\t\t\"\"\"\n\n\t\t# Completely random image that doesn't have similar images\n\t\t#rn_im_index = np.where( df_index == 1334)[0][0]\n\t\tdf = self.df\n\t\tdf_index = df.index.values\n\t\trn_im_index = random.randint(0, df.shape[0])\n\n\t\tprint \"random image index: {} id:{}\".format(rn_im_index, df_index[rn_im_index])\n\n\t\ti = rn_im_index\n\t\tindex_x = df.iloc[0:i,i].index\n\t\tindex_y = df.iloc[i,i:df.index.values.size].index\n\n\t\tvalues_x = df.iloc[0:i,i].values\n\t\tvalues_y = df.iloc[i,i:df.index.values.size].values\n\n\t\tindex = np.concatenate((index_x, index_y),axis=0)\n\t\tvalues = np.concatenate((values_x,values_y),axis=0)\n\n\t\tzipped = zip(index,values)\n\t\tzipped_sorted = sorted(zipped, key=lambda x: x[1])[::-1][0:8]\n\t\t#zipped_sorted = sorted(zipped, key=lambda x: x[1])[0:8]\n\t\tprint zipped_sorted\n\t\tindex , values = zip(*zipped_sorted)\n\t\t#print index\n\t\ttop_n_similar_images = map(int,list(index))\n\t\t#return df, duplicated_items\n\n\t\t# Filter out threshold less than 0.5\n\t\t#if self.mode == 'RGB':\n\t\tindex_aux = []\n\t\ti = 0\n\t\tfor im_id in top_n_similar_images:\n\t\t\tif self.mode == 'RGB' and values[i] > 0.5:\n\t\t\t\tindex_aux.append(im_id)\n\t\t\telif self.mode == 'L' and values[i] > 0.1:\n\t\t\t\tindex_aux.append(im_id)\n\t\t\ti += 1\n\n\t\ttop_n_similar_images = index_aux\n\n\t\tif len(top_n_similar_images) > 0 or self.mode == 'L':\n\t\t\n\t\t\t#print top_n_similar_images\n\t\t\ttop_n_similar_images = self.removeDuplicates(top_n_similar_images)\n\t\t\t#print top_n_similar_images\n\t\n\t\t\t#top_n_similar_images = df.sort_values(by=[rn_im_index],ascending = False).loc[:,rn_im_index][0:10].index.values\n\t\t\t\n\t\t\toutput = open(self.data_path + 'X_original.pkl', 'r')\n\t\t\tX_original = cPickle.load(output)\n\t\t\toutput.close()\n\t\t\t\n\t\t\t#print top_n_similar_images[0]\n\t\t\tindex = np.asarray(index,dtype='int64')\n\t\t\t\n\t\t\tif self.mode == 'RGB':\n\t\t\t\tself.reconstructImage(X_original[rn_im_index]).show()\n\t\t\telif self.mode == 'L':\n\t\t\t\tim_base = X_original[rn_im_index] * 256\n\t\t\t\tim_base = np.asarray(im_base, dtype='float64')\n\t\t\t\tim_base = filter.sobel(im_base)\n\t\n\t\t\t\tio.imshow(im_base)\n\t\t\t\tio.show()\t\n\n\t\t\tfor i in xrange(0,len(top_n_similar_images)):\n\t\t\t\tindex_i = np.where( df_index == top_n_similar_images[i])[0][0]\n\n\t\t\t\tif self.mode == 'L':\n\t\t\t\t\tim_i = X_original[index_i] * 256\n\t\t\t\t\tim_i = np.asarray(im_i, dtype='float64')\n\t\t\t\t\tim_i = filter.sobel(im_i)\n\t\n\t\t\t\t\tio.imshow(im_i)\n\t\t\t\t\tio.show()\n\n\t\t\t\telif self.mode == 'RGB':\n\t\t\t\t\tself.reconstructImage(X_original[index_i]).show()\n\t\telse:\n\t\t\tprint \"There are no image higher than the minimum threshold\"",
"def policy(self):\n element = self.find_css('#grading_type')[0]\n return self.get_selected_option_text(element)",
"def get_suggestions():\n\n flash(\"The Recommendation feature is under construction! Please check back soon!\")\n return render_template('index.html')",
"def opinion_type():\n pass",
"def recommend_cosim():\n pass",
"def part1_analyze_coefficients(sentence, display_mode):\n\n assert isinstance(display_mode, FeatureDisplayMode), \"`display_mode` must be `FeatureDisplayMode`.\"\n\n fv = user_review_model.fv\n clf = user_review_model.clf\n clf_coefficients = user_review_model.clf_coefficients\n feature_names = user_review_model.feature_names\n # feature_names_set = user_review_model.feature_names_set\n\n x = fv.transform([sentence]).toarray().flatten()\n\n prob_x = clf.predict_proba([x])[0]\n pred_x = int(prob_x[1] > 0.5)\n\n coef_feature_products = clf_coefficients * x\n\n nonzero_inds = x.nonzero()[0]\n\n if len(nonzero_inds) == 0:\n raise ValueError('No features detected.')\n\n figure_title = display_mode.title\n if display_mode == FeatureDisplayMode.prediction_contribution:\n nonzero_strength_values = coef_feature_products[nonzero_inds]\n elif display_mode == FeatureDisplayMode.feature_weight:\n nonzero_strength_values = clf_coefficients[nonzero_inds]\n elif display_mode == FeatureDisplayMode.raw_feature_tfidf:\n nonzero_strength_values = x[nonzero_inds]\n else:\n raise ValueError(\"Invalid `display_mode` type.\")\n\n detected_features = [feature_names[ind] for ind in nonzero_inds]\n\n ##################################\n # Show in feature extraction list\n ##################################\n\n tokenize = fv.build_tokenizer()\n tokens = tokenize(sentence)\n human_sorted_features = sort_features_human_friendly_order(tokens, detected_features)\n\n feature_to_ind = fv.vocabulary_\n ind_to_feature_contribution = {ind: contrib for ind, contrib in zip(nonzero_inds, nonzero_strength_values)}\n human_sorted_values = [ind_to_feature_contribution[feature_to_ind[f]] for f in human_sorted_features]\n\n\n ########################################\n # Show in feature contribution bar graph\n ########################################\n\n sorted_feature_values = sorted(zip(detected_features, nonzero_strength_values), key=lambda tup: tup[1]) # sort by values\n\n negative_feature_list = []\n negative_feature_values = []\n positive_feature_list = []\n positive_feature_values = []\n\n\n # Separate negative and positive\n min_val = np.inf\n max_val = -np.inf\n for f, val in sorted_feature_values:\n if val < 0:\n negative_feature_list.append(f)\n negative_feature_values.append(val)\n else:\n positive_feature_list.append(f)\n positive_feature_values.append(val)\n\n # Also get max/min values for later use\n abs_val = abs(val)\n if abs_val < min_val:\n min_val = abs_val\n if abs_val > max_val:\n max_val = abs_val\n\n positive_bars = go.Bar(\n y = positive_feature_list,\n x = positive_feature_values,\n name = 'Positive',\n orientation = 'h',\n marker = {\n 'color': rgba(*UI_STYLES.POSITIVE_COLOR, 0.7),\n 'opacity': 0.7,\n 'line': {\n 'color': rgba(*UI_STYLES.POSITIVE_COLOR),\n 'width': 2,\n }\n },\n )\n\n negative_bars = go.Bar(\n y = negative_feature_list,\n x = negative_feature_values,\n name = 'Negative',\n orientation = 'h',\n marker = {\n 'color': rgba(*UI_STYLES.NEGATIVE_COLOR, 0.7),\n 'line': {\n 'color': rgba(*UI_STYLES.NEGATIVE_COLOR),\n 'width': 2,\n }\n }\n )\n \n figure_feature_contribution = {\n 'data': [\n negative_bars,\n positive_bars,\n ],\n 'layout': go.Layout(\n title=figure_title,\n yaxis=dict(\n autorange=\"reversed\", \n automargin=True,\n ),\n xaxis=dict(\n automargin=True,\n ),\n ),\n }\n\n # Will used to later map in html UI e.g., opacity of elements based on strength\n relative_feature_strengths = get_relative_strengths(np.abs(human_sorted_values), 0.15, 1.0)\n data_for_sp = {\n 'positive_features': list(zip(positive_feature_list, positive_feature_values)),\n 'negative_features': list(zip(negative_feature_list, negative_feature_values)),\n 'min_val': min_val,\n 'max_val': max_val,\n }\n\n\n return {\n 'figure_feature_contribution': figure_feature_contribution,\n 'sp_data': data_for_sp,\n 'human_sorted_features': human_sorted_features,\n 'human_sorted_values': human_sorted_values,\n 'relative_feature_strengths': relative_feature_strengths,\n 'pred_x': pred_x,\n 'prob_x': prob_x,\n }",
"def recommend(user_id, ratings, movie_names, n_neighbors=10, n_recomm=5):\n \n # convert long to wide\n ratings_wide = ratings.pivot(index='user', columns='movie', values='rating')\n\n # all the items a user has not rated, that can be recommended\n all_items = ratings_wide.loc[user_id,:]\n unrated_items = all_items.loc[all_items.isnull()]\n \n # convert the index with item ids into Series values\n unrated_items = unrated_items.index.to_series(name='item_ids').reset_index(drop=True)\n print('User {} has {} unrated items.'.format(user_id, len(unrated_items)))\n \n # compute user similarities\n similarities = compute_similarities(user_id, ratings_wide)\n \n # generate predictions for unseen items based on the user similarity data\n predictions = unrated_items.apply(lambda d: predict_rating(d, ratings_wide, similarities, N=n_neighbors))\n \n # sort items by highest predicted rating\n predictions = predictions.sort_values(ascending=False)\n \n # recommend top N items\n recommends = predictions.head(n_recomm)\n \n # reformat the result\n recommends = recommends.to_frame(name='predicted_rating')\n recommends = recommends.rename_axis('movie_id')\n recommends = recommends.reset_index()\n \n recommends['name'] = recommends.movie_id.apply(lambda d: movie_names[d])\n \n return recommends",
"def test_recommendation_evaluation_3(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=1,\n novelty=False) == \\\n {'HitRatio@2': 0.02, 'NDCG@2': 0.0179, 'Precision@2': 0.01, 'Recall@2': 0.02}",
"def auto_review(self):\n return self._auto_review",
"def show_recall(self):\r\n return round((recall_score(self.actual, self.predicted)*100),2)",
"def test_set_scored_recommendations_post(self):\n pass",
"def recommend(self):\n\t\t\n\t\titems = self.unique_biz_id.items()\n\n\t\t# business id is essentially restaurant id, replace the naming \n\t\tfor rest1, i1 in items:\n\t\t\tfor rest2, i2 in items:\n\t\t\t\tif i1 < i2:\n\t\t\t\t\tsim, nsup = self.calculate_similarity( rest1 = rest1, rest2 = rest2 )\n\t\t\t\t\tself.database_sim[i1][i2] = sim\n\t\t\t\t\tself.database_sim[i2][i1] = sim\n\t\t\t\t\tself.database_sup[i1][i2] = nsup\n\t\t\t\t\tself.database_sup[i2][i1] = nsup\n\t\t\t\telif i1 == i2:\n\t\t\t\t\tnsup = self.df[ self.df['business_id'] == rest1 ]['user_id'].count()\n\t\t\t\t\tself.database_sim[i1][i1] = 1.0\n\t\t\t\t\tself.database_sup[i1][i1] = nsup",
"def get_initial_display(self):\r\n return {self.answer_id: self.initial_display}",
"def get_initial_display(self):\r\n return {self.answer_id: self.initial_display}",
"def display_score(self):\n if self.args:\n return self.display_score_for_group()\n return self.display_top_donor_for_each_group()",
"def taketurn(self):\n # get my options from the game\n opts = self.game.options()\n rec_opt = self._primestrat.recommend(opts, self.board)\n if rec_opt is not None:\n self.implementstrategy(rec_opt)\n else:\n super().taketurn()",
"def get_rating(self):\n self.rating = imdb.get_title_ratings(self.ID)['rating']",
"def log_best_performer(self) -> None:\n best = self.get_highest_accuracy()\n self.logger.info(f\"\\n\\nThe model with the highest accuracy {best[0]} has the following characteristics: \\n\")\n for k, v in best[1].items():\n if k != 'best_performer':\n self.logger.info(f\"{k} : {v}\")\n else:\n self.logger.info(f\"Best Accuracy: {v['Accuracy']}\")\n self.logger.info(\"Features used: \")\n for f in v['Labels']:\n self.logger.info(f)\n for nw, w in v['Vars'].items():\n self.logger.info(f\"{nw}: {w}\")",
"def async_get_preferred_item(self) -> str:\n return self._preferred_item",
"def choose_prescription(self):\n print(\"------\\nCHOOSE PRESCRIPTION!\\n------\")\n for idx, prescription in enumerate(self.prescriptions):\n print(f'PRESCRIPTION NO. {idx + 1}', end='')\n prescription.display()\n choice = input_integer(\"Enter the Prescription No. to buy medicines: \") - 1\n return self.prescriptions[choice]",
"def test_getting_rating_label_to_search(self):\n\n rating = get_rating_label_to_search(\"Hunger Rating\")\n self.assertEqual(rating, Post.hunger)",
"def item_based_recommend(user_id, user_item_time_dict, item2item_sim, sim_item_topk, recall_item_num, item_topk_click):\n \n # fetch the user's history clicks\n hist_items = user_item_time_dict[user_id]\n user_hist_items = []\n for (item_list, click_time) in hist_items:\n user_hist_items.extend(item_list)\n user_hist_items_ = {item_id for item_id in user_hist_items}\n \n item_rank = {}\n for item in user_hist_items:\n try:\n for another_item, wij in sorted(item2item_sim[item].items(), key=lambda x: x[1], reverse=True)[:sim_item_topk]:\n if another_item in user_hist_items_:\n continue\n\n item_rank.setdefault(another_item, 0)\n item_rank[another_item] += wij\n except:\n continue\n \n # fill the item_rank if the number of news in item_rank is less than recall_item_num\n if len(item_rank) < recall_item_num:\n for i, item in enumerate(item_topk_click):\n if item in item_rank.items():\n continue\n item_rank[item] = - i - 100 # set a random negative number\n if len(item_rank) == recall_item_num:\n break\n \n item_rank = sorted(item_rank.items(), key=lambda x: x[1], reverse=True)[:recall_item_num]\n \n return item_rank",
"def similarRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n similarE = user_preferences[\"gustos_similares\"]\r\n equal_styles = list(matcher.match(\"User\",similar = similarE))\r\n return equal_styles",
"def _recommend_movie(user_id, movie_id, number_movies):\n #get the recommended movie ids from pickled model\n rec_movies = sparkrecommender.movie_recomendation(user_id,movie_id,number_movies)\n #get a list of movies ids used in model\n moviesdf = pd.read_csv('movies.csv',index_col='movieId')\n \n #build list of lists with [[imdb ID, movie title, post img link]]\n rec_movies_list = []\n for movie_id in rec_movies:\n temp_list = []\n imdbid_ = str(get_imdbId(movie_id))\n temp_list.append(imdbid_)\n temp_list.append(moviesdf.loc[movie_id,'title'])\n temp_list.append('http://img.omdbapi.com/?apikey=ae550a04&i=tt'+str(imdbid_))\n rec_movies_list.append(temp_list)\n return rec_movies_list",
"def substitute_display(self, category_id, food_id):\n ref = category_id, food_id\n self.cursor.execute(\"\"\" SELECT food.name, store.name,\n food.link_openffacts,\n food.nutriscore, food.description, food.id\n FROM food\n INNER JOIN store_food\n ON food.id = store_food.food_id\n INNER JOIN store\n ON store_food.store_id = store.id\n WHERE food.id IN (SELECT category_food.food_id\n FROM category_food\n WHERE category_food.category_id = %s)\n AND food.id != %s\n ORDER BY food.nutriscore\n LIMIT 1 OFFSET 0\"\"\", ref)\n row = self.cursor.fetchone()\n print(\"Voici un subistitut de votre choix initial : \")\n print(\"Nom du produit : \" + row[0])\n print(\"Grade nutriscore : \" + row[3])\n print(\"Lien OpenFoodFacts : \" + row[2])\n print(\"Magasin(s) : \" + row[1])\n print(\"Description du produit : \" + row[4])\n return row[5]",
"def compute_recommendations_and_qii(sc, dataset, user_id):\n # TODO avoid retraining?\n print \"Training the model, rank:\", rank, \"numIter:\", numIter,\\\n \"lmbda:\", lmbda\n start_recommend_time = time.time()\n model = ALS.train(dataset, rank, numIter, lmbda)\n\n print \"Computing recommendations/QII for user: \", user_id\n myRatings = get_ratings_from_uid(dataset, user_id)\n #print \"User ratings: \", list(myRatings.collect())\n\n # make personalized recommendations\n recommendations = build_recommendations(sc, myRatings, model)\n end_recommend_time = time.time()\n rec_time = end_recommend_time - start_recommend_time\n print \"Time it took to create recommendations:\", rec_time\n\n if recommendations_to_print > 0:\n print \"Movies recommended for you:\"\n print_top_recommendations(recommendations, recommendations_to_print)\n\n local_influence = compute_local_influence(sc, user_id, recommendations,\n dataset, rank, lmbda, numIter, qii_iters)\n\n print \"Local influence:\"\n t = PrettyTable([\"Movie ID\", \"Local Influence\"])\n for mid, minf in sorted(local_influence.items(), key = lambda x: -x[1]):\n if print_movie_names:\n t.add_row([movies[mid], minf])\n else:\n t.add_row([mid, minf])\n print t\n\n return recommendations, local_influence",
"def Calcification(self):\n s = self.calcification\n assert s in range(1,7), \"Calcification score out of bounds.\"\n if s == 1: return 'Popcorn'\n elif s == 2: return 'Laminated'\n elif s == 3: return 'Solid'\n elif s == 4: return 'Non-central'\n elif s == 5: return 'Central'\n elif s == 6: return 'Absent'",
"def recommend(self, user_id, N=10):\n scores = self.user_factors[user_id] @ self.product_factors.T\n best = np.argpartition(scores, -N)[-N:]\n return sorted(zip(best, scores[best]), key=lambda x: -x[1])",
"def choose_option():\n print(\"1. title of most played game\"\n \"\\n2. how many copies have been sold in total\"\n \"\\n3. average selling\"\n \"\\n4. how many characters long is the longest title\"\n \"\\n5. average of the release dates\"\n \"\\n6. properties of the game\"\n \"\\n7. how many games are grouped by genre\"\n \"\\n8. ordered titles of games by date and alphabet\"\n \"\\n9. Exit\")\n\n option = input(\"\\nDisplay: \")\n return option",
"def getDecision(self):\n return self.decision"
] | [
"0.64533204",
"0.62321275",
"0.6155811",
"0.6037975",
"0.59529597",
"0.58630055",
"0.57988244",
"0.5778563",
"0.5745785",
"0.5703222",
"0.56989217",
"0.56337386",
"0.56248695",
"0.557974",
"0.55621016",
"0.5547041",
"0.55275047",
"0.55242544",
"0.5524008",
"0.55168205",
"0.5512141",
"0.55120516",
"0.5480696",
"0.5479235",
"0.54697424",
"0.54624045",
"0.5445806",
"0.5445535",
"0.54224813",
"0.5404911",
"0.5400754",
"0.5400704",
"0.5367185",
"0.5356928",
"0.53496945",
"0.5338782",
"0.5322811",
"0.5320682",
"0.5318845",
"0.5314615",
"0.53076416",
"0.53040475",
"0.52926844",
"0.5267264",
"0.5263863",
"0.5260472",
"0.5252695",
"0.52517223",
"0.52500856",
"0.5250064",
"0.5243575",
"0.52367324",
"0.523573",
"0.52344096",
"0.5223768",
"0.5222968",
"0.5220656",
"0.5207484",
"0.5207367",
"0.5199141",
"0.51910967",
"0.51854074",
"0.51831436",
"0.51795065",
"0.5159353",
"0.51531637",
"0.51502067",
"0.51476204",
"0.5146585",
"0.51400125",
"0.51316506",
"0.5125918",
"0.5117871",
"0.5101768",
"0.50898874",
"0.5084562",
"0.50837284",
"0.507609",
"0.5067608",
"0.5065973",
"0.5061441",
"0.50439715",
"0.5032723",
"0.5032723",
"0.5017222",
"0.50164753",
"0.50084966",
"0.5008308",
"0.50055724",
"0.50018376",
"0.500106",
"0.49981532",
"0.4994389",
"0.49928334",
"0.49883264",
"0.4977359",
"0.49764606",
"0.49754953",
"0.49731854",
"0.4968853"
] | 0.6441277 | 1 |
Note this initialization command will start spawning traffic and select the specified human demonstrators for imitation learning | def initialize_element(self):
init_command = {
"StartLearning": True,
"AgentID": 1854
}
msg = json.dumps(init_command).encode('unicode_escape')
self.socket_control.send(msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def starting_tests(self):\n# disable menus during testing, because their message loop seems to interfere\n# with the natlink message loop which waits for recognitionMimic to\n# finish\n self.testing = 1",
"def initMana():\n run(\"chariot-me -i\")",
"def starting_tests(self):\n# disable menus during testing, because their message loop seems to interfere\n# with the natlink message loop which waits for recognitionMimic to\n# finish\n self.enable_menus(0)\n self.testing = 1\n self.parent.starting_tests()",
"def main(argv):\n\n IP_ADDRESS = \"10.0.1.16\"\n\n robot = MistyRobot(IP_ADDRESS)\n\n print \"HELP: %s\\r\\n\" % pprint(robot.GetHelp())\n print \"DEVICE INFORMATION: %s\\r\\n\" % pprint(robot.GetDeviceInformation())\n print \"BATTERY LEVEL: %s\\r\\n\" % pprint(robot.GetBatteryLevel())\n print \"AUDIO CLIPS: %s\\r\\n\" % pprint(robot.GetListOfAudioClips())\n print \"AUDIO FILES: %s\\r\\n\" % pprint(robot.GetListOfAudioFiles())\n print \"VIDEO CLIPS: %s\\r\\n\" % pprint(robot.GetListOfVideoClips())\n\n print \"SENSORS: %s\\r\\n\" % pprint(robot.GetStringSensorValues())\n\n robot.LocomotionTrack(leftTrackSpeed=3, rightTrackSpeed=3)\n robot.Stop(delay=4)\n\n # This API call doesn't seem to work properly or consistently,\n # only moves head down, regardless of values\n #robot.MoveHead(pitch=-5, roll=0, yaw=0, velocity=4)\n #robot.MoveHead(pitch=5, roll=0, yaw=0, velocity=4, delay=3)\n\n # This API call doesn't seem to work\n robot.DriveTime(linearVelocity=3, angularVelocity=5, timeMS=5000, degrees=0)\n\n # This API call doesn't seem to work\n robot.Drive(linearVelocity=3, angularVelocity=5)\n robot.Stop(delay=4)\n\n robot.StartFaceTraining(faceId=\"person1\")\n robot.CancelFaceTraining(delay=5)\n\n print \"LEARNED FACES: %s\\r\\n\" % pprint(robot.GetLearnedFaces())\n\n robot.ClearLearnedFaces()\n\n print \"LEARNED FACES AFTER CLEAR: %s\\r\\n\" % pprint(robot.GetLearnedFaces())\n\n robot.SetMood(\"sad\")\n robot.SetMood(\"angry\", delay=3)\n robot.SetMood(\"groggy\", delay=3)\n robot.SetMood(\"confused\", delay=3)\n robot.SetMood(\"content\", delay=3)\n robot.SetMood(\"concerned\", delay=3)\n robot.SetMood(\"unamused\", delay=3)\n robot.SetMood(\"happy\", delay=3)\n robot.SetMood(\"love\", delay=3)",
"def setUp(self):\n super().setUp()\n self.devices = _DEVICE_STRATEGY()\n command_line = [\"pool\", \"create\", self._POOLNAME] + self.devices\n RUNNER(command_line)",
"def init(self, sevabot):\n self.sevabot = sevabot\n self.standard_xml = \"sevabot/alice/std-startup.xml\"\n\n self.commands = {\n \"!alice start\": self.start,\n \"!alice stop\" : self.stop\n }",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.setup_start_agents = False",
"def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\n sim.run(n_trials=100) # press Esc or close pygame window to quit",
"def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline= True ) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\n sim.run(n_trials=100) # press Esc or close pygame window to quit",
"def discovery():\n launch_training_on_all_splits(experiment='discovery', splits=DISCOVERY_SPLIT, base_model='pretrained', dropout=0.7987, learning_rate=0.00009659)",
"def setup_interactive(shared):\n parser = setup_args()\n parser.add_argument('--port', type=int, default=PORT, help='Port to listen on.')\n SHARED['opt'] = parser.parse_args(print_args=False)\n\n SHARED['opt']['task'] = 'parlai.agents.local_human.local_human:LocalHumanAgent'\n\n # Create model and assign it to the specified task\n agent = create_agent(SHARED.get('opt'), requireModelExists=True)\n SHARED['agent'] = agent\n # SHARED['world'] = create_task(SHARED.get('opt'), SHARED['agent'])\n\n # show args after loading model\n parser.opt = agent.opt\n parser.print_args()\n return agent.opt",
"def setup(self):\n self.machine = Machine(['a', 'b', 'c', '_'])",
"def train_main(cls):\n launcher = cls()\n launcher.launch()",
"def __init__(self):\n super().__init__(sys.argv)\n self.s1 = serverControl()\n self.c1 = clientControl(\"Markus\")\n self.c2 = clientControl(\"Hannes\")",
"def init_mission(agent_host, port=0, agent_type='Unknown', mission_type='Unknown', mission_seed=0,\n movement_type='Continuous'):\n\n # -- Set up the mission via XML definition --#\n mission_xml, msize, reward_goal, reward_intermediate, n_intermediate_rewards, reward_timeout, reward_sendcommand, timeout = GetMissionInstance(\n mission_type, mission_seed, agent_type)\n my_mission = MalmoPython.MissionSpec(mission_xml, True)\n my_mission.forceWorldReset()\n\n # -- Enforce the specific restriction for the assessed exercise --#\n # -- If you want a super agent, define one for you self --#\n my_mission.setModeToCreative()\n if agent_type.lower() == 'random':\n n = msize\n my_mission.observeGrid(-n, -1, -n, n, -1, n, 'grid')\n my_mission.requestVideoWithDepth(320, 240)\n elif agent_type.lower() == 'simple':\n n = msize\n my_mission.observeGrid(-n, -1, -n, n, -1, n, 'grid');\n my_mission.requestVideo(320, 240)\n elif agent_type.lower() == 'realistic':\n n = 1 # n=1 means local info only !\n my_mission.observeGrid(-n, -1, -n, n, -1, n, 'grid');\n my_mission.requestVideoWithDepth(320, 240)\n my_mission.observeFullInventory()\n elif agent_type.lower() == 'helper':\n n = 100\n my_mission.observeGrid(-n, -1, -n, n, -1, n, 'grid');\n my_mission.requestVideoWithDepth(320, 240)\n else:\n # -- Define a custom agent and add the sensors you need --#\n n = 100\n my_mission.observeGrid(-n, -1, -n, n, 1, n, 'grid');\n my_mission.requestVideoWithDepth(320, 240)\n\n # -- Add support for the specific movement type requested (and given the constraints of the assignment) --#\n # -- See e.g. http://microsoft.github.io/malmo/0.17.0/Schemas/MissionHandlers.html --#\n if movement_type.lower() == 'absolute':\n my_mission.allowAllAbsoluteMovementCommands()\n elif movement_type.lower() == 'continuous':\n my_mission.allowContinuousMovementCommand('move')\n my_mission.allowContinuousMovementCommand('strafe')\n my_mission.allowContinuousMovementCommand('pitch')\n my_mission.allowContinuousMovementCommand('turn')\n my_mission.allowContinuousMovementCommand('crouch')\n elif movement_type.lower() == 'discrete':\n my_mission.allowDiscreteMovementCommand('turn')\n my_mission.allowDiscreteMovementCommand('move')\n my_mission.allowDiscreteMovementCommand('movenorth')\n my_mission.allowDiscreteMovementCommand('moveeast')\n my_mission.allowDiscreteMovementCommand('movesouth')\n my_mission.allowDiscreteMovementCommand('movewest')\n my_mission.allowDiscreteMovementCommand('look')\n\n # -- Get the resulting xml (and return in order to check that conditions match the report) --#\n final_xml = my_mission.getAsXML(True)\n\n # Set up a recording for later inspection\n my_mission_record = MalmoPython.MissionRecordSpec('tmp' + \".tgz\")\n my_mission_record.recordRewards()\n my_mission_record.recordMP4(24, 400000)\n\n # -- Attempt to start a mission --#\n max_retries = 5\n for retry in range(max_retries):\n try:\n agent_host.startMission(my_mission, my_mission_record)\n break\n except RuntimeError as e:\n if retry == max_retries - 1:\n print(\"Error starting mission:\", e)\n exit(1)\n else:\n time.sleep(2)\n\n # -- Loop until mission starts: --#\n print(\"Waiting for the mission to start \")\n state_t = agent_host.getWorldState()\n while not state_t.has_mission_begun:\n sys.stdout.write(\".\")\n time.sleep(0.1)\n state_t = agent_host.getWorldState()\n for error in state_t.errors:\n print(\"Error:\", error.text)\n\n print\n print(\"Mission started (xml returned)... \")\n return final_xml, reward_goal, reward_intermediate, n_intermediate_rewards, reward_timeout, reward_sendcommand, timeout",
"def __init__(self, agent_id=\"default\", experiment_id=\"default\"):\n self.runtime = runtime()\n self.agent_id = agent_id\n self.experiment_id = experiment_id",
"def initialize_robot():\n\n proxy_motion = naoqi.ALProxy(\"ALMotion\", IP_ROBOT, PORT_ROBOT)\n proxy_motion.wakeUp()\n\n proxy_autonomous_life = naoqi.ALProxy(\"ALAutonomousLife\", IP_ROBOT, PORT_ROBOT)\n proxy_autonomous_life.setState(\"disabled\")\n\n proxy_motion = naoqi.ALProxy(\"ALMotion\", IP_ROBOT, PORT_ROBOT)\n proxy_motion.wakeUp()",
"def __init__(self, machine):\n super().__init__(machine)\n self.features['has_steppers'] = True",
"def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.00000001, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line",
"def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.001, display=True) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line",
"def __init__(self, numOfGames, muteOutput, randomAI, AIforHuman):\n self.numOfGames = numOfGames\n self.muteOutput = muteOutput\n self.maxTimeOut = 10000\n\n self.AIforHuman = AIforHuman\n self.gameRules = GameRules()\n self.AIPlayer = TicTacToeAgent()\n\n if randomAI:\n self.AIPlayer = randomAgent()\n else:\n self.AIPlayer = TicTacToeAgent()\n if AIforHuman:\n self.HumanAgent = randomAgent()\n else:\n self.HumanAgent = TicTacToeAgent1()",
"def main():\n print(\"runner\")\n runner = Runner()\n stop_on_idle = True\n probes = []\n for url in urls:\n probe_cls = random.choice((HttpProbe, ThreadProbe, ShellProbe))\n runner.probes.append(probe_cls(url))\n\n runner.run()",
"def setUp(self):\n lang = self._sim_lang\n self._simulator = self._find_resource(\n f\"drake/examples/hardware_sim/hardware_sim_{lang}\")\n self._example_scenarios = self._find_resource(\n \"drake/examples/hardware_sim/example_scenarios.yaml\")\n self._test_scenarios = self._find_resource(\n \"drake/examples/hardware_sim/test/test_scenarios.yaml\")\n self._default_extra = {\n # For our smoke test, exit fairly quickly.\n \"simulation_duration\": 0.0625,\n }",
"def __init__(self, numOfGames, muteOutput, randomAI, AIforHuman):\n self.numOfGames = numOfGames\n self.muteOutput = muteOutput\n self.maxTimeOut = 30 \n\n self.AIforHuman = AIforHuman\n self.gameRules = GameRules()\n self.AIPlayer = TicTacToeAgent()\n\n if randomAI:\n self.AIPlayer = randomAgent()\n else:\n self.AIPlayer = TicTacToeAgent()\n if AIforHuman:\n self.HumanAgent = randomAgent()\n else:\n self.HumanAgent = keyboardAgent()",
"def run(num_trials):\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.1, display=True) \n # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=num_trials) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n\n a.performace_report(num_trials)",
"def multi_agent_example():\n env = holodeck.make(\"CyberPunkCity-FollowSight\")\n\n cmd0 = np.array([0, 0, -2, 10])\n cmd1 = np.array([0, 0, 0])\n for i in range(10):\n env.reset()\n env.tick()\n env.act(\"uav0\", cmd0)\n env.act(\"nav0\", cmd1)\n for _ in range(1000):\n states = env.tick()\n pixels = states[\"uav0\"][\"RGBCamera\"]",
"def experiment_init(self):\n pass",
"def __init__(self, network: Network):\n if LOG[\"ExperimentAI\"]:\n print(\"[ExperimentAI] Initializing AI\")\n self.network = network",
"def init():\n\n @click.group(cls=cli.make_commands(__name__))\n def run():\n \"\"\"Cross-cell supervision tools.\"\"\"\n cli.init_logger('daemon.conf')\n\n return run",
"def main():\n\n\t# Run setup\n\ts = Setup()\n\tcontrolRoom, studio, newscaster = s.beginSetup()\n\n\t# Start cameras\n\tcontrolRoom.startCameras()\n\tprint 'Cameras started'\n\tcontrolRoom.setCameraSize()\n\n\tif len(controlRoom.studio.cameras) > 1:\n\t\tprint 'Everything up and running...'\n\n\t\t# Fetch a camera that best matches the headpose angle\n\t\tcamera = controlRoom.getClosestCamera()\n\t\twhile True:\n\t\t\t# If advance camera selection algo indicates true, fetch camera closest to headpose\n\t\t\tif controlRoom.cameraSelectionADV():\n\t\t\t\tcamera = controlRoom.getClosestCamera()\n\t\t\tprint 'Active camera: ' + str(camera.cameraID)\n\t\t\t\n\t\t\t# Capture frame or in simulation mode, light up led\n\t\t\tcamera.capture()\n\n\telif len(controlRoom.studio.cameras) == 1:\n\t\twhile True:\n\t\t\tcontrolRoom.studio.cameras[0].capture()\n\t\t\ttime.sleep(2)\n\telse:\n\t\tprint 'No cameras found! Something seems to be wrong...'\n\n\t# Shutdown all cameras and kill all windows\n\tcontrolRoom.shutdownCameras()",
"def parley(self):\n wait_times = constants.TUTORIAL_WAIT_TIMES\n self.introduce_chat_interface()\n self.wait_for_response(\n message='Please type a greeting message to continue.',\n delay_time=wait_times['chat-interface'],\n )\n self.introduce_persona()\n self.wait_for_response(\n message=constants.APPRENTICE_PERSONA_ROLE_INSTRUCTION,\n delay_time=wait_times['persona'],\n )\n self.introduce_partner_entity()\n self.wait_for_response(\n message=constants.APPRENTICE_CHITCHAT_INSTRUCTION,\n delay_time=wait_times['persona'],\n )\n self.introduce_partner_knowledge()\n self.wait_for_response(\n message=constants.APPRENTICE_PERSONA_MSG_INSTRUCTION,\n delay_time=wait_times['knowledge'],\n )\n self.go_for_start()\n self.episodeDone = True",
"def agent_init(self):\n pass",
"def main(_):\n description = xm.ExperimentDescription(\n 'HIS - trial=%d' % FLAGS.trial, tags=['his'])\n experiment = build_experiment()\n xm.launch_experiment(description, experiment)",
"def initialize_home_hub(argv):\n parse_cmd_line_opts(argv)\n init_logging()\n init_error_reporting()\n \n # Verify we have a valid home id\n if HOME_ID is None:\n print('Home ID is invalid or missing. Please provide an integer following the -i flag')\n exit()\n\n # Begin Home Hub Specific Setup\n logger.info('Starting the Home Hub main program for Home: %s', HOME_ID)\n\n # Get the email and password for this HH's user from the env vars\n powernet_user_email = os.getenv('POWERNET_USER_EMAIL', None)\n powernet_user_password = os.getenv('POWERNET_USER_PASSWORD', None)\n \n if powernet_user_email is None:\n logger.info('Missing the required login email address')\n logger.info('Please set the POWERNET_USER_EMAIL environment variable and try again')\n exit()\n \n if powernet_user_password is None:\n logger.info('Missing the required login password')\n logger.info('Please set the POWERNET_USER_PASSWORD environment variable and try again')\n exit()\n \n # attempt to authenticate against our API\n form_payload = {'email': powernet_user_email, 'password': powernet_user_password}\n response = requests.post('https://pwrnet-158117.appspot.com/api/v1/powernet_user/auth/', data=form_payload)\n auth_token = response.json()['token']\n\n # Initializing variables for queue and threads\n rpi = HardwareInterface(house_id=HOME_ID, gpio_map=None, auth_token=auth_token)\n buffer_size = 8\n q_ai = Queue(buffer_size)\n\n # Initialize threads\n producer_ai_thread = Thread(name='Producer', target=rpi.producer_ai, args=(q_ai,))\n producer_ai_thread.start()\n\n consumer_ai_thread = Thread(name='Consumer', target=rpi.consumer_ai, args=(q_ai,))\n consumer_ai_thread.start()\n\n devices_thread = Thread(name='Device', target=rpi.devices_th)\n devices_thread.start()\n\n load_control_thread = Thread(name=\"LoadControl\", target=rpi.local_controller_th)\n load_control_thread.start()",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.start_agents_once = False\n self.start_servers_once = False\n self.setup_start_agents = False\n self.setup_start_servers = False",
"def __init__(self, a):\n # sanity check\n assert(isinstance(a, agent.Agent))\n \n # save the agent reference\n self.a = a\n \n self.a.tc_h1(\"CONNECT TESTS\")\n \n # create the host instance\n self.host = host.Host(a, STA)\n # create the access point instances\n self.ap1 = accesspoint.AccessPoint(a, AP1, channel=5, period=100, ssid=\"louis\")\n self.ap2 = accesspoint.AccessPoint(a, AP2, channel=11, period=100, ssid=\"louis\")\n\n # reset the host (resetting the MIBs)\n self.host.reset(True)\n\n # set the host MAC address\n self.host.dbg_macaddr()",
"def start(self):\n self.__init__()\n self.set_n_players()\n self.init_players()\n self.init_territory_selection_phase()\n self.init_troop_deployment_phase()\n # self.game_phase()",
"def main():\n utils.vip_main(actuator_agent, identity='platform.d.actuator')",
"def onSpawn(self):\n self.spawned = True\n self._interactor.initialiseDevices()",
"def _starting_up():\n global bus, skill_manager, event_scheduler\n\n bus.on('intent_failure', FallbackSkill.make_intent_failure_handler(bus))\n\n # Create the Intent manager, which converts utterances to intents\n # This is the heart of the voice invoked skill system\n service = IntentService(bus)\n try:\n PadatiousService(bus, service)\n except Exception as e:\n LOG.exception('Failed to create padatious handlers '\n '({})'.format(repr(e)))\n event_scheduler = EventScheduler(bus)\n\n # Create a thread that monitors the loaded skills, looking for updates\n try:\n skill_manager = SkillManager(bus)\n except MsmException:\n # skill manager couldn't be created, wait for network connection and\n # retry\n LOG.info('Msm is uninitialized and requires network connection',\n 'to fetch skill information\\n'\n 'Waiting for network connection...')\n while not connected():\n time.sleep(30)\n skill_manager = SkillManager(bus)\n\n skill_manager.daemon = True\n # Wait until priority skills have been loaded before checking\n # network connection\n skill_manager.load_priority()\n skill_manager.start()\n check_connection()",
"def main():\n\n run_manual_session()\n # run_automated_session()",
"def __init__(self, scenario):\n client.__init__(self, scenario)\n # TODO: Your initialization, if any (not likely). Oh, and remove the next line.\n raise Exception( \"DO NOT instantiate the skeleton implementation\" )",
"def setup(client):\n client.add_cog(ProcessDisplay(client))",
"def main():\n driver = Driver()\n driver.start()",
"def launch(**kwargs):\n\n logger, loghost, logport, clients, guis, params = unpack_launcher(**kwargs)\n config = load_config(kwargs['config'], logger=logger)\n\n\n ao_client = find_client(logger, clients, 'nidaqmx')\n ai_client = find_client(logger, clients, 'nidaqmx_ai')\n\n # Instantiate Monitor script\n laser_stabilizer = LaserStabilizer(\n config=kwargs['config'],\n ao_client=ao_client,\n ai_client=ai_client\n )\n\n update_service = Service()\n update_service.assign_module(module=laser_stabilizer)\n update_service.assign_logger(logger=logger)\n update_server, update_port = create_server(update_service, logger, host=get_ip())\n logger.update_data(data={'port': update_port})\n laser_stabilizer.gui.set_network_info(port=update_port)\n update_server.start()\n\n # Run continuously\n # Note that the actual operation inside run() can be paused using the update server\n while True:\n\n laser_stabilizer.run()",
"def setUp(self):\n _, instance_path, shared_inputs = sys.argv\n app = lnt.server.ui.app.App.create_standalone(instance_path)\n app.testing = True\n self.client = app.test_client()\n self.shared_inputs = shared_inputs",
"def main():\n tester = Tester()\n # parse args, load configuration and create all required objects.\n tester.setup_experiment()\n # GO!\n tester.run_experiment()",
"def minimal_interactive_cli_bootstrap(client):\n # Fetch available TAN mechanisms by the bank, if we don't know it already. If the client was created with cached data,\n # the function is already set.\n if not client.get_current_tan_mechanism():\n client.fetch_tan_mechanisms()\n mechanisms = list(client.get_tan_mechanisms().items())\n if len(mechanisms) > 1:\n print(\"Multiple tan mechanisms available. Which one do you prefer?\")\n for i, m in enumerate(mechanisms):\n print(i, \"Function {p.security_function}: {p.name}\".format(p=m[1]))\n choice = input(\"Choice: \").strip()\n client.set_tan_mechanism(mechanisms[int(choice)][0])\n\n if client.is_tan_media_required() and not client.selected_tan_medium:\n print(\"We need the name of the TAN medium, let's fetch them from the bank\")\n m = client.get_tan_media()\n if len(m[1]) == 1:\n client.set_tan_medium(m[1][0])\n else:\n print(\"Multiple tan media available. Which one do you prefer?\")\n for i, mm in enumerate(m[1]):\n print(i,\n \"Medium {p.tan_medium_name}: Phone no. {p.mobile_number_masked}, Last used {p.last_use}\".format(\n p=mm))\n choice = input(\"Choice: \").strip()\n client.set_tan_medium(m[1][int(choice)])",
"async def start(self, roles, dialogs):\n self.__init__(self.active_role, (self.active_help, self.external_help))",
"def init():\r\n\t# add grabber tools based on proxy tools\r\n\tfor proxyWrapper in vizconnect.getToolsWithMode('Proxy'):\r\n\t\tgrabberTool = tools.grabber.HandGrabber(usingPhysics=False,\r\n\t\t\t\t\t\t\t\t\t\t\t\tusingSprings=False,\r\n\t\t\t\t\t\t\t\t\t\t\t\tplacementMode=tools.placer.MODE_DROP_DOWN)\r\n\t\t\r\n\t\tname = 'grabber_tool_based_on_'+proxyWrapper.getName()\r\n\t\tgrabberWrapper = vizconnect.addTool(raw=grabberTool,\r\n\t\t\t\t\t\t\t\t\t\t\tname=name,\r\n\t\t\t\t\t\t\t\t\t\t\tmake='Virtual',\r\n\t\t\t\t\t\t\t\t\t\t\tmodel='Grabber')\r\n\t\t# parent the grabber wrapper to the proxy's parent\r\n\t\tgrabberWrapper.setParent(proxyWrapper)\r\n\t\t\r\n\t\tgrabberTool.setItems(grabbableItems)\r\n\t\r\n\tviz.callback(viz.getEventID('RESET_THE_LOFT_LAYOUT'), lambda e: resetMovedObjects())",
"def main():\n args = _parse_arguments()\n\n util.log_init(\"sitl_A%s_%s.txt\" % (args.id, util.get_latest_log(\"latest_sitl.txt\")), util.log_level[args.level])\n\n shared.AGENT_ID = 'A%s' % args.id\n shared.AGENT_COUNT = args.n\n shared.CURRENT_ALGORITHM = args.algorithm\n shared.AGENT_CHARACTER = args.character\n shared.des_alt = args.alt\n \n util.log_info(\"AGENT_ID = %s\" % shared.AGENT_ID)\n util.log_info(\"Algorithm: %s\" % shared.CURRENT_ALGORITHM)\n util.log_info(\"Agent type: %s\" % shared.AGENT_CHARACTER)\n\n print \"Start simulator (SITL)\"\n sitl = SITL(args.pix) # initialize SITL with firmware path\n\n if shared.AGENT_ID in start_loc:\n sitl_args = ['--home=%s' % start_loc[shared.AGENT_ID]]\n else:\n sitl_args = ['--home=%s' % start_loc['FFF']]\n \n # Pre-recorded coordinates.\n #sitl_args = ['-I0', '--model', 'quad', '--home=31.301201,121.498192,9,353']\t\n sitl.launch(sitl_args, await_ready=True, restart=True)\n\n # Connect to the vehicle. (Spawn an instance of Vehicle named \"vehicle\")\n # connection port is coded in the file name of the firmware like \"ac3.4.5_port5760\"\n # use regular expression to search the string and extract port number\n port = re.search(r'port\\d{4}', args.pix)\n port = re.search(r'\\d{4}', port.group()).group()\n\n print \"Connecting to copter on: TCP: 127.0.0.1:%s\" % port\n copter = nav.connect('tcp:127.0.0.1:%s' % port, wait_ready=True, rate=20)\n util.log_info(\"Copter connected. Firmware: %s\" % copter.version)\n \n if not args.xbee: # simulate XBee using ZeroMQ\n [pub, sub] = comm.zmq_init(comm_port_list[shared.AGENT_ID], comm_port_list)\n subscriber_thread = comm.Subscriber(shared.AGENT_ID, sub)\n subscriber_thread.start()\n xbee = pub # make xbee the publisher\n util.log_info(\"ZeroMQ initialzied.\") \n \n else: # use actual xbee ports\n ser = serial.Serial(args.xbee, 57600)\n xbee = comm.xbee_init(ser)\n util.log_info(\"Xbee initialzed.\")\n\n info = \"IFO,%s connected with firmware %s\" % (shared.AGENT_ID, copter.version)\n comm.xbee_broadcast(xbee, info)\n\n _add_listeners(copter)\n\n takeoff_thread = nav.Takeoff(copter, xbee, shared.des_alt, 3)\n purge_thread = comm.Purge(shared.neighbors)\n broadcast_thread = comm.Broadcast(shared.AGENT_ID, copter, xbee)\n flocking_thread = _choose_algorithm(copter, xbee, shared.neighbors)\n\n takeoff_thread.start()\n takeoff_thread.join() # wait until takeoff procedure completed\n\n if shared.status['airborne']: # only execute the threads when airborne\n util.log_info(\"Copter is airborne, starting threads.\")\n broadcast_thread.start()\n purge_thread.start()\n flocking_thread.start()\n\n # main loop\n while True:\n try: time.sleep(.2)\n except KeyboardInterrupt: break\n \n if shared.status['airborne']:\n # echo exiting status\n if shared.status['exiting']:\n info = \"IFO,%s %s-ing.\" % (shared.AGENT_ID,shared.status['command'])\n comm.xbee_broadcast(xbee, info)\n util.log_info(info)\n\n # if an rtl or land command is received, kill flocking and set the `exiting` flag\n elif shared.status['command'] == 'RTL' or shared.status['command'] == 'LAND':\n shared.status['thread_flag'] |= shared.FLOCKING_FLAG\n nav.set_mode(copter, shared.status['command'])\n shared.status['exiting'] = True\n\n if not flocking_thread.is_alive(): # break the loop if finished\n break\n\n nav.wait_for_disarm(copter) # wait for disarm\n comm.xbee_broadcast(xbee, 'IFO,%s terminated.' % shared.AGENT_ID)\n\n # clean up\n purge_thread.stop()\n while purge_thread.is_alive(): \n util.log_info('Waiting for purge to shutdown') \n purge_thread.join(3)\n util.log_info('Purge killed.')\n\n broadcast_thread.stop()\n while broadcast_thread.is_alive(): \n util.log_info('Waiting for broadcast to shutdown') \n broadcast_thread.join(3)\n util.log_info('Broadcast killed.')\n\n copter.close()\n util.log_info(\"Copter shutdown.\")\n\n if args.xbee:\n xbee.halt()\n ser.close()\n util.log_info(\"Xbee and serial closed.\")\n else:\n subscriber_thread.stop()\n while subscriber_thread.is_alive(): \n util.log_info('Waiting for Subscriber to shutdown') \n subscriber_thread.join(3)\n util.log_info('Subscriber killed.')\n\n sitl.stop()\n util.log_info(\"SITL shutdown.\")",
"def initialize(self):\n if self.real:\n self.agent.connect(self)\n else:\n self.connect() # Connect python client to VREP\n self.agent.connect(self)",
"def setup(cls):\n cls.runner = CliRunner()\n cls.agent_name = \"myagent\"\n cls.cwd = os.getcwd()\n cls.t = tempfile.mkdtemp()\n # copy the 'packages' directory in the parent of the agent folder.\n shutil.copytree(Path(CUR_PATH, \"..\", \"packages\"), Path(cls.t, \"packages\"))\n\n os.chdir(cls.t)\n result = cls.runner.invoke(\n cli,\n [*CLI_LOG_OPTION, \"init\", \"--author\", AUTHOR],\n standalone_mode=False,\n )\n assert result.exit_code == 0\n result = cls.runner.invoke(\n cli,\n [*CLI_LOG_OPTION, \"create\", \"--local\", cls.agent_name],\n standalone_mode=False,\n )\n assert result.exit_code == 0\n os.chdir(cls.agent_name)\n # add connection first time",
"def setup(bot):\n bot.add_cog(MyAnimeList())",
"def launch_devices(self):\n self.data[0], temp = alghoritm.temperature(self.data[0], self.set_thermostat, 0) # get value\n HC35_3S.launch(self.data_path, self.samples_size, temp) # set it via device\n\n self.data[1], humidi = alghoritm.humidity(self.data[1], self.set_humidifier, 0)\n humidifier.launch(self.data_path, self.samples_size, humidi)\n\n self.data[2], moistu = alghoritm.moisture(self.data[2], self.set_sprinklers, 0)\n HUNTER.launch(self.data_path, self.samples_size, moistu)\n\n self.data[3], o2 = alghoritm.o2(self.data[3], self.set_ventilation, 0)\n ventilation.launch_o2(self.data_path, self.samples_size, o2)\n\n self.data[4], co2 = alghoritm.co2(self.data[4], self.set_ventilation, 0)\n ventilation.launch_co2(self.data_path, self.samples_size, co2)",
"def parley(self):\n wait_times = constants.TUTORIAL_WAIT_TIMES\n self.introduce_chat_interface()\n self.wait_for_response(\n message='Please type a greeting message to continue.',\n delay_time=wait_times['chat-interface'],\n )\n self.introduce_knowledgeable_entity()\n self.wait_for_response(\n message=constants.ONBOARDING_ACKNOWLEDGE_UNDERSTOOD,\n delay_time=wait_times['chat-interface'],\n )\n self.introduce_search()\n self.wait_for_response(\n message=constants.ONBOARDING_ACKNOWLEDGE_UNDERSTOOD,\n delay_time=wait_times['knowledge'],\n )\n self.try_search()\n self.wait_for_response_with_search()\n self.introduce_persona()\n self.wait_for_response_with_search()\n self.go_for_start()\n self.episodeDone = True",
"def start_run(self, context: RobotRunnerContext) -> None:\n rospy.init_node(\"robot_runner\", disable_signals=True)\n self.ina219_profiler = INA219ProfilerClient()\n self.cpu_mem_profiler = ResourceProfilerClient()",
"def setup(bot: Bot) -> None:\n bot.add_cog(Latency(bot))",
"def setUp(self):\n # Direct connection used to match the property values\n self.sockobj = socket(AF_INET, SOCK_STREAM)\n self.sockobj.settimeout(socket_timeout)\n # Connect to the selected server\n self.sockobj.connect(server) \n self.pyclient = PySimpleClient()\n self.cmd_num = 0\n for servo_type in app_nr.values():\n self.__dict__[servo_type] = self.pyclient.getComponent(\"MINORSERVO/\" + servo_type)",
"def load_scenario(self):\n logger.info(\"Loading scenario...\")\n for manager in self.config[\"fleets\"]:\n name = manager[\"name\"]\n password = manager[\"password\"] if \"password\" in manager else faker_factory.password()\n fleet_type = manager[\"fleet_type\"]\n strategy = manager.get(\"strategy\")\n icon = manager.get(\"icon\")\n agent = self.create_fleetmanager_agent(name, password, fleet_type=fleet_type, strategy=strategy)\n\n self.set_icon(agent, icon, default=fleet_type)\n\n while len(self.manager_agents) < self.config.num_managers:\n time.sleep(0.1)\n\n for transport in self.config[\"transports\"]:\n name = transport[\"name\"]\n password = transport[\"password\"] if \"password\" in transport else faker_factory.password()\n position = transport[\"position\"]\n fleetmanager = transport[\"fleet\"]\n fleet_type = transport[\"fleet_type\"]\n speed = transport.get(\"speed\")\n trust = transport.get(\"trust\")\n rates = transport.get(\"rates\")\n velocity_factor = transport.get(\"velocity_factor\")\n fuel = transport.get(\"fuel\")\n autonomy = transport.get(\"autonomy\")\n current_autonomy = transport.get(\"current_autonomy\")\n strategy = transport.get(\"strategy\")\n icon = transport.get(\"icon\")\n agent = self.create_transport_agent(name, password, position=position, speed=speed, fleet_type=fleet_type,\n fleetmanager=fleetmanager, strategy=strategy, autonomy=autonomy,\n current_autonomy=current_autonomy, trust=trust, rates=rates, velocity_factor=velocity_factor)\n\n if icon:\n self.set_icon(agent, icon, default=fleet_type)\n\n for customer in self.config[\"customers\"]:\n name = customer[\"name\"]\n password = customer[\"password\"] if \"password\" in customer else faker_factory.password()\n fleet_type = customer[\"fleet_type\"]\n position = customer[\"position\"]\n target = customer[\"destination\"]\n strategy = customer.get(\"strategy\")\n icon = customer.get(\"icon\")\n agent = self.create_customer_agent(name, password, fleet_type, position=position, target=target,\n strategy=strategy)\n\n self.set_icon(agent, icon, default=\"customer\")\n\n for station in self.config[\"stations\"]:\n password = station[\"password\"] if \"password\" in station else faker_factory.password()\n strategy = station.get(\"strategy\")\n icon = station.get(\"icon\")\n agent = self.create_station_agent(station[\"name\"], password, position=station[\"position\"],\n power=station[\"power\"], places=station[\"places\"], strategy=strategy)\n self.set_icon(agent, icon, default=\"electric_station\")",
"def initialize(self):\n\n # --------- BEGIN YOUR CODE ----------\n\n # This is exactly the same as Human.initialize, just copy the code over\n\n # --------- END YOUR CODE ----------\n pass",
"def __init__(self, configs, simulator, wait_time=3):\n self.configs = configs\n self.sim = simulator.sim\n self.gripper = VREP_Gripper()\n self.open()",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n\n # Always start the servers for each test variant\n self.start_agents_once = False\n self.start_servers_once = False\n\n # Whether to skip tearDown\n self.skip_teardown = False",
"def run(): \n learning_rate = 0.42\n discount_rate = 0.15\n initial_q_hat = 4\n \n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent, learning_rate, discount_rate, initial_q_hat) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n print \"Failed trials: \"\n print a.get_failed_trials()\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line",
"def setUp(self):\n bed_patient = PatientsGenerator(0, 1, 0, 'a')\n self.admitgen = AdmissionsGenerator(bed_patient, [-1])",
"def initialize_ai(self):\n\n self.gid, self.genome = constants.genomes_to_run[self.identifier]\n self.genome.fitness = -1\n self.net = neat.nn.FeedForwardNetwork.create(self.genome, constants.conf)\n # self.net = neat.nn.RecurrentNetwork\n # .create(self.genome, constants.conf)",
"def test_init_experiment(self):\n optimizer = \"RandomSearch\"\n name = \"test_init_experiment\"\n param_defs = {\n \"x\": MinMaxNumericParamDef(0, 1),\n \"name\": NominalParamDef([\"A\", \"B\", \"C\"])\n }\n minimization = True\n\n LAss = PrettyLabAssistant()\n LAss.init_experiment(name, optimizer, param_defs, minimization=minimization)\n\n exp_ass = LAss.exp_assistants[name]\n\n assert_equal(exp_ass.optimizer, optimizer)\n assert_is_none(exp_ass.optimizer_arguments, None)\n assert_equal(exp_ass.experiment.minimization_problem, minimization)\n with assert_raises(ValueError):\n LAss.init_experiment(name, optimizer, param_defs, minimization=minimization)",
"def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=False) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0000001, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n\n print 'alpha, gamma:', a.alpha, a.gamma\n print 'penalties:', a.total_penalties\n print 'total rewards:', a.total_rewards",
"def test_create_tang_1(self):\n command_line = (\n self._MENU\n + [self._POOLNAME]\n + self._DEVICES\n + [\"--clevis=tang\", \"--trust-url\", \"--tang-url=http\"]\n )\n TEST_RUNNER(command_line)",
"def _init_agents(self):\n self.agents = [Agent(e=0.1, a=0.1, row=self.row, col=self.col) for i in range(2)]",
"def __init__(self,\n environment_spec: specs.EnvironmentSpec,\n ):\n # Create the actor\n actor = delta_hedge_actor.DeltaHedgeActor(environment_spec.actions)\n learner = fake_learner.FakeLeaner()\n\n super().__init__(\n actor=actor,\n learner=learner,\n min_observations=100,\n observations_per_step=1e9)",
"def initialize(self):\n self.ha_url = self.args.get(\"ha_url\", None)\n self.use_current_brightness = self.args.get(\"use_current_brightness\", False)\n self.condition = self.args.get(\"condition\")\n self.lights = self.args[\"lights\"]\n self.listen_state(self.change_lights_color, self.args[\"media_player\"], attribute = self.args.get(\"photo_attribute\", \"entity_picture\"))",
"def main():\n import optparse\n import sys\n parser = optparse.OptionParser()\n parser.add_option('-c', '--controller', default='NewController',\n help='Controller class to instantiate.')\n parser.add_option('-o', '--outputs', type='int', default=5,\n help='Number of outputs to use on the hardware.')\n options, _arguments = parser.parse_args()\n try:\n Demo(options.controller, options.outputs)\n except controller.ConnectionError:\n sys.exit('ABORT: Could not find a suitable device.')",
"def __init__(self, machine):\n super().__init__(machine)\n\n # Set default platform features. Each platform interface can change\n # these to notify the framework of the specific features it supports.\n self.features['has_drivers'] = True\n self.features['max_pulse'] = 255",
"def __init__(self, machine):\n super().__init__(machine)\n\n # Set default platform features. Each platform interface can change\n # these to notify the framework of the specific features it supports.\n self.features['has_drivers'] = True\n self.features['max_pulse'] = 255",
"def editor_multi_agent_example():\n agent_definitions = [\n AgentDefinition(\"uav0\", agents.UavAgent, [sensors.RGBCamera, sensors.LocationSensor]),\n AgentDefinition(\"uav1\", agents.UavAgent, [sensors.LocationSensor, sensors.VelocitySensor])\n ]\n env = HolodeckEnvironment(agent_definitions, start_world=False)\n\n cmd0 = np.array([0, 0, -2, 10])\n cmd1 = np.array([0, 0, 5, 10])\n\n for i in range(10):\n env.reset()\n env.act(\"uav0\", cmd0)\n env.act(\"uav1\", cmd1)\n for _ in range(1000):\n states = env.tick()",
"def setUp(self):\n # Start the servers and agents\n super().setUp()\n\n # Get the parameters\n self.ior_flags = self.params.get(\n \"ior_flags\", \"/run/ior/*\")\n self.test_file = self.ior_cmd.test_file.value",
"def test_defaults():\n model = torch.nn.Module()\n dataset = torch.utils.data.Dataset()\n dataloader = torch.utils.data.DataLoader(dataset)\n loaders = OrderedDict()\n loaders[\"train\"] = dataloader\n\n test_callbacks = OrderedDict(\n [\n (\"_timer\", TimerCallback),\n (\"_metrics\", MetricManagerCallback),\n (\"_validation\", ValidationManagerCallback),\n (\"_saver\", CheckpointCallback),\n (\"_console\", ConsoleLogger),\n (\"_tensorboard\", TensorboardLogger),\n (\"_exception\", ExceptionCallback),\n ]\n )\n\n exp = SupervisedExperiment(model=model, loaders=loaders)\n _test_callbacks(test_callbacks, exp)",
"def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create learning agent\n # a = e.create_agent(RandomAgent) # create random agent\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.01)\n # reduce update_delay to speed up simulation\n sys.stdout = open(\"./output.txt\", \"w\")\n tic = time()\n sim.run(n_trials=100) # press Esc or close pygame window to quit\n toc = time()\n sys.stdout = sys.__stdout__\n\n print \"Totoal time used: {}.\".format(toc - tic)\n parse(\"./output.txt\")",
"def test_mcts_agent(self):\n logging.info(\"Starting test_mcts_agent\")\n dirname = os.path.dirname(__file__)\n filename = os.path.join(dirname, \"../configs/factory_floor_simple.yaml\")\n parameters = getParameters(filename)\n env = FactoryFloor(parameters)\n obs = env.reset()\n\n mctsAgents = []\n\n randomagent = 'aiagents.single.RandomAgent.RandomAgent'\n for robotId in env.action_space.spaces.keys():\n mctsparams = {'treeAgent':{'class': randomagent, 'id':robotId, 'parameters':{} },\n 'rolloutAgent':{'class': randomagent, 'id':robotId, 'parameters':{} }} \n mctsparams['simulator'] = dict(parameters)\n mctsparams['simulator']['fullname'] = \"aienvs.FactoryFloor.FactoryFloor.FactoryFloor\"\n \n mctsAgents.append(MctsAgent(robotId, env.action_space, env.observation_space , mctsparams))\n\n complexAgent = BasicComplexAgent(mctsAgents, env.action_space, env.observation_space)\n\n episode = Episode(complexAgent, env, obs, render=True)\n episode.run()",
"def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--identifier\", required=True,\n help=\"A short name/identifier for your experiment, e.g. 'ex42b'.\")\n args = parser.parse_args()\n\n train(args)",
"def _initialize_runners_startup(self):\n if self.command_group.is_cmd0_runner():\n self._initialize_runner(self.command_group.cmd0)\n if self.command_group.is_cmd1_runner():\n self._initialize_runner(self.command_group.cmd1)\n if self.command_group.is_cmd2_runner():\n self._initialize_runner(self.command_group.cmd2)",
"def setUp(self):\n self.anime_link = \"https://animepertutti.com/sword-art-online-alicization-war-of-underworld-sub-ita-streaming-download-z\" #noqa",
"def start_with_console():\n print_welcome()\n option = input(\"Choose a number [1/2/3]: \")\n cexc.check_start_exceptions(option)\n if option == \"1\":\n picture = create_white_picture_with_inputs()\n elif option == \"2\":\n picture = load_picture_with_inputs()\n elif option == \"3\":\n picture = create_probability_picture_with_inputs()\n steps = get_steps(input(\"Give a number of steps to do (max=30000): \"))\n print_big_number_announcement(steps)\n Simulator(steps, picture).simulate()",
"def setup_class(cls):\n super(TestCliTransferFetchAINetwork, cls).setup_class()\n cls.agent_name2 = \"agent_\" + \"\".join(\n random.choices(string.ascii_lowercase, k=5) # nosec\n )\n cls.create_agents(cls.agent_name2)\n\n cls.gen_key(cls.agent_name)\n cls.gen_key(cls.agent_name2)",
"def setUp(self):\n self.s = Simulation()\n self.s['Retina']=GeneratorSheet(nominal_density=4.0)\n self.s['V1']= CFSheet(nominal_density=4.0)\n self.s['V2'] = CFSheet(nominal_density=4.0)\n\n self.s.connect('Retina','V1',delay=0.5,connection_type=CFProjection,\n name='RtoV1',learning_fn=CFPLF_Hebbian())\n\n self.s.connect('Retina','V2',delay=0.5,connection_type=CFProjection,\n name='RtoV2',learning_fn=CFPLF_Hebbian())",
"def setUp(self):\n self.delegate = AlwaysHitDelegate(\"\")\n self.environment = BattleEnvironment()",
"def setup(bot: Bot) -> None:\n bot.add_cog(VoiceGate(bot))",
"def pre_launch(mission):\n started_since = mission.ut() - mission.current_step[\"start_ut\"]\n if started_since > 5:\n mission.next()\n elif mission.current_step[\"first_call\"]:\n vessel = mission.conn.space_center.active_vessel\n ap = vessel.auto_pilot\n\n ap.engage()\n ap.target_pitch_and_heading(90, 90)\n vessel.control.throttle = 1\n vessel.control.sas = False\n vessel.control.rcs = mission.parameters.get('use_rcs', False)",
"async def setup(bot):\n await bot.add_cog(People(bot))",
"def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver",
"def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver",
"def setUp(self):\n os.environ[\"PADDLE_TRAINERS_NUM\"] = \"2\"\n os.environ[\n \"PADDLE_PSERVERS_IP_PORT_LIST\"\n ] = \"127.0.0.1:36001,127.0.0.2:36001\"",
"def initialise_sim(self):\n pass",
"def generate(simulator, p, starts, goals, environment, r):\n num_gen_humans = min(len(starts), len(goals))\n print(\"Generating auto humans:\", num_gen_humans)\n from agents.humans.human_configs import HumanConfigs\n for i in range(num_gen_humans):\n start_config = generate_config_from_pos_3(starts[i])\n goal_config = generate_config_from_pos_3(goals[i])\n start_goal_configs = HumanConfigs(start_config, goal_config)\n human_i_name = \"auto_%04d\" % i\n # Generates a random human from the environment\n new_human_i = Human.generate_human_with_configs(\n start_goal_configs,\n generate_appearance=p.render_3D,\n name=human_i_name\n )\n # update renderer and get human traversible if it exists\n if p.render_3D:\n r.add_human(new_human_i)\n environment[\"human_traversible\"] = \\\n np.array(r.get_human_traversible())\n\n # Input human fields into simulator\n simulator.add_agent(new_human_i)",
"def init_process(mech):\n gases[mech] = ct.Solution(mech)\n gases[mech].transport_model = 'Multi'",
"def main():\n if input(\"Mode 0=raw / 1=wrapper: ? [0]\") == \"1\":\n # Wrapped mode\n try:\n number = os.environ[\"ROBOT_ID\"]\n except KeyError:\n number = int(input(\"Enter robot number (1-5):\"))\n robot = PiBot.PiBot(robot_nr=number, directory=\"../\")\n suite = get_suite(robot, number)\n gripper = input(\"Include gripper tests (0=no, 1=yes)? [1]\")\n if gripper != \"0\":\n suite.add(\"Clear gripper space... testing gripper up-down\",\n \"gripper up-down\", robot.set_grabber_height,\n [60, 10], [5, 5], [], [], 1)\n suite.add(\"Clear gripper space... testing gripper open-close\",\n \"gripper open-close\", robot.close_grabber,\n [80, 5], [5, 5], [], [], 1)\n else:\n # Raw mode\n robot = commRaspMain.PiBot()\n while not all(map(lambda fn: fn(), [robot._motors_enable,\n robot._encoders_enable,\n robot._servo_enable])):\n time.sleep(0.05)\n robot._tof_init()\n robot._gyro_start()\n robot._adc_conf(3)\n number = int(input(\"Enter robot number (1-5):\"))\n suite = get_suite(robot, number)\n\n robot._motorL_set(0)\n robot._motorR_set(0)\n\n suite.execute()",
"def swait_setup_random_number(swait, **kw):\n swait.reset()\n swait.scan.put(\"Passive\")\n swait.calc.put(\"RNDM\")\n swait.scan.put(\".1 second\")\n swait.desc.put(\"uniform random numbers\")",
"def maya_start_up():\n import maya.utils as mu\n mu.executeDeferred(\"import mliber;reload(mliber);mliber.show_in_maya()\")",
"def test_Demo(self):\n self._run(self._example_scenarios, \"Demo\")"
] | [
"0.63875884",
"0.61016667",
"0.60508204",
"0.60147184",
"0.5999624",
"0.5965473",
"0.59024185",
"0.587887",
"0.58662325",
"0.5809647",
"0.58030933",
"0.5800339",
"0.5754827",
"0.574139",
"0.5726314",
"0.5693041",
"0.56924486",
"0.5661824",
"0.5648796",
"0.5642869",
"0.5640304",
"0.56317896",
"0.56188244",
"0.5617767",
"0.561329",
"0.55837846",
"0.55784434",
"0.5563329",
"0.5561879",
"0.55580723",
"0.5550675",
"0.5546213",
"0.55422115",
"0.5540608",
"0.5537232",
"0.5533412",
"0.5530924",
"0.5514835",
"0.55099905",
"0.5509989",
"0.5509385",
"0.5506967",
"0.5500754",
"0.55005676",
"0.5496803",
"0.5491379",
"0.5471824",
"0.5468343",
"0.5450747",
"0.544664",
"0.5439867",
"0.54340297",
"0.54304373",
"0.54292995",
"0.54171884",
"0.5415282",
"0.54124653",
"0.53878367",
"0.53864515",
"0.5381608",
"0.5380916",
"0.5371356",
"0.5370087",
"0.53618115",
"0.53581744",
"0.5353703",
"0.534307",
"0.53407735",
"0.53384405",
"0.5335234",
"0.5334325",
"0.5330372",
"0.5323556",
"0.5322977",
"0.5322977",
"0.53112054",
"0.5307562",
"0.5300312",
"0.5290742",
"0.5287836",
"0.5286958",
"0.52771133",
"0.52755904",
"0.5273739",
"0.52717316",
"0.5269291",
"0.5255589",
"0.52404785",
"0.5233554",
"0.5225836",
"0.5224202",
"0.5224202",
"0.5221116",
"0.52200943",
"0.5220085",
"0.5217254",
"0.52085954",
"0.52057254",
"0.5204776",
"0.5200377"
] | 0.5699686 | 15 |
this reset should block until env is ready again after reset | def reset(self):
while True:
packet = self.socket_nanomsg.recv()
payload = packet[self.header_length:]
payload = payload.decode('unicode_escape')
dictionary = json.loads(payload)
restart = dictionary["Restart"] == "True"
if not restart:
break
return self.observation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _soft_reset(self):\n self._reset_specific_envs(self.episodes_done)\n self._update_other_info()",
"def _hard_reset(self):\n self._reset_specific_envs(np.ones_like(self.episodes_done))\n self._update_other_info()",
"def soft_reset():",
"def reset(self, env):\n self._env = env\n return",
"def hard_reset() -> NoReturn:",
"def _reset(self):\n if not self._first_create:\n self._sc2_env.close()\n self._sc2_env = self._create_env()\n self._first_create = False\n return self._sc2_env.reset()",
"def reset_env(self):\n return self.env.reset()",
"def reset(self):\n return self.env.reset()",
"def _reset(self, env_id: np.ndarray) -> None:",
"def reset():\n _runtime.reset()",
"def reset(self):\n self.success = False\n self.i = 0\n if self.monitor:\n self.env = gym.wrappers.Monitor(self.env, \"./mountaincar-monitor\", force=True)\n state = self.env.reset()\n state = self.preprocess_state(state)\n state = np.concatenate([state] * self.action_repeat)\n return state",
"def test_reset():\n dev = _aws_device(wires=2)\n dev._circuit = CIRCUIT\n dev._task = TASK\n\n dev.reset()\n assert dev.circuit is None\n assert dev.task is None",
"def async_reset(self) -> None:",
"def soft_reset() -> None:\n ...",
"def _set_environment(self) -> None:\n last_update_time = time.time()\n while True:\n # The 'math' in the next line keeps the refresh intervals more regular since the update takes time to\n # complete.\n time.sleep(REFRESH_INTERVAL - (time.time() - last_update_time)) # REFRESH_INTERVAL - ELAPSED_TIME\n last_update_time = time.time()\n with self.lock:\n if self.desired_environment:\n self._update_environment(self.desired_environment)",
"def handle_reset(self):\n self.initialise()",
"async def send_reset(self):\n try:\n await self._send_command([PrivateConstants.SYSTEM_RESET])\n except RuntimeError:\n exit(0) #keep this??",
"async def admin_reset(self, ctx: commands.Context):\n await self.config.clear_all()\n await self.initialize_internals()\n await ctx.send('Global team management factory reset complete.')",
"def resetEnv(self):\n obs = self.env.reset()\n self.state = torch.tensor(obs, device=self.device, dtype=torch.float).unsqueeze(0)\n return",
"def reset():",
"def reset():",
"def reset():",
"def reset() -> None:\n Resources.total = dict(jobs=os.cpu_count() or 1)\n Resources.available = Resources.total.copy()\n Resources.default = dict(jobs=1)\n Resources.condition = asyncio.Condition()",
"def test_env_reset_and_step(self):\n create_env = CreateEnv()\n env = create_env.env\n\n # Assert that the total number of agents matches the sum of the 'n_agents'\n # configuration and the number of planners (1 in this case)\n num_planners = 1\n self.assertEqual(\n len(env.all_agents), create_env.env_config[\"n_agents\"] + num_planners\n )\n\n # Assert that the number of agents created in the world\n # matches the configuration specification\n self.assertEqual(len(env.world.agents), create_env.env_config[\"n_agents\"])\n\n # Assert that the planner's index in the world is 'p'\n self.assertEqual(env.world.planner.idx, \"p\")\n\n obs = env.reset()\n\n # Test whether the observation dictionary keys are created as expected\n self.assertEqual(\n sorted(list(obs.keys())),\n [str(i) for i in range(create_env.env_config[\"n_agents\"])] + [\"p\"],\n )\n\n obs, reward, done, info = env.step({})\n\n # Check that the observation, reward and info keys match\n self.assertEqual(obs.keys(), reward.keys())\n self.assertEqual(obs.keys(), info.keys())\n\n # Assert that __all__ is in done\n assert \"__all__\" in done",
"def reset(self):\n \n self.env.reset()\n obs, _, done, _ = self.env.step(1)\n if done: \n self.env.reset()\n obs, _, done, _ = self.env.step(2)\n if done: \n self.env.reset()\n \n return obs",
"def _reset(self): # We are using a virtual function defined in the gym infrastructure.\n self.gazebo.unpauseSim()\n \"\"\"\n why we need to unpauseSim because resetting controllers and for checking the sensors, we need the simulation\n to be running because otherwise we don't have any sensory data and we don't have access to the controller reset\n functions services they won't work and tell you to hit play. => it is very important.\n \"\"\"\n self.controllers_object.reset_controllers()\n self.check_all_sensors_ready()\n self.set_init_pose()\n #initialized robot\n self.gazebo.pauseSim()\n self.gazebo.resetSim()\n self.gazebo.unpauseSim()\n self.controllers_object.reset_controllers()\n self.check_all_sensors_ready()\n self.gazebo.pauseSim()\n self.init_env_variables()\n obs = self._get_obs()\n simplified_obs = self.convert_obs_to_state(obs)\n\n return simplified_obs",
"def reset():\r\n pass",
"def auto_setup(self):\n if self.mot_type == \"xps8p\":\n return\n if self.get_par(\"err_sevr\") == 3:\n print \"Reinitializing motor {}...\".format(self.name)\n self.reinit()\n ok = self.wait_par(\"err_sevr\", 3, match_value=False, timeout=20)\n if ok:\n print \"Successfully reinitialized {}.\".format(self.name)\n time.sleep(0.5)\n else:\n print \"Reinitializing {} timed out. Aborting auto_setup.\".format(self.name)\n return\n\n for i in range(3):\n for clear, name in ((self.clear_pu, \"powerup\"),\n (self.clear_stall, \"stall flag\"),\n (self.clear_error, \"error flag\")):\n clear(check=True, wait=False)\n\n ok = []\n for bit, mask in ((RA_POWERUP, 1), (RA_STALL, 1), (RA_ERR, RA_ERR_MASK)):\n ok.append(self._wait_msta_bit(bit, 0, mask, timeout=10))\n if not all(ok):\n print \"Issues with clearing flags for {}\".format(self.name)\n\n try: # Not every environment has pmgr access\n self.pmgr.apply_config(dumb_config=self.name)\n except:\n pass",
"def _doReset(self):\n self._cmdReset()",
"def reset():\n pass",
"def reset():\n pass",
"def __reset_variables(self):\r\n self.__running = True",
"def reset(self):\n self.stuck = False",
"def on_reset_after_execution(self):\n pass",
"def reset(self):\n self.state = self.process_state(self.env.reset())\n return self.state",
"def reset(self, blocking=True):\n ret = super(ReacherEnv, self).reset(blocking=blocking)\n self._episode_steps = 0\n return ret",
"def _reset(self):",
"def _reset(self) -> None:",
"def _reset(self) -> None:",
"def reset(self, **kwargs):\n return self.env.reset(**kwargs)",
"def reset(self) -> None:\n\n self.host.reset()",
"def _graceful_restart(self, wait):\n\n self._sut.shutdown(True)\n self._sut.start()\n\n if wait:\n sleep(BespokeGlobals.VM_BOOT_WAIT)",
"def _handle_reset(self):\n # reset own state\n self.grbl_version = None\n self.in_check_mode = False\n self.line_active = False\n # wait for init\n self._wait_for_grbl_init()",
"def sendEnvironmentReset(self, type=0):\r\n print \"SEND: EnvironmentReset\"\r\n res = self.sender.sendEnvironmentReset(type)\r\n time.sleep(self.msgWaitingTime)\r\n return res",
"def _verify_agent_reset(self):\n if self._ia_client is None:\n return\n\n state = self._ia_client.get_agent_state()\n if state != ResourceAgentState.UNINITIALIZED:\n cmd = AgentCommand(command=ResourceAgentEvent.RESET)\n retval = self._ia_client.execute_agent(cmd)",
"def reset():\n from . import core\n core.http.reset()",
"def _reset(self):\n pass",
"def reset() -> None:\n ...",
"def reset_mock():\n if not var_cache['local'].reset_mock_interface():\n raise AssertionError('reset mock server fail')",
"def test_reset_reset(self):\n check_attr(self.o, 'reset')\n self.o.reset()\n self.subtest_someAgents(self.o, 2, 10)\n _0 = self.patch_agent_reset(self.o)\n # Démarrage des patches et stockage des mocks\n _1 = [_.start() for _ in _0 ]\n self.assertEqual(sum([_.call_count for _ in _1]), 0)\n self.o.reset()\n self.assertEqual(sum([_.call_count for _ in _1]), len(_0), \"individual calls expected\")\n # Fin du patching\n # for _ in _0 : _.stop()\n hum.patch.stopall()",
"def on_reset(self):\n pass",
"def _reset_seeds(self) -> None:\n self._seeds = [None for _ in range(self.num_envs)]",
"def __mode_reset(self):\n\t\tfor key,val in self.ms_all.iteritems():\n\t\t\tval.reset_restart()",
"def reset(self):\r\n _debug('api.reset()')\r\n self.write('*RST')\r\n self.query('*IDN?') # Pauses operation until fully reset?\r",
"def reset(self):\r\n _debug('api.reset()')\r\n self.write('*RST')\r\n self.query('*IDN?') # Pauses operation until fully reset?\r",
"def reset(self):\r\n _debug('api.reset()')\r\n self.write('*RST')\r\n self.query('*IDN?') # Pauses operation until fully reset?\r",
"def reset(self):\r\n _debug('api.reset()')\r\n self.write('*RST')\r\n self.query('*IDN?') # Pauses operation until fully reset?\r",
"def _reset(self):\r\n self._state = self.INITIALIZING\r\n self._option_values = options.Values()\r\n self._argv = []",
"def reset(self):\r\n _debug('simq03b_api.reset')\r\n self.write('*RST')\r\n self.query('*IDN?') # Pauses operation until fully reset?\r",
"def env_init(self, env_info={}):\n self.dealer_sticks = env_info['dealer_sticks']\n self.random = np.random.RandomState(env_info['seed'])\n self.current_state = None",
"def reset(self):\n error_estop = \"\"\"\\\nE-Stop is ASSERTED. Disengage E-Stop and then reset the robot.\n\"\"\"\n error_nonfatal = \"\"\"Non-fatal Robot Error on reset.\nRobot reset cleared stopped state and robot can be enabled, but a non-fatal\nerror persists. Check diagnostics or rethink.log for more info.\n\"\"\"\n error_env = \"\"\"Failed to reset robot.\nPlease verify that the ROS_IP or ROS_HOSTNAME environment variables are set\nand resolvable. For more information please visit:\nhttp://sdk.rethinkrobotics.com/wiki/RSDK_Shell#Initialize\n\"\"\"\n is_reset = lambda: (self._state.enabled == False and\n self._state.stopped == False and\n self._state.error == False and\n self._state.estop_button == 0 and\n self._state.estop_source == 0)\n pub = rospy.Publisher('robot/set_super_reset', Empty, queue_size=10)\n\n if (self._state.stopped and\n self._state.estop_button == AssemblyState.ESTOP_BUTTON_PRESSED):\n rospy.logfatal(error_estop)\n raise IOError(errno.EREMOTEIO, \"Failed to Reset: E-Stop Engaged\")\n\n rospy.loginfo(\"Resetting robot...\")\n try:\n baxter_dataflow.wait_for(\n test=is_reset,\n timeout=3.0,\n timeout_msg=error_env,\n body=pub.publish\n )\n except OSError as e:\n if e.errno == errno.ETIMEDOUT:\n if self._state.error == True and self._state.stopped == False:\n rospy.logwarn(error_nonfatal)\n return False\n raise",
"async def send_reset(self):\n try:\n await self._send_command([PrivateConstants.SYSTEM_RESET])\n except RuntimeError:\n exit(0)",
"def reset(self):\n \n pass",
"def trial_reset():\n commands = [\n 'rm -f temp/*',\n ]\n\n for cmd in commands:\n p = Popen(cmd, shell=True)\n p.wait()",
"def reset(self):\n self.iterator = 0\n if self.reset_jnts is True:\n # pause simulation\n while not self._physics_pauser.wait_for_service(timeout_sec=1.0):\n self.node.get_logger().info('/pause_physics service not available, waiting again...')\n pause_future = self._physics_pauser.call_async(Empty.Request())\n print(\"Pausing physics\")\n rclpy.spin_until_future_complete(self.node, pause_future)\n\n # reset controllers\n while not self._robot_resetter.wait_for_service(timeout_sec=1.0):\n self.node.get_logger().info('/lobot_arm/reset service not available, waiting again...')\n reset_robot_future = self._robot_resetter.call_async(Empty.Request())\n print(\"Resetting controller initial positions\")\n rclpy.spin_until_future_complete(self.node, reset_robot_future)\n\n # reset simulation\n while not self._reset_sim.wait_for_service(timeout_sec=1.0):\n self.node.get_logger().info('/reset_simulation service not available, waiting again...')\n reset_future = self._reset_sim.call_async(Empty.Request())\n print(\"Resetting simulation\")\n rclpy.spin_until_future_complete(self.node, reset_future)\n\n # unpause simulation\n while not self._physics_unpauser.wait_for_service(timeout_sec=1.0):\n self.node.get_logger().info('/unpause_physics service not available, waiting again...')\n unpause_future = self._physics_unpauser.call_async(Empty.Request())\n rclpy.spin_until_future_complete(self.node, unpause_future)\n print(\"Unpausing simulation\")",
"def reset():\n return True",
"def _restart(self):\n pass",
"def finished_restarting():\n flags.restarting = False\n group_spawn(qtile.current_group)\n qtile.cmd_spawn(\"nitrogen --restore\")",
"def tearDown(self):\n self.api.reset()",
"def tearDown(self):\n self.api.reset()",
"def tearDown(self):\n self.api.reset()",
"def tearDown(self):\n self.api.reset()",
"def restart(self):\n\t\treturn self.reset().start()",
"def reset():\n Vessel.reset_instances()",
"def test_01_factory_reset(self):\n time.sleep(_LOG_CATCH_UP_DELAY)\n start_time = datetime.datetime.now()\n\n self.device.factory_reset()\n self.assertTrue(\n self.device.connected,\n f\"{self.device.name} is offline after factory_reset() execution \"\n \"finished. factory_reset should block until the device comes back \"\n \"online and becomes responsive.\")\n self._verify_no_unexpected_reboots(start_time)",
"def reset(self) -> None:\n # See section 7.2.2 of the datasheet for reset description.\n self._reset.value = True\n time.sleep(0.0001) # 100 us\n self._reset.value = False\n time.sleep(0.005) # 5 ms",
"def onReset(self):\n # stop timer\n self.TIMER_ALIVE_AGT.stop()\n \n # cleanup remote agent\n self.resetAgent()",
"def reset(self):\n self._reset_next_step = False\n self.step_count = 0\n \n self._state = self.state_initializer()\n self._meta_state = self._meta_state_initializer()\n self.task.reset(self._state, self._meta_state)\n self.physics.reset(self._state)\n self.action_space.reset(self._state)\n for rule in self.game_rules:\n rule.reset(self._state, self._meta_state)\n rule.step(self._state, self._meta_state)\n \n return dm_env.restart(self.observation())",
"def _reset(self, reason: str=None):\n pass",
"def reset(self):\n if self.reset_tracker >= self.reset_interval:\n instance = self.sampling_function()\n self.env.use_next_instance(instance=instance)\n return self.env.reset()",
"def reset(self):\n self.reset_dev_via_serial(self.forced_reset_timeout)",
"def reset(self):\r\r\n self.read(\"*cls\")\r\r\n self.waitForCompletion()\r\r\n self.read(\"*RST\") # Reset and query\r\r\n self.dev.write(\"*cls\")\r\r\n while self.read(\"*OPC?\") != \"1\": time.sleep(1) # Wait until completion\r\r",
"def reset(self):\n while (True):\n index = self.expect([pexpect.TIMEOUT, SHELL_PROMPT], timeout=1)\n if index == 0:\n break",
"async def reset(self):\n await self.set_param(\"ContinuousExposures\", 0)\n await self.set_param(\"Exposures\", 0)\n cmd = await self.send_command(\"RESETTIMING\", timeout=1)\n if not cmd.succeeded():\n self.status = ControllerStatus.ERROR\n raise ArchonError(f\"Failed sending RESETTIMING ({cmd.status.name})\")\n\n # TODO: here we should do some more checks before we say it's IDLE.\n self.status = ControllerStatus.IDLE",
"def reset(self):\n ...",
"def reset(self):\n ...",
"def exec_reset():\n # {{{1\n def python_callback(event):\n print('__RESET__')\n update(task='test:main:reset', timeframe='5m', axis_reset=True, active=False)\n return python_callback",
"def reset(self):\n # The camera will give no response to this command\n self._serial_io('\\x55\\x99\\x66\\x11', None)\n while True:\n try:\n self.system_state = 0x11\n if self.system_state == 0x11:\n break\n except CygnetExc:\n time.sleep(.2)\n while True:\n self.system_state = 0x12\n time.sleep(.2)\n if self.system_state == 0x16:\n break",
"def reset(self):\n GPIO.output(self.reset_pin, GPIO.LOW)\n time.sleep(0.1)\n GPIO.output(self.reset_pin, GPIO.HIGH)\n time.sleep(0.1)\n\n if self.inky_version == 2:\n self._send_command(_V2_RESET)\n\n self._busy_wait()",
"def reset():\n\n local(\"rm -rf ./build\")\n local(\"mkdir ./build\")",
"def reset_env(\n self, key: chex.PRNGKey, params: EnvParams\n ) -> Tuple[chex.Array, EnvState]:\n # Always start with no stock\n # # By defauly, we start on a random weekday\n # Otherwise, with fixed burn-in, would always\n # count return from same weekday\n weekday = jax.lax.cond(\n params.initial_weekday == -1,\n lambda _: jax.random.randint(key, (), 0, 7, dtype=jnp_int),\n lambda _: params.initial_weekday.astype(jnp_int),\n None,\n )\n\n state = EnvState(\n weekday=weekday,\n stock=self.initial_stock,\n step=0,\n )\n return self.get_obs(state), state",
"def reset(self):\n self.ai.reset()",
"def _doResetMemory(self):\n self._cmdClearMemory()\n time.sleep(1)\n self._cmdResetParameters()\n time.sleep(1)",
"def test_reset(self):\n ran = []\n def foo():\n ran.append(None)\n\n c = task.Clock()\n lc = TestableLoopingCall(c, foo)\n lc.start(2, now=False)\n c.advance(1)\n lc.reset()\n c.advance(1)\n self.assertEqual(ran, [])\n c.advance(1)\n self.assertEqual(ran, [None])",
"def done(self, env):\n del env\n return False",
"def reset(self, sync=True):\n self.vmomi_object.ResetVM_Task()\n if sync: self._wait_for_power_on()",
"def storage_reset(self):\n daos_srv_bin = os.path.join(self.daosbinpath, \"daos_server\")\n cmd = \"{} storage prepare -n --reset -f\".format(daos_srv_bin)\n result = pcmd(self._hosts, cmd)\n if len(result) > 1 or 0 not in result:\n raise ServerFailed(\"Error resetting NVMe storage\")",
"def reset(self):\n self.wait_until_idle()\n self.__interface.write_pin(self.__interface.RST_PIN, RPi.GPIO.LOW)\n time.sleep(self.__interface.WT_PIN_TOGGLE)\n self.__interface.write_pin(self.__interface.RST_PIN, RPi.GPIO.HIGH)\n time.sleep(self.__interface.WT_PIN_TOGGLE)\n\n self.__sleeping = False",
"def restart(self):",
"def reset():\n teardown_db()\n build()",
"def reset(self, **kwargs):\n if self._backend_agent:\n self._backend_agent._on_gym_reset_begin(self, **kwargs)\n\n result = self.env.reset(**kwargs)\n if self.steps_done_in_episode > 0 and not self.is_episode_done:\n self.episodes_done += 1\n self.total.episodes_done_inc()\n self.is_episode_done = False\n self.steps_done_in_episode = 0\n\n if self._backend_agent:\n self._backend_agent._on_gym_reset_end(self, result, **kwargs)\n return result"
] | [
"0.7107423",
"0.70898026",
"0.69635344",
"0.683081",
"0.67939526",
"0.676074",
"0.6658018",
"0.6602491",
"0.6600713",
"0.6585621",
"0.65487516",
"0.65477717",
"0.6531425",
"0.65132505",
"0.6499355",
"0.6410681",
"0.6381121",
"0.6369087",
"0.6363661",
"0.6357603",
"0.6357603",
"0.6357603",
"0.63530326",
"0.63452345",
"0.63331777",
"0.6325028",
"0.628857",
"0.6271872",
"0.6265967",
"0.6263587",
"0.6263587",
"0.62581414",
"0.62421817",
"0.6223728",
"0.6216575",
"0.6212581",
"0.620005",
"0.61893404",
"0.61893404",
"0.6171727",
"0.6164988",
"0.6152601",
"0.61375076",
"0.6136978",
"0.61175203",
"0.61073464",
"0.61073035",
"0.6106893",
"0.6106024",
"0.6098116",
"0.60889906",
"0.60887843",
"0.60751283",
"0.60652906",
"0.60652906",
"0.60652906",
"0.60652906",
"0.6053664",
"0.60278386",
"0.60066515",
"0.59924865",
"0.59906924",
"0.5988108",
"0.5975641",
"0.5971487",
"0.59520847",
"0.5941933",
"0.5937505",
"0.5927755",
"0.5927755",
"0.5927755",
"0.5927755",
"0.592009",
"0.59148103",
"0.5902146",
"0.5895337",
"0.5895122",
"0.58918417",
"0.5888152",
"0.58880824",
"0.58864737",
"0.5880879",
"0.5875095",
"0.58710736",
"0.5866336",
"0.5866336",
"0.58611596",
"0.5847343",
"0.5844642",
"0.5828315",
"0.58241683",
"0.5823835",
"0.5818843",
"0.5812888",
"0.5807824",
"0.5807156",
"0.58051866",
"0.5797942",
"0.579579",
"0.5795296",
"0.5793046"
] | 0.0 | -1 |
This method is called by pika if the connection to RabbitMQ can't be established. | def on_connection_open_error(self, _unused_connection, err):
# LOGGER.error('Connection open failed: %s', err)
self.reconnect() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self):\n\n if settings.DEBUG:\n parameters = pika.ConnectionParameters(self._host)\n else:\n credentials = pika.PlainCredentials(\n username=settings.RABBITMQ_USERNAME,\n password=settings.RABBITMQ_PASSWORD\n )\n parameters = pika.ConnectionParameters(\n host=self._host,\n port=self._port,\n virtual_host=self._vhost,\n credentials=credentials\n )\n\n try:\n msg = \"Connection established successfully with rabbitmq server !!!\"\n self.connection = pika.BlockingConnection(parameters)\n self.channel = self.connection.channel()\n print(msg)\n logging.info(msg)\n except Exception as e:\n raise RabbitmqConnectionError(str(e))",
"def _connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.exchange_declare(exchange=self.exch, type=\"topic\", durable=True, auto_delete=False,)\n self.log(\"%conn-open\", \"info\", \"Connection to AMQP broker opened\")\n except Exception,e:\n self.log(\"%conn-error\", \"error\", \"Error whilst connecting to AMQP broker (%s)\" % e)\n self.closeConn()",
"def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True",
"def connect(self):\r\n try:\r\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(self.ip))\r\n print (\"connected!\")\r\n except Exception as error:\r\n print (\"connect() - error - {}\".format(error))",
"def _connect(self) -> BlockingChannel:\n for _ in range(self.retry):\n getLogger().info(\"Trying to connect to RabbitMQ ...\")\n try:\n connection = pika.BlockingConnection(self.connection_params)\n channel = connection.channel()\n channel.exchange_declare(self.exchange_name, 'direct', durable=True)\n channel.basic_qos(prefetch_count=self.prefetch)\n channel.queue_declare(\n self.queue_name, durable=True\n )\n channel.queue_bind(self.queue_name, self.exchange_name, self.binding_key)\n except (AMQPConnectionError, ChannelError) as e:\n getLogger().error(f\"Connection to RabbitMQ failed {e}\")\n sleep(self.retry_interval)\n else:\n getLogger().info(\"Connected to RabbitMQ\")\n return channel\n else:\n getLogger().error(f\"Giving up connecting to RabbitMQ: {self.connection_params}\")\n raise exceptions.ConnectionFailed",
"def connect(self):\n if self._connection is not None:\n self.logger.debug('Using allready existing connection [{}]'.format(\n self._connection))\n # Create a new communication channel\n self._channel = self._connection.channel()\n return True\n try:\n # Create a new connection\n self.logger.debug(\n 'Connecting to AMQP broker @ [{}:{}, vhost={}]...'.format(\n self.connection_params.host,\n self.connection_params.port,\n self.connection_params.vhost))\n self.logger.debug('Connection parameters:')\n self.logger.debug(self.connection_params)\n self._connection = AMQPConnection(self.connection_params)\n # Create a new communication channel\n self._channel = self._connection.channel()\n self.logger.info(\n 'Connected to AMQP broker @ [{}:{}, vhost={}]'.format(\n self.connection_params.host,\n self.connection_params.port,\n self.connection_params.vhost))\n except pika.exceptions.ConnectionClosed:\n self.logger.debug('Connection timed out. Reconnecting...')\n return self.connect()\n except pika.exceptions.AMQPConnectionError:\n self.logger.debug('Connection error. Reconnecting...')\n return self.connect()\n except Exception as exc:\n self.logger.exception('')\n raise (exc)\n return self._channel",
"def __init__(self):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n self.channel = self.connection.channel()",
"def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)",
"def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel",
"def run(self):\n try:\n\n self._connection = self.connect()\n self._connection.ioloop.start()\n except (KeyboardInterrupt, SystemExit):\n self.stop()\n except Exception as e:\n logger.warn(\"Exception: %s\", str(e))\n logger.warn(\"Exception caught on rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self.internal_error_queue.put(self.consumer_id)",
"def connect(self):\n logger.info(\"[{}] Connecting to exchange {}\".format(self.bot_id, self.exchange))\n creds = pika.PlainCredentials(self.rabbit_user, self.rabbit_pw)\n return pika.SelectConnection(pika.ConnectionParameters(host=self.rabbit_host,\n port=self.rabbit_port,\n virtual_host='/',\n credentials=creds,\n socket_timeout=1,\n retry_delay=5 # 5 seconds\n ),\n self.on_connection_open,\n stop_ioloop_on_close=False)",
"def connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\n self.chan.exchange_declare(exchange=self.EXCH, type=\"topic\", durable=True, auto_delete=False,)\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\"ctag\")\n except:\n self.closeConn()",
"def _setup_connection(self, parameters):\n logger.info('Connecting to %s', parameters)\n return pika.BlockingConnection(parameters = parameters)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def create_connection(self):\n if self.conn:\n raise Exception(\"Connection already open\")\n cfg = self.config[self.MODULE_NAME]['amqp']['connection']\n log.debug(str(cfg))\n self.conn = pika.AsyncoreConnection(pika.ConnectionParameters(\n credentials = pika.PlainCredentials(cfg['login'],cfg['password']), \n heartbeat=cfg['heartbeat'],\n virtual_host=cfg['vhost'],\n port=cfg['port'],\n host=cfg['host']))\n self.channel = self.conn.channel()\n\n self._setup_tubes()",
"def init_connect_mq(self):\n try:\n mq_username = Configs.mq_username\n mq_pwd = Configs.mq_pwd\n mq_ip_addr = Configs.mq_ip_addr\n mq_port_num = Configs.mq_port_num\n mq_vhost = Configs.mq_vhost\n\n mq_credentials = pika.PlainCredentials(mq_username, mq_pwd)\n mq_connection = pika.BlockingConnection(\n pika.ConnectionParameters(host=mq_ip_addr, port=mq_port_num, virtual_host=mq_vhost,\n credentials=mq_credentials))\n # connect to mq channel\n self.mq_channel = mq_connection.channel()\n self.mq_channel.exchange_declare(exchange=Configs.mq_exchange_name, exchange_type='topic', durable='true')\n # self.mq_channel.queue_declare(queue='test', durable=False, arguments={'x-message-ttl': 10000})\n self.mq_conn_flag = True\n print(\" ************** MQ Connect Success ************** \")\n except Exception as e:\n print(e)",
"def make_connection(self):\n\n credentials = pika.PlainCredentials(self._username, self._password)\n parameters = pika.ConnectionParameters(self._host, self._port, self._vhost, credentials, socket_timeout=300)\n self._connection = pika.BlockingConnection(parameters)\n print(\"Connected Successfully...\")",
"def connect(self):\n\t\tself.printed_sub = False\n\t\tself.client.connect(BROKER)\n\t\tself.client.loop_forever()",
"def check_connection(self):\n pass",
"def test_broken_connection(\n mocker, create_result_queue_info, conn_url, rabbitmq_conn_url\n):\n vhost_path = rabbitmq_conn_url.rsplit(\":\", maxsplit=1)[-1].lstrip(\"0123456789\")\n conn_url += vhost_path\n pika_params = pika.URLParameters(conn_url)\n try:\n pika.BlockingConnection(pika_params)\n\n # matches known-good credentials, so this won't be an effective test\n # (parameter). This might happen on the default CI infrastructure for\n # amqp://localhost:5672, which Pika politely translates to\n # amqp://guest:guest@localhost:5672.\n # See: https://pika.readthedocs.io/en/stable/examples/using_urlparameters.html\n return\n except pika.exceptions.AMQPConnectionError:\n # expected path for a valid test\n pass\n\n q_info = create_result_queue_info(connection_url=conn_url)\n\n rp = ResultPublisher(queue_info=q_info)\n mock_cb = mocker.patch.object(rp, \"_on_open_failed\")\n try:\n rp.start()\n try_assert(lambda: mock_cb.called)\n finally:\n rp.stop()",
"def connect(self):\n self._connect()\n if self.conn is not None:\n try:\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\n except:\n self.closeConn()",
"def handle_mq_publication(self, mq_config: dict = None, data: dict = None) -> None:\n if not self.application.settings.get(\"pika_client\"):\n logging.info(\"no pika_client found\")\n return\n if not mq_config:\n return\n if not mq_config.get(\"enabled\"):\n return\n if not mq_config.get(\"methods\").get(self.request.method):\n return\n try:\n default_version = \"v1\"\n default_rkey = f\"k.{default_version}.{self.tenant}.{self.endpoint}\"\n ex = mq_config.get(\"exchange\")\n ver = (\n default_version\n if not mq_config.get(\"version\")\n else mq_config.get(\"version\")\n )\n rkey = (\n default_rkey\n if not mq_config.get(\"routing_key\")\n else mq_config.get(\"routing_key\")\n )\n uri = (\n self.request.headers.get(\"Original-Uri\")\n if self.request.headers.get(\"Original-Uri\")\n else self.request.uri\n )\n # try hard to be able to publish, if e.g. the broker restarted\n connection_open = self.application.settings.get(\n \"pika_client\"\n ).connection.is_open\n re_open_connection = False\n if connection_open:\n channel_open = self.application.settings.get(\n \"pika_client\"\n ).channel.is_open\n if not channel_open:\n logging.info(\"RabbitMQ channel is closed\")\n re_open_connection = True\n if not connection_open:\n logging.info(\"RabbitMQ connection is closed\")\n re_open_connection = True\n if re_open_connection:\n logging.info(\"trying to re-open RabbitMQ connection\")\n self.application.settings.get(\"pika_client\").connect()\n self.pika_client = self.application.settings.get(\"pika_client\")\n self.pika_client.publish_message(\n exchange=ex,\n routing_key=rkey,\n method=self.request.method,\n uri=uri,\n version=ver,\n data=data,\n )\n if not options.rabbitmq_cache.empty(): # if the broker was down\n try:\n logging.info(\n f\"publishing {options.rabbitmq_cache.qsize()} messages from cache\"\n )\n message = options.rabbitmq_cache.get_nowait()\n while message:\n self.pika_client.publish_message(\n exchange=message.get(\"ex\"),\n routing_key=message.get(\"rkey\"),\n method=message.get(\"method\"),\n uri=message.get(\"uri\"),\n version=message.get(\"version\"),\n data=message.get(\"data\"),\n timestamp=message.get(\"timestamp\"),\n )\n message = options.rabbitmq_cache.get_nowait()\n except queue.Empty:\n pass # nothing left\n except (Exception, UnboundLocalError) as e:\n summary = f\"exchange: {ex}, routing_key: {rkey}, version: {ver}\"\n msg = f\"problem publishing message, {summary}\"\n logging.error(msg)\n logging.error(e)\n options.rabbitmq_cache.put(\n {\n \"ex\": ex,\n \"rkey\": rkey,\n \"method\": self.request.method,\n \"uri\": uri,\n \"version\": ver,\n \"data\": data,\n \"timestamp\": int(time.time()),\n }\n )",
"def _connect_async(self):\n self._pgconn = libpq.PQconnectStart(ascii_to_bytes(self.dsn))\n if not self._pgconn:\n raise exceptions.OperationalError('PQconnectStart() failed')\n elif libpq.PQstatus(self._pgconn) == libpq.CONNECTION_BAD:\n raise self._create_exception()\n\n libpq.PQsetNoticeProcessor(\n self._pgconn, self._notice_callback, ffi.NULL)",
"async def _connect(self):\n self._connection = await connect_robust(self._connection_string)\n self._channel = await self._connection.channel()\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})",
"def _connect(self):\n #print(\"Connecting...\")\n self._connection = reactor.connectTCP(self.host, self.port, self.factory) #@UndefinedVariable",
"def _amqp_bind(self):\n if self.amqp_connection is not None:\n try:\n self.amqp_connection.close()\n except:\n pass\n\n self.amqp_connection = pika.BlockingConnection(\n pika.ConnectionParameters(\n host=self.amqp_server\n )\n )\n\n # listening channel for ermrest change notifications\n self.notice_channel = self.amqp_connection.channel()\n try:\n # newer pika API\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\n except TypeError as te:\n # try older API as fallback\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\n sys.stderr.write('ERMrest change-notice channel open.\\n')",
"def connect(self):\n self.log.info(u\"==> Connecting to MQTT broquer ...\")\n try:\n self.MQTTClient.connect(self.mqtthost, int(self.mqttport), 60)\n self.log.info(u\"==> Connected on MQTT broquer\")\n self.MQTTClient.loop_start() # This will automatically reconnect if connection is lost.\n except:\n error = u\"### Error while connecting to MQTT broquer : %s \" % str(traceback.format_exc())\n raise MQTTException(error)",
"def connectionMade(self):\n AMQClient.connectionMade(self)\n\n def eb(failure):\n log.err(failure)\n self.transport.loseConnection()\n\n d = self.gotConnection()\n d.addErrback(eb)",
"def _check_connection(self):\n if \"_connection\" not in self.__dict__:\n message = \"use connect method before doing operation on this database\"\n raise Exception(message)",
"def configure_rabbit (ec2_conn,base_name,params ):\n print \"configuring rabbitmq exchanges and Queues\"\n app_type = 'RABBITMQ'\n \n logging.basicConfig()\n \n ## Allow security from build server to rabbitmq\n rabbit_lb_sec_grp_name = get_lb_secgrp_name( base_name, app_type )\n rabbit_lb_sec_grp = find_secgrp(ec2_conn, rabbit_lb_sec_grp_name)\n \n try :\n rabbit_lb_sec_grp.authorize( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr )\n except :\n print \"rule exists aready\" \n \n \n rabbitmq_host = params.get( 'host' )\n rabbitmq_port = params.get( 'port' )\n rabbitmq_username = params.get( 'user-name' )\n rabbitmq_password = params.get( 'password' )\n exchanges = params.get( 'exchanges' )\n \n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\n amqp_url = str(amqp_url)\n parameters = pika.URLParameters(amqp_url)\n connection = pika.BlockingConnection(parameters)\n channel = connection.channel()\n \n \n \n for exchnage in exchanges :\n exchange_name = exchnage.get(\"name\")\n exchange_type = exchnage.get(\"type\")\n queue_name = exchnage.get(\"queue\")\n routings = exchnage.get(\"bindings\")\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable=True )\n channel.queue_declare(queue=queue_name,\n durable=True)\n for routing in routings :\n channel.queue_bind(queue=queue_name, exchange=exchange_name, routing_key=routing)\n print \"binging exchnage: \" +exchange_name+\", to a queue:\"+queue_name+\" ,with routing key:\"+routing\n \n ## close connection at the end \n connection.close()\n \n ## At the end revoke the build server rule \n try :\n rabbit_lb_sec_grp.revoke( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr)\n \n except :\n print \"exception removing rule\"",
"def connect(self):\n self.logger.info(\"Connecting to AMQP broker @ [{}:{}] ...\".format(\n self._host, self._port))\n connection = pika.SelectConnection(\n pika.URLParameters(host=self.host, port=self.port),\n on_open_callback=self.on_connection_open,\n on_open_error_callback=self.on_connection_open_error,\n on_close_callback=self.on_connection_closed,\n stop_ioloop_on_close=False)\n self._connection = connection\n return connection",
"def __init__(self, amqp_url):\n self._connection = None\n self._channel = None\n self._url = amqp_url",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def _on_connection_error(self, exception):\n print(\"connection failed: {}\".format(exception))\n time.sleep(1)\n self.connect()",
"def check_connection(self):\n return False",
"def _connect(self):\n for attempt in range(1, self.num_attempts + 1):\n try:\n conn = self.rabbitmq_context.get_connection(self.timeout)\n chan = conn.channel()\n return (conn, chan)\n except AMQPError as ex:\n if attempt >= self.num_attempts:\n if self.ignore_connection_failure:\n raise ex\n else:\n self.fail(\n \"Could not access RabbitMQ host {0} because {1}\"\n .format(self.rabbitmq_context.host, repr(ex)))\n else:\n time.sleep(self.seconds_between_attempts)",
"def _connect(self):\n try: \n self.r = redis.StrictRedis(host=self.host, port=self.port, db=self.db)\n except:\n raise",
"def connectionMade(self):\n protocol.Protocol.connectionMade(self)\n self.port = self.transport.getHost().port\n #Start the inactivity timer the connection is dropped if we receive no data\n self.activateInactivityTimer()\n self.sessionState = SMPPSessionStates.OPEN\n self.log.warning(\"SMPP connection established from %s to port %s\", self.transport.getPeer().host, self.port)",
"def _get_rabbit_connection_info(queue_key):\n\n\tif consul_server == \"127.0.0.1\":\n\t\treturn \"Consul server is set to 127.0.0.1\", None\n\tlook_for_service_name = \"docker-rabbitmq-5672\"\n\tfound_service = config_manager.discover_service(consul_server, look_for_service_name)\n\tif found_service.__class__.__name__ not in (\"list\", \"tuple\"):\n\t\treturn \"Service class not in expected format\", None\n\tif len(found_service) == 0:\n\t\treturn \"No services found for `%s`\" % look_for_service_name, None\n\n\trabbitmq_host = found_service[0][\"Address\"]\n\trabbitmq_port = int(found_service[0][\"ServicePort\"])\n\n\tconfig_arr = config_manager.get_config(consul_server, [queue_key, \"rabbitmq_user\", \"rabbitmq_pass\"])\n\trabbit_username = config_arr[0][\"rabbitmq_user\"]\n\trabbit_password = config_arr[0][\"rabbitmq_pass\"]\n\n\ttry:\n\t\tcredentials = pika.PlainCredentials(rabbit_username, rabbit_password)\n\t\tparameters = pika.ConnectionParameters(rabbitmq_host, rabbitmq_port, \"/\", credentials,\n\t\t heartbeat=0, blocked_connection_timeout=None)\n\t\tconnection = pika.BlockingConnection(parameters)\n\t\treturn None, connection\n\texcept Exception, ex:\n\t\treturn traceback.print_exc(), None",
"def consume_message(message):\n # Assign the message to the global drone_message\n global drone_message\n drone_message = message\n # The Rabbit mq runs in the localhost and the username , password is\n # athavan\n credentials = pika.PlainCredentials('guest', 'guest')\n # Pass the mqhost , port , virtualhost and credentials\n parameters = pika.ConnectionParameters('localhost', 5672, '/', credentials)\n connection = pika.SelectConnection(parameters, on_connected)\n try:\n connection.ioloop.start()\n except KeyboardInterrupt:\n # close the connnection\n connection.close()\n # loop until we are fully closed. It will stop on its own\n connection.ioloop.start()",
"def __init__(self):\n self.try_to_connect()",
"def _check_connect(self) -> bool:\n\n if (self._conn is None):\n if (self._exception):\n raise base_connection.ConnectException(\n \"No connection established\")\n\n else:\n return False\n\n return True",
"def connect(self):\n self.logger.info('connecting to %s', self._url)\n return pika.SelectConnection(pika.URLParameters(self._url), self.on_connection_open, stop_ioloop_on_close=False)",
"def __init__(self, routing_key):\n self.routing_key = routing_key\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\n self.channel = self.connection.channel()\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\n self.callback_queue = result.method.queue\n\n self.channel.basic_consume(\n queue=self.callback_queue,\n on_message_callback=self.on_response,\n auto_ack=True\n )",
"def initialize(self):\n if not self.connection.is_closed():\n self.connection.close()\n\n self.connection.connect()",
"def _connect_failed(self):\n\t\tself.root.stdout.write(\"Error: Connection Failed!\\n\")\n\t\tself.client = False",
"def handle_connect(self):\n pass",
"def run(self):\n\n self.make_connection()\n self.channel()\n self.declare_queue()\n self.publish_message()\n self.close_connection()",
"def init(\n self,\n ) -> bool:\n success = True\n try:\n self.client = mqtt.Client(client_id=\"Draco\", protocol=mqtt.MQTTv5)\n self.client.on_connect = self.on_connect\n self.client.on_message = self.on_message\n self.client.connect(\n host=self._config[\"broker_ip\"], port=self._config[\"broker_port\"]\n )\n self.client.loop_start()\n\n except Exception as error:\n print(f\"Process {self._pid} - \" + repr(error))\n success = False\n return success",
"def check_publishers_connection(self):\n rate = rospy.Rate(10) # 10hz\n while (self._cart_velocity_publisher.get_num_connections() == 0 and not rospy.is_shutdown()):\n rospy.logdebug(\"No susbribers to _cart_velocity_publisher yet so we wait and try again\")\n try:\n rate.sleep()\n except rospy.ROSInterruptException:\n # This is to avoid error when world is rested, time when backwards.\n pass\n rospy.logdebug(\"_base_pub Publisher Connected\")\n\n rospy.logdebug(\"All Publishers READY\")",
"def setup_amq_kafka_bridge(self):\n try:\n kafka_bridge = templating.load_yaml(os.path.join(self.dir, self.amq_kafka_bridge_yaml))\n self.kafka_bridge = OCS(**kafka_bridge)\n self.kafka_bridge.create()\n except(CommandFailed, CalledProcessError) as cf:\n log.error('Failed during setup of AMQ KafkaConnect')\n raise cf\n # Making sure the kafka_bridge is running\n if self.is_amq_pod_running(pod_pattern=\"my-bridge-bridge\"):\n return self.kafka_bridge\n else:\n raise ResourceWrongStatusException(\"kafka_bridge_pod pod is not getting to running state\")",
"def _create_channel(self):\n self.connection = pika.BlockingConnection(self.pikaparams)\n self.channel = self.connection.channel()\n try:\n yield self.channel\n finally:\n self.channel.close()\n self.connection.close()",
"def _create_connection(self, host, port):\n return pika.BlockingConnection(pika.ConnectionParameters(host=host,\n port=port))",
"def __init__(self, options):\n self._options = options\n host = self._get_option('rabbit_host', 'str', 'localhost')\n port = self._get_option('rabbit_port', 'int', 5672)\n use_ssl = self._get_option('rabbit_use_ssl', 'bool', False)\n userid = self._get_option('rabbit_userid', 'str', 'guest')\n password = self._get_option('rabbit_password', 'str', 'guest')\n virtual_host = self._get_option('rabbit_virtual_host', 'str', '/')\n\n self.connection = kombu.connection.BrokerConnection(\n hostname=host,\n userid=userid,\n password=password,\n virtual_host=virtual_host,\n ssl=use_ssl)\n\n self.topic = self._get_option('rabbit_notification_topic',\n 'str',\n 'glance_notifications')",
"def accept_connection(self):\n pass",
"def amqp(self, **options):\n pass",
"def get_pending_messages():\n global logger\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n msg = \"exception 1 in connecting\"\n logger.debug(msg)\n # print(msg)\n time.sleep(3)\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n logger.debug(msg+\" for the second time\")\n return -1\n channel = connection.channel()\n queue = channel.queue_declare(queue=queue_name, durable=True, auto_delete=False)\n num = queue.method.message_count\n connection.close()\n return num",
"def _connect(self):\n try:\n self.conn = psycopg2.connect(\n host=self.host,\n user=self.username,\n password=self.password,\n port=self.port,\n dbname=self.dbname\n )\n except psycopg2.DatabaseError as e:\n logger.error(e)\n raise e\n logger.info('Connection opened successfully.')",
"def setup_amq_kafka_connect(self):\n try:\n kafka_connect = templating.load_yaml(os.path.join(self.dir, self.amq_kafka_connect_yaml))\n self.kafka_connect = OCS(**kafka_connect)\n self.kafka_connect.create()\n except(CommandFailed, CalledProcessError) as cf:\n log.error('Failed during setup of AMQ KafkaConnect')\n raise cf\n\n if self.is_amq_pod_running(pod_pattern=\"my-connect-cluster-connect\"):\n return self.kafka_connect\n else:\n raise ResourceWrongStatusException(\"my-connect-cluster-connect pod is not getting to running state\")",
"async def run(app):\n app.logger.debug(\"START RABBITMQ \")\n config = app.config.get('RABBITMQ')\n\n app.logger.debug(config)\n\n while True:\n loop = asyncio.get_event_loop()\n\n try:\n app.logger.debug(\"Create connection!\")\n connection = await aio_pika.connect_robust(\n \"amqp://{}:{}@{}\".format(\n config['username'],\n config['password'],\n config['host']\n ), loop=loop\n )\n # Creating channel\n app.logger.debug(\"Create channel\")\n channel = await connection.channel()\n async with connection:\n app.logger.debug(\"create exchange {}\".format(config['exchange_name']))\n await channel.declare_exchange(config['exchange_name'])\n\n app.logger.debug(\"create queue {}\".format(QUEUE_NAME))\n\n queue = await channel.declare_queue(\n QUEUE_NAME, auto_delete=True, durable=False\n )\n await queue.bind(exchange=config['exchange_name'], routing_key='*')\n\n async with queue.iterator() as queue_iter:\n async for message in queue_iter:\n async with message.process():\n content = message.body.decode()\n app.logger.debug(\"RABBITMQ: got message {}\".format(content))\n loop = asyncio.get_event_loop()\n loop.create_task(app.hub.dispatch_message(content))\n except Exception as e:\n app.logger.error(\"Exception in connection with rabbitmq. Back of a bit, and try again\")\n app.logger.exception(e)\n await asyncio.sleep(3)",
"def test_configuration1(self):\n with self.assertRaises((TypeError, AttributeError)):\n queue = RabbitQueue()\n queue.connect()",
"def __check_ping(self):\n if not self.communications.ping():\n self.communications.ping(True)",
"def _detect(self):\n if monasca_setup.detection.find_process_cmdline('rabbitmq-server') is not None:\n self.available = True",
"def _on_connection_close(self):\n print(\"connection was closed, reconnecting...\")\n self.connect()",
"def connect(self):\n if not self.is_connected:\n self._init_cec_connection()",
"def _is_redis_available(self) -> None:\n try:\n redis = self._conn_redis()\n redis.ping()\n except ConnectionError as err:\n raise HTTPException(status_code=500,detail=f\"REDIS CONNECTION -> {err}\")",
"def reconnect(self):\n # only used for sending:\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n\n self._connection.ioloop.stop()\n self._connection.connect()\n self._connection.ioloop.start()",
"def _connect(self):\r\n self.sock = socket.socket()\r\n host = \"pubsub.pubnub.com\"\r\n port = 80\r\n if self.use_ssl:\r\n self.sock = ssl.wrap_socket(self.sock)\r\n port = 443\r\n self.sock.connect((host, port))\r\n self.connected = True",
"def connectionMade(self):\n self.factory._r_on_connection_established(self)",
"def _check_publishers_connection(self):\n rate = rospy.Rate(10) # 1hz\n while self._vel_pub.get_num_connections() == 0 and not rospy.is_shutdown():\n rospy.logdebug(\"No susbribers to _vel_pub yet so we wait and try again\")\n try:\n rate.sleep()\n except rospy.ROSInterruptException:\n # This is to avoid error when world is rested, time when backwards.\n pass\n rospy.logdebug(\"_vel_pub Publisher Connected\")\n\n rospy.logdebug(\"All Publishers READY\")",
"def connect(_url, _port, _user, _passwd, _exchange, _queue):\n connection = None\n channel = None\n exchange = None\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(\n port=_port,\n host=_url,\n credentials=pika.PlainCredentials(_user, _passwd))\n )\n channel = connection.channel()\n exchange = channel.exchange_declare(\n exchange=_exchange,\n passive=False,\n durable=False,\n exchange_type='fanout'\n )\n\n queue = channel.queue_declare(\n queue=_queue,\n durable=False,\n exclusive=False,\n auto_delete=True\n ).method.queue\n channel.queue_bind(exchange=_exchange, queue=queue, routing_key='')\n\n return connection, channel, exchange, queue\n\n except Exception as e:\n logger.error(e)\n if not (channel is None):\n channel.close()\n channel = None\n if not (connection is None):\n connection.close()\n connection = None\n return None, None",
"def connectionInitialized(self):\n log.msg('Connection Initialized')\n self.send(AvailablePresence())\n self.xmlstream.addObserver(\"/iq[@type='result']\", self.handleRequest)\n self.xmlstream.addObserver(\"/message\", self._onMessage)",
"def send_rabbit_message (params ):\n print \"sending message to rabbitmq exchange\"\n logging.basicConfig()\n rabbitmq_host = params.get( 'host' )\n rabbitmq_port = params.get( 'port' )\n rabbitmq_username = params.get( 'user-name' )\n rabbitmq_password = params.get( 'password' )\n exchange_name = params.get( 'exchange' )\n routing_key = params.get( 'routing' )\n message = params.get( 'message' )\n \n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\n amqp_url = str(amqp_url)\n parameters = pika.URLParameters(amqp_url)\n connection = pika.BlockingConnection(parameters)\n channel = connection.channel()\n \n channel.basic_publish(exchange=exchange_name,routing_key=routing_key,body=message)\n ## close connection at the end \n connection.close()",
"def do_start(self):\n threading.Thread(group = None, \n target = self._subscribe_message, name = \"RabbitMQSubscribeThread\") .start()\n threading.Thread(group = None, \n target = self._publish_message, name = \"RabbitMQPublishThread\").start()",
"def connect(self):\n assert self.listening\n assert not self.connected\n ctx = zmq.Context.instance()\n port = NODE_INFOS[self.ID].port\n self._send_socket = ctx.socket(zmq.PUB)\n self._send_socket.bind(f\"tcp://*:{port}\")\n self.connected = True",
"def _connect(self):\n if not self.connected:\n self.connection = SQSConnection(self.access_key, self.secret_key, region=self.region)\n self.queue = self.connection.create_queue(self.name)\n self.connected = True\n return self",
"def connect(self):\n # First close any existing producer if already connected\n if hasattr(self, 'producer') and getattr(self, 'connected', False) == True:\n try:\n self.producer.close()\n except Exception:\n pass\n # Create the producer\n try:\n self.producer = self.client.create_producer(self.control_topic, schema=pulsar.schema.StringSchema(),\n block_if_queue_full=True)\n self.connected = True\n except Exception as e:\n logger.warn('Cannot connect a producer to publish commands ' + str(e))\n self.connected = False",
"def _on_connection_success(self):\n if self.connect_handler:\n self.connect_handler()",
"def start(self):\n if not self._connected:\n self._client.connect(self._addr, port=self._port, keepalive=60, bind_address=\"\")\n self._client.loop_start()\n self._connected = True\n logger.info(\"Connection with MQTT Broker at %s:%d estabilished.\", self._addr, self._port)",
"async def test_connection(self):\n await self.webhook_connection.connect()\n assert self.webhook_connection.is_connected is True",
"def checkConnection(self,msg):\n if (len(msg) == 0):\n sleep(self.m_to/2)\n print >>sys.stderr, 'Closing due to possible server fault'\n self.close()",
"def connect(self):\n # Loop and check\n error = None\n while self.router_manager.can_failover():\n try:\n router = self.router_manager.get_next_router()\n self.stream.connect(\n router.get_connection_params(), self._connect_timeout\n )\n reader = MessageReader(self.stream)\n writer = MessageWriter(self.stream)\n self.protocol = Protocol(reader, writer)\n\n caps_data = self.protocol.get_capabilites().capabilities\n caps = (\n {get_item_or_attr(cap, \"name\").lower(): cap for cap in caps_data}\n if caps_data\n else {}\n )\n\n # Set TLS capabilities\n self._set_tls_capabilities(caps)\n\n # Set connection attributes capabilities\n if \"attributes\" in self.settings:\n conn_attrs = self.settings[\"attributes\"]\n self.protocol.set_capabilities(session_connect_attrs=conn_attrs)\n\n # Set compression capabilities\n compression = self.settings.get(\"compression\", Compression.PREFERRED)\n algorithms = self.settings.get(\"compression-algorithms\")\n algorithm = (\n None\n if compression == Compression.DISABLED\n else self._set_compression_capabilities(\n caps, compression, algorithms\n )\n )\n self._authenticate()\n self.protocol.set_compression(algorithm)\n return\n except (OSError, RuntimeError) as err:\n error = err\n router.set_unavailable()\n\n # Python 2.7 does not raise a socket.timeout exception when using\n # settimeout(), but it raises a socket.error with errno.EAGAIN (11)\n # or errno.EINPROGRESS (115) if connect-timeout value is too low\n if error is not None and isinstance(error, socket.timeout):\n if len(self._routers) <= 1:\n raise TimeoutError(\n \"Connection attempt to the server was aborted. \"\n f\"Timeout of {self._connect_timeout} ms was exceeded\"\n )\n raise TimeoutError(\n \"All server connection attempts were aborted. \"\n f\"Timeout of {self._connect_timeout} ms was exceeded for each \"\n \"selected server\"\n )\n if len(self._routers) <= 1:\n raise InterfaceError(f\"Cannot connect to host: {error}\")\n raise InterfaceError(\"Unable to connect to any of the target hosts\", 4001)",
"def __enable_connections(self):\r\n pass",
"def run(self):\n\n self.debug = self.forwarder_options.get(\"debug\", \"0\") != \"0\"\n if self.debug:\n self.logger.setLevel(logging.DEBUG)\n\n processor_count = int(self.forwarder_options.get(\"message_processor_count\", 1))\n cpu_count = multiprocessing.cpu_count()\n if processor_count > cpu_count:\n self.logger.info(\"processor_count (%s) > cpu_count. Defaulting to cpu_count\", (processor_count, cpu_count))\n processor_count = cpu_count\n\n self.event_processor = EventProcessor(self.forwarder_options)\n self.processor_pool = multiprocessing.Pool(processor_count)\n\n while True:\n try:\n self.consume_message_bus(test=self.testing)\n except Exception as e:\n self.retry_attempts += 1\n if self.retry_attempts > self.max_retry_attempts:\n self.logger.critical(\"Too many attempts to reconnect (%d). Exiting now.\" % self.max_retry_attempts)\n break\n\n if isinstance(e, pika.exceptions.AMQPConnectionError) or isinstance(e, pika.exceptions.ConnectionClosed):\n self.logger.error(\"Connection is closed or refused, retrying in %s seconds\" % self.retry_interval)\n else:\n self.logger.exception(\"An unexpected error occurred, retrying in %s seconds\" % self.retry_interval)\n\n if self.connection is not None:\n self.connection.close()\n self.connection = None\n\n time.sleep(self.retry_interval)",
"async def connection_made(self):\n logging.info('connecting to %s:%s' % self.address)",
"def connect_never_retry():\n try:\n messaging_service = MessagingService.builder().from_properties(boot.broker_properties()) \\\n .with_reconnection_retry_strategy(RetryStrategy.never_retry()).build()\n future = messaging_service.connect_async()\n\n return future.result()\n\n except PubSubPlusClientError as exception:\n raise exception\n\n finally:\n messaging_service.disconnect_async()",
"def start(self):\n self._connect()\n self._init_exchange()\n self._init_queue()\n self._bind_queue()",
"def __init__(self, address, queue_name):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(address))\n self.queue_name = queue_name\n\n # create the channel\n self.channel = self.connection.channel()\n\n # declare the queue\n self.channel.queue_declare(queue=queue_name, durable=True)\n\n logging.info(\"Message Broker connected to {0}\".format(address))",
"def _connect(self):\n self.connection = RedisConnection(self.host, self.port, self.dbname)",
"def test_postgresql_connect_fail(self):\n if test_migrations._is_backend_avail(\n 'postgres', 'kickstand_cifail', self.PASSWD, self.DATABASE):\n self.fail(\"Shouldn't have connected\")",
"def reconnect(self):\n raise NotImplementedError()",
"def _connection_failed(self, link_uri, msg):\n\t\tprint \"Connection to %s failed: %s\" % (link_uri, msg)\n\t\tself.is_connected = False",
"def handle_connection_lost(self, exc: Optional[Exception]) -> None:",
"def connect(self):\n\t\tpass",
"def prepare_buy(self):\n self.redisHandle.connect_redis(\"localhost\")\n # [TODO] check return value",
"def test_postgresql_connect_fail(self):\n if _is_backend_avail('postgresql', user=\"openstack_cifail\"):\n self.fail(\"Shouldn't have connected\")",
"def connect(self, host):\n return False",
"async def _connect(self):\n pass",
"def connect(self):\n try:\n super().connect(self.host, username=self.username,\n password=self.password)\n except paramiko.AuthentificationException:\n print(\"Authentification error occured.\")\n except paramiko.SSHException:\n print(\"Connection error occuredi.\")\n\n pass # TODO"
] | [
"0.76508445",
"0.73340255",
"0.7146357",
"0.70382",
"0.69546276",
"0.68715435",
"0.6687028",
"0.6670201",
"0.6660305",
"0.6649513",
"0.6638036",
"0.66325414",
"0.6580405",
"0.6532733",
"0.6532733",
"0.6532733",
"0.6495587",
"0.6482817",
"0.6463216",
"0.62942183",
"0.6246966",
"0.6237009",
"0.6225781",
"0.6219473",
"0.62127614",
"0.6159434",
"0.6136952",
"0.6124725",
"0.61032134",
"0.61008596",
"0.6080768",
"0.6054206",
"0.60490936",
"0.5990241",
"0.59753335",
"0.59070927",
"0.5906825",
"0.59046",
"0.58827347",
"0.58422154",
"0.583358",
"0.5814536",
"0.5807988",
"0.5796974",
"0.5796595",
"0.57864195",
"0.5781047",
"0.57533145",
"0.5721942",
"0.57102126",
"0.57020766",
"0.56770486",
"0.56737095",
"0.5667839",
"0.56591463",
"0.565869",
"0.564448",
"0.56369203",
"0.563604",
"0.56304824",
"0.56289506",
"0.5627064",
"0.5591211",
"0.55870867",
"0.5585865",
"0.5576539",
"0.55722237",
"0.5572144",
"0.5569486",
"0.55692244",
"0.55652773",
"0.55561477",
"0.55525166",
"0.5541243",
"0.55383354",
"0.5538089",
"0.552556",
"0.55239516",
"0.55061597",
"0.5499559",
"0.5485889",
"0.54836726",
"0.54649675",
"0.5463765",
"0.545981",
"0.5457999",
"0.54577255",
"0.54552144",
"0.5453369",
"0.5450799",
"0.5448437",
"0.54452467",
"0.5438091",
"0.54352945",
"0.54297525",
"0.5428037",
"0.5421551",
"0.54212725",
"0.54167116",
"0.54134214",
"0.540544"
] | 0.0 | -1 |
This method is invoked by pika when the connection to RabbitMQ is closed unexpectedly. Since it is unexpected, we will reconnect to RabbitMQ if it disconnects. | def on_connection_closed(self, _unused_connection, reason):
self._channel_ctrl = None
self._channel_task = None
if self._closing:
self._connection.ioloop.stop()
else:
# LOGGER.warning('Connection closed, reconnect necessary: %s', reason)
self.reconnect() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _on_connection_close(self):\n print(\"connection was closed, reconnecting...\")\n self.connect()",
"def on_channel_closed(self, *args, **kwargs):\n if not self._normal_close:\n self.log.warning(\n 'Channel closed. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def on_connection_closed(self, connection, reply_code, reply_text):\n self._channel = None\n if self._closing:\n self._connection.ioloop.stop()\n else:\n logger.warning('Connection closed, reopening in 5 seconds: (%s) %s',\n reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"def connection_closed(self, exc):\n _logger.info(\"Connection lost: %s\", str(exc))\n super().close()",
"def connection_lost(self, exc):\n if self._closing:\n return\n self._closing = True\n\n # inform yielding readers about closed connection\n if exc is None:\n logger.info(\"Connection closed for %s\", self)\n self.reader.feed_eof()\n else:\n logger.info(\"Connection lost for %s: %s\", self, exc)\n self.reader.set_exception(exc)\n\n # cancel protocol tasks, namely on-connect negotiations\n for task in self._tasks:\n task.cancel()\n\n # close transport (may already be closed), set _waiter_closed and\n # cancel Future _waiter_connected.\n self._transport.close()\n self._waiter_connected.cancel()\n if self.shell is None and self._waiter_closed is not None:\n # raise deprecation warning, _waiter_closed should not be used!\n self._waiter_closed.set_result(weakref.proxy(self))\n\n # break circular references.\n self._transport = None",
"def on_connection_closed(self, connection, reply_code, reply_text):\n\n self._channel = None # there cannot be a channel, since the connection holding it was shut down\n if self._closing:\n # we are trying to stop. Just do so.\n self._connection.ioloop.stop()\n else:\n # this is unexpected. Restart the connection (after a timeout)\n self.logger.warning('The connection closed: %s:%s - retrying', reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"def reconnect(self):\n # only used for sending:\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n\n self._connection.ioloop.stop()\n self._connection.connect()\n self._connection.ioloop.start()",
"def on_connection_closed(self, connection, reply_code, reply_text):\n if self._closing:\n self._connection.ioloop.stop()\n else:\n self.logger.warning(\n 'Connection closed, reopening in 5 seconds: (%s) %s',\n reply_code, reply_text)\n self._connection.add_timeout(self.CONNECTION_TIMEOUT_SEC,\n self.reconnect)",
"def connection_lost(self, exc):\n if not self._closing:\n self._closing = True\n self.log.info('{about}{reason}'.format(\n about=self.__str__(),\n reason=': {}'.format(exc) if exc is not None else ''))\n self.waiter_connected.cancel()\n self.waiter_closed.set_result(self)",
"def connection_closed(self) -> bool:",
"def connection_remote_closed(self, connection, pn_condition):\n assert len(self.receivers) == 0\n self.connection.close()",
"def force_reconnect(self):\r\n self.socket.close()",
"async def connection_lost(self):\n logging.info('connection dropped')",
"def connection_lost(self, exc):\n super().connection_lost(exc)\n\n if self.session is not None:\n # Kill the session.\n self.session.close(SessionCloseErrorCode.SESSION_DIED)\n self.session = None\n\n self.client = None",
"def reconnect(self):\n self.__connection.reconnect()",
"def reconnect(self):\n try:\n try: self.exit()\n except Exception, ex: handle_exception()\n self.reconnectcount += 1\n logging.warn('%s - reconnecting .. sleeping %s seconds' % (self.name, self.reconnectcount*15))\n time.sleep(self.reconnectcount * 15) \n self.doreconnect()\n except Exception, ex: \n handle_exception()",
"def loseConnection(self):\n self.transport.loseConnection()",
"def connectionLost(self, reason):\n self.chan = None\n self.dispatcher.unregister(self.producer.put)\n log.err(reason, \"Connection lost\")\n AMQClient.connectionLost(self, reason)",
"def connection_lost(self, exc):\n self._log.warn(\"Serial Connection Lost\")\n self.transport = None\n self.onReady(False)",
"def connection_lost(self, exc):\n logger.info('The server closed the connection')\n self.loop.stop()",
"def _on_close(self):\n self.web_socket_open = False\n self.logged_in = False\n print(\"WebSocket Closed for \" + self.session_name)\n\n if not self.disconnected_by_user:\n print(\"Reconnect to the endpoint for \" + self.session_name + \" after 3 seconds... \")\n time.sleep(3)\n self.connect()",
"def connection_closed(self):\n self.atv = None\n self._start_connect_loop()\n self._update_state(disconnected=True)",
"def connection_lost(self, exc):\n if self._stream.done:\n # Stream is done, no need to panic\n pass\n else:\n self._logger.debug('[%s] Connection lost!', self._sock_id, exc_info=exc)",
"def on_connection_closed(self):",
"def connection_lost(self, transport, exc):\n if transport not in self.clients:\n return\n reason = str(exc) if exc else 'Connection reset by peer'\n self.client_close(transport, reason)",
"def connection_lost(self, exc) -> None:\n # We can assert these because this should never get called\n # before self.connection_made which sets these:\n assert self.transport is not None\n assert self.task is not None\n logging.info(\"Server: Connection lost.\")\n self.task.cancel()\n self.transport.close()",
"def connectionLost(self, reason):\n print \"connection lost from\", self.addr\n reactor.stop()",
"def reconnect(self):\n raise NotImplementedError()",
"def connection_lost(self, exc):\n pass",
"def close(self):\n if self.connection.opened():\n logger.info(' connection closed.')\n self.connection.close()",
"def __on_connection_close(self) -> None:\r\n logger.info(\"Checking closed connections.\")\r\n for browser in set(self.browsers.keys()):\r\n if browser._connection.connection is None or not browser._connection.connection.open:\r\n logger.warning(f\"Found closed connection: {browser}\")\r\n asyncio.create_task(\r\n self.replace_browser(browser))",
"def _recover_network_failure(self):\n if self.auto_reconnect and not self._is_closing:\n connected = False\n while not connected:\n log_msg = \"* ATTEMPTING RECONNECT\"\n if self._retry_new_version:\n log_msg = \"* RETRYING DIFFERENT DDP VERSION\"\n self.ddpsocket._debug_log(log_msg)\n time.sleep(self.auto_reconnect_timeout)\n self._init_socket()\n try:\n self.connect()\n connected = True\n if self._retry_new_version:\n self._retry_new_version = False\n else:\n self._is_reconnecting = True\n except (socket.error, WebSocketException):\n pass",
"def reconnect(self):\n # This is the old connection IOLoop instance, stop its ioloop\n self._connection.ioloop.stop()\n\n if not self._closing:\n # Create a new connection\n self._connection = self.connect()\n\n # There is now a new connection, needs a new ioloop to run\n self._connection.ioloop.start()",
"def safe_close(self):\n if self.channel_is_closed:\n return\n if not self.channel_is_bad:\n try:\n self.safe_do_command(\"quit\")\n except BadGtpResponse, e:\n self.errors_seen.append(str(e))\n try:\n self.channel.close()\n except GtpTransportError, e:\n self.errors_seen.append(\"error closing %s:\\n%s\" % (self.name, e))\n self.channel_is_closed = True",
"def on_consume_cancelled(self, *args, **kwargs): # pragma: no cover\n self.log.warning(\n 'Consume cancelled. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def reconnect(self):\n # This is the old connection IOLoop instance, stop its ioloop\n self._connection.ioloop.stop()\n\n if not self._closing:\n # Create a new connection\n self._connection = self.connect()\n # There is now a new connection, needs a new ioloop to run\n self._connection.ioloop.start()",
"def connectionLost(self, reason):\n print \"lost connection to\", host, \"port\", port\n reactor.stop()",
"def on_connection_open_error(self, _unused_connection, err):\n # LOGGER.error('Connection open failed: %s', err)\n self.reconnect()",
"def initiate_reconnect(self):\n\t\t# The connection is broken. Don't wait for a lock to signal that it\n\t\t# is broken.\n\t\tnow = time.time()\n\t\tif self.connection_is_usable:\n\t\t\tlogger.debug(\"Initiating jabber reconnect on usable connection\")\n\t\telif self.last_reconnect + self.reconnect_timeout < now:\n\t\t\tlogger.debug(\"Initiating reconnect because previous reconnect timed out\")\n\t\telse:\n\t\t\tlogger.debug(\"Not initiating jabber reconnect after recent reconnect\")\n\t\t\treturn\n\n\t\tself.connection_is_usable = False\n\t\tos.write(self.reconnect_trigger_write, \"\\0\")\n\t\tself.last_reconnect = now",
"def reconnect(self):\n self.close()\n self.connect()",
"async def _reconnect(self):\n # pylint: disable=broad-except\n while self._state != const.STATE_CONNECTED:\n try:\n await self._connect()\n self._reconnect_task = None\n return\n except Exception as err:\n # Occurs when we could not reconnect\n _LOGGER.debug(\"Failed to reconnect to %s: %s\", self.host, err)\n await self._disconnect()\n await asyncio.sleep(self._reconnect_delay)\n except asyncio.CancelledError:\n # Occurs when reconnect is cancelled via disconnect\n return",
"async def _handle_connection_error(self, error: Exception = \"hearbeat\"):\n if self._reconnect_task:\n return\n await self._disconnect()\n if self._auto_reconnect:\n self._state = const.STATE_RECONNECTING\n self._reconnect_task = asyncio.create_task(self._reconnect())\n else:\n self._state = const.STATE_DISCONNECTED\n\n _LOGGER.debug(\"Disconnected from %s: %s\", self.host, error)\n self._avr.dispatcher.send(const.SIGNAL_TELNET_EVENT, const.EVENT_DISCONNECTED)",
"def _close_connection(self, connection):\n logger.info('Closing connection')\n if connection and connection.is_open:\n connection.close()",
"def __connection_lost(self):\n print(\"Error: connection lost.\")\n try:\n # Try and send a message back to the server to notify connection\n # lost\n self.client_socket.send(\"q\".encode())\n except:\n pass\n # Raise an error to finish\n raise Exception",
"async def close_connection(self):\n\t\t...",
"def on_upstream_connection_close(self) -> None:\n pass # pragma: no cover",
"def onCorruptConnection(self):\n self.log.critical(\"Connection is corrupt!!! Shutting down...\")\n self.connectionCorrupted = True\n self.cancelOutboundTransactions(SMPPClientConnectionCorruptedError())\n self.shutdown()",
"def connectionLost(self, reason):\n self.factory._r_on_connection_lost(self)",
"async def clean_up(self) -> None:\n self.logger.info(\"clean_up\", \"closing redis connection\")\n if self.pubsub_task and not self.pubsub_task.done():\n self.pubsub_task.cancel()\n try:\n await self.pubsub_task\n except CancelledError:\n pass\n self.pubsub_task = None\n if self.pubsub_channel is not None:\n self.pubsub_channel.close()\n await super().clean_up()",
"def closed(self, code, reason=None):\n self.logger.info(\n \"Socket connection closed {0}:{1}\".format(code, reason))\n self._heartbeats.stop_heartbeats()\n self._disconnect_handler()",
"def test_disconnect_closed(self):\n self.sock.close()\n self.inverter.sock.close()\n self.inverter.sock_file.close()\n self.inverter.disconnect() # Should not raise exception",
"def close_connection(self):\n logger.info('Closing connection')\n self._connection.close()",
"async def on_disconnect(self, reconnecting):\n pass",
"def loseConnection(self):\n self.xmlstream.connectionLost(\n failure.Failure(Exception(self.connectionLostMsg))\n )",
"def connection_lost(self, exc):\n self.node.notify(Task(TaskType.CONN_LOST, exc))",
"def reconnect(self):\n self.should_reconnect = True\n self.stop()",
"async def __aexit__(self, exc_type, exc_value, traceback):\n\n # Close the connection\n await self.disconnect()",
"def log_reconnect(self):\n pass",
"def connectionLost(self, reason):\n if self.factory:\n self.factory.reactor.removeReader(self)",
"def on_connection_closed(self, connection, *args):\n self.logger.debug(\"Connection %s closed: %s\", connection, args)\n self._connection.ioloop.stop()",
"def _connection_lost(self, link_uri, msg):\n print('Connection to %s lost: %s' % (link_uri, msg))",
"def handle_connection_lost(self, exc: Optional[Exception]) -> None:",
"def _close_connection(self):\n if self.connection:\n self.connection.destroy()\n self.connection = None",
"def close_connection(self):\n\n self._connection.close()\n print(\"Closed connection....\")",
"def connection_lost(self, exc: Optional[Exception]) -> None:\n self.listener.handle_connection_lost(exc)",
"def reconnect(self):\n print(\"reconnect\")\n\n self._in_packet = {\n \"command\": 0,\n \"have_remaining\": 0,\n \"remaining_count\": [],\n \"remaining_mult\": 1,\n \"remaining_length\": 0,\n \"packet\": b\"\",\n \"to_process\": 0,\n \"pos\": 0}\n\n self._current_out_packet = None\n\n self._last_msg = time.time()\n\n self._ping_t = 0\n print(\"reconnect: self._state =\", self._state)\n self._state = mqtt_cs_new\n if self._sock:\n self._sock.close()\n self._sock = None\n print(\"self._sock == None\")\n\n sock = socket.create_connection((self._host, self._port), source_address=(self._bind_address, 0))\n self._sock = sock\n self._sock.setblocking(0)\n self.ep = select.epoll()\n self.fileno = self._sock.fileno()\n self.ep.register(self.fileno)\n\n print(\"self._sock =\", self._sock)\n\n return self._send_connect(self._keepalive)",
"def errConnectionLost(self):\n self.logger('stderr closed by process %d' % self._pid)",
"def close_connection(self):\n if not self.is_open():\n return\n if self._active_result is not None:\n self._active_result.fetch_all()\n self.protocol.send_connection_close()\n self.protocol.read_ok()\n self.stream.close()",
"def connectionLost(self,reason):\n pass",
"async def on_disconnected(self):\n self._connected = False\n self._connectedToBroker = False",
"def close(self):\n if self.closed:\n return\n try:\n self.channel.close(self)\n self.dispose()\n except StopIteration:\n # If the underlying connection for the channel is closed explicitly\n # open will not able to find an appropriate channel, to send close.\n pass",
"def handle(self, message):\n\n self._set_timeout(message)\n self._set_interval(message)\n self._set_reconnect(message)\n\n if not message['successful']:\n raise Reconnect(\n 'Unsuccessful connect response: {}'\n .format(message.get('error')))",
"def onClose(self, wasClean, code=None, reason=None):\n self.sessionhandler.disconnect(self)\n if self.nextHeartbeatCall:\n self.nextHeartbeatCall.cancel()\n self.nextHeartbeatCall = None\n if wasClean:\n logger.log_info(f\"Discord connection closed ({code}) reason: {reason}\")\n else:\n logger.log_info(f\"Discord connection lost.\")",
"def disconnect(self) -> None:\n self.log.debug(f\"Disconnecting from {self.host} : {self.port}\")\n if self._connected:\n self.client.publish(\n self.lastwill_message.topic, self.lastwill_message.payload\n )\n self.client.loop_stop()\n self.client.disconnect()",
"def _refresh_connection(self):\n\n try:\n response = requests.get(\n f\"https://{self.hostname}:{self.port}/{self._ENDPOINTS['tokens']}/{self.session_id}\",\n headers=self._headers,\n verify=False\n ).json()\n\n if 'messages' in response and response['messages'][0]['severity'] == 'error':\n self._connect()\n\n except requests.ConnectionError as error:\n logging.exception(error)\n raise ConnectionError(f\"Error reconnecting to {self.hostname}\")",
"def disconnect(self):\n self.close_when_done()\n #logs.logger.debug(\"disconnect %s\" % self)",
"def on_connection_open_error(self, _unused_connection, err):\n self.logger.info('Connection open failed: %s', err)\n self.reconnect()",
"def connectionLost(self, reason):\n if self.lc and self.lc.running:\n self.lc.stop()\n self.factory.open_connections.remove((self.connection_timestamp,\n self.transport.getPeer()))\n self.log.info(\"Connection lost from: {address}.\"\n \"Clients connected {nClients}\",\n address=self.transport.getPeer(),\n nClients=len(self.factory.open_connections))",
"def closed(self, code, reason=None):\n if code != 1000:\n self._error = errors.SignalFlowException(code, reason)\n _logger.info('Lost WebSocket connection with %s (%s: %s).',\n self, code, reason)\n for c in self._channels.values():\n c.offer(WebSocketComputationChannel.END_SENTINEL)\n self._channels.clear()\n with self._connection_cv:\n self._connected = False\n self._connection_cv.notify()",
"def _connection_lost(self, link_uri, msg):\n print \"Connection to %s lost: %s\" % (link_uri, msg)",
"def disconnect(self):\n _error = None\n try:\n self.connection.shutdown()\n except Exception as e:\n log.error(e, exc_info=True)\n _error = 'disconnect error: %s' % e\n finally:\n if _error is not None and config.DEBUG_TO_CONSOLE:\n print (_error)\n self.is_connected = False\n self.connection = None",
"async def heartbeat_loop():\n self.debug(\"Started heartbeat loop\")\n while True:\n try:\n await self.heartbeat()\n await asyncio.sleep(HEARTBEAT_INTERVAL)\n except asyncio.CancelledError:\n self.debug(\"Stopped heartbeat loop\")\n raise\n except asyncio.TimeoutError:\n self.debug(\"Heartbeat failed due to timeout, disconnecting\")\n break\n except Exception as ex: # pylint: disable=broad-except\n self.exception(\"Heartbeat failed (%s), disconnecting\", ex)\n break\n\n transport = self.transport\n self.transport = None\n transport.close()",
"def checkConnection(self,msg):\n if (len(msg) == 0):\n sleep(self.m_to/2)\n print >>sys.stderr, 'Closing due to possible server fault'\n self.close()",
"def _connect(self) -> BlockingChannel:\n for _ in range(self.retry):\n getLogger().info(\"Trying to connect to RabbitMQ ...\")\n try:\n connection = pika.BlockingConnection(self.connection_params)\n channel = connection.channel()\n channel.exchange_declare(self.exchange_name, 'direct', durable=True)\n channel.basic_qos(prefetch_count=self.prefetch)\n channel.queue_declare(\n self.queue_name, durable=True\n )\n channel.queue_bind(self.queue_name, self.exchange_name, self.binding_key)\n except (AMQPConnectionError, ChannelError) as e:\n getLogger().error(f\"Connection to RabbitMQ failed {e}\")\n sleep(self.retry_interval)\n else:\n getLogger().info(\"Connected to RabbitMQ\")\n return channel\n else:\n getLogger().error(f\"Giving up connecting to RabbitMQ: {self.connection_params}\")\n raise exceptions.ConnectionFailed",
"def reconnecting(self) -> bool:",
"def _r_on_connection_lost(self, protocol):\n del self._connections[protocol.id]",
"def close_connection(self):\n super().close_session()",
"def on_channel_closed(self, channel, reply_code, reply_text):\n self.logger.warning('channel closed: %s: %s', reply_code, reply_text)\n self._channel = None\n if not self._stopping:\n # this wasn't supposed to happen\n self._connection.close()",
"def reconnect(self):\n while True:\n try:\n log.info('try to reconnect %s' % self._conf.hosts)\n self.close()\n self.connect()\n self.client().admin.command('ismaster')\n return\n except Exception as e:\n log.error('reconnect failed: %s' % e)\n time.sleep(1)",
"def connectionLost(reason):",
"async def close(self):\n self.debug(\"Closing connection\")\n self.real_local_key = self.local_key\n if self.heartbeater is not None:\n self.heartbeater.cancel()\n try:\n await self.heartbeater\n except asyncio.CancelledError:\n pass\n self.heartbeater = None\n if self.dispatcher is not None:\n self.dispatcher.abort()\n self.dispatcher = None\n if self.transport is not None:\n transport = self.transport\n self.transport = None\n transport.close()",
"def connection_timedout(self):\n\n try:\n message = (\n f\"Connection to {self.channel} timed out, was the channel\"\n \" spelt correctly and is port 6667 open?\\n\"\n )\n self.send_to_outputfield(message)\n except Exception as e:\n logging.error(str(e))\n logging.exception(\"Exception : \")\n self.close()",
"def clientConnectionLost(self, connector, reason):\n time.sleep(30)\n connector.connect()",
"def _disconnect(self):\n self._factory.stopTrying()\n self._connection.disconnect()",
"def _connection_lost(self, link_uri, msg):\n\t\tprint \"Connection to %s lost: %s\" % (link_uri, msg)\n\t\t#print results",
"def close_connection(self, connection):\n pass",
"def disconnect(self) -> None:\n try:\n self.s.close()\n except OSError as e:\n logging.exception(e)",
"def close_connection(self):\r\n if self.conn:\r\n self.conn.close()",
"def clientConnectionLost(self, connector, reason):\n # This flag tells us if Cardinal was told to disconnect by a user. If\n # not, we'll attempt to reconnect.\n if not self.disconnect:\n self.logger.info(\n \"Connection lost (%s), reconnecting in %d seconds.\" %\n (reason, self.minimum_reconnection_wait)\n )\n\n # Reset the last reconnection wait time since this is the first\n # time we've disconnected since a successful connection and then\n # wait before connecting.\n self.last_reconnection_wait = self.minimum_reconnection_wait\n time.sleep(self.minimum_reconnection_wait)\n connector.connect()\n else:\n self.logger.info(\n \"Disconnected successfully (%s), quitting.\" % reason\n )\n\n reactor.stop()",
"def connectionLost(self, reason):\n self.factory.loader.db.session.commit()\n if reactor.running:\n reactor.stop()"
] | [
"0.72513586",
"0.7179087",
"0.7149396",
"0.70594245",
"0.6951189",
"0.6929702",
"0.69085944",
"0.6851485",
"0.6758257",
"0.6698265",
"0.65894914",
"0.65487945",
"0.654612",
"0.652902",
"0.65252477",
"0.65175503",
"0.65148693",
"0.650336",
"0.6501206",
"0.64962",
"0.64569867",
"0.6439214",
"0.64217234",
"0.6393424",
"0.63917845",
"0.63645095",
"0.63618064",
"0.63170576",
"0.6313807",
"0.6302205",
"0.62992775",
"0.62879556",
"0.6268829",
"0.62627965",
"0.62535894",
"0.62507814",
"0.62328124",
"0.6231287",
"0.620598",
"0.61482954",
"0.6127998",
"0.61273956",
"0.6125051",
"0.6109176",
"0.6074326",
"0.6072508",
"0.6069014",
"0.6064202",
"0.60540277",
"0.60489976",
"0.60460883",
"0.6043267",
"0.6042359",
"0.6041379",
"0.6040653",
"0.6025014",
"0.60236114",
"0.6010805",
"0.6005568",
"0.60034263",
"0.59959376",
"0.5995513",
"0.5993114",
"0.59920186",
"0.5989296",
"0.5976745",
"0.597383",
"0.5973097",
"0.5967587",
"0.59648675",
"0.59591794",
"0.5958203",
"0.5954991",
"0.59505934",
"0.59439296",
"0.5942596",
"0.5939899",
"0.59291315",
"0.5927255",
"0.592681",
"0.59246016",
"0.59222627",
"0.59174263",
"0.59135705",
"0.5909871",
"0.5907042",
"0.5889818",
"0.5887189",
"0.5882317",
"0.5875652",
"0.58750844",
"0.58734566",
"0.58644336",
"0.5864141",
"0.5857378",
"0.5848323",
"0.5847014",
"0.5844631",
"0.58381885",
"0.58344173"
] | 0.6745841 | 9 |
Will be invoked if the connection can't be opened or is closed. Indicates that a reconnect is necessary then stops the ioloop. | def reconnect(self):
self.should_reconnect = True
self.stop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconnect(self):\n # This is the old connection IOLoop instance, stop its ioloop\n self._connection.ioloop.stop()\n\n if not self._closing:\n # Create a new connection\n self._connection = self.connect()\n\n # There is now a new connection, needs a new ioloop to run\n self._connection.ioloop.start()",
"def reconnect(self):\n # This is the old connection IOLoop instance, stop its ioloop\n self._connection.ioloop.stop()\n\n if not self._closing:\n # Create a new connection\n self._connection = self.connect()\n # There is now a new connection, needs a new ioloop to run\n self._connection.ioloop.start()",
"def on_connection_closed(self, _unused_connection, reason):\n self._channel_ctrl = None\n self._channel_task = None\n if self._closing:\n self._connection.ioloop.stop()\n else:\n # LOGGER.warning('Connection closed, reconnect necessary: %s', reason)\n self.reconnect()",
"def force_reconnect(self):\r\n self.socket.close()",
"def _on_connection_close(self):\n print(\"connection was closed, reconnecting...\")\n self.connect()",
"def stopConnecting(self):\n self.failIfNotConnected(error.UserError())",
"def connection_lost(self, exc):\n logger.info('The server closed the connection')\n self.loop.stop()",
"def connection_closed(self):\n self.atv = None\n self._start_connect_loop()\n self._update_state(disconnected=True)",
"def reconnect(self):\n raise NotImplementedError()",
"def on_connection_closed(self, connection, reply_code, reply_text):\n self._channel = None\n if self._closing:\n self._connection.ioloop.stop()\n else:\n logger.warning('Connection closed, reopening in 5 seconds: (%s) %s',\n reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"def on_connection_closed(self, connection, reply_code, reply_text):\n\n self._channel = None # there cannot be a channel, since the connection holding it was shut down\n if self._closing:\n # we are trying to stop. Just do so.\n self._connection.ioloop.stop()\n else:\n # this is unexpected. Restart the connection (after a timeout)\n self.logger.warning('The connection closed: %s:%s - retrying', reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"def stop(self):\n if self._connected:\n self._client.loop_stop()\n self._client.disconnect()\n self._connected = False\n logger.info(\"Connection with MQTT Broker closed.\")",
"def on_connection_closed(self, connection, reply_code, reply_text):\n if self._closing:\n self._connection.ioloop.stop()\n else:\n self.logger.warning(\n 'Connection closed, reopening in 5 seconds: (%s) %s',\n reply_code, reply_text)\n self._connection.add_timeout(self.CONNECTION_TIMEOUT_SEC,\n self.reconnect)",
"def on_connection_open_error(self, _unused_connection, err):\n # LOGGER.error('Connection open failed: %s', err)\n self.reconnect()",
"def reconnect(self):\n # only used for sending:\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n\n self._connection.ioloop.stop()\n self._connection.connect()\n self._connection.ioloop.start()",
"async def _reconnect(self):\n # pylint: disable=broad-except\n while self._state != const.STATE_CONNECTED:\n try:\n await self._connect()\n self._reconnect_task = None\n return\n except Exception as err:\n # Occurs when we could not reconnect\n _LOGGER.debug(\"Failed to reconnect to %s: %s\", self.host, err)\n await self._disconnect()\n await asyncio.sleep(self._reconnect_delay)\n except asyncio.CancelledError:\n # Occurs when reconnect is cancelled via disconnect\n return",
"def reconnect(self):\n self.__connection.reconnect()",
"def disconnect(self):\n _error = None\n try:\n self.connection.shutdown()\n except Exception as e:\n log.error(e, exc_info=True)\n _error = 'disconnect error: %s' % e\n finally:\n if _error is not None and config.DEBUG_TO_CONSOLE:\n print (_error)\n self.is_connected = False\n self.connection = None",
"def connection_closed(self) -> bool:",
"def stop(self):\n if not self._closing:\n self._closing = True\n if self._consuming:\n self.stop_consuming()\n self._connection.ioloop.start()\n else:\n self._connection.ioloop.stop()",
"def close_connection(self):\r\n self.running = False\r\n self.client_socket.close()",
"def reconnect(self):\n self.close()\n self.connect()",
"def on_connection_closed(self, connection, *args):\n self.logger.debug(\"Connection %s closed: %s\", connection, args)\n self._connection.ioloop.stop()",
"async def _auto_reconnect(self):\n while True:\n await asyncio.sleep(10)\n try:\n await self.connect()\n return\n except CannotConnect:\n pass",
"def DisconnectReuseSocket(self) -> bool:",
"def stop(self):\n self.logger.info('stopping')\n self._stopping = True\n if self._channel:\n self._channel.close()\n self._closing = True\n self._connection.close()\n self._connection.ioloop.start()\n self.logger.info('stopped')",
"def reconnect(self):\n try:\n try: self.exit()\n except Exception, ex: handle_exception()\n self.reconnectcount += 1\n logging.warn('%s - reconnecting .. sleeping %s seconds' % (self.name, self.reconnectcount*15))\n time.sleep(self.reconnectcount * 15) \n self.doreconnect()\n except Exception, ex: \n handle_exception()",
"def _on_disconnection(self, *_):\n\n if self._proxy is not None:\n self._proxy.close()\n self._proxy = None",
"def connectionLost(self, reason):\n print \"lost connection to\", host, \"port\", port\n reactor.stop()",
"def on_connection_open_error(self, _unused_connection, err):\n self.logger.info('Connection open failed: %s', err)\n self.reconnect()",
"def connection_lost(self, exc):\n if self._closing:\n return\n self._closing = True\n\n # inform yielding readers about closed connection\n if exc is None:\n logger.info(\"Connection closed for %s\", self)\n self.reader.feed_eof()\n else:\n logger.info(\"Connection lost for %s: %s\", self, exc)\n self.reader.set_exception(exc)\n\n # cancel protocol tasks, namely on-connect negotiations\n for task in self._tasks:\n task.cancel()\n\n # close transport (may already be closed), set _waiter_closed and\n # cancel Future _waiter_connected.\n self._transport.close()\n self._waiter_connected.cancel()\n if self.shell is None and self._waiter_closed is not None:\n # raise deprecation warning, _waiter_closed should not be used!\n self._waiter_closed.set_result(weakref.proxy(self))\n\n # break circular references.\n self._transport = None",
"def connectionLost(self, reason):\n print \"connection lost from\", self.addr\n reactor.stop()",
"def test_clientConnectionFailedStopsReactor(self):\n reactor = self.buildReactor()\n needsRunningReactor(reactor, lambda: self.connect(reactor, Stop(reactor)))\n self.runReactor(reactor)",
"def connection_lost(self, exc):\n self._log.warn(\"Serial Connection Lost\")\n self.transport = None\n self.onReady(False)",
"def abortConnection():\n pass",
"def close(self):\r\n if self.connected:\r\n #self.onClose()\r\n self.con.close()\r\n self._close() # Reset the thread and connection, and stop all sounds playing through the output.\r\n else:\r\n raise UserError(errors['NotConnectedYet'])",
"def connection_lost(self, exc) -> None:\n # We can assert these because this should never get called\n # before self.connection_made which sets these:\n assert self.transport is not None\n assert self.task is not None\n logging.info(\"Server: Connection lost.\")\n self.task.cancel()\n self.transport.close()",
"def disconnect(self):\n logger.debug(\"disconnecting\")\n if self.connected and self.conn:\n self.can_listen = False\n self.conn.close()\n self.connected = False",
"def _recover_network_failure(self):\n if self.auto_reconnect and not self._is_closing:\n connected = False\n while not connected:\n log_msg = \"* ATTEMPTING RECONNECT\"\n if self._retry_new_version:\n log_msg = \"* RETRYING DIFFERENT DDP VERSION\"\n self.ddpsocket._debug_log(log_msg)\n time.sleep(self.auto_reconnect_timeout)\n self._init_socket()\n try:\n self.connect()\n connected = True\n if self._retry_new_version:\n self._retry_new_version = False\n else:\n self._is_reconnecting = True\n except (socket.error, WebSocketException):\n pass",
"def reconnect(self):\n self.test_cmd()\n if not self.check_network: \n self.reset()\n attempt=0\n while not self.check_network and attempt<self.retries:\n self.full_reset()\n attempt+=1",
"async def connection_lost(self):\n logging.info('connection dropped')",
"def close(self):\n if self.verbose:\n print \"Disconnecting from \", self.IP_address\n if self.leicasocket is not None:\n try:\n self.leicasocket.close()\n self.connected=False\n return True\n except:\n print \"Error closing connection. Did you pass in the correct socket object ?\"\n return False",
"async def _handle_connection_error(self, error: Exception = \"hearbeat\"):\n if self._reconnect_task:\n return\n await self._disconnect()\n if self._auto_reconnect:\n self._state = const.STATE_RECONNECTING\n self._reconnect_task = asyncio.create_task(self._reconnect())\n else:\n self._state = const.STATE_DISCONNECTED\n\n _LOGGER.debug(\"Disconnected from %s: %s\", self.host, error)\n self._avr.dispatcher.send(const.SIGNAL_TELNET_EVENT, const.EVENT_DISCONNECTED)",
"def attempt_reconnect(self):\n time.sleep(self.reconnect_delay)\n self.connect_to()",
"def reconnect(self, seconds: int) -> None:",
"def _disconnect(self):\n self._factory.stopTrying()\n self._connection.disconnect()",
"def shutdown(self):\n if self.alive:\n libplasma.disconnect(self.conn)\n self.alive = False",
"async def close_connection(self):\n\t\t...",
"def run(self):\n try:\n while True:\n self.__listen()\n except (ConnectionResetError, ConnectionAbortedError):\n self.session.close()\n return",
"def reconnecting(self) -> bool:",
"def connectionLost(self, reason):\n if not self.connected:\n self.failIfNotConnected(error.ConnectError(string=reason))\n else:\n self.disconnected = 1\n self.connected = 0\n # self._closeSocket()\n protocol = self.protocol\n del self.protocol\n protocol.connectionLost(reason)\n self.connector.connectionLost(reason)\n self.connectionLostDefer.callback(1)",
"def connection_lost(self, exc):\n if not self._closing:\n self._closing = True\n self.log.info('{about}{reason}'.format(\n about=self.__str__(),\n reason=': {}'.format(exc) if exc is not None else ''))\n self.waiter_connected.cancel()\n self.waiter_closed.set_result(self)",
"def reconnect(self) -> bool:\n self.log.debug(\"Attempting reconnect\")\n if self._connected:\n self.client.loop_stop()\n self.client.disconnect()\n\n return self.connect()",
"def connection_lost(self, exc):\n if self._stream.done:\n # Stream is done, no need to panic\n pass\n else:\n self._logger.debug('[%s] Connection lost!', self._sock_id, exc_info=exc)",
"def clientConnectionLost(self, connector, reason):\n time.sleep(30)\n connector.connect()",
"def on_disconnect(unused_client, unused_userdata, rc):\n\tprint('on_disconnect', error_str(rc))\n\n\t# Since a disconnect occurred, the next loop iteration will wait with\n\t# exponential backoff.\n\tglobal should_backoff\n\tshould_backoff = True",
"def _on_close(self):\n self.web_socket_open = False\n self.logged_in = False\n print(\"WebSocket Closed for \" + self.session_name)\n\n if not self.disconnected_by_user:\n print(\"Reconnect to the endpoint for \" + self.session_name + \" after 3 seconds... \")\n time.sleep(3)\n self.connect()",
"def clientConnectionLost(self, connector, reason):\n\n print(\"Disconnected from the server\") # client console notification\n reactor.callFromThread(reactor.stop) # reactor shutdown",
"def clientConnectionFailed(self, connector, reason):\n\n print(\"Connection failed\") # client console notification\n reactor.callFromThread(reactor.stop) # reactor shutdown",
"def end(self):\n if self.conn:\n self.conn.close()\n self.conn = None\n #print(\"closed.\")",
"def close_connection(self):\n if self.socket:\n self.socket.close()",
"def close_connection(self):\r\n if self.conn:\r\n self.conn.close()",
"def stop(self):\n self.logger.debug(\"Stopping request consumer\")\n self._connection.ioloop.add_callback_threadsafe(partial(self._connection.close))",
"def attempt_to_connect(self):\n if self.server_handler.attempt_connection:\n self.server_handler.attempt_connection = False\n else:\n self.server_handler.attempt_connection = True",
"def disconnected(self):\n\n self.fire(connect(self.host, self.port))",
"def close(self):\n if self._conn:\n logger.info(\"close connection.\")\n self._conn.unbind_s()",
"def reconnect(self):\n try:\n self.redis = Redis(self.servers, self.port, self.db)\n except Exception, e:\n print e",
"def _connect_failed(self):\n\t\tself.root.stdout.write(\"Error: Connection Failed!\\n\")\n\t\tself.client = False",
"async def on_disconnect(self, reconnecting):\n pass",
"def restart(self):\r\n self._safe_close()\r\n self._stopped.clear()\r\n self.reconnect()",
"def failIfNotConnected(self, err):\n if (self.connected or self.disconnected or\n not hasattr(self, \"connector\")):\n return\n\n self.connector.connectionFailed(failure.Failure(err))\n del self.connector\n self.connectionFailedDefer.callback(1)",
"def closed(self, code, reason=None):\n self.logger.info(\n \"Socket connection closed {0}:{1}\".format(code, reason))\n self._heartbeats.stop_heartbeats()\n self._disconnect_handler()",
"def checkConnection(self,msg):\n if (len(msg) == 0):\n sleep(self.m_to/2)\n print >>sys.stderr, 'Closing due to possible server fault'\n self.close()",
"def terminate_connection(self, volume, connector, is_mirror=False):\n return super(HBSDRESTISCSI, self).terminate_connection(\n volume, connector)",
"def connectionLost(reason):",
"def disconnect(self):\r\n try:\r\n self.connection.close()\r\n print (\"disconnected!\")\r\n except Exception as error:\r\n print (\"disconnect() - error - {}\".format(error))",
"def _close_connection(self):\n if self.connection:\n self.connection.destroy()\n self.connection = None",
"def try_reconnect_handler(connected_successfully: bool):\n if not connected_successfully:\n safe_print(print_mutex, \"Server connection failed. Trying to reconnect...\")\n else:\n safe_print(print_mutex, \"Connected to server again.\")",
"async def reconnect(self) -> None:\n\n if self._state in [self._CONNECTING, self._RECONNECTING]:\n logger.debug(\"Already (re-)connecting, waiting for it to finish...\")\n async with self._connected_condition:\n await self._connected_condition.wait()\n\n logger.debug(\"(Re-)connected, finished waiting\")\n return\n\n if self._state != self._RUNNING:\n raise IncorrectStateException((\"reconnect() may not be called while\"\n \" the connection is not running.\"))\n\n # Disconnecting via task because otherwise, the _connected_condition\n # might fire before we start waiting for it.\n #\n # The event loop will reconenct after the ws connection has been\n # disconnected.\n logger.debug(\"Disconnecting and letting the event loop reconnect\")\n await self._disconnect()",
"def _lost_connection(self, delay=0):\n _LOGGER.warning(\"PyISY lost connection to the ISY event stream.\")\n self.isy.connection_events.notify(ES_LOST_STREAM_CONNECTION)\n self.unsubscribe()\n if self._on_lost_function is not None:\n time.sleep(delay)\n self._on_lost_function()",
"def __connection_lost(self):\n print(\"Error: connection lost.\")\n try:\n # Try and send a message back to the server to notify connection\n # lost\n self.client_socket.send(\"q\".encode())\n except:\n pass\n # Raise an error to finish\n raise Exception",
"def stop(self):\n self.conn.stop()",
"def shutdown(self):\n self._msg_disp.abort()\n self._conn_mgr.shutdown_connections()",
"def reconnect(self, failure=None):\n self.disconnect()\n if not self.error:\n if self.reconnect_count < self.reconnect_max:\n self.reconnect_count += 1\n delay = self.reconnect_delay * self.reconnect_count\n logger.info(\"reconnecting in %d seconds\" % delay)\n time.sleep(delay)\n self.listen()\n return True\n self.error = 'Maximum reconnect attempts reached'\n logger.fatal(self.error)",
"def shutdown(self):\n self.connected = False\n self.protocol.send_message(self.sock, '__!shutdown__')\n data = self.protocol.recover_message(self.sock)\n self.sock.close()\n self.sock = None",
"def watchdog(self, loop):\n while True:\n if (self.reconnect_time > 0 and \n time.time() - self.reconnect_time > 60):\n\n self.logger.error(\n \"Could not reconnect to MQTT broker after 60s\")\n loop.stop()\n break\n else:\n yield from asyncio.sleep(1)",
"def clientConnectionLost(self, connector, reason):\n connector.connect()",
"def clientConnectionLost(self, connector, reason):\n connector.connect()",
"def clientConnectionLost(self, connector, reason):\n connector.connect()",
"def clientConnectionLost(self, connector, reason):\n connector.connect()",
"def connection_remote_closed(self, connection, pn_condition):\n assert len(self.receivers) == 0\n self.connection.close()",
"def should_reconnect(self):\n if not self.by_remote:\n if self.code == 1006:\n if self.reason == 'Abnormal closure':\n return True\n \n return False",
"def on_channel_closed(self, *args, **kwargs):\n if not self._normal_close:\n self.log.warning(\n 'Channel closed. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def loseConnection(self):\n self.transport.loseConnection()",
"def _on_connection_error(self, exception):\n print(\"connection failed: {}\".format(exception))\n time.sleep(1)\n self.connect()",
"def disconnect(self) -> None:\n try:\n self.s.close()\n except OSError as e:\n logging.exception(e)",
"def test_startconnector_with_noretry_on_con_failure(self):\n\n yield self.connect('127.0.0.1', self.pbPort)\n\n localConfig = copy.copy(self.defaultConfig)\n localConfig.reconnectOnConnectionFailure = False\n yield self.add(localConfig)\n yield self.start(localConfig.id)\n\n # It takes a moment to stop the service after a connection failure\n while True:\n ssRet = yield self.service_status(localConfig.id)\n if ssRet != 1:\n break;\n else:\n time.sleep(1)\n\n self.assertEqual(0, ssRet)\n\n yield self.stop(localConfig.id)",
"def connection_lost(self, exc: Optional[Exception]) -> None:\n self.listener.handle_connection_lost(exc)",
"def on_connection_closed(self):",
"def _r_on_connection_lost(self, protocol):\n del self._connections[protocol.id]"
] | [
"0.7249165",
"0.72301304",
"0.7075581",
"0.6911849",
"0.6774475",
"0.67738265",
"0.67159784",
"0.67140543",
"0.6647249",
"0.66425675",
"0.6637142",
"0.66236544",
"0.66109645",
"0.66052055",
"0.65366995",
"0.65227723",
"0.6449884",
"0.6439589",
"0.6395996",
"0.63703144",
"0.63626593",
"0.63522243",
"0.6349202",
"0.63424313",
"0.6332475",
"0.6322036",
"0.63137966",
"0.63091034",
"0.630417",
"0.6285324",
"0.6277426",
"0.62554425",
"0.62539583",
"0.6238141",
"0.62340724",
"0.62260556",
"0.6207876",
"0.6194281",
"0.61754847",
"0.61650145",
"0.6156403",
"0.6140269",
"0.61315376",
"0.611344",
"0.6109293",
"0.6096925",
"0.6096203",
"0.60958856",
"0.60926706",
"0.60920966",
"0.606366",
"0.6060531",
"0.6054637",
"0.6053017",
"0.60463864",
"0.60411423",
"0.6036758",
"0.6024016",
"0.602262",
"0.6018547",
"0.6018244",
"0.6006013",
"0.6002802",
"0.5998726",
"0.5998638",
"0.59901136",
"0.59889525",
"0.59871674",
"0.5985117",
"0.5975084",
"0.5967474",
"0.59656173",
"0.5955903",
"0.5936851",
"0.5928814",
"0.5927593",
"0.59271216",
"0.592663",
"0.592613",
"0.5926068",
"0.59232646",
"0.59224004",
"0.59214777",
"0.5915141",
"0.5915008",
"0.59125894",
"0.5911071",
"0.5911071",
"0.5911071",
"0.5911071",
"0.5908951",
"0.5904394",
"0.5904044",
"0.5903414",
"0.5903151",
"0.5902509",
"0.59024197",
"0.59021866",
"0.5898351",
"0.58976173"
] | 0.69579345 | 3 |
Open a new channel with RabbitMQ by issuing the Channel.Open RPC command. When RabbitMQ responds that the channel is open, the on_channel_open callback will be invoked by pika. | def open_channel(self):
# LOGGER.info('Creating a new channel')
self._connection.channel(on_open_callback=self.on_channel_task_open)
self._connection.channel(on_open_callback=self.on_channel_ctrl_open) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_channel(self):\n logger.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_open)",
"def open_channel(self):\n self.logger.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_open)",
"def open_channel(self):\n self.logger.info('creating channel')\n self._connection.channel(on_open_callback=self.on_channel_opened)",
"def channel_open(self):\n self._chan = self._session.invoke_shell()",
"def on_channel_open(self, channel):\n self.logger.debug(\"Channel opened: %s\", channel)\n\n self._channel = channel\n self._channel.add_on_close_callback(self.on_channel_closed)\n\n self.start_consuming()",
"def open(self):\n if self._is_open():\n return\n\n channel = api.Api.ssh_channel_new(self._session)\n if channel is None:\n raise exceptions.ChannelException(\"Channel cannot be created: {}\".format(self.get_error_message()))\n\n ret = api.Api.ssh_channel_open_session(channel)\n if ret != api.SSH_OK:\n raise exceptions.ChannelException(\"Channel cannot be opened: {}\".format(self.get_error_message()))\n\n self._channel = channel",
"def channel(self):\n\n self._channel = self._connection.channel()\n print(\"Channel opened...\")",
"def on_channel_open(self, channel):\n self.logger.info('Channel opened')\n self._channel = channel\n self.add_on_channel_close_callback()",
"def on_channel_open(self, new_channel):\n\t\tself.channel = new_channel\n\t\tself.declare_queue(self.on_queue_declared)",
"def open_channel(self, timeout=120):\n if self.get_channel_count() < self.MAX_CHANNELS and self.is_connected():\n try:\n channel = self.get_client().invoke_shell()\n channel.settimeout(timeout)\n self.add_channel(channel)\n return channel\n except error as e:\n print(\"opening channel error\")\n self._error = e\n # return None",
"def on_channel_open(self, channel):\n logger.info('Channel opened')\n self._channel = channel\n self._channel.basic_qos(prefetch_count=\n self.DEFAULT_PREFETCH_COUNT)\n self.add_on_channel_close_callback()\n self.setup_queues_and_bindings()",
"def _open(self):\n if self.channel is None:\n self.channel = self.transport.open_session()\n\n return self.channel",
"def on_channel_opened(self, channel):\n self.logger.info('channel opened')\n self._channel = channel\n\n self.logger.info('adding channel close callback')\n self._channel.add_on_close_callback(self.on_channel_closed)\n\n self.setup_exchange()",
"def on_open_channel(new_channel):\n # assign new channel to the global channel variable\n global channel\n channel = new_channel\n\n # channel is assigned and declare a queue named scripbox.\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\n # Pass a callback on_queue_declared which fires when a queue declaration\n # is successful\n channel.queue_declare(queue='scripbox', durable=True,\n auto_delete=False, callback=on_queue_declared)",
"def channelOpen(self, specificData):\n log.msg('opened forwarding channel %s to %s:%s' % (self.id, self.host, self.port))\n self._connectDone()",
"def _on_channel_open(self, channel_id: str) -> None:\n self._send_alive(channel_id)",
"def open_channel(config_file):\n server_ip, port, channel_name, content_type = get_channel_config(config_file)\n channel = PresenterChannel(server_ip, port, channel_name, content_type)\n ret = channel.startup()\n if ret:\n log_error(\"ERROR:Open channel failed\")\n return None\n return channel",
"def on_connection_open(self, connection):\n self.logger.debug(\"Connection opened: %s\", connection)\n self.open_channel()",
"def on_primary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_primary_channel = ch\n \n # For receiving confirmations...\n if self.receive_delivery_confirmations:\n self.amqp_primary_channel.confirm_delivery(callback=self.on_delivered, nowait=True)\n \n # Declare 'IN' queue - for receiving items to queue\n self.amqp_primary_channel.queue_declare(queue=self.amqp_in_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_in_queue_declared)\n \n # Declare 'fanout' exchange - for broadcasting items\n # The fanout exchange is very simple. It just broadcasts all the\n # messages it receives to all the queues it knows.\n self.amqp_primary_channel.exchange_declare(exchange=self.amqp_broadcast_exchange, type='fanout',\n callback=self.on_exchange_declared)",
"def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)",
"def _create_channel(self):\n self.connection = pika.BlockingConnection(self.pikaparams)\n self.channel = self.connection.channel()\n try:\n yield self.channel\n finally:\n self.channel.close()\n self.connection.close()",
"def on_connected(self, connection):\n\t\t# Open a channel\n\t\tconnection.channel(self.on_channel_open)",
"def on_connection_open(self, unused_connection):\n logger.info('Connection opened')\n self.add_on_connection_close_callback()\n self.open_channel()",
"def test_open_via_channel(testchannel, callit):\n\n channel = testchannel.channel() if callit else testchannel.channel\n\n with channel as t:\n assert t.state == ChannelState.open\n\n assert testchannel.state == ChannelState.closed",
"def on_channel_task_open(self, channel):\n # LOGGER.info('Channel opened')\n self._channel_task = channel\n self._channel_task.add_on_close_callback(self.on_channel_closed)\n channel.queue_declare(\n queue=self.queue_task,\n durable=False,\n exclusive=False\n )\n channel.basic_qos(prefetch_count=self._prefetch_count)\n self._init_ok_task = True",
"def new_channel(self, *args, **kwargs):\n logger.debug('creating channel -> connection.channel(%r, %r)' % (args, kwargs))\n if self.enabled:\n channel = self.connection.channel(*args, **kwargs)\n self._channels.append(channel)\n return channel\n else:\n return None",
"def on_connected(connection):\n # open a channel\n connection.channel(on_open_channel)",
"def on_channel_ctrl_open(self, channel):\n # LOGGER.info('Channel opened')\n self._channel_ctrl = channel\n self._channel_ctrl.add_on_close_callback(self.on_channel_closed)\n self._channel_ctrl.basic_qos(prefetch_count=1)\n self.setup_exchange()",
"def on_connection_open(self, unused_connection):\n self.logger.info('Connection established!')\n self.open_channel()",
"def on_connection_open(self, unused_conncetion):\n self.logger.info('connection opened, adding connection close callback')\n self._connection.add_on_close_callback(self.on_connection_closed)\n self.open_channel()",
"def on_connected(connection):\n # Open a channel\n connection.channel(on_channel_open)",
"def connect(self):\n logger.info(\"[{}] Connecting to exchange {}\".format(self.bot_id, self.exchange))\n creds = pika.PlainCredentials(self.rabbit_user, self.rabbit_pw)\n return pika.SelectConnection(pika.ConnectionParameters(host=self.rabbit_host,\n port=self.rabbit_port,\n virtual_host='/',\n credentials=creds,\n socket_timeout=1,\n retry_delay=5 # 5 seconds\n ),\n self.on_connection_open,\n stop_ioloop_on_close=False)",
"def _connect(self):\n hostport = self.getHost()\n channelOpenData = forwarding.packOpen_direct_tcpip((self.host, self.port), (hostport.host, hostport.port))\n self.connector.connection.openChannel(self, channelOpenData)",
"def create_connection(self):\n if self.conn:\n raise Exception(\"Connection already open\")\n cfg = self.config[self.MODULE_NAME]['amqp']['connection']\n log.debug(str(cfg))\n self.conn = pika.AsyncoreConnection(pika.ConnectionParameters(\n credentials = pika.PlainCredentials(cfg['login'],cfg['password']), \n heartbeat=cfg['heartbeat'],\n virtual_host=cfg['vhost'],\n port=cfg['port'],\n host=cfg['host']))\n self.channel = self.conn.channel()\n\n self._setup_tubes()",
"def test_open_state(testchannel):\n\n with testchannel.open() as t:\n assert t.state == ChannelState.open\n\n assert testchannel.state == ChannelState.closed",
"def channel(self):\n if not hasattr(self, '_channel'):\n self._channel = self.new_channel()\n return self._channel",
"def connect(self):\n if self._connection is not None:\n self.logger.debug('Using allready existing connection [{}]'.format(\n self._connection))\n # Create a new communication channel\n self._channel = self._connection.channel()\n return True\n try:\n # Create a new connection\n self.logger.debug(\n 'Connecting to AMQP broker @ [{}:{}, vhost={}]...'.format(\n self.connection_params.host,\n self.connection_params.port,\n self.connection_params.vhost))\n self.logger.debug('Connection parameters:')\n self.logger.debug(self.connection_params)\n self._connection = AMQPConnection(self.connection_params)\n # Create a new communication channel\n self._channel = self._connection.channel()\n self.logger.info(\n 'Connected to AMQP broker @ [{}:{}, vhost={}]'.format(\n self.connection_params.host,\n self.connection_params.port,\n self.connection_params.vhost))\n except pika.exceptions.ConnectionClosed:\n self.logger.debug('Connection timed out. Reconnecting...')\n return self.connect()\n except pika.exceptions.AMQPConnectionError:\n self.logger.debug('Connection error. Reconnecting...')\n return self.connect()\n except Exception as exc:\n self.logger.exception('')\n raise (exc)\n return self._channel",
"def open_channel(from_name, to_name):\n sc = SecureChannel(from_name, to_name)\n sc.network_factory = NetworkFactory(CONFIG_FILE)\n return sc",
"def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel",
"def _connect(self) -> BlockingChannel:\n for _ in range(self.retry):\n getLogger().info(\"Trying to connect to RabbitMQ ...\")\n try:\n connection = pika.BlockingConnection(self.connection_params)\n channel = connection.channel()\n channel.exchange_declare(self.exchange_name, 'direct', durable=True)\n channel.basic_qos(prefetch_count=self.prefetch)\n channel.queue_declare(\n self.queue_name, durable=True\n )\n channel.queue_bind(self.queue_name, self.exchange_name, self.binding_key)\n except (AMQPConnectionError, ChannelError) as e:\n getLogger().error(f\"Connection to RabbitMQ failed {e}\")\n sleep(self.retry_interval)\n else:\n getLogger().info(\"Connected to RabbitMQ\")\n return channel\n else:\n getLogger().error(f\"Giving up connecting to RabbitMQ: {self.connection_params}\")\n raise exceptions.ConnectionFailed",
"def get_channel(self):\n if self.channel is None or not self.channel.is_open:\n if not self.connection.is_open:\n self.connection = CONNECTION_MANAGER.get_connection(self.connection_name)\n self.channel = self.connection.channel()\n return self.channel",
"def __init__(self):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n self.channel = self.connection.channel()",
"def _comm_open(self, comm, msg):\n self.calling_comm_id = comm.comm_id\n self._register_comm(comm)\n self._set_pickle_protocol(\n msg['content']['data']['pickle_highest_protocol'])\n\n # IOPub might not be connected yet, keep sending messages until a\n # reply is received.\n self._pending_comms[comm.comm_id] = comm\n self._notify_comm_ready(comm)\n self.kernel.io_loop.call_later(.3, self._check_comm_reply)",
"def on_secondary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_secondary_channel = ch\n \n # Declare 'IN' queue - for receiving confirmations\n self.amqp_secondary_channel.queue_declare(queue=self.amqp_confirm_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_confirm_queue_declared)",
"def test_open_alreadyopen(testchannel, state):\n\n testchannel._state = state\n with pytest.raises(ChannelOpenError):\n testchannel.open()",
"def _connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.exchange_declare(exchange=self.exch, type=\"topic\", durable=True, auto_delete=False,)\n self.log(\"%conn-open\", \"info\", \"Connection to AMQP broker opened\")\n except Exception,e:\n self.log(\"%conn-error\", \"error\", \"Error whilst connecting to AMQP broker (%s)\" % e)\n self.closeConn()",
"async def on_channel_create(self, channel):\n if channel.is_private:\n return\n\n role = await self.get_role(channel.server)\n if not role:\n return\n\n await self.setup_channel(channel, role)",
"def open(self, *args, **kwargs):\n self._open = True\n self._stat.websocket_stream_open += 1\n # Create subscription for the stream\n url = self.request.uri\n self._logger.info(\"Websocket connection %s %s\", url, self)\n\n async_future = asyncio.async(\n self.netconf_subscribe(\n self.request.uri,\n self.request.headers.get(\"Authorization\")), \n loop=self._asyncio_loop)\n yield tornado.platform.asyncio.to_tornado_future(async_future)",
"def open(self):\n self.__port.open()",
"def Open(self):\n if self.writer is None:\n self.writer = self.IO.Open(self.channel_name, adios2.Mode.Write)",
"def connect(self):\n\n if settings.DEBUG:\n parameters = pika.ConnectionParameters(self._host)\n else:\n credentials = pika.PlainCredentials(\n username=settings.RABBITMQ_USERNAME,\n password=settings.RABBITMQ_PASSWORD\n )\n parameters = pika.ConnectionParameters(\n host=self._host,\n port=self._port,\n virtual_host=self._vhost,\n credentials=credentials\n )\n\n try:\n msg = \"Connection established successfully with rabbitmq server !!!\"\n self.connection = pika.BlockingConnection(parameters)\n self.channel = self.connection.channel()\n print(msg)\n logging.info(msg)\n except Exception as e:\n raise RabbitmqConnectionError(str(e))",
"def open_connection(self):\r\n # Open ModBus connection\r\n try:\r\n self.c = ModbusClient(host=self.host, port=self.port,\r\n unit_id=self.unit_id, auto_open=True, auto_close=True)\r\n except ValueError:\r\n print(\"Error with host: {}, port: {} or unit-ID: {} params\".format(\r\n self.host, self.port, self.unit_id))",
"def start(self):\n self.bus.log('Starting up OLA Plugin.')\n self.bus.subscribe(\n self.channel_names['channel_request'],\n self.handle_channel\n )\n self.bus.subscribe(\n self.channel_names['channel_set'],\n self.handle_channel_set\n )\n self.ola_connection.start()",
"def is_open(self, channel=None):\n return self.get_state(channel) == 2",
"async def connect(self):\n self.user = self.scope['user']\n self.room_name = self.scope['url_route']['kwargs']['room_name']\n self.room_group_name = 'chat_{}'.format(self.room_name)\n\n await self.channel_layer.group_add(\n self.room_group_name,\n self.channel_name\n )\n\n await self.accept()",
"def connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\n self.chan.exchange_declare(exchange=self.EXCH, type=\"topic\", durable=True, auto_delete=False,)\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\"ctag\")\n except:\n self.closeConn()",
"def on_open(self) -> None:\n\n channel = [{\"name\": \"level2\", \"product_ids\": list(self.products.keys())}]\n msg_subscribe = {\"type\": \"subscribe\", \"channels\": channel}\n\n subscribe_payload = json.dumps(msg_subscribe)\n self.ws.send(subscribe_payload)",
"def test_start_closed(testchannel):\n with pytest.raises(ChannelClosedError):\n testchannel.start()",
"async def open(self, *args, **kwargs) -> bool:\n\n return await self._open_internal(*args, **kwargs)",
"def open(self):\n if self._connected:\n try:\n self.native.find_prompt()\n except: # noqa E722 pylint: disable=bare-except\n self._connected = False\n\n if not self._connected:\n self.native = ConnectHandler(\n device_type=\"cisco_asa\",\n ip=self.host,\n username=self.username,\n password=self.password,\n port=self.port,\n global_delay_factor=self.global_delay_factor,\n secret=self.secret,\n verbose=False,\n )\n self._connected = True\n\n log.debug(\"Host %s: Connection to controller was opened successfully.\", self.host)",
"def init_app(self):\n LOGGER.info('Launching the init app for the producer')\n\n # Open channel to set the exchange\n channel_handler = ChannelHandler(self._connection)\n channel_handler.open_channel()\n self._channel = channel_handler.get_channel()\n\n # Set the default exchange to use\n exchange_name = 'SIEF'\n exchange_handler = ExchangeHandler(self._channel, exchange_name)\n exchange_handler.setup_exchange()\n self._exchange_name = exchange_handler.get_exchange_name()\n\n channel_handler.close_channel()",
"def channel(self) -> 'Channel': # stub\n return self._channel",
"def open(self):\n self._command = \"open\"",
"def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True",
"def connect(self):\n\n label = self.scope[\"url_route\"][\"kwargs\"][\"label\"]\n self.user = self.scope[\"user\"]\n\n try:\n room = Relationship.objects.get(label=label)\n except Relationship.DoesNotExist:\n log.warning('No relationship have this label=%s', label)\n self.close()\n return\n except Exception as error:\n log.error(\"建立聊天室channel時發生錯誤: %s\" % error)\n self.close()\n return\n\n if not (room.client == self.user or room.performer == self.user):\n log.warning(\n '%s try to connect to the relationship that not belog to him', self.user)\n self.close()\n return\n\n self.scope[\"room\"] = room\n # Accept the incoming connection\n self.accept()\n\n async_to_sync(self.channel_layer.group_add)(\n \"chat\" + str(label), self.channel_name)",
"def open(self, host, port, username, password, compress, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):\n self.ssh_client.connect(host, port, username,\n password, compress=compress, timeout=timeout)\n self.channel = self.ssh_client.invoke_shell(width=65278, height=65278)\n self.ssh_fileno = self.fileno()",
"def is_open(self, channel=None):\n return self.get_state(channel)",
"def test_channel_opened_notification(node_factory):\n opts = [{}, {\"plugin\": os.path.join(os.getcwd(), \"tests/plugins/misc_notifications.py\")}]\n amount = 10**6\n l1, l2 = node_factory.line_graph(2, fundchannel=True, fundamount=amount,\n opts=opts)\n l2.daemon.wait_for_log(r\"A channel was opened to us by {}, \"\n \"with an amount of {}*\"\n .format(l1.info[\"id\"], amount))",
"def connect(self, message, **kwargs):\n # Accept the connection; this is done by default if you don't override\n # the connect function.\n self.message.reply_channel.send({\"accept\": True})",
"def channel(self):\n return Channel({'id': self.channel_id, 'connection': self.connection})",
"def _amqp_bind(self):\n if self.amqp_connection is not None:\n try:\n self.amqp_connection.close()\n except:\n pass\n\n self.amqp_connection = pika.BlockingConnection(\n pika.ConnectionParameters(\n host=self.amqp_server\n )\n )\n\n # listening channel for ermrest change notifications\n self.notice_channel = self.amqp_connection.channel()\n try:\n # newer pika API\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\n except TypeError as te:\n # try older API as fallback\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\n sys.stderr.write('ERMrest change-notice channel open.\\n')",
"def connect(self):\n self.logger.info(\"Connecting to AMQP broker @ [{}:{}] ...\".format(\n self._host, self._port))\n connection = pika.SelectConnection(\n pika.URLParameters(host=self.host, port=self.port),\n on_open_callback=self.on_connection_open,\n on_open_error_callback=self.on_connection_open_error,\n on_close_callback=self.on_connection_closed,\n stop_ioloop_on_close=False)\n self._connection = connection\n return connection",
"def onOpen(self):\n logger.log_msg(\"Discord connection established.\")\n self.factory.bot = self\n\n self.init_session(\"discord\", \"discord.gg\", self.factory.sessionhandler)\n self.uid = int(self.factory.uid)\n self.logged_in = True\n self.sessionhandler.connect(self)",
"def connect(self):\n self._connect()\n if self.conn is not None:\n try:\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\n except:\n self.closeConn()",
"def make_connection(self):\n\n credentials = pika.PlainCredentials(self._username, self._password)\n parameters = pika.ConnectionParameters(self._host, self._port, self._vhost, credentials, socket_timeout=300)\n self._connection = pika.BlockingConnection(parameters)\n print(\"Connected Successfully...\")",
"def create_channel(pvname, connect=False, auto_cb=True, callback=None):\n #\n # Note that _CB_CONNECT (defined above) is a global variable, holding\n # a reference to _onConnectionEvent: This is really the connection\n # callback that is run -- the callack here is stored in the _cache\n # and called by _onConnectionEvent.\n pvn = STR2BYTES(pvname)\n ctx = current_context()\n global _cache\n if ctx not in _cache:\n _cache[ctx] = {}\n if pvname not in _cache[ctx]: # new PV for this context\n entry = {'conn':False, 'chid': None,\n 'ts': 0, 'failures':0, 'value': None,\n 'callbacks': [ callback ]}\n _cache[ctx][pvname] = entry\n else:\n entry = _cache[ctx][pvname]\n if not entry['conn'] and callback is not None: # pending connection\n _cache[ctx][pvname]['callbacks'].append(callback)\n elif (hasattr(callback, '__call__') and\n not callback in entry['callbacks']):\n entry['callbacks'].append(callback)\n callback(chid=entry['chid'], pvname=pvname, conn=entry['conn'])\n\n conncb = 0\n if auto_cb:\n conncb = _CB_CONNECT\n if entry.get('chid', None) is not None:\n # already have or waiting on a chid\n chid = _cache[ctx][pvname]['chid']\n else:\n chid = dbr.chid_t()\n ret = libca.ca_create_channel(pvn, conncb, 0, 0,\n ctypes.byref(chid))\n PySEVCHK('create_channel', ret)\n entry['chid'] = chid\n\n if connect:\n connect_channel(chid)\n if conncb != 0:\n poll()\n return chid",
"def create_channel(uri, loop=None):\n\n if not loop:\n loop = Mainloop()\n\n connection = create_connection(loop, uri)\n chan = Channel(connection)\n return loop, chan",
"def join_channel(self, channel):\r\n self._send('JOIN #%s\\r\\n' % channel)",
"def join(self, channel):\n raise NotImplementedError",
"async def create_channel(self):\n self._logger.info(\"Deploying chaincode...\")\n network_file_path = os.path.join(os.getcwd(), \"network.json\")\n channel_config_path = os.path.join(self.config_path, \"channel-artifacts\", \"channel.tx\")\n\n self.fabric_client = Client(net_profile=network_file_path)\n\n org1_admin = self.fabric_client.get_user(org_name='org1.example.com', name='Admin')\n\n # Create a New Channel, the response should be true if succeed\n response = await self.fabric_client.channel_create(\n orderer='orderer1.example.com',\n channel_name='mychannel',\n requestor=org1_admin,\n config_tx=channel_config_path\n )\n self._logger.info(\"Result of channel creation: %s\", response)",
"def channel(self):\n raise NotImplementedError",
"def join_channel(self) -> None:\n response = self.client.conversations_list()\n for channel in response.data[\"channels\"]:\n if channel[\"name\"] == BaseConfig.SLACK_CHANNEL:\n self.channel_id = channel[\"id\"]\n if not self.channel_id:\n raise Exception(f\"Channel: {BaseConfig.SLACK_CHANNEL} was not found\")\n self.client.conversations_join(channel=self.channel_id)",
"async def channel(self, ctx):\n pass",
"def handle_comm_open(self, comm, msg):\n self.comm = comm\n self.comm.on_msg(self.handle_comm_msg)\n\n # TODO: Check if the msg is empty - no protocol - die\n self.geonotebook._remote = Remote(self.comm.send, self._unwrap(msg))\n # Reply to the open comm, this should probably be set up on\n # self.geonotebook._remote as an actual proceedure call\n\n self.comm.send({\n \"method\": \"set_protocol\",\n \"data\": self.geonotebook.get_protocol()\n })\n\n # THis should be handled in a callback that is fired off\n # When set protocol etc is complete.\n if self.initializing:\n basemap = Config().basemap\n self.geonotebook.add_layer(\n None, name=\"osm_base\", layer_type=\"osm\",\n vis_url=basemap[\"url\"],\n system_layer=True,\n attribution=basemap[\"attribution\"])\n\n self.geonotebook.add_layer(\n None, name=\"annotation\",\n layer_type=\"annotation\", vis_url=None,\n system_layer=True, expose_as=\"annotation\")\n\n self.initializing = False",
"def __init__(__self__, *,\n channel: Optional[pulumi.Input['ReleaseChannelChannel']] = None):\n if channel is not None:\n pulumi.set(__self__, \"channel\", channel)",
"def open(self, data=None, metadata=None, buffers=None):\n comm_manager = getattr(self.kernel, 'comm_manager', None)\n if comm_manager is None:\n raise RuntimeError(\"Comms cannot be opened without a kernel \"\n \"and a comm_manager attached to that kernel.\")\n\n comm_manager.register_comm(self)\n try:\n f_msg = self.open_hook or self._publish_msg\n f_msg('comm_open',\n data=data, metadata=metadata, buffers=buffers,\n target_name=self.target_name, target_module=self.target_module,\n )\n self._closed = False\n except:\n comm_manager.unregister_comm(self)\n raise",
"async def _connect(self):\n self._connection = await connect_robust(self._connection_string)\n self._channel = await self._connection.channel()\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})",
"def handle_channel_assigned(self, channel):\n logger.debug(\"AIRepository was assigned channel {}\".format(channel))\n self.channel = channel",
"def active_channel(self, channel):\n old_timeout = self.resource.timeout\n self.resource.timeout = 500\n if channel in self.channel_list:\n self.scpi.set_active_channel(channel)\n else:\n print('Channel %i not in list of channels. Create channel first'\n % channel)\n set_channel = self.scpi.query_active_channel()\n self.resource.timeout = old_timeout\n return set_channel",
"async def connect(self, channel=\"btc_confirmed_exchange_flows\"):\n uri = \"wss://ws.tokenanalyst.io\"\n id = \"token_analyst_stream\"\n payload = {\"event\":\"subscribe\",\"channel\":channel,\"id\":id,\"key\":self._key}\n\n async with websockets.connect(uri, ping_timeout=None) as websocket:\n self._ws = websocket\n await websocket.send(json.dumps(payload))\n async for msg in websocket: \n data = await self.interpret(json.loads(msg), id)\n yield data",
"def test_open_channel_event(\n get_accounts: Callable, token_network: Contract, event_handler: Callable\n) -> None:\n ev_handler = event_handler(token_network)\n (A, B) = get_accounts(2)\n\n txn_hash = call_and_transact(token_network.functions.openChannel(A, B))\n channel_identifier = token_network.functions.getChannelIdentifier(A, B).call()\n\n ev_handler.add(\n txn_hash,\n ChannelEvent.OPENED,\n check_channel_opened(channel_identifier, A, B),\n )\n ev_handler.check()",
"def listen(self):\n self.channel.start_consuming()",
"def opened(self):\n self.logger.info(\"Socket connection open\")\n # Send a connection request\n self.sender.send_packet(52)",
"def _open(self, timeout_time=None):\n # pylint: disable=protected-access\n if not self.running:\n if self._handler:\n self._handler.close()\n if self.redirected:\n alt_creds = {\n \"username\": self.client._auth_config.get(\"iot_username\"),\n \"password\": self.client._auth_config.get(\"iot_password\")}\n else:\n alt_creds = {}\n self._create_handler()\n self._handler.open(connection=self.client._conn_manager.get_connection(\n self.client.address.hostname,\n self.client.get_auth(**alt_creds)\n ))\n while not self._handler.client_ready():\n time.sleep(0.05)\n self._max_message_size_on_link = self._handler.message_handler._link.peer_max_message_size \\\n or constants.MAX_MESSAGE_LENGTH_BYTES # pylint: disable=protected-access\n self.running = True",
"def _channel_invoke_shell(self) -> None:\n self._shell = True\n self.channel.shell()",
"def open(self, callback=None):\n return self._framework.future_or_callback(self._ensure_connected(True),\n callback,\n self.get_io_loop(),\n self)",
"def open(self, *args, **kwargs):\n\n self.clients.append(self)\n\n hello = {\n 'sensors': self.sensors,\n 'readings': self.readings\n }\n\n self.write_message(json.dumps(hello))",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def channel(self) -> Channel:\n return self._channel",
"def open(self, callback=None):\n loop = self.get_io_loop()\n future = self._framework.get_future(loop)\n retval = self._framework.future_or_callback(future, callback, loop)\n connected_callback = functools.partial(self._connected_callback, future)\n self._ensure_connected(sync=True, callback=connected_callback)\n return retval"
] | [
"0.83644223",
"0.8340947",
"0.8301517",
"0.7597217",
"0.72027296",
"0.716055",
"0.7139532",
"0.69952625",
"0.6950215",
"0.6906779",
"0.68752795",
"0.68152535",
"0.6695374",
"0.6694395",
"0.6605529",
"0.65631926",
"0.6421272",
"0.6414429",
"0.6350669",
"0.6262175",
"0.62492967",
"0.6234307",
"0.6142892",
"0.611312",
"0.6086732",
"0.6059281",
"0.60363245",
"0.598019",
"0.5977624",
"0.5932534",
"0.59304804",
"0.5909502",
"0.579337",
"0.5778698",
"0.57467526",
"0.5738133",
"0.5691762",
"0.56272423",
"0.5621294",
"0.560673",
"0.5599879",
"0.5597201",
"0.5593677",
"0.55502534",
"0.5498951",
"0.54908156",
"0.5449365",
"0.5404635",
"0.5400225",
"0.5388121",
"0.5379467",
"0.53723437",
"0.5360502",
"0.5309538",
"0.53087425",
"0.53070307",
"0.52931494",
"0.525043",
"0.524813",
"0.52413124",
"0.5231406",
"0.52296853",
"0.52110577",
"0.52109593",
"0.51942724",
"0.5188948",
"0.5169832",
"0.51607996",
"0.5159883",
"0.5158527",
"0.51400805",
"0.51214755",
"0.5119169",
"0.511207",
"0.5103749",
"0.51015234",
"0.5091029",
"0.50647527",
"0.5060361",
"0.50429934",
"0.50341374",
"0.5033698",
"0.5026335",
"0.5020367",
"0.5018054",
"0.5008045",
"0.49909008",
"0.49806032",
"0.49693975",
"0.49662957",
"0.4961229",
"0.4960731",
"0.4949611",
"0.49413133",
"0.4925265",
"0.4903743",
"0.49033517",
"0.48900574",
"0.48889944",
"0.48863465"
] | 0.7994719 | 3 |
This method is invoked by pika when the channel has been opened. The channel object is passed in so we can make use of it. Since the channel is now open, we'll declare the exchange to use. | def on_channel_task_open(self, channel):
# LOGGER.info('Channel opened')
self._channel_task = channel
self._channel_task.add_on_close_callback(self.on_channel_closed)
channel.queue_declare(
queue=self.queue_task,
durable=False,
exclusive=False
)
channel.basic_qos(prefetch_count=self._prefetch_count)
self._init_ok_task = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_channel_opened(self, channel):\n self.logger.info('channel opened')\n self._channel = channel\n\n self.logger.info('adding channel close callback')\n self._channel.add_on_close_callback(self.on_channel_closed)\n\n self.setup_exchange()",
"def setup_exchange(self, channel, exchange_name, exchange_type):\n logger.info('Declaring exchange : %s', exchange_name)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable = True)",
"def on_channel_open(self, channel):\n self.logger.debug(\"Channel opened: %s\", channel)\n\n self._channel = channel\n self._channel.add_on_close_callback(self.on_channel_closed)\n\n self.start_consuming()",
"def on_channel_open(self, new_channel):\n\t\tself.channel = new_channel\n\t\tself.declare_queue(self.on_queue_declared)",
"def on_channel_open(self, channel):\n logger.info('Channel opened')\n self._channel = channel\n self._channel.basic_qos(prefetch_count=\n self.DEFAULT_PREFETCH_COUNT)\n self.add_on_channel_close_callback()\n self.setup_queues_and_bindings()",
"def __init__(self, channel, exchange_name='SIAEF', type_exchange='direct',\n durable=True, auto_delete=False):\n self._channel = channel\n self._exchange = exchange_name\n self._type = type_exchange\n self._durable = durable\n self._auto_delete = auto_delete",
"def on_open_channel(new_channel):\n # assign new channel to the global channel variable\n global channel\n channel = new_channel\n\n # channel is assigned and declare a queue named scripbox.\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\n # Pass a callback on_queue_declared which fires when a queue declaration\n # is successful\n channel.queue_declare(queue='scripbox', durable=True,\n auto_delete=False, callback=on_queue_declared)",
"def channel(self):\n\n self._channel = self._connection.channel()\n print(\"Channel opened...\")",
"def on_primary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_primary_channel = ch\n \n # For receiving confirmations...\n if self.receive_delivery_confirmations:\n self.amqp_primary_channel.confirm_delivery(callback=self.on_delivered, nowait=True)\n \n # Declare 'IN' queue - for receiving items to queue\n self.amqp_primary_channel.queue_declare(queue=self.amqp_in_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_in_queue_declared)\n \n # Declare 'fanout' exchange - for broadcasting items\n # The fanout exchange is very simple. It just broadcasts all the\n # messages it receives to all the queues it knows.\n self.amqp_primary_channel.exchange_declare(exchange=self.amqp_broadcast_exchange, type='fanout',\n callback=self.on_exchange_declared)",
"def setup_exchange(self):\n self.logger.info('declaring exchange %s', self.exchange)\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)",
"def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)",
"def on_channel_open(self, channel):\n self.logger.info('Channel opened')\n self._channel = channel\n self.add_on_channel_close_callback()",
"def setup_exchange(self):\n LOGGER.info('Setting the exchange with name :%s and type :%s',\n self._exchange, self._type)\n if self._channel is None:\n raise ChannelDoesntExist('The channel doesn''t exist')\n\n if len(self._exchange) < 3:\n raise ExchangeNameDoesntMatch('This exchange name does''nt match')\n # Check if the channel doesn't exist on rabbit\n\n list_rabbit_exchange = [] # Correct me\n if self._exchange in list_rabbit_exchange:\n raise ExchangeAlreadyExist('This exchange is already exist')\n\n # Check Me : self._channel.basic_qos(prefetch_count=1)\n self._channel.exchange_declare(exchange=self._exchange,\n type=self._type,\n durable=self._durable,\n auto_delete=self._auto_delete)",
"def open_channel(self):\n self.logger.info('creating channel')\n self._connection.channel(on_open_callback=self.on_channel_opened)",
"def handle_channel_assigned(self, channel):\n logger.debug(\"AIRepository was assigned channel {}\".format(channel))\n self.channel = channel",
"def on_channel_ctrl_open(self, channel):\n # LOGGER.info('Channel opened')\n self._channel_ctrl = channel\n self._channel_ctrl.add_on_close_callback(self.on_channel_closed)\n self._channel_ctrl.basic_qos(prefetch_count=1)\n self.setup_exchange()",
"def exchange(self, exchange):\n\n self._exchange = exchange",
"def open_channel(self):\n self.logger.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_open)",
"def compose(self, channel_name):\n return super().compose(subscription=channel_name)",
"def compose(self, channel_name):\n return super().compose(subscription=channel_name)",
"def _create_channel(self):\n self.connection = pika.BlockingConnection(self.pikaparams)\n self.channel = self.connection.channel()\n try:\n yield self.channel\n finally:\n self.channel.close()\n self.connection.close()",
"def open_channel(self):\n logger.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_open)",
"def __init__(self):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n self.channel = self.connection.channel()",
"def setup_exchange(self):\n LOGGER.info('Declaring exchange: %s', self.topic_ctrl)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n\n self._channel_ctrl.exchange_declare(\n exchange=self.topic_ctrl,\n exchange_type='topic',\n callback=self.on_exchange_declareok)",
"def _set_channel_(self, channel):\n self._channel = channel",
"def _amqp_bind(self):\n if self.amqp_connection is not None:\n try:\n self.amqp_connection.close()\n except:\n pass\n\n self.amqp_connection = pika.BlockingConnection(\n pika.ConnectionParameters(\n host=self.amqp_server\n )\n )\n\n # listening channel for ermrest change notifications\n self.notice_channel = self.amqp_connection.channel()\n try:\n # newer pika API\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\n except TypeError as te:\n # try older API as fallback\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\n sys.stderr.write('ERMrest change-notice channel open.\\n')",
"def on_secondary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_secondary_channel = ch\n \n # Declare 'IN' queue - for receiving confirmations\n self.amqp_secondary_channel.queue_declare(queue=self.amqp_confirm_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_confirm_queue_declared)",
"def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel",
"def open_channel(self):\n # LOGGER.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_task_open)\n self._connection.channel(on_open_callback=self.on_channel_ctrl_open)",
"def setExchange(self, exchange):\r\n\t\tself.exchange = exchange",
"def _on_channel_open(self, channel_id: str) -> None:\n self._send_alive(channel_id)",
"def channel_open(self):\n self._chan = self._session.invoke_shell()",
"def set_channel(cls, channel):\n cls.channel = channel",
"def on_exchange_declareok(self, unused_frame):\n self.logger.info('exchange declared')\n self.setup_queue()",
"async def channel(self, ctx):\n pass",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def __init__(self, url, routing_key, log_file='/dev/null', exchange='yacamc_exchange', exchange_type='direct',\n queue=None, acked=True, sender=False, otq = False, log_level=logging.FATAL):\n\n if queue is None:\n queue = routing_key\n self.exchange = exchange\n self.exchange_type = exchange_type\n self.queue = queue\n self.routing_key = routing_key\n self._url = url\n self.acked = acked\n self.otq = otq\n\n self.cb = None\n\n self._connection = None\n self._channel = None\n self._closing = False\n\n log_format = '%(levelname) -10s %(asctime)s %(name) -30s %(funcName) -35s %(lineno) -5d: %(message)s'\n handler = logging.FileHandler(log_file)\n logging.basicConfig(level=log_level, format=log_format)\n self.logger = logging.getLogger(__name__)\n self.logger.addHandler(handler)\n\n # used only for sending\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n self._stopping = False\n self._done_sending = False\n self.message = \"\"\n self.sender = sender\n\n # self.run()\n # self._connection = self.connect()",
"def __init__(__self__, *,\n channel: Optional[pulumi.Input['ReleaseChannelChannel']] = None):\n if channel is not None:\n pulumi.set(__self__, \"channel\", channel)",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def _connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.exchange_declare(exchange=self.exch, type=\"topic\", durable=True, auto_delete=False,)\n self.log(\"%conn-open\", \"info\", \"Connection to AMQP broker opened\")\n except Exception,e:\n self.log(\"%conn-error\", \"error\", \"Error whilst connecting to AMQP broker (%s)\" % e)\n self.closeConn()",
"def init_app(self):\n LOGGER.info('Launching the init app for the producer')\n\n # Open channel to set the exchange\n channel_handler = ChannelHandler(self._connection)\n channel_handler.open_channel()\n self._channel = channel_handler.get_channel()\n\n # Set the default exchange to use\n exchange_name = 'SIEF'\n exchange_handler = ExchangeHandler(self._channel, exchange_name)\n exchange_handler.setup_exchange()\n self._exchange_name = exchange_handler.get_exchange_name()\n\n channel_handler.close_channel()",
"def active_channel(self, channel):\n old_timeout = self.resource.timeout\n self.resource.timeout = 500\n if channel in self.channel_list:\n self.scpi.set_active_channel(channel)\n else:\n print('Channel %i not in list of channels. Create channel first'\n % channel)\n set_channel = self.scpi.query_active_channel()\n self.resource.timeout = old_timeout\n return set_channel",
"def connect(self):\n logger.info(\"[{}] Connecting to exchange {}\".format(self.bot_id, self.exchange))\n creds = pika.PlainCredentials(self.rabbit_user, self.rabbit_pw)\n return pika.SelectConnection(pika.ConnectionParameters(host=self.rabbit_host,\n port=self.rabbit_port,\n virtual_host='/',\n credentials=creds,\n socket_timeout=1,\n retry_delay=5 # 5 seconds\n ),\n self.on_connection_open,\n stop_ioloop_on_close=False)",
"def channelOpen(self, specificData):\n log.msg('opened forwarding channel %s to %s:%s' % (self.id, self.host, self.port))\n self._connectDone()",
"def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)",
"def __init__(self, channel, name):\n self._channel = channel\n self.name = name",
"def __init__(__self__, *,\n channel: Optional[pulumi.Input['GatewayAPIConfigChannel']] = None):\n if channel is not None:\n pulumi.set(__self__, \"channel\", channel)",
"def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')",
"def modify_channel(self, channel):\n self._poller.modify(channel.fileno, channel._events)",
"async def declare_exchange(self) -> asyncio.Future:\n # pylint: disable=protected-access\n future = self._backend._create_future()\n\n def on_declare_exchange(frame):\n future.set_result(frame)\n self.log.debug('Exchange `%s` declared ok', self.exchange)\n\n self._channel.exchange_declare(\n on_declare_exchange,\n self.exchange,\n self.exchange_type\n )\n\n return future",
"def subscribe(self, channel, **kwargs):\n pass",
"def _open(self):\n if self.channel is None:\n self.channel = self.transport.open_session()\n\n return self.channel",
"def join(self, channel):\n raise NotImplementedError",
"def __init__(self, routing_key):\n self.routing_key = routing_key\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\n self.channel = self.connection.channel()\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\n self.callback_queue = result.method.queue\n\n self.channel.basic_consume(\n queue=self.callback_queue,\n on_message_callback=self.on_response,\n auto_ack=True\n )",
"def add_channel(self, channel):\n self._channels[channel.fileno] = channel\n self._poller.add(channel.fileno, channel._events)",
"def __init__(self, address, queue_name):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(address))\n self.queue_name = queue_name\n\n # create the channel\n self.channel = self.connection.channel()\n\n # declare the queue\n self.channel.queue_declare(queue=queue_name, durable=True)\n\n logging.info(\"Message Broker connected to {0}\".format(address))",
"def setExchange(self, exchange):\r\n\t\tself.pair.exchange = exchange",
"def on_connected(self, connection):\n\t\t# Open a channel\n\t\tconnection.channel(self.on_channel_open)",
"def on_connection_open(self, unused_connection):\n self.logger.info('Connection established!')\n self.open_channel()",
"def channel(self):\n if not hasattr(self, '_channel'):\n self._channel = self.new_channel()\n return self._channel",
"def channel(self):\n raise NotImplementedError",
"async def declare_and_consume(self, handler):\n try:\n await self.declare()\n self.consume(handler)\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.reconnect()",
"def handle_delivery(channel, method, header, body):\n print(body)",
"def on_message(self, unused_channel, basic_deliver, properties, body):\n logger.info('Received message # %s from %s: %s',\n basic_deliver.delivery_tag, properties.app_id, body)\n self.rx_queue.put(body)\n self.acknowledge_message(unused_channel, basic_deliver.delivery_tag)",
"def ack_message(channel, delivery_tag):\n global logger\n if channel.is_open:\n channel.basic_ack(delivery_tag)\n logger.debug(\"Channel is acked!\")\n else:\n # Channel is already closed, so we can't ACK this message;\n # log and/or do something that makes sense for your app in this case.\n logger.debug(\"Channel is closed!\")",
"def run(self):\n\n def callback(ch, method, properties, body):\n json_body = json.loads(body)\n self.buffer.append(Fvalue.fromdict(json_body))\n\n sleep(5) # We introduce a slight delay to let the RabbitMQ container to accept connections\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.mq_host,port=self.mq_port))\n channel = connection.channel()\n channel.exchange_declare(exchange=self.mq_host + '_exchange', exchange_type='direct')\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.queue_bind(exchange=self.mq_host + '_exchange',\n queue=queue_name,\n routing_key=self.routing_key)\n channel.basic_consume(callback,queue=queue_name,no_ack=True)\n channel.start_consuming()",
"def consume(self):\n LOGGER.debug('Consumer Initialized')\n # self.connect()\n channel = self.get_channel()\n self._bind_things(channel)\n\n try:\n LOGGER.info('Start consuming')\n channel.start_consuming()\n except ConnectionClosed:\n LOGGER.exception('Pika connection closed detected. Will attempt to start consuming again')\n self.consume()\n except KeyboardInterrupt as e:\n LOGGER.info('Keyboard interrupt, stop consuming')\n self.shutdown()\n raise e\n except Exception as e:\n LOGGER.exception(\"'%s\" % str(e))\n self.shutdown()\n if self.settings.CONSUMER['RAISE_EXCEPTION']:\n LOGGER.info(\"CONSUMER RAISED EXCEPTION\")\n raise e",
"def ceilometer_amq(self):\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='ceilometer', type='topic')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='metering')\n\n #channel.queue_bind(exchange='ceilometer.agent.notification_fanout', queue=queue_name)\n #channel.queue_bind(exchange='ceilometer.collector_fanout', queue=queue_name)\n channel.basic_consume(self.ceilometer_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()",
"def whenReadReady(self, channel, call):",
"def part(self, channel):\n raise NotImplementedError",
"def on_message(self, unused_channel, basic_deliver, properties, body):\n\n start = time.time()\n self.invocations += 1\n\n logger.info(\n u\"[{}] received message #{} from exchange {}: {}\".format(self.bot_id,\n basic_deliver.delivery_tag, self.exchange,\n body.decode('utf-8')))\n\n self.statsd.incr(self.statsd_prefix + \"message.receive\")\n\n # Ack the message before processing to tell rabbit we got it.\n # TODO before sending ack we should persist the message in a local queue to avoid the possibility of losing it\n self.acknowledge_message(basic_deliver.delivery_tag)\n\n try:\n\n try:\n json_body = json.loads(body)\n\n except ValueError as ve:\n logger.exception(\n \"[{}] Invalid JSON received from exchange: {} error: {} msg body: []\".format(self.bot_id,\n self.exchange,\n ve.message, body))\n raise\n\n else:\n response_messages = self.callback_func(json_body)\n\n if response_messages is None:\n response_messages = []\n\n logger.info(\"[{}] Sending {} response messages\".format(self.bot_id, len(response_messages)))\n\n for message in response_messages:\n self._channel.basic_publish(exchange=message.get('exchange', self.exchange),\n routing_key=message.get('queue', self.queue_name),\n body=message.get('body'))\n logger.info(\"[{}] published message {}\".format(self.bot_id, message))\n self.statsd.incr(self.statsd_prefix + \"message.publish\")\n\n except Exception as e:\n msg = \"[{}] Unexpected error - {}, message {}, from exchange {}. sending to error queue {}\"\n self.statsd.incr(self.statsd_prefix + \"message.error\")\n logger.exception(msg.format(self.bot_id, e, body, self.exchange, self.error_queue_name))\n self._channel.basic_publish(exchange='',\n routing_key=self.error_queue_name,\n body=body)\n\n\n exec_time_millis = int((time.time() - start) * 1000)\n self.total_execution_time += exec_time_millis\n\n logger.debug(\"Consumer {0} message handling time: {1}ms\".format(self.consumer_id, exec_time_millis))\n\n # if we have processed 100 messages, log out the average execution time at INFO then reset the total\n if self.invocations % 100 == 0:\n average_execution_time = self.total_execution_time / 100\n logger.info(\"Consumer {0} Avg message handling time (last 100): {1}ms\".format(self.consumer_id, average_execution_time))\n self.total_execution_time = 0\n\n self.statsd.timing(self.statsd_prefix + 'message.process.time', int((time.time() - start) * 1000))",
"def test_open_via_channel(testchannel, callit):\n\n channel = testchannel.channel() if callit else testchannel.channel\n\n with channel as t:\n assert t.state == ChannelState.open\n\n assert testchannel.state == ChannelState.closed",
"def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True",
"def connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\n self.chan.exchange_declare(exchange=self.EXCH, type=\"topic\", durable=True, auto_delete=False,)\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\"ctag\")\n except:\n self.closeConn()",
"def on_connection_open(self, unused_connection):\n logger.info('Connection opened')\n self.add_on_connection_close_callback()\n self.open_channel()",
"def join(self, channel):\n self.channels[channel.name.lower()] = channel\n channel.protocol = self.protocol\n self.protocol.join(channel.name)",
"async def on_channel_create(self, channel):\n if channel.is_private:\n return\n\n role = await self.get_role(channel.server)\n if not role:\n return\n\n await self.setup_channel(channel, role)",
"def open(self):\n if self._is_open():\n return\n\n channel = api.Api.ssh_channel_new(self._session)\n if channel is None:\n raise exceptions.ChannelException(\"Channel cannot be created: {}\".format(self.get_error_message()))\n\n ret = api.Api.ssh_channel_open_session(channel)\n if ret != api.SSH_OK:\n raise exceptions.ChannelException(\"Channel cannot be opened: {}\".format(self.get_error_message()))\n\n self._channel = channel",
"def set_channel(self, channel):\n self.response['channel'] = channel",
"def refresh_channel(self, channel_name):\n try:\n cm = self.__core.get_service(\"channel_manager\")\n cdb = cm.channel_database_get()\n channel = cdb.channel_get(channel_name)\n channel.consumer_refresh()\n except Exception:\n traceback.print_exc()",
"def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)",
"def set_channel(self, channel_name, value):\n try:\n cm = self.__core.get_service(\"channel_manager\")\n cdb = cm.channel_database_get()\n channel = cdb.channel_get(channel_name)\n try:\n print \"in set_channel\" #if this is not displayed => this function is not called => it must be deleted...\n typing_value = channel.type()(value)#what is going on here?! I don't know...\n except:\n traceback.print_exc()\n return\n channel.consumer_set(Sample(time.time(), typing_value))\n except Exception:\n traceback.print_exc()",
"def on_connection_open(self, unused_conncetion):\n self.logger.info('connection opened, adding connection close callback')\n self._connection.add_on_close_callback(self.on_connection_closed)\n self.open_channel()",
"def channel(self) -> 'Channel': # stub\n return self._channel",
"def configure_rabbit (ec2_conn,base_name,params ):\n print \"configuring rabbitmq exchanges and Queues\"\n app_type = 'RABBITMQ'\n \n logging.basicConfig()\n \n ## Allow security from build server to rabbitmq\n rabbit_lb_sec_grp_name = get_lb_secgrp_name( base_name, app_type )\n rabbit_lb_sec_grp = find_secgrp(ec2_conn, rabbit_lb_sec_grp_name)\n \n try :\n rabbit_lb_sec_grp.authorize( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr )\n except :\n print \"rule exists aready\" \n \n \n rabbitmq_host = params.get( 'host' )\n rabbitmq_port = params.get( 'port' )\n rabbitmq_username = params.get( 'user-name' )\n rabbitmq_password = params.get( 'password' )\n exchanges = params.get( 'exchanges' )\n \n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\n amqp_url = str(amqp_url)\n parameters = pika.URLParameters(amqp_url)\n connection = pika.BlockingConnection(parameters)\n channel = connection.channel()\n \n \n \n for exchnage in exchanges :\n exchange_name = exchnage.get(\"name\")\n exchange_type = exchnage.get(\"type\")\n queue_name = exchnage.get(\"queue\")\n routings = exchnage.get(\"bindings\")\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable=True )\n channel.queue_declare(queue=queue_name,\n durable=True)\n for routing in routings :\n channel.queue_bind(queue=queue_name, exchange=exchange_name, routing_key=routing)\n print \"binging exchnage: \" +exchange_name+\", to a queue:\"+queue_name+\" ,with routing key:\"+routing\n \n ## close connection at the end \n connection.close()\n \n ## At the end revoke the build server rule \n try :\n rabbit_lb_sec_grp.revoke( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr)\n \n except :\n print \"exception removing rule\"",
"def start_consuming(self, channel, rx_queue_name):\n if self.should_stop():\n logger.info(\"ready to stop, pause to consume\")\n return\n logger.info('Issuing consumer related RPC commands')\n self._consumer_tag = channel.basic_consume(\n self.on_message, rx_queue_name, auto_ack = False)\n channel.start_consuming()",
"def on_connection_open(self, connection):\n self.logger.debug(\"Connection opened: %s\", connection)\n self.open_channel()",
"def publish(self, channel: str, message):\n raise TypeError(\"{} - publish not implemented!\")",
"def connect(self):\n self._connect()\n if self.conn is not None:\n try:\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\n except:\n self.closeConn()",
"def on_connected(connection):\n # open a channel\n connection.channel(on_open_channel)",
"def handle_message(self, data, channel):\n pass",
"def set_channel(self, channel_name, value):\n try:\n cm = self.__core.get_service(\"channel_manager\")\n cdb = cm.channel_database_get()\n channel = cdb.channel_get(channel_name)\n try:\n typing_value = channel.type()(value)\n except Exception:\n traceback.print_exc()\n return\n channel.consumer_set(Sample(time.time(), typing_value))\n except Exception:\n traceback.print_exc()",
"def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )",
"def conan_channel(self, conan_channel):\n\n self._conan_channel = conan_channel",
"def publish(self, channel: str, content: str) -> None:\n print(f\"{self._name} publishes message '{content}' to \"\n f\"channel-[{channel}]\")\n self._server.route(channel, content)",
"async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self",
"def getExchange(self):\r\n\t\treturn self.exchange",
"def consume(self, handler):\n bounded_handler = partial(handler, self)\n self._consume_handler = handler\n self.log.debug(\"Start consuming\")\n self._channel.add_on_close_callback(\n self.on_channel_closed\n )\n self._consumer_tag = self._channel.basic_consume(bounded_handler,\n self.name)\n self.log.debug(\"Consumer tag %s on CHANNEL%i\",\n self._consumer_tag, self._channel.channel_number)"
] | [
"0.7178235",
"0.71312135",
"0.6934091",
"0.69002146",
"0.68959934",
"0.6857475",
"0.6773806",
"0.67432135",
"0.67312485",
"0.66281015",
"0.6605424",
"0.6559665",
"0.6524245",
"0.6497938",
"0.6474605",
"0.6457484",
"0.6354469",
"0.6314629",
"0.62993664",
"0.62993664",
"0.6295614",
"0.62921304",
"0.62611634",
"0.61720675",
"0.6097485",
"0.60867244",
"0.6081172",
"0.60721475",
"0.60643196",
"0.6001836",
"0.58959347",
"0.5881841",
"0.58187264",
"0.5809401",
"0.57962483",
"0.57955503",
"0.57955503",
"0.57955503",
"0.5783908",
"0.57778156",
"0.57382125",
"0.57171583",
"0.5693431",
"0.56875914",
"0.5682117",
"0.5663298",
"0.56619084",
"0.5661303",
"0.5661209",
"0.56561476",
"0.564862",
"0.564186",
"0.5631268",
"0.5629412",
"0.5595857",
"0.55870295",
"0.5581384",
"0.55705965",
"0.55681294",
"0.5544538",
"0.55361813",
"0.5528609",
"0.55186373",
"0.55106467",
"0.55067974",
"0.549468",
"0.5483375",
"0.54827994",
"0.5466906",
"0.5456461",
"0.5454113",
"0.54272854",
"0.54272145",
"0.54122",
"0.53971434",
"0.5386855",
"0.5376592",
"0.53679734",
"0.5367468",
"0.53586984",
"0.53508526",
"0.5350262",
"0.5344938",
"0.53434426",
"0.5343375",
"0.5334974",
"0.531159",
"0.53113097",
"0.52946466",
"0.52915746",
"0.52794254",
"0.52717793",
"0.5266609",
"0.5263447",
"0.5261521",
"0.5258792",
"0.5257259",
"0.525366",
"0.5230281",
"0.52274936"
] | 0.6251805 | 23 |
This method is invoked by pika when the channel has been opened. The channel object is passed in so we can make use of it. Since the channel is now open, we'll declare the exchange to use. | def on_channel_ctrl_open(self, channel):
# LOGGER.info('Channel opened')
self._channel_ctrl = channel
self._channel_ctrl.add_on_close_callback(self.on_channel_closed)
self._channel_ctrl.basic_qos(prefetch_count=1)
self.setup_exchange() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_channel_opened(self, channel):\n self.logger.info('channel opened')\n self._channel = channel\n\n self.logger.info('adding channel close callback')\n self._channel.add_on_close_callback(self.on_channel_closed)\n\n self.setup_exchange()",
"def setup_exchange(self, channel, exchange_name, exchange_type):\n logger.info('Declaring exchange : %s', exchange_name)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable = True)",
"def on_channel_open(self, channel):\n self.logger.debug(\"Channel opened: %s\", channel)\n\n self._channel = channel\n self._channel.add_on_close_callback(self.on_channel_closed)\n\n self.start_consuming()",
"def on_channel_open(self, new_channel):\n\t\tself.channel = new_channel\n\t\tself.declare_queue(self.on_queue_declared)",
"def on_channel_open(self, channel):\n logger.info('Channel opened')\n self._channel = channel\n self._channel.basic_qos(prefetch_count=\n self.DEFAULT_PREFETCH_COUNT)\n self.add_on_channel_close_callback()\n self.setup_queues_and_bindings()",
"def __init__(self, channel, exchange_name='SIAEF', type_exchange='direct',\n durable=True, auto_delete=False):\n self._channel = channel\n self._exchange = exchange_name\n self._type = type_exchange\n self._durable = durable\n self._auto_delete = auto_delete",
"def on_open_channel(new_channel):\n # assign new channel to the global channel variable\n global channel\n channel = new_channel\n\n # channel is assigned and declare a queue named scripbox.\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\n # Pass a callback on_queue_declared which fires when a queue declaration\n # is successful\n channel.queue_declare(queue='scripbox', durable=True,\n auto_delete=False, callback=on_queue_declared)",
"def channel(self):\n\n self._channel = self._connection.channel()\n print(\"Channel opened...\")",
"def on_primary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_primary_channel = ch\n \n # For receiving confirmations...\n if self.receive_delivery_confirmations:\n self.amqp_primary_channel.confirm_delivery(callback=self.on_delivered, nowait=True)\n \n # Declare 'IN' queue - for receiving items to queue\n self.amqp_primary_channel.queue_declare(queue=self.amqp_in_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_in_queue_declared)\n \n # Declare 'fanout' exchange - for broadcasting items\n # The fanout exchange is very simple. It just broadcasts all the\n # messages it receives to all the queues it knows.\n self.amqp_primary_channel.exchange_declare(exchange=self.amqp_broadcast_exchange, type='fanout',\n callback=self.on_exchange_declared)",
"def setup_exchange(self):\n self.logger.info('declaring exchange %s', self.exchange)\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)",
"def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)",
"def on_channel_open(self, channel):\n self.logger.info('Channel opened')\n self._channel = channel\n self.add_on_channel_close_callback()",
"def setup_exchange(self):\n LOGGER.info('Setting the exchange with name :%s and type :%s',\n self._exchange, self._type)\n if self._channel is None:\n raise ChannelDoesntExist('The channel doesn''t exist')\n\n if len(self._exchange) < 3:\n raise ExchangeNameDoesntMatch('This exchange name does''nt match')\n # Check if the channel doesn't exist on rabbit\n\n list_rabbit_exchange = [] # Correct me\n if self._exchange in list_rabbit_exchange:\n raise ExchangeAlreadyExist('This exchange is already exist')\n\n # Check Me : self._channel.basic_qos(prefetch_count=1)\n self._channel.exchange_declare(exchange=self._exchange,\n type=self._type,\n durable=self._durable,\n auto_delete=self._auto_delete)",
"def open_channel(self):\n self.logger.info('creating channel')\n self._connection.channel(on_open_callback=self.on_channel_opened)",
"def handle_channel_assigned(self, channel):\n logger.debug(\"AIRepository was assigned channel {}\".format(channel))\n self.channel = channel",
"def exchange(self, exchange):\n\n self._exchange = exchange",
"def open_channel(self):\n self.logger.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_open)",
"def compose(self, channel_name):\n return super().compose(subscription=channel_name)",
"def compose(self, channel_name):\n return super().compose(subscription=channel_name)",
"def _create_channel(self):\n self.connection = pika.BlockingConnection(self.pikaparams)\n self.channel = self.connection.channel()\n try:\n yield self.channel\n finally:\n self.channel.close()\n self.connection.close()",
"def open_channel(self):\n logger.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_open)",
"def __init__(self):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n self.channel = self.connection.channel()",
"def on_channel_task_open(self, channel):\n # LOGGER.info('Channel opened')\n self._channel_task = channel\n self._channel_task.add_on_close_callback(self.on_channel_closed)\n channel.queue_declare(\n queue=self.queue_task,\n durable=False,\n exclusive=False\n )\n channel.basic_qos(prefetch_count=self._prefetch_count)\n self._init_ok_task = True",
"def setup_exchange(self):\n LOGGER.info('Declaring exchange: %s', self.topic_ctrl)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n\n self._channel_ctrl.exchange_declare(\n exchange=self.topic_ctrl,\n exchange_type='topic',\n callback=self.on_exchange_declareok)",
"def _set_channel_(self, channel):\n self._channel = channel",
"def _amqp_bind(self):\n if self.amqp_connection is not None:\n try:\n self.amqp_connection.close()\n except:\n pass\n\n self.amqp_connection = pika.BlockingConnection(\n pika.ConnectionParameters(\n host=self.amqp_server\n )\n )\n\n # listening channel for ermrest change notifications\n self.notice_channel = self.amqp_connection.channel()\n try:\n # newer pika API\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\n except TypeError as te:\n # try older API as fallback\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\n sys.stderr.write('ERMrest change-notice channel open.\\n')",
"def on_secondary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_secondary_channel = ch\n \n # Declare 'IN' queue - for receiving confirmations\n self.amqp_secondary_channel.queue_declare(queue=self.amqp_confirm_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_confirm_queue_declared)",
"def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel",
"def open_channel(self):\n # LOGGER.info('Creating a new channel')\n self._connection.channel(on_open_callback=self.on_channel_task_open)\n self._connection.channel(on_open_callback=self.on_channel_ctrl_open)",
"def setExchange(self, exchange):\r\n\t\tself.exchange = exchange",
"def _on_channel_open(self, channel_id: str) -> None:\n self._send_alive(channel_id)",
"def channel_open(self):\n self._chan = self._session.invoke_shell()",
"def set_channel(cls, channel):\n cls.channel = channel",
"def on_exchange_declareok(self, unused_frame):\n self.logger.info('exchange declared')\n self.setup_queue()",
"async def channel(self, ctx):\n pass",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def __init__(self, url, routing_key, log_file='/dev/null', exchange='yacamc_exchange', exchange_type='direct',\n queue=None, acked=True, sender=False, otq = False, log_level=logging.FATAL):\n\n if queue is None:\n queue = routing_key\n self.exchange = exchange\n self.exchange_type = exchange_type\n self.queue = queue\n self.routing_key = routing_key\n self._url = url\n self.acked = acked\n self.otq = otq\n\n self.cb = None\n\n self._connection = None\n self._channel = None\n self._closing = False\n\n log_format = '%(levelname) -10s %(asctime)s %(name) -30s %(funcName) -35s %(lineno) -5d: %(message)s'\n handler = logging.FileHandler(log_file)\n logging.basicConfig(level=log_level, format=log_format)\n self.logger = logging.getLogger(__name__)\n self.logger.addHandler(handler)\n\n # used only for sending\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n self._stopping = False\n self._done_sending = False\n self.message = \"\"\n self.sender = sender\n\n # self.run()\n # self._connection = self.connect()",
"def __init__(__self__, *,\n channel: Optional[pulumi.Input['ReleaseChannelChannel']] = None):\n if channel is not None:\n pulumi.set(__self__, \"channel\", channel)",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def _connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.exchange_declare(exchange=self.exch, type=\"topic\", durable=True, auto_delete=False,)\n self.log(\"%conn-open\", \"info\", \"Connection to AMQP broker opened\")\n except Exception,e:\n self.log(\"%conn-error\", \"error\", \"Error whilst connecting to AMQP broker (%s)\" % e)\n self.closeConn()",
"def init_app(self):\n LOGGER.info('Launching the init app for the producer')\n\n # Open channel to set the exchange\n channel_handler = ChannelHandler(self._connection)\n channel_handler.open_channel()\n self._channel = channel_handler.get_channel()\n\n # Set the default exchange to use\n exchange_name = 'SIEF'\n exchange_handler = ExchangeHandler(self._channel, exchange_name)\n exchange_handler.setup_exchange()\n self._exchange_name = exchange_handler.get_exchange_name()\n\n channel_handler.close_channel()",
"def active_channel(self, channel):\n old_timeout = self.resource.timeout\n self.resource.timeout = 500\n if channel in self.channel_list:\n self.scpi.set_active_channel(channel)\n else:\n print('Channel %i not in list of channels. Create channel first'\n % channel)\n set_channel = self.scpi.query_active_channel()\n self.resource.timeout = old_timeout\n return set_channel",
"def connect(self):\n logger.info(\"[{}] Connecting to exchange {}\".format(self.bot_id, self.exchange))\n creds = pika.PlainCredentials(self.rabbit_user, self.rabbit_pw)\n return pika.SelectConnection(pika.ConnectionParameters(host=self.rabbit_host,\n port=self.rabbit_port,\n virtual_host='/',\n credentials=creds,\n socket_timeout=1,\n retry_delay=5 # 5 seconds\n ),\n self.on_connection_open,\n stop_ioloop_on_close=False)",
"def channelOpen(self, specificData):\n log.msg('opened forwarding channel %s to %s:%s' % (self.id, self.host, self.port))\n self._connectDone()",
"def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)",
"def __init__(__self__, *,\n channel: Optional[pulumi.Input['GatewayAPIConfigChannel']] = None):\n if channel is not None:\n pulumi.set(__self__, \"channel\", channel)",
"def __init__(self, channel, name):\n self._channel = channel\n self.name = name",
"def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')",
"def modify_channel(self, channel):\n self._poller.modify(channel.fileno, channel._events)",
"async def declare_exchange(self) -> asyncio.Future:\n # pylint: disable=protected-access\n future = self._backend._create_future()\n\n def on_declare_exchange(frame):\n future.set_result(frame)\n self.log.debug('Exchange `%s` declared ok', self.exchange)\n\n self._channel.exchange_declare(\n on_declare_exchange,\n self.exchange,\n self.exchange_type\n )\n\n return future",
"def subscribe(self, channel, **kwargs):\n pass",
"def _open(self):\n if self.channel is None:\n self.channel = self.transport.open_session()\n\n return self.channel",
"def join(self, channel):\n raise NotImplementedError",
"def __init__(self, routing_key):\n self.routing_key = routing_key\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\n self.channel = self.connection.channel()\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\n self.callback_queue = result.method.queue\n\n self.channel.basic_consume(\n queue=self.callback_queue,\n on_message_callback=self.on_response,\n auto_ack=True\n )",
"def add_channel(self, channel):\n self._channels[channel.fileno] = channel\n self._poller.add(channel.fileno, channel._events)",
"def __init__(self, address, queue_name):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(address))\n self.queue_name = queue_name\n\n # create the channel\n self.channel = self.connection.channel()\n\n # declare the queue\n self.channel.queue_declare(queue=queue_name, durable=True)\n\n logging.info(\"Message Broker connected to {0}\".format(address))",
"def setExchange(self, exchange):\r\n\t\tself.pair.exchange = exchange",
"def on_connected(self, connection):\n\t\t# Open a channel\n\t\tconnection.channel(self.on_channel_open)",
"def on_connection_open(self, unused_connection):\n self.logger.info('Connection established!')\n self.open_channel()",
"def channel(self):\n if not hasattr(self, '_channel'):\n self._channel = self.new_channel()\n return self._channel",
"def channel(self):\n raise NotImplementedError",
"async def declare_and_consume(self, handler):\n try:\n await self.declare()\n self.consume(handler)\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.reconnect()",
"def handle_delivery(channel, method, header, body):\n print(body)",
"def on_message(self, unused_channel, basic_deliver, properties, body):\n logger.info('Received message # %s from %s: %s',\n basic_deliver.delivery_tag, properties.app_id, body)\n self.rx_queue.put(body)\n self.acknowledge_message(unused_channel, basic_deliver.delivery_tag)",
"def ack_message(channel, delivery_tag):\n global logger\n if channel.is_open:\n channel.basic_ack(delivery_tag)\n logger.debug(\"Channel is acked!\")\n else:\n # Channel is already closed, so we can't ACK this message;\n # log and/or do something that makes sense for your app in this case.\n logger.debug(\"Channel is closed!\")",
"def run(self):\n\n def callback(ch, method, properties, body):\n json_body = json.loads(body)\n self.buffer.append(Fvalue.fromdict(json_body))\n\n sleep(5) # We introduce a slight delay to let the RabbitMQ container to accept connections\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.mq_host,port=self.mq_port))\n channel = connection.channel()\n channel.exchange_declare(exchange=self.mq_host + '_exchange', exchange_type='direct')\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.queue_bind(exchange=self.mq_host + '_exchange',\n queue=queue_name,\n routing_key=self.routing_key)\n channel.basic_consume(callback,queue=queue_name,no_ack=True)\n channel.start_consuming()",
"def consume(self):\n LOGGER.debug('Consumer Initialized')\n # self.connect()\n channel = self.get_channel()\n self._bind_things(channel)\n\n try:\n LOGGER.info('Start consuming')\n channel.start_consuming()\n except ConnectionClosed:\n LOGGER.exception('Pika connection closed detected. Will attempt to start consuming again')\n self.consume()\n except KeyboardInterrupt as e:\n LOGGER.info('Keyboard interrupt, stop consuming')\n self.shutdown()\n raise e\n except Exception as e:\n LOGGER.exception(\"'%s\" % str(e))\n self.shutdown()\n if self.settings.CONSUMER['RAISE_EXCEPTION']:\n LOGGER.info(\"CONSUMER RAISED EXCEPTION\")\n raise e",
"def ceilometer_amq(self):\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='ceilometer', type='topic')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='metering')\n\n #channel.queue_bind(exchange='ceilometer.agent.notification_fanout', queue=queue_name)\n #channel.queue_bind(exchange='ceilometer.collector_fanout', queue=queue_name)\n channel.basic_consume(self.ceilometer_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()",
"def whenReadReady(self, channel, call):",
"def on_message(self, unused_channel, basic_deliver, properties, body):\n\n start = time.time()\n self.invocations += 1\n\n logger.info(\n u\"[{}] received message #{} from exchange {}: {}\".format(self.bot_id,\n basic_deliver.delivery_tag, self.exchange,\n body.decode('utf-8')))\n\n self.statsd.incr(self.statsd_prefix + \"message.receive\")\n\n # Ack the message before processing to tell rabbit we got it.\n # TODO before sending ack we should persist the message in a local queue to avoid the possibility of losing it\n self.acknowledge_message(basic_deliver.delivery_tag)\n\n try:\n\n try:\n json_body = json.loads(body)\n\n except ValueError as ve:\n logger.exception(\n \"[{}] Invalid JSON received from exchange: {} error: {} msg body: []\".format(self.bot_id,\n self.exchange,\n ve.message, body))\n raise\n\n else:\n response_messages = self.callback_func(json_body)\n\n if response_messages is None:\n response_messages = []\n\n logger.info(\"[{}] Sending {} response messages\".format(self.bot_id, len(response_messages)))\n\n for message in response_messages:\n self._channel.basic_publish(exchange=message.get('exchange', self.exchange),\n routing_key=message.get('queue', self.queue_name),\n body=message.get('body'))\n logger.info(\"[{}] published message {}\".format(self.bot_id, message))\n self.statsd.incr(self.statsd_prefix + \"message.publish\")\n\n except Exception as e:\n msg = \"[{}] Unexpected error - {}, message {}, from exchange {}. sending to error queue {}\"\n self.statsd.incr(self.statsd_prefix + \"message.error\")\n logger.exception(msg.format(self.bot_id, e, body, self.exchange, self.error_queue_name))\n self._channel.basic_publish(exchange='',\n routing_key=self.error_queue_name,\n body=body)\n\n\n exec_time_millis = int((time.time() - start) * 1000)\n self.total_execution_time += exec_time_millis\n\n logger.debug(\"Consumer {0} message handling time: {1}ms\".format(self.consumer_id, exec_time_millis))\n\n # if we have processed 100 messages, log out the average execution time at INFO then reset the total\n if self.invocations % 100 == 0:\n average_execution_time = self.total_execution_time / 100\n logger.info(\"Consumer {0} Avg message handling time (last 100): {1}ms\".format(self.consumer_id, average_execution_time))\n self.total_execution_time = 0\n\n self.statsd.timing(self.statsd_prefix + 'message.process.time', int((time.time() - start) * 1000))",
"def part(self, channel):\n raise NotImplementedError",
"def test_open_via_channel(testchannel, callit):\n\n channel = testchannel.channel() if callit else testchannel.channel\n\n with channel as t:\n assert t.state == ChannelState.open\n\n assert testchannel.state == ChannelState.closed",
"def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True",
"def connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\n self.chan.exchange_declare(exchange=self.EXCH, type=\"topic\", durable=True, auto_delete=False,)\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\"ctag\")\n except:\n self.closeConn()",
"def on_connection_open(self, unused_connection):\n logger.info('Connection opened')\n self.add_on_connection_close_callback()\n self.open_channel()",
"async def on_channel_create(self, channel):\n if channel.is_private:\n return\n\n role = await self.get_role(channel.server)\n if not role:\n return\n\n await self.setup_channel(channel, role)",
"def join(self, channel):\n self.channels[channel.name.lower()] = channel\n channel.protocol = self.protocol\n self.protocol.join(channel.name)",
"def open(self):\n if self._is_open():\n return\n\n channel = api.Api.ssh_channel_new(self._session)\n if channel is None:\n raise exceptions.ChannelException(\"Channel cannot be created: {}\".format(self.get_error_message()))\n\n ret = api.Api.ssh_channel_open_session(channel)\n if ret != api.SSH_OK:\n raise exceptions.ChannelException(\"Channel cannot be opened: {}\".format(self.get_error_message()))\n\n self._channel = channel",
"def refresh_channel(self, channel_name):\n try:\n cm = self.__core.get_service(\"channel_manager\")\n cdb = cm.channel_database_get()\n channel = cdb.channel_get(channel_name)\n channel.consumer_refresh()\n except Exception:\n traceback.print_exc()",
"def set_channel(self, channel):\n self.response['channel'] = channel",
"def on_connection_open(self, unused_conncetion):\n self.logger.info('connection opened, adding connection close callback')\n self._connection.add_on_close_callback(self.on_connection_closed)\n self.open_channel()",
"def set_channel(self, channel_name, value):\n try:\n cm = self.__core.get_service(\"channel_manager\")\n cdb = cm.channel_database_get()\n channel = cdb.channel_get(channel_name)\n try:\n print \"in set_channel\" #if this is not displayed => this function is not called => it must be deleted...\n typing_value = channel.type()(value)#what is going on here?! I don't know...\n except:\n traceback.print_exc()\n return\n channel.consumer_set(Sample(time.time(), typing_value))\n except Exception:\n traceback.print_exc()",
"def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)",
"def channel(self) -> 'Channel': # stub\n return self._channel",
"def start_consuming(self, channel, rx_queue_name):\n if self.should_stop():\n logger.info(\"ready to stop, pause to consume\")\n return\n logger.info('Issuing consumer related RPC commands')\n self._consumer_tag = channel.basic_consume(\n self.on_message, rx_queue_name, auto_ack = False)\n channel.start_consuming()",
"def configure_rabbit (ec2_conn,base_name,params ):\n print \"configuring rabbitmq exchanges and Queues\"\n app_type = 'RABBITMQ'\n \n logging.basicConfig()\n \n ## Allow security from build server to rabbitmq\n rabbit_lb_sec_grp_name = get_lb_secgrp_name( base_name, app_type )\n rabbit_lb_sec_grp = find_secgrp(ec2_conn, rabbit_lb_sec_grp_name)\n \n try :\n rabbit_lb_sec_grp.authorize( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr )\n except :\n print \"rule exists aready\" \n \n \n rabbitmq_host = params.get( 'host' )\n rabbitmq_port = params.get( 'port' )\n rabbitmq_username = params.get( 'user-name' )\n rabbitmq_password = params.get( 'password' )\n exchanges = params.get( 'exchanges' )\n \n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\n amqp_url = str(amqp_url)\n parameters = pika.URLParameters(amqp_url)\n connection = pika.BlockingConnection(parameters)\n channel = connection.channel()\n \n \n \n for exchnage in exchanges :\n exchange_name = exchnage.get(\"name\")\n exchange_type = exchnage.get(\"type\")\n queue_name = exchnage.get(\"queue\")\n routings = exchnage.get(\"bindings\")\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable=True )\n channel.queue_declare(queue=queue_name,\n durable=True)\n for routing in routings :\n channel.queue_bind(queue=queue_name, exchange=exchange_name, routing_key=routing)\n print \"binging exchnage: \" +exchange_name+\", to a queue:\"+queue_name+\" ,with routing key:\"+routing\n \n ## close connection at the end \n connection.close()\n \n ## At the end revoke the build server rule \n try :\n rabbit_lb_sec_grp.revoke( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr)\n \n except :\n print \"exception removing rule\"",
"def on_connection_open(self, connection):\n self.logger.debug(\"Connection opened: %s\", connection)\n self.open_channel()",
"def publish(self, channel: str, message):\n raise TypeError(\"{} - publish not implemented!\")",
"def connect(self):\n self._connect()\n if self.conn is not None:\n try:\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\n except:\n self.closeConn()",
"def on_connected(connection):\n # open a channel\n connection.channel(on_open_channel)",
"def handle_message(self, data, channel):\n pass",
"def set_channel(self, channel_name, value):\n try:\n cm = self.__core.get_service(\"channel_manager\")\n cdb = cm.channel_database_get()\n channel = cdb.channel_get(channel_name)\n try:\n typing_value = channel.type()(value)\n except Exception:\n traceback.print_exc()\n return\n channel.consumer_set(Sample(time.time(), typing_value))\n except Exception:\n traceback.print_exc()",
"def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )",
"def conan_channel(self, conan_channel):\n\n self._conan_channel = conan_channel",
"def publish(self, channel: str, content: str) -> None:\n print(f\"{self._name} publishes message '{content}' to \"\n f\"channel-[{channel}]\")\n self._server.route(channel, content)",
"async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self",
"def consume(self, handler):\n bounded_handler = partial(handler, self)\n self._consume_handler = handler\n self.log.debug(\"Start consuming\")\n self._channel.add_on_close_callback(\n self.on_channel_closed\n )\n self._consumer_tag = self._channel.basic_consume(bounded_handler,\n self.name)\n self.log.debug(\"Consumer tag %s on CHANNEL%i\",\n self._consumer_tag, self._channel.channel_number)",
"def getExchange(self):\r\n\t\treturn self.exchange"
] | [
"0.7178334",
"0.7129195",
"0.6935435",
"0.69001067",
"0.6897367",
"0.68561393",
"0.67737305",
"0.6743625",
"0.67313665",
"0.66248375",
"0.6605752",
"0.65603787",
"0.65214086",
"0.6499043",
"0.6474174",
"0.6351309",
"0.6315634",
"0.62992626",
"0.62992626",
"0.62973344",
"0.6293119",
"0.6262521",
"0.6252635",
"0.6170037",
"0.60970837",
"0.6086007",
"0.6081109",
"0.6072292",
"0.6065226",
"0.5998379",
"0.5896897",
"0.58823156",
"0.58183944",
"0.5806488",
"0.57966846",
"0.5796215",
"0.5796215",
"0.5796215",
"0.5783674",
"0.57776046",
"0.57383454",
"0.5716835",
"0.5693362",
"0.5687886",
"0.56822926",
"0.56638384",
"0.5662079",
"0.5661854",
"0.5661373",
"0.56554943",
"0.564947",
"0.5638993",
"0.5633182",
"0.56298447",
"0.5596309",
"0.55873805",
"0.55822045",
"0.5571322",
"0.5564445",
"0.554556",
"0.55366313",
"0.5528876",
"0.5518898",
"0.5511232",
"0.55073947",
"0.54950154",
"0.54849535",
"0.5483416",
"0.5467641",
"0.54573905",
"0.5456004",
"0.5427978",
"0.5427674",
"0.54134095",
"0.5397478",
"0.5387122",
"0.5377133",
"0.5368655",
"0.53680193",
"0.53593254",
"0.53512937",
"0.5350924",
"0.53437006",
"0.53436047",
"0.53427106",
"0.5335177",
"0.5312403",
"0.53116065",
"0.5295759",
"0.5292204",
"0.5279351",
"0.5273324",
"0.5268095",
"0.52641606",
"0.52598035",
"0.5259008",
"0.5257911",
"0.52517617",
"0.52284",
"0.5228149"
] | 0.6458262 | 15 |
Invoked by pika when RabbitMQ unexpectedly closes the channel. Channels are usually closed if you attempt to do something that violates the protocol, such as redeclare an exchange or queue with different parameters. In this case, we'll close the connection to shutdown the object. | def on_channel_closed(self, channel, reason):
LOGGER.warning('Channel %i was closed: %s', channel, reason)
self.close_connection() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close(self):\n if self.closed:\n return\n try:\n self.channel.close(self)\n self.dispose()\n except StopIteration:\n # If the underlying connection for the channel is closed explicitly\n # open will not able to find an appropriate channel, to send close.\n pass",
"def on_channel_closed(self, channel, reply_code, reply_text):\n self.logger.warning('channel closed: %s: %s', reply_code, reply_text)\n self._channel = None\n if not self._stopping:\n # this wasn't supposed to happen\n self._connection.close()",
"def shutdown(self):\n self.channel.close()\n self.conn.close()",
"def _close_channel(self, channel):\n logger.info('Closing the channel')\n if channel and channel.is_open:\n channel.close()",
"def on_channel_closed(self, *args, **kwargs):\n if not self._normal_close:\n self.log.warning(\n 'Channel closed. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def close_channel(self):\n logger.info('Closing the channel')\n self._channel.close()",
"def close(self, *args, **kwargs):\n # Close all channels\n for channel in self._channels:\n logger.debug('closing channel -> channel.close(%r, %r)' % (args, kwargs))\n channel.close(*args, **kwargs)\n # If this is the only AMQPConnection using the Connection, close it too\n if self.enabled:\n self._active_connections[self.connection_signature][0] -= 1\n if self._active_connections[self.connection_signature][0] <= 0:\n logger.debug('closing connection -> connection.close()')\n self.connection.close()\n del self._active_connections[self.connection_signature]",
"def on_channel_closed(self, channel, *args):\n self.logger.debug(\"Channel %i closed: %s\", channel, args)\n\n if self._connection.is_open:\n self._connection.close()",
"def __exit__(self, *args, **kwargs):\n\n if self.channel:\n self.channel.close()\n self.log.debug(\"SSH channel is closed.\")",
"def safe_close(self):\n if self.channel_is_closed:\n return\n if not self.channel_is_bad:\n try:\n self.safe_do_command(\"quit\")\n except BadGtpResponse, e:\n self.errors_seen.append(str(e))\n try:\n self.channel.close()\n except GtpTransportError, e:\n self.errors_seen.append(\"error closing %s:\\n%s\" % (self.name, e))\n self.channel_is_closed = True",
"def on_channel_closed(self, channel, reply_code, reply_text):\n logger.warning('Channel %i was closed: (%s) %s',\n channel, reply_code, reply_text)\n self._connection.close()",
"def close(self):\n if self.channel is not None:\n self.channel.close()",
"def on_connection_closed(self, connection, reply_code, reply_text):\n self._channel = None\n if self._closing:\n self._connection.ioloop.stop()\n else:\n logger.warning('Connection closed, reopening in 5 seconds: (%s) %s',\n reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"def on_connection_closed(self, _unused_connection, reason):\n self._channel_ctrl = None\n self._channel_task = None\n if self._closing:\n self._connection.ioloop.stop()\n else:\n # LOGGER.warning('Connection closed, reconnect necessary: %s', reason)\n self.reconnect()",
"def on_connection_closed(self, connection, reply_code, reply_text):\n\n self._channel = None # there cannot be a channel, since the connection holding it was shut down\n if self._closing:\n # we are trying to stop. Just do so.\n self._connection.ioloop.stop()\n else:\n # this is unexpected. Restart the connection (after a timeout)\n self.logger.warning('The connection closed: %s:%s - retrying', reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"def connection_remote_closed(self, connection, pn_condition):\n assert len(self.receivers) == 0\n self.connection.close()",
"def close(self):\n if self.channel_is_closed:\n raise StandardError(\"channel is closed\")\n try:\n self.channel.close()\n except GtpTransportError, e:\n raise GtpTransportError(\"error closing %s:\\n%s\" % (self.name, e))\n self.channel_is_closed = True",
"def on_channel_closed(self, channel, reply_code, reply_text):\n self.logger.warning('Channel %i was closed: (%s) %s', channel,\n reply_code, reply_text)\n self._connection.close()",
"def connectionLost(self, reason):\n self.chan = None\n self.dispatcher.unregister(self.producer.put)\n log.err(reason, \"Connection lost\")\n AMQClient.connectionLost(self, reason)",
"def on_close(self):\n self.subscrib.unsubscribe(self.channel)\n self.thread.stop()",
"def tearDown(self):\n if self.__channel:\n self.__channel.close()\n return",
"def exit_gracefully():\n input_channel.close()\n output_channel.close()\n cmd_channel.close()\n connection.close()",
"async def __aexit__(self, exc_type, exc_value, traceback):\n\n # Close the connection\n await self.disconnect()",
"def close(self):\n if self._is_open():\n api.Api.ssh_channel_send_eof(self._channel)\n api.Api.ssh_channel_free(self._channel)\n self._channel = None",
"def on_connection_closed(self, connection, *args):\n self.logger.debug(\"Connection %s closed: %s\", connection, args)\n self._connection.ioloop.stop()",
"def connection_closed(self, exc):\n _logger.info(\"Connection lost: %s\", str(exc))\n super().close()",
"def _close_connection(self):\n if self.connection:\n self.connection.destroy()\n self.connection = None",
"def closed(self, code, reason=None):\n if code != 1000:\n self._error = errors.SignalFlowException(code, reason)\n _logger.info('Lost WebSocket connection with %s (%s: %s).',\n self, code, reason)\n for c in self._channels.values():\n c.offer(WebSocketComputationChannel.END_SENTINEL)\n self._channels.clear()\n with self._connection_cv:\n self._connected = False\n self._connection_cv.notify()",
"async def close(self):\n self.debug(\"Closing connection\")\n self.real_local_key = self.local_key\n if self.heartbeater is not None:\n self.heartbeater.cancel()\n try:\n await self.heartbeater\n except asyncio.CancelledError:\n pass\n self.heartbeater = None\n if self.dispatcher is not None:\n self.dispatcher.abort()\n self.dispatcher = None\n if self.transport is not None:\n transport = self.transport\n self.transport = None\n transport.close()",
"def close(self):\n if self.connection.opened():\n logger.info(' connection closed.')\n self.connection.close()",
"def close_connection(self):\n logger.info('Closing connection')\n self._connection.close()",
"def _close_connection(self, connection):\n logger.info('Closing connection')\n if connection and connection.is_open:\n connection.close()",
"async def close_connection(self):\n\t\t...",
"def close_connection(self):\n\n self._connection.close()\n print(\"Closed connection....\")",
"def close(self):\n if self._closed:\n return\n\n self.listening = False\n\n self.ssl_enabled = False\n\n if self._slave:\n self._slave.close()\n\n self._safely_call(self.on_close)\n\n self._remote_address = None\n self._local_address = None\n\n _Channel.close(self)",
"def on_consumer_cancelled(self, method_frame):\n logger.info('Consumer was cancelled remotely, shutting down: %r',\n method_frame)\n if self._channel:\n self._channel.close()",
"def close(self) -> None:\n self.transport._data_channel_close(self)",
"def close_connection(self, connection):\n pass",
"def on_close(self):\n for channel in self.channels.values():\n channel.close(flush=False)",
"def close_connection(self, connection ):\n pass",
"def test_datachannel_stop_already_closed(testchannel):\n with testchannel.open():\n pass\n\n with pytest.raises(ChannelClosedError):\n testchannel.stop()",
"def on_cancelok(self, unused_frame):\n logger.info('RabbitMQ acknowledged the cancellation of the consumer')\n self.close_channel()",
"def connection_lost(self, exc):\n if self._closing:\n return\n self._closing = True\n\n # inform yielding readers about closed connection\n if exc is None:\n logger.info(\"Connection closed for %s\", self)\n self.reader.feed_eof()\n else:\n logger.info(\"Connection lost for %s: %s\", self, exc)\n self.reader.set_exception(exc)\n\n # cancel protocol tasks, namely on-connect negotiations\n for task in self._tasks:\n task.cancel()\n\n # close transport (may already be closed), set _waiter_closed and\n # cancel Future _waiter_connected.\n self._transport.close()\n self._waiter_connected.cancel()\n if self.shell is None and self._waiter_closed is not None:\n # raise deprecation warning, _waiter_closed should not be used!\n self._waiter_closed.set_result(weakref.proxy(self))\n\n # break circular references.\n self._transport = None",
"def close(self):\r\n if self.connected:\r\n #self.onClose()\r\n self.con.close()\r\n self._close() # Reset the thread and connection, and stop all sounds playing through the output.\r\n else:\r\n raise UserError(errors['NotConnectedYet'])",
"def perform_teardown():\n global credentials, connection, channel\n connection.close()",
"def ShutdownConnection(self): # real signature unknown; restored from __doc__\n pass",
"def connection_lost(self, exc):\n super().connection_lost(exc)\n\n if self.session is not None:\n # Kill the session.\n self.session.close(SessionCloseErrorCode.SESSION_DIED)\n self.session = None\n\n self.client = None",
"def finish():\n if not channel.closed():\n channel.close()\n loop.remove_timeout(timeout)\n kernel.remove_restart_callback(on_restart_failed, 'dead')",
"def onClose(self, wasClean, code=None, reason=None):\n self.sessionhandler.disconnect(self)\n if self.nextHeartbeatCall:\n self.nextHeartbeatCall.cancel()\n self.nextHeartbeatCall = None\n if wasClean:\n logger.log_info(f\"Discord connection closed ({code}) reason: {reason}\")\n else:\n logger.log_info(f\"Discord connection lost.\")",
"def stop(self):\n self.logger.info('stopping')\n self._stopping = True\n if self._channel:\n self._channel.close()\n self._closing = True\n self._connection.close()\n self._connection.ioloop.start()\n self.logger.info('stopped')",
"def close(self):\n self.connection.close()\n print(\"Connection on port \" + str(self.port) + \" closed.\")",
"def handle_close(self, msg):\n self.log.debug(\"handle_close[%s](%s)\", self.comm_id, msg)\n if self._close_callback:\n self._close_callback(msg)",
"def closeConnection(self):\n print(\"closing connection...\")\n self.s.close()\n quit()",
"def close(self) -> None:\n _LOGGER.info('Shutting down connections to deCONZ.')\n if self.websocket:\n self.websocket.stop()",
"def loseConnection(self):\n self.transport.loseConnection()",
"def connection_lost(self, exc):\n if not self._closing:\n self._closing = True\n self.log.info('{about}{reason}'.format(\n about=self.__str__(),\n reason=': {}'.format(exc) if exc is not None else ''))\n self.waiter_connected.cancel()\n self.waiter_closed.set_result(self)",
"def connectionLost(self, reason):\r\n _Protocol.remote_destroy(self)",
"def close(self):\n self.connection = None",
"def close_connection(self):\n try:\n ljm.close(self.connection_handle)\n except LJMError:\n pass",
"def _lowLevelClose(self):\n self.socket_reference.close()",
"def close_channel(self):\n if not self._open:\n return\n for contract in self._state.htlc_contracts:\n contract.invalidate()\n self._state.htlc_contracts = []\n\n self._owner1_htlc_locked_setter(0)\n self._owner2_htlc_locked_setter(0)\n\n BLOCKCHAIN_INSTANCE.close_channel(self._state.message_state)\n\n self._state.channel_data.owner2.notify_of_closed_channel(self, self._state.channel_data.owner1)\n self._state.channel_data.owner1.notify_of_closed_channel(self, self._state.channel_data.owner2)\n self._open = False",
"def close_connection(self):\n self.session.close()",
"def shutdown(self):\n if self.alive:\n libplasma.disconnect(self.conn)\n self.alive = False",
"def connection_lost(self, exc):\n logger.info('The server closed the connection')\n self.loop.stop()",
"def _close(self): # used by model_tests\n Connection.__pool__.pop(self.id)\n self.connected = False",
"def handle_close(self):\n print(self.addr, \"bye\")\n self.close()",
"def close(self):\n self._connection.close()",
"def close_connection(self):\n\t\tself.session.close()",
"def close(self):\n if self._conn:\n logger.info(\"close connection.\")\n self._conn.unbind_s()",
"def close_connection(self):\n self.connection.close()",
"def close_connection(self):\n self.connection.close()",
"def test_disconnect_closed(self):\n self.sock.close()\n self.inverter.sock.close()\n self.inverter.sock_file.close()\n self.inverter.disconnect() # Should not raise exception",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.socket.close()",
"def handle_pipe_closed(self, channel: Channel, session: FBDPSession, msg: FBDPMessage, # pylint: disable=W0613\n exc: Exception=None) -> None:\n # FDBP converts exceptions raised in our event handler to CLOSE messages, so\n # here is the central place to handle errors in data pipe processing.\n # Note problem in service execution outcome\n if exc is not None:\n self.outcome = Outcome.ERROR\n self.details = exc\n #\n if self.stop_on_close:\n self.stop.set()",
"def close_channel(self, channel):\n if channel in self.get_channels():\n channel.close()\n self.remove_channel(channel)\n return True\n return False",
"def onClose(self, *args):\r\n if self._registered:\r\n self._connection.unregisterConnection(self)\r\n self._assembler.stop()\r\n self._registered = False",
"def connection_closed(self) -> bool:",
"def cancel(self):\n def on_cancelok(method_frame):\n \"\"\"Handle cancelok.\n \"\"\"\n self.log.debug(\"Cancel ok on CHANNEL%s\",\n method_frame.channel_number)\n try:\n if self._consumer_tag:\n self._channel.basic_cancel(\n on_cancelok,\n self._consumer_tag\n )\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.log.warning('Channel already closed while closing queue')",
"def close_connection(self):\n if self.socket:\n self.socket.close()",
"def _on_connection_close(self):\n print(\"connection was closed, reconnecting...\")\n self.connect()",
"def close_connection(self):\n if not self.is_open():\n return\n if self._active_result is not None:\n self._active_result.fetch_all()\n self.protocol.send_connection_close()\n self.protocol.read_ok()\n self.stream.close()",
"async def do_cleanup(rcv_trans, rcv_proto):\n\n log.info(\"Closing AMQP receive channel ...\")\n await rcv_proto.close()\n rcv_trans.close()",
"def handle_close(self):\n LOGGER.debug(\"server closed\")\n self.clear()\n data = {}\n self.update_notify_state(data, STAGE_SERVER_UNCONNECTED)\n self.close()\n\n # close all and restart\n asyncore.close_all()",
"def closeConnection(self):\n self.engine.close()",
"def __del__(self):\n if self.connection_obj:\n self.logger.info('Disconnecting from host {0}:{1}'.format(self.host, self.port))\n Disconnect(self.connection_obj)",
"def on_consumer_cancelled(self, method_frame):\n self.logger.debug(\"Consumer was cancelled: %r\", method_frame)\n\n if self._channel:\n self._connection.close()",
"def on_connection_closed(self, connection, reply_code, reply_text):\n if self._closing:\n self._connection.ioloop.stop()\n else:\n self.logger.warning(\n 'Connection closed, reopening in 5 seconds: (%s) %s',\n reply_code, reply_text)\n self._connection.add_timeout(self.CONNECTION_TIMEOUT_SEC,\n self.reconnect)",
"def close(self):\n self.connection_state_lock.acquire()\n try:\n if self.connected:\n try:\n # to-do: handle errors?\n self.connection.close()\n except libvirtError:\n pass\n\n self.connection = None\n self.last_error = None\n finally:\n self.connection_state_lock.release()",
"def close_connection(self):\n self._conn.close()",
"def close(self):\n if self.is_connected:\n def _wrapper_callback(proto):\n proto.send_close()\n return proto\n\n self.factory.on_ready(_wrapper_callback)",
"def close_connection(self, connection):\n connection.client = None\n connection.close()",
"def closed(self, code, reason=None):\n self.logger.info(\n \"Socket connection closed {0}:{1}\".format(code, reason))\n self._heartbeats.stop_heartbeats()\n self._disconnect_handler()",
"def close_connection(self):\n if self.connection is not None:\n self.connection.close()",
"def close(self): \n\t\tself.connection = None",
"def handle_close(self):\n self.cmd_channel.debug(\"ActiveDTP.handle_close()\")\n self.close()",
"async def connection_lost(self):\n logging.info('connection dropped')",
"def disconnect(self):\n _error = None\n try:\n self.connection.shutdown()\n except Exception as e:\n log.error(e, exc_info=True)\n _error = 'disconnect error: %s' % e\n finally:\n if _error is not None and config.DEBUG_TO_CONSOLE:\n print (_error)\n self.is_connected = False\n self.connection = None",
"async def clean_up(self) -> None:\n self.logger.info(\"clean_up\", \"closing redis connection\")\n if self.pubsub_task and not self.pubsub_task.done():\n self.pubsub_task.cancel()\n try:\n await self.pubsub_task\n except CancelledError:\n pass\n self.pubsub_task = None\n if self.pubsub_channel is not None:\n self.pubsub_channel.close()\n await super().clean_up()",
"def add_on_channel_close_callback(self):\n logger.info('Adding channel close callback')\n self._channel.add_on_close_callback(self.on_channel_closed)",
"def add_on_channel_close_callback(self):\n self.logger.info('Adding channel close callback')\n self._channel.add_on_close_callback(self.on_channel_closed)"
] | [
"0.7605382",
"0.75265586",
"0.74880636",
"0.7465269",
"0.7393919",
"0.73355293",
"0.7277174",
"0.7258842",
"0.7201403",
"0.717356",
"0.71427494",
"0.7117505",
"0.71007377",
"0.7098356",
"0.7082408",
"0.70288086",
"0.70259273",
"0.7009042",
"0.69462323",
"0.6893637",
"0.6890997",
"0.6800173",
"0.6741839",
"0.673871",
"0.6731256",
"0.66664034",
"0.66444236",
"0.6633627",
"0.66277575",
"0.66082126",
"0.6592973",
"0.65903556",
"0.6583755",
"0.65762705",
"0.6524841",
"0.6515591",
"0.65141904",
"0.65103674",
"0.65070677",
"0.64887947",
"0.64792246",
"0.6474983",
"0.64686286",
"0.6460751",
"0.64520246",
"0.6450521",
"0.6447844",
"0.6446479",
"0.64444137",
"0.6428116",
"0.6425037",
"0.6406023",
"0.6402478",
"0.63815796",
"0.6377843",
"0.6371385",
"0.636954",
"0.63657075",
"0.636228",
"0.6361798",
"0.63562554",
"0.63462555",
"0.6333098",
"0.632855",
"0.63087165",
"0.6297132",
"0.62873435",
"0.6280918",
"0.62792367",
"0.62732655",
"0.62732655",
"0.627262",
"0.6263828",
"0.6263555",
"0.62608224",
"0.62562686",
"0.6251989",
"0.6242573",
"0.6240777",
"0.62311035",
"0.62300426",
"0.6226286",
"0.62258434",
"0.6224784",
"0.62236077",
"0.6223318",
"0.62200904",
"0.62191194",
"0.6216589",
"0.621312",
"0.62103665",
"0.6195132",
"0.61847204",
"0.61839277",
"0.6182759",
"0.61701053",
"0.6170084",
"0.61677283",
"0.61674505",
"0.6166669"
] | 0.7185234 | 9 |
Setup the exchange on RabbitMQ by invoking the Exchange.Declare RPC command. When it is complete, the on_exchange_declareok method will be invoked by pika. | def setup_exchange(self):
LOGGER.info('Declaring exchange: %s', self.topic_ctrl)
# Note: using functools.partial is not required, it is demonstrating
# how arbitrary data can be passed to the callback when it is called
self._channel_ctrl.exchange_declare(
exchange=self.topic_ctrl,
exchange_type='topic',
callback=self.on_exchange_declareok) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_exchange(self):\n self.logger.info('declaring exchange %s', self.exchange)\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)",
"def setup_exchange(self, channel, exchange_name, exchange_type):\n logger.info('Declaring exchange : %s', exchange_name)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable = True)",
"async def declare_exchange(self) -> asyncio.Future:\n # pylint: disable=protected-access\n future = self._backend._create_future()\n\n def on_declare_exchange(frame):\n future.set_result(frame)\n self.log.debug('Exchange `%s` declared ok', self.exchange)\n\n self._channel.exchange_declare(\n on_declare_exchange,\n self.exchange,\n self.exchange_type\n )\n\n return future",
"def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)",
"def setup_exchange(self):\n LOGGER.info('Setting the exchange with name :%s and type :%s',\n self._exchange, self._type)\n if self._channel is None:\n raise ChannelDoesntExist('The channel doesn''t exist')\n\n if len(self._exchange) < 3:\n raise ExchangeNameDoesntMatch('This exchange name does''nt match')\n # Check if the channel doesn't exist on rabbit\n\n list_rabbit_exchange = [] # Correct me\n if self._exchange in list_rabbit_exchange:\n raise ExchangeAlreadyExist('This exchange is already exist')\n\n # Check Me : self._channel.basic_qos(prefetch_count=1)\n self._channel.exchange_declare(exchange=self._exchange,\n type=self._type,\n durable=self._durable,\n auto_delete=self._auto_delete)",
"def on_exchange_declareok(self, unused_frame):\n self.logger.info('exchange declared')\n self.setup_queue()",
"def setup_queues_and_bindings(self):\n self._channel.exchange_declare(self.setup_queue, exchange=self.exchange, passive=True)",
"def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)",
"def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )",
"def create_exchange(self, exchange_name, exchange_type, internal=None):\n self._channel.exchange_declare(\n exchange=exchange_name,\n durable=True, # Survive reboot\n passive=False, # Perform a declare or just to see if it exists\n internal=internal, # Can only be published to by other exchanges\n exchange_type=exchange_type\n )\n\n self.logger.debug('Created exchange: [name={}, type={}]'.format(\n exchange_name, exchange_type))",
"async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self",
"def setup_queue(self, method_frame):\n logger.info('Declaring queue %s', self.queue_name)\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\n\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)",
"def setup_queue(self):\n self.logger.info('declaring queue %s', self.queue)\n if self.otq:\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\n else:\n self._channel.queue_declare(self.on_queue_declareok, self.queue)",
"def _declare(self, passive=False):\n arguments = dict(self._arguments)\n if self._expires:\n arguments['x-expires'] = self._expires\n if self._message_ttl:\n arguments['x-message-ttl'] = self._message_ttl\n if self._max_length:\n arguments['x-max-length'] = self._max_length\n if self._dlx:\n arguments['x-dead-letter-exchange'] = self._dlx\n if self._dlr:\n arguments['x-dead-letter-routing-key'] = self._dlr\n return specification.Queue.Declare(queue=self.name,\n durable=self._durable,\n passive=passive,\n exclusive=self._exclusive,\n auto_delete=self._auto_delete,\n arguments=arguments)",
"def declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def setup_queue(self, channel, queue_name):\n logger.info('Declaring queue %s', queue_name)\n channel.queue_declare(queue = queue_name, \n durable = True,\n auto_delete = False)",
"def add_exchange(self, exchange_name, exchange_type, alt_exchange_name=None, passive=False, durable=False,\n arguments = None):\n amqp_session = self.__broker.getAmqpSession()\n if arguments == None:\n arguments = {}\n if alt_exchange_name:\n amqp_session.exchange_declare(exchange=exchange_name, type=exchange_type,\n alternate_exchange=alt_exchange_name, passive=passive, durable=durable,\n arguments=arguments)\n else:\n amqp_session.exchange_declare(exchange=exchange_name, type=exchange_type, passive=passive, durable=durable,\n arguments=arguments)",
"def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True",
"async def _connect(self):\n self._connection = await connect_robust(self._connection_string)\n self._channel = await self._connection.channel()\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})",
"def _setup_tubes(self):\n chan = self.channel\n inp = self.config[self.MODULE_NAME]['amqp']['in']\n out = self.config[self.MODULE_NAME]['amqp']['out']\n if inp['exchange']:\n log.info('generating Input Queue'+ str(inp))\n chan.exchange_declare(**inp)\n self.qname = chan.queue_declare(exclusive=True).queue\n chan.queue_bind(exchange=inp['exchange'],queue=self.qname)\n self.consume = lambda cb : chan.basic_consume(cb,queue=self.qname,no_ack=True)\n self.start_loop = lambda : pika.asyncore_loop()\n\n if out['exchange']:\n log.info('generating Output Exchange'+ str(out))\n chan.exchange_declare(**out)\n self.publish = lambda msg: self.channel.basic_publish(exchange=out['exchange'],routing_key='',body=msg)",
"def declare(self):\n self.channel.queue_declare(queue='files_to_database')",
"def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel",
"def _connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.exchange_declare(exchange=self.exch, type=\"topic\", durable=True, auto_delete=False,)\n self.log(\"%conn-open\", \"info\", \"Connection to AMQP broker opened\")\n except Exception,e:\n self.log(\"%conn-error\", \"error\", \"Error whilst connecting to AMQP broker (%s)\" % e)\n self.closeConn()",
"def setup_amq(self):\n self.setup_amq_cluster_operator()\n self.setup_amq_kafka_persistent()\n self.setup_amq_kafka_connect()\n self.setup_amq_kafka_bridge()\n self.amq_is_setup = True\n return self",
"def start(self):\n self._connect()\n self._init_exchange()\n self._init_queue()\n self._bind_queue()",
"def on_queue_declareok(self, method_frame):\n # LOGGER.info('Binding %s to %s with %s',\n # self.EXCHANGE, self.QUEUE, self.ROUTING_KEY)\n # self._channel.queue_bind(self.on_bindok, self.QUEUE,\n # self.EXCHANGE, self.ROUTING_KEY)\n logger.info(\n \"[{}] Binding to {} with queue {} and routing key \\\"\\\"\".format(self.bot_id, self.exchange,\n self.queue_name))\n\n self._channel.queue_bind(self.on_bindok,\n queue=self.queue_name,\n exchange=self.exchange,\n routing_key=\"\")",
"def on_queue_declareok(self, method_frame):\n self.logger.info('binding %s and %s together with %s', self.exchange, self.queue, self.routing_key)\n self._channel.queue_bind(self.on_bindok, self.queue, self.exchange, self.routing_key)",
"def setUpClass(cls):\n cls.queue = RabbitQueue(QUEUE_CONN_PARAMS)",
"def connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\n self.chan.exchange_declare(exchange=self.EXCH, type=\"topic\", durable=True, auto_delete=False,)\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\"ctag\")\n except:\n self.closeConn()",
"def connect(self):\n self._connect()\n if self.conn is not None:\n try:\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\n except:\n self.closeConn()",
"def setup_error_queue(self):\n logger.info('Declaring error queue %s', self.error_queue_name)\n\n self._channel.queue_declare(self.on_error_queue_declareok,queue=self.error_queue_name, durable=True, exclusive=False)",
"def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)",
"def setup_rabbitmq(vhost, user, passwd):\n base_cl = [\"rabbitmqctl\"]\n subprocess.check_call(base_cl + [\"add_user\", user, passwd])\n subprocess.check_call(base_cl + [\"add_vhost\", vhost])\n subprocess.check_call(base_cl + [\"set_permissions\", \"-p\", vhost,\n user, '.*', '.*', '.*'])",
"def keystone_amq(self):\n\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='keystone', type='topic')\n channel.queue_bind(exchange='openstack', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='keystone', queue=queue_name, routing_key='keystone.#')\n\n channel.basic_consume(self.keystone_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()",
"async def declare_and_consume(self, handler):\n try:\n await self.declare()\n self.consume(handler)\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.reconnect()",
"def init_app(self):\n LOGGER.info('Launching the init app for the producer')\n\n # Open channel to set the exchange\n channel_handler = ChannelHandler(self._connection)\n channel_handler.open_channel()\n self._channel = channel_handler.get_channel()\n\n # Set the default exchange to use\n exchange_name = 'SIEF'\n exchange_handler = ExchangeHandler(self._channel, exchange_name)\n exchange_handler.setup_exchange()\n self._exchange_name = exchange_handler.get_exchange_name()\n\n channel_handler.close_channel()",
"def declare_queue(self, topic):\n #from trove.rpc.impl_kombu import Connection\n from trove.openstack.common.rpc import create_connection\n with create_connection() as conn:\n consumer = conn.declare_topic_consumer(topic=topic)",
"def setup():\n global zb\n # Signal handler (Ctrl+C exit)\n signal.signal(signal.SIGINT, signal_handler) \n # DBus\n session_bus = dbus.SessionBus()\n objXBZB = session_bus.get_object(PROTOCOL_BUS_NAME, PROTOCOL_OBJ_PATH + \"/\" + XBEE_ZB + \"/\" + SOCKET0)\n zb = dbus.Interface(objXBZB, dbus_interface=PROTOCOL_BUS_NAME)",
"def __init__(self, address, queue_name):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(address))\n self.queue_name = queue_name\n\n # create the channel\n self.channel = self.connection.channel()\n\n # declare the queue\n self.channel.queue_declare(queue=queue_name, durable=True)\n\n logging.info(\"Message Broker connected to {0}\".format(address))",
"def exchange(self, exchange):\n\n self._exchange = exchange",
"def on_primary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_primary_channel = ch\n \n # For receiving confirmations...\n if self.receive_delivery_confirmations:\n self.amqp_primary_channel.confirm_delivery(callback=self.on_delivered, nowait=True)\n \n # Declare 'IN' queue - for receiving items to queue\n self.amqp_primary_channel.queue_declare(queue=self.amqp_in_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_in_queue_declared)\n \n # Declare 'fanout' exchange - for broadcasting items\n # The fanout exchange is very simple. It just broadcasts all the\n # messages it receives to all the queues it knows.\n self.amqp_primary_channel.exchange_declare(exchange=self.amqp_broadcast_exchange, type='fanout',\n callback=self.on_exchange_declared)",
"def _listen_queue(self, queue, callback):\n # Listen buy/sell orders from external system\n self._logger.info(f\"Declaring rabbit queue {queue}\")\n self._consumer_rabbit_channel.queue_declare(queue=queue, durable=True, auto_delete=True)\n self._logger.info(f\"Declaring callback to rabbit queue: {queue}, callback: {callback}\")\n self._consumer_rabbit_channel.basic_consume(queue, callback,\n consumer_tag=queue)",
"def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')",
"def on_queue_declareok(self, method_frame):\n\n for queue in self._handlers.keys():\n LOGGER.debug('Binding %s to %s with %s',\n self.EXCHANGE, queue, self.ROUTING_KEY)\n self._channel.queue_bind(self.on_bindok, queue,\n self.EXCHANGE, self.ROUTING_KEY)",
"def keystone_amq(self):\n\n connection = pika.BlockingConnection(pika.ConnectionParameters(\n host=self.rabbit_host,\n port=int(self.rabbit_port),\n credentials=pika.PlainCredentials(\n self.rabbit_user,\n self.rabbit_pass))\n )\n channel = connection.channel()\n channel.exchange_declare(exchange='keystone', type='topic')\n channel.queue_declare(queue=\"zcp-keystone\", exclusive=True)\n channel.queue_bind(exchange='keystone',\n queue=\"zcp-keystone\",\n routing_key='notifications.#')\n channel.basic_consume(self.keystone_callback,\n queue=\"zcp-keystone\",\n no_ack=True)\n channel.start_consuming()",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def _env_setup(self, initial_qpos):\n raise NotImplementedError()",
"def on_secondary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_secondary_channel = ch\n \n # Declare 'IN' queue - for receiving confirmations\n self.amqp_secondary_channel.queue_declare(queue=self.amqp_confirm_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_confirm_queue_declared)",
"async def do_startup(config, output_fname, event_loop):\n\n log.info(\"Creating AMQP receive channel ...\")\n rcv_trans, rcv_proto, rcv_chan = await make_amqp_channel(config)\n\n log.info(\"Setting up event exchange ...\")\n await rcv_chan.exchange_declare(\n exchange_name=config.event_exchange, type_name=\"fanout\"\n )\n\n logger = EventLogger(config, output_fname, event_loop)\n\n for signame in [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"]:\n signum = getattr(signal, signame)\n handler = partial(term_handler, signame=signame, loop=event_loop)\n event_loop.add_signal_handler(signum, handler)\n\n log.info(\"Setting up AMQP receiver ...\")\n bm_callback = partial(handle_broker_message, logger)\n await make_receiver_queue(bm_callback, rcv_chan, config, \"\")\n\n return rcv_trans, rcv_proto",
"def init_connect_mq(self):\n try:\n mq_username = Configs.mq_username\n mq_pwd = Configs.mq_pwd\n mq_ip_addr = Configs.mq_ip_addr\n mq_port_num = Configs.mq_port_num\n mq_vhost = Configs.mq_vhost\n\n mq_credentials = pika.PlainCredentials(mq_username, mq_pwd)\n mq_connection = pika.BlockingConnection(\n pika.ConnectionParameters(host=mq_ip_addr, port=mq_port_num, virtual_host=mq_vhost,\n credentials=mq_credentials))\n # connect to mq channel\n self.mq_channel = mq_connection.channel()\n self.mq_channel.exchange_declare(exchange=Configs.mq_exchange_name, exchange_type='topic', durable='true')\n # self.mq_channel.queue_declare(queue='test', durable=False, arguments={'x-message-ttl': 10000})\n self.mq_conn_flag = True\n print(\" ************** MQ Connect Success ************** \")\n except Exception as e:\n print(e)",
"def __init__(self, channel, exchange_name='SIAEF', type_exchange='direct',\n durable=True, auto_delete=False):\n self._channel = channel\n self._exchange = exchange_name\n self._type = type_exchange\n self._durable = durable\n self._auto_delete = auto_delete",
"def publish_message(message: str, broker_ip: str, exchange_name: str, exchange_type: str):\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host=broker_ip))\n channel = connection.channel()\n channel.exchange_declare(exchange=exchange_name, exchange_type=exchange_type, durable=True)\n channel.basic_publish(exchange=exchange_name, routing_key='', body=message)\n print(f'Published {message} to the exchange')\n connection.close()",
"def install(self):\r\n url = XQUEUE_STUB_URL + \"/set_config\"\r\n\r\n # Configure the stub to respond to submissions to our queue\r\n payload = {self._pattern: json.dumps(self._response_dict)}\r\n response = requests.put(url, data=payload)\r\n\r\n if not response.ok:\r\n raise XQueueResponseFixtureError(\r\n \"Could not configure XQueue stub for queue '{1}'. Status code: {2}\".format(\r\n self._pattern, self._response_dict))",
"def setExchange(self, exchange):\r\n\t\tself.exchange = exchange",
"def on_open_channel(new_channel):\n # assign new channel to the global channel variable\n global channel\n channel = new_channel\n\n # channel is assigned and declare a queue named scripbox.\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\n # Pass a callback on_queue_declared which fires when a queue declaration\n # is successful\n channel.queue_declare(queue='scripbox', durable=True,\n auto_delete=False, callback=on_queue_declared)",
"def setup(url=None):\n global TRANSPORT, NOTIFIER\n if not TRANSPORT:\n messaging.set_transport_defaults('payloadvoice')\n TRANSPORT = messaging.get_transport(\n cfg.CONF, url)\n if not NOTIFIER:\n serializer = RequestContextSerializer(None)\n NOTIFIER = messaging.Notifier(TRANSPORT, serializer=serializer)",
"def __init__(self, routing_key):\n self.routing_key = routing_key\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\n self.channel = self.connection.channel()\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\n self.callback_queue = result.method.queue\n\n self.channel.basic_consume(\n queue=self.callback_queue,\n on_message_callback=self.on_response,\n auto_ack=True\n )",
"def connectionMade(self):\r\n self.transport.uid = str(uuid.uuid1())\r\n\r\n self.guid = self.dispatcher.add(self.transport)\r\n self.dispatcher.send(self.guid, {'setup_connection': self.guid})",
"def configure_rabbit (ec2_conn,base_name,params ):\n print \"configuring rabbitmq exchanges and Queues\"\n app_type = 'RABBITMQ'\n \n logging.basicConfig()\n \n ## Allow security from build server to rabbitmq\n rabbit_lb_sec_grp_name = get_lb_secgrp_name( base_name, app_type )\n rabbit_lb_sec_grp = find_secgrp(ec2_conn, rabbit_lb_sec_grp_name)\n \n try :\n rabbit_lb_sec_grp.authorize( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr )\n except :\n print \"rule exists aready\" \n \n \n rabbitmq_host = params.get( 'host' )\n rabbitmq_port = params.get( 'port' )\n rabbitmq_username = params.get( 'user-name' )\n rabbitmq_password = params.get( 'password' )\n exchanges = params.get( 'exchanges' )\n \n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\n amqp_url = str(amqp_url)\n parameters = pika.URLParameters(amqp_url)\n connection = pika.BlockingConnection(parameters)\n channel = connection.channel()\n \n \n \n for exchnage in exchanges :\n exchange_name = exchnage.get(\"name\")\n exchange_type = exchnage.get(\"type\")\n queue_name = exchnage.get(\"queue\")\n routings = exchnage.get(\"bindings\")\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable=True )\n channel.queue_declare(queue=queue_name,\n durable=True)\n for routing in routings :\n channel.queue_bind(queue=queue_name, exchange=exchange_name, routing_key=routing)\n print \"binging exchnage: \" +exchange_name+\", to a queue:\"+queue_name+\" ,with routing key:\"+routing\n \n ## close connection at the end \n connection.close()\n \n ## At the end revoke the build server rule \n try :\n rabbit_lb_sec_grp.revoke( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr)\n \n except :\n print \"exception removing rule\"",
"def amqp(self, **options):\n pass",
"def setup(self):\n self.context = zmq.Context()\n self.sub_socket = self.context.socket(zmq.SUB)\n if self.filter:\n self.sub_socket.setsockopt(zmq.SUBSCRIBE, self.filter)\n self.sub_socket.connect('tcp://'+self.host+':'+str(self.com_port))\n return self",
"def on_queue_declared(self, frame):\n\t\tself.channel.basic_qos(prefetch_count=1)\n\t\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\t\tself.consumer_tag = self.channel.basic_consume(\n\t\t\tself.handle_delivery, \n\t\t\tframe.method.queue\n\t\t)",
"def setExchange(self, exchange):\r\n\t\tself.pair.exchange = exchange",
"def bind(self, exchange, routing_key='', arguments=None, timeout=None):\n\n log.debug(\"Binding exchange %r to exchange %r, routing_key=%r, arguments=%r\", self, exchange, routing_key,\n arguments)\n\n f = self._create_future(timeout)\n\n self._channel.exchange_bind(\n destination=self.name,\n source=self._get_exchange_name(exchange),\n routing_key=routing_key,\n arguments=arguments,\n callback=f.set_result,\n )\n\n return f",
"def _amqp_bind(self):\n if self.amqp_connection is not None:\n try:\n self.amqp_connection.close()\n except:\n pass\n\n self.amqp_connection = pika.BlockingConnection(\n pika.ConnectionParameters(\n host=self.amqp_server\n )\n )\n\n # listening channel for ermrest change notifications\n self.notice_channel = self.amqp_connection.channel()\n try:\n # newer pika API\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\n except TypeError as te:\n # try older API as fallback\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\n sys.stderr.write('ERMrest change-notice channel open.\\n')",
"def add_queue(self, queue_name, alt_exchange_name=None, passive=False, durable=False, arguments = None):\n amqp_session = self.__broker.getAmqpSession()\n if arguments == None:\n arguments = {}\n if alt_exchange_name:\n amqp_session.queue_declare(queue_name, alternate_exchange=alt_exchange_name, passive=passive,\n durable=durable, arguments=arguments)\n else:\n amqp_session.queue_declare(queue_name, passive=passive, durable=durable, arguments=arguments)",
"def declare_queue(self, queue_name):\n if queue_name not in self.queues:\n self.emit_before(\"declare_queue\", queue_name)\n self.queues.add(queue_name)\n self.emit_after(\"declare_queue\", queue_name)\n\n delayed_name = dq_name(queue_name)\n self.delay_queues.add(delayed_name)\n self.emit_after(\"declare_delay_queue\", delayed_name)",
"def __init__(self, options):\n self._options = options\n host = self._get_option('rabbit_host', 'str', 'localhost')\n port = self._get_option('rabbit_port', 'int', 5672)\n use_ssl = self._get_option('rabbit_use_ssl', 'bool', False)\n userid = self._get_option('rabbit_userid', 'str', 'guest')\n password = self._get_option('rabbit_password', 'str', 'guest')\n virtual_host = self._get_option('rabbit_virtual_host', 'str', '/')\n\n self.connection = kombu.connection.BrokerConnection(\n hostname=host,\n userid=userid,\n password=password,\n virtual_host=virtual_host,\n ssl=use_ssl)\n\n self.topic = self._get_option('rabbit_notification_topic',\n 'str',\n 'glance_notifications')",
"def connect(self):\n logger.info(\"[{}] Connecting to exchange {}\".format(self.bot_id, self.exchange))\n creds = pika.PlainCredentials(self.rabbit_user, self.rabbit_pw)\n return pika.SelectConnection(pika.ConnectionParameters(host=self.rabbit_host,\n port=self.rabbit_port,\n virtual_host='/',\n credentials=creds,\n socket_timeout=1,\n retry_delay=5 # 5 seconds\n ),\n self.on_connection_open,\n stop_ioloop_on_close=False)",
"def on_initial_bootstrap(self, process, config, **kwargs):\n\n # get default org_id\n # @TODO: single org assumed for now\n org_ids = process.container.resource_registry.find_resources(RT.Org, id_only=True)\n if not (len(org_ids) and len(org_ids[0]) == 1):\n raise StandardError(\"Could not determine org_id\")\n\n org_id = org_ids[0][0]\n\n ems_client = ExchangeManagementServiceProcessClient(process=process)\n\n #\n # Create XSs and XPs\n #\n for xsname, xsdict in config.get_safe('exchange_spaces', {}).iteritems():\n xso = ResExchangeSpace(name=xsname)\n xso_id = ems_client.create_exchange_space(xso, org_id)\n\n log.info(\"ExchangeSpace %s, id %s\", xsname, xso_id)\n\n for xpname, xpopts in xsdict.get('exchange_points', {}).iteritems():\n\n # @TODO: some translation for types CFG currentl has it as \"topic_tree\" and we've been using \"ttree\"\n ttype = xpopts.get('type', 'topic_tree')\n if ttype == \"topic_tree\":\n ttype = \"ttree\"\n\n xpo = ResExchangePoint(name=xpname, topology_type=ttype)\n xpo_id = ems_client.create_exchange_point(xpo, xso_id)\n\n log.info(\"\\tExchangePoint %s, id %s\", xpname, xpo_id)\n\n #\n # Create and associate brokers with XSs\n #\n for brokername in xsdict.get('brokers', []):\n xbo = ResExchangeBroker(name=brokername)\n xbo_id = ems_client.create_exchange_broker(xbo)\n\n log.info(\"\\tExchangeBroker %s, id %s\", brokername, xbo_id)\n\n # directly associate broker with XS\n # @TODO: should EMS provide this?\n # first find out if the assoc exists already\n assocs = process.container.resource_registry.find_associations(xso_id, PRED.hasExchangeBroker, id_only=True)\n if len(assocs) > 0:\n continue\n process.container.resource_registry.create_association(xso_id, PRED.hasExchangeBroker, xbo_id)",
"def start_consuming(self):\n logger.info('Issuing consumer related RPC commands')\n self.add_on_cancel_callback()\n logger.info(\"[{}] Waiting for messages on exchange {}\".format(self.bot_id, self.exchange))\n self._consumer_tag = self._channel.basic_consume(self.on_message,\n self.queue_name)",
"def setup_exchange(\n self,\n name: str,\n location: Location,\n api_key: ApiKey,\n api_secret: ApiSecret,\n database: 'DBHandler',\n passphrase: Optional[str] = None,\n **kwargs: Any,\n ) -> tuple[bool, str]:\n if location not in SUPPORTED_EXCHANGES: # also checked via marshmallow\n return False, f'Attempted to register unsupported exchange {name}'\n\n if self.get_exchange(name=name, location=location) is not None:\n return False, f'{location!s} exchange {name} is already registered'\n\n api_credentials = ExchangeApiCredentials(\n name=name,\n location=location,\n api_key=api_key,\n api_secret=api_secret,\n passphrase=passphrase,\n )\n exchange = self.initialize_exchange(\n module=self._get_exchange_module(location),\n credentials=api_credentials,\n database=database,\n **kwargs,\n )\n try:\n result, message = exchange.validate_api_key()\n except Exception as e: # pylint: disable=broad-except\n result = False\n message = str(e)\n\n if not result:\n log.error(\n f'Failed to validate API key for {location!s} exchange {name}'\n f' due to {message}',\n )\n return False, message\n\n self.connected_exchanges[location].append(exchange)\n return True, ''",
"def setup(self, **kwargs):\n raise ClixxException(\"Not implemented.\")",
"def listen_commands(self):\n self._consumer_rabbit_connection = BlockingConnection(ConnectionParameters(self._rabbit_host))\n self._consumer_rabbit_channel = self._consumer_rabbit_connection.channel()\n\n # Listen buy/sell orders from external system\n self._listen_queue(QueueName.CMD_BUYSELL, self.on_cmd_buysell)\n self._listen_queue(QueueName.MSG_RAW, self.on_raw_msg)\n # self._logger.info(f\"Declaring rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.queue_declare(queue=QueueName.CMD_BUYSELL, durable=True, auto_delete=True)\n # self._logger.info(f\"Consiming to rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.basic_consume(QueueName.CMD_BUYSELL, self.on_cmd_buysell,\n # consumer_tag=\"WebQuikBroker\")\n self._consumer_rabbit_channel.start_consuming()",
"def setup_broker(self, cfg=None):\n self.__broker = Broker()\n return self.broker",
"def setup(self, *args, **kwargs):\n pass",
"def __init__(self, connection, exchange, queue, routing_key,\n sub_worker, thread_support=True, no_declare=True):\n # Reduce logging from amqp module\n setup_logging(loglevel='INFO', loggers=['amqp'])\n logger.debug(f\"Initializating a new listener for exchange/queue: {exchange}/{queue}...\")\n self.connection = connection\n self.exchange = Exchange(exchange, 'direct',\n durable=True, no_declare=no_declare)\n self.queue = Queue(queue, exchange=self.exchange,\n routing_key=routing_key, no_declare=no_declare)\n self.queues = [self.queue]\n self.no_declare = no_declare\n logger.info(f\"New listener initialized for exchange/queue: {exchange}/{queue}...\")\n logger.debug(f\"Importing sub_worker module: {sub_worker}...\")\n self.sub_worker = sub_worker\n self.thread_support = thread_support\n mod_name = '.'.join(self.sub_worker.split(\".\")[:-1])\n try:\n self.sub_worker_mod = importlib.import_module(mod_name)\n except ModuleNotFoundError as e:\n logger.error(f\"Cannot import the sub worker module named {mod_name}: ModuleNotFoundError\")\n sys.exit(-1)\n except Exception as e:\n logger.error(f\"Cannot import the sub worker module named {mod_name}: \" + str(e))\n sys.exit(-1)",
"async def async_setup(self):\n set_log_levels(\n logger=\"info\",\n logger_pyinsteon=\"info\",\n logger_messages=\"info\",\n logger_topics=False,\n )\n self._address = random_address()\n self._group = 4\n self._hb_mgr = pyinsteon.managers.heartbeat_manager.HeartbeatManager(\n self._address, self._group\n )\n self._heartbeat = None\n self._heartbeat_on = None\n self._heartbeat_off = None\n self._hb_mgr.subscribe(self.heartbeat)\n self._hb_mgr.subscribe_on(self.heartbeat_on)\n self._hb_mgr.subscribe_off(self.heartbeat_off)\n self._on_topic = build_topic(\n ON, None, self._address, self._group, MessageFlagType.ALL_LINK_BROADCAST\n )\n self._off_topic = build_topic(\n OFF, None, self._address, self._group, MessageFlagType.ALL_LINK_BROADCAST\n )",
"def start_publishing(self):\n print(f\"{self._connection_param}: Issuing consumer related RPC commands\")\n # self._channel.confirm_delivery(self.on_delivery_confirmation)\n self.schedule_next_message(self.SLOW_SEND)",
"def setUpClass(cls):\n cls.producer = Producer()\n cls.producer.declare()",
"def setup(self):\n # create the pull socket (to communicate with this actor, others\n # process have to connect a push socket to this socket)\n self.pull_socket, pull_port = self._create_socket(zmq.PULL, -1)\n\n # create the control socket (to control this actor, a process have to\n # connect a pair socket to this socket with the `control` method)\n self.control_socket, ctrl_port = self._create_socket(zmq.PAIR, 0)\n\n self.pull_socket_address = LOCAL_ADDR + ':' + str(pull_port)\n self.control_socket_address = LOCAL_ADDR + ':' + str(ctrl_port)\n\n self._pull_port.value = pull_port\n self._ctrl_port.value = ctrl_port\n self._values_available.set()",
"async def bind(\n self,\n exchange: ExchangeParamType,\n routing_key: Optional[str] = None,\n *,\n arguments: Arguments = None,\n timeout: TimeoutType = None,\n ) -> aiormq.spec.Queue.BindOk:\n\n if routing_key is None:\n routing_key = self.name\n\n log.debug(\n \"Binding queue %r: exchange=%r, routing_key=%r, arguments=%r\",\n self,\n exchange,\n routing_key,\n arguments,\n )\n\n channel = await self.channel.get_underlay_channel()\n return await channel.queue_bind(\n self.name,\n exchange=get_exchange_name(exchange),\n routing_key=routing_key,\n arguments=arguments,\n timeout=timeout,\n )",
"def setup(self):\n global log_th, conf_th, header_th, command_w_th\n self.conf_th_ic = conf_th\n self.header_th_ic = header_th\n self.command_w_th_inc = command_w_th\n self.hostname = conf_th.get_item(q_key='general').get('hostname')\n self.std_recv_size = int(conf_th.get_item(q_key='general').get('std_recv_size'))\n self.data_recv_size = int(conf_th.get_item(q_key='general').get('data_recv_size'))\n self.mail_save_enable = int(conf_th.get_item(q_key='general').get('mail_save_enable'))\n self.mail_save_path = conf_th.get_item(q_key='general').get('mail_save_path')\n self.no_answer = int(conf_th.get_item(q_key='general').get('no_answer'))\n self.sleep_between = int(conf_th.get_item(q_key='general').get('sleep_between'))\n self.message_id = library.q_id_generate(size=16)\n self.client_ip = tuple(self.client_address).__getitem__(0)\n self.client_port = int(tuple(self.client_address).__getitem__(1))\n # Running\n self.header_th_ic.write_header(ip=self.client_ip, qid=self.message_id)\n message = '220 ' + self.hostname\n self.func_sender(message)\n log_th.log_info('{} connected to {} thread'.format(self.client_ip, threading.current_thread().name))",
"def declare_queue(self, c, queue_name):\n return self._management_req(\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\n {\"auto_delete\": False, \"durable\": False, \"arguments\": {}})",
"def _init_objects(self) -> None:\n self.position = selectors.get_position(self.exchange, self.symbol)\n self.broker = Broker(self.position, self.exchange, self.symbol, self.timeframe)\n\n if self.hp is None and len(self.hyperparameters()) > 0:\n self.hp = {}\n for dna in self.hyperparameters():\n self.hp[dna['name']] = dna['default']",
"def __init__(self, amqp_url, *handlers):\n\n self._consumer_tags = []\n\n RabbitMQ.__init__(self, amqp_url)\n\n # save our handlers for ruture use\n self._handlers = {}\n for handle in handlers:\n for k, v in handle.handlers().items():\n self._handlers[k] = v",
"async def _setup(self, *args, **kwargs):\n return self",
"def __init__(self, url, routing_key, log_file='/dev/null', exchange='yacamc_exchange', exchange_type='direct',\n queue=None, acked=True, sender=False, otq = False, log_level=logging.FATAL):\n\n if queue is None:\n queue = routing_key\n self.exchange = exchange\n self.exchange_type = exchange_type\n self.queue = queue\n self.routing_key = routing_key\n self._url = url\n self.acked = acked\n self.otq = otq\n\n self.cb = None\n\n self._connection = None\n self._channel = None\n self._closing = False\n\n log_format = '%(levelname) -10s %(asctime)s %(name) -30s %(funcName) -35s %(lineno) -5d: %(message)s'\n handler = logging.FileHandler(log_file)\n logging.basicConfig(level=log_level, format=log_format)\n self.logger = logging.getLogger(__name__)\n self.logger.addHandler(handler)\n\n # used only for sending\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n self._stopping = False\n self._done_sending = False\n self.message = \"\"\n self.sender = sender\n\n # self.run()\n # self._connection = self.connect()",
"async def setup(self, **kwargs):\n async with self.lock:\n # make configuration is locked so multiple tasks can't attempt\n if self.is_ready:\n return\n self.config = {**{\n 'bootstrap_servers': app_settings['kafka']['brokers'],\n 'value_serializer': lambda data: json.dumps(data).encode('utf-8')\n }, **kwargs}\n self.config.setdefault(\n 'loop', self.loop or asyncio.get_event_loop())\n if self.producer is None:\n producer = AIOKafkaProducer(**self.config)\n await producer.start()\n # delay setting the value until after the producer object\n # is setup; otherwise, other async tasks will attempt\n # to use this object before it is ready and get errors\n self.producer = producer\n return self.producer",
"def start(self):\n if not self._host:\n print(\"No host selected, starting local instance.\")\n self._database = quartjes.controllers.database.default_database()\n self._stock_exchange = quartjes.controllers.stock_exchange2.StockExchange2()\n else:\n reactor.callLater(0, self._connect) #@UndefinedVariable\n if not reactor.running: #@UndefinedVariable\n self._reactor_thread = ClientConnector._ReactorThread()\n self._reactor_thread.start()\n self._factory.wait_for_connection()\n\n self._database = self.get_service_interface(\"database\")\n self._stock_exchange = self.get_service_interface(\"stock_exchange\")",
"def on_init(self, queue=None, **kwargs):\n self.queue = queue if queue else Queue()",
"def run(self):\n\n self.make_connection()\n self.channel()\n self.declare_queue()\n self.publish_message()\n self.close_connection()",
"async def setup(self, ctx):\n pass",
"def on_bindok(self, unused_frame):\n\n self.logger.info('queue bound')\n if self.acked:\n # if we wish to care about the servers replies, this is were we set up things\n self.logger.info('issuing confirm.select RPC')\n self._channel.confirm_delivery(self.on_delivery_confirmation)\n\n if self.sender:\n pass\n self.send()\n else:\n self.start_consuming()",
"def setup_method(self, method):\n if _debug: TestAnnexJCodec._debug(\"setup_method %r\", method)\n\n # minature trapped stack\n self.client = TrappedClient()\n self.codec = AnnexJCodec()\n self.server = TrappedServer()\n bind(self.client, self.codec, self.server)",
"def setup(self):\n\n if self.has_setup():\n self.logger.info(\"%s has a pre-flight setup routine. Running now.\" % self.plugin_dict_name)\n self._module.setup(self, self.versions)",
"async def setup_event(self):\n # We may need stricter conditions, however, it seems likely that the\n # following is sufficient as:\n # a) The first message that will cause an update for both the order\n # websocket and the market data websocket would be a full, atomic\n # update. In other words, it seems that a single message is used\n # to send the full initial state for both sockets. If it too\n # multiple, then a more complex setup lock would be needed.\n # b) As we don't notify subscribers on heartbeats or subscription\n # acknowledgements, we can be certain that marking the client as\n # setup on the first received message is not premature, even if it\n # is just a heartbeat.\n await self._market_data_sock_info.ready.wait()\n if self._authenticate:\n await self._orders_sock_info.ready.wait()"
] | [
"0.8383794",
"0.7805345",
"0.7447871",
"0.7392415",
"0.7378925",
"0.71844965",
"0.7098805",
"0.7023513",
"0.69623685",
"0.6839282",
"0.67839456",
"0.66240335",
"0.6450134",
"0.63366437",
"0.63130057",
"0.63098747",
"0.63098747",
"0.63098747",
"0.6276163",
"0.61075",
"0.60983014",
"0.60890794",
"0.60017866",
"0.5894013",
"0.5889032",
"0.5876458",
"0.5758542",
"0.5754441",
"0.57318914",
"0.5712225",
"0.5588723",
"0.55818045",
"0.5569849",
"0.55445904",
"0.5537369",
"0.5526742",
"0.55259866",
"0.5518854",
"0.5518339",
"0.5509414",
"0.5454219",
"0.5453078",
"0.5449435",
"0.5402855",
"0.5347037",
"0.53445685",
"0.534295",
"0.53156364",
"0.5298946",
"0.5278197",
"0.52692246",
"0.52666783",
"0.5255425",
"0.52487093",
"0.52290356",
"0.52055395",
"0.52003276",
"0.51617426",
"0.5156403",
"0.5132157",
"0.5116958",
"0.5106471",
"0.50967354",
"0.50899047",
"0.5057561",
"0.50361264",
"0.49937207",
"0.4990374",
"0.49801922",
"0.49575406",
"0.49554232",
"0.49500817",
"0.49173066",
"0.4917025",
"0.49119407",
"0.49035072",
"0.49029127",
"0.48901966",
"0.4885529",
"0.48788807",
"0.48719198",
"0.4867937",
"0.48372695",
"0.48233166",
"0.4808944",
"0.48054585",
"0.48048908",
"0.48024762",
"0.4775683",
"0.47657633",
"0.47635108",
"0.4758815",
"0.4754268",
"0.4730848",
"0.47239754",
"0.47222093",
"0.47218725",
"0.47203186",
"0.4713769",
"0.47134602"
] | 0.75742984 | 2 |
Invoked by pika when RabbitMQ has finished the Exchange.Declare RPC command. | def on_exchange_declareok(self, _unused_frame):
self._channel_ctrl.queue_declare(
'',
exclusive=True,
auto_delete=True,
callback=self.on_queue_declareok
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_exchange_declareok(self, unused_frame):\n self.logger.info('exchange declared')\n self.setup_queue()",
"def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)",
"async def declare_exchange(self) -> asyncio.Future:\n # pylint: disable=protected-access\n future = self._backend._create_future()\n\n def on_declare_exchange(frame):\n future.set_result(frame)\n self.log.debug('Exchange `%s` declared ok', self.exchange)\n\n self._channel.exchange_declare(\n on_declare_exchange,\n self.exchange,\n self.exchange_type\n )\n\n return future",
"def declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self",
"def on_queue_declareok(self, method_frame):\n self.logger.info('binding %s and %s together with %s', self.exchange, self.queue, self.routing_key)\n self._channel.queue_bind(self.on_bindok, self.queue, self.exchange, self.routing_key)",
"def _declare(self, passive=False):\n arguments = dict(self._arguments)\n if self._expires:\n arguments['x-expires'] = self._expires\n if self._message_ttl:\n arguments['x-message-ttl'] = self._message_ttl\n if self._max_length:\n arguments['x-max-length'] = self._max_length\n if self._dlx:\n arguments['x-dead-letter-exchange'] = self._dlx\n if self._dlr:\n arguments['x-dead-letter-routing-key'] = self._dlr\n return specification.Queue.Declare(queue=self.name,\n durable=self._durable,\n passive=passive,\n exclusive=self._exclusive,\n auto_delete=self._auto_delete,\n arguments=arguments)",
"def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')",
"def declareDone(self, cmd):\n pass",
"def setup_exchange(self):\n self.logger.info('declaring exchange %s', self.exchange)\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)",
"def on_queue_declareok(self, method_frame):\n # LOGGER.info('Binding %s to %s with %s',\n # self.EXCHANGE, self.QUEUE, self.ROUTING_KEY)\n # self._channel.queue_bind(self.on_bindok, self.QUEUE,\n # self.EXCHANGE, self.ROUTING_KEY)\n logger.info(\n \"[{}] Binding to {} with queue {} and routing key \\\"\\\"\".format(self.bot_id, self.exchange,\n self.queue_name))\n\n self._channel.queue_bind(self.on_bindok,\n queue=self.queue_name,\n exchange=self.exchange,\n routing_key=\"\")",
"def setup_exchange(self, channel, exchange_name, exchange_type):\n logger.info('Declaring exchange : %s', exchange_name)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable = True)",
"def declare(self):\n self.channel.queue_declare(queue='files_to_database')",
"def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)",
"def on_queue_declared(self, frame):\n\t\tself.channel.basic_qos(prefetch_count=1)\n\t\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\t\tself.consumer_tag = self.channel.basic_consume(\n\t\t\tself.handle_delivery, \n\t\t\tframe.method.queue\n\t\t)",
"def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)",
"def setup_queue(self, method_frame):\n logger.info('Declaring queue %s', self.queue_name)\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\n\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)",
"def task_done(self):\n if self.message is None:\n raise Exception('no message to acknowledge')\n self.handle.delete_message(self.message)\n self.message = None",
"def on_queue_declareok(self, method_frame):\n\n for queue in self._handlers.keys():\n LOGGER.debug('Binding %s to %s with %s',\n self.EXCHANGE, queue, self.ROUTING_KEY)\n self._channel.queue_bind(self.on_bindok, queue,\n self.EXCHANGE, self.ROUTING_KEY)",
"def acq_done(self, pvname=None, **kws):\n if kws['value'] == 0:\n self.eventq.put('finish')",
"def acknowledged(self):\n ...",
"async def declare_and_consume(self, handler):\n try:\n await self.declare()\n self.consume(handler)\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.reconnect()",
"def setup_exchange(self):\n LOGGER.info('Declaring exchange: %s', self.topic_ctrl)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n\n self._channel_ctrl.exchange_declare(\n exchange=self.topic_ctrl,\n exchange_type='topic',\n callback=self.on_exchange_declareok)",
"def on_bindok(self, unused_frame):\n\n self.logger.info('queue bound')\n if self.acked:\n # if we wish to care about the servers replies, this is were we set up things\n self.logger.info('issuing confirm.select RPC')\n self._channel.confirm_delivery(self.on_delivery_confirmation)\n\n if self.sender:\n pass\n self.send()\n else:\n self.start_consuming()",
"async def _connect(self):\n self._connection = await connect_robust(self._connection_string)\n self._channel = await self._connection.channel()\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})",
"def rpc_sendback(rpc_flag):\n credential = pika.PlainCredentials('guest', 'guest')\n rpc_connection = pika.BlockingConnection(pika.ConnectionParameters(\n host='localhost', port=5672, virtual_host='/', credentials=credential))\n rpc_channel = rpc_connection.channel()\n rpc_channel.queue_declare(queue=str(rpc_flag))\n #send message to the command center using basic_publish\n if rpc_flag == \"c02\":\n rpc_channel.basic_publish(exchange='', routing_key=str(\n rpc_flag), body='Drone has reached the delivery address')\n elif rpc_flag == \"c03\":\n rpc_channel.basic_publish(exchange='', routing_key=str(rpc_flag),\n body='Drone has unloaded the item')\n elif rpc_flag == \"c04\":\n rpc_channel.basic_publish(exchange='', routing_key=str(rpc_flag),\n body='Drone has reached the parking spot and available for next instruction')",
"def process_create_q(self):\n while not self.create_req.empty():\n [new_name, new_type, mvt] = self.create_req.get()\n self.create_new_peer(new_type, new_name, mvt)\n self.create_req.task_done()",
"def setup_queue(self):\n self.logger.info('declaring queue %s', self.queue)\n if self.otq:\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\n else:\n self._channel.queue_declare(self.on_queue_declareok, self.queue)",
"def _listen_queue(self, queue, callback):\n # Listen buy/sell orders from external system\n self._logger.info(f\"Declaring rabbit queue {queue}\")\n self._consumer_rabbit_channel.queue_declare(queue=queue, durable=True, auto_delete=True)\n self._logger.info(f\"Declaring callback to rabbit queue: {queue}, callback: {callback}\")\n self._consumer_rabbit_channel.basic_consume(queue, callback,\n consumer_tag=queue)",
"def finished(self, reply):\n pass",
"def handleReceived():\r\n global receivedAck\r\n receivedAck = True",
"def callback(ch, method, properties, body):\n print(f\"[X] Received %r\" % body)\n\n # wait for certain time until task is completed\n time.sleep(body.count(b'.'))\n print(\"[X] Done\")\n\n \"\"\"Acknowledge after completing task this prevents message\n message loss when the worker dies. And when worker\n dies message will be passes to another online worker.\n Caution: We are not talking about worker node of RabbitMQ.\n \"\"\"\n ch.basic_ack(delivery_tag=method.delivery_tag)",
"def run(self):\n\n def callback(ch, method, properties, body):\n json_body = json.loads(body)\n self.buffer.append(Fvalue.fromdict(json_body))\n\n sleep(5) # We introduce a slight delay to let the RabbitMQ container to accept connections\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.mq_host,port=self.mq_port))\n channel = connection.channel()\n channel.exchange_declare(exchange=self.mq_host + '_exchange', exchange_type='direct')\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.queue_bind(exchange=self.mq_host + '_exchange',\n queue=queue_name,\n routing_key=self.routing_key)\n channel.basic_consume(callback,queue=queue_name,no_ack=True)\n channel.start_consuming()",
"def connectionMade(self):\n AMQClient.connectionMade(self)\n\n def eb(failure):\n log.err(failure)\n self.transport.loseConnection()\n\n d = self.gotConnection()\n d.addErrback(eb)",
"def handleReceived(): \n global receivedAck\n receivedAck = True",
"def start_publishing(self):\n print(f\"{self._connection_param}: Issuing consumer related RPC commands\")\n # self._channel.confirm_delivery(self.on_delivery_confirmation)\n self.schedule_next_message(self.SLOW_SEND)",
"def setup_queues_and_bindings(self):\n self._channel.exchange_declare(self.setup_queue, exchange=self.exchange, passive=True)",
"def connectionMade(self):\r\n self.transport.uid = str(uuid.uuid1())\r\n\r\n self.guid = self.dispatcher.add(self.transport)\r\n self.dispatcher.send(self.guid, {'setup_connection': self.guid})",
"def callback(ch, method, properties, body):\n ch.basic_ack(delivery_tag=method.delivery_tag)\n print(\"Message received.\")\n data = json.loads(body)\n persist(data)",
"def on_open_channel(new_channel):\n # assign new channel to the global channel variable\n global channel\n channel = new_channel\n\n # channel is assigned and declare a queue named scripbox.\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\n # Pass a callback on_queue_declared which fires when a queue declaration\n # is successful\n channel.queue_declare(queue='scripbox', durable=True,\n auto_delete=False, callback=on_queue_declared)",
"def setupFinished(self, *args, **kwargs): # real signature unknown\n pass",
"def start_finish(self):\r\n self.send_queue.put(('finish',))",
"def setup_queue(self, channel, queue_name):\n logger.info('Declaring queue %s', queue_name)\n channel.queue_declare(queue = queue_name, \n durable = True,\n auto_delete = False)",
"def declare_queue(self, topic):\n #from trove.rpc.impl_kombu import Connection\n from trove.openstack.common.rpc import create_connection\n with create_connection() as conn:\n consumer = conn.declare_topic_consumer(topic=topic)",
"def acknowledge(self, message: Message[ValueType]) -> Message[ValueType]:",
"def acknowledgement(self, message: Message[ValueType]):",
"def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True",
"def on_queue_declared(frame):\n start_consuming(frame)",
"def on_delivered(self, frame):\n pass",
"def keystone_amq(self):\n\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='keystone', type='topic')\n channel.queue_bind(exchange='openstack', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='keystone', queue=queue_name, routing_key='keystone.#')\n\n channel.basic_consume(self.keystone_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()",
"def on_message_received(ch, method, properties, body):\n # the body contains the command flag followed by a colon ':' and the message for the drone\n # decode the body to utf8\n received_bytes = body.decode('utf-8')\n # split the received_bytes to get the command _flag and message\n recieved_message = received_bytes.split(':')\n # since rabbit mq body is a byte\n if (str(recieved_message[0]) == \"c01\"):\n # c01 - command center orders the drone to deliver a item\n print(\"Order Received from the command center to deliver an item to the following address \\n\", str(\n recieved_message[1]))\n time.sleep(2)\n # print in the drone's console that the item has been lift off\n print('\\nLifting off the Item to the delivery address.')\n print('\\nUpdating Status to the command centre ......')\n # Assume the drone has reached the delivery address . Now send a\n # message to the warehouse command center that it has reached the\n # delivery area\n time.sleep(5)\n rpc_sendback(\"c02\")\n # Assume the drone has delivered the item and issue the status message\n # to the command center\n time.sleep(5)\n rpc_sendback(\"c03\")\n # #Assume the drone has reached the parking spot and issue the message to the command center that is available for next instruction\n time.sleep(5)\n rpc_sendback(\"c04\")\n\n else:\n print(\"Received Instruction from Warehouse \" +\n str(recieved_message[1]))\n channel.basic_ack(delivery_tag=method.delivery_tag)\n # channel.start_consuming()",
"def create_exchange(self, exchange_name, exchange_type, internal=None):\n self._channel.exchange_declare(\n exchange=exchange_name,\n durable=True, # Survive reboot\n passive=False, # Perform a declare or just to see if it exists\n internal=internal, # Can only be published to by other exchanges\n exchange_type=exchange_type\n )\n\n self.logger.debug('Created exchange: [name={}, type={}]'.format(\n exchange_name, exchange_type))",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def connectionMade(self):\n self.factory._r_on_connection_established(self)",
"def on_message(self, unused_channel, basic_deliver, properties, body):\n\n start = time.time()\n self.invocations += 1\n\n logger.info(\n u\"[{}] received message #{} from exchange {}: {}\".format(self.bot_id,\n basic_deliver.delivery_tag, self.exchange,\n body.decode('utf-8')))\n\n self.statsd.incr(self.statsd_prefix + \"message.receive\")\n\n # Ack the message before processing to tell rabbit we got it.\n # TODO before sending ack we should persist the message in a local queue to avoid the possibility of losing it\n self.acknowledge_message(basic_deliver.delivery_tag)\n\n try:\n\n try:\n json_body = json.loads(body)\n\n except ValueError as ve:\n logger.exception(\n \"[{}] Invalid JSON received from exchange: {} error: {} msg body: []\".format(self.bot_id,\n self.exchange,\n ve.message, body))\n raise\n\n else:\n response_messages = self.callback_func(json_body)\n\n if response_messages is None:\n response_messages = []\n\n logger.info(\"[{}] Sending {} response messages\".format(self.bot_id, len(response_messages)))\n\n for message in response_messages:\n self._channel.basic_publish(exchange=message.get('exchange', self.exchange),\n routing_key=message.get('queue', self.queue_name),\n body=message.get('body'))\n logger.info(\"[{}] published message {}\".format(self.bot_id, message))\n self.statsd.incr(self.statsd_prefix + \"message.publish\")\n\n except Exception as e:\n msg = \"[{}] Unexpected error - {}, message {}, from exchange {}. sending to error queue {}\"\n self.statsd.incr(self.statsd_prefix + \"message.error\")\n logger.exception(msg.format(self.bot_id, e, body, self.exchange, self.error_queue_name))\n self._channel.basic_publish(exchange='',\n routing_key=self.error_queue_name,\n body=body)\n\n\n exec_time_millis = int((time.time() - start) * 1000)\n self.total_execution_time += exec_time_millis\n\n logger.debug(\"Consumer {0} message handling time: {1}ms\".format(self.consumer_id, exec_time_millis))\n\n # if we have processed 100 messages, log out the average execution time at INFO then reset the total\n if self.invocations % 100 == 0:\n average_execution_time = self.total_execution_time / 100\n logger.info(\"Consumer {0} Avg message handling time (last 100): {1}ms\".format(self.consumer_id, average_execution_time))\n self.total_execution_time = 0\n\n self.statsd.timing(self.statsd_prefix + 'message.process.time', int((time.time() - start) * 1000))",
"def post(self):\n self.finish(self.register())",
"def run(self):\n self.channel.queue_declare(self._request_queue)\n self.channel.basic_consume(self._request_queue, self.on_message)\n try:\n msg = \"Waiting for message ...\"\n print(msg)\n logging.info(msg)\n self.channel.start_consuming()\n except KeyboardInterrupt:\n self.channel.stop_consuming()\n\n self.connection.close()",
"def start_consuming(self):\n logger.info('Issuing consumer related RPC commands')\n self.add_on_cancel_callback()\n logger.info(\"[{}] Waiting for messages on exchange {}\".format(self.bot_id, self.exchange))\n self._consumer_tag = self._channel.basic_consume(self.on_message,\n self.queue_name)",
"def on_message(self, unused_channel, basic_deliver, properties, body):\n logger.info('Received message # %s from %s: %s',\n basic_deliver.delivery_tag, properties.app_id, body)\n self.rx_queue.put(body)\n self.acknowledge_message(unused_channel, basic_deliver.delivery_tag)",
"def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel",
"def __init__(self, routing_key):\n self.routing_key = routing_key\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\n self.channel = self.connection.channel()\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\n self.callback_queue = result.method.queue\n\n self.channel.basic_consume(\n queue=self.callback_queue,\n on_message_callback=self.on_response,\n auto_ack=True\n )",
"def processCompleteMessage(self, msg):\r\n self._connection.receivedMessage(msg)",
"def _post(self, which_port, msg):\n return _spacegrant_swig.hdlc_deframer_sptr__post(self, which_port, msg)",
"def on_reply(self, msg: str):\n self._logger.debug(f\"Got msg: {msg}\")\n self._rabbit_channel.basic_publish(exchange='', routing_key=QueueName.MSG_REPLY, body=str(msg))",
"def _execute(self):\n LOG.info(\"Waiting for a message...\")",
"def amqp(self, **options):\n pass",
"def on_secondary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_secondary_channel = ch\n \n # Declare 'IN' queue - for receiving confirmations\n self.amqp_secondary_channel.queue_declare(queue=self.amqp_confirm_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_confirm_queue_declared)",
"def run(self):\n\n self.make_connection()\n self.channel()\n self.declare_queue()\n self.publish_message()\n self.close_connection()",
"def _post(self, which_port, msg):\n return _spacegrant_swig.hdlc_framer_sptr__post(self, which_port, msg)",
"def consumeMsg():\n\tosuser = 'osdev'\n\tospass = 'osdev'\n\toshost = '10.32.29.94'\n\tosport = '5672'\n\tosvhost = '/openstack'\n\tneutronExchange = Exchange('quantum', type='topic', durable=False)\n\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\n\t\t\trouting_key='notifications.info')\n\twith Connection(\"\".join(['amqp://', osuser, ':', ospass, '@', \n\t\toshost, ':',osport, '/', osvhost])) as conn:\n\t\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\n\t\t\twhile True:\n\t\t\t\ttry: \n\t\t\t\t\tconn.drain_events()\n\t\t\t\texcept Exception, e:\n\t\t\t\t\tlogging.exception('Draining events from AMQP stop')\n\t\t\t\t\tbreak",
"def on_bindok(self, unused_frame):\n logger.info('Queue bound')\n self.setup_error_queue()",
"def acqstart(self):\n return 0",
"def agent_behaviour(queue):\n\n gr = register_message()",
"def ack(self):\n self.consumer.ack(self)",
"def connection_made(self, transport):\n self._log.debug(\"Serial Connection Made\")\n if self.startByte is None:\n self.onReady(True)",
"def finish(self):\n self.connection.reset_arguments()\n self.connection.write_ok()",
"def acked(err, msg):\n if err is not None:\n print(\"Failed to deliver message: {}\".format(err))\n else:\n print(\"Produced record to topic {} partition [{}] @ offset {}\"\n .format(msg.topic(), msg.partition(), msg.offset()))",
"def setup_exchange(self):\n LOGGER.info('Setting the exchange with name :%s and type :%s',\n self._exchange, self._type)\n if self._channel is None:\n raise ChannelDoesntExist('The channel doesn''t exist')\n\n if len(self._exchange) < 3:\n raise ExchangeNameDoesntMatch('This exchange name does''nt match')\n # Check if the channel doesn't exist on rabbit\n\n list_rabbit_exchange = [] # Correct me\n if self._exchange in list_rabbit_exchange:\n raise ExchangeAlreadyExist('This exchange is already exist')\n\n # Check Me : self._channel.basic_qos(prefetch_count=1)\n self._channel.exchange_declare(exchange=self._exchange,\n type=self._type,\n durable=self._durable,\n auto_delete=self._auto_delete)",
"def start_consuming(self):\n self.logger.debug(\"Issuing consumer related RPC commands\")\n\n self._channel.basic_qos(prefetch_count=self._max_concurrent)\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\n consume_kwargs = {\"queue\": self._queue_name}\n if PIKA_ONE:\n consume_kwargs[\"on_message_callback\"] = self.on_message\n else:\n consume_kwargs[\"consumer_callback\"] = self.on_message\n\n self._consumer_tag = self._channel.basic_consume(**consume_kwargs)",
"def item_done(self, rsp=None):\n self.export.item_done(rsp)",
"def finish_message(self, basic_deliver, future):\n delivery_tag = basic_deliver.delivery_tag\n\n if not future.exception():\n try:\n self.logger.debug(\"Acking message %s\", delivery_tag)\n self._channel.basic_ack(delivery_tag)\n except Exception as ex:\n self.logger.exception(\n \"Error acking message %s, about to shut down: %s\", delivery_tag, ex\n )\n self._panic_event.set()\n else:\n real_ex = future.exception()\n\n if isinstance(real_ex, RepublishRequestException):\n try:\n with BlockingConnection(self._connection_parameters) as c:\n headers = real_ex.headers\n headers.update({\"request_id\": real_ex.request.id})\n props = BasicProperties(\n app_id=\"beer-garden\",\n content_type=\"text/plain\",\n headers=headers,\n priority=1,\n delivery_mode=PERSISTENT_DELIVERY_MODE,\n )\n c.channel().basic_publish(\n exchange=basic_deliver.exchange,\n properties=props,\n routing_key=basic_deliver.routing_key,\n body=SchemaParser.serialize_request(real_ex.request),\n )\n\n self._channel.basic_ack(delivery_tag)\n except Exception as ex:\n self.logger.exception(\n \"Error republishing message %s, about to shut down: %s\",\n delivery_tag,\n ex,\n )\n self._panic_event.set()\n elif isinstance(real_ex, DiscardMessageException):\n self.logger.info(\n \"Nacking message %s, not attempting to requeue\", delivery_tag\n )\n self._channel.basic_nack(delivery_tag, requeue=False)\n else:\n # If request processing throws anything else we terminate\n self.logger.exception(\n \"Unexpected exception during request %s processing, about \"\n \"to shut down: %s\",\n delivery_tag,\n real_ex,\n exc_info=False,\n )\n self._panic_event.set()",
"def onDone(self):\n pass",
"def on_primary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_primary_channel = ch\n \n # For receiving confirmations...\n if self.receive_delivery_confirmations:\n self.amqp_primary_channel.confirm_delivery(callback=self.on_delivered, nowait=True)\n \n # Declare 'IN' queue - for receiving items to queue\n self.amqp_primary_channel.queue_declare(queue=self.amqp_in_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_in_queue_declared)\n \n # Declare 'fanout' exchange - for broadcasting items\n # The fanout exchange is very simple. It just broadcasts all the\n # messages it receives to all the queues it knows.\n self.amqp_primary_channel.exchange_declare(exchange=self.amqp_broadcast_exchange, type='fanout',\n callback=self.on_exchange_declared)",
"def send_complete_message(queue):\n local = SocketIO(message_queue=queue)\n local.emit('complete', {'data': 'Operation complete!'})",
"def process_amqp_events(self):\n self.connection.process_data_events()",
"def setup_error_queue(self):\n logger.info('Declaring error queue %s', self.error_queue_name)\n\n self._channel.queue_declare(self.on_error_queue_declareok,queue=self.error_queue_name, durable=True, exclusive=False)",
"def handle_delivery(self, channel, method_frame, header_frame, body):\n try:\n channel.basic_ack(delivery_tag=method_frame.delivery_tag)\n except:\n print 'Error acking'\n json_data = None\n print 'ff'\n ## Is this a string if so; convert to json object\n ## else determine what type of object\n if isinstance(body, types.StringType):\n ## what type of string is this. json??\n ## if it is .. determine what data structures inside\n try:\n _type = json.loads(body)\n except:\n print 'Failed in the json.loads'\n pass\n try:\n self.batch.append(_type)\n if len(self.batch) > self.state[\"batch_len\"]:\n print 'trigger'\n self.coll.insert(self.batch)\n self.batch = []\n except:\n print 'Failed in insert'\n pass\n return 0",
"def declare_queue(self, queue_name):\n if queue_name not in self.queues:\n self.emit_before(\"declare_queue\", queue_name)\n self.queues.add(queue_name)\n self.emit_after(\"declare_queue\", queue_name)\n\n delayed_name = dq_name(queue_name)\n self.delay_queues.add(delayed_name)\n self.emit_after(\"declare_delay_queue\", delayed_name)",
"def resolve_message(self, rq):\n\n if rq.command == u\"initialize\":\n self.next_seq += 1\n DAPInitializeResponse.create(self.next_seq, rq.seq, True, rq.command, body=DAPCapabilities.create(**features)).send(self._current_client)\n self.next_seq += 1\n DAPInitializedEvent.create(self.next_seq).send(self._current_client)\n elif rq.command == u\"setBreakpoints\":\n self.next_seq += 1\n bkps = self.create_breakpoints(**rq.get_arguments().as_current_kwargs())\n body = DAPSetBreakpointsResponseBody.create([b.serialize() for b in bkps])\n DAPSetBreakpointsResponse.create(self.next_seq, rq.seq, True, body).send(self._current_client)\n elif rq.command == u\"configurationDone\":\n self.next_seq += 1\n DAPConfigurationDoneResponse.create(self.next_seq, rq.seq, True).send(self._current_client)\n elif rq.command == u\"launch\":\n # no special noDebug\n self.next_seq += 1\n DAPLaunchResponse.create(self.next_seq, rq.seq, True).send(self._current_client)\n self._ready_for_events = True\n elif rq.command == u\"disconnect\":\n self.next_seq += 1\n DAPDisconnectResponse.create(self.next_seq, rq.seq, True).send(self._current_client)\n self._current_client.close()\n self._current_client = None\n return\n elif rq.command == u\"continue\":\n self.next_seq += 1\n body = DAPContinueResponseBody.create(all_threads_continued=True)\n DAPContinueResponse.create(self.next_seq, rq.seq, True, body).send(self._current_client)\n debugger.stepping = SteppingMode.STEP_NO_STEP\n debugger.continue_next()\n elif rq.command == u\"threads\":\n self.next_seq += 1\n body = DAPThreadsResponseBody.create([DAPThread.create(0, \"renpy_main\")])\n DAPThreadsResponse.create(self.next_seq, rq.seq, True, body).send(self._current_client)\n elif rq.command == u\"stackTrace\":\n self.next_seq += 1\n body = DAPStackTraceResponseBody.create(debugger.get_stack_frames(**rq.get_arguments().as_current_kwargs()))\n DAPStackTraceResponse.create(self.next_seq, rq.seq, True, body).send(self._current_client)\n elif rq.command == u\"scopes\":\n self.next_seq += 1\n body = DAPScopesResponseBody.create(debugger.get_scopes(int(rq.get_arguments().get_frame_id())))\n DAPScopesResponse.create(self.next_seq, rq.seq, True, body).send(self._current_client)\n elif rq.command == u\"variables\":\n self.next_seq += 1\n body = DAPVariablesResponseBody.create(debugger.format_variable(**rq.get_arguments().as_current_kwargs()))\n DAPVariablesResponse.create(self.next_seq, rq.seq, True, body).send(self._current_client)\n elif rq.command == u\"pause\":\n self.next_seq += 1\n DAPPauseResponse.create(self.next_seq, rq.seq, True).send(self._current_client)\n debugger.break_pause = True\n elif rq.command == u\"next\":\n print(\"STEP\")\n self.next_seq += 1\n DAPNextResponse.create(self.next_seq, rq.seq, True).send(self._current_client)\n debugger.store_frames()\n debugger.stepping = SteppingMode.STEP_NEXT\n debugger.continue_next()\n elif rq.command == u\"stepIn\":\n self.next_seq += 1\n DAPStepInResponse.create(self.next_seq, rq.seq, True).send(self._current_client)\n debugger.store_frames()\n debugger.stepping = SteppingMode.STEP_INTO\n debugger.continue_next()\n elif rq.command == u\"stepOut\":\n self.next_seq += 1\n DAPStepOutResponse.create(self.next_seq, rq.seq, True).send(self._current_client)\n debugger.store_frames()\n debugger.stepping = SteppingMode.STEP_OUT\n debugger.continue_next()\n else:\n self.next_seq += 1\n DAPErrorResponse.create(self.next_seq, rq.seq, False, message=\"NotImplemented\").send(self._current_client)",
"def __answer(self, msg: str):\n self.channel.basic_publish(\n exchange='main', routing_key='answer', body=msg)",
"def _cleanup_method(self, queue_name, ep=None):\n if ep._chan is not None and not ep._chan._queue_auto_delete:\n # only need to delete if AMQP didn't handle it for us already!\n # @TODO this will not work with XOs (future)\n try:\n ch = self.container.node.channel(RecvChannel)\n ch._recv_name = NameTrio(get_sys_name(), \"%s.%s\" % (get_sys_name(), queue_name))\n ch._destroy_queue()\n except TransportError as ex:\n log.warn(\"Cleanup method triggered an error, ignoring: %s\", ex)",
"def on_message_callback_complete(self, basic_deliver, future):\n self._connection.ioloop.add_callback_threadsafe(\n partial(self.finish_message, basic_deliver, future)\n )",
"def publish_message(message: str, broker_ip: str, exchange_name: str, exchange_type: str):\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host=broker_ip))\n channel = connection.channel()\n channel.exchange_declare(exchange=exchange_name, exchange_type=exchange_type, durable=True)\n channel.basic_publish(exchange=exchange_name, routing_key='', body=message)\n print(f'Published {message} to the exchange')\n connection.close()",
"def broker_connect_reply(self, data):\n\n print(\"Broker Connected\")\n #IDEA: Does this need a handler?",
"def listen_commands(self):\n self._consumer_rabbit_connection = BlockingConnection(ConnectionParameters(self._rabbit_host))\n self._consumer_rabbit_channel = self._consumer_rabbit_connection.channel()\n\n # Listen buy/sell orders from external system\n self._listen_queue(QueueName.CMD_BUYSELL, self.on_cmd_buysell)\n self._listen_queue(QueueName.MSG_RAW, self.on_raw_msg)\n # self._logger.info(f\"Declaring rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.queue_declare(queue=QueueName.CMD_BUYSELL, durable=True, auto_delete=True)\n # self._logger.info(f\"Consiming to rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.basic_consume(QueueName.CMD_BUYSELL, self.on_cmd_buysell,\n # consumer_tag=\"WebQuikBroker\")\n self._consumer_rabbit_channel.start_consuming()",
"def MessageAck(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)",
"def connectionMade(self):\n self._pid = self.transport.pid\n if self._pid:\n self.logger(\"Process has pid %d\" % self._pid)\n self.transport.closeStdin() # close stdin"
] | [
"0.715761",
"0.6964966",
"0.64156866",
"0.61320156",
"0.6064579",
"0.6064579",
"0.6064579",
"0.6040164",
"0.60303724",
"0.6024567",
"0.6008154",
"0.59611946",
"0.5960115",
"0.5942857",
"0.59143645",
"0.5890094",
"0.58587295",
"0.58443904",
"0.5769042",
"0.57334083",
"0.56965804",
"0.56940883",
"0.5686021",
"0.56322503",
"0.5595592",
"0.5518226",
"0.55104",
"0.54856807",
"0.5483979",
"0.54575163",
"0.5441746",
"0.5432475",
"0.5431004",
"0.5428449",
"0.5423964",
"0.5416232",
"0.5408827",
"0.5398502",
"0.5392296",
"0.5387189",
"0.53807926",
"0.53245544",
"0.5321994",
"0.5300281",
"0.52991104",
"0.52810705",
"0.5270515",
"0.52581024",
"0.5236953",
"0.52234244",
"0.52064973",
"0.52063304",
"0.51882297",
"0.5159087",
"0.5146391",
"0.51431465",
"0.5128809",
"0.5125307",
"0.51187456",
"0.5117978",
"0.51173",
"0.5116646",
"0.51108557",
"0.5099538",
"0.5096952",
"0.50891215",
"0.50750387",
"0.50748116",
"0.50723225",
"0.5062748",
"0.5034104",
"0.50309837",
"0.5027802",
"0.50268465",
"0.5025666",
"0.50212926",
"0.5019259",
"0.50172424",
"0.5006756",
"0.5002955",
"0.4992302",
"0.49822044",
"0.49741298",
"0.4961925",
"0.4954149",
"0.4952012",
"0.4944356",
"0.4929123",
"0.4927448",
"0.4923564",
"0.49153376",
"0.49132282",
"0.49013752",
"0.49011758",
"0.4899168",
"0.48949695",
"0.48919523",
"0.48793998",
"0.48712936",
"0.48683673"
] | 0.7317034 | 0 |
This method sets up the consumer by first calling add_on_cancel_callback so that the object is notified if RabbitMQ cancels the consumer. It then issues the Basic.Consume RPC command which returns the consumer tag that is used to uniquely identify the consumer with RabbitMQ. We keep the value to use it when we want to cancel consuming. The on_message method is passed in as a callback pika will invoke when a message is fully received. | def start_consuming(self):
# LOGGER.info('Issuing consumer related RPC commands')
if self._init_ok_ctrl and self._init_ok_task:
self._channel_ctrl.add_on_cancel_callback(self.on_consumer_ctrl_cancelled)
self._channel_task.add_on_cancel_callback(self.on_consumer_task_cancelled)
self._consumer_tag_task = self._channel_task.basic_consume(
self.queue_task,
auto_ack=False,
on_message_callback=self.on_message
)
self._consumer_tag_ctrl = self._channel_ctrl.basic_consume(
self._topic_queue_name,
auto_ack=False,
on_message_callback=self.on_topic
)
self.was_consuming = True
self._consuming = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_consuming(self):\n self.logger.debug(\"Issuing consumer related RPC commands\")\n\n self._channel.basic_qos(prefetch_count=self._max_concurrent)\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\n consume_kwargs = {\"queue\": self._queue_name}\n if PIKA_ONE:\n consume_kwargs[\"on_message_callback\"] = self.on_message\n else:\n consume_kwargs[\"consumer_callback\"] = self.on_message\n\n self._consumer_tag = self._channel.basic_consume(**consume_kwargs)",
"def start_consuming(self):\n logger.info('Issuing consumer related RPC commands')\n self.add_on_cancel_callback()\n logger.info(\"[{}] Waiting for messages on exchange {}\".format(self.bot_id, self.exchange))\n self._consumer_tag = self._channel.basic_consume(self.on_message,\n self.queue_name)",
"def consume(self):\n LOGGER.debug('Consumer Initialized')\n # self.connect()\n channel = self.get_channel()\n self._bind_things(channel)\n\n try:\n LOGGER.info('Start consuming')\n channel.start_consuming()\n except ConnectionClosed:\n LOGGER.exception('Pika connection closed detected. Will attempt to start consuming again')\n self.consume()\n except KeyboardInterrupt as e:\n LOGGER.info('Keyboard interrupt, stop consuming')\n self.shutdown()\n raise e\n except Exception as e:\n LOGGER.exception(\"'%s\" % str(e))\n self.shutdown()\n if self.settings.CONSUMER['RAISE_EXCEPTION']:\n LOGGER.info(\"CONSUMER RAISED EXCEPTION\")\n raise e",
"def consume(self, handler):\n bounded_handler = partial(handler, self)\n self._consume_handler = handler\n self.log.debug(\"Start consuming\")\n self._channel.add_on_close_callback(\n self.on_channel_closed\n )\n self._consumer_tag = self._channel.basic_consume(bounded_handler,\n self.name)\n self.log.debug(\"Consumer tag %s on CHANNEL%i\",\n self._consumer_tag, self._channel.channel_number)",
"def __init__(self, consumer):\n self._consumer = consumer",
"def consumer(self, consumer):\n self._consumer = consumer",
"def async_consume(self, callback, auto_ack=False):\n logging.info(\"Async consume\")\n if self.thread is not None:\n return\n self.thread_stop = False\n\n def wrapped_callback(ch, method, properties, body):\n #logging.info(\"Wrapped callback'd\")\n callback(ch, method, properties, body)\n #if not self.thread_stop:\n # callback(ch, method, properties, body)\n #else:\n # print(\"Should stop now!\")\n # callback(ch, method, properties, body)\n # self.channel.basic_cancel(self.tag)\n # exit\n\n self.thread = threading.Thread(target=self.consume, args=(wrapped_callback,),\n kwargs={\"auto_ack\":auto_ack})\n self.thread.start()",
"def start_consuming(self):\n\n for queue in self._handlers.keys():\n self._consumer_tags += self._channel.basic_consume(self.on_message,\n queue=queue)",
"def start_consuming(self, channel, rx_queue_name):\n if self.should_stop():\n logger.info(\"ready to stop, pause to consume\")\n return\n logger.info('Issuing consumer related RPC commands')\n self._consumer_tag = channel.basic_consume(\n self.on_message, rx_queue_name, auto_ack = False)\n channel.start_consuming()",
"def consumer(self):\n return self._consumer",
"def subscribe(self, callback):\n self.channel.basic_consume(callback, queue=self.queue_name)\n self.channel.start_consuming()",
"def consume():\n with conn.channel() as chan:\n \n def on_msg_recv(msg):\n \"\"\" Called when message arrives from RabbitMQ\n \"\"\"\n print \"processor|%s::Received message: %s\" % (UID, msg.body)\n chan.basic_ack(msg.delivery_tag)\n log(msg.body)\n process_msg(msg)\n \n \n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\n chan.exchange_declare(exchange = EXCHANGE,\n type = EXCHANGE_TYPE)\n queue = chan.queue_declare(QUEUE)\n chan.queue_bind(exchange = EXCHANGE, \n queue = QUEUE, \n routing_key = ROUTING_KEY)\n \n # Declare that we are going to listen to given queue\n chan.basic_consume(queue = QUEUE, \n callback = on_msg_recv)\n \n # Main loop. Waiting for messages from RabbitMQ.\n while True:\n chan.wait()",
"def stop_consuming(self):\n if self._channel:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._channel.basic_cancel(self.on_cancelok, self._consumer_tag)",
"def __init__(self, bot_id, exchange, callback_func, rabbit_user, rabbit_pw, rabbit_host,\n rabbit_port, consumer_id = 0, internal_error_queue = None, statsd = None):\n\n super(RabbitConsumer, self).__init__()\n\n self.rabbit_port = rabbit_port\n self.rabbit_host = rabbit_host\n self.rabbit_pw = rabbit_pw\n self.rabbit_user = rabbit_user\n self.bot_id = bot_id\n self.exchange = exchange\n self.callback_func = callback_func\n self._closing = False\n self.stopped = False\n self._connection = None\n self._channel = None\n self._closing = False\n self._consumer_tag = None\n\n self.queue_name = self.exchange + \"-\" + self.bot_id\n self.error_queue_name = 'error-' + self.bot_id + \"-\" + self.exchange\n self.consumer_id = consumer_id\n self.internal_error_queue = internal_error_queue\n\n self.statsd = statsd\n\n self.statsd_prefix = self.exchange + \".\"\n\n self.invocations = 0\n self.total_execution_time = 0",
"def consumeMsg():\n\tosuser = 'osdev'\n\tospass = 'osdev'\n\toshost = '10.32.29.94'\n\tosport = '5672'\n\tosvhost = '/openstack'\n\tneutronExchange = Exchange('quantum', type='topic', durable=False)\n\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\n\t\t\trouting_key='notifications.info')\n\twith Connection(\"\".join(['amqp://', osuser, ':', ospass, '@', \n\t\toshost, ':',osport, '/', osvhost])) as conn:\n\t\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\n\t\t\twhile True:\n\t\t\t\ttry: \n\t\t\t\t\tconn.drain_events()\n\t\t\t\texcept Exception, e:\n\t\t\t\t\tlogging.exception('Draining events from AMQP stop')\n\t\t\t\t\tbreak",
"def consumer(self):\n return Consumer(app=self.app, client=self.client)",
"def _mp_consume(client, group, topic, queue, size, events, **consumer_options):\n\n # Initial interval for retries in seconds.\n interval = 1\n while not events.exit.is_set():\n try:\n # Make the child processes open separate socket connections\n client.reinit()\n\n # We will start consumers without auto-commit. Auto-commit will be\n # done by the master controller process.\n consumer = SimpleConsumer(client, group, topic,\n auto_commit=False,\n auto_commit_every_n=None,\n auto_commit_every_t=None,\n **consumer_options)\n\n # Ensure that the consumer provides the partition information\n consumer.provide_partition_info()\n\n while True:\n # Wait till the controller indicates us to start consumption\n events.start.wait()\n\n # If we are asked to quit, do so\n if events.exit.is_set():\n break\n\n # Consume messages and add them to the queue. If the controller\n # indicates a specific number of messages, follow that advice\n count = 0\n\n message = consumer.get_message()\n if message:\n while True:\n try:\n queue.put(message, timeout=FULL_QUEUE_WAIT_TIME_SECONDS)\n break\n except queue.Full:\n if events.exit.is_set():\n break\n\n count += 1\n\n # We have reached the required size. The controller might have\n # more than what he needs. Wait for a while.\n # Without this logic, it is possible that we run into a big\n # loop consuming all available messages before the controller\n # can reset the 'start' event\n if count == size.value:\n events.pause.wait()\n\n else:\n # In case we did not receive any message, give up the CPU for\n # a while before we try again\n time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)\n\n consumer.stop()\n\n except KafkaError as e:\n # Retry with exponential backoff\n log.error(\n \"Problem communicating with Kafka (%s), retrying in %d seconds...\" % (e, interval))\n time.sleep(interval)\n interval = interval * 2 if interval * 2 < MAX_BACKOFF_SECONDS else MAX_BACKOFF_SECONDS",
"def _listen_queue(self, queue, callback):\n # Listen buy/sell orders from external system\n self._logger.info(f\"Declaring rabbit queue {queue}\")\n self._consumer_rabbit_channel.queue_declare(queue=queue, durable=True, auto_delete=True)\n self._logger.info(f\"Declaring callback to rabbit queue: {queue}, callback: {callback}\")\n self._consumer_rabbit_channel.basic_consume(queue, callback,\n consumer_tag=queue)",
"async def consumer(message):\n # TODO\n print(message)",
"def consumer(self, no_ack=False, prefetch=100, priority=None):\n if prefetch is not None:\n self.channel.prefetch_count(prefetch)\n self.channel._consume(self, no_ack, priority)\n self.consuming = True\n yield Consumer(self)",
"def _consume(self):\n # HACK: run_in_executor is used as a workaround to use boto\n # inside a coroutine. This is a stopgap solution that should be\n # replaced once boto has support for asyncio or aiobotocore has\n # a stable release.\n loop = asyncio.get_event_loop()\n receive_message = partial(\n self.client.receive_message,\n QueueUrl=self.app.settings['SQS_INBOUND_QUEUE_URL'],\n AttributeNames=self.app.settings['SQS_ATTRIBUTE_NAMES'],\n MessageAttributeNames=self.app.settings['SQS_MESSAGE_ATTRIBUTES'],\n MaxNumberOfMessages=self.app.settings['SQS_MESSAGE_BATCH_SIZE'],\n VisibilityTimeout=self.app.settings['SQS_VISIBILITY_TIMEOUT'],\n WaitTimeSeconds=self.app.settings['SQS_WAIT_TIME'],\n )\n while True:\n future = loop.run_in_executor(None, receive_message)\n messages = yield from future\n for message in messages.get('Messages', []):\n message['Body'] = json.loads(message['Body'])\n yield from self._message_queue.put(message)",
"def getConsumer(self, topic):\n\n consumer = topic.get_balanced_consumer(zookeeper_connect=self.zookeeper_server, \n consumer_group=self.consumer_group,\n use_rdkafka=self.use_rdkafka,\n auto_offset_reset=self.initial_offset)\n self.consumer_started = True\n\n return consumer",
"def _begin_consuming(self):\n self._consuming = True\n loop = asyncio.get_event_loop()\n self._message_queue = asyncio.Queue(\n maxsize=self.app.settings['SQS_PREFETCH_LIMIT'],\n loop=loop,\n )\n loop.create_task(self._consume())",
"def stop_consuming(self):\n if self._channel:\n self.logger.debug(\"Stopping message consuming on channel %i\", self._channel)\n\n self._connection.ioloop.add_callback_threadsafe(\n partial(\n self._channel.basic_cancel,\n consumer_tag=self._consumer_tag,\n callback=lambda *args: None,\n )\n )",
"def create_consumer(self, topic_id: str, callback: Callable, gcp_subscription_id:str=None):\n backend = None\n if self.vendor == 'kafka':\n backend = KafkaClient(topic_id, self.configs['kafka_servers'])\n Consumer(backend, callback)\n else:\n project_id = os.getenv(\"GOOGLE_CLOUD_PROJECT\")\n subscription_id = gcp_subscription_id\n backend = GooglePubSubClient(project_id=project_id, topic=topic_id,\n subscription_id=subscription_id, gcp_configs=self.configs, callback=callback)\n runner_thread = Thread(target=runner)\n runner_thread.start()",
"def add_on_cancel_callback(self):\n logger.info('Adding consumer cancellation callback')\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)",
"def on_queue_declared(self, frame):\n\t\tself.channel.basic_qos(prefetch_count=1)\n\t\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\t\tself.consumer_tag = self.channel.basic_consume(\n\t\t\tself.handle_delivery, \n\t\t\tframe.method.queue\n\t\t)",
"def subscribeConsumer(consumer):",
"def start_publishing(self):\n print(f\"{self._connection_param}: Issuing consumer related RPC commands\")\n # self._channel.confirm_delivery(self.on_delivery_confirmation)\n self.schedule_next_message(self.SLOW_SEND)",
"def _mp_consume(client, group, topic, chunk, queue, start, exit, pause, size):\n\n # Make the child processes open separate socket connections\n client.reinit()\n\n # We will start consumers without auto-commit. Auto-commit will be\n # done by the master controller process.\n consumer = SimpleConsumer(client, group, topic,\n partitions=chunk,\n auto_commit=False,\n auto_commit_every_n=None,\n auto_commit_every_t=None)\n\n # Ensure that the consumer provides the partition information\n consumer.provide_partition_info()\n\n while True:\n # Wait till the controller indicates us to start consumption\n start.wait()\n\n # If we are asked to quit, do so\n if exit.is_set():\n break\n\n # Consume messages and add them to the queue. If the controller\n # indicates a specific number of messages, follow that advice\n count = 0\n\n message = consumer.get_message()\n if message:\n queue.put(message)\n count += 1\n\n # We have reached the required size. The controller might have\n # more than what he needs. Wait for a while.\n # Without this logic, it is possible that we run into a big\n # loop consuming all available messages before the controller\n # can reset the 'start' event\n if count == size.value:\n pause.wait()\n\n else:\n # In case we did not receive any message, give up the CPU for\n # a while before we try again\n time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)\n\n consumer.stop()",
"def consume(self, consume_mode):\n resp = yield from self.command('consume {}'.format(consume_mode))\n return True",
"def _stop_consuming(self):\n if self._rx_channel and self._rx_channel.is_open:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._rx_channel.basic_cancel(consumer_tag=self._consumer_tag)\n logger.info(\"stop consuming\")",
"def consume_ack(self, event):\n pass",
"async def decoder(\n queue: asyncio.Queue[ConsumerPayload],\n consumer: AIOKafkaConsumer,\n) -> int:\n log.info(\"decoder: starting\")\n try:\n async for msg in consumer:\n if msg.value == EOT:\n log.info(\"decoder: EOT received\")\n break\n log.info(\n \"consumed: %s %s %s %s %s %s\",\n msg.topic,\n msg.partition,\n msg.offset,\n msg.key,\n msg.value,\n msg.timestamp,\n )\n bpayload: bytes = msg.value\n payload: ConsumerPayload = json.loads(bpayload)\n await queue.put(payload)\n except Exception:\n log.exception(\"decoder: exception\")\n log.info(\"decoder: exiting\")\n return 0",
"def run(self):\n\n def callback(ch, method, properties, body):\n json_body = json.loads(body)\n self.buffer.append(Fvalue.fromdict(json_body))\n\n sleep(5) # We introduce a slight delay to let the RabbitMQ container to accept connections\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.mq_host,port=self.mq_port))\n channel = connection.channel()\n channel.exchange_declare(exchange=self.mq_host + '_exchange', exchange_type='direct')\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.queue_bind(exchange=self.mq_host + '_exchange',\n queue=queue_name,\n routing_key=self.routing_key)\n channel.basic_consume(callback,queue=queue_name,no_ack=True)\n channel.start_consuming()",
"def __init__(self, routing_key):\n self.routing_key = routing_key\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\n self.channel = self.connection.channel()\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\n self.callback_queue = result.method.queue\n\n self.channel.basic_consume(\n queue=self.callback_queue,\n on_message_callback=self.on_response,\n auto_ack=True\n )",
"def consume_message(message):\n # Assign the message to the global drone_message\n global drone_message\n drone_message = message\n # The Rabbit mq runs in the localhost and the username , password is\n # athavan\n credentials = pika.PlainCredentials('guest', 'guest')\n # Pass the mqhost , port , virtualhost and credentials\n parameters = pika.ConnectionParameters('localhost', 5672, '/', credentials)\n connection = pika.SelectConnection(parameters, on_connected)\n try:\n connection.ioloop.start()\n except KeyboardInterrupt:\n # close the connnection\n connection.close()\n # loop until we are fully closed. It will stop on its own\n connection.ioloop.start()",
"def __init__(self, consumer_group):\n self.consumer_group = consumer_group",
"def test_create_consumer(self):\n try:\n test_consumer = TestConsumer(self.msg_queue, self.queue_lock, self.topic, self.properties_file)\n except Exception as e:\n self.fail(f\"test_create_consumer() failed with exception: {e}\")\n\n try:\n test_consumer.start()\n except Exception as e:\n self.fail(f\"test_consumer.start() in test_create_consumer() failed with exception: {e}\")\n\n # Sleep for a couple seconds to allow the thread to come up.\n time.sleep(2)\n self.assertEqual(3, threading.active_count()) # Main thread, consumer thread, consumer-group hear-beat daemon.\n\n test_consumer.stop()\n test_consumer.join()\n self.assertEqual(2, threading.active_count())",
"async def cancel(\n self, consumer_tag: ConsumerTag,\n timeout: TimeoutType = None,\n nowait: bool = False,\n ) -> aiormq.spec.Basic.CancelOk:\n\n channel = await self.channel.get_underlay_channel()\n return await channel.basic_cancel(\n consumer_tag=consumer_tag, nowait=nowait, timeout=timeout,\n )",
"def listen_commands(self):\n self._consumer_rabbit_connection = BlockingConnection(ConnectionParameters(self._rabbit_host))\n self._consumer_rabbit_channel = self._consumer_rabbit_connection.channel()\n\n # Listen buy/sell orders from external system\n self._listen_queue(QueueName.CMD_BUYSELL, self.on_cmd_buysell)\n self._listen_queue(QueueName.MSG_RAW, self.on_raw_msg)\n # self._logger.info(f\"Declaring rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.queue_declare(queue=QueueName.CMD_BUYSELL, durable=True, auto_delete=True)\n # self._logger.info(f\"Consiming to rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.basic_consume(QueueName.CMD_BUYSELL, self.on_cmd_buysell,\n # consumer_tag=\"WebQuikBroker\")\n self._consumer_rabbit_channel.start_consuming()",
"def stop_consuming(self):\n if self._channel_ctrl:\n self._channel_ctrl.basic_cancel(self._consumer_tag_ctrl)\n self._channel_ctrl.close()\n if self._channel_task:\n self._channel_task.basic_cancel(self._consumer_tag_task)\n self._channel_task.close()\n\n self._consuming = False",
"def consumer_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"consumer_id\")",
"def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')",
"def cancel(self):\n def on_cancelok(method_frame):\n \"\"\"Handle cancelok.\n \"\"\"\n self.log.debug(\"Cancel ok on CHANNEL%s\",\n method_frame.channel_number)\n try:\n if self._consumer_tag:\n self._channel.basic_cancel(\n on_cancelok,\n self._consumer_tag\n )\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.log.warning('Channel already closed while closing queue')",
"def declare_queue(self, topic):\n #from trove.rpc.impl_kombu import Connection\n from trove.openstack.common.rpc import create_connection\n with create_connection() as conn:\n consumer = conn.declare_topic_consumer(topic=topic)",
"def stop(self):\n logger.info(\"Stopping rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self._closing = True\n self.stop_consuming()\n if self._connection is not None:\n self._connection.ioloop.start()\n self.stopped = True\n logger.info(\"Stopped rabbit consumer for process: %s with consumer id %s\", threading.current_thread,\n str(self.consumer_id))",
"async def produce_consume(topic_name):\n await asyncio.create_task(produce(topic_name))",
"def receive_procedure(channel_to_receive, queue_name=DEFAULT_QUEUE_NAME):\n # Signal handler to exit from function\n signal.signal(signal.SIGINT, signal_handler)\n\n # Start consuming\n channel_to_receive.basic_consume(callback, queue=queue_name, no_ack=True)\n channel_to_receive.start_consuming()",
"def consumer_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"consumer_id\")",
"def create_consumer(self, name, description=None, user=None):\n consumer, created = self.get_or_create(name=name)\n\n if user:\n consumer.user = user\n\n if description:\n consumer.description = description\n\n if created:\n consumer.key, consumer.secret = self.generate_random_codes()\n consumer.save()\n\n return consumer",
"def create_receiver(self):\n receiver = kafka.KafkaConsumer(bootstrap_servers=['%s:%s' % (self._host, self._port)])\n return receiver",
"async def declare_and_consume(self, handler):\n try:\n await self.declare()\n self.consume(handler)\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.reconnect()",
"def listen(self):\n result = self.channel.queue_declare(queue=self.config['queue'], \n exclusive=True)\n if self.endpoints is not None:\n for key in self.endpoints:\n self.channel.queue_bind(exchange=self.config['exchange'], \n queue=self.config['queue'],\n routing_key=f\"sensor_value.{key}\")\n else:\n self.channel.queue_bind(exchange=self.config['exchange'],\n queue=self.config['queue'],\n routing_key=\"sensor_value.#\")\n \n self.channel.basic_consume(queue=self.config['queue'], \n on_message_callback=self.decode_values, \n auto_ack=True)\n\n # starts a while-type loop\n print(\"wabbit eatin hay\")\n self.channel.start_consuming()",
"def consume_user_message(self, message):\n pass",
"def on_cancelok(self, unused_frame):\n logger.info('RabbitMQ acknowledged the cancellation of the consumer')\n self.close_channel()",
"def __init__(self, username, password, consumer):\n\t\t\n\t\tif not callable(consumer):\n\t\t\traise Exception('Consumer must be callable')\n\t\t\n\t\tself.consumer = consumer\n\n\t\tself.curl = pycurl.Curl()\n\n\t\tself.curl.setopt(pycurl.USERPWD, '%s:%s' % (username, password))\n\t\tself.curl.setopt(pycurl.WRITEFUNCTION, self._receive)\n\n\t\tself.reset()",
"def __init__(self, amqp_url, *handlers):\n\n self._consumer_tags = []\n\n RabbitMQ.__init__(self, amqp_url)\n\n # save our handlers for ruture use\n self._handlers = {}\n for handle in handlers:\n for k, v in handle.handlers().items():\n self._handlers[k] = v",
"def on_message(self, channel, method, properties, body):\n if self.acked:\n self.acknowledge_message(method.delivery_tag)\n if self.cb is not None:\n # call the user specified callback\n self.cb(channel, method, properties, body)\n if self.otq:\n self.stop()\n else:\n self.logger.error(\"Received message, but no callback routine set\")",
"def start(self) -> None:\n conn_manager = ConnectionManager(broker_host=self.broker_host, queue=self.queue)\n channel = conn_manager.start_channel()\n channel.basic_consume(queue=self.queue, on_message_callback=self.callback)\n\n try:\n print(\"PV Simulator...\")\n channel.start_consuming()\n except KeyboardInterrupt:\n pass",
"async def consumer_loop(\n uri: str,\n topic: str,\n ssl_context: SSLContext,\n writers: List[Callable[[ConsumerPayload], Awaitable[int]]],\n) -> int:\n log.info(\"consumer: starting\")\n if len(writers) < 1:\n raise ValueError(\"there must be at least one writer passed to consumer_loop.\")\n queue: asyncio.Queue[ConsumerPayload] = asyncio.Queue()\n async with AIOKafkaConsumer(\n topic,\n bootstrap_servers=uri,\n security_protocol=\"SSL\",\n ssl_context=ssl_context,\n group_id=DEFAULT_GROUP_ID,\n ) as consumer:\n await asyncio.gather(\n decoder(queue, consumer), writer_wrapper(queue=queue, writers=writers)\n )\n log.info(\"consumer: exiting\")\n return 0",
"def consumer_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"consumer_id\")",
"def get_consumer(conf_settings, address=Config.INSIGHTS_KAFKA_ADDRESS): # pragma: no cover\n conf = _get_consumer_config(address, conf_settings)\n LOG.info(f\"Consumer config {conf}\")\n return Consumer(conf, logger=LOG)",
"def consumer_details_for_queue(self):\n response_json = self.rabbit_request(\"queues/%2F/\" + self._queue)\n return response_json[\"consumer_details\"]",
"def __init__(self, broker, topic_name, offset=0):\n self.broker = broker\n self.topic_name = topic_name\n # Important: the consumer needs to remember which offsets it\n # has already read!\n self.offset = offset",
"def consume_messages(self):\n\n method_frame, properties, body = self.channel.basic_get(self.queue_name, no_ack=False)\n\n while method_frame:\n\n LOGGER.info(\"Message received\")\n\n self.channel.basic_ack(method_frame.delivery_tag)\n payload = json.loads(body)\n if not isinstance(payload, dict):\n return\n\n # Process the message\n if 'control' in payload:\n LOGGER.info(\"A control signal received!\")\n # self.set_control(payload['control'])\n print(payload['control'])\n\n # Continue getting messages\n method_frame, properties, body = self.channel.basic_get(self.queue_name, no_ack=False)\n\n # TODO\n # return control_signal",
"async def consume_items_from_rabbitmq(queue):\n ctr = 0\n start = time.time()\n while True:\n await asyncio.sleep(0.001)\n for method_frame, properties, body in channel.consume(queue_name, inactivity_timeout=1):\n if method_frame:\n # print(body)\n while queue.full():\n await asyncio.sleep(0.001)\n # await queue.put(body)\n queue.put_nowait(body)\n # Acknowledge the message\n channel.basic_ack(method_frame.delivery_tag)\n ctr += 1\n if not ctr % 1000:\n end = time.time() - start\n print(f'elapsed time: {end:.3f}\\tmessages received: {ctr}')\n else:\n # empty remaining items from queue\n while queue.qsize():\n await asyncio.sleep(0.001)\n end = time.time() - start\n print(f'elapsed time: {end:.3f}\\tmessages received: {ctr}')\n break\n await asyncio.sleep(0.001)\n\n requeued_messages = channel.cancel()",
"def on_message(self, unused_channel, basic_deliver, properties, body):\n logger.info('Received message # %s from %s: %s',\n basic_deliver.delivery_tag, properties.app_id, body)\n self.rx_queue.put(body)\n self.acknowledge_message(unused_channel, basic_deliver.delivery_tag)",
"def subscribe(self):\n with self._rabbit_connection.connection.channel() as channel:\n self._queue = rabbitpy.Queue(\n channel=channel,\n name=self._subscriber_name + \"_queue\",\n durable=True,\n message_ttl=5 * 24 * 60 * 60 * 1000 # 5 days\n )\n self._queue.declare()\n self._queue.bind(self._exchange, self._routing_key)\n\n self._consume()",
"def __init__(self, topic_name, topic_type, wait_for_data=False):\n\n self.data = None\n self.lock = Lock()\n \n self.subscriber = rospy.Subscriber(topic_name, topic_type, self.callback)\n self.get(wait_for_data)",
"def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)",
"def subscribe(self, queue, action):\n self.channel.queue_declare(queue=queue)\n self.channel.basic_consume(queue=queue,\n on_message_callback=action,\n auto_ack=True)\n self.channel.start_consuming()",
"def consume_messages(process_func: Callable[[str], None]):\n consumer = get_consumer()\n\n for message in consumer:\n log.debug(f'Received a message: {message}')\n try:\n process_func(message.value)\n except Exception as e:\n log.error(f'Failed to process a message: {message.value}')\n log.exception(e)",
"def receive(channel):\n\n def callback(ch, method, properties, body):\n\n event = json.loads(body)\n event_info = event['event_info']\n event_type = event['type']\n success = True\n logger.info(f\"Received event {event}\")\n\n try:\n # Events coming from account microservice\n\n if event_type == USER_CREATED_EVENT:\n\n add_and_publish_event(\n GlobalPreferencesCreatedEvent(event['uuid'], event_info['id'], dict(\n vehicles=['bus', 'subway', 'train', 'tram', 'car', 'walking', 'bike', 'taxi',\n 'enjoy', 'mobike'],\n personal_vehicles=[])),\n PREFERENCES_CREATED)\n\n elif event_type == USER_DELETED_EVENT:\n\n add_and_publish_event(GlobalPreferencesDeletedEvent(event['uuid'], event_info['id']), PREFERENCES_DELETED)\n\n # Events generated in this microservice\n\n elif event_type == PREFERENCES_CREATED_EVENT:\n add_global_preferences(GlobalPreferences(**event_info))\n\n elif event_type == PREFERENCES_MODIFIED_EVENT:\n modify_global_preferences(GlobalPreferences(**event_info))\n\n elif event_type == PREFERENCES_DELETED_EVENT:\n delete_global_preferences(GlobalPreferences(**event_info))\n\n elif event_type == CALENDAR_CREATED_EVENT:\n add_calendar(Calendar(**event_info))\n\n elif event_type == CALENDAR_MODIFIED_EVENT:\n modify_calendar(Calendar(**event_info))\n\n elif event_type == CALENDAR_DELETED_EVENT:\n delete_calendar(Calendar(**event_info))\n\n except SQLAlchemyError as e:\n\n # to deal with at least once delivery of rabbitmq and the create methods which are not idempotent\n if (event_type == USER_CREATED_EVENT or event_type == PREFERENCES_CREATED_EVENT or event_type == CALENDAR_CREATED_EVENT) \\\n and method.redelivered and isinstance(e, IntegrityError):\n logger.info(f'Not processed redelivered event {event}')\n\n else:\n logger.info(f\"Couldn't process event {event}\")\n success = False\n\n finally:\n if success: # ack only if the event has been processed\n ch.basic_ack(delivery_tag=method.delivery_tag)\n logger.info(f\"Processed and acked event {event}\")\n\n # channel.basic_qos(prefetch_count=1)\n channel.basic_consume(callback,\n queue=CALENDAR_QUEUE)\n\n logger.info(\"Started listening to events\")\n channel.start_consuming()",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)",
"def run(self):\n self.channel.queue_declare(self._request_queue)\n self.channel.basic_consume(self._request_queue, self.on_message)\n try:\n msg = \"Waiting for message ...\"\n print(msg)\n logging.info(msg)\n self.channel.start_consuming()\n except KeyboardInterrupt:\n self.channel.stop_consuming()\n\n self.connection.close()",
"def prep_consumer(self):\n self.consumer = Consumer.objects.get(id=101)\n if self.consumer.subscriber:\n self.fail('It is assumed that this consumer has no subscriber.')\n self.three_days_ago = datetime.today().date() - timedelta(days=3)\n self.consumer.consumer_create_datetime = self.three_days_ago\n self.consumer.email_subscription.add(1)\n self.consumer.is_emailable = True\n self.rep = get_site_rep(self.consumer.site)\n self.consumer.save()",
"def test_consumer(self):\n try:\n consumer = Consumer()\n consumer.poll()\n except (Exception) as error:\n logging.error(\"\\n\\nConsumer's connection to\"\n \"kafka failed with error: {}\\n\\n\".format(error))\n assert(False)",
"def kafka_consumer(request: 'SubRequest') -> KafkaConsumer:\n _, kafka_port = request.getfixturevalue(kafka_fixture_name)\n\n used_consumer_kwargs = consumer_kwargs.copy()\n used_consumer_kwargs.setdefault('consumer_timeout_ms', DEFAULT_CONSUMER_TIMEOUT_MS)\n used_consumer_kwargs.setdefault('bootstrap_servers', 'localhost:{}'.format(kafka_port))\n\n consumer = KafkaConsumer(\n *kafka_topics,\n **used_consumer_kwargs,\n )\n\n if seek_to_beginning:\n assert kafka_topics, (\n 'In order to be able to seek to beginning, we must have some partitions assigned '\n 'for which we need to subscribe to topics.')\n\n def partitions_assigned():\n consumer.poll(timeout_ms=20)\n return len(consumer.assignment()) > 0\n\n _wait_until(partitions_assigned)\n\n consumer.seek_to_beginning()\n return consumer",
"def _consumer(self) -> None:\n while (data := self._q.get()) is not None:\n write_data(data, self.writer)\n self._q.task_done()\n else:\n logging.info(\"None received. Queue consumed.\")\n self._q.task_done()\n return",
"def consume(self, timeout=None):\n pass",
"def ack(self):\n self.consumer.ack(self)",
"def consume(self, timeout=None):\n\n def _raise_timeout(exc):\n raise driver_common.Timeout(str(exc))\n\n timer = driver_common.DecayingTimer(duration=timeout)\n timer.start()\n\n poll_timeout = (self.consumer_timeout if timeout is None\n else min(timeout, self.consumer_timeout))\n\n while True:\n if self._consume_loop_stopped:\n return\n try:\n return self._poll_messages(poll_timeout)\n except kafka.errors.ConsumerTimeout as exc:\n poll_timeout = timer.check_return(\n _raise_timeout, exc, maximum=self.consumer_timeout)\n except Exception:\n LOG.exception(_LE(\"Failed to consume messages\"))\n return",
"def run(self):\n try:\n\n self._connection = self.connect()\n self._connection.ioloop.start()\n except (KeyboardInterrupt, SystemExit):\n self.stop()\n except Exception as e:\n logger.warn(\"Exception: %s\", str(e))\n logger.warn(\"Exception caught on rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self.internal_error_queue.put(self.consumer_id)",
"def __init__(self, pyrps, queue, consumer_id):\n self.pyrps = pyrps\n self.queue = queue\n self.consumer_id = consumer_id",
"def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.events.pause.set()\n\n while True:\n self.events.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n partition, message = self.queue.get(block=True, timeout=1)\n except queue.Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[partition] = message.offset + 1\n self.events.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.events.start.clear()",
"async def run(self):\n\n self.connection = await aio_pika.connect(self.mq_connection_str, loop=asyncio.get_event_loop())\n self.channel = await self.connection.channel()\n\n # connect to exchanger market data\n # market data send with routing key format: message_type.data_type.exchange.pair[.time_frame]\n # message_type == update | starting, data_type == ticker | candles | depth,\n # exchange, pair, time_frame - sending by listing_info\n binding_mask = '*.*.*.#'\n topic_logs_exchange = await self.channel.declare_exchange(self.exchanger, aio_pika.ExchangeType.TOPIC)\n queue_topic = await self.channel.declare_queue('', auto_delete=True)\n await queue_topic.bind(topic_logs_exchange, routing_key=binding_mask)\n\n # listener queue for listing information\n queue_for_listing = await self.channel.declare_queue('', auto_delete=True)\n await queue_for_listing.bind(topic_logs_exchange, routing_key=self.name_queue_for_listing)\n\n # listener queue for error\n queue_for_error = await self.channel.declare_queue('', auto_delete=True)\n await queue_for_error.bind(topic_logs_exchange, routing_key=self.name_queue_for_error)\n\n def callback_crypto_currency_market_data(message):\n \"\"\"Callback for consume market data\"\"\"\n body = json.loads(message.body.decode('utf-8'))\n \n # routing_key have view: message_type.data_type.exchange.pair[.time_frame]\n # message_type == update | starting, data_type == ticker | candles | depth,\n # exchange, pair, time_frame - sending by listing_info\n # mask: *.*.*.#\n message_type = message.routing_key.split('.')[0]\n data_id = '.'.join(message.routing_key.split('.')[1:])\n\n if message_type == 'update':\n for observer in self.subscribers.get(data_id):\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=message.routing_key,\n data=body\n )\n ))\n elif message_type == 'starting':\n # if exist waiters, send data and move waiters in subscribers\n if not self.waiters_first_msg.get(data_id):\n return\n\n new_subscribers = []\n while self.waiters_first_msg[data_id]:\n observer = self.waiters_first_msg[data_id].pop()\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=message.routing_key,\n data=body\n )\n ))\n new_subscribers.append(observer)\n\n # if not subscribers on this data_id, init new dict-value, else append to exist array\n subscribers = self.subscribers.get(data_id, None)\n if not subscribers and new_subscribers:\n self.subscribers[data_id] = new_subscribers\n asyncio.get_event_loop().create_task(self._send_message_for_subscribe(data_id))\n else:\n for new_subscriber in new_subscribers:\n if new_subscriber not in self.subscribers[data_id]:\n self.subscribers[data_id].append(new_subscriber)\n\n def callback_crypto_currency_listing(message):\n \"\"\"Callback for consume information about access pairs, exchanges and timeframes\"\"\"\n body = json.loads(message.body.decode('utf-8'))\n data_id = TYPE_LISTING\n\n if not self.waiters_first_msg.get(data_id):\n return\n\n while self.waiters_first_msg[data_id]:\n observer = self.waiters_first_msg[data_id].pop()\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=data_id,\n data=body\n )\n ))\n\n def callback_crypto_currency_error(message):\n \"\"\"Callback for consume error queue\"\"\"\n logger.error(message.body.decode('utf-8'))\n\n body = json.loads(message.body.decode('utf-8'))\n\n # validation\n error_place = body.get('error_place')\n message = 'Sorry! Error on server'\n if not message or not error_place:\n return\n\n # send information to ws, that wait or subscribe on error_place\n waiters = self.waiters_first_msg.get(error_place, ())\n for observer in waiters:\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=error_place,\n error=message\n )\n ))\n\n subscribers = self.subscribers.get(error_place, ())\n for observer in subscribers:\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=error_place,\n data=message\n )\n ))\n\n await queue_topic.consume(callback_crypto_currency_market_data)\n await queue_for_listing.consume(callback_crypto_currency_listing)\n await queue_for_error.consume(callback_crypto_currency_error)",
"def start_loop(\n consumer: Consumer,\n message_handler: Callable[[Message], None],\n on_success: Callable[[Message], None] = lambda msg: None,\n on_failure: Callable[[Message, Exception], None] = lambda msg, e: None,\n on_config_update: Callable[[], None] = lambda: None,\n logger: logging.Logger = logging.getLogger('IR')):\n # Used for re-fetching the configuration with a throttle\n last_updated_minute = int(time.time() / 60)\n if not config()['global_config_url']:\n config_tag = _fetch_latest_config_tag()\n\n while True:\n msg = consumer.poll(timeout=0.5)\n if msg is None:\n continue\n curr_min = int(time.time() / 60)\n if not config()['global_config_url'] and curr_min > last_updated_minute:\n # Check for configuration updates\n latest_config_tag = _fetch_latest_config_tag()\n last_updated_minute = curr_min\n if config_tag is not None and latest_config_tag != config_tag:\n config(force_reload=True)\n config_tag = latest_config_tag\n on_config_update()\n if msg.error():\n if msg.error().code() == KafkaError._PARTITION_EOF:\n logger.info('End of stream.')\n else:\n logger.error(f\"Kafka message error: {msg.error()}\")\n continue\n val = msg.value().decode('utf-8')\n try:\n msg = json.loads(val)\n except ValueError as err:\n logger.error(f'JSON parsing error: {err}')\n logger.error(f'Message content: {val}')\n consumer.commit()\n continue\n logger.info(f'Received event: {msg}')\n start = time.time()\n try:\n message_handler(msg)\n # Move the offset for our partition\n consumer.commit()\n on_success(msg)\n logger.info(f\"Handled {msg['evtype']} message in {time.time() - start}s\")\n except Exception as err:\n logger.error(f'Error processing message: {err.__class__.__name__} {err}')\n logger.error(traceback.format_exc())\n # Save this error and message to a topic in Elasticsearch\n on_failure(msg, err)",
"def consume_message_bus(self, test=False):\n if test:\n from test_fake_bus import FakeChannel, FakeConnection\n self.logger.info(\"Running Test Message Bus\")\n\n self.channel = FakeChannel(self.on_bus_message, self.forwarder_options, self.logger)\n self.connection = FakeConnection()\n\n return\n\n username, password = self.get_bus_credentials()\n credentials = pika.PlainCredentials(username, password)\n parameters = pika.ConnectionParameters(self.cb_server_hostname, 5004, \"/\", credentials)\n\n self.connection = pika.SelectConnection(parameters, self.bus_on_connected,\n on_close_callback=self.bus_on_closed)\n self.logger.info(\"Starting bus connection\")\n self.retry_attempts = 0\n self.connection.ioloop.start()",
"def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.pause.set()\n\n while True:\n self.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n meta, message = self.queue.get(block=True, timeout=1)\n except Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[meta.partition] = message.offset + 1\n self.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.start.clear()",
"def verify_consumer():\n\n # Consumer config\n conf = {'bootstrap.servers': bootstrap_servers,\n 'group.id': 'test.py',\n 'session.timeout.ms': 6000,\n 'enable.auto.commit': False,\n 'api.version.request': api_version_request,\n 'on_commit': print_commit_result,\n 'error_cb': error_cb,\n 'default.topic.config': {\n 'auto.offset.reset': 'earliest'\n }}\n\n # Create consumer\n c = confluent_kafka.Consumer(**conf)\n\n def print_wmark(consumer, parts):\n # Verify #294: get_watermark_offsets() should not fail on the first call\n # This is really a librdkafka issue.\n for p in parts:\n wmarks = consumer.get_watermark_offsets(parts[0])\n print('Watermarks for %s: %s' % (p, wmarks))\n\n # Subscribe to a list of topics\n c.subscribe([topic], on_assign=print_wmark)\n\n max_msgcnt = 100\n msgcnt = 0\n\n first_msg = None\n\n while True:\n # Consume until EOF or error\n\n # Consume message (error()==0) or event (error()!=0)\n msg = c.poll()\n if msg is None:\n raise Exception('Got timeout from poll() without a timeout set: %s' % msg)\n\n if msg.error():\n if msg.error().code() == confluent_kafka.KafkaError._PARTITION_EOF:\n print('Reached end of %s [%d] at offset %d' %\n (msg.topic(), msg.partition(), msg.offset()))\n break\n else:\n print('Consumer error: %s: ignoring' % msg.error())\n break\n\n tstype, timestamp = msg.timestamp()\n headers = msg.headers()\n if headers:\n example_header = headers\n\n msg.set_headers([('foo', 'bar')])\n assert msg.headers() == [('foo', 'bar')]\n\n print('%s[%d]@%d: key=%s, value=%s, tstype=%d, timestamp=%s headers=%s' %\n (msg.topic(), msg.partition(), msg.offset(),\n msg.key(), msg.value(), tstype, timestamp, headers))\n\n if first_msg is None:\n first_msg = msg\n\n if (msgcnt == 11):\n parts = c.assignment()\n print('Pausing partitions briefly')\n c.pause(parts)\n exp_None = c.poll(timeout=2.0)\n assert exp_None is None, \"expected no messages during pause, got %s\" % exp_None\n print('Resuming partitions')\n c.resume(parts)\n\n if (msg.offset() % 5) == 0:\n # Async commit\n c.commit(msg, asynchronous=True)\n elif (msg.offset() % 4) == 0:\n offsets = c.commit(msg, asynchronous=False)\n assert len(offsets) == 1, 'expected 1 offset, not %s' % (offsets)\n assert offsets[0].offset == msg.offset()+1, \\\n 'expected offset %d to be committed, not %s' % \\\n (msg.offset(), offsets)\n print('Sync committed offset: %s' % offsets)\n\n msgcnt += 1\n if msgcnt >= max_msgcnt:\n print('max_msgcnt %d reached' % msgcnt)\n break\n\n assert example_header, \"We should have received at least one header\"\n assert example_header == [(u'foo1', 'bar'), (u'foo1', 'bar2'), (u'foo2', '1')]\n\n # Get current assignment\n assignment = c.assignment()\n\n # Get cached watermark offsets\n # Since we're not making use of statistics the low offset is not known so ignore it.\n lo, hi = c.get_watermark_offsets(assignment[0], cached=True)\n print('Cached offsets for %s: %d - %d' % (assignment[0], lo, hi))\n\n # Query broker for offsets\n lo, hi = c.get_watermark_offsets(assignment[0], timeout=1.0)\n print('Queried offsets for %s: %d - %d' % (assignment[0], lo, hi))\n\n # Query offsets for timestamps by setting the topic partition offset to a timestamp. 123456789000 + 1\n topic_partions_to_search = list(map(lambda p: confluent_kafka.TopicPartition(topic, p, 123456789001), range(0, 3)))\n print(\"Searching for offsets with %s\" % topic_partions_to_search)\n\n offsets = c.offsets_for_times(topic_partions_to_search, timeout=1.0)\n print(\"offsets_for_times results: %s\" % offsets)\n\n verify_consumer_seek(c, first_msg)\n\n # Close consumer\n c.close()\n\n # Start a new client and get the committed offsets\n c = confluent_kafka.Consumer(**conf)\n offsets = c.committed(list(map(lambda p: confluent_kafka.TopicPartition(topic, p), range(0, 3))))\n for tp in offsets:\n print(tp)\n\n c.close()",
"def run_collectd_amqp(self):\n amqp_url = 'amqp://admin:admin@{}:{}/%2F'.format(self.mgmt['ip'], self.AMPQ_PORT)\n amqp = AmqpConsumer(amqp_url, self._queue)\n try:\n amqp.run()\n except (AttributeError, RuntimeError, KeyboardInterrupt):\n amqp.stop()",
"def consume(self, queue_name, prefetch=1, timeout=5000):\n return _RedisConsumer(self, queue_name, prefetch, timeout)",
"def on_consume_cancelled(self, *args, **kwargs): # pragma: no cover\n self.log.warning(\n 'Consume cancelled. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def ceilometer_amq(self):\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='ceilometer', type='topic')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='metering')\n\n #channel.queue_bind(exchange='ceilometer.agent.notification_fanout', queue=queue_name)\n #channel.queue_bind(exchange='ceilometer.collector_fanout', queue=queue_name)\n channel.basic_consume(self.ceilometer_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()",
"def subscribe_to_commands(self):\n self.basic_consume(self.process_command, queue=self.name)",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def consumer (self):\n try:\n while True:\n try:\n data = os.read (self.read_fd, 65536)\n if not data:\n break\n except OSError as error:\n if error.errno not in BlockingErrorSet:\n break\n yield self.core.Poll (self.read_fd, POLL_READ)\n finally:\n self.Dispose ()"
] | [
"0.75168574",
"0.7267859",
"0.6537067",
"0.65252763",
"0.619652",
"0.6182665",
"0.61760205",
"0.6132582",
"0.5972022",
"0.5946298",
"0.5869681",
"0.5863082",
"0.5817889",
"0.5807988",
"0.57975596",
"0.57532775",
"0.5696924",
"0.5669013",
"0.5662497",
"0.5657694",
"0.5656697",
"0.5619895",
"0.5616355",
"0.55428094",
"0.5456945",
"0.54190326",
"0.54046",
"0.5373756",
"0.53639317",
"0.53570056",
"0.53478676",
"0.53306997",
"0.53073657",
"0.5295768",
"0.52813387",
"0.526928",
"0.5253511",
"0.5224169",
"0.52216214",
"0.52115923",
"0.51968664",
"0.51629496",
"0.5150429",
"0.5142751",
"0.5135336",
"0.511703",
"0.51167834",
"0.51156485",
"0.51106846",
"0.5095564",
"0.5059486",
"0.504864",
"0.50452405",
"0.5041995",
"0.50377965",
"0.50263506",
"0.5020219",
"0.50198",
"0.5008446",
"0.5001927",
"0.49900475",
"0.49811596",
"0.49518824",
"0.49510005",
"0.4924737",
"0.4910461",
"0.49054578",
"0.48941448",
"0.48857635",
"0.4881632",
"0.48788774",
"0.4870353",
"0.48633698",
"0.48452726",
"0.48337758",
"0.48337758",
"0.48337758",
"0.48188636",
"0.4804829",
"0.4799971",
"0.4799724",
"0.47927478",
"0.47886837",
"0.478377",
"0.47744524",
"0.4770399",
"0.47674248",
"0.4763024",
"0.47581166",
"0.47474763",
"0.47468582",
"0.47400877",
"0.47343895",
"0.47301775",
"0.47235206",
"0.47196758",
"0.47025418",
"0.46925163",
"0.46917355",
"0.4691083"
] | 0.71504706 | 2 |
Invoked by pika when RabbitMQ sends a Basic.Cancel for a consumer receiving messages. | def on_consumer_task_cancelled(self, method_frame):
if self._channel_task:
self._channel_task.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_consuming(self):\n if self._channel:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._channel.basic_cancel(self.on_cancelok, self._consumer_tag)",
"def cancel(self):\n def on_cancelok(method_frame):\n \"\"\"Handle cancelok.\n \"\"\"\n self.log.debug(\"Cancel ok on CHANNEL%s\",\n method_frame.channel_number)\n try:\n if self._consumer_tag:\n self._channel.basic_cancel(\n on_cancelok,\n self._consumer_tag\n )\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.log.warning('Channel already closed while closing queue')",
"def _stop_consuming(self):\n if self._rx_channel and self._rx_channel.is_open:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._rx_channel.basic_cancel(consumer_tag=self._consumer_tag)\n logger.info(\"stop consuming\")",
"def on_cancelok(self, unused_frame):\n logger.info('RabbitMQ acknowledged the cancellation of the consumer')\n self.close_channel()",
"def stop_consuming(self):\n if self._channel:\n self.logger.debug(\"Stopping message consuming on channel %i\", self._channel)\n\n self._connection.ioloop.add_callback_threadsafe(\n partial(\n self._channel.basic_cancel,\n consumer_tag=self._consumer_tag,\n callback=lambda *args: None,\n )\n )",
"async def cancel(\n self, consumer_tag: ConsumerTag,\n timeout: TimeoutType = None,\n nowait: bool = False,\n ) -> aiormq.spec.Basic.CancelOk:\n\n channel = await self.channel.get_underlay_channel()\n return await channel.basic_cancel(\n consumer_tag=consumer_tag, nowait=nowait, timeout=timeout,\n )",
"def add_on_cancel_callback(self):\n logger.info('Adding consumer cancellation callback')\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)",
"def on_consumer_cancelled(self, method_frame):\n self.logger.info('consumer cancelled %r', method_frame)\n if self._channel:\n self._channel.close()",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.queue.channel.rpc(self._basic_cancel)\n self.queue.consuming = False",
"def on_consumer_cancelled(self, method_frame):\n logger.info('Consumer was cancelled remotely, shutting down: %r',\n method_frame)\n if self._channel:\n self._channel.close()",
"def on_consumer_cancelled(self, method_frame):\n self.logger.debug(\"Consumer was cancelled: %r\", method_frame)\n\n if self._channel:\n self._connection.close()",
"async def on_cancel(self, payload):\n\n await self._delete_message(0)\n self.stop()",
"def cancel_callback(self):\n pass",
"def stop_consuming(self):\n if self._channel_ctrl:\n self._channel_ctrl.basic_cancel(self._consumer_tag_ctrl)\n self._channel_ctrl.close()\n if self._channel_task:\n self._channel_task.basic_cancel(self._consumer_tag_task)\n self._channel_task.close()\n\n self._consuming = False",
"def stop_consumer_loop(self, message: Dict) -> NoReturn:\n message.ack()\n self.should_stop = True",
"def OnCancel(self, event):\n pass",
"def OnCancel(self, event):\n pass",
"def _cancel_ack_timeout(self):\n if self._ack_handle.active():\n self._ack_handle.cancel()",
"def cancel(self):\n self.on_cancel()",
"def cancel(self):",
"def cancel(self):",
"def cancel(self):",
"def cancel(self):\n self.stop()\n self.make_callback('canceled')",
"def cancel(self):\n _notify.remove(self.callb)",
"def cancel():",
"def on_consumer_ctrl_cancelled(self, method_frame):\n if self._channel_ctrl:\n self._channel_ctrl.close()",
"def cancelMessageRetrieval(self):\n \n self.gatherData.stop()",
"def cancel(self): #$NON-NLS-1$\r",
"def do_cancel(self):\r\n self.write({'cancelled': True})",
"def on_cancel(self) -> None:\n pass",
"def on_cancel(self) -> None:\n pass",
"def cancel(self):\n pass",
"def consume_ack(self, event):\n pass",
"def on_cancel(self):\n self.state = CANCELED\n self._reject()",
"async def cancel_handler(message: types.Message, state, raw_state=None):\n # Cancel state and inform user about it\n await state.finish()\n # And remove keyboard (just in case)\n await reply(message, \"Canceled.\", reply_markup=types.ReplyKeyboardRemove())",
"def reqGlobalCancel(self):\r\n self.ib.reqGlobalCancel()\r\n logging.info('reqGlobalCancel')",
"def onCancel(self, fetcher): #$NON-NLS-1$\r",
"def _onCancel(self):\n\n self.close()",
"def on_consume_cancelled(self, *args, **kwargs): # pragma: no cover\n self.log.warning(\n 'Consume cancelled. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def cancel(self, membership, callback=None):",
"async def cancel(self):\n\n await self.cb_0.cancel()\n await self.cb_1.cancel()",
"async def cancel(self, ctx):\n\n return",
"def cancel(self):\n raise NotImplementedError(\n u\"%s: Method not implemented\", self.__class__.__name__)",
"def handleCancel(self):\n self.isTerminated = True\n self.terminate()",
"def cancel(self, msg: typing.Optional[str] = None) -> None:\n self._cancelled = CancelledError(msg)\n warnings.warn(\n \"Calling this method will cause a CancelledError to be thrown in the \"\n \"Task sometime in the future.\",\n FutureWarning,\n stacklevel=2,\n )\n self.kill()",
"async def test_cancelled_task(self):\n await self.cog._unsilence(self.text_channel)\n self.cog.scheduler.cancel.assert_called_once_with(self.text_channel.id)",
"def stop(self):\n logger.info(\"Stopping rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self._closing = True\n self.stop_consuming()\n if self._connection is not None:\n self._connection.ioloop.start()\n self.stopped = True\n logger.info(\"Stopped rabbit consumer for process: %s with consumer id %s\", threading.current_thread,\n str(self.consumer_id))",
"async def async_cancel(self):\n raise NotImplementedError",
"def on_cancel(self, *args):\n self.response(Gtk.ResponseType.CANCEL)",
"def cancel(self):\n return self.RES_OK",
"def handle_close(self, msg):\n self.log.debug(\"handle_close[%s](%s)\", self.comm_id, msg)\n if self._close_callback:\n self._close_callback(msg)",
"def messageCancel(self,message):\n if self.app.DEBUG:\n print 'Dialog: Parent: %s.messageCancel'%self.__class__\n return self.message(message,style=wx.YES_NO|wx.ICON_QUESTION | wx.CANCEL)",
"def control_cancel(self, wait_for_ready: bool = True) -> None:\n self.__logger.debug('Eva.control_cancel called')\n return self.__http_client.control_cancel(wait_for_ready=wait_for_ready)",
"def cancel_callback(self, goal_handle):\n self.get_logger().info('Received cancel request')\n return CancelResponse.ACCEPT",
"def _chain_cancel(_):\n if recvd.done():\n return\n if f.cancelled():\n recvd.cancel()",
"def cancel_action(sc: object, channel_id: str, msg_timestamp: str):\n sc.api_call('chat.update',\n channel=channel_id,\n ts=msg_timestamp,\n text=\":face_with_raised_eyebrow: Operation cancelled... :face_with_symbols_on_mouth:\",\n attachments=[])",
"def _order_cancel(self, bo):\n log.info(\"bo_blotter: order_cancel bracket order bo#%s\" % bo.ticket) \n cancelled = bo.cancel()\n return(cancelled)",
"def stop(self):\n self.logger.debug(\"Stopping request consumer\")\n self._connection.ioloop.add_callback_threadsafe(partial(self._connection.close))",
"def do_uncancel(self):\r\n self.write({'cancelled': False})",
"def queue_my_cancel(self, uid):\n \n message = self.OrdTuple(ordtype=\"cancel\",\n uid=uid,\n is_buy=np.nan,\n qty=np.nan,\n price=np.nan, \n timestamp=self._arrival_time()) \n self.my_queue.append(message)",
"def cancel_fedcm_dialog(self):\n pass",
"def cancel(self):\n self.__canceled = True",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)"
] | [
"0.7847234",
"0.7810346",
"0.7453713",
"0.71928334",
"0.6767319",
"0.67397696",
"0.67256796",
"0.6550659",
"0.6513717",
"0.6420064",
"0.64200187",
"0.64027125",
"0.6361164",
"0.6187015",
"0.6158234",
"0.61437774",
"0.61437774",
"0.61342376",
"0.6129699",
"0.612585",
"0.612585",
"0.612585",
"0.612194",
"0.6094325",
"0.6079856",
"0.60495037",
"0.6037749",
"0.59873027",
"0.5985136",
"0.59784925",
"0.59784925",
"0.59776795",
"0.5936454",
"0.5922949",
"0.5905005",
"0.5892696",
"0.58704644",
"0.586295",
"0.5845968",
"0.57720613",
"0.5765897",
"0.5739832",
"0.5715662",
"0.5713194",
"0.56936026",
"0.5691269",
"0.56906205",
"0.56882876",
"0.56673837",
"0.5647887",
"0.5647127",
"0.5642078",
"0.56393856",
"0.56193167",
"0.5611324",
"0.55913526",
"0.55813265",
"0.55795825",
"0.5563039",
"0.55581015",
"0.5558079",
"0.54938304",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703",
"0.54907703"
] | 0.5853428 | 38 |
Invoked by pika when RabbitMQ sends a Basic.Cancel for a consumer receiving messages. | def on_consumer_ctrl_cancelled(self, method_frame):
if self._channel_ctrl:
self._channel_ctrl.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_consuming(self):\n if self._channel:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._channel.basic_cancel(self.on_cancelok, self._consumer_tag)",
"def cancel(self):\n def on_cancelok(method_frame):\n \"\"\"Handle cancelok.\n \"\"\"\n self.log.debug(\"Cancel ok on CHANNEL%s\",\n method_frame.channel_number)\n try:\n if self._consumer_tag:\n self._channel.basic_cancel(\n on_cancelok,\n self._consumer_tag\n )\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.log.warning('Channel already closed while closing queue')",
"def _stop_consuming(self):\n if self._rx_channel and self._rx_channel.is_open:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._rx_channel.basic_cancel(consumer_tag=self._consumer_tag)\n logger.info(\"stop consuming\")",
"def on_cancelok(self, unused_frame):\n logger.info('RabbitMQ acknowledged the cancellation of the consumer')\n self.close_channel()",
"def stop_consuming(self):\n if self._channel:\n self.logger.debug(\"Stopping message consuming on channel %i\", self._channel)\n\n self._connection.ioloop.add_callback_threadsafe(\n partial(\n self._channel.basic_cancel,\n consumer_tag=self._consumer_tag,\n callback=lambda *args: None,\n )\n )",
"async def cancel(\n self, consumer_tag: ConsumerTag,\n timeout: TimeoutType = None,\n nowait: bool = False,\n ) -> aiormq.spec.Basic.CancelOk:\n\n channel = await self.channel.get_underlay_channel()\n return await channel.basic_cancel(\n consumer_tag=consumer_tag, nowait=nowait, timeout=timeout,\n )",
"def add_on_cancel_callback(self):\n logger.info('Adding consumer cancellation callback')\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)",
"def on_consumer_cancelled(self, method_frame):\n self.logger.info('consumer cancelled %r', method_frame)\n if self._channel:\n self._channel.close()",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.queue.channel.rpc(self._basic_cancel)\n self.queue.consuming = False",
"def on_consumer_cancelled(self, method_frame):\n logger.info('Consumer was cancelled remotely, shutting down: %r',\n method_frame)\n if self._channel:\n self._channel.close()",
"def on_consumer_cancelled(self, method_frame):\n self.logger.debug(\"Consumer was cancelled: %r\", method_frame)\n\n if self._channel:\n self._connection.close()",
"async def on_cancel(self, payload):\n\n await self._delete_message(0)\n self.stop()",
"def cancel_callback(self):\n pass",
"def stop_consuming(self):\n if self._channel_ctrl:\n self._channel_ctrl.basic_cancel(self._consumer_tag_ctrl)\n self._channel_ctrl.close()\n if self._channel_task:\n self._channel_task.basic_cancel(self._consumer_tag_task)\n self._channel_task.close()\n\n self._consuming = False",
"def stop_consumer_loop(self, message: Dict) -> NoReturn:\n message.ack()\n self.should_stop = True",
"def OnCancel(self, event):\n pass",
"def OnCancel(self, event):\n pass",
"def _cancel_ack_timeout(self):\n if self._ack_handle.active():\n self._ack_handle.cancel()",
"def cancel(self):\n self.on_cancel()",
"def cancel(self):",
"def cancel(self):",
"def cancel(self):",
"def cancel(self):\n self.stop()\n self.make_callback('canceled')",
"def cancel(self):\n _notify.remove(self.callb)",
"def cancel():",
"def cancelMessageRetrieval(self):\n \n self.gatherData.stop()",
"def cancel(self): #$NON-NLS-1$\r",
"def do_cancel(self):\r\n self.write({'cancelled': True})",
"def on_cancel(self) -> None:\n pass",
"def on_cancel(self) -> None:\n pass",
"def cancel(self):\n pass",
"def consume_ack(self, event):\n pass",
"def on_cancel(self):\n self.state = CANCELED\n self._reject()",
"async def cancel_handler(message: types.Message, state, raw_state=None):\n # Cancel state and inform user about it\n await state.finish()\n # And remove keyboard (just in case)\n await reply(message, \"Canceled.\", reply_markup=types.ReplyKeyboardRemove())",
"def reqGlobalCancel(self):\r\n self.ib.reqGlobalCancel()\r\n logging.info('reqGlobalCancel')",
"def onCancel(self, fetcher): #$NON-NLS-1$\r",
"def _onCancel(self):\n\n self.close()",
"def on_consumer_task_cancelled(self, method_frame):\n if self._channel_task:\n self._channel_task.close()",
"def on_consume_cancelled(self, *args, **kwargs): # pragma: no cover\n self.log.warning(\n 'Consume cancelled. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def cancel(self, membership, callback=None):",
"async def cancel(self):\n\n await self.cb_0.cancel()\n await self.cb_1.cancel()",
"async def cancel(self, ctx):\n\n return",
"def cancel(self):\n raise NotImplementedError(\n u\"%s: Method not implemented\", self.__class__.__name__)",
"def handleCancel(self):\n self.isTerminated = True\n self.terminate()",
"def cancel(self, msg: typing.Optional[str] = None) -> None:\n self._cancelled = CancelledError(msg)\n warnings.warn(\n \"Calling this method will cause a CancelledError to be thrown in the \"\n \"Task sometime in the future.\",\n FutureWarning,\n stacklevel=2,\n )\n self.kill()",
"async def test_cancelled_task(self):\n await self.cog._unsilence(self.text_channel)\n self.cog.scheduler.cancel.assert_called_once_with(self.text_channel.id)",
"def stop(self):\n logger.info(\"Stopping rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self._closing = True\n self.stop_consuming()\n if self._connection is not None:\n self._connection.ioloop.start()\n self.stopped = True\n logger.info(\"Stopped rabbit consumer for process: %s with consumer id %s\", threading.current_thread,\n str(self.consumer_id))",
"async def async_cancel(self):\n raise NotImplementedError",
"def on_cancel(self, *args):\n self.response(Gtk.ResponseType.CANCEL)",
"def cancel(self):\n return self.RES_OK",
"def handle_close(self, msg):\n self.log.debug(\"handle_close[%s](%s)\", self.comm_id, msg)\n if self._close_callback:\n self._close_callback(msg)",
"def messageCancel(self,message):\n if self.app.DEBUG:\n print 'Dialog: Parent: %s.messageCancel'%self.__class__\n return self.message(message,style=wx.YES_NO|wx.ICON_QUESTION | wx.CANCEL)",
"def control_cancel(self, wait_for_ready: bool = True) -> None:\n self.__logger.debug('Eva.control_cancel called')\n return self.__http_client.control_cancel(wait_for_ready=wait_for_ready)",
"def cancel_callback(self, goal_handle):\n self.get_logger().info('Received cancel request')\n return CancelResponse.ACCEPT",
"def _chain_cancel(_):\n if recvd.done():\n return\n if f.cancelled():\n recvd.cancel()",
"def cancel_action(sc: object, channel_id: str, msg_timestamp: str):\n sc.api_call('chat.update',\n channel=channel_id,\n ts=msg_timestamp,\n text=\":face_with_raised_eyebrow: Operation cancelled... :face_with_symbols_on_mouth:\",\n attachments=[])",
"def _order_cancel(self, bo):\n log.info(\"bo_blotter: order_cancel bracket order bo#%s\" % bo.ticket) \n cancelled = bo.cancel()\n return(cancelled)",
"def stop(self):\n self.logger.debug(\"Stopping request consumer\")\n self._connection.ioloop.add_callback_threadsafe(partial(self._connection.close))",
"def do_uncancel(self):\r\n self.write({'cancelled': False})",
"def cancel_fedcm_dialog(self):\n pass",
"def queue_my_cancel(self, uid):\n \n message = self.OrdTuple(ordtype=\"cancel\",\n uid=uid,\n is_buy=np.nan,\n qty=np.nan,\n price=np.nan, \n timestamp=self._arrival_time()) \n self.my_queue.append(message)",
"def cancel(self):\n self.__canceled = True",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)"
] | [
"0.78472316",
"0.7810699",
"0.7453731",
"0.7191473",
"0.67671907",
"0.6740184",
"0.6724212",
"0.6550379",
"0.6513269",
"0.64203066",
"0.6419901",
"0.64034593",
"0.6361006",
"0.61860156",
"0.61590147",
"0.61434734",
"0.61434734",
"0.61338735",
"0.61299396",
"0.61258346",
"0.61258346",
"0.61258346",
"0.6123131",
"0.6094761",
"0.60798544",
"0.60388535",
"0.59872985",
"0.59852153",
"0.5978161",
"0.5978161",
"0.5977794",
"0.5933871",
"0.5923325",
"0.5905817",
"0.58933765",
"0.5869804",
"0.5863066",
"0.58530587",
"0.5844327",
"0.57725996",
"0.57663053",
"0.57399994",
"0.5716198",
"0.5713897",
"0.56944394",
"0.5691416",
"0.5690592",
"0.56891525",
"0.5668023",
"0.56488854",
"0.5647127",
"0.56431043",
"0.56391364",
"0.5619346",
"0.5612677",
"0.55910933",
"0.55812943",
"0.5579838",
"0.55626655",
"0.55578876",
"0.55566823",
"0.5494533",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033",
"0.54927033"
] | 0.60483325 | 25 |
Tell RabbitMQ that you would like to stop consuming by sending the Basic.Cancel RPC command. | def stop_consuming(self):
if self._channel_ctrl:
self._channel_ctrl.basic_cancel(self._consumer_tag_ctrl)
self._channel_ctrl.close()
if self._channel_task:
self._channel_task.basic_cancel(self._consumer_tag_task)
self._channel_task.close()
self._consuming = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_consuming(self):\n if self._channel:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._channel.basic_cancel(self.on_cancelok, self._consumer_tag)",
"def _stop_consuming(self):\n if self._rx_channel and self._rx_channel.is_open:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._rx_channel.basic_cancel(consumer_tag=self._consumer_tag)\n logger.info(\"stop consuming\")",
"def cancel(self):\n def on_cancelok(method_frame):\n \"\"\"Handle cancelok.\n \"\"\"\n self.log.debug(\"Cancel ok on CHANNEL%s\",\n method_frame.channel_number)\n try:\n if self._consumer_tag:\n self._channel.basic_cancel(\n on_cancelok,\n self._consumer_tag\n )\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.log.warning('Channel already closed while closing queue')",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.queue.channel.rpc(self._basic_cancel)\n self.queue.consuming = False",
"def stop_consuming(self):\n if self._channel:\n self.logger.debug(\"Stopping message consuming on channel %i\", self._channel)\n\n self._connection.ioloop.add_callback_threadsafe(\n partial(\n self._channel.basic_cancel,\n consumer_tag=self._consumer_tag,\n callback=lambda *args: None,\n )\n )",
"async def cancel(\n self, consumer_tag: ConsumerTag,\n timeout: TimeoutType = None,\n nowait: bool = False,\n ) -> aiormq.spec.Basic.CancelOk:\n\n channel = await self.channel.get_underlay_channel()\n return await channel.basic_cancel(\n consumer_tag=consumer_tag, nowait=nowait, timeout=timeout,\n )",
"def on_cancelok(self, unused_frame):\n logger.info('RabbitMQ acknowledged the cancellation of the consumer')\n self.close_channel()",
"def cancel(self):\n self.stop()\n self.make_callback('canceled')",
"def stop_consumer_loop(self, message: Dict) -> NoReturn:\n message.ack()\n self.should_stop = True",
"def do_cancel(self):\r\n self.write({'cancelled': True})",
"def cancel(self):\n _notify.remove(self.callb)",
"async def async_cancel(self):\n raise NotImplementedError",
"async def on_cancel(self, payload):\n\n await self._delete_message(0)\n self.stop()",
"def cancel(self):",
"def cancel(self):",
"def cancel(self):",
"def cancel():",
"def cancel(self):\n pass",
"async def cancel(self, ctx):\n\n return",
"def cancel(update: Update, context: CallbackContext) -> int:\n update.message.reply_text(\n 'Bye! I hope we can talk again some day.', reply_markup=ReplyKeyboardRemove()\n )\n\n logger.info(\"User [%s] canceled BBT conversation using command [/stop].\",\n update.message.from_user.first_name)\n return ConversationHandler.END",
"def stop(self):\n logger.info(\"Stopping rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self._closing = True\n self.stop_consuming()\n if self._connection is not None:\n self._connection.ioloop.start()\n self.stopped = True\n logger.info(\"Stopped rabbit consumer for process: %s with consumer id %s\", threading.current_thread,\n str(self.consumer_id))",
"def _cancel(self):\n client = SBusClient(self.storlet_pipe_path)\n try:\n resp = client.cancel(self.task_id)\n if not resp.status:\n raise StorletRuntimeException('Failed to cancel task')\n except SBusClientException:\n raise StorletRuntimeException('Failed to cancel task')",
"def cancel(self):\n self.__canceled = True",
"def cancel(self):\n self.succeeded = False\n self.reject()",
"def cancel(self):\n self.succeeded = False\n self.reject()",
"def cancel(self):\n self.succeeded = False\n self.reject()",
"def cancel(self):\n self.succeeded = False\n self.reject()",
"def cancel(self) -> asyncio.Future:\n pass # pragma: no cover",
"def cancel(self):\n raise NotImplementedError(\n u\"%s: Method not implemented\", self.__class__.__name__)",
"def cancelMessageRetrieval(self):\n \n self.gatherData.stop()",
"def cancel(self):\n\n query = f\"scancel {self.jobid}\"\n if self.cluster:\n query = f\"scancel {self.jobid} --clusters={self.cluster}\"\n\n cmd = BuildTestCommand(query)\n cmd.execute()\n logger.debug(f\"Cancelling Job: {self.jobid} by running: {query}\")\n\n self.poll()\n self._state = \"CANCELLED\"",
"def on_consumer_cancelled(self, method_frame):\n logger.info('Consumer was cancelled remotely, shutting down: %r',\n method_frame)\n if self._channel:\n self._channel.close()",
"def on_cancel(self):\n self.state = CANCELED\n self._reject()",
"def cancel(self):\n self.on_cancel()",
"async def test_cancelled_task(self):\n await self.cog._unsilence(self.text_channel)\n self.cog.scheduler.cancel.assert_called_once_with(self.text_channel.id)",
"def cancel(self) -> None:\n c = self.pgconn.get_cancel()\n c.cancel()",
"async def cancel_handler(message: types.Message, state, raw_state=None):\n # Cancel state and inform user about it\n await state.finish()\n # And remove keyboard (just in case)\n await reply(message, \"Canceled.\", reply_markup=types.ReplyKeyboardRemove())",
"def cancel(\n control_address: str,\n **kwargs,\n ):\n try:\n Grpclet.send_ctrl_msg(control_address, 'TERMINATE')\n except RpcError:\n # TERMINATE can fail if the the runtime dies before sending the return value\n pass",
"def cancel(bot, update):\n bot.sendMessage(chat_id=update.message.chat_id, text=\"As you wish, the operation has been cancelled! 😊\")\n return ConversationHandler.END",
"def cancel(self):\n\t\treturn Job(SDK.PrlJob_Cancel(self.handle)[0])",
"def do_uncancel(self):\r\n self.write({'cancelled': False})",
"def request_stop(self):\n self._messaged.emit((\"stop\",None,0,None))",
"def cancel(self):\n\n self.end()\n super().cancel()",
"def scancel(self, arg):\n\n if isinstance(arg, (list, tuple)):\n for job_id in arg:\n self.scancel(job_id)\n\n elif str(arg).lower() == 'all':\n self._queue = None\n for job_id in self.queue_job_ids:\n self.scancel(job_id)\n\n elif isinstance(arg, (int, str)):\n cmd = ('scancel {}'.format(arg))\n cmd = shlex.split(cmd)\n subprocess.call(cmd)\n\n else:\n e = ('Could not cancel: {} with type {}'\n .format(arg, type(arg)))\n logger.error(e)\n raise ExecutionError(e)",
"def cancel(self, msg: typing.Optional[str] = None) -> None:\n self._cancelled = CancelledError(msg)\n warnings.warn(\n \"Calling this method will cause a CancelledError to be thrown in the \"\n \"Task sometime in the future.\",\n FutureWarning,\n stacklevel=2,\n )\n self.kill()",
"def cancel(self):\n return self.RES_OK",
"def stop(update, context) -> None:\n update.message.reply_text('Okay, bye.')\n\n logger.info(\"User [%s] canceled conversation using command [/stop].\",\n update.message.from_user.first_name)\n return END",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def Cancel(self, request, global_params=None):\n config = self.GetMethodConfig('Cancel')\n return self._RunMethod(\n config, request, global_params=global_params)",
"def canceled(self):\n self.reject()",
"def cancel(self):\n self.cancelled = True",
"def cancel(self):\n self.cancelled = True",
"def cancel(self): #$NON-NLS-1$\r",
"def cancel1_command(self):\n from time import sleep\n\n logger.debug(\" cancel1_command.py \")\n\n logger.debug(\"QUEUE_S1.put(True, block=0\")\n\n # QUEUE_S.put(True, block=False)\n queue1_put(QUEUE_S1, True)\n\n sleep(0.8) # wait for thread to quit",
"def reqGlobalCancel(self):\r\n self.ib.reqGlobalCancel()\r\n logging.info('reqGlobalCancel')",
"def kill(self):\n return self._raw_execute(\"cancel\", {\"job_id\": self.job_id})",
"async def test_cancel(self):\n await self.populate_test_data() # Populate data in foglamp.scheduled_processes\n\n scheduler = Scheduler(_address, _m_port)\n await scheduler.start()\n\n interval_schedule = IntervalSchedule()\n interval_schedule.name = 'cancel_test'\n interval_schedule.process_name = 'sleep30'\n interval_schedule.repeat = datetime.timedelta(seconds=0)\n\n await scheduler.save_schedule(interval_schedule)\n\n await asyncio.sleep(5)\n tasks = await scheduler.get_running_tasks()\n\n await scheduler.cancel_task(tasks[0].task_id) # Cancel a running task\n\n await self.stop_scheduler(scheduler)",
"def control_cancel(self, wait_for_ready: bool = True) -> None:\n self.__logger.debug('Eva.control_cancel called')\n return self.__http_client.control_cancel(wait_for_ready=wait_for_ready)",
"async def module_command_cancel(self, ctx, parsed):\n waiting = []\n wait_id = None\n cancelled = False\n if parsed.args[\"list\"]:\n waiting = [pair[1] for pair in self._delayed_commands.values()]\n else:\n wait_id = parsed.args[\"id\"]\n try:\n cancelled = True\n task, waiting = self._delayed_commands[wait_id]\n task.cancel()\n except KeyError:\n pass\n await ctx.core_command_cancel(parsed, cancelled, wait_id, waiting)",
"def cancel(self, membership, callback=None):",
"def __call__(self, cancel: int, passthrough: Optional[Any] = None, req_id: Optional[int] = None):\n\n data = {\n \"cancel\": int(cancel)\n }\n\n\n\n return self.send_websocket_request(self.name, data, passthrough=passthrough, req_id=req_id)",
"async def close_command(self, ctx: commands.Context) -> None:\n # Don't use a discord.py check because the check needs to fail silently.\n if await self.close_check(ctx):\n log.info(f\"Close command invoked by {ctx.author} in #{ctx.channel}.\")\n await _channel.help_post_closed(ctx.channel)\n if ctx.channel.id in self.scheduler:\n self.scheduler.cancel(ctx.channel.id)",
"async def cancel(self):\n\n await self.cb_0.cancel()\n await self.cb_1.cancel()"
] | [
"0.8647437",
"0.80648834",
"0.7330365",
"0.7032881",
"0.68281984",
"0.6754538",
"0.66251165",
"0.6620288",
"0.6522648",
"0.64616895",
"0.64530724",
"0.6451067",
"0.6432226",
"0.6420512",
"0.6420512",
"0.6420512",
"0.6391846",
"0.62892866",
"0.6275562",
"0.62321556",
"0.621953",
"0.62023264",
"0.61879414",
"0.6136462",
"0.6136462",
"0.6136462",
"0.6136462",
"0.6133691",
"0.61197126",
"0.61086273",
"0.6101029",
"0.60967",
"0.60821456",
"0.60792506",
"0.6055136",
"0.6048051",
"0.6011285",
"0.60056293",
"0.6004487",
"0.5993653",
"0.5992613",
"0.5974587",
"0.5951489",
"0.59401995",
"0.5939013",
"0.5930615",
"0.59298104",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59261936",
"0.59177846",
"0.5911062",
"0.5911062",
"0.59058726",
"0.5900984",
"0.5892197",
"0.58917284",
"0.5882943",
"0.5882763",
"0.58744645",
"0.5870854",
"0.586457",
"0.5858805",
"0.5858323"
] | 0.6646173 | 6 |
Run the example consumer by connecting to RabbitMQ and then starting the IOLoop to block and allow the SelectConnection to operate. | def run(self):
self._connection = self.connect()
self._connection.ioloop.start() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n try:\n\n self._connection = self.connect()\n self._connection.ioloop.start()\n except (KeyboardInterrupt, SystemExit):\n self.stop()\n except Exception as e:\n logger.warn(\"Exception: %s\", str(e))\n logger.warn(\"Exception caught on rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self.internal_error_queue.put(self.consumer_id)",
"def start(self) -> None:\n conn_manager = ConnectionManager(broker_host=self.broker_host, queue=self.queue)\n channel = conn_manager.start_channel()\n channel.basic_consume(queue=self.queue, on_message_callback=self.callback)\n\n try:\n print(\"PV Simulator...\")\n channel.start_consuming()\n except KeyboardInterrupt:\n pass",
"def run(self):\n self.logger.info(\"starting Dashi consumer\")\n while not self.shutdown:\n self.rpc.listen()",
"def connect(self):\n\t\tself.printed_sub = False\n\t\tself.client.connect(BROKER)\n\t\tself.client.loop_forever()",
"def main(host, port, debug=False, max_iters=None, only_proc=False, bulk=False):\n loop = asyncio.get_event_loop()\n asyncio.run(consumer(host, port, max_iters, only_proc, loop, bulk))",
"def consume(self):\n LOGGER.debug('Consumer Initialized')\n # self.connect()\n channel = self.get_channel()\n self._bind_things(channel)\n\n try:\n LOGGER.info('Start consuming')\n channel.start_consuming()\n except ConnectionClosed:\n LOGGER.exception('Pika connection closed detected. Will attempt to start consuming again')\n self.consume()\n except KeyboardInterrupt as e:\n LOGGER.info('Keyboard interrupt, stop consuming')\n self.shutdown()\n raise e\n except Exception as e:\n LOGGER.exception(\"'%s\" % str(e))\n self.shutdown()\n if self.settings.CONSUMER['RAISE_EXCEPTION']:\n LOGGER.info(\"CONSUMER RAISED EXCEPTION\")\n raise e",
"def run(self):\n\n self.make_connection()\n self.channel()\n self.declare_queue()\n self.publish_message()\n self.close_connection()",
"def consume():\n with conn.channel() as chan:\n \n def on_msg_recv(msg):\n \"\"\" Called when message arrives from RabbitMQ\n \"\"\"\n print \"processor|%s::Received message: %s\" % (UID, msg.body)\n chan.basic_ack(msg.delivery_tag)\n log(msg.body)\n process_msg(msg)\n \n \n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\n chan.exchange_declare(exchange = EXCHANGE,\n type = EXCHANGE_TYPE)\n queue = chan.queue_declare(QUEUE)\n chan.queue_bind(exchange = EXCHANGE, \n queue = QUEUE, \n routing_key = ROUTING_KEY)\n \n # Declare that we are going to listen to given queue\n chan.basic_consume(queue = QUEUE, \n callback = on_msg_recv)\n \n # Main loop. Waiting for messages from RabbitMQ.\n while True:\n chan.wait()",
"def start_consuming(self):\n logger.info('Issuing consumer related RPC commands')\n self.add_on_cancel_callback()\n logger.info(\"[{}] Waiting for messages on exchange {}\".format(self.bot_id, self.exchange))\n self._consumer_tag = self._channel.basic_consume(self.on_message,\n self.queue_name)",
"def start_consuming(self):\n self.logger.debug(\"Issuing consumer related RPC commands\")\n\n self._channel.basic_qos(prefetch_count=self._max_concurrent)\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\n consume_kwargs = {\"queue\": self._queue_name}\n if PIKA_ONE:\n consume_kwargs[\"on_message_callback\"] = self.on_message\n else:\n consume_kwargs[\"consumer_callback\"] = self.on_message\n\n self._consumer_tag = self._channel.basic_consume(**consume_kwargs)",
"def run_collectd_amqp(self):\n amqp_url = 'amqp://admin:admin@{}:{}/%2F'.format(self.mgmt['ip'], self.AMPQ_PORT)\n amqp = AmqpConsumer(amqp_url, self._queue)\n try:\n amqp.run()\n except (AttributeError, RuntimeError, KeyboardInterrupt):\n amqp.stop()",
"def run(self):\n self._connection = self.open_connection()\n self._connection.ioloop.start()",
"def run(self):\n self.connect()\n self.run_forever()",
"async def run(app):\n app.logger.debug(\"START RABBITMQ \")\n config = app.config.get('RABBITMQ')\n\n app.logger.debug(config)\n\n while True:\n loop = asyncio.get_event_loop()\n\n try:\n app.logger.debug(\"Create connection!\")\n connection = await aio_pika.connect_robust(\n \"amqp://{}:{}@{}\".format(\n config['username'],\n config['password'],\n config['host']\n ), loop=loop\n )\n # Creating channel\n app.logger.debug(\"Create channel\")\n channel = await connection.channel()\n async with connection:\n app.logger.debug(\"create exchange {}\".format(config['exchange_name']))\n await channel.declare_exchange(config['exchange_name'])\n\n app.logger.debug(\"create queue {}\".format(QUEUE_NAME))\n\n queue = await channel.declare_queue(\n QUEUE_NAME, auto_delete=True, durable=False\n )\n await queue.bind(exchange=config['exchange_name'], routing_key='*')\n\n async with queue.iterator() as queue_iter:\n async for message in queue_iter:\n async with message.process():\n content = message.body.decode()\n app.logger.debug(\"RABBITMQ: got message {}\".format(content))\n loop = asyncio.get_event_loop()\n loop.create_task(app.hub.dispatch_message(content))\n except Exception as e:\n app.logger.error(\"Exception in connection with rabbitmq. Back of a bit, and try again\")\n app.logger.exception(e)\n await asyncio.sleep(3)",
"def test_consumer(self):\n try:\n consumer = Consumer()\n consumer.poll()\n except (Exception) as error:\n logging.error(\"\\n\\nConsumer's connection to\"\n \"kafka failed with error: {}\\n\\n\".format(error))\n assert(False)",
"def listen_commands(self):\n self._consumer_rabbit_connection = BlockingConnection(ConnectionParameters(self._rabbit_host))\n self._consumer_rabbit_channel = self._consumer_rabbit_connection.channel()\n\n # Listen buy/sell orders from external system\n self._listen_queue(QueueName.CMD_BUYSELL, self.on_cmd_buysell)\n self._listen_queue(QueueName.MSG_RAW, self.on_raw_msg)\n # self._logger.info(f\"Declaring rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.queue_declare(queue=QueueName.CMD_BUYSELL, durable=True, auto_delete=True)\n # self._logger.info(f\"Consiming to rabbit queue {QueueName.CMD_BUYSELL}\")\n # self._consumer_rabbit_channel.basic_consume(QueueName.CMD_BUYSELL, self.on_cmd_buysell,\n # consumer_tag=\"WebQuikBroker\")\n self._consumer_rabbit_channel.start_consuming()",
"async def run(self) -> None:\n await self._mqtt.connect()\n LOGGER.info(\"Connected to MQTT Broker\")\n\n async with ClientSession() as websession:\n try:\n await self._setup_bridge(websession)\n except aiohue.errors.Unauthorized:\n LOGGER.error(\"Bridge rejected username. Please use --discover\")\n self.halt()\n return\n await self._publish_bridge_status()\n await self.main(websession)\n\n LOGGER.info(\"Disconnecting from MQTT Broker\")\n await self._publish_bridge_status(online=False)\n await self._mqtt.disconnect()",
"def start_consuming(self):\n # LOGGER.info('Issuing consumer related RPC commands')\n if self._init_ok_ctrl and self._init_ok_task:\n self._channel_ctrl.add_on_cancel_callback(self.on_consumer_ctrl_cancelled)\n self._channel_task.add_on_cancel_callback(self.on_consumer_task_cancelled)\n self._consumer_tag_task = self._channel_task.basic_consume(\n self.queue_task,\n auto_ack=False,\n on_message_callback=self.on_message\n )\n self._consumer_tag_ctrl = self._channel_ctrl.basic_consume(\n self._topic_queue_name,\n auto_ack=False,\n on_message_callback=self.on_topic\n )\n self.was_consuming = True\n self._consuming = True",
"def test_create_consumer(self):\n try:\n test_consumer = TestConsumer(self.msg_queue, self.queue_lock, self.topic, self.properties_file)\n except Exception as e:\n self.fail(f\"test_create_consumer() failed with exception: {e}\")\n\n try:\n test_consumer.start()\n except Exception as e:\n self.fail(f\"test_consumer.start() in test_create_consumer() failed with exception: {e}\")\n\n # Sleep for a couple seconds to allow the thread to come up.\n time.sleep(2)\n self.assertEqual(3, threading.active_count()) # Main thread, consumer thread, consumer-group hear-beat daemon.\n\n test_consumer.stop()\n test_consumer.join()\n self.assertEqual(2, threading.active_count())",
"def __init__(self):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n self.channel = self.connection.channel()",
"def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)",
"def run(self):\n\t\t\n\t\tself.connect(self.config[\"server\"])",
"async def consumer_loop(\n uri: str,\n topic: str,\n ssl_context: SSLContext,\n writers: List[Callable[[ConsumerPayload], Awaitable[int]]],\n) -> int:\n log.info(\"consumer: starting\")\n if len(writers) < 1:\n raise ValueError(\"there must be at least one writer passed to consumer_loop.\")\n queue: asyncio.Queue[ConsumerPayload] = asyncio.Queue()\n async with AIOKafkaConsumer(\n topic,\n bootstrap_servers=uri,\n security_protocol=\"SSL\",\n ssl_context=ssl_context,\n group_id=DEFAULT_GROUP_ID,\n ) as consumer:\n await asyncio.gather(\n decoder(queue, consumer), writer_wrapper(queue=queue, writers=writers)\n )\n log.info(\"consumer: exiting\")\n return 0",
"def run(self):\n self.listen(self.input_topics.filter_by(transmission='tcp'))\n\n logging.info('Getting into the listening loop')\n self.running = True\n while self.running:\n self.loop()",
"def consume_message_bus(self, test=False):\n if test:\n from test_fake_bus import FakeChannel, FakeConnection\n self.logger.info(\"Running Test Message Bus\")\n\n self.channel = FakeChannel(self.on_bus_message, self.forwarder_options, self.logger)\n self.connection = FakeConnection()\n\n return\n\n username, password = self.get_bus_credentials()\n credentials = pika.PlainCredentials(username, password)\n parameters = pika.ConnectionParameters(self.cb_server_hostname, 5004, \"/\", credentials)\n\n self.connection = pika.SelectConnection(parameters, self.bus_on_connected,\n on_close_callback=self.bus_on_closed)\n self.logger.info(\"Starting bus connection\")\n self.retry_attempts = 0\n self.connection.ioloop.start()",
"def main():\n s = start_server()\n accept_connection(s)",
"def run(self):\n client = ProcessorClient()\n try:\n client.connect(self.address)\n except Exception as e:\n self.error = e\n logging.error(e)\n else:\n self.clients[self.name] = client",
"def do_start(self):\n threading.Thread(group = None, \n target = self._subscribe_message, name = \"RabbitMQSubscribeThread\") .start()\n threading.Thread(group = None, \n target = self._publish_message, name = \"RabbitMQPublishThread\").start()",
"def start(self):\n self._connect()\n self._init_exchange()\n self._init_queue()\n self._bind_queue()",
"def run(self):\n self.channel.queue_declare(self._request_queue)\n self.channel.basic_consume(self._request_queue, self.on_message)\n try:\n msg = \"Waiting for message ...\"\n print(msg)\n logging.info(msg)\n self.channel.start_consuming()\n except KeyboardInterrupt:\n self.channel.stop_consuming()\n\n self.connection.close()",
"def _run(self):\n print \"ZMQSubscriber: loop started\"\n port = \"5556\"\n context = zmq.Context()\n socket = context.socket(zmq.SUB)\n socket.connect(\"tcp://localhost:%s\" % port)\n # socket.setsockopt_string(zmq.SUBSCRIBE, u'') # get everything\n socket.setsockopt_string(zmq.SUBSCRIBE, u'[firewall]')\n socket.setsockopt_string(zmq.SUBSCRIBE, u'END')\n\n while self._do_work.is_set():\n try:\n data = socket.recv_string()\n # print \"Got data:\", repr(data)\n print data\n if data == 'END':\n self.stop()\n except Queue.Empty:\n pass\n\n print \"ZMQSubscriber: loop stopped\"",
"def connect(self):\n\n if settings.DEBUG:\n parameters = pika.ConnectionParameters(self._host)\n else:\n credentials = pika.PlainCredentials(\n username=settings.RABBITMQ_USERNAME,\n password=settings.RABBITMQ_PASSWORD\n )\n parameters = pika.ConnectionParameters(\n host=self._host,\n port=self._port,\n virtual_host=self._vhost,\n credentials=credentials\n )\n\n try:\n msg = \"Connection established successfully with rabbitmq server !!!\"\n self.connection = pika.BlockingConnection(parameters)\n self.channel = self.connection.channel()\n print(msg)\n logging.info(msg)\n except Exception as e:\n raise RabbitmqConnectionError(str(e))",
"def run(self):\n self.connect()",
"def consume_message(message):\n # Assign the message to the global drone_message\n global drone_message\n drone_message = message\n # The Rabbit mq runs in the localhost and the username , password is\n # athavan\n credentials = pika.PlainCredentials('guest', 'guest')\n # Pass the mqhost , port , virtualhost and credentials\n parameters = pika.ConnectionParameters('localhost', 5672, '/', credentials)\n connection = pika.SelectConnection(parameters, on_connected)\n try:\n connection.ioloop.start()\n except KeyboardInterrupt:\n # close the connnection\n connection.close()\n # loop until we are fully closed. It will stop on its own\n connection.ioloop.start()",
"def run(self):\n ioloop.IOLoop.current().start()",
"def run(self):\n print('starting up on {} port {}'.format(*self.listener_address))\n self.selector.register(self.listener, selectors.EVENT_READ)\n\n # Serialize our listener's host and port\n serializedAdd = fxp_bytes_subscriber.serialize_address(\n self.listener_address[0], self.listener_address[1])\n\n # Contact with Publisher\n self.listener.sendto(serializedAdd, self.gcd_address)\n\n while True:\n events = self.selector.select(CHECK_INTERVAL)\n for key, mask in events:\n data = self.receive_message()\n self.removeOldQuote()\n self.createGraph(data)\n self.arbitrage()\n self.checkTimeout()",
"def connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\n self.chan.exchange_declare(exchange=self.EXCH, type=\"topic\", durable=True, auto_delete=False,)\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\"ctag\")\n except:\n self.closeConn()",
"def start(self):\n if not self._connected:\n self._client.connect(self._addr, port=self._port, keepalive=60, bind_address=\"\")\n self._client.loop_start()\n self._connected = True\n logger.info(\"Connection with MQTT Broker at %s:%d estabilished.\", self._addr, self._port)",
"def test_main():\n\n listener = Qe2ServerListener('', 4000)\n reactor.run()",
"def run(self):\n print(\"[CONNEXION_MANAGER] start connecting\")\n while True:\n self.connexion_init()",
"def start(self):\n if self._chan is not None:\n try:\n self._chan.start_consume()\n except ChannelError:\n log.info('Subscriber is already started')\n\n else:\n self.gl = spawn(self.listen)",
"def main():\n try:\n asyncio.run(produce_consume(\"com.udacity.lesson3.sample2.purchases\"))\n except KeyboardInterrupt as e:\n print(\"shutting down\")",
"def run(self):\n HOST = 'localhost' # Symbolic name meaning all available interfaces\n PORT = 54123 # Arbitrary non-privileged port\n \n \n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n s.bind((HOST, PORT))\n while(self.running):\n s.listen(1)\n conn, addr = s.accept()\n self.listen_to_connection(conn)\n conn.close()\n s.close()",
"def listen(self):\n self.channel.start_consuming()",
"def run_client(self, event_loop, irc_client):\n # Deliberately written in \"synchronous\" style with run_until_complete()\n # instead of await because async generators don't work in Python 3.5.\n with self.mock_open_connection():\n # Start the client\n run_fut = event_loop.create_task(irc_client.run())\n event_loop.run_until_complete(irc_client.connected.wait())\n # Allow the test to run\n yield\n # Cleanly end the read loop and wait for client to exit\n irc_client.disconnect()\n event_loop.run_until_complete(run_fut)",
"def connect(self):\r\n try:\r\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(self.ip))\r\n print (\"connected!\")\r\n except Exception as error:\r\n print (\"connect() - error - {}\".format(error))",
"def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True",
"def run(self):\n while not self._stopping:\n try:\n self._connection = self.connect()\n self._connection.ioloop.start()\n except KeyboardInterrupt:\n self.stop()\n if (self._connection is not None and not self._connection.is_closed):\n self._connection.ioloop.start()\n\n print(\"Stopping publisher thread\")",
"def main():\n client = mqtt.Client('kj-relayr') # Create client. The parameter is our client-id\n\n # Callback is attached by assigning it to on_message attribute of client.\n # From now on our on_message function will\n client.on_message = on_message\n\n # Connect to the broker - we pass host and port (port is optional).\n client.connect(BROKER_HOST, BROKER_PORT)\n\n # Start the network loop. Without that the client won't be able to receive messages.\n # Internally it starts separate thread of execution in which all the incoming messages\n # are processed.\n client.loop_start()\n\n # Subscribe to relayr/test topic\n result, mid = client.subscribe('relayr/test')\n\n # Methods that publish/subscribe return result (status code) indicating if operation succeeded (result=0) or not\n # as well as message id. This message id can be used for tracking purposes.\n print(f'Result: {result}, message_id: {mid}')\n\n # Publish message to the same topic\n client.publish('relayr/test', 'test message')\n\n # It takes nonzero time before broker receives message and propagates it to subscribed clients.\n # Therefore we artificially stop execution for a second for it to happen. During this time,\n # our client should receive the message and we should see it printed to stdout.\n time.sleep(1)\n\n # Disconnect from the broker.\n client.disconnect()\n\n # Stop the event loop. This will shut the background thread down.\n client.loop_stop()",
"def run(self):\n\n def callback(ch, method, properties, body):\n json_body = json.loads(body)\n self.buffer.append(Fvalue.fromdict(json_body))\n\n sleep(5) # We introduce a slight delay to let the RabbitMQ container to accept connections\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.mq_host,port=self.mq_port))\n channel = connection.channel()\n channel.exchange_declare(exchange=self.mq_host + '_exchange', exchange_type='direct')\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.queue_bind(exchange=self.mq_host + '_exchange',\n queue=queue_name,\n routing_key=self.routing_key)\n channel.basic_consume(callback,queue=queue_name,no_ack=True)\n channel.start_consuming()",
"def run_server(self):\n self.establish_connection()\n while True:\n self.receive_data(self.conn)",
"def start(self):\n if config['port'] or config['host']:\n port = config['port'] or 5222\n host = config['host'] or sleekxmpp.JID(config['jid']).host\n addr = (host, port)\n else:\n addr = tuple()\n self.connect(addr)\n self.process(threaded=True)",
"def _setup_connection(self, parameters):\n logger.info('Connecting to %s', parameters)\n return pika.BlockingConnection(parameters = parameters)",
"def create_consumer(self, topic_id: str, callback: Callable, gcp_subscription_id:str=None):\n backend = None\n if self.vendor == 'kafka':\n backend = KafkaClient(topic_id, self.configs['kafka_servers'])\n Consumer(backend, callback)\n else:\n project_id = os.getenv(\"GOOGLE_CLOUD_PROJECT\")\n subscription_id = gcp_subscription_id\n backend = GooglePubSubClient(project_id=project_id, topic=topic_id,\n subscription_id=subscription_id, gcp_configs=self.configs, callback=callback)\n runner_thread = Thread(target=runner)\n runner_thread.start()",
"def run(self):\n self.log.info(u'[AIM] Logging into aol.com')\n p = protocol.ClientCreator(reactor, OSCARAuth,\n settings.AIM_USERNAME,\n settings.AIM_PASSWORD, icq=0)\n p.connectTCP(*self.server)\n self.log.info('[AIM] Connected')\n p.protocolClass.BOSClass.bot = self\n reactor.callInThread(self.poll)\n reactor.run()\n self.log.info(u'[AIM] Connection closed')",
"def main() -> None:\n\n logger.info(f\"Arguments: {args}\")\n client = iotcore.Client()\n client.subscribe(args.request_topic, iotcore.QOS.AT_MOST_ONCE, handler)\n\n while True:\n # Keep app open and running\n time.sleep(1)",
"def listen(self):\n result = self.channel.queue_declare(queue=self.config['queue'], \n exclusive=True)\n if self.endpoints is not None:\n for key in self.endpoints:\n self.channel.queue_bind(exchange=self.config['exchange'], \n queue=self.config['queue'],\n routing_key=f\"sensor_value.{key}\")\n else:\n self.channel.queue_bind(exchange=self.config['exchange'],\n queue=self.config['queue'],\n routing_key=\"sensor_value.#\")\n \n self.channel.basic_consume(queue=self.config['queue'], \n on_message_callback=self.decode_values, \n auto_ack=True)\n\n # starts a while-type loop\n print(\"wabbit eatin hay\")\n self.channel.start_consuming()",
"def run(self):\n\n if self._quit_time is not None:\n self.schedule_quit_time(self._quit_time)\n\n # Run the broker until it, and thus the whole scale client, have a stop event fully propagated\n self.__broker.run()",
"async def do_startup(config, output_fname, event_loop):\n\n log.info(\"Creating AMQP receive channel ...\")\n rcv_trans, rcv_proto, rcv_chan = await make_amqp_channel(config)\n\n log.info(\"Setting up event exchange ...\")\n await rcv_chan.exchange_declare(\n exchange_name=config.event_exchange, type_name=\"fanout\"\n )\n\n logger = EventLogger(config, output_fname, event_loop)\n\n for signame in [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"]:\n signum = getattr(signal, signame)\n handler = partial(term_handler, signame=signame, loop=event_loop)\n event_loop.add_signal_handler(signum, handler)\n\n log.info(\"Setting up AMQP receiver ...\")\n bm_callback = partial(handle_broker_message, logger)\n await make_receiver_queue(bm_callback, rcv_chan, config, \"\")\n\n return rcv_trans, rcv_proto",
"def _connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.exchange_declare(exchange=self.exch, type=\"topic\", durable=True, auto_delete=False,)\n self.log(\"%conn-open\", \"info\", \"Connection to AMQP broker opened\")\n except Exception,e:\n self.log(\"%conn-error\", \"error\", \"Error whilst connecting to AMQP broker (%s)\" % e)\n self.closeConn()",
"def start(self):\n zmq_uri = (\n \"{protocol}://{address}:{port}\".format(\n protocol=self.protocol, address=self.address, port=self.port\n )\n if self.port\n else \"{protocol}://{address}\".format( # noqa\n protocol=self.protocol, address=self.address\n )\n )\n log.debug(\"ZMQ URI: %s\", zmq_uri)\n self.ctx = zmq.Context()\n if hasattr(zmq, self.type):\n skt_type = getattr(zmq, self.type)\n else:\n skt_type = zmq.PULL\n self.sub = self.ctx.socket(skt_type)\n self.sub.connect(zmq_uri)\n if self.hwm is not None:\n self.sub.setsockopt(zmq.RCVHWM, self.hwm)\n if self.recvtimeout is not None:\n log.debug(\"Setting RCVTIMEO to %d\", self.recvtimeout)\n self.sub.setsockopt(zmq.RCVTIMEO, self.recvtimeout)\n if self.keepalive is not None:\n log.debug(\"Setting TCP_KEEPALIVE to %d\", self.keepalive)\n self.sub.setsockopt(zmq.TCP_KEEPALIVE, self.keepalive)\n if self.keepalive_idle is not None:\n log.debug(\"Setting TCP_KEEPALIVE_IDLE to %d\", self.keepalive_idle)\n self.sub.setsockopt(zmq.TCP_KEEPALIVE_IDLE, self.keepalive_idle)\n if self.keepalive_interval is not None:\n log.debug(\"Setting TCP_KEEPALIVE_INTVL to %d\", self.keepalive_interval)\n self.sub.setsockopt(zmq.TCP_KEEPALIVE_INTVL, self.keepalive_interval)",
"def main() -> None:\n runner()\n asyncio.get_event_loop().run_forever()",
"def main() -> None:\n runner()\n asyncio.get_event_loop().run_forever()",
"async def start(self) -> None:\n while self.producer is None:\n try:\n self.producer = self._producer_factory(\n bootstrap_servers=self.bootstrap_servers,\n ssl_cafile=self.ssl_cafile,\n ssl_certfile=self.ssl_certfile,\n ssl_keyfile=self.ssl_keyfile,\n security_protocol='SSL',\n value_serializer=lambda v: json.dumps(v).encode('utf-8'),\n )\n except kafka.errors.NoBrokersAvailable:\n await trio.sleep(self.connect_interval_secs)\n else:\n logger.info('kafka-ready: %s', self.producer)\n async with self.has_producer:\n self.has_producer.notify_all()",
"def start_consuming(self, channel, rx_queue_name):\n if self.should_stop():\n logger.info(\"ready to stop, pause to consume\")\n return\n logger.info('Issuing consumer related RPC commands')\n self._consumer_tag = channel.basic_consume(\n self.on_message, rx_queue_name, auto_ack = False)\n channel.start_consuming()",
"def connect(self):\n self.start()",
"def run_chat_client():\r\n while must_run:\r\n print_menu()\r\n action = select_user_action()\r\n perform_user_action(action)\r\n print(\"Thanks for watching. Like and subscribe! 👍\")",
"def _main():\n parser = _create_parser()\n args = parser.parse_args()\n\n if args.interval is None:\n args.interval = 10\n\n if args.what_if is None:\n args.what_if = False\n\n loop = asyncio.get_event_loop()\n\n params = {\n \"connection_string\": args.connection_string,\n \"name\": args.name,\n \"interval\": args.interval,\n \"what_if\": args.what_if\n }\n\n loop.run_until_complete(_run(params))",
"def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()",
"def _begin_consuming(self):\n self._consuming = True\n loop = asyncio.get_event_loop()\n self._message_queue = asyncio.Queue(\n maxsize=self.app.settings['SQS_PREFETCH_LIMIT'],\n loop=loop,\n )\n loop.create_task(self._consume())",
"def connect(self):\n self.logger.info(\"Connecting to AMQP broker @ [{}:{}] ...\".format(\n self._host, self._port))\n connection = pika.SelectConnection(\n pika.URLParameters(host=self.host, port=self.port),\n on_open_callback=self.on_connection_open,\n on_open_error_callback=self.on_connection_open_error,\n on_close_callback=self.on_connection_closed,\n stop_ioloop_on_close=False)\n self._connection = connection\n return connection",
"def main():\n my_painting_mqtt_client = MyPaintingMQTTClient()\n my_painting_mqtt_client.run_app()",
"def start_publishing(self):\n print(f\"{self._connection_param}: Issuing consumer related RPC commands\")\n # self._channel.confirm_delivery(self.on_delivery_confirmation)\n self.schedule_next_message(self.SLOW_SEND)",
"def connect(self):\n self._connect()\n if self.conn is not None:\n try:\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\n except:\n self.closeConn()",
"def __init__(self, consumer):\n self._consumer = consumer",
"def connect(self):\n logger.info(\"[{}] Connecting to exchange {}\".format(self.bot_id, self.exchange))\n creds = pika.PlainCredentials(self.rabbit_user, self.rabbit_pw)\n return pika.SelectConnection(pika.ConnectionParameters(host=self.rabbit_host,\n port=self.rabbit_port,\n virtual_host='/',\n credentials=creds,\n socket_timeout=1,\n retry_delay=5 # 5 seconds\n ),\n self.on_connection_open,\n stop_ioloop_on_close=False)",
"def consumeMsg():\n\tosuser = 'osdev'\n\tospass = 'osdev'\n\toshost = '10.32.29.94'\n\tosport = '5672'\n\tosvhost = '/openstack'\n\tneutronExchange = Exchange('quantum', type='topic', durable=False)\n\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\n\t\t\trouting_key='notifications.info')\n\twith Connection(\"\".join(['amqp://', osuser, ':', ospass, '@', \n\t\toshost, ':',osport, '/', osvhost])) as conn:\n\t\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\n\t\t\twhile True:\n\t\t\t\ttry: \n\t\t\t\t\tconn.drain_events()\n\t\t\t\texcept Exception, e:\n\t\t\t\t\tlogging.exception('Draining events from AMQP stop')\n\t\t\t\t\tbreak",
"def start_loop(\n consumer: Consumer,\n message_handler: Callable[[Message], None],\n on_success: Callable[[Message], None] = lambda msg: None,\n on_failure: Callable[[Message, Exception], None] = lambda msg, e: None,\n on_config_update: Callable[[], None] = lambda: None,\n logger: logging.Logger = logging.getLogger('IR')):\n # Used for re-fetching the configuration with a throttle\n last_updated_minute = int(time.time() / 60)\n if not config()['global_config_url']:\n config_tag = _fetch_latest_config_tag()\n\n while True:\n msg = consumer.poll(timeout=0.5)\n if msg is None:\n continue\n curr_min = int(time.time() / 60)\n if not config()['global_config_url'] and curr_min > last_updated_minute:\n # Check for configuration updates\n latest_config_tag = _fetch_latest_config_tag()\n last_updated_minute = curr_min\n if config_tag is not None and latest_config_tag != config_tag:\n config(force_reload=True)\n config_tag = latest_config_tag\n on_config_update()\n if msg.error():\n if msg.error().code() == KafkaError._PARTITION_EOF:\n logger.info('End of stream.')\n else:\n logger.error(f\"Kafka message error: {msg.error()}\")\n continue\n val = msg.value().decode('utf-8')\n try:\n msg = json.loads(val)\n except ValueError as err:\n logger.error(f'JSON parsing error: {err}')\n logger.error(f'Message content: {val}')\n consumer.commit()\n continue\n logger.info(f'Received event: {msg}')\n start = time.time()\n try:\n message_handler(msg)\n # Move the offset for our partition\n consumer.commit()\n on_success(msg)\n logger.info(f\"Handled {msg['evtype']} message in {time.time() - start}s\")\n except Exception as err:\n logger.error(f'Error processing message: {err.__class__.__name__} {err}')\n logger.error(traceback.format_exc())\n # Save this error and message to a topic in Elasticsearch\n on_failure(msg, err)",
"def run(self, item_callback=None):\n self.item_callback = item_callback\n logger.info('Starting consumer. Use CTRL+C to stop.')\n while self.shards:\n # time.sleep(0.5)\n for shard in self.shards:\n shard_id = shard['ShardId']\n shard_iterator = self.get_iterator(shard)\n self.process_records(shard_iterator, shard_id)",
"def enable_subscription():\n client = KConsumer(config=subscriber_config)\n counter = 0\n while 1:\n data = client.consume()\n if data:\n print(\"Received Data\", counter)\n class_label = inference_on_data(data.value)\n publish_response(class_label)",
"def run(self) -> None:\n\t\tself.messageHandler and self.messageHandler.logging(self.mqttClient, logging.DEBUG, f'MQTT: client name: {self.clientID}')\n\t\tself.mqttClient = mqtt.Client(client_id=self.clientID, clean_session=False if self.clientID else True)\t# clean_session=False is defined by TS-0010\n\n\t\t# Enable SSL\n\t\tif self.useTLS:\n\t\t\tself.mqttClient.tls_set(ca_certs=self.caFile, cert_reqs=ssl.CERT_REQUIRED if self.verifyCertificate else ssl.CERT_NONE)\n\n\t\t# Set username/password\n\t\tif self.username and self.password:\n\t\t\tself.mqttClient.username_pw_set(self.username, self.password)\n\t\t\n\t\tself.mqttClient.on_connect \t\t= self._onConnect\n\t\tself.mqttClient.on_disconnect\t= self._onDisconnect\n\t\tself.mqttClient.on_log\t\t\t= self._onLog\n\t\tself.mqttClient.on_subscribe\t= self._onSubscribe\n\t\tself.mqttClient.on_unsubscribe\t= self._onUnsubscribe\n\t\tself.mqttClient.on_message\t\t= self._onMessage\n\n\t\ttry:\n\t\t\tself.messageHandler and self.messageHandler.logging(self.mqttClient, logging.DEBUG, f'MQTT: connecting to host:{self.address}, port:{self.port}, keepalive: {self.keepalive}, bind: {self.bindIF}')\n\t\t\tself.mqttClient.connect(host=self.address, port=self.port, keepalive=self.keepalive, bind_address=self.bindIF)\n\t\texcept Exception as e:\n\t\t\tif self.messageHandler:\n\t\t\t\tself.messageHandler.logging(self.mqttClient, logging.ERROR, f'MQTT: cannot connect to broker: {e}')\n\t\t\t\tself.messageHandler.onError(self, -1)\n\n\t\t# Actually start the actor to run the MQTT client as a thread\n\t\tself.actor = BackgroundWorkerPool.newActor(self._mqttActor, name='MQTTClient').start()",
"def main():\n\n # Logging\n coloredlogs.install(level='INFO')\n\n # Connect to Rabbit\n rabbit = Client('hms_website', 'haum', ['irc_command'])\n\n rabbit.connect()\n\n def voice_required(f):\n \"\"\"Decorator that checks if the sender is voiced.\"\"\"\n def wrapper(*args):\n print(args)\n if 'is_voiced' in args[2] and args[2]['is_voiced']:\n return f(*args)\n else:\n rabbit.publish('irc_debug', {'privmsg': 'On se connait ? Tu n’es pas voiced mon ami...'})\n return wrapper\n\n\n @topic('irc_command')\n def callback(client, topic, message):\n\n @voice_required\n def do_work(client, topic, message):\n rabbit.publish('irc_debug', {'privmsg': 'Mise à jour du site en cours…'})\n\n success = updatesite()\n message = \"T'as tout cassé\"\n\n if success:\n message = \"Le site est à jour !\"\n\n rabbit.publish('irc_debug', {'privmsg': message})\n\n\n if 'command' in message and message['command'] == 'updatesite':\n do_work(client, topic, message)\n\n\n rabbit.listeners.append(callback)\n \n # Infinite listenning for messages\n rabbit.start_consuming()\n\n rabbit.disconnect()",
"def amqp_process_for_nfvi_kpi(self):\n if self.amqp_client is None and self.enable:\n self.amqp_client = multiprocessing.Process(\n name=\"AmqpClient-{}-{}\".format(self.mgmt['ip'], os.getpid()),\n target=self.run_collectd_amqp)\n self.amqp_client.start()",
"def run(self):\n if self.init():\n while not self._stop.value:\n try:\n sockets = dict(self.poll.poll(100))\n if (self.sock_reply in sockets and\n sockets[self.sock_reply] == zmq.POLLIN):\n request = self.sock_reply.recv_multipart()\n # do some 'work', update status\n cmd = loads(request[0])\n self.running = 1\n self.coroutine.run(cmd)\n self.running = 0\n self.nb_job_done += 1\n # send reply back to router/queuer\n self.sock_reply.send_multipart(request)\n\n except Exception as e:\n self.log.error('CONSUMER exception {}'.format(e))\n break\n self.sock_reply.close()\n self.finish()\n self.done = True",
"def main():\n print(\"Starting python server...\")\n\n # Set address to localhost\n address = \"tcp://127.0.0.1:\" + parse_port()\n\n # Start server with class API as \n server = zerorpc.Server(API.API())\n server.bind(address)\n\n print(\"Server started running on {}\".format(address))\n\n # Blocking command. Keeps server running\n server.run()",
"def create_connection(self):\n if self.conn:\n raise Exception(\"Connection already open\")\n cfg = self.config[self.MODULE_NAME]['amqp']['connection']\n log.debug(str(cfg))\n self.conn = pika.AsyncoreConnection(pika.ConnectionParameters(\n credentials = pika.PlainCredentials(cfg['login'],cfg['password']), \n heartbeat=cfg['heartbeat'],\n virtual_host=cfg['vhost'],\n port=cfg['port'],\n host=cfg['host']))\n self.channel = self.conn.channel()\n\n self._setup_tubes()",
"def run():\n listen_active_email_channel()",
"def start(self):\n super().start()\n loop = IOLoop.current()\n # Collect and send all IOPub messages, for all time\n # TODO: Check errors from this loop and restart as needed (or shut down the kernel)\n loop.add_callback(self.relay_iopub_messages)",
"def __init__(self, bot_id, exchange, callback_func, rabbit_user, rabbit_pw, rabbit_host,\n rabbit_port, consumer_id = 0, internal_error_queue = None, statsd = None):\n\n super(RabbitConsumer, self).__init__()\n\n self.rabbit_port = rabbit_port\n self.rabbit_host = rabbit_host\n self.rabbit_pw = rabbit_pw\n self.rabbit_user = rabbit_user\n self.bot_id = bot_id\n self.exchange = exchange\n self.callback_func = callback_func\n self._closing = False\n self.stopped = False\n self._connection = None\n self._channel = None\n self._closing = False\n self._consumer_tag = None\n\n self.queue_name = self.exchange + \"-\" + self.bot_id\n self.error_queue_name = 'error-' + self.bot_id + \"-\" + self.exchange\n self.consumer_id = consumer_id\n self.internal_error_queue = internal_error_queue\n\n self.statsd = statsd\n\n self.statsd_prefix = self.exchange + \".\"\n\n self.invocations = 0\n self.total_execution_time = 0",
"def configure_rabbit (ec2_conn,base_name,params ):\n print \"configuring rabbitmq exchanges and Queues\"\n app_type = 'RABBITMQ'\n \n logging.basicConfig()\n \n ## Allow security from build server to rabbitmq\n rabbit_lb_sec_grp_name = get_lb_secgrp_name( base_name, app_type )\n rabbit_lb_sec_grp = find_secgrp(ec2_conn, rabbit_lb_sec_grp_name)\n \n try :\n rabbit_lb_sec_grp.authorize( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr )\n except :\n print \"rule exists aready\" \n \n \n rabbitmq_host = params.get( 'host' )\n rabbitmq_port = params.get( 'port' )\n rabbitmq_username = params.get( 'user-name' )\n rabbitmq_password = params.get( 'password' )\n exchanges = params.get( 'exchanges' )\n \n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\n amqp_url = str(amqp_url)\n parameters = pika.URLParameters(amqp_url)\n connection = pika.BlockingConnection(parameters)\n channel = connection.channel()\n \n \n \n for exchnage in exchanges :\n exchange_name = exchnage.get(\"name\")\n exchange_type = exchnage.get(\"type\")\n queue_name = exchnage.get(\"queue\")\n routings = exchnage.get(\"bindings\")\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable=True )\n channel.queue_declare(queue=queue_name,\n durable=True)\n for routing in routings :\n channel.queue_bind(queue=queue_name, exchange=exchange_name, routing_key=routing)\n print \"binging exchnage: \" +exchange_name+\", to a queue:\"+queue_name+\" ,with routing key:\"+routing\n \n ## close connection at the end \n connection.close()\n \n ## At the end revoke the build server rule \n try :\n rabbit_lb_sec_grp.revoke( ip_protocol = \"tcp\",\n from_port = 8443,\n to_port = 8443,\n cidr_ip = build_server_cidr)\n \n except :\n print \"exception removing rule\"",
"def run_interactive():\n from cherrypy import engine\n \n # This is what quickstart does but we don't block\n engine.signals.subscribe()\n engine.start()\n #engine.block()",
"def _mp_consume(client, group, topic, queue, size, events, **consumer_options):\n\n # Initial interval for retries in seconds.\n interval = 1\n while not events.exit.is_set():\n try:\n # Make the child processes open separate socket connections\n client.reinit()\n\n # We will start consumers without auto-commit. Auto-commit will be\n # done by the master controller process.\n consumer = SimpleConsumer(client, group, topic,\n auto_commit=False,\n auto_commit_every_n=None,\n auto_commit_every_t=None,\n **consumer_options)\n\n # Ensure that the consumer provides the partition information\n consumer.provide_partition_info()\n\n while True:\n # Wait till the controller indicates us to start consumption\n events.start.wait()\n\n # If we are asked to quit, do so\n if events.exit.is_set():\n break\n\n # Consume messages and add them to the queue. If the controller\n # indicates a specific number of messages, follow that advice\n count = 0\n\n message = consumer.get_message()\n if message:\n while True:\n try:\n queue.put(message, timeout=FULL_QUEUE_WAIT_TIME_SECONDS)\n break\n except queue.Full:\n if events.exit.is_set():\n break\n\n count += 1\n\n # We have reached the required size. The controller might have\n # more than what he needs. Wait for a while.\n # Without this logic, it is possible that we run into a big\n # loop consuming all available messages before the controller\n # can reset the 'start' event\n if count == size.value:\n events.pause.wait()\n\n else:\n # In case we did not receive any message, give up the CPU for\n # a while before we try again\n time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)\n\n consumer.stop()\n\n except KafkaError as e:\n # Retry with exponential backoff\n log.error(\n \"Problem communicating with Kafka (%s), retrying in %d seconds...\" % (e, interval))\n time.sleep(interval)\n interval = interval * 2 if interval * 2 < MAX_BACKOFF_SECONDS else MAX_BACKOFF_SECONDS",
"def _exampleIrc():\n\n write_queue, read_queue = simple_connect((\"localhost\", 6667))\n \n #run(...) will make sure we're connected before dequeuing items\n #Connect to the irc server on localhost\n write_queue.put(\"NICK Dot\")\n write_queue.put(\"USER Dot localhost localhost :Dot the bot\")\n while True:\n data = read_queue.get()\n if data is None: #End of network condition\n return \n if data.startswith(\"PING\"):\n write_queue.put(\"PONG\" + data[4:])\n write_queue.put(\"JOIN #test\")\n if data.endswith(\"quit\"):\n data = None # make the bot send None to kill the connection\n write_queue.put(data)",
"async def run(self):\n\n self.connection = await aio_pika.connect(self.mq_connection_str, loop=asyncio.get_event_loop())\n self.channel = await self.connection.channel()\n\n # connect to exchanger market data\n # market data send with routing key format: message_type.data_type.exchange.pair[.time_frame]\n # message_type == update | starting, data_type == ticker | candles | depth,\n # exchange, pair, time_frame - sending by listing_info\n binding_mask = '*.*.*.#'\n topic_logs_exchange = await self.channel.declare_exchange(self.exchanger, aio_pika.ExchangeType.TOPIC)\n queue_topic = await self.channel.declare_queue('', auto_delete=True)\n await queue_topic.bind(topic_logs_exchange, routing_key=binding_mask)\n\n # listener queue for listing information\n queue_for_listing = await self.channel.declare_queue('', auto_delete=True)\n await queue_for_listing.bind(topic_logs_exchange, routing_key=self.name_queue_for_listing)\n\n # listener queue for error\n queue_for_error = await self.channel.declare_queue('', auto_delete=True)\n await queue_for_error.bind(topic_logs_exchange, routing_key=self.name_queue_for_error)\n\n def callback_crypto_currency_market_data(message):\n \"\"\"Callback for consume market data\"\"\"\n body = json.loads(message.body.decode('utf-8'))\n \n # routing_key have view: message_type.data_type.exchange.pair[.time_frame]\n # message_type == update | starting, data_type == ticker | candles | depth,\n # exchange, pair, time_frame - sending by listing_info\n # mask: *.*.*.#\n message_type = message.routing_key.split('.')[0]\n data_id = '.'.join(message.routing_key.split('.')[1:])\n\n if message_type == 'update':\n for observer in self.subscribers.get(data_id):\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=message.routing_key,\n data=body\n )\n ))\n elif message_type == 'starting':\n # if exist waiters, send data and move waiters in subscribers\n if not self.waiters_first_msg.get(data_id):\n return\n\n new_subscribers = []\n while self.waiters_first_msg[data_id]:\n observer = self.waiters_first_msg[data_id].pop()\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=message.routing_key,\n data=body\n )\n ))\n new_subscribers.append(observer)\n\n # if not subscribers on this data_id, init new dict-value, else append to exist array\n subscribers = self.subscribers.get(data_id, None)\n if not subscribers and new_subscribers:\n self.subscribers[data_id] = new_subscribers\n asyncio.get_event_loop().create_task(self._send_message_for_subscribe(data_id))\n else:\n for new_subscriber in new_subscribers:\n if new_subscriber not in self.subscribers[data_id]:\n self.subscribers[data_id].append(new_subscriber)\n\n def callback_crypto_currency_listing(message):\n \"\"\"Callback for consume information about access pairs, exchanges and timeframes\"\"\"\n body = json.loads(message.body.decode('utf-8'))\n data_id = TYPE_LISTING\n\n if not self.waiters_first_msg.get(data_id):\n return\n\n while self.waiters_first_msg[data_id]:\n observer = self.waiters_first_msg[data_id].pop()\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=data_id,\n data=body\n )\n ))\n\n def callback_crypto_currency_error(message):\n \"\"\"Callback for consume error queue\"\"\"\n logger.error(message.body.decode('utf-8'))\n\n body = json.loads(message.body.decode('utf-8'))\n\n # validation\n error_place = body.get('error_place')\n message = 'Sorry! Error on server'\n if not message or not error_place:\n return\n\n # send information to ws, that wait or subscribe on error_place\n waiters = self.waiters_first_msg.get(error_place, ())\n for observer in waiters:\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=error_place,\n error=message\n )\n ))\n\n subscribers = self.subscribers.get(error_place, ())\n for observer in subscribers:\n asyncio.get_event_loop().create_task(observer.update(\n dict(\n data_id=error_place,\n data=message\n )\n ))\n\n await queue_topic.consume(callback_crypto_currency_market_data)\n await queue_for_listing.consume(callback_crypto_currency_listing)\n await queue_for_error.consume(callback_crypto_currency_error)",
"def main():\n executor(option().host)",
"def run(self, event_loop):\n protocol_factory = lambda: self.PROTOCOL_CLS(self)\n coro = event_loop.create_connection(\n protocol_factory, host=self.host, port=self.port)\n event_loop.run_until_complete(coro)",
"def main(args=None):\n if not args:\n args = sys.argv[1:]\n\n CONF.setup(args) # re-conf\n\n # upstream link configured in local broker\n consume(work, 'stableIDs', 'completed')",
"def run(self):\n self.logger.info(\"start consuming api calls\")\n while not self.shutdown:\n self.rpc.listen()",
"def starting(self):\n ident = self.ident()\n print('{} starting & consuming \"{}\".'.format(ident, self.to_consume))\n\n if self.max_tasks:\n print('{} will die after {} tasks.'.format(ident, self.max_tasks))\n else:\n print('{} will never die.'.format(ident))"
] | [
"0.7256628",
"0.63799363",
"0.6376809",
"0.63610184",
"0.6338159",
"0.6294446",
"0.6242551",
"0.61296886",
"0.6092963",
"0.60882604",
"0.5983006",
"0.5958778",
"0.59122777",
"0.58681065",
"0.58539355",
"0.5847966",
"0.5842972",
"0.58345944",
"0.58326536",
"0.58286023",
"0.5825571",
"0.5821614",
"0.5801635",
"0.58001405",
"0.5736894",
"0.5733552",
"0.5724945",
"0.57004434",
"0.5692098",
"0.56898946",
"0.56364226",
"0.5620238",
"0.56190336",
"0.56174904",
"0.5561644",
"0.55566293",
"0.5535246",
"0.54924315",
"0.5480674",
"0.5478526",
"0.5477881",
"0.5468111",
"0.5439492",
"0.54381603",
"0.5429716",
"0.5419704",
"0.5408274",
"0.5399569",
"0.5370781",
"0.53654885",
"0.53623307",
"0.5346643",
"0.5334828",
"0.53344846",
"0.5332892",
"0.5329577",
"0.53036463",
"0.53022635",
"0.5296546",
"0.5294988",
"0.5290599",
"0.5290275",
"0.5290275",
"0.52863723",
"0.5284385",
"0.52840143",
"0.5282175",
"0.5279414",
"0.52754354",
"0.52726054",
"0.5272208",
"0.5269908",
"0.52694964",
"0.5265152",
"0.52639544",
"0.526373",
"0.52626663",
"0.5248669",
"0.52416116",
"0.52356595",
"0.5223478",
"0.52229637",
"0.5208069",
"0.52030134",
"0.5194516",
"0.5188307",
"0.51835144",
"0.5173807",
"0.5168024",
"0.51677126",
"0.5162475",
"0.5161946",
"0.51542604",
"0.5153092",
"0.51451063",
"0.51385987",
"0.51353806",
"0.51290435",
"0.5118703"
] | 0.61549914 | 8 |
Cleanly shutdown the connection to RabbitMQ by stopping the consumer with RabbitMQ. When RabbitMQ confirms the cancellation, on_cancelok will be invoked by pika, which will then closing the channel and connection. The IOLoop is started again because this method is invoked when CTRLC is pressed raising a KeyboardInterrupt exception. This exception stops the IOLoop which needs to be running for pika to communicate with RabbitMQ. All of the commands issued prior to starting the IOLoop will be buffered but not processed. | def stop(self):
if not self._closing:
self._closing = True
if self._consuming:
self.stop_consuming()
self._connection.ioloop.start()
else:
self._connection.ioloop.stop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_consuming(self):\n if self._channel:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._channel.basic_cancel(self.on_cancelok, self._consumer_tag)",
"def stop(self):\n logger.info(\"Stopping rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self._closing = True\n self.stop_consuming()\n if self._connection is not None:\n self._connection.ioloop.start()\n self.stopped = True\n logger.info(\"Stopped rabbit consumer for process: %s with consumer id %s\", threading.current_thread,\n str(self.consumer_id))",
"def _stop_consuming(self):\n if self._rx_channel and self._rx_channel.is_open:\n logger.info('Sending a Basic.Cancel RPC command to RabbitMQ')\n self._rx_channel.basic_cancel(consumer_tag=self._consumer_tag)\n logger.info(\"stop consuming\")",
"def stop_consuming(self):\n if self._channel:\n self.logger.debug(\"Stopping message consuming on channel %i\", self._channel)\n\n self._connection.ioloop.add_callback_threadsafe(\n partial(\n self._channel.basic_cancel,\n consumer_tag=self._consumer_tag,\n callback=lambda *args: None,\n )\n )",
"def stop(self):\n self.logger.info('stopping')\n self._stopping = True\n if self._channel:\n self._channel.close()\n self._closing = True\n self._connection.close()\n self._connection.ioloop.start()\n self.logger.info('stopped')",
"def cancel(self):\n def on_cancelok(method_frame):\n \"\"\"Handle cancelok.\n \"\"\"\n self.log.debug(\"Cancel ok on CHANNEL%s\",\n method_frame.channel_number)\n try:\n if self._consumer_tag:\n self._channel.basic_cancel(\n on_cancelok,\n self._consumer_tag\n )\n except pika.exceptions.ChannelClosed: # pragma: no cover\n self.log.warning('Channel already closed while closing queue')",
"def stop(self):\n self.logger.debug(\"Stopping request consumer\")\n self._connection.ioloop.add_callback_threadsafe(partial(self._connection.close))",
"def stop_consuming(self):\n if self._channel_ctrl:\n self._channel_ctrl.basic_cancel(self._consumer_tag_ctrl)\n self._channel_ctrl.close()\n if self._channel_task:\n self._channel_task.basic_cancel(self._consumer_tag_task)\n self._channel_task.close()\n\n self._consuming = False",
"def on_cancelok(self, unused_frame):\n logger.info('RabbitMQ acknowledged the cancellation of the consumer')\n self.close_channel()",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.queue.channel.rpc(self._basic_cancel)\n self.queue.consuming = False",
"def on_consumer_cancelled(self, method_frame):\n logger.info('Consumer was cancelled remotely, shutting down: %r',\n method_frame)\n if self._channel:\n self._channel.close()",
"def stop(self):\n if self._connected:\n self._client.loop_stop()\n self._client.disconnect()\n self._connected = False\n logger.info(\"Connection with MQTT Broker closed.\")",
"def shutdown(self):\n self.channel.close()\n self.conn.close()",
"def stop() -> None:\n # Do not disconnect, we want the broker to always publish will\n self._mqttc.loop_stop()",
"def stop(self):\n logger.info(\"Shutting down EndpointInterchange\")\n\n # TODO: shut down executors gracefully\n\n # kill_event must be set before quiesce_event because we need to guarantee that once\n # the quiesce is complete, the interchange will not try to start again\n self._kill_event.set()\n self._quiesce_event.set()",
"def stop(self) -> None:\n self.mqttc.disconnect()",
"def shutdown(self):\n self.factory.reactor.removeReader(self)\n\n self.factory.connections.discard(self)\n\n self.socket.close()\n self.socket = None\n\n self.factory = None\n\n if self.read_scheduled is not None:\n self.read_scheduled.cancel()\n self.read_scheduled = None",
"def stop(self):\n if self._host:\n #threads.blockingCallFromThread(reactor, self._factory.stopTrying)\n threads.blockingCallFromThread(reactor, self._disconnect)\n else:\n self._database = None\n self._stock_exchange.stop()\n self._stock_exchange = None",
"def stop(self):\n self._transport = None\n self._cleanup()\n self._disconnected_callback = None",
"def shutdown(self):\n self._msg_disp.abort()\n self._conn_mgr.shutdown_connections()",
"def on_consume_cancelled(self, *args, **kwargs): # pragma: no cover\n self.log.warning(\n 'Consume cancelled. Reconnect after 5s. args: %s, kwargs: %s',\n args, kwargs\n )\n self._backend.loop.call_later(self._backend.reconnect_timeout,\n self.reconnect)",
"def stop_consumer_loop(self, message: Dict) -> NoReturn:\n message.ack()\n self.should_stop = True",
"def on_connection_closed(self, _unused_connection, reason):\n self._channel_ctrl = None\n self._channel_task = None\n if self._closing:\n self._connection.ioloop.stop()\n else:\n # LOGGER.warning('Connection closed, reconnect necessary: %s', reason)\n self.reconnect()",
"def stop(self):\n self.bus.log('Stopping down OLA Plugin.')\n self.bus.unsubscribe(\n self.channel_names['channel_request'],\n self.handle_channel\n )\n self.bus.unsubscribe(\n self.channel_names['channel_set'],\n self.handle_channel_set\n )\n self.ola_connection.disconnect()\n # wait for thread to finish.\n self.ola_connection.join()",
"def stop(self):\n\n if self._chan is not None:\n self._chan.stop_consume()\n else:\n\n raise SubscriberError('Can not stop the subscriber before it is started')",
"def stopzmq(self):\n\n self.context.destroy()",
"def on_connection_closed(self, connection, reply_code, reply_text):\n\n self._channel = None # there cannot be a channel, since the connection holding it was shut down\n if self._closing:\n # we are trying to stop. Just do so.\n self._connection.ioloop.stop()\n else:\n # this is unexpected. Restart the connection (after a timeout)\n self.logger.warning('The connection closed: %s:%s - retrying', reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"async def _disconnect(self):\n if self._heart_beat_task:\n self._heart_beat_task.cancel()\n try:\n await self._heart_beat_task\n except asyncio.CancelledError:\n pass\n self._heart_beat_task = None\n if self._response_handler_task:\n self._response_handler_task.cancel()\n try:\n await self._response_handler_task\n except asyncio.CancelledError:\n pass\n self._response_handler_task = None\n if self._command_queue_task:\n self._command_queue_task.cancel()\n try:\n await self._command_queue_task\n except asyncio.CancelledError:\n pass\n self._command_queue_task = None\n if self._expected_responses:\n self._expected_responses.cancel_tasks()\n if self._writer:\n self._writer.close()\n self._writer = None\n self._reader = None\n self._sequence = 0\n self._command_queue.clear()",
"def stop(self):\n log.info(\"{}: Stopping {} clients\".format(self.container_id, len(self.clients)))\n self.stopped = True\n self._close_clients()\n self._close_connection()",
"def on_close(self):\n self.subscrib.unsubscribe(self.channel)\n self.thread.stop()",
"def on_consumer_cancelled(self, method_frame):\n self.logger.debug(\"Consumer was cancelled: %r\", method_frame)\n\n if self._channel:\n self._connection.close()",
"def on_consumer_ctrl_cancelled(self, method_frame):\n if self._channel_ctrl:\n self._channel_ctrl.close()",
"def stop(self):\n if self.current_consumer:\n self.current_consumer.close()\n if self.p:\n self.stream.stop_stream()\n self.stream.close()\n self.p.terminate()\n self.stream = None\n self.p = None\n\n logging.info(\"Stopping SleeptalkPoller, stop event set\")",
"async def shutdown(signal, loop):\n print(f\"Received exit signal {signal.name}...\")\n print(\"Closing redis connections\")\n print(\"Nacking outstanding messages\")\n tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]\n\n [task.cancel() for task in tasks]\n\n print(f\"Cancelling {len(tasks)} outstanding tasks\")\n await asyncio.gather(*tasks, return_exceptions=True)\n print(f\"Flushing metrics\")\n loop.stop()",
"def exit_gracefully():\n input_channel.close()\n output_channel.close()\n cmd_channel.close()\n connection.close()",
"def __exit__(self, *args, **kwargs):\n\n if self.channel:\n self.channel.close()\n self.log.debug(\"SSH channel is closed.\")",
"def bcp_goodbye(self, **kwargs):\n if self.config['mediacontroller']['exit_on_disconnect']:\n self.socket_thread.sending_thread.stop()\n sys.exit()",
"def terminate(self):\n if self.is_connected():\n self._paramiko_client.close()",
"def connectionLost(self, contextKey):\r\n LOG(\"Lost connection with context\")\r\n ClientIF.cleanup( force = True )\r\n LOG(\"Pausing executor\")\r\n self.pause()\r\n LOG(\"Paused\")",
"def on_consumer_cancelled(self, method_frame):\n self.logger.info('consumer cancelled %r', method_frame)\n if self._channel:\n self._channel.close()",
"def loop_stop(self):\n super(EventLoop, self).loop_stop()\n self.inq.close()",
"def stop(self) -> None:\n tasks = asyncio.all_tasks(self._loop)\n for t in tasks:\n if not t.done():\n t.cancel()\n self._producer.close()",
"def stop(self):\n logger.info('Orchestrator is stopping')\n self._stop = True\n if self.settings.PARALLEL_EXECUTION:\n self.pool.terminate()\n self.pool.join()",
"def close(self):\n self.cleanup()\n self.scheduler.cancel_all()\n self.scheduler.stop(block=True)\n self.executor.shutdown(wait=True)",
"def shutdown(self) -> None:\n while not self.message_queue.empty():\n self.message_queue.get()\n run_channels = list(self.channels.keys())\n logger.debug(f\"Closing channels {run_channels}\")\n for channel_id in run_channels:\n self.channels[channel_id].close()\n del self.channels[channel_id]\n self.is_shutdown = True\n\n logger.debug(f\"Cancelling status ping task\")\n try:\n if self._status_task is not None and not self._status_task.cancelled():\n self._status_task.cancel()\n\n async def await_status_task():\n await self._status_task\n self._live_run = None\n\n self.get_live_run().loop_wrap.execute_coro(await_status_task())\n except asyncio.CancelledError:\n pass",
"def stop(self):\n if not self:\n return\n\n self._disconnect_clients()\n self._transport.close()\n self._stopped = True",
"async def async_disconnect(self) -> None:\n\n def stop() -> None:\n \"\"\"Stop the MQTT client.\"\"\"\n # Do not disconnect, we want the broker to always publish will\n self._mqttc.loop_stop()\n\n def no_more_acks() -> bool:\n \"\"\"Return False if there are unprocessed ACKs.\"\"\"\n return not any(not op.is_set() for op in self._pending_operations.values())\n\n # stop waiting for any pending subscriptions\n await self._subscribe_debouncer.async_cleanup()\n # reset timeout to initial subscribe cooldown\n self._subscribe_debouncer.set_timeout(INITIAL_SUBSCRIBE_COOLDOWN)\n # stop the unsubscribe debouncer\n await self._unsubscribe_debouncer.async_cleanup()\n # make sure the unsubscribes are processed\n await self._async_perform_unsubscribes()\n\n # wait for ACKs to be processed\n async with self._pending_operations_condition:\n await self._pending_operations_condition.wait_for(no_more_acks)\n\n # stop the MQTT loop\n async with self._paho_lock:\n await self.hass.async_add_executor_job(stop)",
"def on_consumer_task_cancelled(self, method_frame):\n if self._channel_task:\n self._channel_task.close()",
"def finish():\n if not channel.closed():\n channel.close()\n loop.remove_timeout(timeout)\n kernel.remove_restart_callback(on_restart_failed, 'dead')",
"def stop(self):\n self.connection.abort()",
"def stop(self):\n self.connection.abort()",
"def on_connection_closed(self, connection, reply_code, reply_text):\n self._channel = None\n if self._closing:\n self._connection.ioloop.stop()\n else:\n logger.warning('Connection closed, reopening in 5 seconds: (%s) %s',\n reply_code, reply_text)\n self._connection.add_timeout(5, self.reconnect)",
"def runloop_cancel():\n raise RunloopCancel()",
"def close(self) -> None:\n _LOGGER.info('Shutting down connections to deCONZ.')\n if self.websocket:\n self.websocket.stop()",
"def _interrupt(self, threadId, connection):\n try:\n connection.close()\n except pymysql.Error:\n pass",
"async def clean_up(self) -> None:\n self.logger.info(\"clean_up\", \"closing redis connection\")\n if self.pubsub_task and not self.pubsub_task.done():\n self.pubsub_task.cancel()\n try:\n await self.pubsub_task\n except CancelledError:\n pass\n self.pubsub_task = None\n if self.pubsub_channel is not None:\n self.pubsub_channel.close()\n await super().clean_up()",
"def onstop(self, sender, **kwargs):\n try:\n self._soc.close()\n self._socket.close()\n\n except Exception as e:\n _log.error(\"Error : {}\".format(e))",
"def on_channel_closed(self, channel, reply_code, reply_text):\n self.logger.warning('channel closed: %s: %s', reply_code, reply_text)\n self._channel = None\n if not self._stopping:\n # this wasn't supposed to happen\n self._connection.close()",
"def __exit__(self, exc_type, exc_val, exc_tb):\n if self.event_loop:\n self.event_loop.stop()",
"def cleanup(self, sig, func=None):\n\n print \"Closing up shop...\"\n\n # Disconnect all of our remote controllers\n for c in self.config_list:\n self.config_list[c].disconnect()\n\n # Kill our data handler\n self.INPUT_QUEUE.put(G.CTRL_CMD_KILL)\n\n # Terminate the consumers and producers\n self.in_queue.put(G.CTRL_CMD_KILL)\n self.out_queue.put(G.CTRL_CMD_KILL)\n for child in self.comm_processes:\n child.stop()",
"def close(self):\n if self.closed:\n return\n try:\n self.channel.close(self)\n self.dispose()\n except StopIteration:\n # If the underlying connection for the channel is closed explicitly\n # open will not able to find an appropriate channel, to send close.\n pass",
"def stop(self):\n\n # Close our synchronous connection if we've got one\n #if self._nonpool:\n # self._nonpool.close()\n # self._nonpool = None\n # self._nonpool_lastused = None\n\n if not self._started:\n return\n #self._pool.close()\n self._started = False\n #del self._pool",
"def do_stop(self):\n logger.info('Stopping')\n self._stop_consuming()\n logger.info('Stopped')",
"def onClose(self, wasClean, code=None, reason=None):\n self.sessionhandler.disconnect(self)\n if self.nextHeartbeatCall:\n self.nextHeartbeatCall.cancel()\n self.nextHeartbeatCall = None\n if wasClean:\n logger.log_info(f\"Discord connection closed ({code}) reason: {reason}\")\n else:\n logger.log_info(f\"Discord connection lost.\")",
"async def close(self):\n self.debug(\"Closing connection\")\n self.real_local_key = self.local_key\n if self.heartbeater is not None:\n self.heartbeater.cancel()\n try:\n await self.heartbeater\n except asyncio.CancelledError:\n pass\n self.heartbeater = None\n if self.dispatcher is not None:\n self.dispatcher.abort()\n self.dispatcher = None\n if self.transport is not None:\n transport = self.transport\n self.transport = None\n transport.close()",
"async def close(self) -> None:\n logger.debug(\n f\"['{self._instance_connection_string}']: Waiting for _current to be cancelled\"\n )\n self._current.cancel()\n logger.debug(\n f\"['{self._instance_connection_string}']: Waiting for _next to be cancelled\"\n )\n self._next.cancel()\n logger.debug(\n f\"['{self._instance_connection_string}']: Waiting for _client_session to close\"\n )\n await self._client_session.close()",
"def clean_up(self):\n self.stop_full()\n self.ctrl_sock.close()\n self.context.term()",
"def close(self):\n self.pi.set_watchdog(self.gpio, 0)\n if self.either_edge_cb:\n self.either_edge_cb.cancel()\n self.either_edge_cb = None",
"def shutdown(self):\n try:\n if self.working and self.exiting.acquire():\n self.bot('shutting down...')\n self.working = False\n self._handleEvent(self.getEvent('EVT_STOP'))\n if self._cron:\n self._cron.stop()\n self.bot('shutting down database connections...')\n self.storage.shutdown()\n except Exception, e:\n self.error(e)",
"def close(self):\n _LOGGER.debug(\"Closing websocket connections\")\n if self._remote_task:\n self._remote_task.cancel()\n if self._control_task:\n self._control_task.cancel()\n if self._app_monitor_task:\n self._app_monitor_task.cancel()\n if self._managed_session:\n _LOGGER.debug(\"Closing managed ClientSession\")\n self._loop.create_task(self.session.close())",
"def shutdown(self):\n asyncio.cancel(self._server_coro)\n for hid, coro in self.conns.items():\n asyncio.cancel(coro)",
"def _stop(self):\n\n self.streaming_pull_future.cancel() # Trigger the shutdown.\n self.streaming_pull_future.result() # Block until the shutdown is complete.",
"async def shutdown(self):\n\n if self.log_output:\n logging.info('Shutting down ...')\n else:\n print('Shutting down ...')\n\n await self.send_reset()\n\n try:\n self.loop.stop()\n except:\n pass\n try:\n self.loop.close()\n except:\n pass\n sys.exit(0)",
"def stop(self):\n self.conn.stop()",
"async def __aexit__(self, exc_type, exc_value, traceback):\n\n # Close the connection\n await self.disconnect()",
"def shutDown(self):\n self.host = None\n self.port = None\n if(self.loop is not None):\n test = asyncio.run_coroutine_threadsafe(self.stopLoop(), self.loop)\n self.thread.join()\n if(self.loop.is_running()):\n self.loop.stop()\n else:\n self.loop.close()\n self.pool.shutDown()\n self.pool = None\n self.loop = None\n self.thread = None",
"async def shutdown(loop, signal=None):\n if signal:\n logging.info(f\"Received exit signal {signal.name}...\")\n logging.info(\"Closing database connections\")\n logging.info(\"Nacking outstanding messages\")\n tasks = [t for t in asyncio.Task.all_tasks() if t is not\n asyncio.Task.current_task()]\n\n [task.cancel() for task in tasks]\n\n logging.info(f\"Cancelling {len(tasks)} outstanding tasks\")\n results = await asyncio.gather(*tasks, return_exceptions=True)\n\n for result in results:\n if isinstance(result, CustomException):\n logging.error(f\"Custom error: {result}\")\n elif isinstance(result, Exception):\n logging.error(f\"Handling general error: {result}\")\n\n logging.info(f\"Flushing metrics\")\n loop.stop()",
"def shutdown_hook(consumer, session):\r\n try:\r\n logger.info('Closing Kafka Consumer')\r\n consumer.close()\r\n logger.info('Dafka Consumer closed')\r\n logger.info('Closing Cassandra Session')\r\n session.shutdown()\r\n logger.info('Cassandra Session closed')\r\n except KafkaError as kafka_error:\r\n logger.warn('Failed to close Kafka Consumer, caused by: %s', kafka_error.message)\r\n finally:\r\n logger.info('Exiting program')",
"def cancel(self):\n self.stop()\n self.make_callback('canceled')",
"def __exit__(self, exc_type, exc_val, exc_tb) -> None:\n self.stop()",
"def _shutdown(self):\n self.control_socket.send(zmqmessage.IPC_END)\n self.end_threads = True\n self.timeout = 1",
"def test_consumer_cancel_during_shutdown(self):\n client = self.mock_client([])\n processor = Mock()\n group = ConsumerGroup(client, \"group_id\", \"topic1\", processor)\n start_d = group.start()\n with patch(\"afkak._group.Consumer\") as mock_consumer:\n consumer_instance = mock_consumer.return_value\n consumer_start_d = defer.Deferred()\n consumer_instance.start.return_value = consumer_start_d\n consumer_instance._start_d = consumer_start_d\n group.on_join_complete({\"topic1\": [1]})\n self.assertEqual(consumer_instance.start.called, True)\n\n def stop():\n consumer_start_d.errback(defer.CancelledError())\n\n consumer_instance.stop.side_effect = stop\n group.rejoin_after_error(Failure(RequestTimedOutError()))\n\n self.assertEqual(consumer_instance.stop.called, True)\n self.successResultOf(consumer_start_d)\n self.assertNoResult(start_d)",
"async def _disconnect(self) -> None:\n\n if self._ws is not None:\n logger.debug(\"Closing ws connection\")\n await self._ws.close()\n\n # Checking self._ws again since during the above await, another\n # disconnect call could have finished cleaning up.\n if self._ws is None:\n # This indicates that _ws, _awaiting_replies and _ping_check are\n # cleaned up\n logger.debug(\"Ws connection already cleaned up\")\n return\n\n logger.debug(\"Cancelling futures waiting for replies\")\n for future in self._awaiting_replies.values():\n future.set_exception(ConnectionClosedException())\n\n logger.debug(\"Cancelling ping check task\")\n self._ping_check.cancel()\n\n logger.debug(\"Cleaning up variables\")\n self._ws = None\n self._awaiting_replies = None\n self._ping_check = None",
"def stop(self):\n\t\tself.running = False\n\t\tself.data_source.close()\n\t\tfor protocol in self.protocols:\n\t\t\tprotocol.close()\n\t\tprint('%s IO closed' % self.name)",
"def run(self):\n try:\n\n self._connection = self.connect()\n self._connection.ioloop.start()\n except (KeyboardInterrupt, SystemExit):\n self.stop()\n except Exception as e:\n logger.warn(\"Exception: %s\", str(e))\n logger.warn(\"Exception caught on rabbit consumer for process: %s with consumer id %s\", threading.current_thread, str(self.consumer_id))\n self.internal_error_queue.put(self.consumer_id)",
"def shutdown(self, loop):\n\n tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]\n\n for task in tasks:\n task.cancel()\n\n asyncio.gather(*tasks)\n loop.stop()",
"def close(self):\n self.stop()\n GPIO.cleanup()",
"def stop(self):\n self.__logger__.info(\"Stopping Ozone Cluster\")\n call([Command.docker_compose, \"-f\", self.docker_compose_file, \"down\"])\n Blockade.blockade_destroy()",
"def cleanup(self):\n cluster = self.client and self.client.cluster\n\n if self.client:\n self.client.close()\n self.client = None\n\n if cluster:\n try:\n cluster.close(timeout=60.0)\n except RuntimeError as ex:\n ## For some reason, sometimes the cluster can't be closed due to some\n ## problem with 'bkill', which fails with an error that looks like the following.\n ## If that happens, try to re-run bkill one more time in the hopes of really\n ## killing the cluster and not leaving lingering workers running.\n ## (This issue has been observed on the Janelia cluster for both dask and spark clusters.)\n ##\n # RuntimeError: Command exited with non-zero exit code.\n # Exit code: 255\n # Command:\n # bkill 54421878 54421872 54421877\n # stdout:\n #\n # stderr:\n # Job <54421878>: Failed in an LSF library call: Slave LIM configuration is not ready yet\n # Job <54421872>: Failed in an LSF library call: Slave LIM configuration is not ready yet\n # Job <54421877>: Failed in an LSF library call: Slave LIM configuration is not ready yet\n m = re.search(r'bkill( \\d+)+', str(ex))\n if not m:\n raise\n\n logger.warning(\"Failed to kill cluster with bkill, trying one more time...\")\n time.sleep(2.0)\n result = subprocess.run(m.group(), shell=True)\n if result.returncode != 0:\n logger.error(\"Second attempt to kill the cluster failed!\")\n raise",
"def stop(self):\n for cli in self.kafka_clients.itervalues():\n cli.close()",
"def run(self):\n while not self._stopping:\n try:\n self._connection = self.connect()\n self._connection.ioloop.start()\n except KeyboardInterrupt:\n self.stop()\n if (self._connection is not None and not self._connection.is_closed):\n self._connection.ioloop.start()\n\n print(\"Stopping publisher thread\")",
"def stop(self):\n\t\tself.PPCThread.join()\n\t\tself.opc.close()\n\t\tself.close()\n\t\treturn self.PPCThread",
"def _disconnect(self):\n self._factory.stopTrying()\n self._connection.disconnect()",
"def close(self):\r\n if self.connected:\r\n #self.onClose()\r\n self.con.close()\r\n self._close() # Reset the thread and connection, and stop all sounds playing through the output.\r\n else:\r\n raise UserError(errors['NotConnectedYet'])",
"def stop(self):\n # trying this instead of SIGTERM\n # http://stackoverflow.com/a/6659191/3380530\n # self._process.send_signal(SIGINT)\n # Or not. SIGINT doesn't exist on Windows\n self._process.terminate()",
"def cleanup(self):\n try:\n self.disconnect()\n self.log_file.close()\n SerialAsyncLoop.stop_loop(self.logger)\n except Exception as e:\n self.applog.exception(f\"Exception --> {SerialConsole.cleanup.__qualname__}\", exc_info=e)\n raise",
"def disconnect(self):\n _error = None\n try:\n self.connection.shutdown()\n except Exception as e:\n log.error(e, exc_info=True)\n _error = 'disconnect error: %s' % e\n finally:\n if _error is not None and config.DEBUG_TO_CONSOLE:\n print (_error)\n self.is_connected = False\n self.connection = None",
"def stop(self):\n self.kc.stop_channels()\n self.km.shutdown_kernel(now=True)\n del self.km",
"def interrupt_handler(signum, frame): #pylint: disable=W0613\n cleanup()\n sys.exit(-2) # Terminate process here as catching the signal\n # removes the close process behaviour of Ctrl-C",
"def shutdown_hook(consumer, session):\n try:\n logger.info('Closing Kafka Consumer')\n consumer.close()\n logger.info('Kafka Consumer closed')\n logger.info('Closing Cassandra Session')\n session.shutdown()\n logger.info('Cassandra Session closed')\n except KafkaError as kafka_error:\n logger.warn('Failed to close Kafka Consumer, caused by: %s', kafka_error.message)\n finally:\n logger.info('Existing program')"
] | [
"0.7339839",
"0.6967187",
"0.6935288",
"0.676239",
"0.67605835",
"0.66537136",
"0.6602058",
"0.65783286",
"0.6539383",
"0.6339902",
"0.6324922",
"0.62800676",
"0.6018747",
"0.59879136",
"0.5950211",
"0.59477204",
"0.59354734",
"0.5933404",
"0.5920861",
"0.59080935",
"0.5874866",
"0.58673286",
"0.5864189",
"0.58597326",
"0.58519435",
"0.5842559",
"0.5835169",
"0.58343965",
"0.5827064",
"0.582052",
"0.58116657",
"0.5807618",
"0.57803243",
"0.5778035",
"0.57747686",
"0.57535887",
"0.57485384",
"0.5739089",
"0.5731619",
"0.5722384",
"0.5714678",
"0.5704347",
"0.57033354",
"0.5688268",
"0.5686843",
"0.5664301",
"0.56549644",
"0.5654209",
"0.56422555",
"0.5639444",
"0.5639444",
"0.56335855",
"0.5629513",
"0.56252253",
"0.5607726",
"0.55942655",
"0.5593781",
"0.55911607",
"0.5585379",
"0.5574415",
"0.5562202",
"0.55612177",
"0.5560185",
"0.5557465",
"0.5551468",
"0.554874",
"0.5541513",
"0.55398726",
"0.5537745",
"0.55351657",
"0.55256176",
"0.5524701",
"0.55175465",
"0.5513856",
"0.5507769",
"0.5502088",
"0.54949707",
"0.5494647",
"0.5487619",
"0.548269",
"0.5459155",
"0.54587597",
"0.54551786",
"0.54548925",
"0.54543644",
"0.5453448",
"0.54530525",
"0.5452686",
"0.54498047",
"0.544783",
"0.5444579",
"0.54341394",
"0.54319555",
"0.542529",
"0.54206795",
"0.5418699",
"0.5408232",
"0.53993154",
"0.53984517",
"0.53967285"
] | 0.6696183 | 5 |
Initialize variables and operators 1. initialize serial port 2. initialize GPIO pins | def __init__(self, logger):
# cwd = os.getcwd()
# parent_dir = os.path.dirname(cwd)
# self.logger = logger_variable(__name__, parent_dir + '/log_files/SensorData.log')
# open serial port
self.interrupt_pin = 19
self.serialOpen = Serial('/dev/ttyACM1', 115200)
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.interrupt_pin, GPIO.OUT, initial=1)
self.logger = logger | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n GPIO.setwarnings(False)\n GPIO.cleanup() # Reset the high and low levels of the GPIO port\n #The following code defines the GPIO used to control the L298N chip. This definition is different for different Raspberry Pi driver boards.\n self.Motor_A_EN = 17\n self.Motor_B_EN = 4\n self.Motor_A_Pin1 = 27\n self.Motor_A_Pin2 = 18\n self.Motor_B_Pin1 = 21\n self.Motor_B_Pin2 = 26\n self.setup()",
"def _init_io(self):\n GPIO.setwarnings(False)\n GPIO.setmode( GPIO.BCM )\n pins = [ self._spi_dc ]\n for pin in pins:\n GPIO.setup( pin, GPIO.OUT )",
"def GPIO_initialization():\n GPIO.setmode(GPIO.BCM)\n\n GPIO.setup(Sensor.IN_1, GPIO.OUT)\n GPIO.setup(Sensor.IN_2, GPIO.OUT)\n GPIO.setup(Sensor.EN, GPIO.OUT)\n\n GPIO.setup(Membrane_Switch.PSEUDO_MEMBRANE_SWITCH['RED_STOP'], GPIO.IN)\n GPIO.setup(Membrane_Switch.PSEUDO_MEMBRANE_SWITCH['YELLOW_CW'], GPIO.IN)\n GPIO.setup(Membrane_Switch.PSEUDO_MEMBRANE_SWITCH['GREEN_CCW'], GPIO.IN)\n\n GPIO.output(Sensor.IN_1, GPIO.LOW)\n GPIO.output(Sensor.IN_2, GPIO.LOW)",
"def init_serial():\n\tglobal D\n\t# start serial connection\n\tbaud = 9600\n\ttry:\n\t\tD.gps_serial = serial.Serial(\"/dev/ttyAMA0\",baud,timeout=1)\n\t\tD.gps_serial.open()\n\t\tD.gps_serial.write(\"$PMTK220,200*2C\")\n\t\tD.gps_serial.write(\"$PMTK300,200,0,0,0,0*2F\")\n\texcept:\n\t\tprint \"Failed to open serial\"\n\t\trospy.shutdown(\"Failed to open gps serial\")",
"def setup(self):\n if not self._gpio_setup:\n if self._gpio is None:\n try:\n import RPi.GPIO as GPIO\n self._gpio = GPIO\n except ImportError:\n raise ImportError('This library requires the RPi.GPIO module\\nInstall with: sudo apt install python-rpi.gpio')\n self._gpio.setmode(self._gpio.BCM)\n self._gpio.setwarnings(False)\n self._gpio.setup(self.cs_pin, self._gpio.OUT)\n self._gpio.setup(self.dc_pin, self._gpio.OUT, initial=self._gpio.LOW, pull_up_down=self._gpio.PUD_OFF)\n self._gpio.setup(self.reset_pin, self._gpio.OUT, initial=self._gpio.HIGH, pull_up_down=self._gpio.PUD_OFF)\n self._gpio.setup(self.busy_pin, self._gpio.IN, pull_up_down=self._gpio.PUD_OFF)\n\n if self._spi_bus is None:\n import spidev\n self._spi_bus = spidev.SpiDev()\n\n self._spi_bus.open(0, self.cs_channel)\n self._spi_bus.no_cs = True\n self._spi_bus.max_speed_hz = 5000000\n\n self._gpio_setup = True\n\n self._gpio.output(self.reset_pin, self._gpio.LOW)\n time.sleep(0.1)\n self._gpio.output(self.reset_pin, self._gpio.HIGH)\n time.sleep(0.1)\n\n self._gpio.output(self.reset_pin, self._gpio.LOW)\n time.sleep(0.1)\n self._gpio.output(self.reset_pin, self._gpio.HIGH)\n\n self._busy_wait(1.0)\n\n # Sending init commands to display\n self._send_command(AC073TC1_CMDH, [0x49, 0x55, 0x20, 0x08, 0x09, 0x18])\n\n self._send_command(AC073TC1_PWR, [0x3F, 0x00, 0x32, 0x2A, 0x0E, 0x2A])\n\n self._send_command(AC073TC1_PSR, [0x5F, 0x69])\n\n self._send_command(AC073TC1_POFS, [0x00, 0x54, 0x00, 0x44])\n\n self._send_command(AC073TC1_BTST1, [0x40, 0x1F, 0x1F, 0x2C])\n\n self._send_command(AC073TC1_BTST2, [0x6F, 0x1F, 0x16, 0x25])\n\n self._send_command(AC073TC1_BTST3, [0x6F, 0x1F, 0x1F, 0x22])\n\n self._send_command(AC073TC1_IPC, [0x00, 0x04])\n\n self._send_command(AC073TC1_PLL, [0x02])\n\n self._send_command(AC073TC1_TSE, [0x00])\n\n self._send_command(AC073TC1_CDI, [0x3F])\n\n self._send_command(AC073TC1_TCON, [0x02, 0x00])\n\n self._send_command(AC073TC1_TRES, [0x03, 0x20, 0x01, 0xE0])\n\n self._send_command(AC073TC1_VDCS, [0x1E])\n\n self._send_command(AC073TC1_T_VDCS, [0x00])\n\n self._send_command(AC073TC1_AGID, [0x00])\n\n self._send_command(AC073TC1_PWS, [0x2F])\n\n self._send_command(AC073TC1_CCSET, [0x00])\n\n self._send_command(AC073TC1_TSSET, [0x00])",
"def setup(self):\n GPIO.setwarnings(False)\n GPIO.setmode(GPIO.BCM)\n GPIO.setup(self.Motor_A_EN, GPIO.OUT)\n GPIO.setup(self.Motor_B_EN, GPIO.OUT)\n GPIO.setup(self.Motor_A_Pin1, GPIO.OUT)\n GPIO.setup(self.Motor_A_Pin2, GPIO.OUT)\n GPIO.setup(self.Motor_B_Pin1, GPIO.OUT)\n GPIO.setup(self.Motor_B_Pin2, GPIO.OUT)\n self.motorStop() # Avoids automatic motor rotation after initialization\n try: # Try is used here to avoid errors due to repeated setting of PWM\n self.pwm_A = GPIO.PWM(self.Motor_A_EN, 1000)\n self.pwm_B = GPIO.PWM(self.Motor_B_EN, 1000)\n except:\n pass",
"def __init__(self):\n\n GPIO.setup(PIN_BTN, GPIO.IN, GPIO.PUD_UP)\n GPIO.setup(PIN_RED_LED_0, GPIO.OUT, GPIO.LOW)\n GPIO.setup(PIN_BLUE_LED, GPIO.OUT, GPIO.LOW)",
"def comInit(self, port):\n if DEBUG > 1: sys.stderr.write(\"* comInit()\\n\")\n self.seqNo = 0\n self.reqNo = 0\n self.rxPtr = 0\n self.txPtr = 0\n # Startup-Baudrate: 9600,8,E,1, 1s timeout\n self.serialport = serial.Serial(\n port,\n 9600,\n parity = serial.PARITY_EVEN,\n timeout = self.timeout\n )\n if DEBUG: sys.stderr.write(\"using serial port %r\\n\" % self.serialport.portstr)\n #self.SetRSTpin() #enable power\n #self.SetTESTpin() #enable power\n self.serialport.flushInput()\n self.serialport.flushOutput()",
"def __init__(self):\n # FIXME: IS this needed?\n super(ArduinoStation, self).__init__()\n\n self.serial_port_pattern = '/dev/ttyACM{port_num}'\n self.serial_port_num = None\n self.baudrate = 9600\n self.ser = self._setup_serial_connection()\n\n\n # Sensor 1 (DHT11) has 2 readings, Sensor 2 has 1\n ## FIXME: Should look for key pairs in list and submit when no more unique readings are coming through\n if config.SCB_CONFIGURATION == 'standard':\n self.lines_per_observation = 3\n else:\n self.lines_per_observation = 7 # Allows for up to 5 DS18B20 along w/ DHT-11.",
"def setup(self):\n GPIO.setmode(GPIO.BCM)\n for rowp in self.rows:\n GPIO.setup(rowp, GPIO.OUT)\n for colp in self.cols:\n GPIO.setup(colp, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)",
"def setup():\n GPIO.setmode(GPIO.BCM)\n for pin in [config.gpio_pin_p1_stretch,\n config.gpio_pin_p1_serve,\n config.gpio_pin_p2_stretch,\n config.gpio_pin_p2_serve]:\n GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\n\n input_reader_thread = threading.Thread(target=input_reader_worker)\n input_reader_thread.setDaemon(True)\n input_reader_thread.start()",
"def __init__(self):\n GPIO.setmode(GPIO.BCM)\n GPIO.setup(pin,GPIO.OUT)",
"def physical_init(self):\n \n # BCM numbering scheme for Pi pins\n GPIO.setmode(GPIO.BCM)\n \n for attr in self.parm_list:\n if attr.io_pin > 0:\n GPIO.setup(attr.io_pin, attr.io_dir)\n if attr.io_dir == GPIO.OUT:\n GPIO.output(attr.io_pin, attr.value)\n #\n # There seems to be a bug where the edge detection triggers on both\n # edges. Compensate in the ISR.\n #\n GPIO.add_event_detect(self.motion.io_pin, GPIO.BOTH, callback=self.motion_edge)",
"def serial_configure():\n global ser, serial_port, baud_rate\n ser = serial.Serial(port=serial_port, baudrate=baud_rate)",
"def initialize():\n for pin in sorted(OUTPUT_PINS.values()):\n _enable_pin(pin, OUT)\n\n for pin in sorted(INPUT_PINS.values()):\n _enable_pin(pin, IN)",
"def setup_gpio(self):\n logger.info(\"Setting up GPIO pins\")\n gpio.setmode(gpio.BOARD)\n gpio.setup(self.pins[\"SCLK\"], gpio.OUT)\n gpio.setup(self.pins[\"SDO\"], gpio.OUT)\n gpio.setup(self.pins[\"SDI\"], gpio.IN)\n gpio.setup(self.pins[\"IO_UPDATE\"], gpio.OUT)\n gpio.setup(self.pins[\"IO_RESET\"], gpio.OUT)\n gpio.setup(self.pins[\"RAM_SWP_OVR\"], gpio.IN)\n gpio.setup(self.pins[\"EXT_PWR_DOWN\"], gpio.OUT)\n gpio.setup(self.pins[\"MASTER_RESET\"], gpio.OUT)\n gpio.setup(self.pins[\"PLL_LOCK\"], gpio.IN)\n gpio.setup(self.pins[\"P_0\"], gpio.OUT)\n gpio.setup(self.pins[\"P_1\"], gpio.OUT)\n gpio.setup(self.pins[\"P_2\"], gpio.OUT)",
"def setup(self):\n \n # Board refers to the P1 header of the Raspberry Pi board\n GPIO.setmode(GPIO.BOARD)\n\n # Set up pin as an input with a pull up resistor to 3.3V\n GPIO.setup(self.__pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)",
"def __init__(self):\r\n try:\r\n print(f\"Connecting to Arduino on '{self._SERIAL_PORT}'...\", end='')\r\n self.ser = serial.Serial(self._SERIAL_PORT, self._BAUD, timeout=self._TIMEOUT)\r\n # Reset buffers to start with a clean slate\r\n self.ser.reset_input_buffer()\r\n self.ser.reset_output_buffer()\r\n print(\"Ok\")\r\n except serial.SerialException as e:\r\n print(\"Failed:\", e)",
"def _setup(self):\n if self._setup:\n return\n\n GPIO.setmode(GPIO.BCM)\n for i in (self.on, self.off):\n GPIO.setup(i, GPIO.OUT)\n self.stop_all()\n Outlet._setup = True",
"def __init__(self):\n super().__init__()\n\n # Robot state\n self.ask_mode = False\n\n # Connect two large motors on output ports B and C\n self.sound = Sound()\n self.leds = Leds()\n self.p1 = TouchSensor(INPUT_1)\n self.p2 = TouchSensor(INPUT_2)\n self.p3 = TouchSensor(INPUT_3)\n self.p4 = TouchSensor(INPUT_4)",
"def init(self):\n self.reset()\n\n self.__interface.send_command('POWER_SETTING')\n self.__interface.send_data(0x37)\n self.__interface.send_data(0x00)\n\n self.__interface.send_command('PANEL_SETTING')\n self.__interface.send_data(0xCF)\n self.__interface.send_data(0x08)\n\n self.__interface.send_command('BOOSTER_SOFT_START')\n self.__interface.send_data(0xc7)\n self.__interface.send_data(0xcc)\n self.__interface.send_data(0x28)\n\n self.__interface.send_command('POWER_ON')\n self.wait_until_idle()\n\n self.__interface.send_command('PLL_CONTROL')\n self.__interface.send_data(0x3c)\n\n self.__interface.send_command('TEMPERATURE_CALIBRATION')\n self.__interface.send_data(0x00)\n\n self.__interface.send_command('VCOM_AND_DATA_INTERVAL_SETTING')\n self.__interface.send_data(0x77)\n\n self.__interface.send_command('TCON_SETTING')\n self.__interface.send_data(0x22)\n\n self.__interface.send_command('TCON_RESOLUTION')\n self.__interface.send_data(0x02) #source 640\n self.__interface.send_data(0x80)\n self.__interface.send_data(0x01) #gate 384\n self.__interface.send_data(0x80)\n\n self.__interface.send_command('VCM_DC_SETTING')\n self.__interface.send_data(0x1E) #decide by LUT file\n\n self.__interface.send_command(0xe5, False) #FLASH MODE\n self.__interface.send_data(0x03)",
"def init():\n print(\"initializing...\")\n print(\"setting relays off\")\n for pin in PINS:\n GPIO.setup(pin, GPIO.OUT)\n GPIO.output(pin, RELAYOFF)",
"def configure(self):\n\n # instantiate Serial\n self.serial = serial.Serial()\n\n # set port_path, e.g. '/dev/ttyUSBx' or 'COMx'\n self.serial.port = self.port.device\n\n # set baudrate\n self.serial.baudrate = 115200",
"def __init__(self, reset=True):\n self.__helper = _ABEHelpers()\n\n self.__bus = self.__helper.get_smbus()\n self.__bus.write_byte_data(\n self.__ioaddress, self.IOCON, self.__ioconfig)\n self.__port_a_value = self.__bus.read_byte_data(\n self.__ioaddress, self.GPIOA)\n self.__port_b_value = self.__bus.read_byte_data(\n self.__ioaddress, self.GPIOB)\n if reset is True:\n self.__bus.write_byte_data(self.__ioaddress, self.IODIRA, 0xFF)\n self.__bus.write_byte_data(self.__ioaddress, self.IODIRB, 0xFF)\n self.set_port_pullups(0, 0x00)\n self.set_port_pullups(1, 0x00)\n self.invert_port(0, 0x00)\n self.invert_port(1, 0x00)\n\n return",
"def setup(self):\n\n for row_pin in keypad_row_pins:\n #Set up row-pins\n self.gpio.setup(row_pin, self.gpio.OUT)\n\n for col_pin in keypad_col_pins:\n #Set up col-pins\n self.gpio.setup(col_pin, self.gpio.IN)",
"def __init__(self, port):\n\n self.ser = serial.Serial(port=port.upper(), baudrate=9600, bytesize=serial.EIGHTBITS, parity=serial.PARITY_ODD, stopbits=serial.STOPBITS_TWO, xonxoff=False, timeout=200)",
"def __init__(self, port, baud=9600, timeout=1, parity=serial.PARITY_NONE, rtscts=False):\n self.__ser__ = serial.Serial(port=port, baudrate=baud, timeout=timeout, parity=parity)\n self.__ser__.flush()\n # initialize calibrations at unity\n # these can be adjusted by bath.cal_ext.reset(slope, xcept)\n self.cal_int = TCal(1, 0)\n self.cal_ext = TCal(1, 0)",
"def GPIOsetup():\n GPIO.setmode(GPIO.BOARD)\n for led in (RED,YELLOW,GREEN):\n GPIO.setup(LED[led],GPIO.OUT)",
"def connect(self):\n self.arduino = Serial(self.port, self.baud_rate, timeout=self.timeout)",
"def __init__(self, port = '/dev/ttyUSB2'):\n self.port = port\n #self.serial = serial.serial_for_url(port, 9600, parity='N', rtscts=False, xonxoff=False, timeout=1)\n self.serial = None\n self.settings = {}\n self.valid_settings = {}",
"def __init__(self, port_num, frequency=1):\n self.port_num = port_num\n #TODO what is this fuction doing? \n self.port = serial.Serial(port_num, 115200, timeout=1.5)\n '''\n Init Port\n '''\n self._init_port(frequency)",
"def __init__(self):\n GPIO.setmode(GPIO.BOARD)\n for light in self.all:\n GPIO.setup(light, GPIO.OUT)",
"def setup():\n GPIO.setmode(GPIO.BCM)\n for pin in [CHURCH, CHURCH + 1, HALL, HALL + 1]:\n GPIO.setup(pin, GPIO.OUT, initial=GPIO.HIGH)",
"def gpio_setup():\n GPIO.setmode(GPIO.BOARD)\n GPIO.setwarnings(False)\n for led in (RED, AMBER, GREEN):\n GPIO.setup(LED[led],GPIO.OUT)",
"def setup():\n\trfm.setup()\n\t\"\"\"Read the interrupt status1 register\"\"\"\n\tItStatus1 = rfm.read_register(0x03)\n\tItStatus2 = rfm.read_register(0x04)\n\n\t\"\"\"Set RF Parameters\"\"\"\n\t# Set the center frequency to 915MHz\n\trfm.write_register(0x75, 0x75) # Write 0x75 to the Frequency Band Select register\n\trfm.write_register(0x76, 0xBB) # Write 0xBB to the Nominal Carrier Frequency1 register\n\trfm.write_register(0x77, 0x80) # Write 0x80 to the Nominal Carrier Frequency0 register\n\t# Set the desired TX data rate (9.6kbps)\n\trfm.write_register(0x6E, 0x4E) # Write 0x4E to the TXDataRate 1 register\n\trfm.write_register(0x6F, 0xA5) # Write 0xA5 to the TXDataRate 0 register\n\trfm.write_register(0x70, 0x2C) # Write 0x2C to the Modulation Mode Control 1 register\n\t# Set the desired TX deviation (+=45kHz)\n\trfm.write_register(0x72, 0x48) # Write 0x48 to the Frequency Deviation Register\n\n\t\"\"\"Set Packet Configuration\"\"\"\n\t# Set packet structure and modulation type\n\trfm.write_register(0x34, 0x09) # Write 0x09 to the Preamble length register\n\t# Disable header bytes; set variable packet length (the length of the packet is defined by the\n\t# received packet length field of the packet); set the synch word to two bytes long\n\trfm.write_register(0x33, 0x02) # Write 0x02 to the Header Control 2 register\n\t# Set the sync word pattern to 0x2DD4\n\trfm.write_register(0x36, 0x2D) # Write 0x2D to the Sync Word 3 register\n\trfm.write_register(0x37, 0xD4) # Write 0xD4 to the Sync Word 2 register\n\t# Enable the TX packet handler and CRC-16 (IBM) check\n\trfm.write_register(0x30, 0x0D) # Write 0x0D to the Data Access Control register\n\t# Enable FIFO mode and GFSK modulation\n\trfm.write_register(0x71, 0x63) # Write 0x63 to the Modulation Mode Control 2 Register \n\n\t\"\"\"Select modulation\"\"\"\n\t# Set VCO and PLL\n\trfm.write_register(0x54, 0x7F) # Write 0x7F to the VCO Current Trimming register\n\trfm.write_register(0x59, 0x40) # Write 0x40 to the Divider Current Trimming register",
"def init_serial():\n ser = serial.Serial()\n #ser.port = \"\\\\.\\COM4\" # Windows\n ser.port = \"/dev/ttyUSB0\" # Linux\n ser.baudrate = 57600\n try:\n ser.open()\n except Exception, e:\n logger.info(\"Possible open serial port: \" + str(e))\n print 'Check the serial USB port.'\n exit()\n return ser",
"def init(\n baudrate=1000000, bits=8, mode=0, sclk=\"pin13\", mosi=\"pin15\", miso=\"pin14\"\n ):\n utils.print_for_unimplemented_functions(SPI.init.__qualname__)\n telemetry_py.send_telemetry(TelemetryEvent.MICROBIT_API_SPI)",
"def __init__(self,portnum):\n # These should really be set by the user.\n baud = 9600\n databits = 8\n par = serial.PARITY_NONE # parity\n sb = 1 # stop bits\n to = 2\n \n try:\n self.port = serial.Serial(portnum,baud, \\\n parity = par, stopbits = sb, bytesize = databits,timeout = to)\n except \"FIXME\": #serial.serialutil.SerialException:\n raise \"PortFailed\"\n \n obd_debug( self.port.portstr)\n ready = \"ERROR\"\n while ready == \"ERROR\":\n self.send_command(\"atz\") # initialize\n obd_debug( [self.get_result_line()])\n self.send_command(\"ate0\") # echo off\n obd_debug( [self.get_result_line()])\n self.send_command(\"0100\")\n ready = self.get_result_line()[-6:-1]\n print ready",
"def __init__(self):\n\n super().__init__()\n\n self.active = True\n self.driver = Driver.instance()\n self.sensor_manager = SensorManager.instance()\n\n self.pwm = Adafruit_PCA9685.PCA9685(address=0x40, busnum=1) # create PCA9685-object at I2C-port\n self.pwm.set_pwm_freq(50)\n\n GPIO.setwarnings(False)\n GPIO.setmode(GPIO.BCM)\n GPIO.setup(20, GPIO.OUT)\n GPIO.setup(21, GPIO.OUT)\n GPIO.setup(26, GPIO.OUT)\n self.driven_distance = 0",
"def __init__(self):\n self.ser = serial.Serial('/dev/ttyUSB3',9600)\n collect_readings = False\n self.colours = []\n self.max_readings = 50 #maximum number of readings to use",
"def __init__(self, red_pin, green_pin, blue_pin):\n #self.red = gpiozero.PWMLED(red_pin, frequency=80, initial_value=1)\n #self.green = gpiozero.PWMLED(green_pin, frequency=80, initial_value=1)\n #self.blue = gpiozero.PWMLED(blue_pin, frequency=80, initial_value=1)\n self.red = gpiozero.LED(red_pin)\n self.green = gpiozero.LED(green_pin)\n self.blue = gpiozero.LED(blue_pin)\n self.leds = [self.red, self.green, self.blue]\n self.off()",
"def __init__(self,port):\n\n \n self.instrument = serial.Serial(port, baudrate=115200, timeout= 0.002)\n print(\"Connected to power supply.\")\n self.async_query_buffer = [] #create an empty lis\n self.async_reply_buffer = []\n #self.identify()",
"def init_com(self):\r\n self.__ser = serial.Serial(\r\n self.__dev_no, self.__baudrate, timeout=self.__timeout)\r\n\r\n # Stop the Continious Stream, avoid error\r\n self.__ser.write(self.__api.esc_cmd())\r\n self.__ser.write(self.__api.devid_cmd())\r\n tmp = self.__ser.readline().decode()\r\n\r\n # Get Dev ID\r\n if \"ID= \" in tmp:\r\n self.__api.devid = tmp.split(\"ID= \")[1].replace(\"\\r\", \"\")\r\n rospy.loginfo(self.__api.devid)\r\n\r\n init_cmds = [self.__api.factory_settings_cmd, self.__api.format_cmd(self.__format),\r\n self.__api.sample_rate_cmd(100), self.__api.continuous_stream_cmd]\r\n\r\n for cmd in init_cmds:\r\n self.__ser.write(self.__api.write_enable_cmd)\r\n rospy.loginfo(self.__ser.readline().decode())\r\n time.sleep(self.init_sleep)\r\n rospy.loginfo(cmd)\r\n self.__ser.write(cmd)\r\n if cmd != self.__api.continuous_stream_cmd:\r\n rospy.loginfo(self.__ser.readline().decode())\r\n time.sleep(self.init_sleep)\r\n return True\r\n return False",
"def __init__(self, port='/dev/ttyS0', pin=7, logger=None):\n super().__init__(port=port, pin=pin, logger=logger)",
"def __init__(self, port='/dev/ttyUSB0', baudrate=1200,\n calib=[-0.49125, 1.0613], Tident='LSCI,MODEL321', mode=0):\n # for the baratron reading and updating display\n self.dmm = gpib.find('3478a')\n self.__bytes__ = 32\n # so that DMM knows to put something in the output buffer\n gpib.read(self.dmm, self.__bytes__)\n \n # for the temperature reading, many values hardcoded for\n # Lakeshore 321 cryogenic temperature sensor\n self.Tsensor = serial.Serial(port=port, baudrate=baudrate,\n bytesize = 7, parity = 'O')\n self.Tsensor.setTimeout(1)\n self.Tsensor.flushInput()\n self.Tsensor.write('*IDN?\\n')\n answer = self.Tsensor.readline()\n\n if (re.match(Tident, answer) == None):\n raise Exception, \"LS321 ident string not matched\"\n \n # calibration factors consist of two numbers: voltage reading\n # at vacuum, and voltage reading at 1 atm.\n self.calib = calib\n self.mode = mode\n \n # some constants; declared here so that improved versions\n # of front-ends could modify them.\n self.atm = 760.0\n self.unit='TORR'\n self.pascalPerTorr = 133.322\n self.boltzmann = 1.38065e-23\n self.BGUnit='HE'",
"def connect(self):\n # open serial port\n try:\n #device = self.get_device_name(self.serial_number)\n device = \"/dev/ttyAMA0\"\n self.serial.port = device\n # Set RTS line to low logic level\n self.serial.rts = False\n self.serial.open()\n except Exception as ex:\n self.handle_serial_error(ex)",
"def __init__(self, rs=2, e=3, db7=4, db6=14, db5=15, db4=18):\n self.rs = rs\n self.e = e\n self.db7 = db7\n self.db6 = db6\n self.db5 = db5\n self.db4 = db4\n \n GPIO.setmode(GPIO.BCM)\n GPIO.setup([self.rs, self.e, self.db7, self.db6, self.db5, self.db4], GPIO.OUT)\n\n # Display on/off control\n self.display_on_off = 1\n self.cursor_on_off = 1\n self.cursor_blink = 1\n\n # Function set\n self.data_length = 0 # 4 bit data length\n self.numer_of_lines = 1 # two display lines\n self.character_font = 0 # 5x8 lines font",
"def __init__(self, pinForward1, pinBackward1,pinForward2, pinBackward2):\n\n self.pinForward1 = pinForward1\n self.pinBackward1 = pinBackward1\n self.pinForward2 = pinForward2\n self.pinBackward2 = pinBackward2\n\n GPIO.setup(self.pinForward1, GPIO.OUT)\n GPIO.setup(self.pinBackward1, GPIO.OUT)\n GPIO.setup(self.pinForward2, GPIO.OUT)\n GPIO.setup(self.pinBackward2, GPIO.OUT)\n\n self.pwm_forward1 = GPIO.PWM(self.pinForward1, 100)\n self.pwm_backward1 = GPIO.PWM(self.pinBackward1, 100)\n self.pwm_forward2 = GPIO.PWM(self.pinForward2, 100)\n self.pwm_backward2 = GPIO.PWM(self.pinBackward2, 100)\n \n self.pwm_forward1.start(0)\n self.pwm_backward1.start(0)\n self.pwm_forward2.start(0)\n self.pwm_backward2.start(0)",
"def __init__(self, port):\n self._ser = Serial(port, 9600, 8, 'N', 1, timeout=1)\n self._ser.write(b\"\\x03\")\n time.sleep(0.1)\n self._ser.write(b\" \")\n time.sleep(0.1)\n init_response = self._ser.read(100)\n if init_response != b\" SMC24 v2.12\\r\\n\":\n click.echo(\"Monochromator not initialized correctly\", err=True)\n sys.exit(-1)\n self._pos_regex = re.compile(\"^Z\\\\s+(-?\\\\d+).*$\")",
"def __init__(self):\n GPIO.setmode(GPIO.BOARD) # Set's GPIO referencing to RPi Board Refdes\n self.chanlist = [29, 31, 33, 35, 37] # chanlist 0, 1, 2, 3, 4\n GPIO.setup(29, GPIO.IN) # Setup as input to pi\n GPIO.setup(31, GPIO.IN) # Setup as input\n GPIO.setup(33, GPIO.IN) # Setup as input\n GPIO.setup(35, GPIO.IN) # Setup as input\n GPIO.setup(37, GPIO.OUT) # Setup as output from pi\n self.SHTDWN = False\n\n GPIO.add_event_detect(self.chanlist[1], GPIO.BOTH) \n GPIO.add_event_detect(self.chanlist[3], GPIO.FALLING, self.callback_SHTDWN, bouncetime=200)",
"def initialize(self):\n self.log.info(\"Initialize raspPinball hardware.\")\n\n self.config = self.machine.config['rasppinball']\n self.machine.config_validator.validate_config(\"rasppinball\", self.config)\n print(\"***************************\")\n print(self.config)\n #self.machine_type = (\n # self.machine.config['hardware']['driverboards'].lower())\n\n self._connect_to_hardware()\n\n\n # keypad\n self._kp = Keypad()\n self.old_key = \"\"\n self.key = \"\"\n # leds\n self.init_strips()",
"def init_num():\n logging.info(\"Initializing Number Display\")\n try:\n #com = serial.Serial(config.devnum, 9600, timeout=3)\n com = serial.Serial(config.devnum, 9600, timeout=None)\n com.close()\n com.open()\n com.write(config.num['init'])\n #com.close()\n except serial.SerialException as e:\n logging.warning(\"Serial exception: \"+str(e))\n return com",
"def __init__(self, port):\r\n self.ser = serial.Serial(port=port,\r\n baudrate=9600,\r\n # bytesize=serial.EIGHTBITS,\r\n # parity=serial.PARITY_EVEN,\r\n # stopbits=serial.STOPBITS_ONE,\r\n timeout=0.05)\r\n self.ser_io = io.TextIOWrapper(io.BufferedRWPair(self.ser, self.ser),\r\n newline='\\r',\r\n line_buffering=True)",
"def setup_gpio(self):\n GPIO.setmode(GPIO.BOARD)\n GPIO.setup(self._input_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)",
"def __init__(self) -> None:\n self.sensor = serial.Serial(config.DEVICE)\n super().__init__()",
"def init_serial(instrument):\r\n\t# open a serial port\r\n\ttry:\r\n\t\tser = serial.Serial(instrument['port']) # try and open th serial port\r\n\texcept:\r\n\t\tser = serial.Serial() # make an empty serial port object if not\r\n\t# display serial port status\r\n\tprint_spacer()\r\n\tif ser.isOpen()==True:\r\n\t print 'Serial port '+instrument['port']+ ' has been opened.'\r\n\telse:\r\n\t print 'Serial port '+instrument['port']+' failed to open.'\t\t# set up the parameters\r\n\t# set up the serial port parameters\r\n\tser.baudrate = instrument['baudrate'] # set the baudrate\r\n\tser.bytesize = instrument['bytesize'] # \r\n\tser.parity = instrument['parity'] # \r\n\tser.stopbits = instrument['stopbits'] # \r\n\tser.timeout = instrument['timeout'] # specify a timeout (in seconds) so the port doesn't hang\r\n\tser.xonxoff = instrument['xonxoff'] # \r\n\tser.rtscts = instrument['rtscts'] # \r\n\tser.dsrdtr = instrument['dsrdtr'] # \r\n\t#return the serial port back to the caller\r\n\treturn ser",
"def setup(self):\n self.pi.set_pull_up_down(self.gpio, pigpio.PUD_OFF)\n self.pi.set_watchdog(self.gpio, 0)\n self.register_callbacks()",
"def __init__(self, port, baud_rate):\n self.rfid_serial_port = serial.Serial(port, baud_rate)",
"def initialize(self):\n self.ros.enable()\n self.phone_link.enable()",
"def __init__(self, port='/dev/ttyUSB1', baudrate=19200,\n model='TDS', chs=(1,2,3)):\n serial.Serial.__init__(self, port=port, baudrate=baudrate)\n self.model = model\n self.chs = chs\n self.seq = self.readSeq()\n # it should never take more than 5 seconds for any I/O\n self.setTimeout(5)\n # clear buffer in case of errors\n self.flushInput()",
"def setup(port, baud = int('9600'), apn = 'internet.movistar.com.co'):\n try:\n module = serial.Serial('/dev/tty{}'.format(port.upper(), '{}'.format(baud)))\n time.sleep(0.1)\n if module.isOpen():\n print ('Serial Port Available')\n else:\n print ('Serial Port not Available')\n except serial.SerialException:\n print ('Something goes wrong')\n module.close()\n try:\n module.write('AT+CGATT=1\\r\\n'.encode())\n time.sleep(0.01)\n module.write(('AT+CGDCONT=1,\\\"IP\\\",\\\"{}\\\"\\r\\n').format(apn).encode()) \n time.sleep(0.01)\n module.write(('AT+CGSOCKCONT=1,\\\"IP\\\",\\\"{}\\\"\\r\\n').format(apn).encode())\n module.write(('AT+CSOCKSETPN=1\\r\\n').encode())\n time.sleep(0.01)\n module.write(('AT+CGPSURL=\\\"supl.google.com:7276\\\"\\r\\n').encode())\n time.sleep(0.1)\n module.write(('AT+CGPSSSL=1\\r\\n').encode())\n time.sleep(0.1)\n #module.write(('AT+CGPS=1,3\\r\\n').encode())\n #time.sleep(0.2)\n #if _valid_gps(module):\n # print ('GPS configurated')\n #else:\n # print ('GPS not configurated')\n print ('SIM53XX Configurated!')\n except serial.SerialException:\n print ('Something failed during configuration\\rPlase try again...')\n\n return module",
"def setup(motion):\n GPIO.setmode(GPIO.BCM)\n # Sets pin numbering system\n GPIO.setup(motion, GPIO.IN)\n # Configures given pin for input usage.",
"def __init__(self, port: str = '/dev/tty.usbserial-2',\n baudrate: str = 9600):\n\n self.serial = Serial(port, baudrate)\n\n self.camera_address = 0x01\n self.debug = False",
"def init(config):\n ser_if = serial.Serial(config.serial_if, config.baud, timeout=config.timeout)\n sleep(1.6) # wait for serial port to be ready TODO: find a way to check\n return ser_if",
"def __init__(self, device):\n self.device = device\n self.io = serial.Serial(device, 57600, timeout=1)\n self.keys = ['time', 'centroid_x', 'centroid_y', 'centroid_r',\n 'level_1', 'level_2', 'level_3',\n 'width_1', 'width_2', 'width_3',\n 'height_1', 'height_2', 'height_3',\n 'power']",
"def init_relay_card():\n \n global ser_relay\n \n port = \"/dev/ttyACM0\"\n baudrate = 19200\n \n ser_relay = serial.Serial(port,baudrate, timeout=1)",
"def connect():\n try:\n MotorController.serial_connection = serial.Serial(\"/dev/ttyUSB0\")\n MotorController.serial_connection.timeout = 1\n MotorController.serial_connection.baudrate = 115200\n MotorController.serial_connection.xonxoff = True\n MotorController.serial_connection.stopbits = serial.STOPBITS_ONE\n MotorController.serial_connection.parity = serial.PARITY_NONE\n MotorController.serial_connection.bytesize = serial.EIGHTBITS\n MotorController.is_connected = True\n MotorController.serial_connection.write('G0 X4\\r\\n'.encode('utf-8')) #Need to do an absolute move on any axis to be able to do relative moves\n MotorController.serial_connection.write('b!%\\n'.encode('utf-8')) #This line allows for the first command to complete else the command never ends. Don't know why maybe some end of line character or buffer bug\n except serial.SerialException as error:\n return 'Could not connect to motor controller ' + error.__str__()",
"def initialize(self):\n\t\tpcd8544.LCD.initialize(self)\n\t\tRPIO.setup(self._backlight_pin, RPIO.OUT, initial=RPIO.LOW)",
"def __init__(self, gpio_on, gpio_off, delay):\n self.gpio_on = gpio_on\n self.gpio_off = gpio_off\n self.delay = delay",
"def __init__(self, id: int, baudrate: int=9600, bits: int=8, parity: int=None, stop: int=1, tx: Pin=None, rx: Pin=None):",
"def port_setup(robot_name, num_cameras):\n\tglobal local_in_port\n\tglobal local_out_port\n\tglobal local_GPS_port\n\tglobal local_Dest_port\n\n\tglobal local_in_port_name\n\tglobal local_out_port_name\n\tglobal local_GPS_port_name\n\tglobal local_Dest_port_name\n\n\tglobal local_Radio_in_port\n\tglobal local_Radio_out_port\n\n\tglobal ors_in_port_name\n\tglobal ors_out_port_name\n\tglobal ors_GPS_port_name\n\tglobal ors_Dest_port_name\n\tglobal ors_Radio_in_port_name\n\tglobal ors_Radio_out_port_name\n\n\t# Define the names for all the ports\n\tport_prefix = \"/ors/robots/\" + robot_name + \"/\"\n\tlocal_port_prefix = \"/atrv_client/\" + robot_name + \"/\"\n\tview_prefix = \"/img/\" + robot_name + \"/\"\n\n\tors_in_port_name = port_prefix + \"in\"\n\tors_out_port_name = port_prefix + \"out\"\n\n\tors_Dest_port_name = port_prefix + \"Motion_Controller/in\"\n\tors_GPS_port_name = port_prefix + \"GPS/out\"\n\n\tors_Radio_out_port_name = port_prefix + \"Radio/out\"\n\tors_Radio_in_port_name = port_prefix + \"Radio/in\"\n\n\tlocal_in_port_name = local_port_prefix + \"in/\"\n\tlocal_out_port_name = local_port_prefix + \"out/\"\n\n\tlocal_GPS_port_name = local_port_prefix + \"GPS/in/\"\n\tlocal_Dest_port_name = local_port_prefix + \"Motion_Controller/out/\"\n\n\tlocal_Radio_in_port_name = local_port_prefix + \"Radio/in\"\n\tlocal_Radio_out_port_name = local_port_prefix + \"Radio/out\"\n\n\t# Start the yarp network connection\n\tyarp.Network.init()\n\n\t# Open the client ports\n\tlocal_in_port = yarp.BufferedPortBottle()\n\tlocal_in_port.open(local_in_port_name)\n\tlocal_out_port = yarp.BufferedPortBottle()\n\tlocal_out_port.open(local_out_port_name)\n\n\tlocal_GPS_port = yarp.BufferedPortBottle()\n\tlocal_GPS_port.open(local_GPS_port_name)\n\tlocal_Dest_port = yarp.BufferedPortBottle()\n\tlocal_Dest_port.open(local_Dest_port_name)\n\n\tlocal_Radio_out_port = yarp.BufferedPortBottle()\n\tlocal_Radio_out_port.open(local_Radio_out_port_name)\n\tlocal_Radio_in_port = yarp.BufferedPortBottle()\n\tlocal_Radio_in_port.open(local_Radio_in_port_name)\n\n\t# Connect the client ports to the simulator ports\n\tyarp.Network.connect (local_out_port_name, ors_in_port_name)\n\tyarp.Network.connect (ors_out_port_name, local_in_port_name)\n\n\tyarp.Network.connect (ors_GPS_port_name, local_GPS_port_name)\n\tyarp.Network.connect (local_Dest_port_name, ors_Dest_port_name)\n\n\tyarp.Network.connect (local_Radio_out_port_name, ors_Radio_in_port_name)\n\tyarp.Network.connect (ors_Radio_out_port_name, local_Radio_in_port_name)\n\n\n\t# Connect the cameras to yarpview windows\n\tprint (\" * Initializing yarpview windows.\")\n\tfor id in range(int(num_cameras)):\n\t\t# Build the name of the camera\n\t\tcamera_name = \"Camera{0}\".format(id+1)\n\n\t\t# Prepare the ports to be used\n\t\timg_view_port = view_prefix + camera_name\n\t\tatrv_camera_port = port_prefix + camera_name\n\n\t\tyarp.Network.connect (atrv_camera_port, img_view_port)",
"def open_serial(self):\n self.port = serial.Serial(\n self.device,\n baudrate=SERIAL_BAUD,\n timeout=5.0,\n bytesize=serial.EIGHTBITS,\n parity=serial.PARITY_NONE,\n stopbits=serial.STOPBITS_ONE,\n xonxoff=False,\n rtscts=False,\n dsrdtr=False)\n\t\n self.port.flushInput()\n self.port.flushOutput()",
"def connectFPGA():\n global serialObject\n try:\n print(\"Establishing connection to FPGA ..\")\n serialObject = serial.Serial('COM12', 115200, serial.EIGHTBITS, serial.PARITY_NONE, serial.STOPBITS_ONE)\n print(\"Connection established ..\")\n except:\n print(\"Cant Open Specified Port\")",
"def __init__(self):\n\n self.wp = wp\n self.wp.wiringPiSetup()\n\n self.LEDON_PIN = 21\n self.SENSOR_PINS = [22, 26, 23, 27, 24, 28, 25, 29]\n self.NUM_SENSORS = len(self.SENSOR_PINS)\n self.CHARGE_TIME = 10 #us to charge the capacitors\n self.READING_TIMEOUT = 1000 #us, assume reading is black\n\n self.sensorValues = []\n self.calibratedMax = []\n self.calibratedMin = []\n self.lastValue = 0\n self.init_pins()",
"def init(self):\n self.AOMBoxConnection = pyArdDAC.ARD_DAC(HOST=self.AOMBox_IP, PORT=8888, DEBUG=False)#connects to arduino in High frequency Na AOM box\n #channel number should be defined in subclass\n self.INTEGER_MIN = 0\n self.INTEGER_MAX = 65535\n self.VOLTAGE_MIN = 0.0\n self.VOLTAGE_MAX = 5.0\n self.initialised=True\n return \"%s init successful\" % self.hardwareActionName",
"def __init__(self, port='/dev/ttyS0', pin=7, logger=None):\n self.port = port\n self.pin = pin\n self.serial_com = None\n\n if not logger:\n # Null logger if no logger is defined as parameter\n self._logger = logging.getLogger(__name__).addHandler(NullHandler())\n else:\n self._logger = logger",
"def setup(self):\n settings: ClusterQRM_RF_Settings = self.settings\n if self.is_connected:\n # Load settings\n port_settings: ClusterRF_OutputPort_Settings = settings.ports[\"o1\"]\n self.ports[\"o1\"].channel = port_settings.channel\n self._port_channel_map[\"o1\"] = self.ports[\"o1\"].channel\n self.ports[\"o1\"].attenuation = port_settings.attenuation\n self.ports[\"o1\"].lo_enabled = port_settings.lo_enabled\n self.ports[\"o1\"].lo_frequency = port_settings.lo_frequency\n self.ports[\"o1\"].gain = port_settings.gain\n self.ports[\"o1\"].hardware_mod_en = port_settings.hardware_mod_en\n\n self.ports[\"o1\"].nco_freq = 0\n self.ports[\"o1\"].nco_phase_offs = 0\n\n port_settings: QbloxInputPort_Settings = settings.ports[\"i1\"]\n self.ports[\"i1\"].channel = port_settings.channel\n self._port_channel_map[\"i1\"] = self.ports[\"i1\"].channel\n self.ports[\"i1\"].hardware_demod_en = port_settings.hardware_demod_en\n self.ports[\"i1\"].acquisition_hold_off = port_settings.acquisition_hold_off\n self.ports[\"i1\"].acquisition_duration = port_settings.acquisition_duration\n\n self._channel_port_map = {v: k for k, v in self._port_channel_map.items()}\n self.channels = list(self._channel_port_map.keys())\n else:\n raise Exception(\"The instrument cannot be set up, there is no connection\")",
"def init():\n\n global leftDriverStick\n global rightDriverStick\n global goGamePad\n\n try:\n leftDriverStick = T16000M(0)\n except:\n print('OI: Error - Could not instantiate Left Driver Stick on USB port 0!!!')\n\n try:\n rightDriverStick = T16000M(1)\n except:\n print('OI: Error - Could not instantiate Right Driver Stick on USB port 0!!!')\n\n try:\n goGamePad = Joystick(2)\n except:\n print('OI: Error - Could not instantiate Right Driver Stick on USB port 2!!!')\n\n\n # ----------------------------------------------------------\n # Driver Controls\n # ----------------------------------------------------------\n #global resetYawBtn\n #resetYawBtn = JoystickButton(rightDriverStick, config.btnResetYawAngleIndex)\n #resetYawBtn.whenPressed(NavxResetYawAngle())\n\n global btnDriveSlow\n btnDriveSlow = JoystickButton(leftDriverStick, config.btnDriveSlow)\n \n global btnEnableLightSensor\n btnEnableLightSensor = JoystickButton(leftDriverStick, config.btnEnableLightSensorIndex)\n\n global btnExtendAll\n btnExtendAll = JoystickButton(rightDriverStick, config.btnExtendAllIndex)\n btnExtendAll.whenPressed(ExtendAll())\n\n global btnRetract\n btnRetract = JoystickButton(rightDriverStick, config.btnRetractAllIndex)\n btnRetract.whenPressed(RetractAll())\n\n global btnExtendFront\n btnExtendFront = JoystickButton(rightDriverStick, config.btnExtendFrontIndex)\n btnExtendFront.whenPressed(ExtendFront())\n\n global btnExtendBack\n btnExtendBack = JoystickButton(rightDriverStick, config.btnExtendBackIndex)\n btnExtendBack.whenPressed(ExtendBack())\n\n global btnRetractFront\n btnRetractFront = JoystickButton(rightDriverStick, config.btnRetractFrontIndex)\n btnRetractFront.whenPressed(RetractFront())\n\n global btnCargoGrabTog\n btnCargoGrabTog = JoystickButton(goGamePad, config.btnHatchGrabTogIndex)\n btnCargoGrabTog.whenPressed(ExtendBack())\n \n \"\"\"\n global btnResetEncoders\n btnResetEncoders = JoystickButton(leftDriverStick, config.btnResetEncodersIndex)\n btnResetEncoders.whenPressed(TankDriveResetEncoders())\n \"\"\"\n\n \"\"\"\n global axisElevator\n axisElevator = JoystickAxis(goGamePad, config.axisElevatorIndex)\n axisElevator. #??? idk how to configure joystick axis\n \"\"\"\n\n \"\"\"\n global btnRampTog\n btnRampTog = JoystickButton(goGamePad, config.btnRampTogIndex)\n btnRampTog.whenPressed(ExtendFront())\n \"\"\"\n #global btnResetEncoders\n #btnResetEncoders = JoystickButton(leftDriverStick, config.btnResetEncodersIndex)\n #btnResetEncoders.whenPressed(TankDriveResetEncoders())\n\n # These variable names are inconsistent, need to be fixed!!!!\n #global btnRampExtendTog\n #btnRampExtendTog = JoystickButton(goGamePad, config.btnRampExtendTogIndex)\n #btnRampExtendTog.whenPressed(RampExtend())\n\n #global btnRampRetractTog\n #btnRampRetractTog = JoystickButton(goGamePad, config.btnRampRetractTogIndex)\n #btnRampRetractTog.whenPressed(RampRetract())",
"def start(self):\n\n buttons = {}\n for pin in self._pin_nums:\n buttons[\"button_\" + str(pin)] = pin\n\n self._gpio = self.init_interface(\"gpio\",\n impl=self._impl, \n **buttons)\n\n d_len = len(self._dir)\n b_len = len(self._bounce)\n for i, button in enumerate(buttons):\n # Initiliaze every button\n dire = self._dir[i % d_len]\n self._directions.append(dire)\n\n boun = self._bounce[i % b_len]\n self._debounce.append(boun)\n\n self._button_init(button, dire, boun)",
"def __init__(self):\r\n\r\n self.port = 'COM3'\r\n self.baud = 9600\r\n\r\n try:\r\n self.ser = Serial(self.port, self.baud)\r\n except:\r\n exit(\"<ERROR: check serial connection>\")\r\n\r\n if not self.ser.is_open:\r\n exit(f\"<ERROR: can't open serial port: {self.port}>\")\r\n\r\n self.connect()",
"def _initialize_hardware(self):\n # Import\n try:\n import board\n import busio\n import adafruit_vl6180x\n except Exception as ex:\n logging.error(\n '\\n *** ERROR importing Adafruit libraries: {}'.format(\n ex,\n ),\n )\n\n # Things failed, so we must be running locally, not on a widget;\n # don't bother hooking up the VL6180X\n return\n\n # Initialize I2C and VL6180X\n try:\n i2c = busio.I2C(board.SCL, board.SDA)\n self._sensor = adafruit_vl6180x.VL6180X(i2c)\n except Exception as ex:\n logging.error(\n '\\n *** ERROR initializing I2C/LSM303: {}'.format(ex),\n )\n\n self._initialize_id_led()",
"def init_relay(self, port):\n self.ser = SerialHelper()\n self.ser.port = port\n self.ser.start()",
"def init_serial(port):\n try:\n ser_port = serial.Serial(port, 9600)\n except:\n raise SerialPortError(\"Error opening \" + port)\n\n print(\"Serial port \"+ser_port.name+\" opened.\")\n return ser_port",
"def __init__(self, pinForward, pinBackward, pinControl):\n\n self.pinForward = pinForward\n self.pinBackward = pinBackward\n self.pinControl = pinControl\n GPIO.setup(self.pinForward, GPIO.OUT)\n GPIO.setup(self.pinBackward, GPIO.OUT)\n GPIO.setup(self.pinControl, GPIO.OUT)\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\n self.pwm_forward.start(0)\n self.pwm_backward.start(0)\n GPIO.output(self.pinControl,GPIO.HIGH)",
"def __init__(self, port, baudrate):\n return",
"def init_pins(self):\n for pin in self.SENSOR_PINS:\n self.sensorValues.append(0)\n self.calibratedMax.append(0)\n self.calibratedMin.append(0)\n self.wp.pullUpDnControl(pin, self.wp.PUD_DOWN)\n self.wp.pinMode(self.LEDON_PIN, self.wp.OUTPUT)",
"def __init__(self, serial_port='/dev/ttyACM0', baud_rate=9600,\n read_timeout=5):\n self.conn = serial.Serial(serial_port, baud_rate)\n self.conn.timeout = read_timeout # Timeout for readline()",
"def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\n self.GP = GPIOProcessor()\n self.pin1 = self.GP.getPin(pin1)\n self.pin2 = self.GP.getPin(pin2)\n self.pin3 = self.GP.getPin(pin3)\n self.pin4 = self.GP.getPin(pin4)\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\n\n for k in range(4):\n self.pinl[k].out()\n\n self.speed = 100.0",
"def __init__(self, port: str = '/dev/ttyACM0',\n baud_rate: int = 9600,\n timeout: int = 5):\n super(Arduino, self).__init__()\n self.port = port\n self.baud_rate = baud_rate\n self.arduino = None\n self.timeout = timeout",
"def __init__(self, port):\n self.port = port\n self.connection = serial.Serial(timeout=1)\n self.connection.port = self.port",
"def setup(self):\n\t\tself.interface = self.getDriver('light_interface')\n\n\t\tself.pin = self.config['interface_position']\n\t\tself.blink_rate = self.config['blink_rate'] / 2 or 0.5\n\t\tself.is_on = False\n\n\t\tself.intensity = 255\n\t\tself.blink = False\n\t\tself.count = None\n\t\tself.current_count = False\n\t\tself.current_count = None\n\n\t\tself.saved_intensity = None\n\t\tself.saved_blink = False\n\t\tself.saved_count = None\n\n\t\treturn True",
"def initialize_relays(self):\n #create list of bytes to clear out relays\n zeroed_bytes = []\n for i in range(self.num_registers):\n zeroed_bytes.append(0x00)\n\n #clear out any data in the shift registers\n ret = self.e.write_SPI_bytes_to_portA(zeroed_bytes)\n self.strobe_relays()\n print \"read from SPI: \",\n print ret\n\n #enable the relays\n self.enable_relays()",
"async def assign_serial_port(self, serial_manager):\n #logstring(\"you are now in assign_serial_port\")\n if serial_manager is None:\n return\n\n if serial_manager.CurrentPort is None:\n return\n\n self._clear_stored_response_dictionaries()\n\n self.serial_manager = serial_manager\n self.serial_port = serial_manager.CurrentPort\n #to remove, only used for testing right now\n self.serial_port_name = serial_manager.CurrentPort.com_port\n\n # set the read and write handles\n self.read = self.serial_manager.CurrentPort.read\n self.write = self.serial_manager.CurrentPort.write\n\n self._valid_target_exists = True\n\n\n #keeps a direct reference to the pins\n self._digital_pins_directly = []\n self._analog_pins_directly = []\n\n #and ports\n self._ports_directly = []\n\n # wait for arduino to go through a reset cycle if need be\n logstring(\"Waiting for 2 seconds...\")\n time.sleep(self.arduino_wait)\n #logstring(\"time is up!\")\n #await asyncio.sleep(self.arduino_wait)\n\n # register the get_command method with the event loop\n self.loop = asyncio.get_event_loop()\n\n logstring(\"Setting up Firmata on port {}\".format(self.serial_port.com_port))\n\n # get arduino firmware version and print it\n logstring(\"Checking Firmware version\")\n firmware_version = await self.get_firmware_version()\n logstring(\"Finished checking Firmware version\")\n if not firmware_version:\n logerr('*** Firmware Version retrieval timed out. ***')\n logerr('Firmata not found')\n try:\n # attempt to autoload firmata here, if fails again, mark the port as error\n self.disconnect_port_due_to_error()\n return\n except RuntimeError:\n self.disconnect_port_due_to_error()\n return\n except TypeError:\n self.disconnect_port_due_to_error()\n return\n logstring(\"\\nFirmware ID: \" + firmware_version)\n logstring(\"On port {}\".format(self.serial_port_name))\n # get an analog pin map\n\n # try to get an analog report. if it comes back as none - shutdown\n # report = await self.get_analog_map()\n logstring(\"Fetching analog mapping\")\n analogreport = await self.get_analog_map()\n #logstring(\"got analog map\")\n if not analogreport:\n logerr('*** Analog map retrieval timed out. ***')\n logerr('Analog Pin Mapping not found')\n try:\n # attempt to autoload firmata here, if fails again, mark the port as error\n self.disconnect_port_due_to_error()\n return\n except RuntimeError:\n self.disconnect_port_due_to_error()\n return\n except TypeError:\n self.disconnect_port_due_to_error()\n return\n\n capabilityreport = await self.get_capability_report()\n if not capabilityreport:\n logerr('*** Capability Report retrieval timed out. ***')\n logerr('Capability Report not found')\n try:\n # attempt to autoload firmata here, if fails again, mark the port as error\n self.disconnect_port_due_to_error()\n return\n except RuntimeError:\n self.disconnect_port_due_to_error()\n return\n except TypeError:\n self.disconnect_port_due_to_error()\n return\n # custom assemble the pin lists\n pininfo = iter(capabilityreport)\n\n\n self._nested_objects = []\n\n\n for i, analogpinmapping in enumerate(analogreport):\n #set up the data structure that captures data that comes from Firmata\n digital_data = PinData()\n self.digital_pins.append(digital_data)\n HasAnalog = False\n analog_data = PinData()\n self.analog_pins.append(analog_data)\n if analogpinmapping != Constants.IGNORE:\n self.analog_pins_analog_numbering.append(analog_data)\n HasAnalog = True\n #set up the data structure that captures data to be sent to Firmata\n port_num = math.floor(i/8)\n pin_num_within_port = i%8\n HasInput = False\n HasOutput = False\n HasPullup = False\n HasAnalog2 = False\n AnalogResolution = 0\n AnalogPinNum = 127\n HasPWM = False\n PWMResolution = 0\n HasI2C = False\n try:\n nextbyte = next(pininfo)\n while nextbyte != 127: #127 signals the end of the information for a pin\n resolutionbyte = next(pininfo)\n if nextbyte == Constants.INPUT:\n HasInput = True\n if nextbyte == Constants.OUTPUT:\n HasOutput = True\n if nextbyte == Constants.PULLUP:\n HasPullup = True\n if nextbyte == Constants.ANALOG:\n HasAnalog2 = True\n AnalogResolution = resolutionbyte\n AnalogPinNum = analogpinmapping\n if nextbyte == Constants.PWM:\n HasPWM = True,\n PWMResolution=14\n if nextbyte == Constants.SERVO:\n pass\n #nothing to do. we treat it like an OUTPUT\n #resolution is fixed...may do something with this\n #in the future if there are issues with some platform?\n if nextbyte == Constants.I2C:\n HasI2C = True\n nextbyte = next(pininfo)\n except StopIteration:\n pass\n\n if HasAnalog2 != HasAnalog:\n #this really shouldn't happen, but might as well catch it anyway\n raise Exception(\"The Analog Pin Map disagrees with the Capabilty Report as to whether pin {} is an analog pin\".format(i))\n\n #this sets the pin number 0-7 within each port\n if pin_num_within_port == 0: #Yay, new port, create it:\n current_port = Port(\"Port {}\".format(port_num),\n port_num)\n self._nested_objects.append(current_port)\n self._ports_directly.append(current_port)\n\n newpin = Pin(ID = \"Pin {} of Port {} hasanalog = {}\".format(pin_num_within_port,\n port_num, HasAnalog),\n PinNum = i, HasInput=HasInput,\n HasPullup=HasPullup, HasOutput=HasOutput,\n HasAnalog=HasAnalog, AnalogPinNum=analogpinmapping,\n AnalogResolution=AnalogResolution, HasPWM=HasPWM,\n PWMResolution=PWMResolution, HasI2C=HasI2C)\n current_port.pins.append(newpin)\n self._digital_pins_directly.append(newpin)\n logstring(\"Appending a new pin {} len {}\".format(newpin._ID, len(self._digital_pins_directly)))\n if HasAnalog:\n self._analog_pins_directly.append(newpin)\n\n\n\n logstring('Auto-discovery complete. Found ' + \\\n str(len(self.digital_pins)) + ' Digital Pins and ' + \\\n str(len(self.analog_pins_analog_numbering)) + ' Analog Pins')\n\n self._numpins = len(self.digital_pins)\n self._numports = math.ceil(self._numpins/8)\n\n\n self.KeepAlive = KeepAlive(\"Keep Alive\")\n self._nested_objects.append(self.KeepAlive)\n\n self.Tone = Tone(\"Tone\", self._numpins)\n self._nested_objects.append(self.Tone)\n\n #self.EncoderConfig = EncoderConfig(\"Encoder Config\", self._numpins)\n #self._nested_objects.append(self.EncoderConfig)",
"def __init__(self):\n # self.baud = baud\n # self.protocol = protocol\n pass",
"def __init__(self, pinForward, pinBackward, pinControlStraight,pinLeft, pinRight, pinControlSteering):\n\n self.pinForward = pinForward\n self.pinBackward = pinBackward\n self.pinControlStraight = pinControlStraight\n self.pinLeft = pinLeft\n self.pinRight = pinRight\n self.pinControlSteering = pinControlSteering\n GPIO.setup(self.pinForward, GPIO.OUT)\n GPIO.setup(self.pinBackward, GPIO.OUT)\n GPIO.setup(self.pinControlStraight, GPIO.OUT)\n\n GPIO.setup(self.pinLeft, GPIO.OUT)\n GPIO.setup(self.pinRight, GPIO.OUT)\n GPIO.setup(self.pinControlSteering, GPIO.OUT)\n\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\n self.pwm_forward.start(0)\n self.pwm_backward.start(0)\n\n self.pwm_left = GPIO.PWM(self.pinLeft, 100)\n self.pwm_right = GPIO.PWM(self.pinRight, 100)\n self.pwm_left.start(0)\n self.pwm_right.start(0)\n\n GPIO.output(self.pinControlStraight,GPIO.HIGH) \n GPIO.output(self.pinControlSteering,GPIO.HIGH)",
"def init_led():\r\n global led\r\n led = LED(LED_GPIO_PIN)\r\n led.off()",
"def connect(self):\n try:\n # Port and packet handler set up\n self.port_handler = port_h.PortHandler(self.port_name)\n self.packet_handler = packet_h.PacketHandler(self.protocol_version)\n\n # Set up port and baud rate\n self.port_handler.openPort()\n self.port_handler.setBaudRate(self.baud_rate)\n self.__find_motors()\n except rospy.ROSInterruptException: pass\n\n self.running = True",
"def __init__(self, port, pos_em=None, pos_ex=None, baud=9600, timeout=3):\n self.__ser__ = serial.Serial(port=port, baudrate=baud, timeout=timeout)\n self.lock = threading.RLock()\n self.pos_ex = pos_ex\n self.pos_em = pos_em\n \n self.lamp(False)",
"def app_principal_led():\n \"\"\"\n import serial\n ser = serial.Serial(0) # open first serial port\n print ser.portstr # check which port was really used\n ser.write(\"hello\") # write a string\n ser.close() # close port \n \"\"\"\n\n\n start = mpa.ModuloPyArduino()\n p, v = start.config_arduino()\n con = start.set_conection(p, v)\n\n\n print \"\\n Status of conection: \", con\n if con != 0:\n start.serial_loop_app(con, 1)\n else:\n pass\n\n con.close()",
"def main(self) :\n\n # Close the serial port in case the previous run didn't closed it properly\n self.serialPortDWM1001_1.close()\n self.serialPortDWM1001_2.close()\n \n # Sleep for one sec\n time.sleep(1)\n \n # Open serial port\n self.serialPortDWM1001_1.open()\n self.serialPortDWM1001_2.open()\n\n # Check if the serial port is opened\n if(self.serialPortDWM1001_1.isOpen()):\n rospy.loginfo(\"Port `O` opened: {}\".format(self.serialPortDWM1001_1.name) )\n else:\n rospy.logerr(\"Can't open port `O`: {}\".format(self.serialPortDWM1001_1.name))\n \n if(self.serialPortDWM1001_2.isOpen()):\n rospy.loginfo(\"Port `P` opened: {}\".format(self.serialPortDWM1001_2.name) )\n else:\n rospy.logerr(\"Can't open port `P`: {}\".format(self.serialPortDWM1001_2.name))\n\n try: \n tags = ['A', 'B', 'C', 'D']\n # Counting the msgs received and processed to check the system status\n msg_portO_cnt = [0,0,0,0]\n msg_portP_cnt = [0,0,0,0]\n while not rospy.is_shutdown():\n self.serialPortDWM1001_1.write(\"S\".encode())\n # just read everything from serial port \n for _ in range(4): \n serialReadLine = self.serialPortDWM1001_1.read_until()\n # print(serialReadLine)\n if not serialReadLine:\n rospy.logwarn(\"Port O: Read a empty line from Serial Port\")\n continue\n self.publishTagPositions('O',serialReadLine)\n msg_portO_cnt[tags.index(serialReadLine[9])] += 1\n self.rate.sleep()\n\n self.serialPortDWM1001_2.write(\"S\".encode()) \n for _ in range(4): \n serialReadLine = self.serialPortDWM1001_2.read_until()\n #print(serialReadLine)\n if not serialReadLine:\n rospy.logwarn(\"Port P: Read a empty line from Serial Port\")\n continue\n self.publishTagPositions('P',serialReadLine) \n msg_portP_cnt[tags.index(serialReadLine[9])] += 1 \n self.rate.sleep()\n\n if sum(msg_portO_cnt) > 100 and self.verbose :\n rospy.loginfo(\"All OK. Done O-> {}, P-> {} times !\".format(msg_portO_cnt, msg_portP_cnt))\n msg_portO_cnt = [0,0,0,0]\n msg_portP_cnt = [0,0,0,0]\n\n finally:\n rospy.loginfo(\"Quitting, and sending reset command to dev board\")"
] | [
"0.75681484",
"0.74892616",
"0.74392855",
"0.74244773",
"0.7285181",
"0.711128",
"0.7072771",
"0.6974982",
"0.6920696",
"0.689383",
"0.6876875",
"0.68591636",
"0.68544066",
"0.6852921",
"0.6852614",
"0.6843594",
"0.6811466",
"0.6788002",
"0.67217255",
"0.6689759",
"0.665003",
"0.66347617",
"0.66283303",
"0.6617449",
"0.66155577",
"0.6608806",
"0.6590075",
"0.6578235",
"0.6556716",
"0.6549016",
"0.6533724",
"0.6527446",
"0.65259665",
"0.64963",
"0.64607155",
"0.64511806",
"0.6440534",
"0.6426293",
"0.6411218",
"0.6408567",
"0.6384943",
"0.6382576",
"0.6377185",
"0.6359877",
"0.6359827",
"0.6352759",
"0.6339935",
"0.63327205",
"0.63302374",
"0.63182795",
"0.6311003",
"0.6300462",
"0.6299971",
"0.62971145",
"0.6294026",
"0.62870073",
"0.6284271",
"0.62811375",
"0.6264089",
"0.6263149",
"0.62596107",
"0.62584335",
"0.6257661",
"0.6255522",
"0.62250966",
"0.6225033",
"0.6220338",
"0.62135774",
"0.62128",
"0.62107223",
"0.62078273",
"0.6207267",
"0.6205802",
"0.6204653",
"0.6203347",
"0.62011594",
"0.619818",
"0.6193386",
"0.61908764",
"0.6187825",
"0.6179262",
"0.61780626",
"0.6175882",
"0.6174948",
"0.6172693",
"0.6171895",
"0.6168388",
"0.6144724",
"0.6139586",
"0.61252254",
"0.6116678",
"0.61153316",
"0.61098677",
"0.6086608",
"0.60812557",
"0.60768294",
"0.60763264",
"0.6075261",
"0.60635346",
"0.60500294"
] | 0.65110856 | 33 |
Get next report ID or False if not available | def next_id(self):
try:
return Report.objects.filter(id__gt=self.id).order_by("id").first().id
except Exception:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nextId(self):\r\n \r\n nextId = -1\r\n if self._wizard.currentId() == SOURCE_PAGE_ID:\r\n nextId = TARGET_PAGE_ID\r\n elif self._wizard.currentId() == TARGET_PAGE_ID:\r\n nextId = DATASTORE_PAGE_ID\r\n elif self._wizard.currentId() == DATASTORE_PAGE_ID:\r\n nextId = PROPERTY_PAGE_ID\r\n return nextId",
"def get_report_id(self, reports):\n matching_reports = [\n report for report in reports if report.get('title') in [\n self.api_report_id,\n self.api_test_report_id\n ]\n ]\n\n if self.electiondate: # Can also use the explicit 'if is not none'.\n matching_reports = [\n report for report in matching_reports\n if report.get('electionDate') == self.electiondate\n ]\n\n if matching_reports:\n id = matching_reports[0].get('id').rsplit('/', 1)[-1]\n return id\n\n return None",
"def _get_report_id(self):\n report_id = ''\n if self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_BODY_REPORT) \\\n and 'payment' in self._report_data:\n report_id = self._report_data['payment']['invoiceId']\n elif self._report_key == ReportTypes.MHR_REGISTRATION and self._report_data.get('mhrNumber'):\n report_id = self._report_data.get('mhrNumber')\n return report_id",
"def previous_id(self):\n try:\n return Report.objects.filter(id__lt=self.id).order_by(\"-id\").first().id\n except Exception:\n return False",
"def _next_id(self, identifier: Identifier) -> Optional['Identifier']:\n next_id = None\n if identifier.year is not None and \\\n identifier.month is not None and \\\n identifier.num is not None:\n new_year = identifier.year\n new_month = identifier.month\n new_num = identifier.num + 1\n if (identifier.is_old_id and new_num > 999) \\\n or (not identifier.is_old_id\n and identifier.year < 2015\n and new_num > 9999) \\\n or (not identifier.is_old_id\n and identifier.year >= 2015 and new_num > 99999):\n new_num = 1\n new_month = new_month + 1\n if new_month > 12:\n new_month = 1\n new_year = new_year + 1\n\n if identifier.is_old_id:\n next_id = '{}/{:02d}{:02d}{:03d}'.format(\n identifier.archive, new_year % 100, new_month, new_num)\n else:\n if new_year >= 2015:\n next_id = '{:02d}{:02d}.{:05d}'.format(\n new_year % 100, new_month, new_num)\n else:\n next_id = '{:02d}{:02d}.{:04d}'.format(\n new_year % 100, new_month, new_num)\n try:\n return Identifier(arxiv_id=next_id)\n except IdentifierException:\n return None\n else:\n return None",
"def latest_report_id(self) -> str:\n return pulumi.get(self, \"latest_report_id\")",
"def _GetNextId(self):\r\n ret = self.next_id\r\n self.next_id += 1\r\n return str(self.next_id)",
"def get_next_account_id():\n conn = get_connect()\n cursor = conn.execute(\"SELECT accountId FROM account WHERE isSearched = 0 LIMIT 1\")\n result_list = cursor.fetchone()\n conn.close()\n if result_list is None:\n print(\"no more accountId to be searched\")\n return None\n else:\n account_id = result_list[0]\n return account_id",
"def has_next(self):\n if self._count is not None:\n # If count is available, use it\n return bool(self._count)\n else:\n # otherwise we have no idea\n return True",
"def get_next_submission(self):\r\n success, _next_submission = self.peer_grading.get_next_submission({'location': 'blah'})\r\n self.assertEqual(success, True)",
"def get_next_id(identifier: Identifier) -> Optional[Identifier]:\n return current_session().get_next_id(identifier)",
"def next_id(self):\n return self.max_id + 1",
"def next_id(self):\n next_id = self._nextid\n self._nextid += 1\n return next_id",
"def next_jid(self):\n return self._next_jid",
"def reserve_next_run_id(self):\n query = \"SELECT NEXTVAL(pg_get_serial_sequence('task_history', 'run_id'))\"\n cur = self.conn.cursor()\n cur.execute(query)\n self.conn.commit()\n return cur.fetchone()[0]",
"def next_link(self) -> Optional[str]:\n return pulumi.get(self, \"next_link\")",
"def has_next():\n\n return True",
"def next_id(self):\n self.id_counter += 1\n return self.id_counter - 1",
"def describeNextReport(self, simulation): \n steps = self._reportInterval - simulation.currentStep%self._reportInterval\n return (steps, True, False, False, False)",
"def get_next_id(self, identifier: Identifier) -> Optional['Identifier']:\n next_id = self._next_id(identifier)\n if not next_id:\n return None\n\n path = self._get_parent_path(identifier=next_id)\n file_path = os.path.join(path, f'{next_id.filename}.abs')\n if os.path.isfile(file_path):\n return next_id\n\n next_yymm_id = self._next_yymm_id(identifier)\n if not next_yymm_id:\n return None\n\n path = self._get_parent_path(identifier=next_yymm_id)\n file_path = os.path.join(path, f'{next_yymm_id.filename}.abs')\n if os.path.isfile(file_path):\n return next_yymm_id\n\n return None",
"def get_next_match_id():\n conn = get_connect()\n cursor = conn.execute(\"SELECT matchId FROM match WHERE isSearched = 0 LIMIT 1\")\n result_list = cursor.fetchone()\n conn.close()\n if result_list is None:\n print(\"no more matchId to be searched\")\n return None\n else:\n match_id = result_list[0]\n return match_id",
"def _get_next_friendly_id(context):\n from indico.modules.events.surveys.models.surveys import Survey\n survey_id = context.current_parameters['survey_id']\n assert survey_id is not None\n return increment_and_get(Survey._last_friendly_submission_id, Survey.id == survey_id)",
"def nextId(self):\n if len(ExportDialog.exportSubtypes[ExportDialog.currentType]) > 1:\n return ExportDialog.subtypePage\n return ExportDialog.optionPage",
"def has_next():",
"def _determine_next_ott_id(self):\n if self._doc_counter_lock is None:\n self._doc_counter_lock = Lock()\n with self._doc_counter_lock:\n _LOG.debug('Reading \"{}\"'.format(self._id_minting_file))\n noi_contents = self._read_master_branch_resource(self._id_minting_file, is_json=True)\n if noi_contents:\n self._next_ott_id = noi_contents['next_ott_id']\n else:\n raise RuntimeError('Stored ottid minting file not found (or invalid)!')",
"def reserve_next_agent_id(self):\n query = \"SELECT NEXTVAL(pg_get_serial_sequence('agents', 'agent_id'))\"\n cur = self.conn.cursor()\n cur.execute(query)\n self.conn.commit()\n return cur.fetchone()[0]",
"def get_next_id(self):\n con = self.c._connect()\n last_id = self.c.get_last_id(con.cursor())\n con.close()\n return last_id + 1",
"def has_report(self):\n return self.report is not None",
"def get_next_position(self):\n return self.record_manager.get_max_record_id() or 0",
"def get_next_id():\n with open(WORK_LOG_FILENAME, 'r') as work_log:\n work_log_reader = csv.DictReader(work_log)\n entry_id = 0\n for entry in work_log_reader:\n if int(entry['id']) > entry_id:\n entry_id = int(entry['id'])\n entry_id += 1\n return entry_id",
"def test_uidnext(self):\n d = self._examineOrSelect()\n self._response(b'* OK [UIDNEXT 4392] Predicted next UID')\n self.assertEqual(\n self.successResultOf(d),\n {'READ-WRITE': False, 'UIDNEXT': 4392})",
"def next_job_run(self):\n return self._data.get('next_job_run')",
"def get_next_id():\n global _lock, _counter\n with _lock:\n if _counter == 65535:\n _counter = 1\n else:\n _counter += 1\n\n return str(_counter)",
"def PAID(self):\n if self.session.get('last_bill_result', None) is None:\n return False\n return self.session['last_bill_result'] == \"\"",
"def _next_id(self):\n self._uniq_id += 1\n return str(self._uniq_id)",
"def _next_id(self):\n self._uniq_id += 1\n return str(self._uniq_id)",
"def _ns_nextid(self):\n return self._ns(\"nextid\")",
"def next_identity(self) -> OrganisationId:\n ...",
"def _nextId(cls, id=None):\n if (not hasattr(DAG, \"_lastID\")):\n DAG._lastID = 0\n if (id):\n DAG._lastId = id\n DAG._lastID = DAG._lastID + 1\n return DAG._lastID",
"def get_next_identifier(self) -> int:\n if self.items:\n return self.items[-1].identifier + 1\n else:\n return 1",
"def have_next_page(self):\n page_nav = self.driver.find_element(*CustomerGroupsPage.PAGE_NAVIGATION)\n next = page_nav.find_element(*CustomerGroupsPage.NEXT_BTN)\n link = next.find_element_by_tag_name(\"a\")\n if \"disable\" not in next.get_attribute(\"class\"):\n link.click()\n return True\n else: \n return False",
"def _get_next_pk(self, last_pk):\n ans = self.execute(self.commands.next_pk(\n self.name,\n self.primary_key_column,\n last_pk,\n self.chunk_size\n ))[0][0]\n return ans",
"def create_report(self, report_job: dict):\n try:\n # Run the report and wait for it to finish\n report_job_id = self.report_downloader.WaitForReport(report_job)\n return report_job_id\n except errors.AdManagerReportError as e:\n print('[INFO]: Failed to generate report. Error: %s' % e)\n sys.exit()",
"def check_if_next(driver, num_pages):\n \n try: \n next_link = driver.find_element_by_xpath(\"//li[@class='next']\")\n page_links = driver.find_elements_by_xpath(\n \"//li//span[@class='disabled']\")\n last_page = check_if_last_page(page_links, num_pages)\n if last_page: \n return False\n time.sleep(random.randint(3, 6))\n next_link.click()\n return True\n except Exception as e:\n print e\n return False",
"def next_num(self):\n return self.page + 1",
"def _get_next_event_id():\n VenueCrawler._event_id += 1\n return VenueCrawler._event_id",
"def next_value(self):\n self._lock.acquire()\n try:\n id = self._next_id\n self._next_id += 1\n finally:\n self._lock.release()\n return id",
"def generate_next_invoice_number(obj):\n queryset = obj.__class__.objects.filter(year=obj.year, company=obj.company)\n max = queryset.aggregate(Max('number')).values()[0]\n if max is None:\n max = 0\n return (max + 1)",
"def generate_id():\n for i in range(_MAX_NUM_TESTS):\n test, ref = filename(i)\n if not os.path.exists(test) and not os.path.exists(ref):\n return i\n return None",
"def generate_report(self):\n if self.submission_metadata:\n return self._submission_allowed()[1]",
"def ParentReportNumber(self, default=None):\n return self.data.get('parent_report_number', default)",
"def ParentReportNumber(self, default=None):\n return self.data.get('parent_report_number', default)",
"def next(self):\n resp = yield from self.command('next')\n return True",
"def next_identity(self) -> PublicationId:\n ...",
"def get_next_if_any(self):\n try:\n ret = self.work[deepcopy(self.i)]\n self.i += 1\n # print \"Trickling item\", self.i\n return ret\n except Exception:\n return None",
"def has_next(self):\n return self.page < self.pages",
"def has_next(self):\n return self.page < self.pages",
"def has_next(self):\n return self.page < self.pages",
"def __test_gen_report_id_check():\n # all fresh\n report = dp.Report(md_block, md_block, md_block)\n assert_report(report) # expected_id_count=5)\n # 2 fresh\n report = dp.Report(md_block, md_block_id, md_block)\n assert_report(report) # expected_id_count=4)\n # 0 fresh\n report = dp.Report(md_block_id, dp.Text(\"test\", name=\"test-2\"))\n assert_report(report) # expected_id_count=2)",
"def FindNext():\r\n return _hiew.HiewGate_FindNext()",
"def _get_next_venue_id():\n VenueCrawler._venue_id += 1\n return VenueCrawler._venue_id",
"def has_next_page(self):\n if self.page_number == 0:\n return True\n\n return self.next_page_token is not None",
"def next_available_number(cls):\n try:\n return cls.objects.latest().number + 1\n except cls.DoesNotExist:\n return 1",
"def has_next(self):\n return self.current_page < self.pages",
"def next_question(self, id):\n\t\tif id < (len(self.questions) - 1):\n\t\t\treturn self.questions[id+1]\n\t\telse:\n\t\t\treturn None",
"def getNextID(self, d):\n try:\n listOrdered = d.keys()\n listOrdered = funcs.sortStringList(listOrdered)\n lastID = int(listOrdered[-1])\n nextID = str(lastID + 1)\n for i in range(1,int(nextID)):\n if str(i) not in listOrdered:\n return str(i)\n return nextID\n except:\n return '1'",
"def _get_likely_next_devices(self, devices=None):\n if not devices:\n devices = self._get_device_list()\n device_map = map(lambda x: (x.split(\n '/')[-1], x), devices) # create a dict of id:/dev/id from devices\n # In order, we want: nmve, vd?, xvd?, or sd?\n nvme = sorted((d[1] for d in device_map if d[0][0:4] == 'nvme'))\n vds = sorted((d[1] for d in device_map if d[0][0] == 'v'))\n xvds = sorted((d[1] for d in device_map if d[0][0:2] == 'xv'))\n sds = sorted((d[1] for d in device_map if d[0][0] == 's'))\n if nvme:\n # So far, this option applies to AWS only:\n # At the API call, an EBS volume needs to specify a device name\n # as '/dev/sd[f-p] but Ubuntu will register it as /dev/nvme* so\n # based on the number of already available nvme devices, figure\n # out the next API device ID. The process accounts for less than\n # six additional volumes being attached.\n potential_device_ids = ['f', 'g', 'h', 'i', 'j', 'k']\n lnd = '/dev/sd%s' % potential_device_ids[len(nvme) - 1]\n log.debug(\"Likely next attach device: %s\" % lnd)\n return (lnd,)\n elif vds:\n return (self._increment_device_id(vds[-1]),)\n elif xvds:\n return (self._increment_device_id(xvds[-1]),)\n elif sds:\n return (self._increment_device_id(sds[-1]), '/dev/vda', '/dev/xvda')\n else:\n log.error(\"Could not determine next available device from {0}\".format(\n devices))\n return None",
"def _get_next_sequence_number(self):\n cur = self._next_sequence_number\n self._next_sequence_number += 1\n return cur",
"def getNextItemID(self, arrow):\n nextItemID = None\n try:\n for gItem in self.parentWidget.scene.items():\n if not isinstance(gItem, DiagramItem):\n continue \n if gItem.hasInputs():\n if arrow == gItem.getInput(0):\n nextItemID = gItem.itemId\n break\n except Exception as e:\n print(\"error on get next item ID: %s\" % e)\n \n return nextItemID",
"def next_id(arr):\n for x in range(len(arr) + 1):\n if x not in arr:\n return x",
"def _next_id(self):\n # modulo to keep within int32 (signed)\n self.correlation_id = (self.correlation_id + 1) % 2**31\n return self.correlation_id",
"def _next_rId(self):\n tmpl = 'rId%d'\n next_rId_num = 1\n for relationship in self._values:\n if relationship._num > next_rId_num:\n return tmpl % next_rId_num\n next_rId_num += 1\n return tmpl % next_rId_num",
"def next(self):\n if self.has_next:\n next_id = self.page + 1\n if self._cached_next and self._cached_next.id == next_id:\n return self._cached_next\n self._cached_next = Page(next_id)\n return self._cached_next",
"def next_link(self) -> str:\n return pulumi.get(self, \"next_link\")",
"def __generate_reports__(self,configs,mockdb):\n sample_keys = self.__completed_samples_list__(mockdb)\n n = len(sample_keys)\n numbers = configs['pipeline'].get('Flowcell_reports','numbers').split(',')\n numbers.sort(key=int,reverse=True)\n flowcell = mockdb['Flowcell'].__get__(configs['system'],key=self.flowcell_key)\n for number in numbers:\n if n >= int(number):\n if getattr(self,'flowcell_report_' + str(number) + '_key') is None:\n report = mockdb['FlowcellStatisticReport'].__new__(configs['system'],sample_keys=sample_keys,flowcell=flowcell,number=number,base_output_dir=self.base_output_dir)\n report.__fill_qsub_file__(configs)\n report.__launch__(configs['system'])\n setattr(self,'flowcell_report_' + str(number) + '_key',report.key)\n return True\n return False\n return False",
"def _run_next(self):\n result = False\n if not self._stopped.is_set():\n schedule = self._schedules[self._index]\n schedule.run(self._eventbus)\n self._index += 1\n if self._index < len(self._schedules):\n result = True\n return result",
"def get_next_serial(self):\n T = time.gmtime()\n base = T[0] * 10000 + T[1] * 100 + T[2]\n s_base = self.serial // 100\n if s_base < base:\n return base * 100 # New day\n else:\n return self.serial + 1 # May cause future lap",
"def next_invoice_number(cls, user):\n cur_max = cls.query.filter_by(user_id=user.id).count()\n cur_max += 1\n\n return str(cur_max)",
"def _next_request_id(self):\n self._request_id += 1\n return str(self._request_id)",
"def next_page(self):\n\n\t\tif not self.is_paginated:\n\t\t\traise PaginationError(\"The response is not paginated.\")\n\n\t\tif self.current_page >= self.max_page:\n\t\t\treturn False\n\n\t\tnext_request = self.__prepare_request(self.current_page + 1)\n\t\tself.__response = self.__session.send(next_request)\n\n\t\tself.__refresh()\n\t\treturn True",
"def get_next_statement_id(self):\n self._stmt_counter += 1\n return self._stmt_counter",
"def next(self):\n res = self._cursor.fetchone()\n if res:\n self.id = res[0]\n self.book = res[1]\n self.pos = res[2]\n self.content = res[3]\n return True\n\n return False",
"def load_next_posting_id():\n if os.path.exists(\"next_posting_id.txt\"):\n f = file(\"next_posting_id.txt\", \"r\")\n s = f.read().strip()\n f.close()\n try:\n return int(s)\n except ValueError:\n return None\n else:\n return None",
"def next_page(self):\n return self._next_page",
"def next_page(self):\n return self._next_page",
"def check_first_task(self, robot_id): \n individual_buffer = self.all_buffers[robot_id]\n return individual_buffer[-1]",
"def update_next_id(cls):\n cls.next_id += 1",
"def alloc_docid(self):\n self.docid = hex(self.client.incr(self.dbprefix + 'nextid'))[2:]\n return self.docid",
"def if_next(self, **kwargs):\n\n if kwargs.get('event') == 'next':\n logging.debug(u\"- asked to move to next step\")\n return True\n\n return False",
"def get_next_batch_start(self):\n return None",
"def test_get_report_key():\n key = _get_report_key()\n assert key == 'spi-reports/SPI Report 2018-03-01 010203.csv'",
"def _get_next_page(questionnaire, page):\n pages = PageDB(questionnaire).get_pages()\n i = 0\n nr_of_pages = PageDB(questionnaire).get_nr_of_pages()\n while i < nr_of_pages - 1 and pages[i].id <= page.id:\n i += 1\n next_page = pages[i]\n return next_page",
"def _next_yymm_id(self, identifier: Identifier) -> Optional[Identifier]:\n next_yymm_id = None\n if identifier.year is not None and \\\n identifier.month is not None:\n new_year = identifier.year\n new_month = identifier.month + 1\n new_num = 1\n if new_month > 12:\n new_month = 1\n new_year = new_year + 1\n if identifier.is_old_id:\n next_yymm_id = '{}/{:02d}{:02d}{:03d}'.format(\n identifier.archive, new_year % 100, new_month, new_num)\n elif new_year >= 2015:\n next_yymm_id = '{:02d}{:02d}.{:05d}'.format(\n new_year % 100, new_month, new_num)\n else:\n next_yymm_id = '{:02d}{:02d}.{:04d}'.format(\n new_year % 100, new_month, new_num)\n\n try:\n return Identifier(arxiv_id=next_yymm_id)\n except IdentifierException:\n return None\n else:\n return None",
"def _scrape_next_results_page_link(self, response):\n next_pages = response.xpath('//*[@id=\"pagnNextLink\"]/@href |'\n '//ul[contains(@class, \"a-pagination\")]'\n '/a[contains(text(), \"eiter\")]/@href').extract()\n next_page_url = None\n\n if len(next_pages) == 1:\n next_page_url = next_pages[0]\n elif len(next_pages) > 1:\n self.log(\"Found more than one 'next page' link.\", ERROR)\n\n return next_page_url",
"def test_nonIntegerUIDNEXT(self):\n d = self._examineOrSelect()\n self._response(b'* OK [UIDNEXT foo] Predicted next UID')\n self.failureResultOf(d, imap4.IllegalServerResponse)",
"def get_next_page(url):\n match = re.search(r\".*/(\\d+)_p/\", url)\n if match:\n next_number = int(match.group(1)) + 1\n next_url = urljoin(BEGIN_RENT_LISTINGS, f\"{next_number}_p/\")\n return next_url\n else:\n # the first page has no page index\n return urljoin(BEGIN_RENT_LISTINGS, \"2_p/\")",
"def find_next_page(self, soup: BeautifulSoup) -> Optional[str]:\n try:\n next_page = (\n f\"https://www.airbnb.com{soup.find('a', class_='_za9j7e')['href']}\"\n )\n except (TypeError, KeyError):\n next_page = None\n return next_page",
"def test_get_next_submission(self):\r\n\r\n # Setup the peer grading module with the proper linked location.\r\n peer_grading = self._create_peer_grading_with_linked_problem(self.coe_location)\r\n\r\n data = peer_grading.handle_ajax('get_next_submission', {'location': self.coe_location})\r\n self.assertEqual(json.loads(data)['submission_id'], 1)",
"def next_collapsed_id(self):\n to_return = self.collapsed_id_counter\n self.collapsed_id_counter += 1\n return to_return",
"def get_first_page(self):\n return 1"
] | [
"0.62095916",
"0.6153769",
"0.5885677",
"0.5764439",
"0.573282",
"0.56805384",
"0.5647685",
"0.5569167",
"0.5534752",
"0.55111814",
"0.5475925",
"0.5458879",
"0.5441728",
"0.5426077",
"0.5425727",
"0.5425234",
"0.5410581",
"0.5389253",
"0.5372817",
"0.5361491",
"0.5344166",
"0.5321446",
"0.5319763",
"0.5315735",
"0.5304939",
"0.528354",
"0.5280848",
"0.5275618",
"0.52754176",
"0.52722824",
"0.52658355",
"0.5258016",
"0.52526027",
"0.52019644",
"0.5181729",
"0.5181729",
"0.51435924",
"0.5131794",
"0.5126976",
"0.5113219",
"0.5087844",
"0.5079623",
"0.5022558",
"0.5021146",
"0.5016727",
"0.50098515",
"0.5002984",
"0.50003797",
"0.49599537",
"0.49515292",
"0.49501067",
"0.49501067",
"0.49493992",
"0.49429473",
"0.49399775",
"0.49382427",
"0.49382427",
"0.49382427",
"0.4934979",
"0.4928293",
"0.49218947",
"0.49182963",
"0.49102405",
"0.49038762",
"0.48836544",
"0.4881606",
"0.4880399",
"0.4875053",
"0.48662248",
"0.48635823",
"0.4854802",
"0.48546857",
"0.48537788",
"0.4850962",
"0.48509237",
"0.48419547",
"0.48296183",
"0.48259228",
"0.48233697",
"0.48233083",
"0.48216397",
"0.48215812",
"0.48136017",
"0.48107138",
"0.48107138",
"0.479452",
"0.47835332",
"0.4783353",
"0.47817448",
"0.47743878",
"0.47730604",
"0.47532436",
"0.47523338",
"0.47483847",
"0.4740908",
"0.47296765",
"0.47282237",
"0.47282022",
"0.4722092",
"0.4722082"
] | 0.8004583 | 0 |
Get previous report ID or False if not available | def previous_id(self):
try:
return Report.objects.filter(id__lt=self.id).order_by("-id").first().id
except Exception:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next_id(self):\n try:\n return Report.objects.filter(id__gt=self.id).order_by(\"id\").first().id\n except Exception:\n return False",
"def get_report_id(self, reports):\n matching_reports = [\n report for report in reports if report.get('title') in [\n self.api_report_id,\n self.api_test_report_id\n ]\n ]\n\n if self.electiondate: # Can also use the explicit 'if is not none'.\n matching_reports = [\n report for report in matching_reports\n if report.get('electionDate') == self.electiondate\n ]\n\n if matching_reports:\n id = matching_reports[0].get('id').rsplit('/', 1)[-1]\n return id\n\n return None",
"def latest_report_id(self) -> str:\n return pulumi.get(self, \"latest_report_id\")",
"def _get_report_id(self):\n report_id = ''\n if self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_BODY_REPORT) \\\n and 'payment' in self._report_data:\n report_id = self._report_data['payment']['invoiceId']\n elif self._report_key == ReportTypes.MHR_REGISTRATION and self._report_data.get('mhrNumber'):\n report_id = self._report_data.get('mhrNumber')\n return report_id",
"def has_report(self):\n return self.report is not None",
"def ParentReportNumber(self, default=None):\n return self.data.get('parent_report_number', default)",
"def ParentReportNumber(self, default=None):\n return self.data.get('parent_report_number', default)",
"def _previous_id(self, identifier: Identifier) -> Optional['Identifier']:\n previous_id = None\n if identifier.year is not None and \\\n identifier.month is not None and \\\n identifier.num is not None:\n new_year = identifier.year\n new_month = identifier.month\n new_num = identifier.num - 1\n if new_num == 0:\n new_month = new_month - 1\n if new_month == 0:\n new_month = 12\n new_year = new_year - 1\n\n if identifier.is_old_id:\n if new_num == 0:\n new_num = 999\n previous_id = '{}/{:02d}{:02d}{:03d}'.format(\n identifier.archive, new_year % 100, new_month, new_num)\n else:\n if new_year >= 2015:\n if new_num == 0:\n new_num = 99999\n previous_id = '{:02d}{:02d}.{:05d}'.format(\n new_year % 100, new_month, new_num)\n else:\n if new_num == 0:\n new_num = 9999\n previous_id = '{:02d}{:02d}.{:04d}'.format(\n new_year % 100, new_month, new_num)\n try:\n return Identifier(arxiv_id=previous_id)\n except IdentifierException:\n return None\n else:\n return None",
"def _get_existing_report(self, mask, report):\r\n for existing_report in self._reports:\r\n if existing_report['namespace'] == report['namespace']:\r\n if mask == existing_report['queryMask']:\r\n return existing_report\r\n return None",
"def _get_existing_report(self, mask, report):\n for existing_report in self._reports:\n if existing_report['namespace'] == report['namespace']:\n if mask == existing_report['queryMask']:\n return existing_report\n return None",
"def PAID(self):\n if self.session.get('last_bill_result', None) is None:\n return False\n return self.session['last_bill_result'] == \"\"",
"def get_report_file_name(self):\n if os.path.isfile(self.REPORT_FILE_PATH):\n print(\"'{}' is already exist!\".format(self.REPORT_FILE_PATH))\n report_file = self.prompt_report_file_name()\n else:\n report_file = self.REPORT_FILE_PATH\n return report_file",
"def last_known_position(self):\n try:\n last_filed = self.report_set.filter(zombies_only=False)\n last_filed = last_filed.order_by('-reported_date')[0]\n except IndexError:\n last_filed = None\n try:\n last_spotted = self.reported_at.order_by('-reported_date')[0]\n except IndexError:\n last_spotted = None\n if last_filed is None and last_spotted is None:\n return u\"Never seen\"\n else:\n if last_filed is None:\n return last_spotted\n elif last_spotted is None:\n return last_filed\n else:\n if last_filed.reported_date >= last_spotted.reported_date:\n return last_filed\n else:\n return last_spotted",
"def has_stockrecords(self):\n try:\n a=self.stockrecords.pk\n return True\n except:\n return False",
"def has_previous(self):\n return self.current_page > 1",
"def has_previous(self):\n return self.page > 1",
"def IsLocalRerun(self):\n return self.prev_test_run_key is not None",
"def get_previous_id(identifier: Identifier) -> Optional[Identifier]:\n return current_session().get_previous_id(identifier)",
"def report_shared(self, reportid):\r\n return reports.ReportsShared(self, reportid)",
"def __test_gen_report_id_check():\n # all fresh\n report = dp.Report(md_block, md_block, md_block)\n assert_report(report) # expected_id_count=5)\n # 2 fresh\n report = dp.Report(md_block, md_block_id, md_block)\n assert_report(report) # expected_id_count=4)\n # 0 fresh\n report = dp.Report(md_block_id, dp.Text(\"test\", name=\"test-2\"))\n assert_report(report) # expected_id_count=2)",
"def test_get_report_file_id(self):\n vt_analyses = VirusTotalAPIAnalyses('test_api_key')\n vt_analyses.get_report('test_object_id')\n http_err = vt_analyses.get_last_http_error()\n self.assertEqual(http_err, vt_analyses.HTTP_OK)",
"def update_report_history(self, request_result):\n report_info = request_result.get('ReportInfo', {})\n report_request_info = request_result.get('ReportRequestInfo', {})\n request_id = report_state = report_id = False\n if report_request_info:\n request_id = str(report_request_info.get('ReportRequestId', {}).get('value', ''))\n report_state = report_request_info.get('ReportProcessingStatus', {}).get('value',\n '_SUBMITTED_')\n report_id = report_request_info.get('GeneratedReportId', {}).get('value', False)\n elif report_info:\n report_id = report_info.get('ReportId', {}).get('value', False)\n request_id = report_info.get('ReportRequestId', {}).get('value', False)\n\n if report_state == '_DONE_' and not report_id:\n self.get_report_list()\n vals = {}\n if not self.report_request_id and request_id:\n vals.update({'report_request_id': request_id})\n if report_state:\n vals.update({'state': report_state})\n if report_id:\n vals.update({'report_id': report_id})\n self.write(vals)\n return True",
"def generate_report(self):\n if self.submission_metadata:\n return self._submission_allowed()[1]",
"def find_issue_id(self):",
"def _is_last_dataset_id(self, instance_id):\n res = self._db.Query(\"\"\"SELECT report_data_set_instance_id\n FROM report_data_set_instance\n WHERE\n `element_id`=%s\n AND `segment_value_id` = %s\n ORDER BY measurement_time DESC\n LIMIT 0, 1\"\"\",(self._id, self._segment_value_id))\n if not res:\n return False\n last_data_set_instance = self._db.record[0]\n if last_data_set_instance['report_data_set_instance_id'] == instance_id:\n return True\n\n return False",
"def ReporterReference(pidofreporter):\n try:\n pid_list = []\n Mcafee_Reporter_pid = getpid(pidofreporter)\n print \"Now\",Mcafee_Reporter_pid\n listofpid = list(Mcafee_Reporter_pid)\n pid_list.append(listofpid[1])\n split_pids_by_space = [words for segments in pid_list for words in segments.split()]\n print \"split_pids_by_space\", split_pids_by_space\n reporter_current_pid = int(''.join(map(str,split_pids_by_space[1])))\n print \"reporter_current_pid\", reporter_current_pid\n Mcafee_Reporter_Reference = getAppRefByPidofapp(reporter_current_pid)\n #print \"Mcafee_Reporter_Reference\", Mcafee_Reporter_Reference\n except Exception as er:\n return False\n print \"Not able to get Reporter details\"\n print Mcafee_Reporter_Reference\n return Mcafee_Reporter_Reference",
"def get_last_worked_on_step_id(self):\n logger.debug(\"Searching for ID of the step last worked on.\")\n last_id = None\n for step in self.steps:\n if any((task for task in step.tasks if task.status == \"DONE\")) and (not last_id or step.id > last_id):\n last_id = step.id\n if not last_id:\n raise ValueError(\"No ID is found for last worked on step for ticket {}\".format(self.id))\n return last_id",
"def is_retired(self):\n if str.__str__(self) in UID_dictionary:\n return bool(UID_dictionary[self][3])\n\n return False",
"def get_already_raised(self):\r\n return self.already_raised",
"def reported_by(self, user):\n return Report.objects.filter(recipe=self, chef=user).exists()",
"def get_previous_id(self, identifier: Identifier) -> Optional[Identifier]:\n previous_id = self._previous_id(identifier)\n if not previous_id:\n return None\n\n if identifier.year == previous_id.year \\\n and identifier.month == previous_id.month:\n return previous_id\n\n path = self._get_parent_path(previous_id)\n if not os.path.exists(path):\n return None\n\n for _, _, file_list in os.walk(path):\n abs_files = [f[:-4] for f in file_list if f.endswith('.abs')]\n if not abs_files:\n return None\n max_id = max(abs_files)\n try:\n if previous_id.is_old_id:\n short_id = Identifier(\n arxiv_id=f'{previous_id.archive}/{max_id}')\n else:\n short_id = Identifier(arxiv_id=max_id)\n return short_id\n\n except IdentifierException:\n return None\n\n return None",
"def checkAlreadyOpened (self, path, remoteFile=False, repoType=None, project=0):\n # convert to int\n project = int(project)\n \n for tabId in xrange( self.tab.count() ):\n doc = self.tab.widget(tabId)\n # bypass the welcome page\n if isinstance(doc, WelcomePage):\n continue\n # end of bypass\n \n if project:\n if not remoteFile:\n if doc.isRemote == remoteFile and doc.getPath() == path \\\n and doc.repoDest==repoType:\n return tabId\n else:\n if doc.isRemote == remoteFile and doc.getPath() == path \\\n and doc.repoDest==repoType and doc.project==project:\n return tabId\n else:\n if doc.isRemote == remoteFile and doc.getPath() == path \\\n and doc.repoDest==repoType :\n return tabId\n return None",
"def load(self, date):\n report = ndb_data.ReportProperty.query(\n ndb_data.ReportProperty.date == date).get()\n if not report:\n logging.info('Report not found (date %s)', date)\n return False\n self._report = report\n return True",
"def find_last_wp_report(self, wp_report):\n last_wp_report = [r for r in self._data if r[\"site\"] == wp_report[\"site\"]]\n if len(last_wp_report) > 0:\n last_wp_report = last_wp_report[0]\n else:\n last_wp_report = None\n return last_wp_report",
"def previous(self):\n resp = yield from self.command('previous')\n return True",
"def has_prev(self):\n return self.page > 1",
"def has_prev(self):\n return self.page > 1",
"def previous_page(self):\n\n\t\tif not self.is_paginated:\n\t\t\traise PaginationError(\"The response is not paginated.\")\n\n\t\tif self.current_page <= 1:\n\t\t\treturn False\n\n\t\tnext_request = self.__prepare_request(self.current_page - 1)\n\t\tself.__response = self.__session.send(next_request)\n\t\tself.__refresh()\n\t\treturn True",
"def checkreport(planid, stamp):\n try:\n plan = Plan.objects.get(pk=planid)\n except:\n return 'error'\n\n tempdir = settings.REPORTS_ROOT\n filename = '%s_p%d_v%d_%s' % (plan.owner.username, plan.id,\n plan.version, stamp)\n pending_file = '%s/%s.pending' % (tempdir, filename)\n complete_file = '%s/%s.html' % (tempdir, filename)\n\n if os.path.exists(complete_file):\n if os.path.exists(pending_file):\n os.unlink(pending_file)\n return 'ready'\n\n if os.path.exists(pending_file):\n return 'busy'\n\n return 'free'",
"def test_report_id_not_found(self) -> None:\n\n channel = self.make_request(\n \"GET\",\n \"/_synapse/admin/v1/event_reports/123\",\n access_token=self.admin_user_tok,\n )\n\n self.assertEqual(404, channel.code, msg=channel.json_body)\n self.assertEqual(Codes.NOT_FOUND, channel.json_body[\"errcode\"])\n self.assertEqual(\"Event report not found\", channel.json_body[\"error\"])",
"def create_report(self, report_job: dict):\n try:\n # Run the report and wait for it to finish\n report_job_id = self.report_downloader.WaitForReport(report_job)\n return report_job_id\n except errors.AdManagerReportError as e:\n print('[INFO]: Failed to generate report. Error: %s' % e)\n sys.exit()",
"def IsRerun(self):\n return self.prev_test_context is not None",
"def _open_report(self):\n global last_report_path\n subprocess.Popen([last_report_path], shell=True)",
"def test_copy_report_uuid(self):\n report_copy = copy_report(self.report, self.DATA_MODEL)\n self.assertNotEqual(self.report[\"report_uuid\"], report_copy[\"report_uuid\"])",
"def get_previous_version(self):\n previous_study_version = self.source_dataset.source_study_version.get_previous_version()\n if previous_study_version is not None:\n try:\n previous_trait = SourceTrait.objects.get(\n source_dataset__source_study_version=previous_study_version,\n i_dbgap_variable_accession=self.i_dbgap_variable_accession\n )\n except SourceTrait.DoesNotExist:\n return None\n return previous_trait",
"def ready_to_export_transaction(self):\n try:\n SubjectReferral = models.get_model('bcpp_subject', 'subjectreferral')\n subject_referral = SubjectReferral.objects.get(subject_visit=self.subject_visit)\n if subject_referral.referral_code:\n return True\n except SubjectReferral.DoesNotExist:\n pass\n return False",
"def exists(request_handler, name) -> bool:\n data = request_handler.make_request(\n 'GET',\n '/reports'\n )\n for item in data:\n if item['reportName'] == name:\n return True\n return False",
"def reset_reports(reportid):\n _do_reset(reportid)\n return _get_report(reportid)",
"def test_import_is_skipped(self):\n self.database.reports.distinct.return_value = [\"id\"]\n self.import_report(self.report_json)\n self.database.reports.insert_one.assert_not_called()",
"def ID(self):\n if hasattr(self, 'currentID'):\n return self.currentID\n if hasattr(self, 'callDict'):\n thisID = hashIt(self.callDict)\n if hasattr(self, 'pastInfo'):\n self.pastInfo[thisID] = {'callDict': self.callDict}\n else:\n thisID = None\n self.currentID = thisID\n return thisID",
"def _cr(self):\n try:\n return self.__cr\n except AttributeError:\n self.__cr = False\n return False",
"def prompt_report_file_name(self):\n while True:\n report_file = input(\"Enter name for your report file: \")\n if os.path.isfile(report_file):\n print(\"'{}' is already exist!\".format(report_file))\n else:\n break\n return report_file",
"def reference_id(self) -> Optional[str]:\n return pulumi.get(self, \"reference_id\")",
"def latest_id(self):\n return self.checkpoints[-1]",
"def get_current_record_id(self):\n url = self.selenium.get_location()\n for part in url.split(\"/\"):\n oid_match = re.match(OID_REGEX, part)\n if oid_match is not None:\n return oid_match.group(2)\n raise AssertionError(\"Could not parse record id from url: {}\".format(url))",
"def test_initializer_preexisting_report(self):\n saver = ReportStatsDBAccessor(\"myreport\", self.manifest_id)\n saver.update(\n cursor_position=33,\n last_completed_datetime=\"2011-1-1 11:11:11\",\n last_started_datetime=\"2022-2-2 22:22:22\",\n etag=\"myetag\",\n )\n\n self.assertIsNotNone(saver._obj)\n\n # Get another accessor for the same report and verify we get back the right information.\n saver2 = ReportStatsDBAccessor(\"myreport\", self.manifest_id)\n last_completed = saver2.get_last_completed_datetime()\n\n self.assertEqual(last_completed.year, 2011)\n self.assertEqual(last_completed.month, 1)\n self.assertEqual(last_completed.day, 1)\n self.assertEqual(last_completed.hour, 11)\n self.assertEqual(last_completed.minute, 11)\n self.assertEqual(last_completed.second, 11)\n\n self.assertEqual(saver.get_etag(), \"myetag\")",
"def identifier(self):\n ident = self._json['coredata']['dc:identifier'].split(\":\")[-1]\n if ident != self._id:\n text = \"Profile with ID {} has been merged and the new ID is \"\\\n \"{}. Please update your records manually. Files have \"\\\n \"been cached with the old ID.\".format(self._id, ident)\n warn(text, UserWarning)\n return ident",
"def nextId(self):\r\n \r\n nextId = -1\r\n if self._wizard.currentId() == SOURCE_PAGE_ID:\r\n nextId = TARGET_PAGE_ID\r\n elif self._wizard.currentId() == TARGET_PAGE_ID:\r\n nextId = DATASTORE_PAGE_ID\r\n elif self._wizard.currentId() == DATASTORE_PAGE_ID:\r\n nextId = PROPERTY_PAGE_ID\r\n return nextId",
"def test_get_report_key():\n key = _get_report_key()\n assert key == 'spi-reports/SPI Report 2018-03-01 010203.csv'",
"def getPreviousElement(self,currentId):\n\tids = self.getObjectIds()\n\tpreviousId = None\n\tfor id in ids:\n\t if id == currentId:\n\t\treturn previousId\n\t else:\n\t\tpreviousId = id\n\treturn None",
"def get_oeid(self, cr, uid, external_id, referential_id, context=None):\n if external_id:\n ir_model_data_id, expected_oe_id = self._get_expected_oeid\\\n (cr, uid, external_id, referential_id, context=context)\n # Note: OpenERP cleans up ir_model_data which res_id records have been deleted\n # only at server update because that would be a perf penalty, we returns the res_id only if\n # really existing and we delete the ir_model_data unused\n if expected_oe_id and self.exists(cr, uid, expected_oe_id, context=context):\n return expected_oe_id\n return False",
"def _get_last_exported_date(self, cr, uid, external_session, context=None):\n return False",
"def Refereed(self, default=None):\n return self.data.get('metadata', {}).get('refereed', default)",
"def id(self):\n\t\tif self._record is not None:\n\t\t return self._record.id\n\t\telse:\n\t\t return \"NO_ID_ASSIGNED\"",
"def GetReportString(self):\n return _gmat_py.LocatedEvent_GetReportString(self)",
"def has_receipt_id(self):\n return self.receipt_id_uploaded_at is not None",
"def previous_step_result(self):\n return self._previous_step_result",
"def previous_question(self, id):\n\t\tif id > 0:\n\t\t\treturn self.questions[id-1]\n\t\telse:\n\t\t\treturn None",
"def is_already_linked(ticket_id):\n exists_query = db.session.query(\n all_models.IssuetrackerIssue.issue_id\n ).filter_by(issue_id=ticket_id).exists()\n return db.session.query(exists_query).scalar()",
"def _get_response_id(self, response):\n if response.url in self._response_id_cache:\n return self._response_id_cache[response.url]\n else:\n response_id = str(uuid.uuid4())\n self._response_id_cache[response.url] = response_id\n return response_id",
"def isCurrent(element):\n rr = element.find(\"RecordStatus\")\n if rr == None:\n return False\n else:\n return(rr.text == \"current\")",
"def getOldestReportDate(report_type=choices.INCOMING):\n date_qs = Report.objects.order_by(\"date_range_begin\"\n ).filter(report_type=report_type\n ).values(\"date_range_begin\"\n ).first()\n\n if date_qs:\n return date_qs[\"date_range_begin\"]\n\n else:\n return None",
"def recording(self) -> bool:\n\t\treturn self._raw_result['data']['recording']",
"def is_oldest_report_expired(self, token: str) -> list:\n token_address = self.registry.registry.functions.getAddressForString(token).call()\n\n return self._contract.functions.isOldestReportExpired(token_address).call()",
"def _last_roll_revision(self):\n if not self._cached_last_roll_revision:\n revinfo = subprocess2.check_output(['gclient', 'revinfo'],\n cwd=self._path_to_chrome)\n project_path = 'src/' + self._path_to_project\n for line in revinfo.splitlines():\n dep_path, source = line.split(': ', 1)\n if dep_path == project_path:\n self._cached_last_roll_revision = source.split('@')[-1]\n break\n assert len(self._cached_last_roll_revision) == 40\n return self._cached_last_roll_revision",
"def get_track_number(self) -> Optional[int]:\n return self.track_number",
"def active_result(self):\n return self.step_client.previous_step_result()",
"def report_public(self, reportid):\r\n return reports.ReportsPublic(self, reportid)",
"def test_get_report_wrong_object_id(self):\n vt_analyses = VirusTotalAPIAnalyses('test_api_key')\n vt_analyses.get_report('test_object_id')\n http_err = vt_analyses.get_last_http_error()\n self.assertEqual(http_err, vt_analyses.HTTP_NOT_FOUND_ERROR)",
"def getPreviousBuild():",
"def _get_last_read_id():\n webservice_url_initial = 'http://' + host_cmr + ':' + str(host_cmr_port) + '/rest/data/invocations/overview?latestReadId=' \\\n + str(MaxIdInDB[0])\n\n print('Web Service Url Initial for Last Read id is ', webservice_url_initial)\n response_summary = requests.get(webservice_url_initial)\n\n data = response_summary.json()\n df = pd.DataFrame(json_normalize(data))\n lastreadid_max = df[['id']].max()\n lastreadid_min = df[['id']].min()\n print('Last Read id VALUE in apm is ', lastreadid_max['id'])\n print('the min id VALUE in apm this json ', lastreadid_min['id'])\n\n if int(lastreadid_max) >= MaxIdInDB[0]:\n print(\"Send data to influx and MaxIDINDB[0] is from \", MaxIdInDB[0], ' to LastReadId:', int(lastreadid_max))\n a = lastreadid_max['id']\n print('a is ', a)\n return a\n time.sleep(1)",
"def exists(self):\n\n return self.ids[-1] is not None",
"def get_current_id(self):\n\n id = self.ids[-1]\n\n if id is None:\n raise KeyError()\n\n return id",
"def new_trip_report_builder(df,last_scrape):\n count = 0\n for row in range(len(df)):\n if df['numReports'][row]:\n title = df['hike_name'][row]\n url = df['url'][row]\n iterate_new_reports(title, url,last_scrape)\n count += 1\n print(f'Unique Trails {count}')\n else:\n continue\n return None",
"def previous(self):\n if self.has_previous:\n previous_id = self.page - 1\n if self._cached_previous and self._cached_previous.id == previous_id:\n return self._cached_previous\n self._cached_previous = Page(previous_id)\n return self._cached_previous",
"def get_report(self, talkid):\r\n result = QtSql.QSqlQuery('''SELECT * FROM failures WHERE Id = \"%s\"''' % talkid)\r\n if result.next():\r\n failure = Failure(unicode(result.value(0).toString()), # id\r\n unicode(result.value(1).toString()), # comment\r\n unicode(result.value(2).toString()), # indicator\r\n result.value(3).toBool()) # release\r\n else:\r\n failure = None\r\n return failure",
"def test_previous_result_returns_correct_menu(self):\n current_record_before = 1\n self.menu.current_record = current_record_before\n\n result = self.menu.previous_result()\n\n expected_result = self.menu.present_next_result\n\n self.assertEqual(result, expected_result)",
"def _create_skipped_report(self, context: dict) -> Tuple[dict, dict]:\n skipped_ids_report = {}\n saved_record_ids = {}\n dagrun = context['ti'].get_dagrun()\n task_instances = dagrun.get_task_instances()\n for task in task_instances:\n task_skipped_ids = context[\"ti\"].xcom_pull(key=\"skipped_ids\", task_ids=task.task_id)\n if task_skipped_ids:\n skipped_ids_report[task.task_id] = task_skipped_ids\n\n for task in task_instances:\n task_saved_ids = context[\"ti\"].xcom_pull(key=\"record_ids\", task_ids=task.task_id)\n if task_saved_ids:\n saved_record_ids[task.task_id] = task_saved_ids\n return skipped_ids_report, saved_record_ids",
"def get_changed() -> bool:\n return g.ledger.changed()",
"def PreviousApplicationIdentity(self) -> _n_0_t_2:",
"def test_invalid_report_id(self) -> None:\n\n # `report_id` is negative\n channel = self.make_request(\n \"GET\",\n \"/_synapse/admin/v1/event_reports/-123\",\n access_token=self.admin_user_tok,\n )\n\n self.assertEqual(400, channel.code, msg=channel.json_body)\n self.assertEqual(Codes.INVALID_PARAM, channel.json_body[\"errcode\"])\n self.assertEqual(\n \"The report_id parameter must be a string representing a positive integer.\",\n channel.json_body[\"error\"],\n )\n\n # `report_id` is a non-numerical string\n channel = self.make_request(\n \"GET\",\n \"/_synapse/admin/v1/event_reports/abcdef\",\n access_token=self.admin_user_tok,\n )\n\n self.assertEqual(400, channel.code, msg=channel.json_body)\n self.assertEqual(Codes.INVALID_PARAM, channel.json_body[\"errcode\"])\n self.assertEqual(\n \"The report_id parameter must be a string representing a positive integer.\",\n channel.json_body[\"error\"],\n )\n\n # `report_id` is undefined\n channel = self.make_request(\n \"GET\",\n \"/_synapse/admin/v1/event_reports/\",\n access_token=self.admin_user_tok,\n )\n\n self.assertEqual(400, channel.code, msg=channel.json_body)\n self.assertEqual(Codes.INVALID_PARAM, channel.json_body[\"errcode\"])\n self.assertEqual(\n \"The report_id parameter must be a string representing a positive integer.\",\n channel.json_body[\"error\"],\n )",
"def prev(self):\n return bool(self._ll_tree.prev())",
"def _get_default_mo_id(self, cr, uid, context=None):\n context = context or {}\n wol_obj = self.pool.get('mrp.workorder.lot')\n res = False\n active_id = context.get('active_id', False)\n active_model = context.get('active_model', False)\n if active_id:\n if active_model == 'mrp.production':\n res = active_id\n elif active_model == 'mrp.workorder.lot':\n res = wol_obj.browse(\n cr, uid, active_id, context=context).production_id.id\n else:\n raise osv.except_osv(\n _('Error!!'),\n _('This wizard only can be call from the manufacturing'\n ' order form or the Work Orders by Active Lot menu.'))\n return res",
"def _get_default_mo_id(self, cr, uid, context=None):\n context = context or {}\n wol_obj = self.pool.get('mrp.workorder.lot')\n res = False\n active_id = context.get('active_id', False)\n active_model = context.get('active_model', False)\n if active_id:\n if active_model == 'mrp.production':\n res = active_id\n elif active_model == 'mrp.workorder.lot':\n res = wol_obj.browse(\n cr, uid, active_id, context=context).production_id.id\n else:\n raise osv.except_osv(\n _('Error!!'),\n _('This wizard only can be call from the manufacturing'\n ' order form or the Work Orders by Active Lot menu.'))\n return res",
"def check_rpt_status(self) -> bool:\n return self.allele == self.fasta_alt",
"def get_ident():\n return -1",
"def get_tracks_rel_frame_num(track, frame_num):\n \n if track['first_frame'] > frame_num or track['last_frame'] < frame_num:\n # track is not in current frame\n return False\n \n rel_frame_num = frame_num - track['first_frame']\n \n return rel_frame_num",
"def test_report_id_not_found(self) -> None:\n\n channel = self.make_request(\n \"DELETE\",\n \"/_synapse/admin/v1/event_reports/123\",\n access_token=self.admin_user_tok,\n )\n\n self.assertEqual(404, channel.code, msg=channel.json_body)\n self.assertEqual(Codes.NOT_FOUND, channel.json_body[\"errcode\"])\n self.assertEqual(\"Event report not found\", channel.json_body[\"error\"])",
"def get_or_create_extid(self, cr, uid, external_session, openerp_id, context=None):\n res = self.get_extid(cr, uid, openerp_id, external_session.referential_id.id, context=context)\n if res is not False:\n return res\n else:\n external_session.logger.info(('Missing external resource for object %s'\n ' with openerp id %s. Exporting on the fly')%(self._name, openerp_id))\n return self._export_one_resource(cr, uid, external_session, openerp_id, context=context)",
"def get_current_reference_id():\n with database.make_connection() as connection:\n return r.table('references').get(\"current_reference\").run(connection)[\"reference_id\"]"
] | [
"0.69261867",
"0.6367051",
"0.6234315",
"0.61751926",
"0.600833",
"0.5732639",
"0.5732639",
"0.5496686",
"0.54920655",
"0.5474516",
"0.5460659",
"0.5322554",
"0.5255835",
"0.52374005",
"0.519327",
"0.5184205",
"0.516578",
"0.5152253",
"0.51465",
"0.51069415",
"0.5098686",
"0.5068081",
"0.5060786",
"0.5055873",
"0.5053999",
"0.5050696",
"0.50506514",
"0.50493175",
"0.5011197",
"0.50044596",
"0.4998699",
"0.49786976",
"0.49622738",
"0.4952714",
"0.4948655",
"0.49422085",
"0.49422085",
"0.48739913",
"0.48367584",
"0.48312545",
"0.4825689",
"0.4816292",
"0.48127592",
"0.48084334",
"0.48082045",
"0.4806054",
"0.4804129",
"0.47989166",
"0.47884336",
"0.4787706",
"0.4786199",
"0.4778625",
"0.4777756",
"0.47737375",
"0.47696072",
"0.47665963",
"0.47557473",
"0.47555694",
"0.47524476",
"0.47407243",
"0.4721616",
"0.47212723",
"0.47167486",
"0.47128803",
"0.47084233",
"0.47074386",
"0.47071925",
"0.46958995",
"0.4693298",
"0.46855935",
"0.46802682",
"0.46748897",
"0.46717113",
"0.46677595",
"0.46653292",
"0.4663149",
"0.4661295",
"0.46438143",
"0.4633105",
"0.46282804",
"0.46279842",
"0.46236667",
"0.461679",
"0.46162942",
"0.46152756",
"0.46127906",
"0.4610538",
"0.46098772",
"0.4604022",
"0.46036",
"0.46029535",
"0.4600406",
"0.45996878",
"0.45996878",
"0.45959306",
"0.45942485",
"0.4591963",
"0.459044",
"0.45901412",
"0.45878637"
] | 0.76356864 | 0 |
Constructs HttpRequest from string containing an entire HTTP request | def deserialize(cls, data: bytes) -> HttpRequest:
try:
raw = data.decode("utf-8")
raw_headers, raw_body = raw.split("\r\n\r\n")
header_lines = raw_headers.split("\r\n")
method, path, protocol = header_lines[0].split()
headers = HttpRequest._parse_headers(header_lines[1:])
if "content-length" in headers:
body = raw_body.encode("utf-8")
else:
body = b""
return HttpRequest(method, path, headers, body)
except Exception as err:
raise exceptions.HttpRequestParsingException(
f"Failed to parse {data.decode('utf-8')}"
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_from_text(text):\n lines = text.splitlines()\n match = re.search('^([a-z]+) (.*) (http/[0-9]\\.[0-9])$', lines[0], re.I)\n method, path, version = match.groups()\n headers = {}\n for idx, line in enumerate(lines[1:], start=1):\n if not line:\n break\n hdr, val = [item.strip() for item in line.split(':', 1)]\n hdr = hdr.lower()\n vals = headers.setdefault(hdr, [])\n vals.append(val)\n headers = {hdr: ','.join(sorted(vals)) for hdr, vals in headers.items()}\n check_url = urlparse(path)\n if check_url.scheme and check_url.netloc:\n # absolute URL in path\n url = path\n else:\n # otherwise need to try to construct url from path and host header\n url = ''.join(['http://' if 'host' in headers else '',\n headers.get('host', ''),\n path])\n body = '\\n'.join(lines[idx+1:])\n req = requests.Request(method, url, headers=headers, data=body)\n return req.prepare()",
"def load_request_string(string, format=FORMAT_PEM):\n bio = BIO.MemoryBuffer(string)\n return load_request_bio(bio, format)",
"def parse_request(msg):\n start_line, header, body = _parse_message(msg)\n request, path = _parse_request_line(start_line)\n return Request(request, path, header, body)",
"def to_httpx_request(cls, **kwargs):\n request = kwargs[\"request\"]\n raw_url = (\n request.url.scheme,\n request.url.host,\n request.url.port,\n request.url.target,\n )\n return httpx.Request(\n request.method,\n parse_url(raw_url),\n headers=request.headers,\n stream=request.stream,\n extensions=request.extensions,\n )",
"def build_request(uri='/'):\r\n path, _, querystring = uri.partition('?')\r\n return WSGIRequest({\r\n 'CONTENT_TYPE': 'text/html; charset=utf-8',\r\n 'PATH_INFO': path,\r\n 'QUERY_STRING': querystring,\r\n 'REMOTE_ADDR': '127.0.0.1',\r\n 'REQUEST_METHOD': 'GET',\r\n 'SCRIPT_NAME': '',\r\n 'SERVER_NAME': 'testserver',\r\n 'SERVER_PORT': '80',\r\n 'SERVER_PROTOCOL': 'HTTP/1.1',\r\n 'wsgi.version': (1, 0),\r\n 'wsgi.url_scheme': 'http',\r\n 'wsgi.input': FakePayload(b''),\r\n 'wsgi.errors': six.StringIO(),\r\n 'wsgi.multiprocess': True,\r\n 'wsgi.multithread': False,\r\n 'wsgi.run_once': False,\r\n })",
"def request_factory(environ):\n request = Request(environ)\n _LOG.debug('trunctated request body: {b}'.format(b=request.body[:1000]))\n return request",
"def urllib_req_to_req(urllib_request):\n from ..networking import Request\n from ..utils.networking import HTTPHeaderDict\n return Request(\n urllib_request.get_full_url(), data=urllib_request.data, method=urllib_request.get_method(),\n headers=HTTPHeaderDict(urllib_request.headers, urllib_request.unredirected_hdrs),\n extensions={'timeout': urllib_request.timeout} if hasattr(urllib_request, 'timeout') else None)",
"def _GenHttpRequestProto(self):\n request = jobs_pb2.HttpRequest()\n request.source_ip = \"127.0.0.1\"\n request.user_agent = \"Firefox or something\"\n request.url = \"http://test.com/test?omg=11%45x%20%20\"\n request.user = \"anonymous\"\n request.timestamp = int(time.time() * 1e6)\n request.size = 1000\n return request",
"def make_request_message(request):\n url = urlparse(request.url)\n request_headers = dict(request.headers)\n if 'Host' not in request_headers:\n request_headers['Host'] = url.netloc\n return HTTPMessage(\n line='{method} {path} HTTP/1.1'.format(\n method=request.method,\n path=url.path or '/'),\n headers=NEW_LINE.join(str('%s: %s') % (name, value)\n for name, value\n in request_headers.items()),\n body=request._enc_data,\n content_type=request_headers.get('Content-Type')\n )",
"def build_request(url, headers, body, initial_request: Request) -> Request:\n updated_request = Request(\n method=initial_request.method,\n url=url,\n headers=headers,\n content=body\n )\n\n if hasattr(initial_request, 'extensions'):\n updated_request.extensions = initial_request.extensions\n\n return updated_request",
"def createRequest(test, url, headers=None):\n request = HTTPRequest(url=url)\n if headers: request.headers=headers\n test.record(request, HTTPRequest.getHttpMethodFilter())\n return request",
"def __call__(self, requestStr):\n return self.connection.Request(requestStr)",
"def parse_request(first_line):\n command = None # set in case of error on the first line\n request_version = version = default_request_version\n close_connection = 1\n path = \"\"\n requestline = first_line.rstrip('\\r\\n')\n words = requestline.split()\n if len(words) == 3:\n command, path, version = words\n if version[:5] != 'HTTP/':\n easyHandler.send_error(400, \"Bad request version (%r)\" % version)\n return False\n try:\n base_version_number = version.split('/', 1)[1]\n version_number = base_version_number.split(\".\")\n # RFC 2145 section 3.1 says there can be only one \".\" and\n # - major and minor numbers MUST be treated as\n # separate integers;\n # - HTTP/2.4 is a lower version than HTTP/2.13, which in\n # turn is lower than HTTP/12.3;\n # - Leading zeros MUST be ignored by recipients.\n if len(version_number) != 2:\n raise ValueError\n version_number = int(version_number[0]), int(version_number[1])\n except (ValueError, IndexError):\n easyHandler.send_error(400, \"Bad request version (%r)\" % version)\n return False\n if version_number >= (1, 1) and protocol_version >= \"HTTP/1.1\":\n close_connection = 0\n if version_number >= (2, 0):\n easyHandler.send_error(505,\n \"Invalid HTTP Version (%s)\" % base_version_number)\n return False\n elif len(words) == 2:\n command, path = words\n close_connection = 1\n if command != 'GET':\n easyHandler.send_error(400, \"Bad HTTP/0.9 request type (%r)\" % command)\n return False\n elif not words:\n return False\n else:\n easyHandler.send_error(400, \"Bad request syntax (%r)\" % requestline)\n return easyRequest(command, path, version)",
"def parse_http_request(source_addr, http_raw_data):\n r1 = http_raw_data.split('\\n')[0]\n method = r1.split()[0]\n path = r1.split()[1]\n if path == \"/\":\n r2 = http_raw_data.split('\\n')[1]\n host = r2.split()[0]\n if host == \"Host:\":\n host = re.sub(\"[:]\", \"\", host)\n r3 = r2.split(':')\n url = r2.split()[1]\n headers = []\n r3 = ' '.join(r3).replace('\\r', '').split()\n headers.append(r3)\n headers.append(url)\n headers\n requested_host = headers[0:]\n requested_path = path\n portno = re.findall(r'[0-9]+', r2)\n if portno == []:\n portno = \"80\"\n requested_port = portno\n requested_host = url\n print(\"*\" * 50)\n print(\"[parse_http_request] Implement me!\")\n print(\"*\" * 50)\n # Replace this line with the correct values.\n request_info = HttpRequestInfo(source_addr, method, requested_host, requested_port, requested_path, headers)\n return request_info",
"def parse_request(request: bytes) -> Tuple[RequestLineHeader, str]:\r\n\r\n request = request.decode('ascii')\r\n print(request)\r\n split_request = request.split('\\r\\n')\r\n method, path, http_version = split_request[0].split(' ')\r\n path = ROOT_DIR + ('index.html' if path == '/' else path[1:])\r\n args = split_request[-1] if method == 'POST' else ''\r\n\r\n return RequestLineHeader(method, path, http_version), args",
"def create(app, client_stream, client_addr, client_sock=None):\n # request line\n line = Request._safe_readline(client_stream).strip().decode()\n if not line:\n return None\n method, url, http_version = line.split()\n http_version = http_version.split('/', 1)[1]\n\n # headers\n headers = NoCaseDict()\n while True:\n line = Request._safe_readline(client_stream).strip().decode()\n if line == '':\n break\n header, value = line.split(':', 1)\n value = value.strip()\n headers[header] = value\n\n return Request(app, client_addr, method, url, http_version, headers,\n stream=client_stream, sock=client_sock)",
"def build_http_request(method: bytes, url: bytes,\n protocol_version: bytes = HTTP_1_1,\n headers: Optional[Dict[bytes, bytes]] = None,\n body: Optional[bytes] = None) -> bytes:\n if headers is None:\n headers = {}\n return build_http_pkt(\n [method, url, protocol_version], headers, body)",
"def _CreateRequest(self, url, data=None):\r\n logging.debug(\"Creating request for: '%s' with payload:\\n%s\", url, data)\r\n req = urllib2.Request(url, data=data, headers={\"Accept\": \"text/plain\"})\r\n if self.host_override:\r\n req.add_header(\"Host\", self.host_override)\r\n for key, value in self.extra_headers.iteritems():\r\n req.add_header(key, value)\r\n return req",
"def build_http_request(method: bytes, url: bytes,\n protocol_version: bytes = b'HTTP/1.1',\n headers: Optional[Dict[bytes, bytes]] = None,\n body: Optional[bytes] = None) -> bytes:\n if headers is None:\n headers = {}\n return build_http_pkt(\n [method, url, protocol_version], headers, body)",
"def from_json(json_string: str) -> AnalysisRequest:\n dict_obj = json.loads(json_string)\n\n # make sure the required parameters are present\n required_fields = [\"request_id\"]\n\n for field in required_fields:\n if field not in dict_obj:\n raise Exception(\"JSON string does not represent a DatasetRequest object. Missing \" + field)\n\n # create the object\n request_obj = AnalysisRequest(request_id=dict_obj[\"request_id\"])\n\n return request_obj",
"def parse_request(self):\r\n self.command = None # set in case of error on the first line\r\n self.request_version = version = self.default_request_version\r\n self.close_connection = 1\r\n requestline = self.raw_requestline\r\n # hack: quick and dirty fix for doubled request with bad data\r\n ok = 0\r\n if requestline.startswith(\"GET\"):\r\n ok += 1\r\n if requestline.startswith(\"POST\"):\r\n ok += 1\r\n if requestline.startswith(\"QUIT\"):\r\n ok += 1\r\n if ok == 0:\r\n return False\r\n # hack ends here\r\n requestline = requestline.rstrip('\\r\\n')\r\n self.requestline = requestline\r\n words = requestline.split()\r\n if len(words) == 3:\r\n command, path, version = words\r\n if version[:5] != 'HTTP/':\r\n self.send_error(400, \"Bad request version (%r)\" % version)\r\n return False\r\n try:\r\n base_version_number = version.split('/', 1)[1]\r\n version_number = base_version_number.split(\".\")\r\n # RFC 2145 section 3.1 says there can be only one \".\" and\r\n # - major and minor numbers MUST be treated as\r\n # separate integers;\r\n # - HTTP/2.4 is a lower version than HTTP/2.13, which in\r\n # turn is lower than HTTP/12.3;\r\n # - Leading zeros MUST be ignored by recipients.\r\n if len(version_number) != 2:\r\n raise ValueError\r\n version_number = int(version_number[0]), int(version_number[1])\r\n except (ValueError, IndexError):\r\n self.send_error(400, \"Bad request version (%r)\" % version)\r\n return False\r\n if version_number >= (1, 1) and self.protocol_version >= \"HTTP/1.1\":\r\n self.close_connection = 0\r\n if version_number >= (2, 0):\r\n self.send_error(505,\r\n \"Invalid HTTP Version (%s)\" % base_version_number)\r\n return False\r\n elif len(words) == 2:\r\n command, path = words\r\n self.close_connection = 1\r\n if command != 'GET':\r\n self.send_error(400,\r\n \"Bad HTTP/0.9 request type (%r)\" % command)\r\n return False\r\n elif not words:\r\n return False\r\n else:\r\n self.send_error(400, \"Bad request syntax (%r)\" % requestline)\r\n return False\r\n self.command, self.path, self.request_version = command, path, version\r\n\r\n # Examine the http_request_headers and look for a Connection directive\r\n self.headers = self.MessageClass(self.rfile, 0)\r\n\r\n conntype = self.headers.get('Connection', \"\")\r\n if conntype.lower() == 'close':\r\n self.close_connection = 1\r\n elif conntype.lower() == 'keep-alive' and self.protocol_version >= \"HTTP/1.1\":\r\n self.close_connection = 0\r\n return True",
"def parseRequest(req):\n\treqHeaders = {}\n\treqLine = ''\n\tlineNum = 0\n\n\tfor line in req.splitlines():\n\t\tif line == '':\n\t\t\tbreak\n\t\telif lineNum == 0:\n\t\t\treqLine = line\n\t\t\tlineNum = 1\n\t\telse:\n\t\t\tsplitLine = line.split(' ', 1)\n\t\t\treqHeaders[splitLine[0]] = splitLine[1]\n\n\tsplitReqLine = reqLine.split(' ')\n\tmethod = splitReqLine[0]\n\tpath = splitReqLine[1]\n\tversion = splitReqLine[2]\n\n\treturn method, path, version, reqHeaders",
"def _get_request(self, line, delete_sending=False):\n line = line.replace('\\\\r', '\\r')\n line = line.replace('\\\\n', '\\n')\n # Remove the trailing \\n\n line = line[:-1]\n if delete_sending:\n return ParsedRequest(line.split(SENDING)[1].strip(\"'\"), ignore_dynamic_objects=True)\n return ParsedRequest(line, ignore_dynamic_objects=True)",
"def req():\n return Request()",
"def create_request(params={}, path='/', method='POST'):\n request = DummyRequest(path)\n request.method = method\n request.args = params\n return request",
"def _make_request(self, payload, headers=None):\n pathparts = REQ_PATH.split(b\"/\")\n if pathparts[0] == b\"\":\n pathparts = pathparts[1:]\n dreq = DummyRequest(pathparts)\n dreq.requestHeaders = Headers(headers or {})\n dreq.responseCode = 200 # default to 200\n\n if isinstance(payload, dict):\n payload = json.dumps(payload)\n\n dreq.content = BytesIO(payload.encode())\n dreq.method = \"POST\"\n\n return dreq",
"def create_request(path, environ=None):\n # setup the environ\n if environ is None:\n environ = {}\n\n # create a \"blank\" WebOb Request object\n # using TG Request which is a webob Request plus\n # some compatibility methods\n req = request_local.Request.blank(path, environ)\n\n # setup a Registry\n reg = environ.setdefault('paste.registry', Registry())\n reg.prepare()\n\n # Setup turbogears context with request, url and tmpl_context\n tgl = RequestLocals()\n tgl.tmpl_context = ContextObj()\n tgl.request = req\n\n request_local.context._push_object(tgl)\n\n return req",
"def _get_request(args):\n input_request = args.input_request\n request = None\n if input_request:\n from pathlib import Path\n req_file = Path(input_request)\n if req_file.is_file():\n request = load_certificate_request(req_file)\n\n if not request:\n request = req_handler(args)\n\n return request",
"def buildRequest(self, uri):\r\n req = urllib2.Request(uri)\r\n req.add_header('X-CSRFToken', self.token)\r\n req.add_header('Referer', 'http://www.ingress.com/intel')\r\n req.add_header('Accept-Charset', 'utf-8')\r\n req.add_header('User-agent', 'Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.64 Safari/537.31')\r\n return req",
"def parse (self, request):\n\n data = {}\n body_start = request.find('\\r\\n\\r\\n')\n if body_start == -1:\n data['body'] = None\n else:\n data['body'] = request[body_start+4:]\n parts = request.split(' ', 2)\n data['method'] = parts[0]\n data['resource'] = parts[1]\n return (data)",
"def parse_request(cls, request_raw: bytes, docs_root: Path, generate_index: bool = False, timeout: float = None) -> typing.NamedTuple:\n if not request_raw:\n raise HTTPException(HTTPStatus.BAD_REQUEST, 'Empty request')\n\n lines = request_raw.decode(HTTP_DEFAULT_ENCODING).rstrip(END_LINE).split(END_LINE)\n\n request_line_parts = lines[0].split()\n if len(request_line_parts) not in [2, 3]:\n raise HTTPException(HTTPStatus.BAD_REQUEST, f'Invalid request line format: {lines[0]}')\n\n command, uri = request_line_parts[:2]\n\n if len(request_line_parts) == 2 and command != 'GET':\n raise HTTPException(HTTPStatus.BAD_REQUEST, f'Bad HTTP/0.9 request type: {command}')\n\n protocol = Protocol(DEFAULT_REQUEST_VERSION if len(request_line_parts) == 2 else request_line_parts[-1])\n\n rpath = unquote(urlsplit(uri).path).lstrip('/')\n logging.debug('%s wanted.', rpath)\n if any(part in rpath.split('/') for part in ['~', '.', '..']):\n raise HTTPException(HTTPStatus.FORBIDDEN, f'Forbidden path format: {rpath}')\n abs_path = docs_root.joinpath(rpath)\n if abs_path.is_file() and rpath.endswith('/'):\n raise HTTPException(HTTPStatus.NOT_FOUND)\n if abs_path.is_dir() and not generate_index:\n abs_path = abs_path.joinpath(INDEX_FILE_NAME)\n if not abs_path.exists():\n raise HTTPException(HTTPStatus.NOT_FOUND)\n\n headers = OrderedDict(list((key.title(), value.strip().lower()) for key, _, value in (line.partition(':') for line in lines[1:] if line)))\n return cls(\n protocol=protocol,\n command=command,\n rpath=rpath,\n abs_path=abs_path,\n docs_root=docs_root,\n headers=headers,\n timeout=timeout,\n ctime=time.time(),\n body=None)",
"def _prepare_request(\n self,\n request: Union[GraphQLRequest, str],\n operation: Optional[str] = None,\n variables: Optional[Dict[str, Any]] = None,\n headers: Optional[Dict[str, str]] = None,\n ) -> GraphQLRequest:\n if isinstance(request, str):\n request = GraphQLRequest(query=request)\n\n return request.copy(\n headers=headers,\n headers_fallback=self._headers,\n operation=operation,\n variables=variables,\n )",
"def parse_request(line):\n\n datetimestring = re.search(r\"\\[.*\\]\", line).group().strip('[]')\n date_time = strptime(datetimestring, \"%d/%b/%Y %H:%M:%S\")\n\n return Request(line, date_time)",
"def toHTTPRequest(self):\n query = {}\n if (not self.getValues() == None):\n values = self.getValues()\n for key, value in values.iteritems():\n query[key[0].upper() + key[1 : len(key)]] = value\n\n if (self.getMethod() == 'GET'):\n request = UrlLibRequest(self.getUrl() + urlencode(query))\n else:\n request = UrlLibRequest(self.getUrl(), urlencode(query))\n\n request.add_header('Accept-Encoding', 'gzip, deflate')\n\n return request",
"def _CreateRequest(self, url, data=None):\n logging.debug(\"Creating request for: '%s' with payload:\\n%s\", url, data)\n req = urllib2.Request(url, data=data)\n if self.host_override:\n req.add_header(\"Host\", self.host_override)\n for key, value in self.extra_headers.iteritems():\n req.add_header(key, value)\n return req",
"def parse_request(self):\r\n # HTTP/1.1 connections are persistent by default. If a client\r\n # requests a page, then idles (leaves the connection open),\r\n # then rfile.readline() will raise socket.error(\"timed out\").\r\n # Note that it does this based on the value given to settimeout(),\r\n # and doesn't need the client to request or acknowledge the close\r\n # (although your TCP stack might suffer for it: cf Apache's history\r\n # with FIN_WAIT_2).\r\n request_line = self.rfile.readline()\r\n if not request_line:\r\n # Force self.ready = False so the connection will close.\r\n self.ready = False\r\n return\r\n \r\n if request_line == \"\\r\\n\":\r\n # RFC 2616 sec 4.1: \"...if the server is reading the protocol\r\n # stream at the beginning of a message and receives a CRLF\r\n # first, it should ignore the CRLF.\"\r\n # But only ignore one leading line! else we enable a DoS.\r\n request_line = self.rfile.readline()\r\n if not request_line:\r\n self.ready = False\r\n return\r\n \r\n environ = self.environ\r\n \r\n method, path, req_protocol = request_line.strip().split(\" \", 2)\r\n environ[\"REQUEST_METHOD\"] = method\r\n \r\n # path may be an abs_path (including \"http://host.domain.tld\");\r\n scheme, location, path, params, qs, frag = urlparse(path)\r\n \r\n if frag:\r\n self.simple_response(\"400 Bad Request\",\r\n \"Illegal #fragment in Request-URI.\")\r\n return\r\n \r\n if scheme:\r\n environ[\"wsgi.url_scheme\"] = scheme\r\n if params:\r\n path = path + \";\" + params\r\n \r\n environ[\"SCRIPT_NAME\"] = \"\"\r\n \r\n # Unquote the path+params (e.g. \"/this%20path\" -> \"this path\").\r\n # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2\r\n #\r\n # But note that \"...a URI must be separated into its components\r\n # before the escaped characters within those components can be\r\n # safely decoded.\" http://www.ietf.org/rfc/rfc2396.txt, sec 2.4.2\r\n atoms = [unquote(x) for x in quoted_slash.split(path)]\r\n path = \"%2F\".join(atoms)\r\n environ[\"PATH_INFO\"] = path\r\n \r\n # Note that, like wsgiref and most other WSGI servers,\r\n # we unquote the path but not the query string.\r\n environ[\"QUERY_STRING\"] = qs\r\n \r\n # Compare request and server HTTP protocol versions, in case our\r\n # server does not support the requested protocol. Limit our output\r\n # to min(req, server). We want the following output:\r\n # request server actual written supported response\r\n # protocol protocol response protocol feature set\r\n # a 1.0 1.0 1.0 1.0\r\n # b 1.0 1.1 1.1 1.0\r\n # c 1.1 1.0 1.0 1.0\r\n # d 1.1 1.1 1.1 1.1\r\n # Notice that, in (b), the response will be \"HTTP/1.1\" even though\r\n # the client only understands 1.0. RFC 2616 10.5.6 says we should\r\n # only return 505 if the _major_ version is different.\r\n rp = int(req_protocol[5]), int(req_protocol[7])\r\n server_protocol = environ[\"ACTUAL_SERVER_PROTOCOL\"]\r\n sp = int(server_protocol[5]), int(server_protocol[7])\r\n if sp[0] != rp[0]:\r\n self.simple_response(\"505 HTTP Version Not Supported\")\r\n return\r\n # Bah. \"SERVER_PROTOCOL\" is actually the REQUEST protocol.\r\n environ[\"SERVER_PROTOCOL\"] = req_protocol\r\n self.response_protocol = \"HTTP/%s.%s\" % min(rp, sp)\r\n \r\n # If the Request-URI was an absoluteURI, use its location atom.\r\n if location:\r\n environ[\"SERVER_NAME\"] = location\r\n \r\n # then all the http headers\r\n try:\r\n self.read_headers()\r\n except ValueError, ex:\r\n self.simple_response(\"400 Bad Request\", repr(ex.args))\r\n return\r\n \r\n creds = environ.get(\"HTTP_AUTHORIZATION\", \"\").split(\" \", 1)\r\n environ[\"AUTH_TYPE\"] = creds[0]\r\n if creds[0].lower() == 'basic':\r\n user, pw = base64.decodestring(creds[1]).split(\":\", 1)\r\n environ[\"REMOTE_USER\"] = user\r\n \r\n # Persistent connection support\r\n if self.response_protocol == \"HTTP/1.1\":\r\n if environ.get(\"HTTP_CONNECTION\", \"\") == \"close\":\r\n self.close_connection = True\r\n else:\r\n # HTTP/1.0\r\n if environ.get(\"HTTP_CONNECTION\", \"\") != \"Keep-Alive\":\r\n self.close_connection = True\r\n \r\n # Transfer-Encoding support\r\n te = None\r\n if self.response_protocol == \"HTTP/1.1\":\r\n te = environ.get(\"HTTP_TRANSFER_ENCODING\")\r\n if te:\r\n te = [x.strip().lower() for x in te.split(\",\") if x.strip()]\r\n \r\n read_chunked = False\r\n \r\n if te:\r\n for enc in te:\r\n if enc == \"chunked\":\r\n read_chunked = True\r\n else:\r\n # Note that, even if we see \"chunked\", we must reject\r\n # if there is an extension we don't recognize.\r\n self.simple_response(\"501 Unimplemented\")\r\n self.close_connection = True\r\n return\r\n \r\n if read_chunked:\r\n if not self.decode_chunked():\r\n return\r\n \r\n # From PEP 333:\r\n # \"Servers and gateways that implement HTTP 1.1 must provide\r\n # transparent support for HTTP 1.1's \"expect/continue\" mechanism.\r\n # This may be done in any of several ways:\r\n # 1. Respond to requests containing an Expect: 100-continue request\r\n # with an immediate \"100 Continue\" response, and proceed normally.\r\n # 2. Proceed with the request normally, but provide the application\r\n # with a wsgi.input stream that will send the \"100 Continue\"\r\n # response if/when the application first attempts to read from\r\n # the input stream. The read request must then remain blocked\r\n # until the client responds.\r\n # 3. Wait until the client decides that the server does not support\r\n # expect/continue, and sends the request body on its own.\r\n # (This is suboptimal, and is not recommended.)\r\n #\r\n # We used to do 3, but are now doing 1. Maybe we'll do 2 someday,\r\n # but it seems like it would be a big slowdown for such a rare case.\r\n if environ.get(\"HTTP_EXPECT\", \"\") == \"100-continue\":\r\n self.simple_response(100)\r\n \r\n self.ready = True",
"def build_request(input_id, method, params=None):\n request = {\"method\": method, \"id\": input_id}\n if params is not None:\n request[\"params\"] = params\n return request",
"def make_request(self, environ, **kwargs):\n factory = self.get(abcs.ARequest)\n request = factory(environ, self, **kwargs)\n self._set_request_attributes(request)\n return request",
"def parse_request(request):\n request_split = request.split()\n method = request_split[0]\n uri = request_split[1]\n protocol = request_split[2]\n print(\"Protocol: \" + protocol)\n headers = request_split[3]\n\n if method != \"GET\":\n raise RequestError(405, \"Method Not Allowed\")\n elif protocol != \"HTTP/1.1\":\n raise RequestError(505, \"HTTP Version Not Supported\")\n elif \"Host:\" not in headers:\n raise RequestError(400, \"Bad Request\")\n else:\n return uri",
"def make_subrequest(request, path):\n env = request.environ.copy()\n if path and '?' in path:\n path_info, query_string = path.split('?', 1)\n path_info = unquote(path_info)\n else:\n path_info = unquote(path)\n query_string = ''\n env['PATH_INFO'] = path_info\n env['QUERY_STRING'] = query_string\n subreq = request.__class__(env, method='GET', content_type=None,\n body=b'')\n subreq.remove_conditional_headers()\n # XXX \"This does not remove headers like If-Match\"\n return subreq",
"def load_request_der_string(string):\n bio = BIO.MemoryBuffer(string)\n return load_request_bio(bio, FORMAT_DER)",
"def _request(url, data=None):\n if data:\n req = urllib.request.Request(\n url,\n json.dumps(data).encode(\"utf-8\"),\n {\n \"X-Starfighter-Authorization\": _KEY,\n \"accept-encoding\": \"gzip\",\n \"content-type\": \"application/json\"\n }\n )\n else:\n req = urllib.request.Request(url)\n return req",
"def initialize_from_http_request(self, request):\n self.tool_id = request.path.strip('/').split('/')[0]\n self.path = request.path\n self._set_response_format(request)\n self._set_ip_address(request)\n self._set_tool_address_family(request)\n self._set_user_agent(request)\n self._set_path_qs(request)\n self._set_geolocation(request)\n self.metro = request.get(message.METRO, default_value=None)\n self._set_policy(request)",
"def parse_buffer(data):\r\n\tm = re.match(\"([^;]+);([\\d.]+);([\\d]+)\", data)\r\n\tif not m:\r\n\t\tprint('Couldn''t grok request ''{0}'''.format(data), file=sys.stderr)\r\n\t\treturn None\r\n\r\n\treq = Request()\r\n\treq.service = m.group(1)\r\n\treq.host = m.group(2)\r\n\treq.port = int(m.group(3))\r\n\treq.timestamp = time.time()\r\n\r\n\treturn req",
"async def get_request(cls, req):\n url = str(req.url)\n logger.debug('Getting data and status code',\n extra={'has_body': req.has_body, 'url': url})\n query = parse_qs(req.rel_url.query_string)\n headers = {k.decode(): v.decode() for k, v in req.raw_headers}\n body = None\n if req.can_read_body:\n body = await req.read()\n\n return ConnexionRequest(url=url,\n method=req.method.lower(),\n path_params=dict(req.match_info),\n query=query,\n headers=headers,\n body=body,\n json_getter=lambda: cls.jsonifier.loads(body),\n files={},\n context=req)",
"def create(cls, request):\n if isinstance(request, Request):\n request = request.prepare()\n\n # Method\n method = request.method.lower()\n\n # Cookies\n cookie = {}\n if request._cookies is not None:\n # cookies are stored in a cookiejar object\n cookie = request._cookies.get_dict()\n\n # Preparing a request formats the URL with params, strip them out again\n o = urlparse(request.url)\n params = parse_qs(o.query)\n # extract the URL without query parameters\n url = o._replace(query=None).geturl()\n\n # Order matters because all python requests issued from a session\n # include Accept */* which does not necessarily match the content type\n mimetype = request.headers.get(\"Content-Type\") or request.headers.get(\n \"Accept\"\n )\n\n # Headers - request.headers is not an instance of Headers\n # which is expected\n header = Headers(dict(request.headers))\n\n # Body\n # TODO: figure out if request._body_position is relevant\n body = request.body\n\n # Path gets deduced by path finder against spec\n parameters = RequestParameters(\n query=ImmutableMultiDict(params),\n header=header,\n cookie=cookie,\n )\n return OpenAPIRequest(\n full_url_pattern=url,\n method=method,\n parameters=parameters,\n body=body,\n mimetype=mimetype,\n )",
"def read_request(conn):\n\n # Grab the headers from the connection socket\n temp = conn.recv(1)\n while temp[-4:] != CRLF * 2:\n temp += conn.recv(1)\n request = temp.rstrip().split(CRLF)\n\n # Pull/parse the request line...\n temp = request[0].split()\n request_line = {}\n request_line['method'] = temp[0]\n request_line['uri'] = temp[1]\n request_line['protocol'] = temp[2]\n request_line['query_string'] = urlparse(request_line['uri']).query\n\n # ... parse the query string into a dict...\n request_line['query'] = {}\n if request_line['query_string']:\n temp = parse_qs(request_line['query_string']).iteritems()\n request_line['query'] = {\n key : val[0]\n for key, val in temp\n }\n\n # ... and grab headers...\n # For this I must remove the request line\n request = request[1:]\n headers = {}\n for line in request:\n key, value = line.split(': ', 1)\n key = key.lower()\n # now handle duplicate headers\n if key not in headers:\n # if the header isn't already in, add it\n headers[key] = value\n else:\n # it's already in the headers, add it in to previous\n # value delimited by a comma (as per spec)\n headers[key] = ', '.join([headers[key], value])\n # ... and content (if it exists)\n _input = ''\n if 'content-length' in headers:\n content = ''\n while len(content) < int(headers['content-length']):\n content += conn.recv(1)\n # Parse any form data\n if 'content-type' in headers:\n if ('application/x-www-form-urlencoded' in headers['content-type']\n or 'multipart/form-data' in headers['content-type']):\n # Init the field storage...\n _input = StringIO(content)\n temp = cgi.FieldStorage(\n headers=headers, fp=_input,\n environ={'REQUEST_METHOD' : 'POST'}\n )\n # ... re-init the input stream\n _input = StringIO(content)\n # ... reset content to a dictionary...\n content = {}\n # ... and then parse all keys, values into content.\n for key in temp:\n lkey = key.lower()\n if temp[key].file:\n # we have a file, so let's store the FieldStorage object\n content[lkey] = temp[key]\n else:\n # we have something else, just store the value (string)\n content[lkey] = temp[key].value\n else:\n # TODO do something with other types\n # reset content to a dictionary\n content = {}\n else:\n # TODO is there a default content-type, assuming length is given?\n content = {}\n else:\n # empty content\n # WSGI spec says don't process if CONTENT-LENGTH isn't specified\n content = {}\n\n # Now to put it all together in one request object:\n request = {\n 'REQUEST_METHOD': request_line['method'],\n 'SCRIPT_NAME': '',\n 'PATH_INFO': request_line['uri'],\n 'QUERY_STRING': request_line['query_string'],\n 'query': request_line['query'],\n 'SERVER_PROTOCOL': request_line['protocol'],\n 'SERVER_PORT': conn.getsockname()[0],\n 'wsgi.version': (1, 0),\n 'wsgi.errors': sys.stderr,\n 'wsgi.multithread': False,\n 'wsgi.multiprocess': False,\n 'wsgi.run_once': False,\n 'wsgi.url_scheme': 'http',\n 'CONTENT_TYPE': (\n headers['content-type'] if 'content-type' in headers else ''\n ),\n 'CONTENT_LENGTH': (\n headers['content-length'] if 'content-length' in headers else ''\n ),\n 'wsgi.input': _input,\n 'headers': headers,\n 'content': content\n }\n\n if 'cookie' in headers:\n request['HTTP_COOKIE'] = headers['cookie']\n # TODO think about what to do with Expires, which can contain commas...\n\n return request",
"def parse_buffer(data):\n\tm = re.match(\"([^;]+);([\\d.]+);([\\d]+)\", data)\n\tif not m:\n\t\tprint('Couldn''t grok request ''{0}'''.format(data), file=sys.stderr)\n\t\treturn None\n\n\treq = Request()\n\treq.service = m.group(1)\n\treq.host = m.group(2)\n\treq.port = int(m.group(3))\n\treq.timestamp = time.time()\n\n\treturn req",
"def make_request_string(string):\n message = str2list(string)\n modbus = hex2dec_on_list(message)\n return convert_list_to_unicode_str(modbus)",
"async def read_request_line(self):\n while True:\n rl = await self.reader.readline()\n # skip empty lines\n if rl == b'\\r\\n' or rl == b'\\n':\n continue\n break\n rl_frags = rl.split()\n if len(rl_frags) != 3:\n raise HTTPException(400)\n self.method = rl_frags[0]\n url_frags = rl_frags[1].split(b'?', 1)\n self.path = url_frags[0]\n if len(url_frags) > 1:\n self.query_string = url_frags[1]",
"def request_factory(environ):\n request = Request(environ)\n if request.is_xhr:\n request.response = Response()\n request.response.headerlist = []\n request.response.headerlist.extend(\n (\n ('Access-Control-Allow-Origin', '*'),\n ('Access-Control-Allow-Credentials', 'true'),\n ('Access-Control-Max-Age', 86400),\n ('Content-Type', 'application/json')\n )\n )\n return request",
"def parse_request(self, request):\n request = str(request)\n str_start = request.find(\"GET /?\")\n str_end = request.find(\"HTTP\")\n str_full = request[str_start + 6:str_end - 1]\n\n options = {}\n temp_option = []\n temp_selector = \"\"\n\n for i, letter in enumerate(str_full):\n if letter == \"=\":\n options[\"\".join(temp_option)] = []\n temp_selector = \"\".join(temp_option)\n temp_option = []\n elif letter == \"&\":\n options[temp_selector] = \"\".join(temp_option)\n temp_selector = \"\"\n temp_option = []\n elif i + 1 >= len(str_full):\n temp_option.append(letter)\n options[temp_selector] = \"\".join(temp_option)\n else:\n temp_option.append(letter)\n\n return options",
"def build_request(self, theurl, fields, files, txheaders=None):\n\n content_type, body = self.encode_multipart_formdata(fields, files)\n if not txheaders: txheaders = {}\n txheaders['Content-type'] = content_type\n txheaders['Content-length'] = str(len(body))\n\n return urllib2.Request(theurl, body, txheaders)",
"def mock_request(request_path_query=\"\", # type: Str\n method=\"GET\", # type: Str\n params=None, # type: Optional[Dict[Str, Str]]\n body=\"\", # type: Union[Str, JSON]\n content_type=None, # type: Optional[Str]\n headers=None, # type: Optional[AnyHeadersType]\n cookies=None, # type: Optional[AnyCookiesType]\n settings=None, # type: SettingsType\n ): # type: (...) -> Request\n parts = request_path_query.split(\"?\")\n path = parts[0]\n query = dict()\n if len(parts) > 1 and parts[1]:\n for part in parts[1].split(\"&\"):\n kv = part.split(\"=\") # handle trailing keyword query arguments without values\n if kv[0]: # handle invalid keyword missing\n query[kv[0]] = kv[1] if len(kv) > 1 else None\n elif params:\n query = params\n request = DummyRequest(path=path, params=query)\n request.path_qs = request_path_query\n request.method = method\n request.content_type = content_type\n request.headers = headers or {}\n request.cookies = cookies or {}\n request.matched_route = None # cornice method\n if content_type:\n request.headers[\"Content-Type\"] = content_type\n request.body = body\n try:\n if body:\n # set missing DummyRequest.json attribute\n request.json = json_pkg.loads(body)\n except (TypeError, ValueError):\n pass\n request.registry.settings = settings or {}\n return request # noqa # fake type of what is normally expected just to avoid many 'noqa'",
"def createHttpRequest(self, endpoint, payload=None, method=None, xDepth=None):\n\n logger.debug(\"Endpoint: {}\".format(endpoint))\n\n if endpoint is None:\n raise TypeError(\"expected CIC endpoint url but received None\",\"CIC_WRONG_ARGUMENT_TYPE_ERR\")\n\n # if no playload provided always do HTTP GET by default\n if payload is None:\n logger.debug(\"Preparing HTTP GET\")\n request = urllib2.Request(self.cicUrl+endpoint)\n\n elif ((payload is not None) and (method == \"POST\")):\n logger.debug(\"Preparing HTTP Post\")\n data = json.dumps(payload)\n request = urllib2.Request(self.cicUrl+endpoint,data, {'Content-Type': 'application/json'})\n request.get_method = lambda: 'POST'\n\n elif ((payload is not None) or (method==\"PATCH\")):\n logger.debug(\"Preparing HTTP Patch\")\n data = urllib.urlencode(payload)\n request = urllib2.Request(self.cicUrl+endpoint,data)\n request.get_method = lambda: 'PATCH'\n\n if xDepth:\n request.add_header(\"X-Depth\", xDepth)\n\n return request",
"def _createPostRequest(self, postBody: dict) -> object:\n request = HttpRequest()\n request.method = \"POST\"\n for name,value in postBody.items():\n request.POST[name]= value\n return request",
"def validate_http_request(request):\n request_str = request.decode('utf-8')\n print(request_str)\n split_request = request_str.split(' ')\n if (split_request[0] == 'GET') and split_request[2].startswith('HTTP/1.1'):\n request_url = split_request[1].replace(\"/\", \"\\\\\")\n x = (True, request_url)\n return x\n y = (False, None)\n return y",
"def newRequest(self):\n return Request( )",
"def __init__(self, request):\n self.arguments = {}\n for k, v in request.GET.items():\n self.arguments.setdefault(k, []).append(v)\n\n self.full_url = lambda: request.url\n self.host = request.host\n self.path = request.path",
"def _build_request(self, endpoint='', **parameters):\n\n request = {\n 'method': parameters.pop('method', 'GET'),\n 'data': parameters.pop('data', None),\n 'json': parameters.pop('json', None)\n }\n\n # url = {base_url}[/{endpoint}]\n url = '/'.join(filter(None, (self.__class__.base_url, endpoint)))\n\n for index, (key, value) in enumerate(parameters.items()):\n url += '{symbol}{key}={value}'.format(\n symbol='&' if index else '?', key=key, value=value\n )\n\n request['url'] = url\n\n return request",
"def request(self, **request):\n environ = {\n 'HTTP_COOKIE': self.cookies,\n 'PATH_INFO': '/',\n 'QUERY_STRING': '',\n 'REQUEST_METHOD': 'GET',\n 'SCRIPT_NAME': '',\n 'SERVER_NAME': 'testserver',\n 'SERVER_PORT': 80,\n 'SERVER_PROTOCOL': 'HTTP/1.1',\n 'wsgi.version': (1,0),\n 'wsgi.url_scheme': 'http',\n 'wsgi.input': FakePayload(''),\n 'wsgi.errors': self.errors,\n 'wsgi.multiprocess': True,\n 'wsgi.multithread': False,\n 'wsgi.run_once': False,\n }\n environ.update(self.defaults)\n environ.update(request)\n return WSGIRequest(environ)",
"def strReq(url, data):\n return requests.Request('GET', url, params=data).prepare().url",
"def _prepare_service_request_string(json_obj):\n requestString = json.dumps(json_obj)\n requestString = urlencode(requestString)\n return \"request=\"+requestString",
"def _parse_request_line(line):\n # Up to the first space is the method.\n index0 = line.index(SPACE)\n method = line[: index0]\n # Starting from the first space, up to the next space is the path.\n index1 = line.index(SPACE, index0 + 1)\n path = line[index0 + 1 : index1]\n # The remainder is the protocol version.\n http_version = line[index1 + 1 :]\n # Make sure it's the protocol version we recognize.\n assert http_version == HTTP_VERSION\n return method, path",
"def dorequest( request, body=None, chunk=None, trailers=None ):",
"def http_request_pipeline(source_addr, http_raw_data):\n # Parse HTTP request\n # Return error if needed, then:\n validity = check_http_request_validity(http_raw_data)\n if validity == HttpRequestState.GOOD:\n parse_http_request(source_addr, http_raw_data)\n\n if validity == HttpRequestState.INVALID_INPUT:\n\n code = '400'\n message = 'Bad Request'\n object = HttpErrorResponse(code, message)\n object.to_http_string()\n return object\n if validity == HttpRequestState.NOT_SUPPORTED:\n\n code = '501'\n message = 'Not Implemented'\n object = HttpErrorResponse(code, message)\n object.to_http_string()\n return object\n\n sanitize_http_request(http_raw_data)\n # Validate, sanitize, return Http object.\n print(\"*\" * 50)\n print(\"[http_request_pipeline] Implement me!\")\n print(\"*\" * 50)\n return None",
"def build_http_pkt(line: List[bytes],\n headers: Optional[Dict[bytes, bytes]] = None,\n body: Optional[bytes] = None) -> bytes:\n req = WHITESPACE.join(line) + CRLF\n if headers is not None:\n for k in headers:\n req += build_http_header(k, headers[k]) + CRLF\n req += CRLF\n if body:\n req += body\n return req",
"def build_http_pkt(line: List[bytes],\n headers: Optional[Dict[bytes, bytes]] = None,\n body: Optional[bytes] = None) -> bytes:\n req = WHITESPACE.join(line) + CRLF\n if headers is not None:\n for k in headers:\n req += build_http_header(k, headers[k]) + CRLF\n req += CRLF\n if body:\n req += body\n return req",
"def _get_request(self, client: socket.socket) -> utils.Request:\r\n\t\treq = client.recv(1024).decode(\"utf-8\")\r\n\r\n\t\treturn utils.Request(req)",
"def parse_request(json_data: str) -> Request:\n logger.debug('Type: {}'.format(type(json_data)))\n data = json.loads(json_data)\n\n return Request(\n data[\"text\"],\n PatternCategory(data[\"previous_pattern\"]\n ) if \"previous_pattern\" in data else None,\n data[\"mood\"],\n data[\"affection\"],\n Gender(data[\"bot_gender\"]),\n data[\"bot_name\"],\n date.fromtimestamp(data[\"bot_birthdate\"]),\n data[\"bot_favorite_color\"],\n data[\"father_name\"],\n data[\"father_age\"],\n data[\"mother_name\"],\n data[\"mother_age\"],\n )",
"def __init__(self, environ, stdin):\n\n # Request-Line\n # ============\n\n method = environ['REQUEST_METHOD']\n\n path = environ.get('PATH_INFO', '/')\n query = environ.get('QUERY_STRING', '')\n if query:\n query = '?' + query\n raw_uri = environ.get('SCRIPT_NAME', '') + path + query\n uri = urlparse.urlparse(raw_uri)\n keys = ( 'scheme'\n , 'netloc'\n , 'path'\n , 'parameters'\n , 'query'\n , 'fragment'\n )\n _uri = {}\n for i in range(len(uri)):\n k = keys[i]\n v = uri[i]\n _uri[k] = v\n uri = _uri\n\n http_version = environ['SERVER_PROTOCOL']\n\n raw_line = \"%s %s %s\\r\\n\" % (method, raw_uri, http_version)\n\n\n # Headers\n # =======\n\n headers = []\n for k, v in environ.iteritems():\n k = k.lower()\n if k.startswith('http_'):\n as_string = \"%s: %s\" % (k[5:].replace('_','-'), v)\n headers.append(as_string)\n raw_headers = '\\r\\n'.join(headers)\n raw_headers += '\\r\\n'\n headers = message_from_string(raw_headers)\n\n\n # Body\n # ====\n\n raw_body = stdin.read()\n\n\n # Save the API we want.\n # =====================\n\n raw = raw_line + raw_headers + raw_body\n\n self.raw = raw\n self.raw_line = raw_line\n self.raw_headers = raw_headers\n self.raw_body = raw_body\n\n self.method = method\n self.uri = uri\n self.path = path\n self.headers = headers",
"def fromRequest(cls, req):\n raise NotImplementedError(\n 'fromRequest is not implemented on %r' % (cls.__name__,))",
"def _get_request(url, params):\n request = requests.get(url, params=params)\n\n return request",
"def request(self, **request):\r\n environ = {\r\n 'HTTP_COOKIE': self.cookies,\r\n 'PATH_INFO': '/',\r\n 'QUERY_STRING': '',\r\n 'REQUEST_METHOD': 'GET',\r\n 'SCRIPT_NAME': '',\r\n 'SERVER_NAME': 'testserver',\r\n 'SERVER_PORT': 80,\r\n 'SERVER_PROTOCOL': 'HTTP/1.1',\r\n }\r\n environ.update(self.defaults)\r\n environ.update(request)\r\n request = WSGIRequest(environ)\r\n\r\n handler = BaseHandler()\r\n handler.load_middleware()\r\n for middleware_method in handler._request_middleware:\r\n if middleware_method(request):\r\n raise Exception(\"Couldn't create request object - \"\r\n \"request middleware returned a response\")\r\n\r\n return request",
"def createRequest(self, **kwargs):\n for k,v in kwargs.items():\n self.request[\"content\"][k] = v\n \n return self.request",
"def request(self, params=None):\n\t\trequest = APIRequest(self.api)\n\t\tfor attr in APIRequest.attrs:\n\t\t\tval = getattr(self, attr)\n\t\t\t# Copy Mappings (e.g. headers)\n\t\t\tval = dict(val) if isinstance(val, collections.abc.Mapping) else val\n\t\t\tsetattr(request, attr, val)\n\t\t# Update GET parameters\n\t\tif params:\n\t\t\trequest.params.update(params)\n\t\treturn request",
"def get_request(url, params={}):\n if isinstance(params, dict):\n if len(params) > 0:\n url += \"?\" + urllib.parse.urlencode(params)\n else:\n raise TypeError(\"data must be a dict\")\n headers = {}\n github_token = os.environ.get(\"GITHUB_TOKEN\")\n if github_token:\n headers[\"Authorization\"] = f\"Bearer {github_token}\"\n return urllib.request.Request(url, headers=headers)",
"def get_normalized_request_string(request, params=None):\n if params is None:\n params = parse_authz_header(request, {})\n bits = []\n bits.append(params[\"ts\"])\n bits.append(params[\"nonce\"])\n bits.append(request.method.upper())\n bits.append(request.path_qs)\n try:\n host, port = request.host.rsplit(\":\", 1)\n except ValueError:\n host = request.host\n if request.scheme == \"http\":\n port = \"80\"\n elif request.scheme == \"https\":\n port = \"443\"\n else:\n msg = \"Unknown scheme %r has no default port\" % (request.scheme,)\n raise ValueError(msg)\n bits.append(host.lower())\n bits.append(port)\n bits.append(params.get(\"ext\", \"\"))\n bits.append(\"\") # to get the trailing newline\n return \"\\n\".join(bits)",
"def http_request(method, url, params=None):\n if method.lower() not in _request_methods:\n raise NotImplementedError(\"HTTP request method not implemented\")\n\n\n return _request_methods[method.lower()](url, params)",
"def create_http_req(self, data, ID, tunnel_type, host_name):\n\n get = 'GET /' + data.encode(\"hex\") + ' HTTP/1.1' + const.END_LINE\n host = 'Host: ' + host_name + const.END_LINE\n user_agent = ( 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_1) ' +\n 'AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11' +\n const.END_LINE )\n #accept = 'Accept: */*' + const.END_LINE\n accept = 'Accept: text/html,application/xhtml+xml,application/xml' + const.END_LINE\n accept_language = 'Accept-Language: en-us,en;q=0.5' + const.END_LINE\n accept_encoding = 'Accept-Encoding: gzip,deflate' + const.END_LINE\n accept_charset = 'Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7' + const.END_LINE\n #keep_alive = 'Keep-Alive: 115' + const.END_LINE\n keep_alive = ''\n connection = 'Connection: keep-alive' + const.END_LINE\n referer = 'Referer: ' + const.END_LINE\n cookie = ( 'Cookie: ' + const.COOKIE_NAME + '=' + ID + '; ' +\n const.TUNNEL_COOKIE_NAME + '=' + tunnel_type + const.END_LINE )\n\n req = ( get +\n host +\n user_agent +\n accept +\n accept_language +\n accept_encoding +\n accept_charset +\n keep_alive +\n connection +\n referer +\n cookie +\n const.END_LINE )\n\n return req",
"def setup_request_commandline() -> Request:\r\n parser = argparse.ArgumentParser()\r\n parser.add_argument(\"key\", help=\"The key to use when encrypting or \"\r\n \"decrypting. This needs to be of \"\r\n \"length 8, 16 or 24\")\r\n parser.add_argument(\"-s\", \"--string\", help=\"The string that needs to be \"\r\n \"encrypted or decrypted\")\r\n parser.add_argument(\"-f\", \"--file\", help=\"The text file that needs to be\"\r\n \"encrypted or decrypted\")\r\n parser.add_argument(\"-o\", \"--output\", default=\"print\",\r\n help=\"The output of the program. This is 'print' by \"\r\n \"default, but can be set to a file name as well.\")\r\n parser.add_argument(\"-m\", \"--mode\", default=\"en\",\r\n help=\"The mode to run the program in. If 'en' (default)\"\r\n \" then the program will encrypt, 'de' will cause \"\r\n \"the program to decrypt\")\r\n try:\r\n args = parser.parse_args()\r\n request = Request()\r\n request.encryption_state = CryptoMode(args.mode)\r\n request.data_input = args.string\r\n request.input_file = args.file\r\n request.output = args.output\r\n request.key = args.key\r\n print(request)\r\n return request\r\n except Exception as e:\r\n print(f\"Error! Could not read arguments.\\n{e}\")\r\n quit()",
"def parse_request(request):\n\n method, path, version = request.split(\"\\r\\n\")[0].split(\" \")\n if method != \"GET\":\n raise NotImplementedError\n return path",
"def create_http_request(self) -> str:\n\n if self.http_command == \"PUT\" or self.http_command == \"POST\":\n ctype = \"text/html\"\n body = input(\"Enter data to insert: \")\n clength = len(body.encode(HttpClient.FORMAT))\n msg = self.http_command + \" \" + self.file_name + \" HTTP/1.1\\r\\nHost: \" + str(self.uri) \\\n + \"\\r\\nConnection: close\" \\\n + \"\\r\\nContent-Type: \" + ctype \\\n + \"\\r\\nContent-Length: \" + str(clength) + \"\\r\\n\\r\\n\" + body + \"\\r\\n\"\n else:\n msg = self.http_command + \" \" + self.file_name + \" HTTP/1.1\\r\\nHost: \" + str(self.uri) \\\n + \"\\r\\n\\r\\n\"\n\n # + \"\\r\\nIf-Modified-Since: 30 Mar 2021 23:24:50 GMT\"\n\n return msg",
"def _fomat_request(self, request):\n request = bytes(f\"{request} \\r\\n\", \"ascii\")\n return request",
"def setup_request_commandline() -> Request:\n parser = argparse.ArgumentParser()\n parser.add_argument(\"key\", help=\"The key to use when encrypting or \"\n \"decrypting. This needs to be of \"\n \"length 8, 16 or 24\")\n parser.add_argument(\"-s\", \"--string\", help=\"The string that needs to be \"\n \"encrypted or decrypted\")\n parser.add_argument(\"-f\", \"--file\", help=\"The text file that needs to be\"\n \"encrypted or decrypted\")\n parser.add_argument(\"-o\", \"--output\", default=\"print\",\n help=\"The output of the program. This is 'print' by \"\n \"default, but can be set to a file name as well.\")\n parser.add_argument(\"-m\", \"--mode\", default=\"en\",\n help=\"The mode to run the program in. If 'en' (default)\"\n \" then the program will encrypt, 'de' will cause \"\n \"the program to decrypt\")\n try:\n args = parser.parse_args()\n request = Request()\n request.encryption_state = CryptoMode(args.mode)\n request.data_input = args.string\n request.input_file = args.file\n request.output = args.output\n request.key = args.key\n print(request)\n return request\n except Exception as e:\n print(f\"Error! Could not read arguments.\\n{e}\")\n quit()",
"def __init__(self, query_string: str) -> None:\n super().__init__(parse_qs(query_string))",
"def __init__(self, url_str):\n parsed_url = requests.compat.urlparse(utils.to_str(url_str))\n netloc_parts = parsed_url.netloc.split(\"@\")\n if len(netloc_parts) == 1:\n username = password = None\n host_str = netloc_parts[0]\n else:\n username, password = netloc_parts[0].split(\":\")\n host_str = netloc_parts[1]\n\n host_parts = host_str.split(\":\")\n host = host_parts[0]\n\n if len(host_parts) == 1:\n port = 80\n else:\n port = int(host_parts[1])\n\n params = [\n (key, val[0] if val[0] else None)\n for key, val in parse_qs(parsed_url.query, True).items()\n ]\n\n self._info = dict(\n scheme=parsed_url.scheme or \"http\",\n username=username,\n password=password,\n host=host,\n port=port,\n path=parsed_url.path or \"/\",\n params=params,\n fragment=parsed_url.fragment\n )\n self._url = None",
"def get_request():\n uri = flask.request.base_url\n if flask.request.query_string:\n uri += \"?\" + flask.request.query_string.decode(\"utf-8\")\n\n method = flask.request.method\n headers = dict(flask.request.headers)\n body = flask.request.get_data()\n return jsonapi.base.Request(uri, method, headers, body)",
"def prepare_sync_request(cls, httpx_request, **kwargs):\n httpx_request.read()\n return httpx_request, kwargs",
"def new_request(self, **kwargs):\n url = self.config[\"base_url\"]\n\n if kwargs.get(\"user_id\") is not None:\n url = url + kwargs[\"user_id\"]\n\n self.req = request.Request(host=self.config[\"host\"], protocol=constant.HTTP, url=url,\n method=kwargs[\"method\"], time_out=kwargs[\"timeout\"])\n\n return self",
"def get_request(req: Dict) -> Dict:\n for field in ['body']:\n if field in req:\n data = req[field]\n if isinstance(data, str):\n return create_request(data)\n elif isinstance(data, dict) and 'text' in data:\n return data\n return None",
"def create_command_from_request(request: RequestInterface):",
"def get_request_dict(request: Union[str, bytes, HttpRequest, dict]) -> Dict[str, str]:\n if isinstance(request, (str, bytes)):\n try:\n return json.loads(request)\n except Exception:\n print('Must be given a valid JSON')\n raise\n if not isinstance(request, dict):\n return vars(request)\n return request",
"def request(self, verb, url, payload: Optional[Any] = ..., multipart: Optional[Any] = ...):\n ...",
"def request_factory() -> RequestFactory:\n\n return RequestFactory()",
"def read_request(inFile):\n\treq = {}\n\twith open(inFile) as f:\n \t\tfor line in f:\n\t\t\tkv = line.split()\t\t\t\n \t\tk, v = kv[0], kv[1:]\n \t\t\treq[k] = v\n\treturn req",
"def __call__(self, request):\n if self.where == \"qs\":\n parts = urlparse(request.url)\n qs = parse_qs(parts.query)\n qs[self.qs_key] = self.token\n request.url = urlunparse(\n (\n parts.scheme,\n parts.netloc,\n parts.path,\n parts.params,\n urlencode(qs),\n parts.fragment,\n )\n )\n elif self.where == \"header\":\n request.headers[\"Authorization\"] = \"Bearer {}\".format(self.token)\n return request",
"def getRequest(self):\n req = self.conn.readline()\n return req.split()",
"def request_factory(self) -> 'JSONRPCRequest':\n return JSONRPCRequest()",
"def make_req(self, uri, request_method, params, headers):\n self._conn.request(request_method, uri, params, headers)\n response = self._conn.getresponse()\n\n payload = response.read()\n return payload"
] | [
"0.66163635",
"0.64092165",
"0.6310418",
"0.6307847",
"0.62922215",
"0.6205955",
"0.6139031",
"0.61217684",
"0.60365695",
"0.60207903",
"0.5994213",
"0.5978753",
"0.5958118",
"0.5937699",
"0.5780297",
"0.5706186",
"0.5587631",
"0.5573185",
"0.55512106",
"0.5533943",
"0.5532476",
"0.5530401",
"0.55293185",
"0.55147636",
"0.55001533",
"0.5458124",
"0.5457386",
"0.5437374",
"0.5419851",
"0.54007363",
"0.5389923",
"0.5377279",
"0.53689003",
"0.53641087",
"0.5362591",
"0.53584605",
"0.5326907",
"0.53213084",
"0.5284631",
"0.5280045",
"0.5264151",
"0.5257002",
"0.5232239",
"0.52280086",
"0.52058315",
"0.5201769",
"0.51974005",
"0.5196873",
"0.5187318",
"0.51795",
"0.5179303",
"0.5179273",
"0.51646465",
"0.515536",
"0.51486975",
"0.5148476",
"0.5132257",
"0.5131967",
"0.51112527",
"0.51043034",
"0.50936127",
"0.5078729",
"0.50779665",
"0.50707495",
"0.50641835",
"0.50558317",
"0.5055477",
"0.5055477",
"0.50554615",
"0.50347036",
"0.5008156",
"0.5005794",
"0.4999392",
"0.4990059",
"0.49893385",
"0.49862745",
"0.49727288",
"0.49563494",
"0.49288827",
"0.49256015",
"0.4924879",
"0.49202055",
"0.4914702",
"0.49143627",
"0.49075174",
"0.4896926",
"0.48932502",
"0.48924825",
"0.48837042",
"0.4869322",
"0.48684922",
"0.48678008",
"0.48634842",
"0.48551166",
"0.48516095",
"0.48454377",
"0.48392355",
"0.48282358",
"0.4821035",
"0.48205724"
] | 0.64779276 | 1 |
Parses headers to a dictionary from a list of strings | def _parse_headers(raw_headers: List[str]) -> Dict[str, str]:
headers: Dict[str, str] = {}
for header in raw_headers:
name = header[: header.find(":")].strip()
value = header[header.find(":") + 1 :].strip()
headers[name.lower()] = value
return headers | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_headers(headers):\n try:\n return dict(header.split(\":\") for header in headers)\n except:\n raise ValueError(\"Invalid headers %s\" % headers)",
"def generate_header_dic(self, header_strings):\n headers = dict()\n\n for header_values in header_strings:\n header_list = header_values.split(':')\n headers[header_list[0]] = header_list[1]\n return headers",
"def headers_raw_to_dict(headers_raw):\n\n if headers_raw is None:\n return None\n headers = headers_raw.splitlines()\n headers_tuples = [header.split(':', 1) for header in headers]\n\n result_dict = {}\n for header_item in headers_tuples:\n if not len(header_item) == 2:\n continue\n\n item_key = header_item[0].strip()\n item_value = header_item[1].strip()\n result_dict[item_key] = item_value\n\n return result_dict",
"def get_headers(headers: HTTPHeaders) -> Mapping[str, List[str]]:\r\n return {header.lower(): headers.get_list(header) for header in headers.keys()}",
"def readHeaders(lines):\n\n result = {}\n for line in lines:\n if line[0] == \"#\":\n continue\n if line.strip() == \"\":\n continue\n key, value = line.split(\":\", 1)\n result[key.strip()] = parseSloppily(value)\n return result",
"def updateheader(self, headerlist=[], http_s_obj=None):\n header = {}\n for headerparam in headerlist:\n key_value = headerparam.split(\":\", 1)\n if len(key_value) == 2:\n try:\n key = key_value[0]\n value = key_value[1].strip()\n header.update({key: value})\n if http_s_obj:\n if http_s_obj.header.get(key):\n http_s_obj.header.update({key: value})\n except Exception:\n continue\n return header",
"def _parse_header(lines):\n # The dict into which we will store header fields.\n header = {}\n # Loop over lines in the header.\n for line in lines:\n # Find the first colon.\n index = line.index(COLON)\n # Up to the colon is the field name.\n name = line[: index]\n # After the colon is the field value.\n value = line[index + 1 :]\n # The field value may begin or end with extra space, which is not \n # significant. Remove it.\n value = value.strip()\n # Store the field.\n header[name] = value\n # All done.\n return header",
"def _unpack_headers(self, headers):\n return dict((k,v[0]) for (k,v) in headers.getAllRawHeaders())",
"def get_headers(s, sep=': ', strip_cookie=False, strip_cl=True, strip_headers: list = []) -> dict():\n d = dict()\n for kv in s.split('\\n'):\n kv = kv.strip()\n if kv and sep in kv:\n v=''\n k = kv.split(sep)[0]\n if len(kv.split(sep)) == 1:\n v = ''\n else:\n v = kv.split(sep)[1]\n if v == '\\'\\'':\n v =''\n # v = kv.split(sep)[1]\n if strip_cookie and k.lower() == 'cookie': continue\n if strip_cl and k.lower() == 'content-length': continue\n if k in strip_headers: continue\n d[k] = v\n return d",
"def get_headers(s, sep=': ', strip_cookie=False, strip_cl=True, strip_headers: list = []) -> dict():\n d = dict()\n for kv in s.split('\\n'):\n kv = kv.strip()\n if kv and sep in kv:\n v=''\n k = kv.split(sep)[0]\n if len(kv.split(sep)) == 1:\n v = ''\n else:\n v = kv.split(sep)[1]\n if v == '\\'\\'':\n v =''\n # v = kv.split(sep)[1]\n if strip_cookie and k.lower() == 'cookie': continue\n if strip_cl and k.lower() == 'content-length': continue\n if k in strip_headers: continue\n d[k] = v\n return d",
"def decode_header(header):\n new_header = {}\n\n for item in header:\n split = item.split('\\t')\n new_header[split[0].replace(':', '')] = split[1].replace(\"\\r\\n\", \"\")\n\n return new_header",
"def parse_headers(file_contents: str) -> dict:\n\n match = re.search(r'#HEADER#(.*?)#', file_contents, re.MULTILINE | re.DOTALL)\n\n if match is None:\n raise Exception('No #HEADER# provided')\n\n headers = {}\n lines = match.group(1).split(\"\\n\")\n\n for line in lines:\n if line.strip() != '':\n parts = line.split(' : ')\n value = re.sub(r'(^[\\'\"]|[\\'\"]$)', '', parts[1].strip())\n headers[parts[0].strip()] = value\n\n return headers",
"def __parseHeaders(headers):\n global __all_headers\n if headers and len(headers) > 0:\n for header in headers:\n name = header.getElementsByTagName(\"name\")[0].childNodes[0].data\n value = header.getElementsByTagName(\"value\")[0].childNodes[0].data\n __addHeader(name, value)\n #print(__all_headers)",
"def fill_headers(self, headers):\n self.headers = {h[0]: h[1] for h in headers}",
"def unpack_header(header):\n header_values = {}\n for line in header.split('\\n'):\n tokens = line.split('=')\n if len(tokens) > 1:\n header_values[tokens[0].strip()] = tokens[1].split(';')[0].strip()\n return header_values",
"def _split_headers(headers):\n amz_headers = {}\n reg_headers = {}\n for cur in headers:\n if cur.lower().startswith('x-amz-'):\n amz_headers[cur] = headers[cur]\n else:\n reg_headers[cur] = headers[cur]\n return (amz_headers, reg_headers)",
"def extract_header(self, string): \n\n header_list = re.findall(r\"\\$\\*(.*)\\*\\$\", string)[0].split(\",\")\n header = {}\n for i in header_list:\n spl = i.split(\":\")\n header[spl[0]] = spl[1]\n\n return header",
"def _parse_header(self, line):\n if self._regex_helper.search_compiled(W._re_header, line):\n if not self.headers:\n for value in re.findall(W._re_header, line):\n self.headers.append(value[0])\n raise ParsingDone\n else:\n # Dictionary which is going to be appended to the returned list\n ret = dict()\n # List of entries\n _entries = list()\n # List of values in WHAT entry\n _what_entry = list()\n for value in re.findall(W._re_header, line):\n _entries.append(value[0])\n for what_index in range(len(self.headers) - 1, len(_entries)):\n _what_entry.append(_entries[what_index])\n _what_entry_string = ' '.join(_what_entry)\n for index in range(len(self.headers)):\n if index < len(self.headers) - 1:\n ret.update({self.headers[index]: _entries[index]})\n else:\n ret.update({self.headers[index]: _what_entry_string})\n self.current_ret['RESULT'].append(ret)\n raise ParsingDone",
"def parse_header(header_lines):\n info = {}\n for line in header_lines:\n if line.startswith('Citation'):\n info['Citation'] = line.split()[-1].strip()\n elif ':' in line:\n try:\n field, value = map(strip,line.split(':',1))\n info[field] = value\n except ValueError:\n #no interesting header line\n continue\n else:\n continue\n return Info(info)",
"def _convert_list_tuples_to_dict(self, headers_list):\n # type: (List[Tuple[str, str]]) -> Dict[str, str]\n headers_dict = {} # type: Dict\n if headers_list is not None:\n for header_tuple in headers_list:\n key, value = header_tuple[0], header_tuple[1]\n if key in headers_dict:\n headers_dict[key] = \"{}, {}\".format(\n headers_dict[key], value)\n else:\n headers_dict[header_tuple[0]] = value\n return headers_dict",
"def _parse_raw_header_entries(header_entries):\n\n def __check_key(key):\n return not(\"_\" in key or \" \" in key or \":\" in key or not len(key))\n\n result = {}\n if (len(header_entries) < 1):\n return result\n\n # Remove leading '--'\n header_entries = header_entries[1:]\n if (not len(header_entries) % 2 == 0):\n raise ValueError(\"last key does not have a value\")\n\n while (len(header_entries)):\n # Retrieve raw key\n logging.debug(\"current header content \" + str(header_entries))\n word = header_entries[0]\n header_entries = header_entries[1:]\n\n # Try to trim equal\n if (word[-1] == ':'):\n word = word[:-1]\n\n if(not __check_key(word)):\n raise ValueError(\"invalid key '{}' in key value list\".format(word))\n\n result[word] = header_entries[0]\n header_entries = header_entries[1:]\n\n return result",
"def parseHeader(header):\n tokens = [t for t in header.split(' ') if t]\n result = {}\n for i in range(len(tokens)):\n result[tokens[i]] = i \n\n return result",
"def parse_header(self, out):\n self.headers = {}\n for h in out.split(\"\\r\\n\\r\\n\", 1)[0].split(\"\\r\\n\"):\n x = h.split(\":\")\n self.headers[x[0]] = \":\".join(x[1:]).lstrip()\n return True",
"def read_prism_hdr(hdr_path): \n with open(hdr_path, 'r') as input_f:\n header_list = input_f.readlines()\n \n return dict(item.strip().split() for item in header_list)",
"def trim_headers(all_headers, relevant_headers=[\"From\", \"To\", \"Subject\", \"Date\"]):\n data = {}\n for header in all_headers:\n if header['name'] in relevant_headers:\n data[header['name']] = header['value']\n\n return data",
"def _parse_header(path):\n with open(path) as f:\n text = f.read().splitlines()\n raw_segs = [line.split() for line in text if ':' in line]\n\n # convert the content into a giant dict of all key, values\n return dict((i[0][:-1], i[1:]) for i in raw_segs)",
"def _parse_headers(headers):\n\n headers_new = []\n # reformat column headers if needed\n for j, hd in enumerate(headers):\n # rename so always have T1/2 (s)\n if hd == \"T1/2 (num)\" or hd == \"T1/2 (seconds)\":\n hd = \"T1/2 (s)\"\n # for uncertainties, add previous column header to it\n if j > 0 and \"Unc\" in hd:\n hd = headers[j - 1] + \" \" + hd\n if \"Unc\" in hd and \"Unc.\" not in hd:\n hd = hd.replace(\"Unc\", \"Unc.\")\n # expand abbreviated headers\n if \"Energy\" in hd and \"Energy Level\" not in hd:\n hd = hd.replace(\"Energy\", \"Energy Level\")\n if \"Par. Elevel\" in hd:\n hd = hd.replace(\"Par. Elevel\", \"Parent Energy Level\")\n if \"Abund.\" in hd:\n hd = hd.replace(\"Abund.\", \"Abundance (%)\")\n if \"Ene.\" in hd:\n hd = hd.replace(\"Ene.\", \"Energy\")\n if \"Int.\" in hd:\n hd = hd.replace(\"Int.\", \"Intensity (%)\")\n if \"Dec\" in hd and \"Decay\" not in hd:\n hd = hd.replace(\"Dec\", \"Decay\")\n if \"Rad\" in hd and \"Radiation\" not in hd:\n hd = hd.replace(\"Rad\", \"Radiation\")\n if \"EP\" in hd:\n hd = hd.replace(\"EP\", \"Endpoint\")\n if \"Mass Exc\" in hd and \"Mass Excess\" not in hd:\n hd = hd.replace(\"Mass Exc\", \"Mass Excess\")\n headers_new.append(hd)\n if len(set(headers_new)) != len(headers_new):\n raise NNDCRequestError(\n \"Duplicate headers after parsing\\n\"\n + f' Original headers: \"{headers}\"\\n'\n + f' Parsed headers: \"{headers_new}\"'\n )\n return headers_new",
"def _headers(self) -> Mapping[str, str]:\n return {}",
"def parse_header(self):",
"def parse_list_header(value):\n result = []\n for item in urllib2.parse_http_list(value):\n if item[:1] == item[-1:] == '\"':\n item = unquote_header_value(item[1:-1])\n result.append(item)\n return result",
"def GetResponseHeadersDict(self):\n headers = collections.defaultdict(list)\n for (key, value) in self._wpr_response.original_headers:\n headers[key.lower()].append(value)\n return {k: ','.join(v) for (k, v) in headers.items()}",
"def read_headers(input_file):\n\n with open(input_file+'.hdr','r') as f:\n return [float(h) if not h.isalpha() else h for h in [l.split()[1] for l in f.readlines()]] #isdigit() does not catch floats",
"def fitsio_header_to_dict(hdr):\n d = {}\n for key in hdr.keys():\n if key != 'HISTORY' or key != \"COMMENT\":\n d[key.lower()] = hdr.get(key)\n return d",
"def parse_header(self): # -> list[Unknown]:\n ...",
"def _parse_wsgi_headers(wsgi_environ):\n prefix = 'HTTP_'\n p_len = len(prefix)\n # use .items() despite suspected memory pressure bc GC occasionally\n # collects wsgi_environ.iteritems() during iteration.\n headers = {\n key[p_len:].replace('_', '-').lower():\n val for (key, val) in wsgi_environ.items()\n if key.startswith(prefix)}\n return headers",
"def _read_header_line_2(lines: list) -> dict:\n fields = (\n \"detection_status\",\n \"warning\",\n \"cloud_base_data\",\n \"warning_flags\",\n )\n values = [[line[0], line[1], line[3:20], line[21:].strip()] for line in lines]\n return values_to_dict(fields, values)",
"def parse_header(header):\n if header[0] != '@':\n return None\n \n instrument, run_number, flowcell_id, lane, tile, x_pos, y_pos_read, is_filtered, control_number, index = header[1:].split(\":\")\n y_pos, read = y_pos_read.split()\n return {'instrument': str(instrument),\n 'run_number': int(run_number),\n 'flowcell_id': str(flowcell_id),\n 'lane': int(lane),\n 'tile': int(tile),\n 'x_pos': int(x_pos),\n 'y_pos': int(y_pos),\n 'read': int(read),\n 'is_filtered': (is_filtered == 'Y'),\n 'control_number': int(control_number),\n 'index': str(index)} # Note that MiSeq Reporter outputs a SampleSheet index rather than the index sequence",
"def _headers(self, headers_dict):\n return Headers(dict((k,[v]) for (k,v) in headers_dict.items()))",
"def parse_header(self, h, f=None):\n if f == None:\n f = self.extract_zt\n return [f(w) for w in h.split()[1:]]",
"def _read_headers(self, fp):\n d = {}\n if isinstance(fp, str):\n csvfile = open(fp, newline=\"\")\n else:\n csvfile = fp\n csvreader = csv.reader(csvfile, delimiter=\",\", quotechar='\"')\n for row in csvreader:\n if row[0].isdigit():\n break\n else:\n d[row[0]] = row[1:]\n\n return d",
"def header_population(headers):\n return [{'id': field, 'name': field, 'field': field, 'sortable': True} for field in headers]",
"def _extract_metadata(self, header, cleaner):\n metadata = []\n for k, v in header.items():\n key = str(cleaner(k)) # clean key and ensure it is a string\n val = str(cleaner(v)) # clean value and ensure it is a string\n if (key and val):\n metadata.append(Metadatum(key, val))\n return metadata",
"def get_fields_from_header (header, ignore=FITS_IGNORE_KEYS):\n hdrs = dict()\n filtered = [ card for card in header.items() if (card[0] not in ignore) ]\n hdrs.update(filtered)\n return hdrs",
"def condition_matching_header(rmapping, header):\n return dict(header) # NOOP for JWST, may have to revisit",
"def _read_header_line_1(self, lines: list) -> dict:\n fields = (\n \"model_id\",\n \"unit_id\",\n \"software_level\",\n \"message_number\",\n \"message_subclass\",\n )\n if self._is_ct25k():\n indices = [1, 3, 4, 6, 7, 8]\n else:\n indices = [1, 3, 4, 7, 8, 9]\n values = [split_string(line, indices) for line in lines]\n return values_to_dict(fields, values)",
"def get_data(contents):\n\n header = {}\n copy = contents.split(\"\\n\")\n\n header_contents = dict(\n start_date=\"Start Date\",\n end_date=\" End Date\",\n subject=\" Subject\",\n experiment=\" Experiment\",\n group=\" Group\",\n box=\" Box\",\n start_time=\" Start Time\",\n end_time=\" End Time\",\n program=\" Program\",\n msn=\" MSN\",\n )\n\n for line in copy:\n for key in header_contents:\n heading = line.split(\":\")\n if heading[0] == header_contents[key]:\n if key == \"start_time\" or key == \"end_time\":\n header[key] = (\n heading[1].lstrip() + \":\" + heading[2] + \":\" + heading[3]\n )\n else:\n header[key] = heading[1].lstrip()\n\n data = {}\n copy = contents.split()\n\n uppercase = string.ascii_uppercase\n\n idx = []\n for i, val in enumerate(copy):\n if val[0] in uppercase and val[1] == \":\":\n idx.append(i)\n\n for i, j in zip(idx[:-1], idx[1:]):\n data[copy[i].lower()[0]] = [\n timestamp for timestamp in copy[i + 1 : j] if timestamp[-1] != \":\"\n ]\n\n return header, data",
"def test_header_parser_vanilla(self):\n lines = [\"Content-Type: application/json\", \"Accept: application/json\"]\n h = {\"Content-Type\": \"application/json\", \"Accept\": \"application/json\"}\n headers = parser._parse_headers(lines)\n self.assertEqual(h, headers)",
"def get_header():\n str_list = ['specimennumber','speciesid','group','family','genus','species','scientificname', \\\n 'commonname','country','state','county','locality','latitude','longitude', \\\n 'source','accuracy','drainagename','centroidtype','huc8name','huc8', \\\n 'huc10name','huc10','huc12name','huc12','date','year','month','day','status','comments', \\\n 'recordtype','disposal','museumcatnumber','freshmarineintro','references']\n return str_list",
"def _ToTuples(headers):\n all_headers = []\n for line in headers:\n if line[0] in '\\t ':\n if not all_headers:\n logging.warning(\n 'Unexpected response header continuation line [%s]', line)\n continue\n name, value = all_headers.pop()\n value += '\\n ' + line.strip()\n else:\n name_value = RealHttpFetch._GetHeaderNameValue(line)\n if not name_value:\n logging.warning(\n 'Response header in wrong format [%s]', line)\n continue\n name, value = name_value # pylint: disable=unpacking-non-sequence\n all_headers.append((name, value))\n return all_headers",
"def process_header_request(self, request, http_s_obj):\n response_dict = {}\n data = request.split(\"\\r\\n\\r\\n\")\n header_info = data[0].split(\"\\r\\n\")\n headers = self.updateheader(header_info, http_s_obj)\n response_dict.update({'type': header_info[0].split()[0]})\n response_dict.update({'headers': headers})\n body = data[1]\n response_dict.update({'data': body})\n path = header_info[0].split()[1]\n if path.find('?') != -1:\n split_sym = '?'\n if path.find('&') != -1:\n split_sym = '&'\n try:\n req = path.split(split_sym)\n path = req[0]\n query = req[1]\n except Exception as e:\n query = ''\n response_dict.update({'path': path})\n response_dict.update({'query': query})\n\n return response_dict",
"def get_email_details(header: str) -> dict:\n # this is one way to solve the exercise\n # result_keys = [\"from\", \"to\", \"subject\", \"date\"]\n # search_strings = [\n # r\"From\\:\\s(.*)\",\n # r\"To\\:\\s(.*)\",\n # r\"Subject\\:\\s(.*)\",\n # r\"Date\\:\\s(.*)\\s[+-]\",\n # ]\n # result_values = [re.search(s, EMAIL_HEADER).group(1) for s in search_strings]\n # print(dict(zip(result_keys, result_values)))\n\n # or we could use groupdict as suggested\n m = re.search(\n r\"From\\:\\s(?P<from>.*)\\n.*To\\:\\s(?P<to>.*)\\n.*Subject\\:\\s(?P<subject>.+?)\\n.*Date\\:\\s(?P<date>.*)\\s[+-]\",\n header,\n re.MULTILINE | re.DOTALL,\n )\n return m.groupdict() if m else None",
"def parse_header_parameters(line):\n parts = _parseparam(\";\" + line)\n key = parts.__next__().lower()\n pdict = {}\n for p in parts:\n i = p.find(\"=\")\n if i >= 0:\n has_encoding = False\n name = p[:i].strip().lower()\n if name.endswith(\"*\"):\n # Lang/encoding embedded in the value (like \"filename*=UTF-8''file.ext\")\n # https://tools.ietf.org/html/rfc2231#section-4\n name = name[:-1]\n if p.count(\"'\") == 2:\n has_encoding = True\n value = p[i + 1 :].strip()\n if len(value) >= 2 and value[0] == value[-1] == '\"':\n value = value[1:-1]\n value = value.replace(\"\\\\\\\\\", \"\\\\\").replace('\\\\\"', '\"')\n if has_encoding:\n encoding, lang, value = value.split(\"'\")\n value = unquote(value, encoding=encoding)\n pdict[name] = value\n return key, pdict",
"def list_to_dict(list: list, keys: list):\n dictionary = dict()\n for key in keys:\n try:\n index = list.index(f'{key}:')\n dictionary[list[index].strip(':')] = list[index + 1]\n except ValueError:\n print(f'{key} not found!')\n return dictionary",
"def extract_object_metadata_from_headers(headers):\n meta_headers = {}\n for header, value in headers.items():\n header = header.title()\n\n if (header.startswith(\"X-Object-Meta-\") or\n header.startswith(\"X-Object-Sysmeta-\") or\n header in SPECIAL_OBJECT_METADATA_HEADERS):\n\n # do not let a client pass in ORIGINAL_MD5_HEADER\n if header not in (ORIGINAL_MD5_HEADER,\n ORIGINAL_MD5_HEADER.title()):\n meta_headers[header] = value\n\n return meta_headers",
"def readFrom(self,fn):\n hdrs = {}\n try:\n f = open(fn+\".headers\",\"tr\")\n for l in f:\n if l[-1:]==\"\\n\":\n l = l[:-1]\n i = l.find(\": \")\n if -1!=i:\n hdrs[l[:i]] = l[i+2:]\n f.close()\n except (Exception,Error) as err:\n log(\"readFrom: header: error: \"+str(err))\n try:\n f2 = open(fn,\"br\")\n data = f2.read()\n f2.close()\n except (Exception,Error) as err:\n log(\"readFrom: body: error: \"+str(err))\n return (hdrs,data)",
"def parse_headers(fp, _class=http.client.HTTPMessage):\n headers = []\n while True:\n line = fp.readline(http.client._MAXLINE + 1)\n if len(line) > http.client._MAXLINE:\n raise http.client.LineTooLong(\"header line\")\n headers.append(line)\n if len(headers) > http.client._MAXHEADERS:\n raise HTTPException(f\"got more than {http.client._MAXHEADERS} headers\")\n if line in (b'\\r\\n', b'\\n', b''):\n break\n\n hstring = b''.join(headers)\n inferred = chardet.detect(hstring)\n if inferred and inferred['confidence'] > 0.8:\n # print(\"Parsing headers!\", hstring)\n hstring = hstring.decode(inferred['encoding'])\n else:\n hstring = hstring.decode('iso-8859-1')\n\n return email.parser.Parser(_class=_class).parsestr(hstring)",
"def test_parse_header(self):\n data = parse_header(self.header)\n self.assertEqual(data.get(\"application\"), \"my Grandma\")\n self.assertEqual(data.get(\"version\"), \"has\")\n self.assertEqual(data.get(\"reference\"), \"furry\")\n self.assertEqual(data.get(\"query_letters\"), 27)\n self.assertEqual(data.get(\"database\"), \"Cats\")",
"def _build_header_dictionary(self):\n start = 0\n #print self.raw_data\n for a in range(20):\n redatapuller = re.compile(\"\\r\\n\\r\\n\\r\\n(?P<word>.*?)\\t.*?\\n\", re.DOTALL)\n m = redatapuller.search(self.raw_data[start:])\n if not(m):\n break\n self.header_dictionary[m.group(\"word\")] = start + m.end()\n if a==0:\n self.header_dictionary[\"main\"] = start + m.end()\n start += m.end()",
"def parse_header_links(value):\n\n links = []\n rels = {}\n replace_chars = \" '\\\"\"\n\n for val in re.split(\", *<\", value):\n try:\n url, params = val.split(\";\", 1)\n except ValueError:\n url, params = val, ''\n link = {}\n link[\"url\"] = url.strip(\"<> '\\\"\")\n for param in params.split(\";\"):\n try:\n key, value = param.split(\"=\")\n except ValueError:\n break\n link[key.strip(replace_chars)] = value.strip(replace_chars)\n\n if (\"rel\" in link): rels[link[\"rel\"]] = link[\"url\"]\n links.append(link)\n return rels",
"def parse_header_block(lines):\n data = [line for line in lines[:MAX_HEADER_HEIGHT] if line.strip()]\n if not data or not INVITATION_RE.match(data[0]):\n return None\n out = {'number':None, 'type':None, 'date':None, 'time':None, 'place':None, 'datetime':None}\n for item in data:\n # typ a poradove cislo zastupitelstva\n m = TITLE_RE.match(item)\n if m:\n out['number'] = m.group(1).strip()\n out['type'] = m.group(2).strip()\n\n # den konani zastupitelstva\n m = TERM_DATE_RE.match(item)\n if m:\n try:\n out['date'] = date(int(m.group(3).strip()), int(m.group(2).strip()), int(m.group(1).strip()))\n except ValueError:\n pass\n\n # cas konani zastupitelstva\n m = TERM_TIME_RE.match(item)\n if m:\n try:\n out['time'] = time(int(m.group(1).strip()), int(m.group(2).strip()))\n except ValueError:\n pass\n\n # misto konani zastupitelstva\n m = PLACE_RE.match(item)\n if m:\n out['place'] = m.group(1).strip()\n\n # poskladani kompletniho datetime objektu\n out['datetime'] = out['date'] and out['time'] and \\\n datetime.combine(out['date'], out['time']) or None\n\n return out",
"def read_headers(self, string_series):\n top_header = string_series.iloc[[0]].to_values(\n r'\\s+', data_type=int)[0]\n headers = {\n 'n_node': top_header[0],\n 'n_element': top_header[1],\n 'all_dim_nodal_data': top_header[2],\n 'all_dim_elemental_data': top_header[3],\n }\n\n if headers['all_dim_nodal_data'] != 0:\n nodal_data_header = string_series.iloc[[\n headers['n_node'] + headers['n_element'] + 1\n ]].to_values(r'\\s+', data_type=int)[0]\n headers.update({\n 'n_nodal_data': nodal_data_header[0],\n 'nodal_data_dims': nodal_data_header[1:],\n })\n else:\n headers.update({\n 'n_nodal_data': 0,\n 'nodal_data_dims': [0],\n })\n\n if headers['all_dim_elemental_data'] != 0:\n elemental_data_header = string_series.iloc[[\n headers['n_node'] + headers['n_element'] + 1\n + headers['n_nodal_data']\n + min(1, headers['n_nodal_data']) * (headers['n_node'] + 1)\n ]].to_values(r'\\s+', data_type=int)[0]\n headers.update({\n 'n_elemental_data': elemental_data_header[0],\n 'elemental_data_dims': elemental_data_header[1:],\n })\n else:\n headers.update({\n 'n_elemental_data': 0,\n 'elemental_data_dims': [0],\n })\n\n return headers",
"def spamHeaders(self) -> Tuple[List[str], Dict[str, str]]:\n sections = [\"STATUS\", \"TITLE\", \"PROJECT\", \"FILE\", \"SITE\", \"CHANNAME\", \"DATA\"]\n sectionHeaders = {}\n sectionHeaders[\"STATUS\"] = [\"STATUS\"]\n sectionHeaders[\"TITLE\"] = [\"AUTHOR\", \"VERSION\", \"DATE\", \"COMMENT\"]\n sectionHeaders[\"FILE\"] = [\"NAME\", \"FREQBAND\", \"DATE\"]\n sectionHeaders[\"CHANNAME\"] = [\"ITEMS\", \"NAME\"]\n sectionHeaders[\"DATA\"] = [\"ITEMS\", \"CHAN\"]\n return sections, sectionHeaders",
"def header_info(msg_ids, accumulator):\n headers = []\n for ms_id in msg_ids:\n if ms_id in accumulator.headers_map.keys():\n headers.append(accumulator.headers_map[ms_id])\n return headers",
"def get_header(json_list):\n header = set()\n for dict in json_list:\n header.update(dict.keys())\n return list(header)",
"def encode_meta_headers(headers):\n ret = {}\n for header, value in headers.items():\n value = encode_utf8(value)\n header = header.lower()\n\n if (isinstance(header, str) and\n header.startswith(USER_METADATA_TYPE)):\n header = encode_utf8(header)\n\n ret[header] = value\n return ret",
"def convert_headers(self, tickers):\n\n result = _makehash()\n for pair_name, fetched_values_dict in list(tickers.items()):\n for header, value in list(fetched_values_dict.items()):\n result[pair_name][self.config['headers'][header]] = value\n return result",
"def headers(self, v):\n raise NotImplementedError",
"def _parse_challenge(header):\n # type: (str) -> Dict[str, str]\n ret = {}\n if header.startswith(BEARER):\n challenge_params = header[len(BEARER) + 1 :]\n\n matches = re.split(AUTHENTICATION_CHALLENGE_PARAMS_PATTERN, challenge_params)\n _clean(matches)\n ret = {}\n for i in range(0, len(matches), 2):\n ret[matches[i]] = matches[i + 1]\n\n return ret",
"def _get_cleaned_headers(headers):\r\n cleaned_headers = []\r\n for header in headers:\r\n # Google strips special characters, whitespace, and underscores first,\r\n # and then strips any *leading* digits. This order is extremely\r\n # important!\r\n sanitized = sub(r'^\\d+', '', sub(r'[\\W_]', '', header.lower()))\r\n if len(sanitized) > 0:\r\n cleaned_headers.append(sanitized)\r\n else:\r\n raise GoogleSpreadsheetError(\"Encountered a header '%s' that was \"\r\n \"either blank or consisted only of special characters. \"\r\n \"Could not map the header to the internal representation \"\r\n \"used by the Google Spreadsheet. Please change the header \"\r\n \"to consist of at least one alphanumeric character.\"\r\n % header)\r\n\r\n # When the same sanitized header appears multiple times in the first row\r\n # of a spreadsheet, _n is appended to the name to make it unique.\r\n header_count = defaultdict(int)\r\n results = []\r\n\r\n for header, cleaned_header in zip(headers, cleaned_headers):\r\n new_header = cleaned_header\r\n\r\n if header_count[cleaned_header] > 0:\r\n # Google's numbering starts from _2, hence the +1.\r\n new_header = '%s_%d' % (cleaned_header,\r\n header_count[cleaned_header] + 1)\r\n\r\n header_count[cleaned_header] += 1\r\n results.append(new_header)\r\n\r\n return results",
"def manage_headers(dem_header_file, header_paths):\n dem_header = parse_dem_header(dem_header_file)\n # find param files containing filename dates\n if len(header_paths) == 2:\n headers = [parse_epoch_header(hp) for hp in header_paths]\n combined_header = combine_headers(headers[0], headers[1], dem_header)\n else:\n # probably have DEM or incidence file\n combined_header = dem_header\n combined_header[ifc.DATA_TYPE] = ifc.DEM\n\n return combined_header",
"def _get_headers(environ):\n # type: (Dict[str, str]) -> Iterator[Tuple[str, str]]\n for key, value in iteritems(environ):\n key = str(key)\n if key.startswith(\"HTTP_\") and key not in (\n \"HTTP_CONTENT_TYPE\",\n \"HTTP_CONTENT_LENGTH\",\n ):\n yield key[5:].replace(\"_\", \"-\").title(), value\n elif key in (\"CONTENT_TYPE\", \"CONTENT_LENGTH\"):\n yield key.replace(\"_\", \"-\").title(), value",
"def extract_from_header(headers, header_type):\n LOG.debug(f\"[extract_from_header] extracting `{header_type}` from headers: {headers}\")\n if headers is None:\n return\n for header in headers:\n if header_type in header:\n for item in header:\n if item == header_type or item is None:\n continue\n else:\n return item.decode(\"ascii\")\n return",
"def headers(self):\r\n return dict(**self._get_headers())",
"def _headers(self) -> Mapping[str, str]:\n return self.auth.headers() if self.auth else {}",
"def getAllHeaders():",
"def parse_api_header(content):\n result = {}\n for line in content.split('\\n'):\n for kw in KEYWORDS:\n if kw in line:\n _, _, value = line.strip().split()\n value = value.strip()\n\n if kw == oqs.CRYPTO_ALGNAME:\n assert value[0] == value[-1] == '\"'\n value = value[1:-1]\n\n result[kw] = value\n break\n\n return result",
"def headers(self) -> dict:\n raise NotImplementedError # pragma: no cover",
"def _format_header(fields):\n # The list into which we will collect header lines.\n lines = []\n for name, value in fields.items():\n # A header line looks like, \"name: value\".\n line = name + COLON + SPACE + value\n # Add this line to the list.\n lines.append(line)\n return lines",
"def headers(self):\n return Dict(**self._get_headers())",
"def test_get_cleaned_headers(self):\r\n # Some duplicates.\r\n exp = ['foo', 'foo_2', 'foo_3', 'foo_4', 'fooo', 'foo_5', 'foo_6',\r\n 'foo_7', 'foo_8', 'foo_9', 'f2oo456', 'foo_10']\r\n obs = _get_cleaned_headers(\r\n ['foo', 'Foo', 'FOO', 'F_oO', 'F:Oo_o', '123foo', '#Foo',\r\n '123foo', ' 123Foo', 'f O\\tO#', ' f2\\too456', '456 foo'])\r\n self.assertEqual(obs, exp)\r\n\r\n # All unique.\r\n exp = ['foo', 'bar']\r\n obs = _get_cleaned_headers(['Fo#o', 'bar'])\r\n self.assertEqual(obs, exp)\r\n\r\n # Header consisting of only special characters and header that is\r\n # blank.\r\n self.assertRaises(GoogleSpreadsheetError, _get_cleaned_headers,\r\n ['Foo', '___', 'BAR'])\r\n self.assertRaises(GoogleSpreadsheetError, _get_cleaned_headers,\r\n ['Foo', '', 'BAR'])",
"def getHeaders(self):\n hd = {}\n line = self.conn.readline()\n while line != \"\\r\\n\":\n print \":\"+line+\":\"+\" len = \",len(line)\n key,value = line.split(':',1)\n hd[key] = value.rstrip()\n line = self.conn.readline()\n return hd",
"def parse_header(header_string):\r\n header_string = str(header_string)\r\n header_string = header_string.replace(\"b'\", \"\")\r\n header = header_string.split()\r\n header_nums = []\r\n for j in range(len(header) - 1):\r\n header_nums.append(int(header[j]))\r\n header = header_nums\r\n freq_list = [0] * 256\r\n for i, item in enumerate(header):\r\n if i % 2 == 0: # if a char\r\n freq_list[item] = header[i + 1] # update at freq its # of occurance\r\n freq_list[0] = 1\r\n return freq_list",
"def parse_header(f):\n columns = ['pokemon', 'species_id', 'height', 'weight', 'type_1', 'type_2',\n 'url_image', 'generation_id', 'evolves_from_species_id']\n sep = ','\n result = {}\n allData = []\n with open(const.DATA_FILENAME, newline=\"\") as myData:\n for line in myData:\n line = line.strip()\n line = line.split(sep)\n allData.append(line)\n for i in columns:\n j = 0\n while j < len(allData[0]):\n if allData[0][j] == i:\n result[i] = j\n j += 1\n return result",
"def header_values(header, mail):\n\tif header not in mail.keys():\n\t\traise HeaderMissed(header)\n\tvalues = [header_decode(mail[header])]\n\tif header in HEADER_ADDRESS_FIELDS:\n\t\treturn [email.utils.formataddr(x) for x in email.utils.getaddresses(values)]\n\treturn values",
"def test_normalize_headers():\n headers = [\n 'AllocationTransferAgencyIdentifier', 'BeginningPeriodOfAvailability', 'flex_mycol', 'FLEX_ANOTHER'\n ]\n mapping = {'allocationtransferagencyidentifier': 'ata', 'beginningperiodofavailability': 'boa'}\n\n result = csvReader.normalize_headers(headers, False, mapping)\n assert list(result) == [\n 'allocationtransferagencyidentifier', 'beginningperiodofavailability', 'flex_mycol', 'flex_another'\n ]\n result = csvReader.normalize_headers(headers, True, mapping)\n assert list(result) == ['ata', 'boa', 'flex_mycol', 'flex_another']",
"def parse_header(self):\n bodystart=re.compile(r\"<body>\", re.IGNORECASE).search(self.lines).span()[1]\n oldheader=self.lines[0:bodystart]\n start=re.compile(\"<title>\", re.IGNORECASE).search(oldheader).span()[1]\n finish=re.compile(\"</title>\", re.IGNORECASE).search(oldheader).span()[0]\n titles=oldheader[start:finish].split(\"--\")\n # Duplicate if needed\n if len(titles)==1: titles.append(titles[0])\n self.title, self.header= {}, {}\n for i, lang in enumerate(LANGS):\n self.title[lang]=titles[i]\n self.header[lang]=\"%s%s%s\" % (oldheader[:start], self.title[lang], oldheader[finish:],)",
"def parse_header_dict(self, header_dict=None):\n if header_dict is not None:\n self.header_dict = header_dict\n\n assert isinstance(self.header_dict, dict)\n\n for key, value in self.header_dict.items():\n if \"wire\" in key:\n if key.find(\"n\") == 0:\n self.ex_length = float(value.split()[0])\n self.ex_azimuth = float(value.split()[1])\n elif key.find(\"e\") == 0:\n self.ey_length = float(value.split()[0])\n self.ey_azimuth = float(value.split()[1])\n elif \"system\" in key:\n self.box_id = value.split(\";\")[0].strip()\n self.mag_id = value.split(\";\")[1].strip()\n elif \"gps\" in key:\n gps_list = value.split()\n self.header_gps_stamp = MTime(\n dateutil.parser.parse(\n \" \".join(gps_list[0:2]), dayfirst=True\n )\n )\n self.header_gps_latitude = self._get_latitude(\n gps_list[2], gps_list[3]\n )\n self.header_gps_longitude = self._get_longitude(\n gps_list[4], gps_list[5]\n )\n self.header_gps_elevation = float(gps_list[6])\n elif \"run\" in key:\n self.run_id = value.replace('\"', \"\")\n else:\n setattr(self, key.replace(\" \", \"_\").replace(\"/\", \"_\"), value)",
"def get_headers_dict(self) -> Dict[Text, Text]:\n headers_dict: Dict = dict()\n\n # load values into headers dict\n headers_dict[\"container-name\"] = self.get_name()\n headers_dict[\"container-image\"] = self.get_image()\n headers_dict[\"container-is-started\"] = self.is_started()\n headers_dict[\"container-is-ready\"] = self.is_ready()\n headers_dict[\"container-restarts\"] = self.get_restart_count()\n\n # add in state values\n headers_dict.update(self.get_state_dict())\n\n # return the dict\n return headers_dict",
"def get_header(header_row):\n header = {}\n header['station'], c1, c2, c3, date, time, tz = header_row.split()\n header['short_model'] = c1\n header['model'] = f'{c1} {c2} {c3}' \n header['runtime'] = dateutil.parser.parse(f'{date} {time} {tz}')\n return header",
"def parse_log_headers(headers: str) -> (('label', 'unit'),):\n return tuple((label, (unit or None))\n for label, unit in HEADER_RE.findall(headers))",
"def parser_headings(xmlthing):\n match = RE_HEADINGS.search(u(xmlthing))\n if match:\n try:\n buf = match.group()\n flds = RE_FLDS.findall(buf)\n vals = RE_VALS.findall(buf)\n return dict(zip(flds, vals))\n except Exception: # pragma: no cover\n LOGGER.debug(\"Bad parsing of 'headings' for 'oclc' service!\")\n return {} # pragma: no cover",
"def build_headers(self):\n\n # User-agent is always sent\n headers = {'user-agent': self.useragent}\n for hdr in self.config.client_standard_headers:\n val = getattr(self.config, 'client_' + hdr.lower().replace('-','_'))\n headers[hdr] = val\n\n return headers",
"def getHeaders(self, args, pascalCase = False):\n\t\tfilePath, idxStart, idxEnd, regex = args\n\t\theaders = []\n\n\t\twith open(filePath, 'r', encoding=\"utf-8\") as fp: \n\t\t\tlines = fp.readlines()[idxStart:idxEnd]\t\t\t\n\t\t\tfor ln in lines:\n\t\t\t\tkey = search(regex, ln)\n\n\t\t\t\tif key:\n\t\t\t\t\t# Removes the last char (e.g. :)\n\t\t\t\t\tkey = key.group()[:-1]\n\t\t\t\t\t# Puts the string in pascal case\n\t\t\t\t\tif pascalCase: key = ''.join(x for x in key.title() if not x.isspace())\n\n\t\t\t\t\theaders.append(key)\n\n\t\treturn headers",
"def headers(self) -> Mapping[str, str]:\n return pulumi.get(self, \"headers\")",
"def parse_specimen_dict(spec_filename, header_exists=True):\n\n spec_file = open(spec_filename, \"r\")\n specimen_dict = dict()\n\n if header_exists:\n header = spec_file.readline()\n\n for line in spec_file:\n line = line.rstrip()\n line = line.split(\"\\t\")\n\n if(not(line[0] == \"\")):\n specimen_dict[line[0]] = (line[1], line[2])\n\n spec_file.close()\n return specimen_dict",
"def scrub_headers(headers):\n if isinstance(headers, dict):\n headers = headers.items()\n headers = [\n (parse_header_string(key), parse_header_string(val))\n for (key, val) in headers\n ]\n if not logger_settings.get('redact_sensitive_headers', True):\n return dict(headers)\n if logger_settings.get('reveal_sensitive_prefix', 16) < 0:\n logger_settings['reveal_sensitive_prefix'] = 16\n return {key: safe_value(key, val) for (key, val) in headers}",
"def _readheader(lines):\n hdrdict = {}\n #input list of 26 lines of header\n #station and channel\n line = lines[5]\n parts = line.strip().split()\n fname = parts[1]\n fparts = fname.split('_')\n hdrdict['station'] = fparts[-2]+'_'+fparts[-1]\n\n #the \"Component\" lines look like either: Component S00W, Component S90E, Component Up\n compstr = lines[12].strip().split()[1]\n hdrdict['channel'] = get_comp_name(compstr)\n\n #instrument\n hdrdict['instrument'] = lines[3].split()[1].strip()\n \n #location string\n line = lines[6]\n hdrdict['location'] = line.strip()\n #event origin, buffer start year/month\n line = lines[16]\n parts = line.strip().split()\n bufyear = int(parts[8])\n bufmonth = int(parts[9])\n #epicentral location, buffer start day/hour\n line = lines[17]\n parts = line.strip().split()\n bufday = int(parts[8])\n bufhour = int(parts[9])\n #numpoints, buffer start min/sec\n line = lines[19]\n parts = line.strip().split()\n hdrdict['npts'] = int(parts[0])\n bufmin = int(parts[8])\n millisec = int(parts[9])\n bufsec = int(millisec/1000)\n bufmicrosec = int(np.round(millisec/1000.0 - bufsec))\n hdrdict['starttime'] = UTCDateTime(datetime(bufyear,bufmonth,bufday,bufhour,bufmin,bufsec,bufmicrosec))\n #part C\n #frequency, calibration value and some other stuff we don't care about\n line = lines[20]\n parts = line.strip().split()\n hdrdict['sampling_rate'] = float(parts[0])\n hdrdict['delta'] = 1.0/hdrdict['sampling_rate']\n hdrdict['calib'] = float(parts[7])\n #site location info, this time in dd\n line = lines[21]\n parts = line.strip().split()\n hdrdict['lat'] = float(parts[0]) * -1\n hdrdict['lon'] = float(parts[1])\n hdrdict['height'] = 0.0\n #duration\n line = lines[22]\n parts = line.strip().split()\n hdrdict['duration'] = float(parts[0])\n hdrdict['endtime'] = hdrdict['starttime'] + hdrdict['duration']\n #max acceleration - good for sanity check\n line = lines[23]\n parts = line.strip().split()\n hdrdict['maxacc'] = float(parts[0])\n hdrdict['network'] = 'NZ'\n hdrdict['units'] = 'acc'\n return hdrdict",
"def getHeaderDict(self):\r\n #put the headers into a dict\r\n \r\n print(\"opening \",self.filename)\r\n with open(self.filename, 'r') as readfile:\r\n headers = readfile.readline()\r\n firstrow = readfile.readline()\r\n if not firstrow:\r\n print(\"first line after headers is blank\")\r\n self.loadDictRow(keystring=headers)\r\n else: #assume first row after headers is test router\r\n print(\"load test router row\") \r\n self.loadDictRow(keystring = headers, valuestring = firstrow) \r\n \r\n # check for headers\r\n miscount=0\r\n for key in self.dataheader:\r\n if not key in self.objdict:\r\n print(\"missing key !\", key)\r\n miscount += 1\r\n\r\n if miscount == 0:\r\n print(\"all Columns found. Thank you.\")\r\n # elif (miscount == 11) and (\"IPADDRESS\" in ):\r\n # print(\"Found IP Address column. program will add additional columns\")\r\n elif miscount > 11:\r\n print(\"Could not locate Header Row\")\r\n elif miscount > 0:\r\n print(\"some columns missing, will add additional columns\")\r\n \r\n \r\n #end file check on filename \r",
"def _prefixed_items_from_list(items: List[namedtuple], item_prefix, prefix, tag_names: Set[str] = set([])):\n result = {}\n for index, nt in enumerate(items):\n result[\"%s%d\" % (item_prefix, index)] = _parse(nt, prefix, tag_names)\n return result",
"def parse_cookies( headers ):"
] | [
"0.78225195",
"0.74253625",
"0.73871934",
"0.7215364",
"0.7209012",
"0.71768695",
"0.7095645",
"0.70905596",
"0.70813763",
"0.70813763",
"0.70154387",
"0.6994542",
"0.6965097",
"0.69445574",
"0.6913696",
"0.6835682",
"0.6808548",
"0.6762677",
"0.6754819",
"0.6710498",
"0.6692153",
"0.6673916",
"0.6601852",
"0.6580222",
"0.64974713",
"0.64949113",
"0.6489278",
"0.64567626",
"0.64103353",
"0.64019674",
"0.638692",
"0.6383157",
"0.6367993",
"0.6289359",
"0.6234642",
"0.62230325",
"0.61886346",
"0.61842465",
"0.6143589",
"0.6123308",
"0.61129284",
"0.61084205",
"0.61074835",
"0.60818875",
"0.60673344",
"0.60480237",
"0.6046546",
"0.604177",
"0.6025002",
"0.601387",
"0.6009226",
"0.59718233",
"0.59713715",
"0.59595656",
"0.5945021",
"0.59339154",
"0.5925607",
"0.59248817",
"0.59127426",
"0.5909621",
"0.5909267",
"0.5901867",
"0.5898775",
"0.5895869",
"0.5893249",
"0.58812934",
"0.5870251",
"0.5862537",
"0.5860587",
"0.58491766",
"0.58388954",
"0.58378696",
"0.58324355",
"0.5821715",
"0.58179957",
"0.5814727",
"0.5810107",
"0.5786599",
"0.5785399",
"0.5782124",
"0.57768923",
"0.577685",
"0.57675445",
"0.5763781",
"0.57515776",
"0.5749878",
"0.5741427",
"0.5737987",
"0.5733218",
"0.5722964",
"0.57058865",
"0.57058483",
"0.5697634",
"0.5697485",
"0.56916237",
"0.5687768",
"0.5681788",
"0.5681068",
"0.5677937",
"0.56755644"
] | 0.806986 | 0 |
Returns HTTP response as raw bytes | def serialize(self) -> bytes:
headers = "\r\n".join(
f"{header}: {value}" for header, value in self.headers.items()
)
return (
f"HTTP/1.0 {self.status} {STATUS_CODES[self.status]}\r\n"
f"{headers}\r\n"
"\r\n"
).encode("utf-8") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def raw_response(self):\r\n return self._full_response",
"def unparsed_response(self) -> bytes:\n return self._unparsed_response",
"def get_raw_data(url):\n\n req = requests.get(url, stream=True)\n req.raw.decode_content = True\n return req.raw",
"def return_response_string(self):\n response = \"{} {}\\r\\n\".format(self.protocol, self.code)\n str_headers = \"\"\n if self.headers:\n for k, v in self.headers.items():\n str_headers += \"{}: {}\\r\\n\".format(k, v)\n\n encoded_response = \"{}{}\\r\\n\".format(response, str_headers)\n encoded_response = encoded_response.encode(\"utf-8\")\n if self.body:\n if type(self.body) is not bytes:\n self.body = self.body.encode(\"utf-8\")\n encoded_response = encoded_response + self.body\n return encoded_response",
"def _get_raw_html(self):\n buffer = BytesIO()\n c = pycurl.Curl()\n c.setopt(c.URL, self.url)\n c.setopt(c.WRITEDATA, buffer)\n c.perform()\n c.close()\n return buffer.getvalue()",
"def getresponse(self):\n self.resp.status = self.resp.status_code\n old_getheader = self.resp.raw.getheader\n\n def _decode_header(string):\n if string is None:\n return string\n return string.encode('iso-8859-1').decode('utf-8')\n\n def _encode_header(string):\n if string is None:\n return string\n return string.encode('utf-8').decode('iso-8859-1')\n\n def getheaders():\n return [(_decode_header(k), _decode_header(v))\n for k, v in self.resp.headers.items()]\n\n def getheader(k, v=None):\n return _decode_header(old_getheader(\n _encode_header(k.lower()), _encode_header(v)))\n\n def releasing_read(*args, **kwargs):\n chunk = self.resp.raw.read(*args, **kwargs)\n if not chunk:\n # NOTE(sigmavirus24): Release the connection back to the\n # urllib3's connection pool. This will reduce the number of\n # log messages seen in bug #1341777. This does not actually\n # close a socket. It will also prevent people from being\n # misled as to the cause of a bug as in bug #1424732.\n self.resp.close()\n return chunk\n\n self.resp.getheaders = getheaders\n self.resp.getheader = getheader\n self.resp.read = releasing_read\n\n return self.resp",
"def read_raw(self) -> bytes:\n r = requests.get(self.raw_url)\n if r.status_code == 404:\n raise Exception(f\"Document {self.key} does not exist\")\n r.raise_for_status()\n return r.content",
"def _download_from_url(self) -> bytes:\n response = requests.get(self.url, allow_redirects=True)\n return response.content",
"def encode(self) -> bytes:\n\n encoded_message = struct.pack(Protocol.Formats.RESPONSE_FORMAT, self.response)\n return encoded_message",
"def get_binary(url):\n a = requests.get(url, stream=True)\n return a.content",
"def handle_upstream_response(self, raw: bytes) -> bytes:\n return raw # pragma: no cover",
"def generate_http_response(body):\n body = json.dumps(body, ensure_ascii=False).encode('utf8')\n return body",
"def get_response(self):\n result = self.get_response_impl()\n if self.log_dest is not None:\n is_error, response = result\n if is_error:\n response = \"? \" + response\n else:\n response = \"= \" + response\n self._log(\"<< \", response.rstrip())\n return result",
"def text_body(response: tornado.httpclient.HTTPResponse) -> str:\n return response.body.decode(encoding(response))",
"def request_content(self):\n try:\n length = int(self.headers.get('content-length'))\n\n except (TypeError, ValueError):\n return \"\"\n else:\n return self.rfile.read(length)",
"def request_content(self):\r\n try:\r\n length = int(self.headers.getheader('content-length'))\r\n\r\n except (TypeError, ValueError):\r\n return \"\"\r\n else:\r\n return self.rfile.read(length)",
"def _response(status_line):\n return b\"HTTP/1.1 \" + status_line + b\"\\nContent-length: 0\\n\\n\"",
"def get_response_byte(self):\n raise NotImplementedError",
"def getOutputStream(self):\r\n self._setHeaders()\r\n return self._response.getOutputStream()",
"def do_GET(self):\n self.send_head()\n f = io.BytesIO()\n f.write(self.output.encode())\n f.seek(0)\n shutil.copyfileobj(f, self.wfile)\n f.close()",
"def response_as_stream(self) -> Any:\n raise NotImplementedError # pragma: no cover",
"def make_request_txt(self):\n #print (self.url)\n try:\n with closing(get(self.url, stream=True)) as resp: #returns b`txt`\n if self.is_txt(resp):\n return resp.content.decode(\"utf-8\")\n else:\n return None\n except RequestException as e:\n print('Error during requests to {0} : {1}'.format(url, str(e)))\n return None",
"def get_content(self):\n return self.__response.content",
"def create_200_response(file: str) -> bytes:\n date = datetime.datetime.now(datetime.timezone.utc).strftime(\"%a, %d %b %Y %H:%M:%S GMT\")\n content_data = HttpServer.get_content_data(file)\n\n header = \"HTTP/1.1 200 OK\" + \"\\r\\nDate: \" + date + \"\\r\\n\" + content_data + \"\\r\\n\\r\\n\"\n print(header)\n raw_header = header.encode(HttpServer.FORMAT)\n raw_body = HttpServer.create_body(file)\n response = raw_header + raw_body\n\n return response",
"def get_raw_data(self):\n return self.content",
"def make_response(self, s):\n if sys.version_info[0] < 3:\n return s\n return s.encode('utf-8') # nocoverage - unreachable under py2",
"def content(self):\n return(self.__response.content)",
"def content(self):\n if hasattr(self.raw_content, 'read'):\n if hasattr(self.raw_content, 'seek'):\n self.raw_content.seek(0)\n data = self.raw_content.read()\n else:\n data = self.raw_content\n\n if isinstance(data, str):\n data = data.encode(\"utf-8\")\n return data",
"def response(flow: HTTPFlow) -> None:\n\n if Header().URL in flow.request.pretty_url:\n print(colored(f'Original Response Body: {flow.response.content}', 'cyan'))\n # decrypt\n plaintext = flow.response.content\n # return plaintext\n flow.response.content = plaintext\n print(colored(f'd2b.py response -> {flow.response.content}', 'blue'))",
"async def text(self, encoding=\"utf-8\", errors=\"strict\"):\n return self.response.decode(encoding, errors=errors)",
"def make_response_message(response):\n encoding = response.encoding or 'ISO-8859-1'\n original = response.raw._original_response\n response_headers = response.headers\n return HTTPMessage(\n line='HTTP/{version} {status} {reason}'.format(\n version='.'.join(str(original.version)),\n status=original.status, reason=original.reason,),\n headers=str(original.msg),\n body=response.content.decode(encoding) if response.content else '',\n content_type=response_headers.get('Content-Type'))",
"def decode_response(response):\n return response.read().decode('utf-8')",
"def get(self, request):\r\n data = {\r\n 'results': 'THIS IS THE PROTECTED STRING FROM SERVER',\r\n }\r\n return Response(data, status=status.HTTP_200_OK)",
"def response(self):\n return self._send(bytes([0xef,0xfe,0x02,0x0,0x0,0x0,0x0,0x0]))",
"def get_response(self, request):\n data = self.get_data(request)\n outrepr = self.get_outrepr(request)\n return outrepr(data)",
"def body(self):\n return self._response and self._response.body or \"\"",
"def bytes2response(data, level=3,\n method=None, url=\"http://example.com\", req_headers=None, req_files=None,\n req_data=None, req_auth=None, req_json=None\n ):\n # These imports can be moved outside to gain slight performance improvement\n # they are placed here by default to avoid compatible issues\n import http.client\n import requests.packages\n import requests.adapters\n \n fake_socket = FakeSocket(data)\n resp_builtin = http.client.HTTPResponse(fake_socket, method=method, url=url) # type: http.client.HTTPResponse\n resp_builtin.begin()\n if level == 0:\n return resp_builtin, resp_builtin.read() # type: http.client.HTTPResponse,bytes\n \n # resolve to the requests builtin urllib3 HTTPResponse\n resp_requests_basic = requests.packages.urllib3.response.HTTPResponse.from_httplib(resp_builtin)\n if level == 1:\n return resp_requests_basic # type: requests.packages.urllib3.response.HTTPResponse\n \n # fake Request\n req = requests.Request(\n method=method, url=url, headers=req_headers, files=req_files,\n data=req_data, auth=req_auth, json=req_json\n )\n req = req.prepare()\n \n # fake adapter, which is necessarily for response construct\n adapter = requests.adapters.HTTPAdapter()\n \n # resolve to the wellknown/often-see requests.Response\n wellknown_resp = adapter.build_response(req, resp_requests_basic)\n wellknown_resp._content = resp_requests_basic.data\n \n return wellknown_resp # type: requests.Response",
"def raw_convert_file():\n try:\n str_out = io.BytesIO()\n str_out.write(process_text(request.data.decode('utf-8')).encode('utf-8'))\n str_out.seek(0)\n\n return send_file(\n str_out,\n attachment_filename='result.txt',\n as_attachment=True,\n mimetype='text/plain'\n )\n except:\n return make_response('', 400)",
"def raw(self):\n try:\n return urlopen(str(self.url))\n except HTTPError as error:\n try:\n # parse error body as json and use message property as error message\n parsed = self._parsejson(error)\n raise RequestError(parsed['message']) from None\n except ValueError:\n # when error body is not valid json, error might be caused by server\n raise StatbankError() from None",
"def printable_reponse(self):\n resp = self.response\n msg = \"-- Reponse : {} -- \\r\\n\".format(resp.status_code)\n msg += \"Headers: {} \\r\\n\".format(str(resp.headers))\n msg += \"Body: {} \\r\\n\\r\\n\".format(str(resp.content))\n return msg",
"def get_bytes_content(url: str) -> bytes:\n\n url = _fix_url(url)\n\n return get(url).content",
"def __get_post_body(self):\n content_len = int(self.headers.getheader('content-length', 0))\n return self.rfile.read(content_len)",
"def raw(self):\n return self.data",
"def raw_body(self):\n return file_ops.read_utf8(self.raw_file_name)",
"async def get_byte(self, **kwargs: Any) -> JSON:\n error_map = {\n 401: ClientAuthenticationError,\n 404: ResourceNotFoundError,\n 409: ResourceExistsError,\n 304: ResourceNotModifiedError,\n }\n error_map.update(kwargs.pop(\"error_map\", {}) or {})\n\n _headers = kwargs.pop(\"headers\", {}) or {}\n _params = kwargs.pop(\"params\", {}) or {}\n\n cls: ClsType[JSON] = kwargs.pop(\"cls\", None)\n\n request = build_primitive_get_byte_request(\n headers=_headers,\n params=_params,\n )\n request.url = self._client.format_url(request.url)\n\n _stream = False\n pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access\n request, stream=_stream, **kwargs\n )\n\n response = pipeline_response.http_response\n\n if response.status_code not in [200]:\n if _stream:\n await response.read() # Load the body in memory and close the socket\n map_error(status_code=response.status_code, response=response, error_map=error_map)\n raise HttpResponseError(response=response)\n\n if response.content:\n deserialized = response.json()\n else:\n deserialized = None\n\n if cls:\n return cls(pipeline_response, cast(JSON, deserialized), {})\n\n return cast(JSON, deserialized)",
"def serialize(self, req, resp, resource) -> bytes:\n if self.cache_config['CACHE_CONTENT_TYPE_JSON_ONLY']:\n if FALCONVERSION_MAIN < 3:\n return resp.body\n else:\n return resp.text\n else:\n if FALCONVERSION_MAIN < 3:\n return msgpack.packb([resp.content_type, resp.body], use_bin_type=True)\n else:\n return msgpack.packb([resp.content_type, resp.text], use_bin_type=True)",
"def test_response_non_text_encoding():\n headers = {\"Content-Type\": \"image/png\"}\n response = httpcore.Response(200, content=b\"xyz\", headers=headers)\n assert response.text == \"xyz\"\n assert response.encoding == \"ascii\"",
"def process_response(raw_response):\n\n # Note Currently SNE supports text or application/json response\n # get the content - type\n content_type = raw_response.headers.get('content-type')\n result = ''\n if 'text' in content_type:\n result = raw_response.text\n elif 'application/json' in content_type:\n result = raw_response.json()\n else:\n result = raw_response.content\n\n return result",
"def to_http_string(self):\n method = self.method\n path = self.requested_path\n version = \"HTTP/1.0\\r\\n\"\n http_string = method+' ' + path+' ' + version\n for header in self.headers:\n http_string += header[0] + ':' + ' ' + header[1] + '\\r\\n'\n http_string += '\\r\\n'\n print(\"*\" * 50)\n print(\"[to_http_string] Implement me!\")\n print(\"*\" * 50)\n return http_string",
"def get_raw_response_content(url_iter):\n response = attempt_connection(url_iter)\n if response == None:\n debug(\"returning with None\")\n return None, None\n not_text = is_non_text_content(response)\n if not_text:\n return response, \"\"\n\n content = get_content(response, url_iter)\n\n cookie_str = contains_setCookie(content)\n if cookie_str != \"\":\n response = attempt_connection(url_iter, cookie_str)\n content = get_content(response, url_iter)\n\n return response, content",
"def get_response(self, url):\n\n conn = http.client.HTTPConnection('localhost:8080')\n conn.request('GET', url)\n\n response = conn.getresponse()\n self.assertEqual(200, response.getcode())\n\n conn.close()\n\n return response",
"def get_body(self):\r\n fp = self._environ['wsgi.input']\r\n return fp.read()",
"def getContent(self, url, data=None, referer=None):\n encoded_data = urlencode(data) if data else None\n # if referer is None: url\n default_headers = {'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.2.9) Gecko/20100824 Firefox/3.6.9 ( .NET CLR 3.5.30729; .NET4.0E)',\n 'Accept-Language': 'pt-br;q=0.5',\n 'Accept-Charset': 'utf-8;q=0.7,*;q=0.7',\n 'Accept-Encoding': 'gzip',\n 'Connection': 'close',\n 'Cache-Control': 'no-cache',\n 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',\n 'Referer': referer}\n\n req = Request(url, encoded_data, default_headers, origin_req_host=referer)\n\n retries = 0\n try:\n handle = self._opener.open(req)\n except HTTPError:\n retries += 1\n if retries > self.max_retries:\n raise\n if handle.info().get('Content-Encoding') == 'gzip':\n data = handle.read()\n buf = StringIO(data)\n f = GzipFile(fileobj=buf)\n response = f.read()\n else:\n response = handle.read()\n # return response.decode('utf-8')\n return response",
"def _to_bytes(self):\n return self.to_uri().to_text().encode('ascii')",
"def _bin_body_to_file(output_file_path, response):\n with open(output_file_path, \"wb\") as outfile:\n for chunk in response.iter_content(chunk_size=128):\n outfile.write(chunk)",
"def encodeResponse(self, response):\n return self.encoder.encode(response)",
"def get_contents_as_string(self, headers=None,\r\n cb=None, num_cb=10,\r\n torrent=False,\r\n version_id=None,\r\n response_headers=None):\r\n fp = StringIO.StringIO()\r\n self.get_contents_to_file(fp, headers, cb, num_cb, torrent=torrent,\r\n version_id=version_id,\r\n response_headers=response_headers)\r\n return fp.getvalue()",
"def reponse(self, data):\n response = self.response\n response.headers['Content-Type'] = 'application/json'\n json.dump(data, response.out)\n return response",
"def content(self):\n encoding = self.headers.get(\"Content-Transfer-Encoding\", None)\n content = self._part.content\n\n if encoding == \"base64\":\n return base64.b64decode(content)\n elif encoding == \"binary\":\n return content.strip(b\"\\r\\n\")\n else:\n return content",
"def test_response_non_text_encoding():\n headers = {\"Content-Type\": \"image/png\"}\n response = httpx.Response(\n 200,\n content=b\"xyz\",\n headers=headers,\n )\n assert response.text == \"xyz\"\n assert response.encoding == \"utf-8\"",
"def get_body(self):\n fp = self._environ['wsgi.input']\n return fp.read()",
"def render(self):\n\n # If the content type is not specified, we set\n # it to text/html as the default\n if 'content-type' not in map(lambda x:x.lower(), self.headers):\n self.headers['Content-Type'] = 'text/html'\n\n # Set headers as list of tuples\n self.headers = [(k, v) for k, v in self.headers.items()]\n\n # httplib.responses maps the HTTP 1.1 status codes to W3C names.\n # Output example: '200 OK' or '404 Not Found'\n resp_code = '{} {}'.format(self.code, httplib.responses[self.code])\n\n if str(self.code)[0] in ['4', '5'] and not self.data:\n self.make_response(resp_code, self.headers)\n return resp_code.encode('utf-8')\n\n try:\n data = bytes(self.data).encode('utf-8')\n except UnicodeDecodeError:\n data = bytes(self.data)\n \n self.make_response(resp_code, self.headers)\n return data",
"def raw_data(self):\n return self._raw_data",
"def raw_data(self):\n return self._raw_data",
"def get_body_encoded(self):\r\n return self.encode(self.get_body())",
"def get_server_response(self):\n\n response = []\n while True:\n\n try:\n returned_data = self.socket.recv(len(self.last_sent_request), socket.MSG_WAITALL)\n except socket.timeout:\n print(\"Unable to read response from host. Timed out.\")\n break\n\n if not returned_data:\n break\n else:\n response.append(returned_data.decode(\"utf-8\"))\n\n response_obj = HTTPResponse(''.join(response))\n return response_obj",
"def to_byte_array(self, http_string):\n return bytes(http_string, \"UTF-8\")",
"def to_byte_array(self, http_string):\n return bytes(http_string, \"UTF-8\")",
"def BuildResponse(status, rendered_data):\n response = http.HttpResponse(status=status,\n content_type=\"application/json; charset=utf-8\")\n response[\"Content-Disposition\"] = \"attachment; filename=response.json\"\n response[\"X-Content-Type-Options\"] = \"nosniff\"\n\n response.write(\")]}'\\n\") # XSSI protection\n\n # To avoid IE content sniffing problems, escape the tags. Otherwise somebody\n # may send a link with malicious payload that will be opened in IE (which\n # does content sniffing and doesn't respect Content-Disposition header) and\n # IE will treat the document as html and executre arbitrary JS that was\n # passed with the payload.\n str_data = json.dumps(rendered_data, cls=JSONEncoderWithRDFPrimitivesSupport)\n response.write(str_data.replace(\"<\", r\"\\u003c\").replace(\">\", r\"\\u003e\"))\n\n return response",
"def raw_data(self) -> str:\n return self._raw_data",
"def raw_data(self) -> str:\n return self._raw_data",
"def from_sync_httpx_response(cls, httpx_response, target, **kwargs):\n return httpcore.Response(\n status=httpx_response.status_code,\n headers=httpx_response.headers.raw,\n content=httpx_response.stream,\n extensions=httpx_response.extensions,\n )",
"def get_remote_bytes(file_url) -> io.BytesIO:\n result = urlfetch.fetch(file_url)\n return io.BytesIO(result.content)",
"def _get_json_response(self, url, data, headers):\n if data:\n data = json.dumps(data)\n req = urllib2.Request(url, data, headers)\n response = urllib2.urlopen(req)\n raw_response = response.read()\n return raw_response",
"def _fetch_http(self, url, params):\n params['format'] = 'json'\n # urllib.urlencode expects str objects, not unicode\n fixed = dict([(to_bytes(b[0]), to_bytes(b[1]))\n for b in params.items()])\n request = urllib2.Request(url, urllib.urlencode(fixed))\n request.add_header('Accept-encoding', 'gzip')\n response = self._opener.open(request)\n if isinstance(self._cj, cookielib.MozillaCookieJar):\n self._cj.save()\n if response.headers.get('Content-Encoding') == 'gzip':\n compressed = StringIO(response.read())\n gzipper = gzip.GzipFile(fileobj=compressed)\n data = gzipper.read()\n else:\n data = response.read()\n return data",
"def __get_raw_content(self, response):\n\n files = response.get('files')\n\n for f in files:\n file_data = files.get(f)\n if file_data.get('truncated'):\n r = requests.get(file_data.get('raw_url'))\n file_data.update({\n 'content': str(r.content, 'utf-8')\n })\n\n return response",
"def recvsafe(self):\n\n import base64\n\n data = self.as_bytes(self.recvraw())\n return base64.b85decode(data)",
"def _get_raw_data(self, url, series):\n url = self._get_url(url, series)\n try:\n response = self.http.request(url, headers=self._reqheaders)\n except httplib2.ServerNotFoundError as e:\n raise TVDBConnectError(e.message), None, sys.exc_info()[2]\n rep = response[0]\n log.debug(\n 'http-status:%s,content:%s', \n rep['status'], \n rep['content-type']\n )\n if int(rep['status']) >= 400:\n raise TVDBConnectError(\n 'Failed to get \"%s\" from thetvdb. errno:%s' % (\n series, rep['status']),\n rep['status']\n ) \n return response[1]",
"def _output(content):\n serve = True\n # check modifications and etag\n if 'If-Modified-Since' in request.headers:\n last_seen = datetime.datetime.strptime(\n request.headers['If-Modified-Since'], HTTP_DATE_FMT)\n if last_seen >= content.modified.replace(microsecond=0):\n serve = False\n if 'If-None-Match' in request.headers:\n etags = [x.strip('\" ')\n for x in request.headers['If-None-Match'].split(',')]\n if content.etag in etags:\n serve = False\n\n headers = {}\n if content.content_type:\n headers['Content-Type'] = content.content_type\n last_modified = content.modified.strftime(HTTP_DATE_FMT)\n headers['Last-Modified'] = last_modified\n headers['ETag']= '\"%s\"' % (content.etag,)\n for header in content.headers:\n key, value = header.split(':', 1)\n headers[key] = value.strip()\n if serve:\n response.body = content.body\n for key, value in headers.iteritems():\n response.set_header(key, value)\n response.content_type=content.content_type\n response.status=int(content.status)\n else:\n response.status=304\n return response",
"def httpretrieve_get_string(url, querydata=None, postdata=None, \\\r\n httpheaders=None, proxy=None, timeout=30):\r\n\r\n # Open a read-only file-like object for the HTTP request.\r\n httpobj = httpretrieve_open(url, querydata=querydata, postdata=postdata, \\\r\n httpheaders=httpheaders, proxy=proxy, timeout=timeout)\r\n\r\n # Read all of the response and return it.\r\n try:\r\n return httpobj.read()\r\n finally:\r\n httpobj.close()",
"def get_response(self):\n headers = HTTPHeaderMap()\n\n response = None\n while response is None:\n # 'encourage' the socket to receive data.\n self._sock.fill()\n response = self.parser.parse_response(self._sock.buffer)\n\n for n, v in response.headers:\n headers[n.tobytes()] = v.tobytes()\n\n self._sock.advance_buffer(response.consumed)\n\n if (response.status == 101 and \n b'upgrade' in headers['connection'] and \n H2C_PROTOCOL.encode('utf-8') in headers['upgrade']):\n raise HTTPUpgrade(H2C_PROTOCOL, self._sock)\n\n return HTTP11Response(\n response.status,\n response.msg.tobytes(),\n headers,\n self._sock,\n self\n )",
"def get_raw_data(self):\r\n \r\n return(self.return_data)",
"def get_content(url, headers={}, decoded=True):\n\n # print('get_content: %s' % url)\n\n req = request.Request(url, headers=headers)\n if cookies:\n cookies.add_cookie_header(req)\n req.headers.update(req.unredirected_hdrs)\n\n for i in range(10):\n try:\n response = request.urlopen(req)\n break\n except socket.timeout:\n print('request attempt %s timeout' % str(i + 1))\n\n data = response.read()\n\n\n if is_py2:\n response = response.info()\n\n # Handle HTTP compression for gzip and deflate (zlib)\n content_encoding = response.getheader('Content-Encoding')\n if content_encoding == 'gzip':\n data = ungzip(data)\n elif content_encoding == 'deflate':\n data = undeflate(data)\n\n # Decode the response body\n if decoded:\n charset = match1(response.getheader('Content-Type'), r'charset=([\\w-]+)')\n if charset is not None:\n data = data.decode(charset)\n else:\n data = data.decode('utf-8')\n\n return data",
"def get_contents_as_string(self, headers=None, cb=None, num_cb=10,\r\n torrent=False):\r\n\r\n fp = StringIO.StringIO()\r\n self.get_contents_to_file(fp)\r\n return fp.getvalue()",
"async def get_body_bytes(self) -> bytes:\n _bytes = b''\n async for chunk in self._request.stream():\n _bytes += chunk\n if len(_bytes) > int(\n tedious.config.CONFIG[\"ASGI\"][\"max-body-size\"]):\n raise BodyBytesTooLarge()\n return _bytes if len(_bytes) > 0 else None",
"def rawdata(self) -> str:\n return self._data",
"async def read(self) -> bytes:\n\n # NOTE(kgriffs): Yield to other tasks to give them a chance to\n # send us more body chunks if any are available.\n #\n # https://bugs.python.org/issue34476\n #\n await asyncio.sleep(0)\n\n if self._chunk_pos >= len(self._chunks):\n return b''\n\n data = b''.join(self._chunks[self._chunk_pos :])\n self._chunk_pos = len(self._chunks)\n\n return data",
"def _response(request):\n with urllib.request.urlopen(request) as response:\n status = response.getcode()\n # print(status, response.info(), )\n data = json.loads(\n response.read().decode('utf-8')\n )\n # print(data)\n if status == 200 and data[\"ok\"]:\n return data, status\n elif status == 200 and not data[\"ok\"]:\n raise ValueError('client._response() - Server response is not good ' +\n json.dumps(data))\n else:\n raise ConnectionFault('client._response() - Connection Error: ' +\n str(response.getcode()))",
"def process_raw_response(self):\n non_excepts = self.non_exceptionals\n raw = self.raw_response\n\n #if the raw respones is an urllib2 error act accordingly.\n if isinstance(raw, non_excepts):\n self.error = raw\n if isinstance(raw, HTTPError):\n self.status_code = raw.code\n self.headers = dict(raw.headers)\n else:\n #its a url error nothing to do\n pass\n\n else:\n #only urllib.addinfourl type should be now be possible\n self.status_code = raw.code\n self.headers = dict(raw.headers)\n self.body = \"\".join(raw.readlines())",
"def fetch(url, user_agent=\"django-oembed/0.1\"):\r\n request = urllib2.Request(url)\r\n request.add_header('User-Agent', user_agent)\r\n request.add_header('Accept-Encoding', 'gzip')\r\n opener = urllib2.build_opener()\r\n f = opener.open(request)\r\n result = f.read()\r\n if f.headers.get('content-encoding', '') == 'gzip':\r\n result = gzip.GzipFile(fileobj=StringIO(result)).read()\r\n f.close()\r\n return result",
"def do_GET(self): # TODO: add type.\n response_body = get_response_body(self.response_file)\n\n self.send_response(200)\n self.send_header('Content-type', 'text/html; charset=UTF-8')\n self.send_header('Content-length', len(response_body))\n self.end_headers()\n self.wfile.write(response_body.encode('utf-8'))\n logging.info('[Request method] GET')\n logging.info(\"[Request headers]\\n%s\", str(self.headers))",
"def _http_request(self, url):\n try:\n opener = urllib.build_opener()\n opener.addheaders = [('User-agent', 'Mozilla/5.0')]\n response = opener.open(url, None)\n #response = urllib.urlopen(url, timeout=5)\n return response.read()\n except (urllib.URLError, ValueError, IndexError, TimeoutException, BadStatusLine):\n return ''",
"def get_raw_data(self):\n return self.HTML",
"def content_str(self):\n return self.content.decode(self.encoding)",
"def response_data(self):\n return self._response_data",
"def get_binary(self, url: str, accept: str = None, token: str = None) -> Iterator[bytes]:\n with requests.get(url,\n headers=self._get_headers(\n token,\n {\"Content-Type\": None, \"Accept\": (accept or \"*/*\")}\n ),\n verify=False,\n stream=True,\n proxies=self._get_proxies()) as res:\n self._check_response(res, token)\n if not res.ok:\n logger.error(http_debug(res))\n elif logger.isEnabledFor(logging.DEBUG):\n logger.debug(http_debug(res))\n\n yield from res.iter_content(chunk_size=65536)",
"def handle_response(response):\n if isinstance(response, str):\n return response\n else:\n return response.decode('utf-8')",
"def get_response(self):\r\n response = self.response\r\n return response",
"def __send_response(self, response):\n logger.debug(' >>> %s', binascii.b2a_qp(response[0]))\n self.request.send(struct.pack('!I', len(response)))\n self.request.send(response)",
"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"
] | [
"0.6890451",
"0.6742287",
"0.6584883",
"0.6479265",
"0.64499426",
"0.64372015",
"0.6330324",
"0.62823755",
"0.62604046",
"0.62554294",
"0.61657286",
"0.6161668",
"0.61603785",
"0.615336",
"0.6128405",
"0.6104145",
"0.60856897",
"0.6075969",
"0.59855884",
"0.5960043",
"0.595298",
"0.59418553",
"0.5941064",
"0.59123224",
"0.5861417",
"0.5853812",
"0.5842209",
"0.58228415",
"0.57930046",
"0.5788623",
"0.57808745",
"0.5779465",
"0.5775389",
"0.5767626",
"0.5745646",
"0.57247424",
"0.5696745",
"0.5691621",
"0.56868285",
"0.56857836",
"0.56758356",
"0.5668303",
"0.5663528",
"0.5662671",
"0.5658544",
"0.56307423",
"0.56281656",
"0.5624255",
"0.5615508",
"0.56123227",
"0.5609188",
"0.5605147",
"0.5603805",
"0.55908275",
"0.55854565",
"0.5580885",
"0.5578825",
"0.55769736",
"0.55668014",
"0.556278",
"0.5538546",
"0.5532771",
"0.5518809",
"0.5518809",
"0.55140734",
"0.55026644",
"0.550119",
"0.550119",
"0.54924846",
"0.54845047",
"0.54845047",
"0.5484244",
"0.548195",
"0.5481003",
"0.54799616",
"0.5475529",
"0.5472443",
"0.5467486",
"0.5418535",
"0.54185224",
"0.5411515",
"0.54084605",
"0.5407214",
"0.54055977",
"0.54011565",
"0.5394157",
"0.5389917",
"0.5387011",
"0.5386698",
"0.5384374",
"0.53833234",
"0.5382955",
"0.5380676",
"0.5365032",
"0.5364062",
"0.53624123",
"0.53586584",
"0.5357909",
"0.535716",
"0.5355885"
] | 0.58378893 | 27 |
Initialize melon order class attributes | def __init__(self, species, qty, order_type, tax, country_code=None):
#Define all the attributes needed
self.species = species
self.qty = qty
self.country_code = country_code
self.shipped = False
self.order_type = order_type
self.tax = tax
#if the qty exceeds we raise the exception class
if self.qty > 100:
raise TooManyMelonsError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._order_list = []",
"def __init__(self, *args, **kwargs):\n self._orders = None\n super().__init__(*args, **kwargs)",
"def __init__(self):\n self.orders = {}",
"def __init__(self, order):\n self.order = order\n self.keys = []\n self.values = []\n self.leaf = True",
"def __init__(self):\n self._exchange_params_by_currency_id = None # type: Optional[ExchangeParams]\n self._utility_params_by_good_id = None # type: Optional[UtilityParams]\n self._transaction_fees = None # type: Optional[Dict[str, int]]\n self._quantity_shift = QUANTITY_SHIFT",
"def initialize(self):\n self.muondEdx = []\n self.muondNdx = []\n self.muonmomentum = []\n self.piondEdx = []\n self.piondNdx = []\n self.pionmomentum = []\n self.kaondEdx = []\n self.kaondNdx = []\n self.kaonmomentum = []\n self.protdEdx = []\n self.protdNdx = []\n self.protmomentum = []\n self.elecdEdx = []\n self.elecdNdx = []\n self.elecmomentum = []",
"def __init__(self, d=0., order=0., *args, **kwargs):\n self.d = d\n self.order = order\n print \"Mirror\", args, kwargs\n Element.__init__(self, *args, **kwargs)",
"def __init__(self):\n self.relation = ''\n self.attributes = []\n self.attribute_types = dict()\n self.attribute_data = dict()\n self.comment = []\n self.data = []\n pass",
"def __init__(self, order_id):\n self.order_items = []\n self.order_id = order_id",
"def __init__(self, symbol, order_type, quantity, direction):\n self.type = 'ORDER'\n self.symbol = symbol\n self.order_type = order_type\n self.quantity = quantity\n self.direction = direction",
"def __init__(self):\n self._distance_data = []\n self._location_data = []\n self._package_data = []",
"def __init__(self, order=0, shape=None):\n self.child = None\n self.shape = shape\n self.order = order\n self.index = 0",
"def __init__(self, atomic_number, element, mass, state):\n self.atomic_number = int(atomic_number)\n self.element = element\n self.mass = int(mass)\n self.state = int(state)",
"def __init__(self, order):\n self.n = order\n self.markov_dict = {}\n self.prob_dict = Counter()",
"def __init__(self):\n self.stack = []\n self.ordered = []",
"def clsorderinginit(cls, slots):\n # pylint: disable=W0601\n global slotlist\n if isinstance(slots, list):\n slotlist = slots\n else:\n print(\"Error expecting a list of slots as input\")\n cls.log(3, \"Error expecting a list of slots as input\")\n cls.initordering()\n cls.log(1, \"Class ordering Init\")",
"def __init__(self, species, qty):\n super(DomesticMelonOrder, self).__init__(species, qty)",
"def __init__(self):\n self.dependsOn = [] # Expected to contain Dependency objects.",
"def __init__(self):\n self._keys = []\n self._sortKeys = []",
"def init_attrs(self):\n raise NotImplementedError",
"def initialize(cls):",
"def __init__(self):\n self.comm = None\n self.rank = None\n self.size = None",
"def __init__(self, *args):\n\t\tfrom collections import OrderedDict\n\t\tnew_dict = {}\n\t\tfor x, y in enumerate(args):\n\t\t\tnew_dict.update({x: y})\n\t\tnew_dict = OrderedDict(sorted(new_dict.items()))\n\t\tself.__dict__ = new_dict",
"def __init__(self):\n self.number = None\n self.nodes = []\n self.type = None\n self.group = None\n self.material = None\n self.key = -1",
"def __init__(self, order_items: list):\n self.order_items = order_items\n self.destination = None",
"def __attrs_post_init__(self):",
"def __init__(self, m, c):\n self.m = m\n self.c = c",
"def __init__(self, **kwargs):\n self.is_initialized = False\n self.delta = 1",
"def __init__(self, process_list):\n self.__process_list = process_list\n self.__n_initial = len(process_list)",
"def __init__(self, order: [BBoxType] = None):\n\t\tself.order = order and list(reversed(order))",
"def __init__(self, position, momentum, mass):\n self.position = position\n self.momentum = momentum\n self.mass = mass",
"def __init__(self):\n self._data = PositionalList() # list of Item instances",
"def __init__(self, order, warehouse_list):\n self.order=order\n \"\"\" \n a list of object with warehouse name and inventory amounts \n (inventory distribution) for these items\n \"\"\"\n self.warehouse_list=warehouse_list\n \"\"\"total amout of item being ordered in this order\"\"\"\n self.total_order_amount=0\n for amount in order.values():\n self.total_order_amount+=amount",
"def __init__(self):\n self._data = PositionalList() # list of _Item instances",
"def __init__(self, *args, **kwargs):\n\n OrderedDict.__init__(self, *args, **kwargs)\n\n # the original parsed code, used for saving things out\n self.__orig = {}",
"def initialize(self, **kwargs):",
"def initialise(self):",
"def __init__(self, polyorder=2):\n self.polyorder = polyorder",
"def __init__(self, context):\n self.context = context\n \n self._m_ticket = self._m_ticket_initial\n\n self._d_orders = {}\n self._d_orders['trades'] = OrderedDict()\n self._d_orders['history'] = OrderedDict()\n self._d_orders['cancelled'] = OrderedDict()",
"def __init__(self):\n print(\"\\nStarting a new order.\\nThank you for visiting our on-line store!\")\n self.__items_list = []\n self.__purchase_date = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.__order_number = Order.__last_order_number_used + 1\n Order.__last_order_number_used = self.__order_number",
"def __post_init__(self, *args, **kwargs) -> None:\n # add other __init__ items here ...\n pass",
"def __init__(self):\n self.run = OrderedDict()",
"def __init__(self, species, qty, order_type, tax):\n self.species = species\n self.qty = qty\n self.shipped = False\n self.order_type = order_type\n self.tax = tax",
"def __post_init__(self):\n pass",
"def __init__(self, order_number, product_id, item_type, name, product_details, factory, quantity, holiday):\n self._order_number = order_number\n self._product_id = product_id\n self._item_type = item_type\n self._name = name\n self._product_details = product_details\n self._factory = factory\n self._quantity = quantity\n self._holiday = holiday\n self._is_valid = True\n self._invalid_notes = \"\"",
"def _init(self):\n pass",
"def __init__(\n self, warehouse_id: int, district_id: int, orders_to_examine: int\n ):\n super().__init__()\n self.warehouse_id = warehouse_id\n self.district_id = district_id\n self.orders_to_examine = orders_to_examine",
"def __init__(self):\n self.quantityList = []",
"def __init__(self,mk,level=2):\n\t\tself.Market=mk\n\t\tself.Level=level\n\t\tself.OrderBook=self.getMarketData(self.Level)",
"def __init__(self, **initial_attributes):\n\n for attribute_name, attribute_value in initial_attributes.items():\n setattr(self, attribute_name, attribute_value)",
"def create_order():",
"def __init__(self, order_json):\n self.shop = order_json['shop']\n self.size = order_json['size']\n self.customer_name = order_json['name']\n self.drink_name = order_json['drink']\n self.customer_number = order_json['customer_number']\n self.location = order_json['location']\n self.details = order_json['details']",
"def __init__(self, species, qty):\n\n self.species = species\n self.qty = qty\n self.shipped = False\n self.tax = 0.00\n # Adds a timestamp attribute when you instantiate any melon\n self.timestamp = dt.now()",
"def __init__(self):\n self.normal = []\n self.reverse = []",
"def __init__(self, order_details: OrderDetails):\n self.details = order_details",
"def __init__(self, num_carts, locations):\n self._locations = locations\n self._depot = 0 # packing zone index\n self._num_carts = num_carts",
"def __init__(self):\n\n self.sequence = []",
"def __init__(self) -> None:\n self.normal_customer: List[str] = list()\n self.priority_customer: List[str] = list()",
"def __init__(self, dao):\n RAMSTKDataModel.__init__(self, dao)\n\n # Initialize private dictionary attributes.\n\n # Initialize private list attributes.\n\n # Initialize private scalar attributes.\n\n # Initialize public dictionary attributes.\n\n # Initialize public list attributes.\n\n # Initialize public scalar attributes.",
"def extra_init(self):\n pass",
"def __init__(self, **kwds):\n raise NotImplementedError",
"def init(self) -> None:",
"def __init__(self, a, b, c):\r\n self.a = a\r\n self.b = b\r\n self.c = c",
"def __init__(self):\n super().__init__()\n self._connected = False\n self._connectedToBroker = False\n self._accountInformation = None\n self._positions = []\n self._orders = []\n self._specifications = []\n self._specificationsBySymbol = {}\n self._pricesBySymbol = {}",
"def __init__(self, **kwargs):\n self.__dict__.update(kwargs)\n self._calc_coords()",
"def __init__(self, attribute_names):\r\n self.attribute_names = attribute_names\r\n self.tree = None",
"def __init__(self):\n\n self._dict = OrderedDict(zip(const.BFHCOLS, [0] * 111))",
"def __init__(self,**kwargs):\n self.attr = ['angle','width','height','m','Fg','Fs','Fd','kf','Ff']\n # attributes of the incline in order: angle,width,height, mass,Fg(gravity force),Fs(statical force), Fd (dynamical force),kf(friction coefficient), Ff(friction force)\n self.data = {param: None for param in self.attr}#initialazing data\n self.given_data = set() #set of data given by user\n self.add_data(**kwargs)",
"def _init(self):",
"def initordering(cls):\n for i in range(len(clslist)):\n stages = cls.getConfigStages()\n for j in range(len(stages)):\n for k in range(len(slotlist)):\n cls.initorderingclsslot(clslist[i], stages[j], slotlist[k])\n # print(ordering)\n cls.log(1, ordering)",
"def __init__(self, args, kwargs):\n self._args_dec = list(args)\n self._kwargs_dec = dict(kwargs)",
"def __init__(self, species, qty):\n\n super().__init__(species, qty)\n self.order_type = \"domestic\"\n self.tax = 0.08",
"def __init__(self, order_dict):\n self.order_ref = order_dict['order_ref']\n\n self.error_status_code = order_dict.get('error_status_code', None)\n self.error_reason = order_dict.get('error_reason', None)\n self.status = order_dict.get('status')\n self.created = timeutils.parse_isotime(order_dict['created'])\n if order_dict.get('updated') is not None:\n self.updated = timeutils.parse_isotime(order_dict['updated'])\n else:\n self.updated = None\n self.secret_ref = order_dict.get('secret_ref')",
"def _set_init(self):\n ## Main information\n self.idxs = None\n self.sp_relative_pos = None\n ## Auxiliar information\n self.ks = None\n self.iss = [0]\n ## Class structural information\n self._setted = False\n self._constant_rel_pos = False\n self.staticneighs = None\n self.staticneighs_set = None",
"def __init__ (self):\n pass",
"def __init__(self):\r\n self.data = PositionalList()",
"def __init__(self, **attrs):\n \n self.minifig_id = None\n self.name = None\n self.pieces = None\n \n self.img_url = None\n \n self.count = None\n \n super().__init__(**attrs)",
"def __init__(self):\n # Dict of minecraft object in form of \"dict[id] = name\"\n self.data_values = dict()\n self.parser = self.setup_parser()",
"def __init__ (self, pseudo, bag, position, jeu):\n self.pseudo = pseudo\n self.bag = bag\n self.position = position\n self.jeu = jeu",
"def __init__(self, species, qty):\n #Include all arguments in exact order, if default values enter directly\n super (DomesticMelonOrder, self). __init__(species, qty, \"domestic\", 0.08)",
"def __init__(self, **kwargs):\n self.__dict__.update(kwargs)",
"def __init__(self, **kwargs):\n self.__dict__.update(kwargs)",
"def __init__(self, **keywords):\n # Set cord with the normal method if it was passed. Set atoms if\n # atomlist was passed. init() if both were passed.\n if keywords.has_key(\"cord\"):\n self.setcord(keywords[\"cord\"])\n if keywords.has_key(\"weights\"):\n self.setweights(keywords[\"weights\"])\n if keywords.has_key(\"cord\") and keywords.has_key(\"weights\"):\n self.init()",
"def __init__():",
"def __init__(self, **attrs):\n \n self.list_id = None\n self.name = None\n self.pieces = None\n \n super().__init__(**attrs)",
"def __init__(self, **kwargs):\n pass",
"def __init__(self, **kwargs):\n pass",
"def __init__(self, **kwargs):\n pass",
"def __init__(self, openChannels, spinGroups, **kwargs):\n\n ancestryModule.ancestry.__init__(self)\n self.channels = openChannels\n self.spinGroups = spinGroups\n for attr in self.optAttrList:\n setattr(self, attr, kwargs.get(attr))",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def __init__(self):\n super().__init__()\n self.n = 0.0\n self.p = 0.0\n self.type = 'Binomial'\n self.hasInfiniteBound = True\n self.distType = 'Discrete'\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'",
"def init(self):",
"def init(self):",
"def __init__(self, addendum, amount, tip_amount=None, transaction_id=None):\n self.__camelcase=constants.ALL_FIELDS\n self.__order=['Addendum', 'Amount', 'TipAmount', 'TransactionId']\n self.addendum=addendum\n self.amount=amount\n self.tip_amount=tip_amount\n self.transaction_id=transaction_id"
] | [
"0.74250233",
"0.6944454",
"0.6860201",
"0.6591807",
"0.65587133",
"0.6512998",
"0.65046525",
"0.649869",
"0.64915425",
"0.64882565",
"0.64488816",
"0.64295405",
"0.63480777",
"0.63372934",
"0.6327731",
"0.62828344",
"0.62793356",
"0.6275021",
"0.6272606",
"0.62568283",
"0.6247163",
"0.6245283",
"0.6234274",
"0.6233342",
"0.6231571",
"0.6209029",
"0.62073743",
"0.6163926",
"0.6162654",
"0.6157355",
"0.6149744",
"0.6137851",
"0.6135939",
"0.6134652",
"0.61252064",
"0.61211187",
"0.61054873",
"0.61004066",
"0.60882396",
"0.60857797",
"0.60737467",
"0.60730726",
"0.6055987",
"0.6053358",
"0.60426325",
"0.6037497",
"0.6036794",
"0.602994",
"0.60266614",
"0.6020846",
"0.6018013",
"0.60166556",
"0.60051787",
"0.5998676",
"0.5998027",
"0.5997193",
"0.59930193",
"0.59926736",
"0.5989966",
"0.59885675",
"0.5985484",
"0.59818226",
"0.5980722",
"0.5980185",
"0.59697056",
"0.5962058",
"0.5960094",
"0.5959131",
"0.59576863",
"0.5956889",
"0.59558225",
"0.59508145",
"0.59453946",
"0.5944699",
"0.59444624",
"0.59213734",
"0.5920344",
"0.5916395",
"0.5913025",
"0.5907942",
"0.59074897",
"0.59074897",
"0.58998734",
"0.5895501",
"0.5894681",
"0.5893536",
"0.5893536",
"0.5893536",
"0.58928037",
"0.58817536",
"0.58817536",
"0.58817536",
"0.58817536",
"0.58817536",
"0.58817536",
"0.58817536",
"0.58817536",
"0.5880439",
"0.5877774",
"0.5877774",
"0.587722"
] | 0.0 | -1 |
Set shipped to true. | def mark_shipped(self):
self.shipped = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mark_shipped(self):\n\n self.shipped = True\n # moved from DomesticMelonOrder",
"def setNewShip(self):\n self._ship = Ship()",
"def action_ship_create(self):\n res = super(SaleOrder, self).action_ship_create()\n for sale_order in self:\n if sale_order.invoiced:\n sale_order.picking_ids.write({'x_is_paid': True})\n return res",
"def setNewShip(self):\r\n self._ship = Ship(GAME_WIDTH/2,SHIP_BOTTOM+SHIP_HEIGHT/2,SHIP_WIDTH,\r\n SHIP_HEIGHT,'ship.png')",
"def shipper_reference(self, shipper_reference):\n\n self._shipper_reference = shipper_reference",
"async def ship(self, ctx):\r\n if ctx.invoked_subcommand:\r\n return\r\n defenders = ctx.message.mentions\r\n if defenders:\r\n for defender in defenders:\r\n captain = defender.name\r\n user_ship = Ship.find_ship(captain)\r\n if not user_ship:\r\n await ctx.send(\"{} does not yet have a ship.\".format(captain))\r\n else:\r\n em = discord.Embed(colour=0xAA0000)\r\n em.set_author(name=user_ship.ship_name, icon_url=defender.avatar_url)\r\n em.add_field(name='Ship Level: {}'.format(str(user_ship.level())),\r\n value=\"Win/Loss: {}/{}\".format(user_ship.win, user_ship.loss), inline=False)\r\n em.add_field(name=\"__Part__\", value=parts_print, inline=True)\r\n em.add_field(name=\"__Level__\", value=user_ship.info(), inline=True)\r\n em.set_footer(text=\"Their ship's coffers hold {} gold\".format(user_ship.gold),\r\n icon_url=\"https://cdn.discordapp.com/emojis/554730061463289857.gif\")\r\n em_msg = await ctx.send(embed=em)\r\n return\r\n\r\n captain = ctx.message.author.name\r\n user_ship = Ship.find_ship(captain)\r\n\r\n if not user_ship:\r\n user_ship = Ship(captain)\r\n user_ship.update(is_new=True)\r\n\r\n await ctx.send('Congratulations on the new ship, Captain {}! Welcome aboard!'\r\n '\\nCannons and Crew contribute to your attack,'\r\n ' while Armor and Sails contribute to defense\\nHere\\'s what she\\'s got:'.format(captain))\r\n\r\n em = discord.Embed(colour=0xDD0000)\r\n em.set_author(name=user_ship.ship_name,\r\n icon_url=ctx.message.author.avatar_url)\r\n em.add_field(name='Ship Level: {}'.format(str(user_ship.level())),\r\n value=\"Win/Loss: {}/{}\".format(user_ship.win, user_ship.loss), inline=False)\r\n #em.add_field(name='Ship Level', value=str(user_ship.level()), inline=False)\r\n em.add_field(name=\"__Part__\", value=parts_print, inline=True)\r\n em.add_field(name=\"__Level__\", value=user_ship.info(), inline=True)\r\n em.set_footer(text=\"Your ship's coffers hold {} gold\".format(user_ship.gold),\r\n icon_url=\"https://cdn.discordapp.com/emojis/554730061463289857.gif\")\r\n em_msg = await ctx.send(embed=em)",
"def on_ship(self, ship):\n # TODO: add ship to game\n # The game has a set combination of ships which is created when choosing the field size\n # (by battleships.ship_combination_creator()).\n # After that you need to create the player and add every ship from the combination (\n # without position) to his fleet. Done by add_ship(size) in the player class,\n # just cycle through the fleet_config of the Game class.\n # Then you need a button to determine the facing of the ship (north, west, east, south) and\n # something that shows which ship you are placing (either go through the array yourself\n # or by choosing the size per button).\n # Then the player needs to call position_ship(size, x, y, facing). If the ship cannot be\n # placed there (either because it conflicts with another ship or goes over the edge of\n # the board) the function will return a False, if it works it'll return True.\n # By calling check_ship_placement() from the Player class you can check whether all\n # ships are placed or not (returning True if all are placed, returning False if one or\n # more are still missing a position).\n # Apparently this is a commuication error on both sides:\n # This is how the ship placement works via the now built GUI:\n # New Game-> field size setting -> player name entry + ship placement,\n # via click, hoover and click (lenght of placed ship 1+hoover+1)\n # a list of coords creates the ship\n # {'n': [[(0, 0), (1, 0), (2, 0), (3, 0)]],\n # 'b': [[(1, 1), (2, 1), (3, 1), (4, 1)], [(2, 2), (2, 3), (2, 4)]]}\n\n if len(ship) < 3 or len(ship) > 6:\n # set length of ship to 3 to 6\n return False\n return True",
"def getShip(self):\n \"return self._ship\"\n if self._ship == None:\n return True\n return False",
"def shipping(self, shipping):\n\n self._shipping = shipping",
"def ship_goods(self, by=None):",
"def free_shipping(self, free_shipping):\n\n self._free_shipping = free_shipping",
"def shipCollided(self):\n self.shipHealth -= 1\n\n if self.shipHealth > 0:\n self.startInvincibilty()\n return True\n else:\n return False",
"def _createShip(self):\n self._ship=Ship()",
"def has_active_ship(self):\n if self.mark in (constants.ACTIVE_SHIP_MARK, constants.HIT_SHIP_MARK):\n return True\n return False",
"def drawShip(self,view):\r\n if not self.getShip() is None:\r\n self.getShip().draw(view)",
"def _ship_hit(self):\n\n if self.stats.ships_left > 0:\n #Decrement ships\n self.stats.ships_left -= 1\n self.sb.prep_ships()\n\n #Get rid of remaining aliens and bullets\n self.aliens.empty()\n self.bullets.empty()\n\n # Recenter the ship\n self.ship.center_ship\n\n # pause\n sleep(0.5)\n else:\n self.stats.game_active = False\n pygame.mouse.set_visible(True)",
"def has_destroyed_ship(self):\n if self.mark == constants.DEAD_SHIP_MARK:\n return True\n return False",
"def export_shipment_status_to_magento(self):\n Shipment = Pool().get('stock.shipment.out')\n Sale = Pool().get('sale.sale')\n\n instance = self.instance\n\n sale_domain = [\n ('magento_store_view', '=', self.id),\n ('shipment_state', '=', 'sent'),\n ('magento_id', '!=', None),\n ('shipments', '!=', None),\n ]\n\n if self.last_shipment_export_time:\n sale_domain.append(\n ('write_date', '>=', self.last_shipment_export_time)\n )\n\n sales = Sale.search(sale_domain)\n\n self.last_shipment_export_time = datetime.utcnow()\n self.save()\n\n for sale in sales:\n # Get the increment id from the sale reference\n increment_id = sale.reference[\n len(instance.order_prefix): len(sale.reference)\n ]\n\n for shipment in sale.shipments:\n try:\n # Some checks to make sure that only valid shipments are\n # being exported\n if shipment.is_tracking_exported_to_magento or \\\n shipment.state not in ('packed', 'done') or \\\n shipment.magento_increment_id:\n sales.pop(sale)\n continue\n with magento.Shipment(\n instance.url, instance.api_user, instance.api_key\n ) as shipment_api:\n item_qty_map = {}\n for move in shipment.outgoing_moves:\n if isinstance(move.origin, SaleLine) \\\n and move.origin.magento_id:\n # This is done because there can be multiple\n # lines with the same product and they need\n # to be send as a sum of quanitities\n item_qty_map.setdefault(\n str(move.origin.magento_id), 0\n )\n item_qty_map[str(move.origin.magento_id)] += \\\n move.quantity\n shipment_increment_id = shipment_api.create(\n order_increment_id=increment_id,\n items_qty=item_qty_map\n )\n Shipment.write(list(sale.shipments), {\n 'magento_increment_id': shipment_increment_id,\n })\n\n if self.export_tracking_information and (\n shipment.tracking_number and shipment.carrier\n ):\n shipment.export_tracking_info_to_magento()\n except xmlrpclib.Fault, fault:\n if fault.faultCode == 102:\n # A shipment already exists for this order,\n # we cannot do anything about it.\n # Maybe it was already exported earlier or was created\n # separately on magento\n # Hence, just continue\n continue\n\n return sales",
"def set_ship(self, ship: Ship):\n if self._ship:\n self._ship.stop_listening(self.ship_took_damage)\n\n self._ship = ship\n self._ship.take_damage.listen_post(\n self.ship_took_damage\n )\n\n # To reset any interfaces\n self.ship_took_damage(Damage('null'))",
"def _ship_hit(self):\n if self.stats.ships_left > 0:\n # Decrement ships_left\n self.stats.ships_left -= 1\n self.sb.prep_ships()\n\n # Remove remianing aliens & bullets\n self.aliens.empty()\n self.bullets.empty()\n\n # Create new fleet and ship at start location\n self._create_fleet()\n self.ship.center_ship()\n\n # pause\n sleep(0.5)\n else:\n self.stats.game_active = False \n pygame.mouse.set_visible(True)",
"def _ship_hit (self):\n\n\t\tself.stats.ship_left -=1\n\n\t\t\"\"\"get rid of remaining bullets and ships\"\"\"\n\t\tself.aliens.empty()\n\t\tself.bullets.empty()\n\n\t\t#Create a new fleet\n\n\t\tself._create_fleet()\n\t\tself.ship.center_ship()\n\n\t\t#pause\n\t\tsleep (0.5)",
"def _ship_hit(self):\n if self.stats.ships_left > 0:\n # Decrement ships_left.\n self.stats.ships_left -= 1\n self.scoreboard.prep_ships()\n\n # Get rid of any remaining aliens and bullets.\n self.aliens.empty()\n self.bullets.empty()\n\n # Create a new fleet and center the ship.\n self._create_fleet()\n self.ship.center_ship()\n\n # Pause\n sleep(0.5)\n else:\n self.stats.game_active = False\n pygame.mouse.set_visible(True)",
"def _ship_hit(self):\n if self.stats.ships_left > 0:\n self.stats.ships_left -= 1\n self.sb.prep_ships()\n self.stars.empty()\n self.bullets.empty()\n self._create_galaxy()\n self.ship.center_ship()\n sleep(0.5)\n else:\n self.stats.game_active = False\n pygame.mouse.set_visible(True)",
"def go_home(self, ship) -> Position:\n self.ship_states[ship.id].destination = self.closest_dropoff(ship)\n self.ship_states[ship.id].mode = Modes.DEPOSITING",
"def shipper_department(self, shipper_department):\n\n self._shipper_department = shipper_department",
"def move_ship(self,direction):\n assert isinstance(direction, str)\n assert direction == 'left' or direction == 'right'\n self.stay_on_screen()\n if direction == 'left':\n self.x -= SHIP_MOVEMENT\n elif direction == 'right':\n self.x += SHIP_MOVEMENT",
"def position_ship(self, cell, fleet, hit_power):\n if not cell.occupied:\n ship = Ship(fleet, cell, hit_power)\n cell.occupied = True\n cell.mark = constants.ACTIVE_SHIP_MARK\n cell.ship = ship\n self.shipList.append(ship)\n else:\n # raise ex.CannotPlaceFleetError()\n print(\"XXXXXX\")",
"def draw_ship(self, image, ship, dims):\n # Get the center x, y and the size s\n x, y, s, r, m = dims\n\n #Load files\n if ship == 'cruiseship':\n im_path = 'ships/cruiseship_isolated.png'\n ma_path = 'ships/cruiseship_isolated_mask.png'\n elif ship == 'tanker':\n im_path = 'ships/tanker_isolated.png'\n ma_path = 'ships/tanker_isolated_mask.png'\n\n #Transforming ship\n ship = cv2.imread(im_path)\n ship_transformed = self.transform(ship.copy(), dims)\n ship_shape = np.shape(ship_transformed)\n s_x = int((ship_shape[0]+0.5)//2)\n s_y = int((ship_shape[1]+0.5)//2)\n ship_transformed = ship_transformed[0:np.shape(image[x-s_x:x+s_x, y-s_y:y+s_y, :])[0],\n 0:np.shape(image[x-s_x:x+s_x, y-s_y:y+s_y, :])[1],\n :]\n ship_transformed_th = self.threshold(ship_transformed)\n\n #Adding boat to image\n image_slice = image[x - s_x:x + s_x, y - s_y:y + s_y, :]\n image_slice -= 255*image_slice*ship_transformed_th\n image_slice += ship_transformed\n image[x - s_x:x + s_x, y - s_y:y + s_y, :] = image_slice\n\n return image",
"def _ship_hit(self):\n # takes one life away if there's lives left\n # also removes that life from the scoreboard\n if self.stats.ships_left > 0:\n self.stats.ships_left -= 1\n self.sb.prep_ships()\n\n # removes alien fleet + leftover bullets\n self.aliens.empty()\n self.bullets.empty()\n\n # creates a new fleet and centers players ship\n self._create_fleet()\n self.ship.center_ship()\n\n # stops game for a short while\n sleep(1.5)\n\n else:\n self.stats.game_active = False\n pygame.mouse.set_visible(True)",
"def set_ship(self):\n lst_ship = Ship().random_ship()\n small_ships = lst_ship[0]\n mid_ship = lst_ship[1]\n l_ship = lst_ship[2]\n xl_ship = lst_ship[3]\n for i in range(10):\n self.board.append(['0']*10)\n for i in range(10):\n self.board.append(['0']*10)\n for i in small_ships:\n self.board[i[0]][i[1]] = '1'\n for i in mid_ship:\n self.board[i[0]][i[1]] = '1'\n for i in l_ship:\n self.board[i[0]][i[1]] = '1'\n for i in xl_ship:\n self.board[i[0]][i[1]] = '1'\n return (self.board)",
"def display_ship(self):\r\n self.screen.blit(self.ship, self.rect)",
"def _sideways_ship_hit(self):\n if self.stats.sideways_ships_left > 0:\n self.stats.sideways_ships_left -= 1\n self.aliens.empty()\n self.bullets.empty()\n self._create_fleet()\n self.sideways_ship.center_sideways_ship()\n sleep(0.5)\n else:\n self.stats.game_active = False",
"def ship_new(name):\n click.echo('Created ship %s' % name)",
"def userBuyShipObj(self, user : bbUser.bbUser, requestedShip : bbShip.bbShip):\n if self.userCanAffordItemObj(user, requestedShip):\n self.shipsStock.removeItem(requestedShip)\n user.credits -= requestedShip.getValue()\n user.inactiveShips.addItem(requestedShip)\n else:\n raise RuntimeError(\"user \" + str(user.id) + \" attempted to buy ship \" + requestedShip.name + \" but can't afford it: \" + str(user.credits) + \" < \" + str(requestedShip.getValue()))",
"def hit(self):\n\n self.units.pop()\n return (len(self.units) == 0) # Returns True if the ship has been sunk",
"def buy_ship(self, location, ship_type):\n payload = {'location': location, 'type': ship_type}\n r = requests.post(self.base_url + f'/users/{self.username}/ships', headers=self.auth_header, )\n return r.text",
"def new_ships_set(self):\n\n with open(SHIPS_TEMPLATE, \"r\") as file:\n for line in file:\n size, text_cords, direction = line.strip().split(\" \")\n self.__create_ship(int(size), text_cords, direction)",
"def ship_updates(ai, var, screen, ship, charges, shields, hub):\r\n\tship.update(ai)\r\n\tship.draw_ship()\r\n\tcharge_shield_graphics(ai, var, screen, ship, charges, shields, hub)",
"def send_shipments(self):\n return SendIntensity(self)",
"def getShip(self):\r\n return self._ship",
"def default_shipping(self, default_shipping):\n\n self._default_shipping = default_shipping",
"def set_ships(self, dictionary):\n for key, value in dictionary.items():\n if value < 0:\n raise SettingsError(\"No negative ships\")\n self._parser.set(\"settings\", \"carriers\", str(dictionary[CARRIER]))\n self._parser.set(\"settings\", \"battleships\", str(dictionary[BATTLESHIP]))\n self._parser.set(\"settings\", \"cruisers\", str(dictionary[CRUISER]))\n self._parser.set(\"settings\", \"destroyers\", str(dictionary[DESTROYER]))\n self._save()",
"async def add_ship(self, pn, x, y, dx, dy, size):\n board = self.boards[pn]\n try:\n board.add_ship(x, y, dx, dy, size)\n return True\n except ValueError:\n return False",
"def convert_to_depositing(self, ship):\n if ship.halite_amount >= constants.MAX_HALITE * 0.95:\n ship.type = 'depositing'\n ship.hval = 1/ship.hval\n heapq.heappush(self.ships_deposit, ship)\n return True\n else:\n return False",
"def build_ships(self, ship, number=1, planet=None):\n menge = \"\" if number == 1 else str(number)\n self.send_build_post(\"shipyard\", planet, codes.ships[ship], form={\"menge\": menge})",
"def no_free_shipping(self, no_free_shipping):\n\n self._no_free_shipping = no_free_shipping",
"def place_ship(self, ship, x, y, orientation):\n\t\tdx = (orientation == GameBoard.O_HORIZONTAL)\n\t\tdy = (orientation == GameBoard.O_VERTICAL)\n\t\t# Check if there's enough space first.\n\t\tfor i in range(ship.size):\n\t\t\ttile = self.get_our_tile(x + i * dx, y + i * dy)\n\t\t\tif not tile.is_free():\n\t\t\t\traise ValueError(\"You already have a ship there!\")\n\n\t\tself.dump()\n\t\t# Enlist the ship in the navy.\n\t\tship.place(x, y, orientation)\n\t\tself.ships.append(ship)\n\t\t# Mark the tiles occupied by the ship.\n\t\tfor i in range(ship.size):\n\t\t\tcx = x + i * dx\n\t\t\tcy = y + i * dy\n\n\t\t\t# Create a tile boundary around the ship.\n\t\t\ttile = bt.Tile(bt.Tile.T_OCCUPIED)\n\t\t\tif i == 0:\n\t\t\t\t#\n\t\t\t\t# :AAAAA\n\t\t\t\t#\n\t\t\t\t# :\n\t\t\t\t# E\n\t\t\t\t# E\n\t\t\t\t#\n\t\t\t\tself.set_our_tile(cx - dx, cy - dy, tile)\n\t\t\t\t# :\n\t\t\t\t# :AAAAA\n\t\t\t\t#\n\t\t\t\t# ::\n\t\t\t\t# E\n\t\t\t\t# E\n\t\t\t\t#\n\t\t\t\tself.set_our_tile(cx - dx - dy, cy - dy - dx, tile)\n\t\t\t\t# :\n\t\t\t\t# :AAAAA\n\t\t\t\t# :\n\t\t\t\t# :::\n\t\t\t\t# E\n\t\t\t\t# E\n\t\t\t\t#\n\t\t\t\tself.set_our_tile(cx - dx + dy, cy - dy + dx, tile)\n\t\t\telif i == ship.size - 1:\n\t\t\t\t# :\n\t\t\t\t# :AAAAA:\n\t\t\t\t# :\n\t\t\t\t# :::\n\t\t\t\t# E\n\t\t\t\t# E\n\t\t\t\t# :\n\t\t\t\tself.set_our_tile(cx + dx, cy + dy, tile)\n\t\t\t\t# : :\n\t\t\t\t# :AAAAA:\n\t\t\t\t# :\n\t\t\t\t# :::\n\t\t\t\t# E\n\t\t\t\t# E\n\t\t\t\t# ::\n\t\t\t\tself.set_our_tile(cx + dx - dy, cy + dy - dx, tile)\n\t\t\t\t# : :\n\t\t\t\t# :AAAAA:\n\t\t\t\t# : :\n\t\t\t\t# :::\n\t\t\t\t# E\n\t\t\t\t# E\n\t\t\t\t# :::\n\t\t\t\tself.set_our_tile(cx + dx + dy, cy + dy + dx, tile)\n\t\t\t# :::::::\n\t\t\t# :AAAAA:\n\t\t\t# : :\n\t\t\t# :::\n\t\t\t# :E\n\t\t\t# :E\n\t\t\t# :::\n\t\t\tself.set_our_tile(cx - dy, cy - dx, tile)\n\t\t\t# :::::::\n\t\t\t# :AAAAA:\n\t\t\t# :::::::\n\t\t\t# :::\n\t\t\t# :E:\n\t\t\t# :E:\n\t\t\t# :::\n\t\t\tself.set_our_tile(cx + dy, cy + dx, tile)\n\n\t\t\t# Create the ship tile by tile.\n\t\t\tself.set_our_tile(cx, cy, ship.tile())\n\n\t\tself.dump()",
"def _initialize_ship_states(self):\n for ship in self.ships:\n if ship.id not in self.ship_states:\n state = ShipState(Modes.COLLECTING)\n self.ship_states[ship.id] = state",
"def ship(self, irc, msg, args, channel, optlist, shiptype):\n if not self.registryValue('full_access', channel):\n irc.reply('Concord denies you access on this channel!')\n return\n\n rows = self._sql(\"\"\"\n SELECT \"groupID\", \"groupName\" FROM \"invGroups\"\n WHERE \"categoryID\"=6 and \"groupName\" ILIKE %s AND published=true\"\"\", ['%%{0}%%'.format(shiptype)], db='sde', single=False)\n\n if len(rows) > 1:\n irc.reply('Found more than one shiptype: \"{0}\". Be more specific'.format(\n [r['groupName'] for r in rows]\n ), prefixNick=False)\n return\n\n if len(rows) == 1:\n invGroup = rows[0]\n #find the ships which match the groupID of the ship type\n ships = self._sql(\"\"\"\n SELECT \"typeID\", \"typeName\" FROM \"invTypes\"\n WHERE \"groupID\"=%s AND published=true\"\"\", [invGroup['groupID']], db='sde', single=False)\n typeIDs = [s['typeID'] for s in ships]\n else:\n # There was no group matching that name, but it could be a specific ship\n invGroup = None\n row = self._get_typeID('%%{0}%%'.format(shiptype))\n if row:\n typeIDs = [row,]\n shiptype = self._get_type(row)['typeName']\n else:\n irc.reply('Unknown shiptype', prefixNick=False)\n return\n\n\n rows = self._sql(\"\"\"\n SELECT * FROM corporation_membertracking\n WHERE owner_id=%s AND \"shipTypeID\" IN %s\"\"\",\n [self.corporationID, tuple(typeIDs)], single=False)\n\n if (len(rows) <= self.registryValue('max_lines', channel) or ('all', True) in optlist) \\\n and len(rows) > 0:\n irc.reply('Found {0} characters in {1}'.format(\n len(rows),\n invGroup['groupName']\n ), prefixNick=False)\n for row in rows:\n if row['shipType'] == 'Unknown Type':\n ship = 'Pod'\n else:\n ship = row['shipType']\n irc.reply('{0} :: {1} :: {2}'.format(\n ircutils.bold(row['name']),\n self._colorize_system(self._get_location_by_name(row['location'])),\n ship\n ), prefixNick=False)\n elif len(rows) > self.registryValue('max_lines', channel):\n irc.reply('Found {0} characters in {1}, but will not name them all'.format(\n len(rows),\n invGroup['groupName']\n ), prefixNick=False)\n else:\n if invGroup:\n shiptype = invGroup['groupName']\n\n irc.reply('Found {0} characters in {1}'.format(\n len(rows),\n shiptype\n ), prefixNick=False)",
"def ship_container(self):",
"def no_free_shipping(self):\n return self._no_free_shipping",
"def ship_mstone(request):\n if (request.method == \"POST\" and\n 'ms' in request.POST and\n request.user.has_perm('shipping.can_ship')):\n try:\n mstone = Milestone.objects.get(code=request.POST['ms'])\n # get current signoffs\n cs = _signoffs(mstone).values_list('id', flat=True)\n mstone.signoffs.add(*list(cs)) # add them\n mstone.status = 2\n # XXX create event\n mstone.save()\n except:\n pass\n return HttpResponseRedirect(reverse('shipping.views.milestones'))",
"def ShipOrder(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def stay_on_screen(self):\n if self.x <= 0 + SHIP_WIDTH/2:\n self.x += SHIP_MOVEMENT\n if self.x >= GAME_WIDTH- SHIP_WIDTH/2:\n self.x -= SHIP_MOVEMENT",
"def toggle_dropable(self,new_bool):\n self.dropablee = new_bool",
"def ship_hit(si_settings,screen,stats,sb,ship,aliens,bullets):\n if stats.ships_left > 0:\n # Decrement ships_left.\n stats.ships_left -= 1\n #update Scoreboard\n sb.prep_ships()\n else:\n stats.game_active = False\n pygame.mouse.set_visible(True)\n #empties aliens and bullets\n aliens.empty()\n bullets.empty()\n #makes new aliens and centers ship\n create_fleet(si_settings,screen,ship,aliens)\n ship.center_ship()\n #stop\n sleep(0.5)",
"def select_ship(self, type):\n ship = PlayerShip(type=type)\n self.speed = str(ship.stats['speed'])\n self.hp = str(ship.stats['hp'])\n self.attack = str(ship.stats['attack'])\n self.ammo = str(ship.stats['ammo'])\n self.skin = ship.skin\n self.ship = ship\n Logger.info(\n 'Application: '\n 'Changing the ship displayed in the base to the '\n '\"{}\" type.'.format(self.ship.type)\n )",
"def toggle(self, env, pos):\n return False",
"def test_create_shipment(self):\n pass",
"def addShip(self,start,stop,ship):\n\n if (start[0] == stop[0]):\n for y in range (start[1], stop[1]+1):\n self.ships[(start[0],y)] = ship\n else:\n for x in range (start[0],stop[0]+1):\n self.ships[(x,start[1])] = ship\n self.fleetSize +=1\n return self.fleetSize",
"def ship_hit(ai_settings, stats, screen, ship, aliens, bullets):\n\tif stats.ship_left > 1:\n\t\tstats.ship_left -= 1\n\t\n\t\t# Empty aliens and bullets\n\t\taliens.empty()\n\t\tbullets.empty()\n\t\n\t\t# Restore the initial screen\n\t\tcreate_fleet(ai_settings, screen, aliens)\n\t\tship.center_ship()\n\t\n\t\t# Pause\n\t\tsleep(1.0)\n\telse:\n\t\tstats.game_active = False",
"def place_ship(self, ship: Ship, location: Point, orientation: Orientation) -> None:\n\n ship_point_set = ship.get_points(location, orientation)\n ship_type = ship.ship_type\n\n if self.board.issuperset(\n ship.get_points(location, orientation)\n ) and ship_point_set.isdisjoint(self.all_ship_locations):\n self.all_ship_locations.update(ship_point_set)\n self.individual_ship_locations[ship_type] = set(ship_point_set)\n else:\n raise InvalidShipPlacementException(f'Placement of {ship} at {location} in orientation {orientation.value} is invalid')",
"def place_ship(self, row, col, ship, aligment):\n self._validate_place_params(row, col, ship, aligment)\n\n if aligment == ShipPosition.HORIZONTAL:\n # Place ship in horizontal position, populating in right direction\n for i in range(self.get_col_index(col), ship.LENGH + self.get_col_index(col)):\n self.board[(row, self.get_col_value(i))] = ship\n elif aligment == ShipPosition.VERTICAL:\n # Place ship in vertical position, populating in down direction\n for i in range(self.get_row_index(row), ship.LENGH + self.get_row_index(row)):\n self.board[(self.get_row_value(i), col)] = ship",
"def prep_ships(self):\n\t\t\tself.ships = Group()\n\t\t\tfor ship_number in range(self.stats.ships_left):\n\t\t\t\tship = Ship(self.ai_settings, self.screen)\n\t\t\t\tship.rect.x = 10 + ship_number * ship.rect.width\n\t\t\t\tship.rect.y = 10\n\t\t\t\tself.ships.add(ship)",
"def leave_dropoff(self, ship):\n possible_dests = ship.position.get_surrounding_cardinals()\n random.shuffle(possible_dests)\n self.ship_states[ship.id].preferred_move = possible_dests[0]\n move = self.move_safe(ship, possible_dests)\n self.command(ship, ship.move(move), move=move)",
"def free_shipping_minimum(self, free_shipping_minimum):\n\n self._free_shipping_minimum = free_shipping_minimum",
"def userSellShipObj(self, user : bbUser.bbUser, ship : bbShip.bbShip):\n user.credits += ship.getValue()\n self.shipsStock.addItem(ship)\n user.inactiveShips.removeItem(ship)",
"def reset_stats(self):\n self.ships_left = self.g_settings.ship_limit",
"def prep_ships(self):\r\n\t\tself.ships=Group()\r\n\t\tfor ship_number in range(self.stats.ships_left):\r\n\t\t\tship=Ship(self.ai_settings, self.screen)\r\n\t\t\tship.transform()\r\n\t\t\tship.rect.x=10+ship_number*ship.rect.width\r\n\t\t\tship.rect.y=10\r\n\t\t\tself.ships.add(ship)",
"def sinkShips(self):\r\n while True:\r\n stillSinkingShips = False\r\n for i in range(len(self.shipsToSink) - 1, -1, -1):\r\n sunkShip, shipCoordinates = self.positionAndSinkShip(self.shipsToSink[i])\r\n if sunkShip:\r\n stillSinkingShips = True\r\n for coordinates in shipCoordinates:\r\n self.enemyBoard[coordinates.x][coordinates.y] = BoardState.SUNK\r\n del(self.shipsToSink[i])\r\n if not stillSinkingShips:\r\n break",
"def _choose_ship(self, ship_type, board):\n coordinate = self._get_coordinate()\n direction = self._get_ship_direction()\n \n try:\n board.set_ship(coordinate, direction, ship_type, self.name)\n except b_types.BattleshipError:\n print(\"Invalid Coordinate! Make sure the entire ship is in bounds and it doesn't overlap with another ship.\")\n self._choose_ship(ship_type, board)",
"def ship_hit(ai_settings, stats, screen, ship, boss, bullets,boss_bullets):\n if stats.ships_left > 1:\t\n # Decrement ships_left\n stats.ships_left -= 1\n # Empty the list of bullets\n bullets.empty()\n boss_bullets.empty()\n #center the ship.\n ship.center_ship()\n # Pause.\n #sleep(0.5)\n else:\n stats.game_active = False\n pygame.mouse.set_visible(True)",
"def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):\n\tif stats.ships_left > 0:\n\t\t#Decrement ships_left\n\t\tstats.ships_left -= 1\n\t\t\n\t\t#Update scoreboard\n\t\tsb.prep_ships()\n\t\t\n\t\t#Empty the list of aliens and bullets\n\t\taliens.empty()\n\t\tbullets.empty()\n\t\t\n\t\t#Create a new fleet and center the ship\n\t\tcreate_fleet(ai_settings, screen, ship, aliens)\n\t\tship.center_ship()\n\t\t\n\t\t#Pause\n\t\tsleep(0.5)\n\n\telse:\n\t\tstats.game_active = False \n\t\tpygame.mouse.set_visible(True)",
"def is_flagged(self, is_flagged):\n \n self._is_flagged = is_flagged",
"def ship_hit(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, images):\r\n if stats.ships_left > 0:\r\n # Decrement ships_left.\r\n stats.ships_left -= 1\r\n\r\n # Animate the ship explosion\r\n ship_explosion(si_settings, screen, ship)\r\n\r\n # Update scoreboard.\r\n sb.prep_ships()\r\n\r\n # Empty the list of aliens and bullets.\r\n aliens.empty()\r\n bullets.empty()\r\n alienBullets.empty()\r\n\r\n # Create a new fleet and center the ship.\r\n create_fleet(si_settings, screen, ship, aliens, images)\r\n ship.center_ship()\r\n\r\n # Pause.\r\n sleep(0.5)\r\n else:\r\n stats.game_active = False\r\n pygame.mouse.set_visible(True)",
"def reset(self):\n self.ship_list = self.backup_list",
"def move_ship():\n anim = animate(\n ship,\n tween='accel_decel',\n pos=ship.target,\n duration=ship.distance_to(ship.target) / 200,\n on_finished=next_ship_target,\n )",
"def free_shipping(self):\n return self._free_shipping",
"def set_population_dependent_flags(self, *args):\n # check if self.food <= self.population\n # change self.hungry\n # change if population can be added (6)\n if self.population.get() == Species.MAX_POP:\n # turn off add population button\n pass",
"def choose_ship(self, ship_type, board): \n raise Exception(\"Unimplemented\")",
"def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):\n if stats.ships_left > 0:\n # Decrement ships left.\n stats.ships_left -= 1\n\n # Update scoreboard.\n sb.prep_ships()\n\n # Empty the list of aliens and bullets.\n aliens.empty()\n bullets.empty()\n\n # Create new fleet.\n create_fleet(ai_settings, screen, ship, aliens)\n\n # Center the ship.\n ship.center_ship()\n\n # Pause for a while.\n sleep(0.5)\n else:\n stats.game_active = False\n pygame.mouse.set_visible(True)",
"def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):\n if stats.ships_left > 0:\n #decrement the value of ships_left\n stats.ships_left -= 1\n #update scoreboard\n sb.prep_ships()\n #when hit remove bullets and aliens from screen\n aliens.empty()\n bullets.empty()\n #create a new fleet with ship at centre\n create_fleet(ai_settings, screen,ship, aliens)\n ship.center_ship()\n #pause for a sec to collect defeat\n sleep(1.0)\n else:\n stats.game_active = False\n pygame.mouse.set_visible(True)",
"def test_ship_orders(self):\n pass",
"def _animateShip(self,input,dt):\n move = 0\n if input.is_key_down('left'):\n move -= SHIP_MOVEMENT\n self._ship.x = max(self._ship.x+move,0)\n if input.is_key_down('right'):\n move += SHIP_MOVEMENT\n self._ship.x = min(self._ship.x+move, GAME_WIDTH)\n #extra feature\n if self._ship != None :\n self._ship.x += move\n self._ship.x = max(self._ship.x, 0+SHIP_WIDTH/2)\n self._ship.x = min(self._ship.x, GAME_WIDTH-SHIP_WIDTH/2)",
"async def battleshipset(self, ctx):\n\t\tawait ctx.send_help()\n\t\tcfg = await self.config.guild(ctx.guild).all()\n\t\tmsg = (\n\t\t\t'Extra shot on hit: {extraHit}\\n'\n\t\t\t'Mention on turn: {doMention}\\n'\n\t\t\t'Display the board using an image: {doImage}\\n'\n\t\t\t'Game contained to a thread: {useThreads}\\n'\n\t\t).format_map(cfg)\n\t\tawait ctx.send(f'```py\\n{msg}```')",
"def prep_ships(self):\n self.ships = Group()\n for ship_number in range(self.stats.ships_left):\n ship = Ship(self.ai_settings, self.screen)\n ship.rect.x = 10 + ship_number * ship.rect.width\n ship.rect.y = 10\n self.ships.add(ship)",
"def ship_to_pickup_address(self, address):\n self._set('shipping', 'pickup_address_id', address.id)",
"def set_food_dependent_flags(self):\n # check if self.food <= self.population\n # change self.hungry\n pass",
"def delivery(self, value: dict):\n self._delivery = value\n # Ensure the correct key is updated and object is set as dirty\n flag_modified(self, '_delivery')",
"def ship_market(self, **kwargs):\n payload = kwargs\n r = requests.get(self.base_url + f'/game/ships', headers=self.auth_header, params=payload)\n return r.text",
"def shipping_address(self, shipping_address):\n\n self._shipping_address = shipping_address",
"def confirm_ship_mstone(request):\n if not (\"ms\" in request.GET):\n return HttpResponseRedirect(reverse('shipping.views.milestones'))\n try:\n mstone = Milestone.objects.get(code=request.GET['ms'])\n except:\n return HttpResponseRedirect(reverse('shipping.views.milestones'))\n if mstone.status != 1:\n return HttpResponseRedirect(reverse('shipping.views.milestones'))\n statuses = _signoffs(mstone, getlist=True)\n pending_locs = []\n good = 0\n for (tree, loc), flags in statuses.iteritems():\n if 0 in flags:\n # pending\n pending_locs.append(loc)\n if 1 in flags:\n # good\n good += 1\n pending_locs.sort()\n return render_to_response('shipping/confirm-ship.html',\n {'mstone': mstone,\n 'pending_locs': pending_locs,\n 'good': good,\n 'login_form_needs_reload': True,\n 'request': request,\n },\n context_instance=RequestContext(request))"
] | [
"0.8498651",
"0.67255795",
"0.6544039",
"0.63688415",
"0.60945463",
"0.605988",
"0.6033643",
"0.598843",
"0.5941769",
"0.5935463",
"0.58800787",
"0.58588344",
"0.5824456",
"0.58200085",
"0.5804504",
"0.58038855",
"0.5789497",
"0.57643706",
"0.57440627",
"0.5726546",
"0.56743693",
"0.5668424",
"0.5653945",
"0.5643936",
"0.56422305",
"0.5614899",
"0.5544522",
"0.55381",
"0.549206",
"0.5491279",
"0.54331803",
"0.54156095",
"0.540719",
"0.5403305",
"0.5363107",
"0.53608745",
"0.53547347",
"0.533369",
"0.5297132",
"0.52946866",
"0.52777135",
"0.5276812",
"0.525918",
"0.52546394",
"0.52518636",
"0.5241898",
"0.52368045",
"0.5220965",
"0.52143896",
"0.5210064",
"0.5205131",
"0.52014554",
"0.51940006",
"0.5187203",
"0.5164726",
"0.5155592",
"0.5144474",
"0.5116733",
"0.51045835",
"0.51022995",
"0.5092791",
"0.50918704",
"0.50735986",
"0.50655025",
"0.5060262",
"0.5046693",
"0.50386375",
"0.5029039",
"0.5023704",
"0.50229514",
"0.5017791",
"0.5003659",
"0.4995159",
"0.49913943",
"0.4991222",
"0.49810877",
"0.4971497",
"0.49651653",
"0.4956985",
"0.4950165",
"0.49473053",
"0.49423286",
"0.49360445",
"0.4924663",
"0.49246308",
"0.4920353",
"0.49160954",
"0.4911666",
"0.49085313",
"0.4904182",
"0.49035364",
"0.48950842"
] | 0.85205853 | 8 |
Initialize melon order attributes | def __init__(self, species, qty):
#Include all arguments in exact order, if default values enter directly
super (DomesticMelonOrder, self). __init__(species, qty, "domestic", 0.08) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._order_list = []",
"def __init__(self):\n self.orders = {}",
"def initialize(self):\n self.muondEdx = []\n self.muondNdx = []\n self.muonmomentum = []\n self.piondEdx = []\n self.piondNdx = []\n self.pionmomentum = []\n self.kaondEdx = []\n self.kaondNdx = []\n self.kaonmomentum = []\n self.protdEdx = []\n self.protdNdx = []\n self.protmomentum = []\n self.elecdEdx = []\n self.elecdNdx = []\n self.elecmomentum = []",
"def __init__(self, *args, **kwargs):\n self._orders = None\n super().__init__(*args, **kwargs)",
"def __init__(self, order=0, shape=None):\n self.child = None\n self.shape = shape\n self.order = order\n self.index = 0",
"def __init__(self, species, qty):\n super(DomesticMelonOrder, self).__init__(species, qty)",
"def __init__(self):\n self.relation = ''\n self.attributes = []\n self.attribute_types = dict()\n self.attribute_data = dict()\n self.comment = []\n self.data = []\n pass",
"def create_order():",
"def __init__(self, order):\n self.order = order\n self.keys = []\n self.values = []\n self.leaf = True",
"def init_attrs(self):\n raise NotImplementedError",
"def __init__(self, d=0., order=0., *args, **kwargs):\n self.d = d\n self.order = order\n print \"Mirror\", args, kwargs\n Element.__init__(self, *args, **kwargs)",
"def __init__(self, order_id):\n self.order_items = []\n self.order_id = order_id",
"def __init__(self, symbol, order_type, quantity, direction):\n self.type = 'ORDER'\n self.symbol = symbol\n self.order_type = order_type\n self.quantity = quantity\n self.direction = direction",
"def __init__(self,**kwargs):\n self.attr = ['angle','width','height','m','Fg','Fs','Fd','kf','Ff']\n # attributes of the incline in order: angle,width,height, mass,Fg(gravity force),Fs(statical force), Fd (dynamical force),kf(friction coefficient), Ff(friction force)\n self.data = {param: None for param in self.attr}#initialazing data\n self.given_data = set() #set of data given by user\n self.add_data(**kwargs)",
"def _init_node_attributes(self):\n assert False",
"def __init__(self, order: [BBoxType] = None):\n\t\tself.order = order and list(reversed(order))",
"def __init__(self, atomic_number, element, mass, state):\n self.atomic_number = int(atomic_number)\n self.element = element\n self.mass = int(mass)\n self.state = int(state)",
"def __init__(self, order, warehouse_list):\n self.order=order\n \"\"\" \n a list of object with warehouse name and inventory amounts \n (inventory distribution) for these items\n \"\"\"\n self.warehouse_list=warehouse_list\n \"\"\"total amout of item being ordered in this order\"\"\"\n self.total_order_amount=0\n for amount in order.values():\n self.total_order_amount+=amount",
"def __init__(self, name, orderData, orderGraph, col):\n\t\tself.name = name\n\t\tself.colour = col\n\t\tself.dominance = 0\n\t\tself.orderInData = orderData #order of this ancestry in the admix data (never changes)\n\t\tself.orderInGraph = orderGraph #order of this ancestry in the graph",
"def __init__(self):\n self.number = None\n self.nodes = []\n self.type = None\n self.group = None\n self.material = None\n self.key = -1",
"def __init__(self):\n self._distance_data = []\n self._location_data = []\n self._package_data = []",
"def __init__(self, order):\n self.n = order\n self.markov_dict = {}\n self.prob_dict = Counter()",
"def initordering(cls):\n for i in range(len(clslist)):\n stages = cls.getConfigStages()\n for j in range(len(stages)):\n for k in range(len(slotlist)):\n cls.initorderingclsslot(clslist[i], stages[j], slotlist[k])\n # print(ordering)\n cls.log(1, ordering)",
"def __init__(self, species, qty, country_code):\n super(InternationalMelonOrder, self).__init__(species, qty, \"international\", 0.17, country_code)",
"def __init__(self):\n self.comm = None\n self.rank = None\n self.size = None",
"def __attrs_post_init__(self):",
"def __init__(self, **attrs):\n \n self.minifig_id = None\n self.name = None\n self.pieces = None\n \n self.img_url = None\n \n self.count = None\n \n super().__init__(**attrs)",
"def __init__(self, **attrs):\n \n self.list_id = None\n self.name = None\n self.pieces = None\n \n super().__init__(**attrs)",
"def __init__(self):\n self._data = PositionalList() # list of Item instances",
"def __init__(self, position, momentum, mass):\n self.position = position\n self.momentum = momentum\n self.mass = mass",
"def __init__(self, order_items: list):\n self.order_items = order_items\n self.destination = None",
"def __init__(self, species, qty, country_code):\n\n self.country_code = country_code\n return super(InternationalMelonOrder, self).__init__(species, qty)",
"def __init__(self, species, qty, country_code):\n super(InternationalMelonOrder, self).__init__(species, qty)\n\n self.country_code = country_code",
"def __init__(self):\n self._data = PositionalList() # list of _Item instances",
"def __init__(self, context):\n self.context = context\n \n self._m_ticket = self._m_ticket_initial\n\n self._d_orders = {}\n self._d_orders['trades'] = OrderedDict()\n self._d_orders['history'] = OrderedDict()\n self._d_orders['cancelled'] = OrderedDict()",
"def _init_attributes(self):\n self.attr = {\n 'name': None,\n 'tags': [],\n 'openHours': None,\n 'type': None,\n 'parent': None,\n 'locationId': None,\n 'bannerAbbreviation': None,\n 'arcGisAbbreviation': None,\n 'geoLocation': None,\n 'geometry': None,\n 'summary': None,\n 'description': None,\n 'descriptionHtml': None,\n 'address': None,\n 'city': None,\n 'state': None,\n 'zip': None,\n 'county': None,\n 'telephone': None,\n 'fax': None,\n 'thumbnails': [],\n 'images': [],\n 'departments': [],\n 'website': None,\n 'sqft': None,\n 'calendar': None,\n 'campus': None,\n 'girCount': None,\n 'girLimit': False,\n 'girLocations': None,\n 'synonyms': [],\n 'bldgId': None,\n 'parkingZoneGroup': None,\n 'propId': None,\n 'adaParkingSpaceCount': None,\n 'motorcycleParkingSpaceCount': None,\n 'evParkingSpaceCount': None,\n 'weeklyMenu': None,\n 'notes': None,\n 'labels': {},\n 'steward': None,\n 'shape': {}\n }",
"def __init__(self):\n self._exchange_params_by_currency_id = None # type: Optional[ExchangeParams]\n self._utility_params_by_good_id = None # type: Optional[UtilityParams]\n self._transaction_fees = None # type: Optional[Dict[str, int]]\n self._quantity_shift = QUANTITY_SHIFT",
"def __init__(self, species, qty):\n\n self.species = species\n self.qty = qty\n self.shipped = False\n self.tax = 0.00\n # Adds a timestamp attribute when you instantiate any melon\n self.timestamp = dt.now()",
"def setOrder(self, order):\n\t\tself.orderInData = order",
"def __init__(self,mk,level=2):\n\t\tself.Market=mk\n\t\tself.Level=level\n\t\tself.OrderBook=self.getMarketData(self.Level)",
"def __init__(self, order_json):\n self.shop = order_json['shop']\n self.size = order_json['size']\n self.customer_name = order_json['name']\n self.drink_name = order_json['drink']\n self.customer_number = order_json['customer_number']\n self.location = order_json['location']\n self.details = order_json['details']",
"def __init__(self):\n\n self._dict = OrderedDict(zip(const.BFHCOLS, [0] * 111))",
"def __init__(self, *args):\n\t\tfrom collections import OrderedDict\n\t\tnew_dict = {}\n\t\tfor x, y in enumerate(args):\n\t\t\tnew_dict.update({x: y})\n\t\tnew_dict = OrderedDict(sorted(new_dict.items()))\n\t\tself.__dict__ = new_dict",
"def setOrder(self, verbose = 1):\n\n self.order = np.arange(self.atoms.shape[0])\n if verbose > 0:\n string = \"Updated the saved order\"\n ut.infoPrint(string)",
"def prepare_node_attrs(self):",
"def __init__(self, **initial_attributes):\n\n for attribute_name, attribute_value in initial_attributes.items():\n setattr(self, attribute_name, attribute_value)",
"def __init__(self):\n self.quantityList = []",
"def __init__(self, species, qty):\n super(GovernmentMelonOrder, self).__init__(species, qty)\n\n self.passed_inspection = False",
"def __init__(self, order_number, product_id, item_type, name, product_details, factory, quantity, holiday):\n self._order_number = order_number\n self._product_id = product_id\n self._item_type = item_type\n self._name = name\n self._product_details = product_details\n self._factory = factory\n self._quantity = quantity\n self._holiday = holiday\n self._is_valid = True\n self._invalid_notes = \"\"",
"def __init__(self, species, qty):\n\n super().__init__(species, qty)\n self.order_type = \"domestic\"\n self.tax = 0.08",
"def __init__(self, weight, attributes, first_incident_node, second_incident_node):\n self.weight = weight # initialize all necessary fields\n self.attributes = attributes\n self.first_incident_node = first_incident_node\n self.second_incident_node = second_incident_node",
"def __init__(self, pos, model):\n super().__init__(pos, model)\n self.pos = pos\n self.amount = 0.0",
"def initialize(self):\n # FIX: INITIALIZE PROCESS INPUTS??\n for mech, value in self.initial_values.items():\n mech.initialize(value)",
"def __init__(self, polyorder=2):\n self.polyorder = polyorder",
"def __init__(self):\n self.stack = []\n self.ordered = []",
"def __init__(self, addendum, amount, tip_amount=None, transaction_id=None):\n self.__camelcase=constants.ALL_FIELDS\n self.__order=['Addendum', 'Amount', 'TipAmount', 'TransactionId']\n self.addendum=addendum\n self.amount=amount\n self.tip_amount=tip_amount\n self.transaction_id=transaction_id",
"def __init__(self, **kwargs):\n super(ProjectionMatrix, self).__init__(**kwargs) \n LOG.debug(str(kwargs))\n\n #OpenMEEG attributes\n self.om_head = None\n self.om_sources = None\n self.om_sensors = None\n self.om_head2sensor = None\n\n self.om_inverse_head = None\n self.om_source_matrix = None\n self.om_source2sensor = None #For MEG, not used for EEG",
"def __init__(self, numMonomers, dim, b, **kwargs):\n self.numMonomers = numMonomers\n self.dim = dim\n position = kwargs.get('position',None)\n if(position is not None):\n self.positions = position\n else:\n self.positions = b*np.cumsum(np.random.randn(numMonomers,dim),0)\n self.b = b\n self.LaplacianMatrix = self.Linear_Rouse_Matrix()\n Graph.__init__(self,self.numMonomers,adjmatrix=self.LaplacianMatrix.copy())\n self.Nc = 0\n self.freeMonomers = []\n self.possibleEncounters = []\n self.freeMonomersNames = {}\n \n self.forces = []\n \n self.colors = ['r']*numMonomers",
"def __init__(self, species, qty, order_type, tax):\n self.species = species\n self.qty = qty\n self.shipped = False\n self.order_type = order_type\n self.tax = tax",
"def __init__(self, process_list):\n self.__process_list = process_list\n self.__n_initial = len(process_list)",
"def _set_attributes(self):",
"def __init__(self, grid_tuples):\n super(ParamGrid, self).__init__()\n self.grid = OrderedDict(grid_tuples)",
"def __init__(self):\r\n self.data = PositionalList()",
"def createOrders(self):\n self.ordersDict = {}\n for pstep in self.processingSteps:\n if pstep.orderid not in self.ordersDict:\n self.ordersDict[pstep.orderid] = Order()\n self.ordersDict[pstep.orderid].addProcessingStep(pstep)",
"def __init__(self, ebunch=None):\n super(BayesianModel, self).__init__()\n if ebunch:\n self.add_edges_from(ebunch)\n self.cpds = []\n self.cardinalities = self.get_cardinality()\n self.probs = dict()",
"def __init__(self):\n self.rho=[]\n self.te=[]\n self.ti=[]\n self.ne=[]\n self.ni=[]\n self.ni1=[]\n self.ni2=[]\n self.ni3=[]\n self.vtor=[]\n self.zeff=[]\n\n self.nion=1\n self.Z=[]\n self.A=[]\n self.coll_mode=[]",
"def __attrs_post_init__(self):\n\n self.jobdate = parse(to_str(self.jobdate).strip())\n self.vehicleid = to_str(self.vehicleid).strip()\n self.reason = to_str(self.reason).strip()\n self.notes = to_str(self.notes).strip()\n self.costparts = Decimal(to_str(self.costparts).strip())\n self.costlabor = Decimal(to_str(self.costlabor).strip())\n self.costtotal = Decimal(to_str(self.costtotal).strip())\n\n # Apply additional data transformations\n self.yearmon = datetime.strftime(self.jobdate, '%Y-%m')",
"def __init__(self, initial_data=[]):\n hdict.__init__(self)\n\n for elt in initial_data:\n self.add(elt)",
"def __init__(self, dimensions=2):\n assert dimensions > 0\n for d in range(0,dimensions+1):\n self.weight.append(0)",
"def __init__(self):\n self.run = OrderedDict()",
"def set_order(self, order):\n self.order = order",
"def set_order(self, order):\n self.order = order",
"def __init__(self):\n self.normal = []\n self.reverse = []",
"def __init__(self):\n self._keys = []\n self._sortKeys = []",
"def __init__(self, m, c):\n self.m = m\n self.c = c",
"def __init__(self, statistic, order=2, log=False, normalize=False, type='norm', **kwargs):\n if type=='norm':\n name = statistic.name + '_l' + str(order)\n else:\n name = statistic.name + '_' + type\n if log:\n name += 'log'\n super().__init__(name, statistic.group, **kwargs)\n self._order = order\n self._log = log\n self.statistic = statistic\n self._saved_stat = None\n self._normalize = normalize\n self._type = type",
"def __init__(self, ordered_dict):\n self.cur_item = 0\n self.dict = ordered_dict",
"def __init__(self, desc = {}):\n (\n self.x,\n self.y,\n self.z\n ) = itemgetter('x','y','z')(desc['position'])\n (\n self.rotX,\n self.rotY,\n self.rotZ\n ) = itemgetter('x','y','z')(desc['rotation'])",
"def __init__(self, attribute_names):\r\n self.attribute_names = attribute_names\r\n self.tree = None",
"def __init__(self, extra_fields=None):\n if extra_fields:\n self.fields.extend(extra_fields)\n self.data = {k: [] for k in self.fields}\n self.last_r = 0.0",
"def __init__(self):\n print(\"\\nStarting a new order.\\nThank you for visiting our on-line store!\")\n self.__items_list = []\n self.__purchase_date = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.__order_number = Order.__last_order_number_used + 1\n Order.__last_order_number_used = self.__order_number",
"def __init__(self, num_carts, locations):\n self._locations = locations\n self._depot = 0 # packing zone index\n self._num_carts = num_carts",
"def reorder(self, new_order):\n #TODO doesn't work probably CRA 3/2019\n for field in [\"atoms\", \"xyz\"]:\n self.__dict__[field] = self.__dict__[field][list(new_order)]\n self.atoms = [self.atoms[i] for i in new_order]",
"def _init(self, position):\n\t\tself._position = position",
"def __init__(self, order_details: OrderDetails):\n self.details = order_details",
"def __init__(self, **attrs):\n \n self.part_id = None\n self.category_id = None\n self.external_ids = {}\n self.name = None\n \n self.year_from = None\n self.year_to = None\n \n self.url = None\n self.img_url = None\n \n self.print_of = None\n self.prints = []\n self.molds = []\n self.alternates = []\n \n super().__init__(**attrs)",
"def __init__(self):\n self.COMMON_ATOMS = [('B', 0), ('B', -1), ('Br', 0), ('Br', -1), ('Br', 2), ('C', 0), ('C', 1), ('C', -1), ('Cl', 0),\n ('Cl', 1), ('Cl', -1), ('Cl', 2), ('Cl', 3), ('F', 0), ('F', 1), ('F', -1), ('I', -1), ('I', 0),\n ('I', 1), ('I', 2), ('I', 3), ('N', 0), ('N', 1), ('N', -1), ('O', 0), ('O', 1), ('O', -1),\n ('P', 0),\n ('P', 1), ('P', -1), ('S', 0), ('S', 1), ('S', -1), ('Se', 0), ('Se', 1), ('Se', -1), ('Si', 0),\n ('Si', -1)]",
"def __init__(self, openChannels, spinGroups, **kwargs):\n\n ancestryModule.ancestry.__init__(self)\n self.channels = openChannels\n self.spinGroups = spinGroups\n for attr in self.optAttrList:\n setattr(self, attr, kwargs.get(attr))",
"def __init__(self, order_dict):\n self.order_ref = order_dict['order_ref']\n\n self.error_status_code = order_dict.get('error_status_code', None)\n self.error_reason = order_dict.get('error_reason', None)\n self.status = order_dict.get('status')\n self.created = timeutils.parse_isotime(order_dict['created'])\n if order_dict.get('updated') is not None:\n self.updated = timeutils.parse_isotime(order_dict['updated'])\n else:\n self.updated = None\n self.secret_ref = order_dict.get('secret_ref')",
"def __init__ (self,raw_order):\n self.raw=raw_order\n \n raw_order=raw_order.split(\",\") # Turn into a list of strings\n \n self.Code=raw_order[0] # The order code\n self.TIcode=raw_order[3] # The code of the instrument\n self.Type=raw_order[7] # A buy or a sell order\n self.Price=float(raw_order[10]) \n self.Size=int(raw_order[11]) # doesn't allow for half of stock\n self.BroadcastUpdateAction=raw_order[13]\n try:\n self.Time = datetime(int(raw_order[-3][4::]),int(raw_order[-3][2:4]),int(raw_order[-3][0:2]),\n int(raw_order[-2][0:2]), int(raw_order[-2][3:5]), int(raw_order[-2][6:8]), int(raw_order[-2][9::]))\n except:\n \n self.Time = datetime(int(raw_order[-3][4::]),int(raw_order[-3][2:4]),int(raw_order[-3][0:2]),\n int(raw_order[-2][0:2]), int(raw_order[-2][3:5]), int(raw_order[-2][6:8]))\n \n \n self.MessageSequenceNumber=int(raw_order[-1]) # A number that takes care of orders placed at the same time\n\n self.ind=\"LimitOrder\"\n self.ParticipantCode=raw_order[6]\n self.BestBid=0; self.BestAsk=np.inf\n self.N_Prec=0;self.Vol_Prec=0\n self.OriginalSize=int(raw_order[11])",
"def __init__(self):\n # Dict of minecraft object in form of \"dict[id] = name\"\n self.data_values = dict()\n self.parser = self.setup_parser()",
"def __init__(self, **kwargs):\n self.__dict__.update(kwargs)\n self._calc_coords()",
"def __init__ (self, pseudo, bag, position, jeu):\n self.pseudo = pseudo\n self.bag = bag\n self.position = position\n self.jeu = jeu",
"def __init__(self, attributes_names: list):\r\n self.attributes_names = attributes_names",
"def __init__(self, attributes_names: list):\r\n self.attributes_names = attributes_names",
"def initialise(self):",
"def __init__(self, geom, matrix, materialnodebysymbol):\n self.matrix = matrix\n self.materialnodebysymbol = materialnodebysymbol\n self._primitives = geom._primitives\n self.original = geom",
"def __init__(self, *args, **kwargs):\n\n OrderedDict.__init__(self, *args, **kwargs)\n\n # the original parsed code, used for saving things out\n self.__orig = {}",
"def __init__ (self):\n self.tag = 0\n self.mDict = {}",
"def __init__(self, melon_type, shape, color_rating, harvest_from, harvest_by):\n self.melon_type = melon_type\n self.shape = shape\n self.color_rating = color_rating\n self.harvest_from = harvest_from\n self.harvest_by = harvest_by"
] | [
"0.68216413",
"0.6461353",
"0.6418837",
"0.6366196",
"0.62271947",
"0.6196553",
"0.6189848",
"0.618619",
"0.6156593",
"0.61555725",
"0.61342317",
"0.6116472",
"0.6085777",
"0.59540695",
"0.5946118",
"0.593134",
"0.5919386",
"0.5895247",
"0.5894288",
"0.58701146",
"0.5856023",
"0.58309937",
"0.5768767",
"0.57612264",
"0.5744106",
"0.5738495",
"0.5711613",
"0.5703207",
"0.5697906",
"0.5695903",
"0.5677723",
"0.5675916",
"0.5674612",
"0.5661744",
"0.56508505",
"0.5650713",
"0.56484383",
"0.5640504",
"0.56382465",
"0.5635909",
"0.5623067",
"0.56229186",
"0.56167704",
"0.561625",
"0.5604361",
"0.55976313",
"0.5594784",
"0.5591189",
"0.5579339",
"0.55775577",
"0.55767655",
"0.55683273",
"0.55641174",
"0.5559811",
"0.55566543",
"0.5536365",
"0.5536221",
"0.5535361",
"0.5534583",
"0.55313694",
"0.55263054",
"0.55099136",
"0.550706",
"0.55011415",
"0.54986626",
"0.5496526",
"0.5494687",
"0.5491642",
"0.5486783",
"0.5484029",
"0.5482564",
"0.5482564",
"0.5480494",
"0.5478862",
"0.54779387",
"0.547598",
"0.54758364",
"0.5474528",
"0.5465505",
"0.5464627",
"0.546415",
"0.546415",
"0.54608524",
"0.54411036",
"0.54311424",
"0.5425524",
"0.54227823",
"0.542164",
"0.5418937",
"0.5418815",
"0.5414191",
"0.5413547",
"0.54121065",
"0.54101706",
"0.54101706",
"0.5406778",
"0.54031575",
"0.54022264",
"0.5398617",
"0.5396539"
] | 0.5670754 | 33 |
Initialize melon order attributes | def __init__(self, species, qty, country_code):
super(InternationalMelonOrder, self).__init__(species, qty, "international", 0.17, country_code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._order_list = []",
"def __init__(self):\n self.orders = {}",
"def initialize(self):\n self.muondEdx = []\n self.muondNdx = []\n self.muonmomentum = []\n self.piondEdx = []\n self.piondNdx = []\n self.pionmomentum = []\n self.kaondEdx = []\n self.kaondNdx = []\n self.kaonmomentum = []\n self.protdEdx = []\n self.protdNdx = []\n self.protmomentum = []\n self.elecdEdx = []\n self.elecdNdx = []\n self.elecmomentum = []",
"def __init__(self, *args, **kwargs):\n self._orders = None\n super().__init__(*args, **kwargs)",
"def __init__(self, order=0, shape=None):\n self.child = None\n self.shape = shape\n self.order = order\n self.index = 0",
"def __init__(self, species, qty):\n super(DomesticMelonOrder, self).__init__(species, qty)",
"def __init__(self):\n self.relation = ''\n self.attributes = []\n self.attribute_types = dict()\n self.attribute_data = dict()\n self.comment = []\n self.data = []\n pass",
"def create_order():",
"def __init__(self, order):\n self.order = order\n self.keys = []\n self.values = []\n self.leaf = True",
"def init_attrs(self):\n raise NotImplementedError",
"def __init__(self, d=0., order=0., *args, **kwargs):\n self.d = d\n self.order = order\n print \"Mirror\", args, kwargs\n Element.__init__(self, *args, **kwargs)",
"def __init__(self, order_id):\n self.order_items = []\n self.order_id = order_id",
"def __init__(self, symbol, order_type, quantity, direction):\n self.type = 'ORDER'\n self.symbol = symbol\n self.order_type = order_type\n self.quantity = quantity\n self.direction = direction",
"def __init__(self,**kwargs):\n self.attr = ['angle','width','height','m','Fg','Fs','Fd','kf','Ff']\n # attributes of the incline in order: angle,width,height, mass,Fg(gravity force),Fs(statical force), Fd (dynamical force),kf(friction coefficient), Ff(friction force)\n self.data = {param: None for param in self.attr}#initialazing data\n self.given_data = set() #set of data given by user\n self.add_data(**kwargs)",
"def _init_node_attributes(self):\n assert False",
"def __init__(self, order: [BBoxType] = None):\n\t\tself.order = order and list(reversed(order))",
"def __init__(self, atomic_number, element, mass, state):\n self.atomic_number = int(atomic_number)\n self.element = element\n self.mass = int(mass)\n self.state = int(state)",
"def __init__(self, order, warehouse_list):\n self.order=order\n \"\"\" \n a list of object with warehouse name and inventory amounts \n (inventory distribution) for these items\n \"\"\"\n self.warehouse_list=warehouse_list\n \"\"\"total amout of item being ordered in this order\"\"\"\n self.total_order_amount=0\n for amount in order.values():\n self.total_order_amount+=amount",
"def __init__(self, name, orderData, orderGraph, col):\n\t\tself.name = name\n\t\tself.colour = col\n\t\tself.dominance = 0\n\t\tself.orderInData = orderData #order of this ancestry in the admix data (never changes)\n\t\tself.orderInGraph = orderGraph #order of this ancestry in the graph",
"def __init__(self):\n self.number = None\n self.nodes = []\n self.type = None\n self.group = None\n self.material = None\n self.key = -1",
"def __init__(self):\n self._distance_data = []\n self._location_data = []\n self._package_data = []",
"def __init__(self, order):\n self.n = order\n self.markov_dict = {}\n self.prob_dict = Counter()",
"def initordering(cls):\n for i in range(len(clslist)):\n stages = cls.getConfigStages()\n for j in range(len(stages)):\n for k in range(len(slotlist)):\n cls.initorderingclsslot(clslist[i], stages[j], slotlist[k])\n # print(ordering)\n cls.log(1, ordering)",
"def __init__(self):\n self.comm = None\n self.rank = None\n self.size = None",
"def __attrs_post_init__(self):",
"def __init__(self, **attrs):\n \n self.minifig_id = None\n self.name = None\n self.pieces = None\n \n self.img_url = None\n \n self.count = None\n \n super().__init__(**attrs)",
"def __init__(self, **attrs):\n \n self.list_id = None\n self.name = None\n self.pieces = None\n \n super().__init__(**attrs)",
"def __init__(self):\n self._data = PositionalList() # list of Item instances",
"def __init__(self, position, momentum, mass):\n self.position = position\n self.momentum = momentum\n self.mass = mass",
"def __init__(self, order_items: list):\n self.order_items = order_items\n self.destination = None",
"def __init__(self, species, qty, country_code):\n\n self.country_code = country_code\n return super(InternationalMelonOrder, self).__init__(species, qty)",
"def __init__(self, species, qty, country_code):\n super(InternationalMelonOrder, self).__init__(species, qty)\n\n self.country_code = country_code",
"def __init__(self, species, qty):\n #Include all arguments in exact order, if default values enter directly\n super (DomesticMelonOrder, self). __init__(species, qty, \"domestic\", 0.08)",
"def __init__(self):\n self._data = PositionalList() # list of _Item instances",
"def __init__(self, context):\n self.context = context\n \n self._m_ticket = self._m_ticket_initial\n\n self._d_orders = {}\n self._d_orders['trades'] = OrderedDict()\n self._d_orders['history'] = OrderedDict()\n self._d_orders['cancelled'] = OrderedDict()",
"def _init_attributes(self):\n self.attr = {\n 'name': None,\n 'tags': [],\n 'openHours': None,\n 'type': None,\n 'parent': None,\n 'locationId': None,\n 'bannerAbbreviation': None,\n 'arcGisAbbreviation': None,\n 'geoLocation': None,\n 'geometry': None,\n 'summary': None,\n 'description': None,\n 'descriptionHtml': None,\n 'address': None,\n 'city': None,\n 'state': None,\n 'zip': None,\n 'county': None,\n 'telephone': None,\n 'fax': None,\n 'thumbnails': [],\n 'images': [],\n 'departments': [],\n 'website': None,\n 'sqft': None,\n 'calendar': None,\n 'campus': None,\n 'girCount': None,\n 'girLimit': False,\n 'girLocations': None,\n 'synonyms': [],\n 'bldgId': None,\n 'parkingZoneGroup': None,\n 'propId': None,\n 'adaParkingSpaceCount': None,\n 'motorcycleParkingSpaceCount': None,\n 'evParkingSpaceCount': None,\n 'weeklyMenu': None,\n 'notes': None,\n 'labels': {},\n 'steward': None,\n 'shape': {}\n }",
"def __init__(self):\n self._exchange_params_by_currency_id = None # type: Optional[ExchangeParams]\n self._utility_params_by_good_id = None # type: Optional[UtilityParams]\n self._transaction_fees = None # type: Optional[Dict[str, int]]\n self._quantity_shift = QUANTITY_SHIFT",
"def __init__(self, species, qty):\n\n self.species = species\n self.qty = qty\n self.shipped = False\n self.tax = 0.00\n # Adds a timestamp attribute when you instantiate any melon\n self.timestamp = dt.now()",
"def setOrder(self, order):\n\t\tself.orderInData = order",
"def __init__(self,mk,level=2):\n\t\tself.Market=mk\n\t\tself.Level=level\n\t\tself.OrderBook=self.getMarketData(self.Level)",
"def __init__(self, order_json):\n self.shop = order_json['shop']\n self.size = order_json['size']\n self.customer_name = order_json['name']\n self.drink_name = order_json['drink']\n self.customer_number = order_json['customer_number']\n self.location = order_json['location']\n self.details = order_json['details']",
"def __init__(self):\n\n self._dict = OrderedDict(zip(const.BFHCOLS, [0] * 111))",
"def __init__(self, *args):\n\t\tfrom collections import OrderedDict\n\t\tnew_dict = {}\n\t\tfor x, y in enumerate(args):\n\t\t\tnew_dict.update({x: y})\n\t\tnew_dict = OrderedDict(sorted(new_dict.items()))\n\t\tself.__dict__ = new_dict",
"def setOrder(self, verbose = 1):\n\n self.order = np.arange(self.atoms.shape[0])\n if verbose > 0:\n string = \"Updated the saved order\"\n ut.infoPrint(string)",
"def prepare_node_attrs(self):",
"def __init__(self, **initial_attributes):\n\n for attribute_name, attribute_value in initial_attributes.items():\n setattr(self, attribute_name, attribute_value)",
"def __init__(self):\n self.quantityList = []",
"def __init__(self, species, qty):\n super(GovernmentMelonOrder, self).__init__(species, qty)\n\n self.passed_inspection = False",
"def __init__(self, order_number, product_id, item_type, name, product_details, factory, quantity, holiday):\n self._order_number = order_number\n self._product_id = product_id\n self._item_type = item_type\n self._name = name\n self._product_details = product_details\n self._factory = factory\n self._quantity = quantity\n self._holiday = holiday\n self._is_valid = True\n self._invalid_notes = \"\"",
"def __init__(self, species, qty):\n\n super().__init__(species, qty)\n self.order_type = \"domestic\"\n self.tax = 0.08",
"def __init__(self, weight, attributes, first_incident_node, second_incident_node):\n self.weight = weight # initialize all necessary fields\n self.attributes = attributes\n self.first_incident_node = first_incident_node\n self.second_incident_node = second_incident_node",
"def __init__(self, pos, model):\n super().__init__(pos, model)\n self.pos = pos\n self.amount = 0.0",
"def initialize(self):\n # FIX: INITIALIZE PROCESS INPUTS??\n for mech, value in self.initial_values.items():\n mech.initialize(value)",
"def __init__(self, polyorder=2):\n self.polyorder = polyorder",
"def __init__(self):\n self.stack = []\n self.ordered = []",
"def __init__(self, addendum, amount, tip_amount=None, transaction_id=None):\n self.__camelcase=constants.ALL_FIELDS\n self.__order=['Addendum', 'Amount', 'TipAmount', 'TransactionId']\n self.addendum=addendum\n self.amount=amount\n self.tip_amount=tip_amount\n self.transaction_id=transaction_id",
"def __init__(self, **kwargs):\n super(ProjectionMatrix, self).__init__(**kwargs) \n LOG.debug(str(kwargs))\n\n #OpenMEEG attributes\n self.om_head = None\n self.om_sources = None\n self.om_sensors = None\n self.om_head2sensor = None\n\n self.om_inverse_head = None\n self.om_source_matrix = None\n self.om_source2sensor = None #For MEG, not used for EEG",
"def __init__(self, numMonomers, dim, b, **kwargs):\n self.numMonomers = numMonomers\n self.dim = dim\n position = kwargs.get('position',None)\n if(position is not None):\n self.positions = position\n else:\n self.positions = b*np.cumsum(np.random.randn(numMonomers,dim),0)\n self.b = b\n self.LaplacianMatrix = self.Linear_Rouse_Matrix()\n Graph.__init__(self,self.numMonomers,adjmatrix=self.LaplacianMatrix.copy())\n self.Nc = 0\n self.freeMonomers = []\n self.possibleEncounters = []\n self.freeMonomersNames = {}\n \n self.forces = []\n \n self.colors = ['r']*numMonomers",
"def __init__(self, species, qty, order_type, tax):\n self.species = species\n self.qty = qty\n self.shipped = False\n self.order_type = order_type\n self.tax = tax",
"def __init__(self, process_list):\n self.__process_list = process_list\n self.__n_initial = len(process_list)",
"def _set_attributes(self):",
"def __init__(self, grid_tuples):\n super(ParamGrid, self).__init__()\n self.grid = OrderedDict(grid_tuples)",
"def __init__(self):\r\n self.data = PositionalList()",
"def createOrders(self):\n self.ordersDict = {}\n for pstep in self.processingSteps:\n if pstep.orderid not in self.ordersDict:\n self.ordersDict[pstep.orderid] = Order()\n self.ordersDict[pstep.orderid].addProcessingStep(pstep)",
"def __init__(self, ebunch=None):\n super(BayesianModel, self).__init__()\n if ebunch:\n self.add_edges_from(ebunch)\n self.cpds = []\n self.cardinalities = self.get_cardinality()\n self.probs = dict()",
"def __init__(self):\n self.rho=[]\n self.te=[]\n self.ti=[]\n self.ne=[]\n self.ni=[]\n self.ni1=[]\n self.ni2=[]\n self.ni3=[]\n self.vtor=[]\n self.zeff=[]\n\n self.nion=1\n self.Z=[]\n self.A=[]\n self.coll_mode=[]",
"def __attrs_post_init__(self):\n\n self.jobdate = parse(to_str(self.jobdate).strip())\n self.vehicleid = to_str(self.vehicleid).strip()\n self.reason = to_str(self.reason).strip()\n self.notes = to_str(self.notes).strip()\n self.costparts = Decimal(to_str(self.costparts).strip())\n self.costlabor = Decimal(to_str(self.costlabor).strip())\n self.costtotal = Decimal(to_str(self.costtotal).strip())\n\n # Apply additional data transformations\n self.yearmon = datetime.strftime(self.jobdate, '%Y-%m')",
"def __init__(self, initial_data=[]):\n hdict.__init__(self)\n\n for elt in initial_data:\n self.add(elt)",
"def __init__(self, dimensions=2):\n assert dimensions > 0\n for d in range(0,dimensions+1):\n self.weight.append(0)",
"def __init__(self):\n self.run = OrderedDict()",
"def set_order(self, order):\n self.order = order",
"def set_order(self, order):\n self.order = order",
"def __init__(self):\n self.normal = []\n self.reverse = []",
"def __init__(self):\n self._keys = []\n self._sortKeys = []",
"def __init__(self, m, c):\n self.m = m\n self.c = c",
"def __init__(self, statistic, order=2, log=False, normalize=False, type='norm', **kwargs):\n if type=='norm':\n name = statistic.name + '_l' + str(order)\n else:\n name = statistic.name + '_' + type\n if log:\n name += 'log'\n super().__init__(name, statistic.group, **kwargs)\n self._order = order\n self._log = log\n self.statistic = statistic\n self._saved_stat = None\n self._normalize = normalize\n self._type = type",
"def __init__(self, ordered_dict):\n self.cur_item = 0\n self.dict = ordered_dict",
"def __init__(self, desc = {}):\n (\n self.x,\n self.y,\n self.z\n ) = itemgetter('x','y','z')(desc['position'])\n (\n self.rotX,\n self.rotY,\n self.rotZ\n ) = itemgetter('x','y','z')(desc['rotation'])",
"def __init__(self, attribute_names):\r\n self.attribute_names = attribute_names\r\n self.tree = None",
"def __init__(self, extra_fields=None):\n if extra_fields:\n self.fields.extend(extra_fields)\n self.data = {k: [] for k in self.fields}\n self.last_r = 0.0",
"def __init__(self):\n print(\"\\nStarting a new order.\\nThank you for visiting our on-line store!\")\n self.__items_list = []\n self.__purchase_date = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.__order_number = Order.__last_order_number_used + 1\n Order.__last_order_number_used = self.__order_number",
"def __init__(self, num_carts, locations):\n self._locations = locations\n self._depot = 0 # packing zone index\n self._num_carts = num_carts",
"def reorder(self, new_order):\n #TODO doesn't work probably CRA 3/2019\n for field in [\"atoms\", \"xyz\"]:\n self.__dict__[field] = self.__dict__[field][list(new_order)]\n self.atoms = [self.atoms[i] for i in new_order]",
"def _init(self, position):\n\t\tself._position = position",
"def __init__(self, order_details: OrderDetails):\n self.details = order_details",
"def __init__(self, **attrs):\n \n self.part_id = None\n self.category_id = None\n self.external_ids = {}\n self.name = None\n \n self.year_from = None\n self.year_to = None\n \n self.url = None\n self.img_url = None\n \n self.print_of = None\n self.prints = []\n self.molds = []\n self.alternates = []\n \n super().__init__(**attrs)",
"def __init__(self):\n self.COMMON_ATOMS = [('B', 0), ('B', -1), ('Br', 0), ('Br', -1), ('Br', 2), ('C', 0), ('C', 1), ('C', -1), ('Cl', 0),\n ('Cl', 1), ('Cl', -1), ('Cl', 2), ('Cl', 3), ('F', 0), ('F', 1), ('F', -1), ('I', -1), ('I', 0),\n ('I', 1), ('I', 2), ('I', 3), ('N', 0), ('N', 1), ('N', -1), ('O', 0), ('O', 1), ('O', -1),\n ('P', 0),\n ('P', 1), ('P', -1), ('S', 0), ('S', 1), ('S', -1), ('Se', 0), ('Se', 1), ('Se', -1), ('Si', 0),\n ('Si', -1)]",
"def __init__(self, openChannels, spinGroups, **kwargs):\n\n ancestryModule.ancestry.__init__(self)\n self.channels = openChannels\n self.spinGroups = spinGroups\n for attr in self.optAttrList:\n setattr(self, attr, kwargs.get(attr))",
"def __init__(self, order_dict):\n self.order_ref = order_dict['order_ref']\n\n self.error_status_code = order_dict.get('error_status_code', None)\n self.error_reason = order_dict.get('error_reason', None)\n self.status = order_dict.get('status')\n self.created = timeutils.parse_isotime(order_dict['created'])\n if order_dict.get('updated') is not None:\n self.updated = timeutils.parse_isotime(order_dict['updated'])\n else:\n self.updated = None\n self.secret_ref = order_dict.get('secret_ref')",
"def __init__ (self,raw_order):\n self.raw=raw_order\n \n raw_order=raw_order.split(\",\") # Turn into a list of strings\n \n self.Code=raw_order[0] # The order code\n self.TIcode=raw_order[3] # The code of the instrument\n self.Type=raw_order[7] # A buy or a sell order\n self.Price=float(raw_order[10]) \n self.Size=int(raw_order[11]) # doesn't allow for half of stock\n self.BroadcastUpdateAction=raw_order[13]\n try:\n self.Time = datetime(int(raw_order[-3][4::]),int(raw_order[-3][2:4]),int(raw_order[-3][0:2]),\n int(raw_order[-2][0:2]), int(raw_order[-2][3:5]), int(raw_order[-2][6:8]), int(raw_order[-2][9::]))\n except:\n \n self.Time = datetime(int(raw_order[-3][4::]),int(raw_order[-3][2:4]),int(raw_order[-3][0:2]),\n int(raw_order[-2][0:2]), int(raw_order[-2][3:5]), int(raw_order[-2][6:8]))\n \n \n self.MessageSequenceNumber=int(raw_order[-1]) # A number that takes care of orders placed at the same time\n\n self.ind=\"LimitOrder\"\n self.ParticipantCode=raw_order[6]\n self.BestBid=0; self.BestAsk=np.inf\n self.N_Prec=0;self.Vol_Prec=0\n self.OriginalSize=int(raw_order[11])",
"def __init__(self):\n # Dict of minecraft object in form of \"dict[id] = name\"\n self.data_values = dict()\n self.parser = self.setup_parser()",
"def __init__(self, **kwargs):\n self.__dict__.update(kwargs)\n self._calc_coords()",
"def __init__ (self, pseudo, bag, position, jeu):\n self.pseudo = pseudo\n self.bag = bag\n self.position = position\n self.jeu = jeu",
"def __init__(self, attributes_names: list):\r\n self.attributes_names = attributes_names",
"def __init__(self, attributes_names: list):\r\n self.attributes_names = attributes_names",
"def initialise(self):",
"def __init__(self, geom, matrix, materialnodebysymbol):\n self.matrix = matrix\n self.materialnodebysymbol = materialnodebysymbol\n self._primitives = geom._primitives\n self.original = geom",
"def __init__(self, *args, **kwargs):\n\n OrderedDict.__init__(self, *args, **kwargs)\n\n # the original parsed code, used for saving things out\n self.__orig = {}",
"def __init__ (self):\n self.tag = 0\n self.mDict = {}",
"def __init__(self, melon_type, shape, color_rating, harvest_from, harvest_by):\n self.melon_type = melon_type\n self.shape = shape\n self.color_rating = color_rating\n self.harvest_from = harvest_from\n self.harvest_by = harvest_by"
] | [
"0.68216413",
"0.6461353",
"0.6418837",
"0.6366196",
"0.62271947",
"0.6196553",
"0.6189848",
"0.618619",
"0.6156593",
"0.61555725",
"0.61342317",
"0.6116472",
"0.6085777",
"0.59540695",
"0.5946118",
"0.593134",
"0.5919386",
"0.5895247",
"0.5894288",
"0.58701146",
"0.5856023",
"0.58309937",
"0.5768767",
"0.5744106",
"0.5738495",
"0.5711613",
"0.5703207",
"0.5697906",
"0.5695903",
"0.5677723",
"0.5675916",
"0.5674612",
"0.5670754",
"0.5661744",
"0.56508505",
"0.5650713",
"0.56484383",
"0.5640504",
"0.56382465",
"0.5635909",
"0.5623067",
"0.56229186",
"0.56167704",
"0.561625",
"0.5604361",
"0.55976313",
"0.5594784",
"0.5591189",
"0.5579339",
"0.55775577",
"0.55767655",
"0.55683273",
"0.55641174",
"0.5559811",
"0.55566543",
"0.5536365",
"0.5536221",
"0.5535361",
"0.5534583",
"0.55313694",
"0.55263054",
"0.55099136",
"0.550706",
"0.55011415",
"0.54986626",
"0.5496526",
"0.5494687",
"0.5491642",
"0.5486783",
"0.5484029",
"0.5482564",
"0.5482564",
"0.5480494",
"0.5478862",
"0.54779387",
"0.547598",
"0.54758364",
"0.5474528",
"0.5465505",
"0.5464627",
"0.546415",
"0.546415",
"0.54608524",
"0.54411036",
"0.54311424",
"0.5425524",
"0.54227823",
"0.542164",
"0.5418937",
"0.5418815",
"0.5414191",
"0.5413547",
"0.54121065",
"0.54101706",
"0.54101706",
"0.5406778",
"0.54031575",
"0.54022264",
"0.5398617",
"0.5396539"
] | 0.57612264 | 23 |
Return the country code. | def get_country_code(self):
return self.country_code | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def country_code(self):\n return self.__country_code",
"def country_code(self):\n return self.__country_code",
"def country_code(self):\n return self._plrevgeoloc.countryCode",
"def country(self) -> str:\n return pulumi.get(self, \"country\")",
"def get_country_code(self):\n #method on the class InternationalMelonOrder\n\n return self.country_code\n # international has country code; domestic does not\n # WAI???",
"def country_code(self) -> str | None:\n pass",
"def country(self):\n # type: () -> string_types\n return self._country",
"def country() -> str:",
"def country(self) -> Optional[str]:\n return pulumi.get(self, \"country\")",
"def country(self) -> Optional[str]:\n return pulumi.get(self, \"country\")",
"def get_country_code(self):\n\n try:\n sub_div = next(sub_div for sub_div in pycountry.subdivisions if sub_div.name == self.location)\n country = next(country for country in pycountry.countries if country.alpha_2 == sub_div.country_code)\n return country.alpha_3\n except StopIteration as exc:\n print(\"Cannot find subdivision in\" + str(exc))\n return 'XXX'",
"def country(self):\n return self.status.place['country']",
"def get_country(self):\n return self.reference[REF_COUNTRY][REF_VALUE]",
"def COUNTRY_CODE():\n COUNTRY_CODE = \"us/90210\"\n return COUNTRY_CODE",
"def country_letter_code(self):\n if \"countryLetterCode\" in self._prop_dict:\n return self._prop_dict[\"countryLetterCode\"]\n else:\n return None",
"def country(self):\n return self._country",
"def country(self):\n return self._country",
"def country(self):\n if \"country\" in self._prop_dict:\n return self._prop_dict[\"country\"]\n else:\n return None",
"def country(self):\n if \"country\" in self._prop_dict:\n return self._prop_dict[\"country\"]\n else:\n return None",
"def get_country(ip):\r\n return geoip.country_code_by_addr(ip)",
"def country(self):\n if self._country is not None:\n return self._country\n if not self.isValid():\n return None\n self._country = self.geocoder_results.country\n return self._country",
"def get_country_code(country_name):\n # worldmap_chart = pygal.maps.world.World()\n # for code, name in worldmap_chart:\n\n for code, name in i18n.COUNTRIES:\n\n # for code, name in COUNTRIES.items():\n if name == country_name:\n print(code)\n return code\n # If the country wasn't found, return None.\n return None",
"def country_or_region(self) -> str:\n return pulumi.get(self, \"country_or_region\")",
"def get_country_code(contry_name):\n for code, name in COUNTRIES.items():\n if name == contry_name:\n return code\n return None",
"def country_id(self):\n return self._country_id",
"def country_id(self):\n return self._country_id",
"def country_codes(country):\n countryObject = None\n try:\n countryObject = pycountry.countries.search_fuzzy(country)\n return countryObject[0].alpha_2\n except LookupError:\n pass\n try:\n splittedCountry = country.split(',')[0]\n countryObject = pycountry.countries.search_fuzzy(splittedCountry)\n return countryObject[0].alpha_2\n except LookupError:\n return 'No Code'",
"def get_country_code(country_name) :\n for code, name in COUNTRIES.items() :\n if name==country_name :\n return code\n # if the country wasn't found, return None\n return None",
"def country(alpha_2_code: str) -> None:",
"def country(name):\n return location_db().find(name=name)[\"country\"]",
"def _get_country_code(self, cr, uid, context=None):\n context = context or {}\n user_company = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id\n return user_company.partner_id and user_company.partner_id.country_id \\\n and user_company.partner_id.country_id.code or 'XX'",
"def get_country_code(country_name):\n\n for code, name in COUNTRIES.items():\n if name == country_name:\n return code\n\n # If country was not found, return nothing\n return None",
"def get_cloudflare_country(self, request):\n try:\n return request.META['HTTP_CF_IPCOUNTRY'].lower()\n except KeyError:\n pass",
"def get_country_from_record(ip):\r\n record = geoip.record_by_addr(ip)\r\n if record != None:\r\n return record['country_code']",
"def conference_country(self):\n return ConferenceReader(self.record).country",
"def get_country_code(country_name):\n for code, name in COUNTRIES.items():\n if name == country_name:\n return code\n elif country_name == 'Yemen, Rep.':\n return 'ye'\n elif country_name == 'Vietnam':\n return 'vn'\n elif country_name == 'Tanzania':\n return 'tz'\n elif country_name == 'Moldova':\n return 'md'\n elif country_name == 'Macao SAR, China':\n return 'mo'\n elif country_name == 'Macedonia, FYR':\n return 'mk'\n elif country_name == 'Libya':\n return 'ly'\n elif country_name == 'Lao PDR':\n return 'la'\n elif country_name == 'Korea, Dem. Rep.':\n return 'kp'\n elif country_name == 'Korea, Rep.':\n return 'kr'\n elif country_name == 'Gambia':\n return 'gm'\n elif country_name == 'Iran, Islamic Rep.':\n return 'ir'\n elif country_name == 'Hong Kong SAR':\n return 'hk'\n elif country_name == 'Congo, Dem. Rep.':\n return 'cd'\n elif country_name == 'Congo, Rep.':\n return 'cf'\n elif country_name == 'Macao SAR, China':\n return 'mo'\n elif country_name == 'Macedonia, FYR':\n return 'mk'\n elif country_name == 'Libya':\n return 'ly'\n elif country_name == 'Lao PDR':\n return 'la'\n elif country_name == 'Korea, Dem. Rep.':\n return 'kp'\n elif country_name == 'Korea, Rep.':\n return 'kr'\n elif country_name == 'Gambia':\n return 'gm'\n # If the country wasn't found, return None.\n return None",
"def issuerCountry(self) -> str:\n country = self.issuer.native['country_name']\n return country",
"def get_country_code(country_name):\n # values = list(COUNTRIES.values())\n # keys = list(COUNTRIES.keys())\n #\n # try:\n # index = values.index(country_name)\n # except ValueError:\n # # Not found\n # return None\n #\n # return keys[index]\n\n for code, name in COUNTRIES.items():\n if name == country_name:\n return code\n\n return None",
"def get_country_dcid(country_code: str) -> str:\n numeric_code = int(country_code, 10)\n if numeric_code in UN_COUNTRY_CODES:\n return UN_COUNTRY_CODES[numeric_code]\n return None",
"def get_country_code(country_name):\n for code, name in COUNTRIES.items():\n if name == country_name:\n return code\n # if string isn't found returns None\n else:\n continue",
"def get_country(self, field_name='COUNTRY'):\n default = self.get_default(field_name)\n if default != '' and default != None:\n return '%s' % str(default).split(',')[-1].strip()\n return ''",
"def country_identifier(name):\n if name.lower() in _country_dict.keys():\n return _country_dict[name.lower()]\n else:\n return name",
"def country_of_origin(self):\n if self.investor_company:\n return self.investor_company.address_country",
"def get_country(self, country):\n if country == \"United Kingdom\": return \"en\"\n if country == \"Portugal\": return \"pt\"\n\n result = self.session.get(\"https://en.ogame.gameforge.com\")\n soup = BeautifulSoup(result.content, \"html.parser\")\n\n code_list = soup.find(\"ul\", {\"id\": \"mmoList1\"})\n countries = {}\n for tag in code_list.find_all(\"li\"):\n link = tag.find(\"a\")[\"href\"]\n name = tag.string.strip() # name of the country\n code = link.split(\".\")[0].replace(\"//\", \"\")\n countries[name] = code # save to the dict\n\n # check if input was ok\n if not country in countries.keys():\n self.crash(\"Country\", country, \"was not found on the list.\")\n if len(countries[country]) != 2:\n self.crash(\"Can't fetch code for country\", country)\n\n return countries[country]",
"def get_country(ip_addr):\r\n html = urllib2.urlopen('http://freegeoip.net/json/' + ip_addr).read()\\\r\n .decode('utf-8')\r\n responseJson = json.loads(html)\r\n return responseJson.get('country_code')",
"def get_country_info(country):\n return GoogleV3().geocode(country)",
"def country_flag(country):\n\tif not country:\n\t\treturn u''\n\tresult = Country.objects.filter(name__icontains=country)\n\tif result:\n\t\tc = result[0]\n\t\tiso = c.iso\n\t\tflag_location = iso_flag(iso)\n\t\treturn flag_location\n\treturn u''",
"def user_country(self):\n return utils.to_country(lib.sp_session_user_country(self._sp_session))",
"def mock_country_code_by_addr(self, ip_addr):\r\n ip_dict = {\r\n '1.0.0.0': 'CU',\r\n '2.0.0.0': 'IR',\r\n '3.0.0.0': 'SY',\r\n '4.0.0.0': 'SD',\r\n '5.0.0.0': 'AQ', # Antartica\r\n }\r\n return ip_dict.get(ip_addr, 'US')",
"def get_country_from_code(country_code):\n country = []\n countries = [(country.alpha_2, country.name) for country in pycountry.countries]\n for country_index in range(len(countries)):\n # index 0 is the country code selected from the form\n if(countries[country_index][0] == country_code):\n country.append(countries[country_index])\n return country[0][1]",
"def get_country_name(ip_addr):\n global geoip_db_reader\n try:\n name = geoip_db_reader.country(ip_addr).country.name\n return name\n except geoip2.errors.AddressNotFoundError:\n return None",
"def get_weather_country(self):\n return self.bot_data_file[\"weather\"][\"default_country\"]",
"def city_country(city_name, country_name):\n city_country_combo = city_name + ', ' + country_name\n return city_country_combo.title()",
"def get_ip_country(ip_address):\r\n return requests.get(IPINFO_URL.format(ip = ip_address)).json()['country']",
"def get_ip_country(ip_address):\r\n with requests.Session() as s:\r\n resp = s.get(IPINFO_URL.format(ip=ip_address))\r\n resp.raise_for_status()\r\n return resp.json()['country']",
"def get_country_details(self,country):\n try:\n country_obj = pycountry.countries.get(name=country)\n if country_obj is None:\n c = pycountry.countries.search_fuzzy(country)\n country_obj = c[0]\n continent_code = pc.country_alpha2_to_continent_code(country_obj.alpha_2)\n continent = pc.convert_continent_code_to_continent_name(continent_code)\n return country_obj.alpha_3, continent\n except:\n if 'Congo' in country:\n country = 'Congo'\n elif country == 'Diamond Princess' or country == 'Laos' or country == 'MS Zaandam' or country == 'Holy See' or country == 'Timor-Leste':\n return country, country\n elif country == 'Korea, South' or country == 'South Korea':\n country = 'Korea, Republic of'\n elif country == 'Taiwan*':\n country = 'Taiwan'\n elif country == 'Burma':\n country = 'Myanmar'\n elif country == 'West Bank and Gaza':\n country = 'Gaza'\n else:\n return country, country\n country_obj = pycountry.countries.search_fuzzy(country)\n continent_code = pc.country_alpha2_to_continent_code(country_obj[0].alpha_2)\n continent = pc.convert_continent_code_to_continent_name(continent_code)\n return country_obj[0].alpha_3, continent",
"def countries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"countries\")",
"def countries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"countries\")",
"def country_hint(self, value):\n return None",
"def language_name(value):\n return pycountry.languages.get(alpha_2=value)",
"def countries(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"countries\")",
"def country_name(country_id):\n if country_id == '999':\n #Added for internal call - ie flag/phone.png\n return _('internal call').title()\n try:\n obj_country = Country.objects.get(id=country_id)\n return obj_country.countryname\n except:\n return _('unknown').title()",
"def city_country(city, country):\n return(city.title() + \", \" + country.title())",
"def get_default_country(self):\n proxy = self.env['ir.config_parameter']\n default_country = proxy.sudo().get_param('default_country')\n if not default_country:\n raise UserError('Please use Default Country as US in config parameters.')\n return default_country.strip()",
"def get_default_country(self):\n proxy = self.env['ir.config_parameter']\n default_country = proxy.sudo().get_param('default_country')\n if not default_country:\n raise UserError('Please use Default Country as US in config parameters.')\n return default_country.strip()",
"def city_country(city, country):\r\n\treturn(city.title() + ', ' + country.title())",
"def get_currency_code(self: RcnRegion) -> Optional[str]:\n return {\n RcnRegion.GREAT_BRITAIN: \"GBP\",\n RcnRegion.NORWAY: \"NOK\",\n RcnRegion.SWEDEN: \"SEK\",\n }.get(self)",
"def city_country(city, country):\n return city.title() + \", \" + country.title()",
"def _get_iso_code(cls, language):\n iso = cls._SPECIAL_ISO_CODES.get(language, language[:3])\n return iso if language in cls._SUPPORTED_LANGUAGES else None",
"def city_country(city, country):\n return(city + ', ' + country)",
"def test_country_code(self):\n\t\tcountry_name = 'United States'\n#\t\tpopulation = int(float(pop_dict['Value']))\n\t\tcode = get_country_code(country_name)\t\t\n\t\t#Assert methods verifies result received matches expected one\n\t\tself.assertEqual(code, 'usa')",
"def calling_code_with_country(formatting=''):\r\n\r\n cursor.execute('select * from countries_and_calling_codes \\\r\n order by random() limit 1;')\r\n (country, calling_code) = cursor.fetchone()\r\n if formatting is dict:\r\n return formatting({country: calling_code})\r\n return (formatting([country,\r\n calling_code]) if formatting else '{} {}'.format(country,\r\n calling_code))",
"def __create_country_dropdown(self):\n return dcc.Dropdown(\n id=\"dd_country\",\n options=self.data_reader.get_country_options(),\n value=\"Canada\",\n )",
"def city_country(city, country):\n formatted_city_country = city.title() + \", \" + country.title() + \".\"\n return formatted_city_country",
"def language_code(self) -> str:\n return pulumi.get(self, \"language_code\")",
"def city_country(city, country):\n full_city = city + \", \" + country\n return full_city.title()",
"def country():\r\n\r\n cursor.execute('SELECT country_names FROM countries \\\r\n order by RANDOM() limit 1;')\r\n return cursor.fetchone()[0]",
"def get_city_country(city, country, population=''):\n if population:\n city_country = f\"{city}, {country} - population {population}\"\n else:\n city_country = f\"{city}, {country}\"\n return city_country.title()",
"def city_country(city_name, country_name):\n combi = f\"{city_name.title()}, {country_name.title()}\"\n return combi.title()",
"def _get_country_id(self, code2):\n if not hasattr(self, '_country_codes'):\n self._country_codes = {}\n\n if code2 not in self._country_codes.keys():\n self._country_codes[code2] = Country.objects.get(code2=code2).pk\n return self._country_codes[code2]",
"def get_user_country(user_location):\n geo_locator = geopy.Nominatim(user_agent=\"User Location\", timeout=10)\n location = geo_locator.reverse(user_location, language='en')\n location = str(location).split(', ')\n country = location[-1]\n\n if country == 'United States of America':\n country = 'USA'\n elif country == 'United Kingdom':\n country = 'UK'\n\n return country",
"def get_city_country(city, country, population=''):\n if population:\n location = city + ' ' + country + ' ' + str(population)\n return location.title()\n\n else:\n location = city + ' ' + country\n return location.title()",
"def state(self):\n state_code = MISSING\n try:\n country_code = self.status.place[\"country_code\"]\n except TypeError:\n return MISSING\n place_type = self.status.place[\"place_type\"]\n if country_code == \"US\" and place_type == \"city\":\n full_name = self.status.place[\"full_name\"]\n state_code = full_name.split(\",\")[-1].strip().upper()\n state_code = state_code if state_code in valid_state_codes else MISSING\n else:\n pass\n return state_code",
"def resolveCountryCode(country_code):\n country_name = None\n if len(country_code) > 2:\n country_name = country_code\n country_code = next((cc for cc, country in countries.items() if country == country_code), None)\n if country_code not in countries:\n logger.error(\"Country code %s unknown. For a list of know codes execute:\")\n logger.error(sys.argv[0] + ' --list-countries \\tList all available countries that can be blocked.')\n sys.exit(255)\n if not country_name:\n country_name = countries[country_code]\n return [country_code, country_name]",
"def language_code(self):\n return self._language_code",
"def test_country_name_in_countries(self):\n\t\tcountry_code = get_country_code('Andorra')\n\t\tself.assertEqual(country_code, 'ad')",
"def get_city_country(city, country, population=''):\n\tif population:\n\t\tcity_country = city.title() + ', ' + country.title() + \" - population \" + str(population)\n\telse:\n\t\tcity_country = city.title() + ', ' + country.title()\n\treturn city_country",
"def city_country(city, country):\n return f\"{city.title()}, {country.title()}\"",
"def city_country(city, country):\n return f\"{city.title()}, {country.title()}\"",
"def postal_code(self):\n return self._postal_code",
"def getCountry(soup):\n title_details = self.getAdditionalDetails(soup)\n pattern = r'country_of_origin.*?>(.*?)<'\n country = re.findall(pattern, str(title_details))\n return country",
"def get_country_by_country_code(country_code):\n # string is default converter for dynamic routes\n # get_or_404() is like get() but aborts with 404 if not found\n # instead of returning None.\n return jsonify(Country.query.get_or_404(country_code).to_dict())",
"def flag(countrycode: str) -> str:\r\n\r\n code = [c for c in countrycode.lower() if c in ASCII_LOWER]\r\n if len(code) == 2:\r\n # Regional indicator symbols\r\n return flag_regional_indicator(code)\r\n if len(code) > 2 and len(code) < 7:\r\n # Tag sequence\r\n return flag_tag_sequence(code)\r\n found = ''.join(code)\r\n raise ValueError(\r\n 'invalid countrycode, found %d (%r) in %r.' %\r\n (len(found), found, countrycode))"
] | [
"0.8740297",
"0.8740297",
"0.8514241",
"0.8449802",
"0.83579975",
"0.8277011",
"0.8177935",
"0.8112277",
"0.806426",
"0.806426",
"0.80227566",
"0.8021162",
"0.80009323",
"0.7983514",
"0.7848084",
"0.7834845",
"0.7834845",
"0.77554494",
"0.77554494",
"0.7722244",
"0.77020496",
"0.7666578",
"0.7636668",
"0.757869",
"0.757715",
"0.757715",
"0.7571095",
"0.75694007",
"0.7529751",
"0.7519669",
"0.7438305",
"0.73345906",
"0.7253247",
"0.72332984",
"0.72189456",
"0.7174124",
"0.71315795",
"0.70699376",
"0.7060021",
"0.70546424",
"0.70501626",
"0.7020268",
"0.70061105",
"0.69815004",
"0.6932719",
"0.692307",
"0.68571067",
"0.67723143",
"0.6623281",
"0.6593745",
"0.6555861",
"0.6543522",
"0.65030503",
"0.6471673",
"0.6461888",
"0.64119494",
"0.63923067",
"0.63923067",
"0.6390296",
"0.63784015",
"0.6357719",
"0.6357339",
"0.63310957",
"0.63099325",
"0.63099325",
"0.6307245",
"0.63035476",
"0.62929565",
"0.6291867",
"0.62696767",
"0.6246072",
"0.62390614",
"0.6232047",
"0.6231423",
"0.62169397",
"0.6215233",
"0.6213064",
"0.6210202",
"0.6203329",
"0.62017167",
"0.61856097",
"0.61406755",
"0.61392456",
"0.6131071",
"0.6125633",
"0.6102936",
"0.6097312",
"0.6095383",
"0.6095383",
"0.6086465",
"0.6074124",
"0.60702497",
"0.6067476"
] | 0.87174577 | 8 |
method that takes boolean value for passed = True or False | def mark_inspection(self, passed):
self.passed_inspection = passed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def functionWithArg(arg):\n return bool(arg)",
"def give_me_a_boolean():\n return True\n pass",
"def convert_boolean(cls, param, value):\r\n return True",
"def isTrue(*args, **kwargs)->None:\n pass",
"def boolean_func(experiment):",
"def set_boolean(x):\n\n if x:\n return \"True\"\n else:\n return \"False\"",
"def bool_option (arg: Any) -> bool:\n return True",
"def iff(bool,trueValue,falseValue):\n if bool:\n return trueValue\n else:\n return falseValue",
"def _true(*args):\n # pylint:disable=unused-argument\n return True",
"def _always_true(*args, **kwargs):\n return True",
"def Bool(arg):\n return arg.lower() in ('y', 'true', 't', '1')",
"def boolean(val):\n\tif val == \"True\" or val == \"1\":\n\t\treturn True\n\telse:\n\t\treturn False",
"def process_bool_arg(arg):\n if isinstance(arg, bool):\n return arg\n elif isinstance(arg, basestring):\n if arg.lower() in [\"true\", \"1\"]:\n return True\n elif arg.lower() in [\"false\", \"0\"]:\n return False",
"def get_bool2(self):\n pass",
"def check_for_bool(check):",
"def __bool__(self):\n raise ValueError(\"bool() not permitted\")",
"def __bool__(self):\n return bool(self.get_value())",
"def __bool__(x):\n if x.value == 1:\n return True\n elif x.value == -1:\n return False\n else:\n raise ValueError('cannot determine boolean value of Unknown')",
"def f1(a, b): \n if a == False and b == True:\n return True\n else:\n return False",
"def parameter_cast_to_bool(ival):\r\n if type(ival) is bool:\r\n return ival\r\n if type(ival) is int:\r\n return bool(ival)\r\n if type(ival) is str:\r\n lower = ival.lower()\r\n if lower == 'no' or lower == 'false' or lower == '0':\r\n return False\r\n if lower == 'yes' or lower == 'true' or lower == '1':\r\n return True\r\n return None",
"def bool(x) -> bool:\n pass",
"def getBoolParam(self, params, name):\n return params.get(name) in ('True', 'true', '1')",
"def explicit_bool(value: bool) -> bool:\n return value",
"def visit_true(self) -> T:",
"def __call__(self, *args):\n if self.fall or not args:\n return True\n elif self.value in args: # changed for v1.5\n self.fall = True\n return True\n else:\n return False",
"def boolean_function(bool_variable):\n\tif bool_variable:\n\t\treturn \"The boolean variable is True\"\n\telse:\n\t\treturn \"The boolean variable is False\"",
"def unbool(element, true=object(), false=object()):\r\n\r\n if element is True:\r\n return true\r\n elif element is False:\r\n return false\r\n return element",
"def g1(a, b): \n if a == True and b == True:\n return False\n else:\n return True",
"def test_bool_field():",
"def __bool__(self):\n return self is TRUE",
"def visit_false(self) -> T:",
"def getBoolean(self, int: int, int2: int) -> bool:\n ...",
"def _prep_bool_arg(arg):\n return bool(strtobool(str(arg)))",
"def do(self, value):\n return True",
"def _op(\n x: Union[bool, dts.Boolean, tps.BooleanValue],\n y: Union[bool, dts.Boolean, tps.BooleanValue],\n ) -> T:",
"def is_bool(self):\n return False",
"def bool(self, obj):\n return True",
"def bool(self, obj):\n return True",
"def __call__(self, parser, namespace, value, unused_option_string=None):\n try:\n setattr(namespace, self.dest, util.parse_bool(value))\n except TypeError as err:\n raise argparse.ArgumentError(self, 'Boolean value required') from err",
"def __init__(self, val: bool) -> None:\n if type(val) != bool:\n raise TypeError(f\"Invalid literal {val} with type '{val.__class__.__name__}' for parameter 'val'\")\n self._val: bool = val\n return",
"def _boolean_callback(self, *args):\n\t\tnew_value = args[1].get_boolean()\n\n\t\targs[0].set_state(GLib.Variant.new_boolean(new_value))\n\t\tself.window.set_picture_title()\n\t\tself.get_active_pane().hide_options_menu()",
"def on_true(self) -> global___Expression:",
"def bool_(val):\n if isinstance(val, six.string_types) and val.lower() == 'false':\n return False\n return bool(val)",
"def make_bool(value):\n def make_value():\n return verify.Term(verify.BOOLEAN, value)\n return make_value",
"def is_bool (self, phrase):\r\n \r\n return isinstance(phrase,bool)",
"def on_false(self) -> global___Expression:",
"def __bool__(self):\r\n raise TypeError('cannot use secure type in Boolean expressions')",
"def lift(f):\n @wraps(f)\n def inner(value):\n result = f(value)\n return SuperBool(result, f.__doc__) if not isinstance(result, SuperBool) else result\n return inner",
"def arg_to_boolean(arg: str) -> Optional[bool]:\n return argToBoolean(arg) if arg else None",
"def pythonvalue(self, value):\n return value in (\"true\", \"1\")",
"def __bool__(self):\n return bool(self._value)",
"def light(self, value: bool | int, /) -> None:",
"def post_formatter(self, value):\n if isinstance(value, bool):\n return value and 'true' or None\n return value",
"def __bool__(self):\n raise RuntimeError(\"Cannot evaluate CrypTensors to boolean values\")",
"def bool_validator_advice(validator_args):\n \n return \" {True, False}\"",
"def boolval(space, w_obj):\n return space.newbool(space.is_true(w_obj))",
"def bool(self, item, default=None):\n try:\n item = self.__getattr__(item)\n except AttributeError as err:\n if default is not None:\n return default\n raise err\n\n if isinstance(item, (bool, int)):\n return bool(item)\n\n if (isinstance(item, str) and\n item.lower() in ('n', 'no', 'false', 'f', '0')):\n return False\n\n return True if item else False",
"def __bool__(self):\r\n return self.valid",
"def isPass(value: Any) -> bool: # pragma: no cover\n if isinstance(value, bool):\n return True\n return PASS in value",
"def val(self, new_val: bool) -> None:\n if type(new_val) != bool:\n raise TypeError(f\"Invalid literal {new_val} with type '{new_val.__class__.__name__}' for parameter 'new_val'\")\n self._val: bool = new_val\n return",
"def CONST_BOOL(self, t):\n t.value = False if t.value == '#false' else True\n return t",
"def flag():\n pass",
"def restricted_bool(x):\n try:\n x = bool(x)\n except ValueError:\n raise argparse.ArgumentTypeError(\"%r not a bool literal\" % (x,))\n return x",
"def _handle_boolean(\n *, artifacts: types.ColumnArtifacts # pylint: disable=unused-argument\n) -> Boolean:\n return Boolean",
"def test_getboolean_with_default(self):\n self.assertEqual(self.config.getboolean('advanced','p'),None)\n self.assertEqual(self.config.getboolean('advanced','p',True),True)",
"def setBoolValue(self, *args):\n return _libsbml.ConversionProperties_setBoolValue(self, *args)",
"def process_arg(arg):\n return False",
"def cast(self, value: Any) -> Any:\n if value is None:\n return False\n if isinstance(value, bool):\n return value\n strvalue = str(value).lower()\n if strvalue in ['1', 't', 'true']:\n return True\n elif strvalue in ['', '0', 'f', 'false']:\n return False\n raise err.InvalidArgumentError(\"not a Boolean '{}'\".format(value))",
"def infer_bool(input_value):\n # Boolean\n if isinstance(input_value, bool):\n return input_value\n\n # Integer\n if isinstance(input_value, int):\n return bool(input_value)\n\n # String\n if isinstance(input_value, str):\n if 'Y' in input_value.upper():\n return True\n else:\n return False\n\n # None\n if input_value is None:\n return False",
"def get_bool(self, option, argument=None):\n return bool(self.get(option, argument))",
"def convertToBoolean(boolean: bool) -> bool:\n ...",
"def _setForBinding (self, value):\n if not isinstance(value, bool):\n raise TypeError(value)\n self.__forBinding = value\n return value",
"def __init__(self, value, extra=None):\n if not isinstance(value, bool):\n raise TypeError(\n 'Passed value must be a bool. %s found instead.' % type(value))\n\n self._value = value\n self._extra = extra",
"def value(self) -> bool:",
"def return_false(self):\n return False",
"def _check_boolean_value(arg_dict, key):\n to_check_value = arg_dict[key].lower()\n if to_check_value in ['disabled', 'enabled']:\n return 0\n else:\n return -1",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def setEnabled(*args):",
"def resolve_url_bool(val):\n if isinstance(val, str):\n if val.lower() == \"true\" or val == \"1\":\n return True\n else:\n return False\n else:\n return False",
"def getBool(string):\n return (True)",
"def setBoolValue(self, *args):\n return _libsbml.ConversionOption_setBoolValue(self, *args)",
"def bool_on_off(value):\n return 'on' if value else 'off'",
"def get_boolean(self, df):\n if not self.value:\n return False\n elif not self.par:\n return ()\n if self.variable_type == 'interval':\n return self._interval_boolean(df)\n elif self.variable_type == 'list':\n return self._list_boolean(df)",
"def is_true(self, opt_value):\r\n return isinstance(opt_value, tuple) and opt_value[0] or opt_value",
"def format_bool(b):\n return \"YES\" if b else \"NO\"",
"def take_action_on_flags(self, *args, **kwargs):\r\n pass",
"def boolean(self) -> bool:\n return self.random.choice([True, False])",
"def __bool__(self):\n raise RuntimeError(\"Cannot evaluate BinarySharedTensors to boolean values\")",
"def preprocess_bools(args):\n for arg in args:\n if type(args[arg]) == bool:\n args[arg] = int(args[arg])\n return args",
"def T(*args):\n return True",
"def bool_flag(s):\n if s.lower() in ['off', 'false', '0']:\n return False\n if s.lower() in ['on', 'true', '1']:\n return True\n raise argparse.ArgumentTypeError(\"invalid value for a boolean flag (0 or 1)\")",
"def string_to_bool(arg):\r\n if arg.lower() == 'true':\r\n arg = True\r\n elif arg.lower() == 'false':\r\n arg = False\r\n else:\r\n raise ValueError('ValueError: Argument must be either \"true\" or \"false\".')\r\n return arg"
] | [
"0.75803596",
"0.734512",
"0.7176815",
"0.7096356",
"0.7058401",
"0.70008546",
"0.69879454",
"0.6956472",
"0.69338465",
"0.6895815",
"0.68813026",
"0.6857039",
"0.67971283",
"0.6779212",
"0.6753107",
"0.6710721",
"0.6669785",
"0.66588914",
"0.6656253",
"0.6649511",
"0.6648595",
"0.65900725",
"0.6570412",
"0.655949",
"0.65578455",
"0.65515655",
"0.6482064",
"0.6435379",
"0.64353627",
"0.64251006",
"0.6419614",
"0.6419437",
"0.6415863",
"0.6389879",
"0.6359352",
"0.6318283",
"0.63081974",
"0.63081974",
"0.6293982",
"0.62776154",
"0.62699693",
"0.62600833",
"0.6255073",
"0.6246858",
"0.62248653",
"0.62150365",
"0.6196909",
"0.619241",
"0.61851466",
"0.6157449",
"0.615707",
"0.6136266",
"0.61321354",
"0.6117189",
"0.6116899",
"0.6109574",
"0.6107399",
"0.61065096",
"0.610336",
"0.60942733",
"0.6091188",
"0.6088099",
"0.60865116",
"0.60753924",
"0.6053491",
"0.6041019",
"0.6037283",
"0.60355127",
"0.6032059",
"0.6029896",
"0.602754",
"0.6021089",
"0.6019305",
"0.6015177",
"0.60068524",
"0.60004675",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5999671",
"0.5989997",
"0.59893453",
"0.5987428",
"0.59760207",
"0.59687966",
"0.59635144",
"0.59631366",
"0.5962238",
"0.5961555",
"0.59614915",
"0.595482",
"0.59483397",
"0.59478706",
"0.59459704"
] | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.