code stringlengths 281 23.7M |
|---|
class HeaderChainSyncer(Service):
def __init__(self, chain: AsyncChainAPI, db: BaseAsyncChainDB, peer_pool: ETHPeerPool, enable_backfill: bool=True, checkpoint: Checkpoint=None) -> None:
self.logger = get_logger('trinity.sync.header.chain.HeaderChainSyncer')
self._db = db
self._checkpoint = checkpoint
self._enable_backfill = enable_backfill
self._chain = chain
self._peer_pool = peer_pool
if (checkpoint is None):
self._launch_strategy: SyncLaunchStrategyAPI = FromGenesisLaunchStrategy(db)
else:
self._launch_strategy = FromCheckpointLaunchStrategy(db, chain, checkpoint, peer_pool)
self._header_syncer = ETHHeaderChainSyncer(chain, db, peer_pool, self._launch_strategy)
async def run(self) -> None:
head = (await self._db.coro_get_canonical_head())
if (self._checkpoint is not None):
self.logger.info('Initializing header-sync; current head: %s, using checkpoint: %s', head, self._checkpoint)
else:
self.logger.info('Initializing header-sync; current head: %s', head)
try:
(await self._launch_strategy.fulfill_prerequisites())
except asyncio.TimeoutError as exc:
self.logger.exception(f'Timed out while trying to fulfill prerequisites of sync launch strategy: {exc} from {self._launch_strategy}')
self.manager.cancel()
return
if self._enable_backfill:
backfiller = SequentialHeaderChainGapSyncer(self._chain, self._db, self._peer_pool)
self.manager.run_child_service(backfiller)
self.manager.run_daemon_child_service(self._header_syncer)
self.manager.run_daemon_task(self._persist_headers)
(await self.manager.wait_finished())
async def _persist_headers(self) -> None:
async for persist_info in persist_headers(self.logger, self._db, self._header_syncer):
if len(persist_info.new_canon_headers):
head = persist_info.new_canon_headers[(- 1)]
else:
head = (await self._db.coro_get_canonical_head())
self.logger.info('Imported %d headers in %0.2f seconds, new head: %s', len(persist_info.imported_headers), persist_info.elapsed_time, head) |
class SimpleEditor(Editor):
scrollable = True
selection = Event()
selected = Any()
activated = Event()
click = Event()
dclick = Event()
veto = Event()
refresh = Event()
def init(self, parent):
factory = self.factory
self._editor = None
if factory.editable:
if factory.shared_editor:
factory_editor = factory.editor
if (factory_editor is None):
factory._editor = self
self.control = sa = QtGui.QScrollArea()
sa.setFrameShape(QtGui.QFrame.Shape.NoFrame)
sa.setWidgetResizable(True)
self.control._node_ui = self.control._editor_nid = None
editors = factory._shared_editors
if (editors is not None):
for editor in factory._shared_editors:
if (editor.ui is self.ui):
editor._editor = self.control
factory._shared_editors = None
return
editor = factory_editor._editor
if ((editor is None) or (editor.ui is not self.ui)):
shared_editors = factory_editor._shared_editors
if (shared_editors is None):
factory_editor._shared_editors = shared_editors = []
shared_editors.append(self)
else:
self._editor = editor.control
self.control = self._tree = _TreeWidget(self)
else:
self._tree = _TreeWidget(self)
self._editor = sa = QtGui.QScrollArea()
sa.setFrameShape(QtGui.QFrame.Shape.NoFrame)
sa.setWidgetResizable(True)
sa._node_ui = sa._editor_nid = None
if (factory.orientation == 'horizontal'):
orient = QtCore.Qt.Orientation.Horizontal
else:
orient = QtCore.Qt.Orientation.Vertical
self.control = splitter = QtGui.QSplitter(orient)
splitter.setSizePolicy(QtGui.QSizePolicy.Policy.Expanding, QtGui.QSizePolicy.Policy.Expanding)
splitter.addWidget(self._tree)
splitter.addWidget(sa)
else:
self.control = self._tree = _TreeWidget(self)
delegate = TreeItemDelegate()
delegate.editor = self
self._tree.setItemDelegate(delegate)
self._item_delegate = delegate
self._map = {}
self._undoable = []
self.sync_value(factory.refresh, 'refresh')
self.sync_value(factory.selected, 'selected')
self.sync_value(factory.activated, 'activated', 'to')
self.sync_value(factory.click, 'click', 'to')
self.sync_value(factory.dclick, 'dclick', 'to')
self.sync_value(factory.veto, 'veto', 'from')
def _selection_changed(self, selection):
try:
tree = self._tree
if ((not isinstance(selection, str)) and isinstance(selection, collections.abc.Iterable)):
item_selection = QtGui.QItemSelection()
for sel in selection:
item = self._object_info(sel)[2]
idx = tree.indexFromItem(item)
item_selection.append(QtGui.QItemSelectionRange(idx))
tree.selectionModel().select(item_selection, QtGui.QItemSelectionModel.SelectionFlag.ClearAndSelect)
else:
tree.setCurrentItem(self._object_info(selection)[2])
except:
from traitsui.api import raise_to_debug
raise_to_debug()
def _selected_changed(self, selected):
if (not self._no_update_selected):
self._selection_changed(selected)
def _veto_changed(self):
self._veto = True
def _refresh_changed(self):
self._tree.viewport().update()
def dispose(self):
if (self._tree is not None):
self._tree.blockSignals(True)
self._delete_node(self._tree.invisibleRootItem())
self._tree = None
super().dispose()
def expand_levels(self, nid, levels, expand=True):
if (levels > 0):
try:
(expanded, node, object) = self._get_node_data(nid)
except Exception:
return
if self._has_children(node, object):
self._expand_node(nid)
if expand:
nid.setExpanded(True)
for cnid in self._nodes_for(nid):
self.expand_levels(cnid, (levels - 1))
def expand_all(self):
iterator = QtGui.QTreeWidgetItemIterator(self._tree)
while iterator.value():
item = iterator.value()
try:
(expanded, node, object) = self._get_node_data(item)
except Exception:
continue
if self._has_children(node, object):
self._expand_node(item)
item.setExpanded(True)
iterator += 1
def update_editor(self):
tree = self._tree
if (tree is None):
return
saved_state = {}
(object, node) = self._node_for(self.old_value)
old_nid = self._get_object_nid(object, node.get_children_id(object))
if old_nid:
self._delete_node(old_nid)
(object, node) = self._node_for(self.old_value)
old_nid = self._get_object_nid(object, node.get_children_id(object))
if old_nid:
self._delete_node(old_nid)
tree.clear()
self._map = {}
(object, node) = self._node_for(self.value)
if (node is not None):
if self.factory.hide_root:
nid = tree.invisibleRootItem()
else:
nid = self._create_item(tree, node, object)
self._map[id(object)] = [(node.get_children_id(object), nid)]
self._add_listeners(node, object)
self._set_node_data(nid, (False, node, object))
if (self.factory.hide_root or self._has_children(node, object)):
self._expand_node(nid)
if (not self.factory.hide_root):
nid.setExpanded(True)
tree.setCurrentItem(nid)
self.expand_levels(nid, self.factory.auto_open, False)
ncolumns = self._tree.columnCount()
if (ncolumns > 1):
for i in range(ncolumns):
self._tree.resizeColumnToContents(i)
def get_error_control(self):
return self._tree
def _get_brush(self, color):
if isinstance(color, SequenceTypes):
q_color = QtGui.QColor(*color)
else:
q_color = QtGui.QColor(color)
return QtGui.QBrush(q_color)
def _set_column_labels(self, nid, node, object):
column_labels = node.get_column_labels(object)
for (i, (header, label)) in enumerate(zip_longest(self.factory.column_headers[1:], column_labels), 1):
renderer = node.get_renderer(object, i)
handles_text = (renderer.handles_text if renderer else False)
if ((header is None) or (label is None) or handles_text):
nid.setText(i, '')
else:
nid.setText(i, label)
def _create_item(self, nid, node, object, index=None):
if (index is None):
cnid = QtGui.QTreeWidgetItem(nid)
else:
cnid = QtGui.QTreeWidgetItem()
nid.insertChild(index, cnid)
renderer = node.get_renderer(object)
handles_text = getattr(renderer, 'handles_text', False)
handles_icon = getattr(renderer, 'handles_icon', False)
if (not (self.factory.word_wrap or handles_text)):
cnid.setText(0, node.get_label(object))
if (not handles_icon):
cnid.setIcon(0, self._get_icon(node, object))
cnid.setToolTip(0, node.get_tooltip(object))
self._set_column_labels(cnid, node, object)
color = node.get_background(object)
if color:
cnid.setBackground(0, self._get_brush(color))
color = node.get_foreground(object)
if color:
cnid.setForeground(0, self._get_brush(color))
return cnid
def _set_label(self, nid, col=0):
if (col != 0):
return
try:
(expanded, node, object) = self._get_node_data(nid)
except Exception:
return
renderer = node.get_renderer(object)
handles_text = getattr(renderer, 'handles_text', False)
if (self.factory.word_wrap or handles_text):
nid.setText(col, '')
else:
nid.setText(col, node.get_label(object))
def _append_node(self, nid, node, object):
return self._insert_node(nid, None, node, object)
def _insert_node(self, nid, index, node, object):
cnid = self._create_item(nid, node, object, index)
has_children = self._has_children(node, object)
self._set_node_data(cnid, (False, node, object))
self._map.setdefault(id(object), []).append((node.get_children_id(object), cnid))
self._add_listeners(node, object)
if has_children:
if node.can_auto_open(object):
cnid.setExpanded(True)
else:
cnid._dummy = QtGui.QTreeWidgetItem(cnid)
return cnid
def _delete_node(self, nid):
for cnid in self._nodes_for(nid):
self._delete_node(cnid)
pnid = nid.parent()
if ((pnid is not None) and (getattr(pnid, '_dummy', None) is nid)):
pnid.removeChild(nid)
del pnid._dummy
return
try:
(expanded, node, object) = self._get_node_data(nid)
except Exception:
pass
else:
id_object = id(object)
object_info = self._map[id_object]
for (i, info) in enumerate(object_info):
if (id(nid) == id(info[1])):
del object_info[i]
break
if (len(object_info) == 0):
self._remove_listeners(node, object)
del self._map[id_object]
if (pnid is None):
self._tree.takeTopLevelItem(self._tree.indexOfTopLevelItem(nid))
else:
pnid.removeChild(nid)
if ((self._editor is not None) and (id(nid) == id(self._editor._editor_nid))):
self._clear_editor()
def _expand_node(self, nid):
try:
(expanded, node, object) = self._get_node_data(nid)
except Exception:
return
if (not expanded):
dummy = getattr(nid, '_dummy', None)
if (dummy is not None):
nid.removeChild(dummy)
del nid._dummy
for child in node.get_children(object):
(child, child_node) = self._node_for(child)
if (child_node is not None):
self._append_node(nid, child_node, child)
self._set_node_data(nid, (True, node, object))
def _nodes_for(self, nid):
return [nid.child(i) for i in range(nid.childCount())]
def _node_index(self, nid):
pnid = nid.parent()
if (pnid is None):
if self.factory.hide_root:
pnid = self._tree.invisibleRootItem()
if (pnid is None):
return (None, None, None)
for i in range(pnid.childCount()):
if (pnid.child(i) is nid):
try:
(_, pnode, pobject) = self._get_node_data(pnid)
except Exception:
continue
return (pnode, pobject, i)
else:
return (None, None, None)
def _has_children(self, node, object):
return (node.allows_children(object) and node.has_children(object))
STD_ICON_MAP = {'<item>': QtGui.QStyle.StandardPixmap.SP_FileIcon, '<group>': QtGui.QStyle.StandardPixmap.SP_DirClosedIcon, '<open>': QtGui.QStyle.StandardPixmap.SP_DirOpenIcon}
def _get_icon(self, node, object, is_expanded=False):
if (not self.factory.show_icons):
return QtGui.QIcon()
icon_name = node.get_icon(object, is_expanded)
if isinstance(icon_name, str):
if icon_name.startswith(''):
image_resource = convert_image(icon_name, 4)
return image_resource.create_icon()
elif (icon_name in self.STD_ICON_MAP):
icon = self.STD_ICON_MAP[icon_name]
return self._tree.style().standardIcon(icon)
path = node.get_icon_path(object)
if isinstance(path, str):
path = [path, node]
else:
path = (path + [node])
image_resource = ImageResource(icon_name, path)
elif isinstance(icon_name, ImageResource):
image_resource = icon_name
elif isinstance(icon_name, tuple):
if (max(icon_name) <= 1.0):
color = QtGui.QColor.fromRgbF(*icon_name)
else:
color = QtGui.QColor.fromRgb(*icon_name)
return self._icon_from_color(color)
elif isinstance(icon_name, QtGui.QColor):
return self._icon_from_color(icon_name)
else:
raise ValueError((('Icon value must be a string or color or color tuple or ' + 'IImageResource instance: ') + 'given {!r}'.format(icon_name)))
file_name = image_resource.absolute_path
return QtGui.QIcon(pixmap_cache(file_name))
def _icon_from_color(self, color):
pixmap = QtGui.QPixmap(self._tree.iconSize())
pixmap.fill(color)
return QtGui.QIcon(pixmap)
def _add_listeners(self, node, object):
if node.allows_children(object):
node.when_children_replaced(object, self._children_replaced, False)
node.when_children_changed(object, self._children_updated, False)
node.when_label_changed(object, self._label_updated, False)
node.when_column_labels_change(object, self._column_labels_updated, False)
def _remove_listeners(self, node, object):
if node.allows_children(object):
node.when_children_replaced(object, self._children_replaced, True)
node.when_children_changed(object, self._children_updated, True)
node.when_label_changed(object, self._label_updated, True)
node.when_column_labels_change(object, self._column_labels_updated, True)
def _object_info(self, object, name=''):
info = self._map[id(object)]
for (name2, nid) in info:
if (name == name2):
break
else:
nid = info[0][1]
(expanded, node, ignore) = self._get_node_data(nid)
return (expanded, node, nid)
def _object_info_for(self, object, name=''):
result = []
for (name2, nid) in self._map[id(object)]:
if (name == name2):
try:
(expanded, node, object) = self._get_node_data(nid)
except Exception:
continue
result.append((expanded, node, nid))
return result
def _node_for(self, object):
if (isinstance(object, tuple) and (len(object) == 2) and isinstance(object[1], TreeNode)):
return object
factory = self.factory
nodes = [node for node in factory.nodes if node.is_node_for(object)]
if (len(nodes) == 1):
return (object, nodes[0])
if (len(nodes) == 0):
return (object, ITreeNodeAdapterBridge(adapter=object))
base = nodes[0].node_for
nodes = [node for node in nodes if (base == node.node_for)]
if (len(nodes) == 1):
return (object, nodes[0])
root_node = None
for (i, node) in enumerate(nodes):
if (node.children == ''):
root_node = node
del nodes[i]
break
else:
root_node = nodes[0]
key = ((root_node,) + tuple(nodes))
if (key in factory.multi_nodes):
return (object, factory.multi_nodes[key])
factory.multi_nodes[key] = multi_node = MultiTreeNode(root_node=root_node, nodes=nodes)
return (object, multi_node)
def _node_for_class(self, klass):
for node in self.factory.nodes:
if issubclass(klass, tuple(node.node_for)):
return node
return None
def _update_icon(self, nid):
try:
(expanded, node, object) = self._get_node_data(nid)
except Exception:
return
renderer = node.get_renderer(object)
if ((renderer is None) or (not renderer.handles_icon)):
nid.setIcon(0, self._get_icon(node, object, expanded))
else:
nid.setIcon(0, QtGui.QIcon())
def _begin_undo(self):
ui = self.ui
self._undoable.append(ui._undoable)
if ((ui._undoable == (- 1)) and (ui.history is not None)):
ui._undoable = ui.history.now
def _end_undo(self):
if (self._undoable.pop() == (- 1)):
self.ui._undoable = (- 1)
def _get_undo_item(self, object, name, event):
return ListUndoItem(object=object, name=name, index=event.index, added=event.added, removed=event.removed)
def _undoable_append(self, node, object, data, make_copy=True):
try:
self._begin_undo()
if make_copy:
data = copy.deepcopy(data)
node.append_child(object, data)
finally:
self._end_undo()
def _undoable_insert(self, node, object, index, data, make_copy=True):
try:
self._begin_undo()
if make_copy:
data = copy.deepcopy(data)
node.insert_child(object, index, data)
finally:
self._end_undo()
def _undoable_delete(self, node, object, index):
try:
self._begin_undo()
node.delete_child(object, index)
finally:
self._end_undo()
def _get_object_nid(self, object, name=''):
info = self._map.get(id(object))
if (info is None):
return None
for (name2, nid) in info:
if (name == name2):
return nid
else:
return info[0][1]
def _clear_editor(self):
editor = self._editor
if (editor._node_ui is not None):
editor.setWidget(None)
editor._node_ui.dispose()
editor._node_ui = editor._editor_nid = None
def _get_node_data(nid):
if (not qobject_is_valid(nid)):
raise RuntimeError(f'Qt object {nid} for node nolonger exists.')
return nid._py_data
def _set_node_data(nid, data):
nid._py_data = data
def get_object(self, nid):
return self._get_node_data(nid)[2]
def get_parent(self, object, name=''):
nid = self._get_object_nid(object, name)
if (nid is not None):
pnid = nid.parent()
if (pnid is not self._tree.invisibleRootItem()):
return self.get_object(pnid)
return None
def get_node(self, object, name=''):
nid = self._get_object_nid(object, name)
if (nid is not None):
return self._get_node_data(nid)[1]
return None
def _on_item_expanded(self, nid):
try:
(_, node, object) = self._get_node_data(nid)
except Exception:
return
if node.can_auto_close(object):
parent = nid.parent()
if (parent is not None):
for snid in self._nodes_for(parent):
if (snid is not nid):
snid.setExpanded(False)
self._expand_node(nid)
self._update_icon(nid)
def _on_item_collapsed(self, nid):
self._update_icon(nid)
def _on_item_clicked(self, nid, col):
try:
(_, node, object) = self._get_node_data(nid)
except Exception:
return
if ((node.click(object) is True) and (self.factory.on_click is not None)):
self.ui.evaluate(self.factory.on_click, object)
self.click = object
def _on_item_dclicked(self, nid, col):
try:
(_, node, object) = self._get_node_data(nid)
except Exception:
return
if (node.dclick(object) is True):
if (self.factory.on_dclick is not None):
self.ui.evaluate(self.factory.on_dclick, object)
self._veto = True
else:
self._veto = True
self.dclick = object
def _on_item_activated(self, nid, col):
try:
(_, node, object) = self._get_node_data(nid)
except Exception:
return
if (node.activated(object) is True):
if (self.factory.on_activated is not None):
self.ui.evaluate(self.factory.on_activated, object)
self._veto = True
else:
self._veto = True
self.activated = object
def _on_tree_sel_changed(self):
nids = self._tree.selectedItems()
selected = []
first = True
for nid in nids:
try:
node = self._get_node_data(nid)[2]
except Exception:
continue
selected.append(node)
for nid in nids:
try:
(expanded, sel_node, sel_object) = self._get_node_data(nid)
except Exception:
continue
if first:
node = sel_node
object = sel_object
not_handled = node.select(sel_object)
first = False
if (len(selected) == 0):
nid = None
object = None
not_handled = True
if (self.factory.selection_mode == 'single'):
self._no_update_selected = True
self.selected = object
self._no_update_selected = False
else:
self._no_update_selected = True
self.selected = selected
self._no_update_selected = False
if (not_handled is True):
self.ui.evaluate(self.factory.on_select, object)
editor = self._editor
if (editor is not None):
editor.setUpdatesEnabled(False)
self._clear_editor()
if (object is not None):
view = node.get_view(object)
if ((view is None) or isinstance(view, str)):
view = object.trait_view(view)
if ((self.ui.history is not None) or (view.kind == 'subpanel')):
ui = object.edit_traits(parent=editor, view=view, kind='subpanel')
else:
ui = object.edit_traits(parent=editor, view=view, kind='panel')
ui.parent = self.ui
editor._node_ui = ui
editor._editor_nid = nid
if (ui.control.layout() is not None):
ui.control.layout().setContentsMargins(0, 0, 0, 0)
editor.setWidget(ui.control)
editor.setUpdatesEnabled(True)
def _on_context_menu(self, pos):
nid = self._tree.itemAt(pos)
if (nid is None):
return
try:
(_, node, object) = self._get_node_data(nid)
except Exception:
return
self._data = (node, object, nid)
self._context = {'object': object, 'editor': self, 'node': node, 'info': self.ui.info, 'handler': self.ui.handler}
pnid = nid.parent()
if ((pnid is None) or (pnid is self._tree.invisibleRootItem())):
parent_node = parent_object = None
else:
(_, parent_node, parent_object) = self._get_node_data(pnid)
self._menu_node = node
self._menu_parent_node = parent_node
self._menu_parent_object = parent_object
menu = node.get_menu(object)
if (menu is None):
menu = self._standard_menu(node, object)
elif isinstance(menu, Menu):
group = menu.find_group(NewAction)
if (group is not None):
group.clear()
actions = self._new_actions(node, object)
if (len(actions) > 0):
group.insert(0, Menu(*actions, name='New'))
else:
menu = None
if (menu is not None):
qmenu = menu.create_menu(self._tree, self)
qmenu.exec_(self._tree.mapToGlobal(pos))
self._data = self._context = self._menu_node = self._menu_parent_node = self._menu_parent_object = None
def _standard_menu(self, node, object):
actions = [CutAction, CopyAction, PasteAction, Separator(), DeleteAction, Separator(), RenameAction]
items = self._new_actions(node, object)
if (len(items) > 0):
actions[0:0] = [Menu(*items, name='New'), Separator()]
return Menu(*actions)
def _new_actions(self, node, object):
object = self._data[1]
items = []
add = node.get_add(object)
if (len(add) == 0):
return items
for klass in add:
prompt = False
factory = None
if isinstance(klass, tuple):
if (len(klass) == 2):
(klass, prompt) = klass
elif (len(klass) == 3):
(klass, prompt, factory) = klass
add_node = self._node_for_class(klass)
if (add_node is None):
continue
class_name = klass.__name__
name = add_node.get_name(object)
if (name == ''):
name = class_name
if (factory is None):
factory = klass
def perform_add(object, factory, prompt):
self._menu_new_node(factory, prompt)
on_perform = partial(perform_add, factory=factory, prompt=prompt)
items.append(Action(name=name, on_perform=on_perform))
return items
def _is_copyable(self, object):
parent = self._menu_parent_node
if isinstance(parent, ObjectTreeNode):
return parent.can_copy(self._menu_parent_object)
return ((parent is not None) and parent.can_copy(object))
def _is_cutable(self, object):
parent = self._menu_parent_node
if isinstance(parent, ObjectTreeNode):
can_cut = (parent.can_copy(self._menu_parent_object) and parent.can_delete(self._menu_parent_object))
else:
can_cut = ((parent is not None) and parent.can_copy(object) and parent.can_delete(object))
return (can_cut and self._menu_node.can_delete_me(object))
def _is_pasteable(self, object):
return self._menu_node.can_add(object, clipboard.instance_type)
def _is_deletable(self, object):
parent = self._menu_parent_node
if isinstance(parent, ObjectTreeNode):
can_delete = parent.can_delete(self._menu_parent_object)
else:
can_delete = ((parent is not None) and parent.can_delete(object))
return (can_delete and self._menu_node.can_delete_me(object))
def _is_renameable(self, object):
parent = self._menu_parent_node
if isinstance(parent, ObjectTreeNode):
can_rename = parent.can_rename(self._menu_parent_object)
else:
can_rename = ((parent is not None) and parent.can_rename(object))
can_rename = (can_rename and self._menu_node.can_rename_me(object))
nid = self._get_object_nid(object)
flags = nid.flags()
if can_rename:
flags |= QtCore.Qt.ItemFlag.ItemIsEditable
else:
flags &= (~ QtCore.Qt.ItemFlag.ItemIsEditable)
nid.setFlags(flags)
return can_rename
def _is_droppable(self, node, object, add_object, for_insert):
if (for_insert and (not node.can_insert(object))):
return False
return node.can_add(object, add_object)
def _drop_object(self, node, object, dropped_object, make_copy=True):
new_object = node.drop_object(object, dropped_object)
if ((new_object is not dropped_object) or (not make_copy)):
return new_object
return copy.deepcopy(new_object)
def add_to_menu(self, menu_item):
action = menu_item.item.action
self.eval_when(action.enabled_when, menu_item, 'enabled')
self.eval_when(action.checked_when, menu_item, 'checked')
def add_to_toolbar(self, toolbar_item):
self.add_to_menu(toolbar_item)
def can_add_to_menu(self, action):
if (action.defined_when != ''):
if (not eval(action.defined_when, globals(), self._context)):
return False
if (action.visible_when != ''):
if (not eval(action.visible_when, globals(), self._context)):
return False
return True
def can_add_to_toolbar(self, action):
return self.can_add_to_menu(action)
def perform(self, action, action_event=None):
self.ui.do_undoable(self._perform, action)
def _perform(self, action):
(node, object, nid) = self._data
method_name = action.action
info = self.ui.info
handler = self.ui.handler
if (method_name.find('.') >= 0):
if (method_name.find('(') < 0):
method_name += '()'
try:
eval(method_name, globals(), {'object': object, 'editor': self, 'node': node, 'info': info, 'handler': handler})
except Exception:
from traitsui.api import raise_to_debug
raise_to_debug()
return
method = getattr(handler, method_name, None)
if (method is not None):
method(info, object)
return
if (action.on_perform is not None):
action.on_perform(object)
def eval_when(self, condition, object, trait):
if (condition != ''):
value = True
try:
if (not eval(condition, globals(), self._context)):
value = False
except Exception as e:
logger.warning(('Exception (%s) raised when evaluating the condition %s. Returning True.' % (e, condition)))
setattr(object, trait, value)
def _menu_copy_node(self):
clipboard.instance = self._data[1]
self._data = None
def _menu_cut_node(self):
(node, object, nid) = self._data
clipboard.instance = object
self._data = None
self._undoable_delete(*self._node_index(nid))
def _menu_paste_node(self):
(node, object, nid) = self._data
self._data = None
self._undoable_append(node, object, clipboard.instance, True)
def _menu_delete_node(self):
(node, object, nid) = self._data
self._data = None
rc = node.confirm_delete(object)
if (rc is not False):
if (rc is not True):
if (self.ui.history is None):
butn = QtGui.QMessageBox.question(self._tree, 'Confirm Deletion', ('Are you sure you want to delete %s?' % node.get_label(object)), (QtGui.QMessageBox.StandardButton.Yes | QtGui.QMessageBox.StandardButton.No))
if (butn != QtGui.QMessageBox.StandardButton.Yes):
return
self._undoable_delete(*self._node_index(nid))
def _menu_rename_node(self):
(_, _, nid) = self._data
self._data = None
self._tree.editItem(nid)
def _on_nid_changed(self, nid, col):
try:
(_, node, object) = self._get_node_data(nid)
except Exception:
return
new_label = str(nid.text(col))
old_label = node.get_label(object)
if (new_label != old_label):
if (new_label != ''):
node.set_label(object, new_label)
else:
self._set_label(nid, col)
def _menu_new_node(self, factory, prompt=False):
(node, object, nid) = self._data
self._data = None
new_object = factory()
if (new_object is None):
return
if ((not prompt) or new_object.edit_traits(parent=self.control, kind='livemodal').result):
self._undoable_append(node, object, new_object, False)
if self.factory.editable:
self._tree.setCurrentItem(nid.child((nid.childCount() - 1)))
def _children_replaced(self, object, name='', new=None):
tree = self._tree
for (expanded, node, nid) in self._object_info_for(object, name):
children = node.get_children(object)
if expanded:
for cnid in self._nodes_for(nid):
self._delete_node(cnid)
for child in children:
(child, child_node) = self._node_for(child)
if (child_node is not None):
self._append_node(nid, child_node, child)
else:
dummy = getattr(nid, '_dummy', None)
if ((dummy is None) and (len(children) > 0)):
nid._dummy = QtGui.QTreeWidgetItem(nid)
elif ((dummy is not None) and (len(children) == 0)):
nid.removeChild(dummy)
del nid._dummy
if node.can_auto_open(object):
nid.setExpanded(True)
def _children_updated(self, object, name, event):
name = name[:(- 6)]
self.log_change(self._get_undo_item, object, name, event)
start = event.index
n = len(event.added)
end = (start + len(event.removed))
tree = self._tree
for (expanded, node, nid) in self._object_info_for(object, name):
children = node.get_children(object)
if expanded:
for cnid in self._nodes_for(nid)[start:end]:
self._delete_node(cnid)
remaining = (len(children) - len(event.removed))
child_index = 0
for child in event.added:
(child, child_node) = self._node_for(child)
if (child_node is not None):
insert_index = ((start + child_index) if (start <= remaining) else None)
self._insert_node(nid, insert_index, child_node, child)
child_index += 1
else:
dummy = getattr(nid, '_dummy', None)
if ((dummy is None) and (len(children) > 0)):
nid._dummy = QtGui.QTreeWidgetItem(nid)
elif ((dummy is not None) and (len(children) == 0)):
nid.removeChild(dummy)
del nid._dummy
if node.can_auto_open(object):
nid.setExpanded(True)
def _label_updated(self, object, name, label):
blk = self._tree.blockSignals(True)
try:
nids = []
for (name2, nid) in self._map[id(object)]:
if (nid not in nids):
try:
node = self._get_node_data(nid)[1]
except Exception:
continue
nids.append(nid)
self._set_label(nid, 0)
self._update_icon(nid)
finally:
self._tree.blockSignals(blk)
def _column_labels_updated(self, object, name, new):
blk = self._tree.blockSignals(True)
try:
nids = []
for (name2, nid) in self._map[id(object)]:
if (nid not in nids):
try:
node = self._get_node_data(nid)[1]
except Exception:
continue
nids.append(nid)
self._set_column_labels(nid, node, object)
finally:
self._tree.blockSignals(blk)
def restore_prefs(self, prefs):
if isinstance(self.control, QtGui.QSplitter):
if isinstance(prefs, dict):
structure = prefs.get('structure')
else:
structure = prefs
self.control.restoreState(structure)
header = self._tree.header()
self.control.setExpandsOnDoubleClick(self.factory.expands_on_dclick)
if ((header is not None) and ('column_state' in prefs)):
header.restoreState(prefs['column_state'])
def save_prefs(self):
prefs = {}
if isinstance(self.control, QtGui.QSplitter):
prefs['structure'] = self.control.saveState().data()
header = self._tree.header()
if (header is not None):
prefs['column_state'] = header.saveState().data()
return prefs |
class LeadGenLegalContentCheckbox(AbstractCrudObject):
def __init__(self, fbid=None, parent_id=None, api=None):
self._isLeadGenLegalContentCheckbox = True
super(LeadGenLegalContentCheckbox, self).__init__(fbid, parent_id, api)
class Field(AbstractObject.Field):
id = 'id'
is_checked_by_default = 'is_checked_by_default'
is_required = 'is_required'
key = 'key'
text = 'text'
_field_types = {'id': 'string', 'is_checked_by_default': 'bool', 'is_required': 'bool', 'key': 'string', 'text': 'string'}
def _get_field_enum_info(cls):
field_enum_info = {}
return field_enum_info |
class OptionPlotoptionsNetworkgraphEvents(Options):
def afterAnimate(self):
return self._config_get(None)
def afterAnimate(self, value: Any):
self._config(value, js_type=False)
def checkboxClick(self):
return self._config_get(None)
def checkboxClick(self, value: Any):
self._config(value, js_type=False)
def click(self):
return self._config_get(None)
def click(self, value: Any):
self._config(value, js_type=False)
def hide(self):
return self._config_get(None)
def hide(self, value: Any):
self._config(value, js_type=False)
def legendItemClick(self):
return self._config_get(None)
def legendItemClick(self, value: Any):
self._config(value, js_type=False)
def mouseOut(self):
return self._config_get(None)
def mouseOut(self, value: Any):
self._config(value, js_type=False)
def mouseOver(self):
return self._config_get(None)
def mouseOver(self, value: Any):
self._config(value, js_type=False)
def show(self):
return self._config_get(None)
def show(self, value: Any):
self._config(value, js_type=False) |
class TransportT(abc.ABC):
Consumer: ClassVar[Type[ConsumerT]]
Producer: ClassVar[Type[ProducerT]]
TransactionManager: ClassVar[Type[TransactionManagerT]]
Conductor: ClassVar[Type[ConductorT]]
Fetcher: ClassVar[Type[ServiceT]]
app: _AppT
url: List[URL]
driver_version: str
loop: asyncio.AbstractEventLoop
def __init__(self, url: List[URL], app: _AppT, loop: Optional[asyncio.AbstractEventLoop]=None) -> None:
...
def create_consumer(self, callback: ConsumerCallback, **kwargs: Any) -> ConsumerT:
...
def create_producer(self, **kwargs: Any) -> ProducerT:
...
def create_conductor(self, **kwargs: Any) -> ConductorT:
... |
def _run_ragout(args):
if (not os.path.isdir(args.out_dir)):
os.mkdir(args.out_dir)
debug_root = os.path.join(args.out_dir, 'debug')
debugger.set_debugging(args.debug)
debugger.set_debug_dir(debug_root)
debugger.clear_debug_dir()
out_log = os.path.join(args.out_dir, 'ragout.log')
_enable_logging(out_log, args.debug)
logger.info('Starting Ragout v%s', str(__version__))
_check_extern_modules(args.synteny_backend)
synteny_backend = SyntenyBackend.get_available_backends()[args.synteny_backend]
recipe = parse_ragout_recipe(args.recipe)
synteny_sizes = _get_synteny_scale(recipe, synteny_backend)
perm_files = synteny_backend.make_permutations(recipe, synteny_sizes, args.out_dir, args.overwrite, args.threads)
phylo_perm_file = perm_files[synteny_sizes[ID_SMALLEST]]
(phylogeny, naming_ref) = _get_phylogeny_and_naming_ref(recipe, phylo_perm_file)
logger.info('Processing permutation files')
raw_bp_graphs = {}
stage_perms = {}
run_stages = _make_run_stages(synteny_sizes, args.resolve_repeats)
for stage in run_stages:
debugger.set_debug_dir(os.path.join(debug_root, stage.name))
stage_perms[stage] = PermutationContainer(perm_files[stage.block_size], recipe, stage.repeats, stage.ref_indels, phylogeny)
raw_bp_graphs[stage] = BreakpointGraph(stage_perms[stage])
target_sequences = read_fasta_dict(synteny_backend.get_target_fasta())
chim_detect = None
if (not args.solid_scaffolds):
chim_detect = ChimeraDetector(raw_bp_graphs, run_stages, target_sequences)
scaffolds = None
prev_stages = []
for stage in run_stages:
logger.info('Stage "%s"', stage.name)
debugger.set_debug_dir(os.path.join(debug_root, stage.name))
prev_stages.append(stage)
broken_perms = stage_perms[stage]
if (not args.solid_scaffolds):
broken_perms = chim_detect.break_contigs(stage_perms[stage], [stage])
breakpoint_graph = BreakpointGraph(broken_perms)
adj_inferer = AdjacencyInferer(breakpoint_graph, phylogeny)
adjacencies = adj_inferer.infer_adjacencies()
cur_scaffolds = scfldr.build_scaffolds(adjacencies, broken_perms, debug_output=True, correct_distances=False)
if (scaffolds is not None):
if (not args.solid_scaffolds):
broken_perms = chim_detect.break_contigs(stage_perms[stage], prev_stages)
cur_scaffolds = merge.merge_scaffolds(scaffolds, cur_scaffolds, broken_perms, stage.rearrange)
merge.get_breakpoints(cur_scaffolds, breakpoint_graph, broken_perms)
scaffolds = cur_scaffolds
debugger.set_debug_dir(debug_root)
last_stage = run_stages[ID_SMALLEST]
scfldr.assign_scaffold_names(scaffolds, stage_perms[last_stage], naming_ref)
scfldr.update_gaps(scaffolds)
if args.refine:
out_overlap = os.path.join(args.out_dir, 'contigs_overlap.dot')
overlap.make_overlap_graph(synteny_backend.get_target_fasta(), out_overlap)
scaffolds = asref.refine_scaffolds(out_overlap, scaffolds, target_sequences)
if args.debug:
shutil.copy(out_overlap, debugger.debug_dir)
os.remove(out_overlap)
out_gen = OutputGenerator(target_sequences, scaffolds)
out_gen.make_output(args.out_dir, recipe['target'])
logger.info('Done!') |
class Rule_Line_Trailing_Whitesapce(Style_Rule_Line):
def __init__(self):
super().__init__('trailing_whitespace', True)
self.mandatory = True
def apply(self, mh, cfg, filename, line_no, line):
if line.endswith(' '):
if (len(line.strip()) == 0):
mh.style_issue(Location(filename, line_no), 'whitespace on blank line', None, self.autofix)
else:
mh.style_issue(Location(filename, line_no, len(line.rstrip()), len(line), line), 'trailing whitespace', None, self.autofix) |
def start_ddp_workers(main, argv, num_workers: tp.Optional[int]=None):
import torch as th
world_size = (num_workers or th.cuda.device_count())
if (not world_size):
fatal('DDP is only available on GPU. Make sure GPUs are properly configured with cuda.')
sys.exit(1)
xp = main.get_xp(argv)
xp.folder.mkdir(exist_ok=True, parents=True)
if xp.rendezvous_file.exists():
xp.rendezvous_file.unlink()
log(f'Starting {world_size} worker processes for DDP.')
with ChildrenManager() as manager:
for rank in range(world_size):
kwargs: tp.Dict[(str, tp.Any)] = {}
env = dict(os.environ)
env['RANK'] = str(rank)
env['LOCAL_RANK'] = str(rank)
env['WORLD_SIZE'] = str(world_size)
env['MASTER_ADDR'] = '127.0.0.1'
args = ['-m', 'dora', '-P', main.package, '--main_module', main.main_module, 'run', '--']
args += argv
if (rank > 0):
kwargs['stdin'] = sp.DEVNULL
kwargs['stdout'] = open((xp.folder / f'worker_{rank}.log'), 'w')
kwargs['stderr'] = sp.STDOUT
manager.add(sp.Popen(([sys.executable] + args), env=env, **kwargs))
sys.exit(int(manager.failed)) |
class Solution2():
def kthSmallest(self, root: TreeNode, k: int) -> int:
def inorder(node):
if (node is None):
return
(yield from inorder(node.left))
(yield node.val)
(yield from inorder(node.right))
for (i, val) in enumerate(inorder(root)):
if (i == (k - 1)):
return val
return None |
def get_value_from_field_indentifier(field: BadgeFieldForms, ticket_holder: TicketHolder):
snake_case_field_identifier = to_snake_case(field.field_identifier)
try:
field.sample_text = getattr(ticket_holder, snake_case_field_identifier)
except AttributeError:
try:
field.sample_text = ticket_holder.complex_field_values[field.field_identifier]
except (AttributeError, KeyError):
print(snake_case_field_identifier) |
class flow_monitor_request(stats_request):
version = 6
type = 18
stats_type = 16
def __init__(self, xid=None, flags=None, entries=None):
if (xid != None):
self.xid = xid
else:
self.xid = None
if (flags != None):
self.flags = flags
else:
self.flags = 0
if (entries != None):
self.entries = entries
else:
self.entries = []
return
def pack(self):
packed = []
packed.append(struct.pack('!B', self.version))
packed.append(struct.pack('!B', self.type))
packed.append(struct.pack('!H', 0))
packed.append(struct.pack('!L', self.xid))
packed.append(struct.pack('!H', self.stats_type))
packed.append(struct.pack('!H', self.flags))
packed.append(('\x00' * 4))
packed.append(loxi.generic_util.pack_list(self.entries))
length = sum([len(x) for x in packed])
packed[2] = struct.pack('!H', length)
return ''.join(packed)
def unpack(reader):
obj = flow_monitor_request()
_version = reader.read('!B')[0]
assert (_version == 6)
_type = reader.read('!B')[0]
assert (_type == 18)
_length = reader.read('!H')[0]
orig_reader = reader
reader = orig_reader.slice(_length, 4)
obj.xid = reader.read('!L')[0]
_stats_type = reader.read('!H')[0]
assert (_stats_type == 16)
obj.flags = reader.read('!H')[0]
reader.skip(4)
obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_monitor_entry.unpack)
return obj
def __eq__(self, other):
if (type(self) != type(other)):
return False
if (self.xid != other.xid):
return False
if (self.flags != other.flags):
return False
if (self.entries != other.entries):
return False
return True
def pretty_print(self, q):
q.text('flow_monitor_request {')
with q.group():
with q.indent(2):
q.breakable()
q.text('xid = ')
if (self.xid != None):
q.text(('%#x' % self.xid))
else:
q.text('None')
q.text(',')
q.breakable()
q.text('flags = ')
value_name_map = {1: 'OFPSF_REQ_MORE'}
q.text(util.pretty_flags(self.flags, value_name_map.values()))
q.text(',')
q.breakable()
q.text('entries = ')
q.pp(self.entries)
q.breakable()
q.text('}') |
def prepare_env(binary=None):
import os
base_path = (Path(__file__).parent / 'staticanalysis/libfunctors/')
def check_for_libfunctors():
libfunctors = (base_path / 'libfunctors.so')
compile_script = './compile_functors.sh'
if libfunctors.is_file():
return
print('libfunctors.so not compiled. Compiling it now...')
os.system((((('cd ' + base_path.absolute().as_posix()) + ' && ') + compile_script) + '&& cd - > /dev/null'))
def check_LD_LIBRARY_PATH():
if ('LD_LIBRARY_PATH' in os.environ):
return
print('Environment variable LD_LIBRARY_PATH not set. Setting it up...')
os.environ['LD_LIBRARY_PATH'] = base_path.absolute().as_posix()
def define_SOLC_BINARY(binary=None):
if (binary is None):
return
print('Setting SOLC_BINARY to {}...'.format(binary))
os.environ['SOLC_BINARY'] = binary
check_for_libfunctors()
check_LD_LIBRARY_PATH()
define_SOLC_BINARY(binary)
return |
class JsHtmlButtonChecks(JsHtml):
def val(self):
return ''
def content(self):
return ''
def disable(self):
return JsObjects.JsObjects.get('\n ')
def add(self, data: Union[(str, primitives.JsDataModel, float, dict, list)], is_unique: bool=True, css_style: Optional[dict]=None, position: str='bottom'):
css_style = (css_style or {'margin': 0, 'display': 'block', 'position': 'relative', 'cursor': 'pointer'})
is_unique = JsUtils.jsConvertData(is_unique, None)
data = JsUtils.jsConvertData(data, None)
css_style = JsUtils.jsConvertData(css_style, None)
return JsObjects.JsObjects.get(('\nvar existingCols = {}; var options = %(options)s;\nif (%(unique)s){%(jqId)s.find(\'span\').each(function(){\n var pItem = $(this); existingCols[pItem.data(\'content\')] = true})};\n%(jsData)s.forEach(function(rec){\n if ((!%(unique)s) || (%(unique)s && (!(rec.value in existingCols))) ){\n var style = %(styls)s;\n var strCss = []; for (key in style) {strCss.push(key + ":" + style[key])}; checkData = \' \';\n if (rec.color != undefined){style.color = rec.color};\n if (rec.name == undefined) {rec.name = rec.value};\n if (rec.checked){var checkData = \'<i class="\'+ options.icon + \'" style="margin:2px"></i>\'};\n var spanContent = \'<span data-content="\'+ rec.value + \'" style="width:16px;display:inline-block;float:left;margin:0">\'+ checkData +\'</span><p style="margin:0" title="\'+ rec.dsc + \'">\' + rec.name + \'</p>\';\n %(jqId)s.append($(\'<label style="\' + strCss.join(";") + \'">\'+ spanContent +\'</label>\'))}\n}) ' % {'styls': css_style, 'options': {}, 'jqId': self.jquery.varId, 'unique': is_unique, 'jsData': data}))
def empty(self):
return ('%s.empty()' % self.jquery.varId)
def delete(self, data: types.JS_DATA_TYPES, data_ref: str='compData'):
data = JsUtils.jsConvertData(data, None)
return JsObjects.JsObjects.get(("\nvar %(dataRef)s = %(jsData)s;\nif (%(dataRef)s === true) {%(jqId)s.empty()}\nelse {%(jqId)s.find('span').each(function(){\n if (%(dataRef)s.indexOf($(this).data('content')) > -1){$(this).parent().remove()}\n})}" % {'jsData': data, 'jqId': self.jquery.varId, 'dataRef': data_ref}))
def check(self, data: types.JS_DATA_TYPES, data_ref: str='compData'):
data = JsUtils.jsConvertData(data, None)
return JsObjects.JsObjects.get(('\nvar %(dataRef)s = %(jsData)s;\n%(jqId)s.find(\'span\').each(function(){\n var itemCode = $(this).data(\'content\');\n if(typeof %(dataRef)s === "boolean"){\n if (%(dataRef)s === true && $(this).find("i").attr("class") === undefined){$(this).trigger("click")}\n if (!%(dataRef)s && $(this).find("i").attr("class") !== undefined){$(this).trigger("click")}}\n else if (%(dataRef)s.indexOf(itemCode) > -1){if ($(this).find("i").attr("class") === undefined){$(this).trigger("click")}}\n})' % {'jsData': data, 'jqId': self.jquery.varId, 'dataRef': data_ref}))
def current(self):
return JsObjects.JsVoid("$(this).find('p').text()")
def css_label(self, data: types.JS_DATA_TYPES, attrs: dict, data_ref: str='compData'):
data = JsUtils.jsConvertData(data, None)
attrs = JsUtils.jsConvertData(attrs, None)
return JsObjects.JsObjects.get(('\n var %(dataRef)s = %(jsData)s; var compAttrs = %(attrs)s;\n %(jqId)s.find(\'span\').each(function(){\n var itemCode = $(this).data(\'content\');\n if (%(dataRef)s.indexOf(itemCode) > -1){$(this).parent().find("p").css(compAttrs)}\n }) ' % {'jsData': data, 'jqId': self.jquery.varId, 'attrs': attrs, 'dataRef': data_ref})) |
class FloatNeighborhoodOutputChecker(doctest.OutputChecker):
posnum = '(?:[0-9]+[.][0-9]*|[.][0-9]+|[0-9]+)(?:e[+-]?[0-9]+)?'
re_spread = re.compile('\\b((?:-?{posnum}|array[(][^()]*[)]){posnum})\\b'.format(posnum=posnum))
def check_output(self, want, got, optionflags):
if (want == got):
return True
elif (('' in want) and self._check_plus_minus(want, got, optionflags)):
return True
return super().check_output(want, got, optionflags)
def _check_plus_minus(cls, want, got, optionflags):
if (optionflags & doctest.NORMALIZE_WHITESPACE):
want = re.sub('\\s+', ' ', want, flags=re.MULTILINE)
got = re.sub('\\s+', ' ', got, flags=re.MULTILINE)
for (i, part) in enumerate(cls.re_spread.split(want)):
if ((i % 2) == 0):
if (got[:len(part)] != part):
return False
got = got[len(part):]
elif part.startswith('array('):
match = re.search('^array[(]([^()]*)[)]'.format(posnum=cls.posnum), got)
if (not match):
return False
(got, got_array) = (got[len(match.group(0)):], cls._parse_array(match.group(1)))
(want_array, want_spread) = part.split('')
want_array = cls._parse_array(want_array[6:(- 1)])
if (want_array.shape != got_array.shape):
return False
if (numpy.isnan(want_array) != numpy.isnan(got_array)).any():
return False
mask = numpy.isnan(want_array)
if numpy.greater(abs((want_array - got_array))[(~ mask)], float(want_spread)).any():
return False
else:
match = re.search('^(-?{posnum})\\b'.format(posnum=cls.posnum), got)
if (not match):
return False
(got, got_number) = (got[len(match.group(0)):], float(match.group(1)))
(want_number, want_spread) = map(float, part.split(''))
if (not (abs((got_number - want_number)) <= want_spread)):
return False
return True
def _parse_array(cls, s):
return numpy.array(cls._parse_array_tokens(filter(None, re.split('\\s*([\\[\\],])\\s*', s, flags=re.MULTILINE))), dtype=float)
def _parse_array_tokens(cls, tokens):
token = next(tokens)
if (token == '['):
data = [cls._parse_array_tokens(tokens)]
for token in tokens:
if (token == ','):
data.append(cls._parse_array_tokens(tokens))
elif (token == ']'):
return data
else:
raise ValueError('unexpected token: {}'.format(token))
else:
return float(token) |
def lazy_import():
from fastly.model.pagination import Pagination
from fastly.model.pagination_links import PaginationLinks
from fastly.model.pagination_meta import PaginationMeta
from fastly.model.service_authorization_response_data import ServiceAuthorizationResponseData
from fastly.model.service_authorizations_response_all_of import ServiceAuthorizationsResponseAllOf
globals()['Pagination'] = Pagination
globals()['PaginationLinks'] = PaginationLinks
globals()['PaginationMeta'] = PaginationMeta
globals()['ServiceAuthorizationResponseData'] = ServiceAuthorizationResponseData
globals()['ServiceAuthorizationsResponseAllOf'] = ServiceAuthorizationsResponseAllOf |
def extractElliPhantomhive(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
if ('WATTT' in item['tags']):
return buildReleaseMessageWithType(item, 'WATTT', vol, chp, frag=frag, postfix=postfix)
return False |
class GlyphCoordinates(object):
def __init__(self, iterable=[]):
self._a = array.array('d')
self.extend(iterable)
def array(self):
return self._a
def zeros(count):
g = GlyphCoordinates()
g._a.frombytes(bytes(((count * 2) * g._a.itemsize)))
return g
def copy(self):
c = GlyphCoordinates()
c._a.extend(self._a)
return c
def __len__(self):
return (len(self._a) // 2)
def __getitem__(self, k):
a = self._a
if isinstance(k, slice):
indices = range(*k.indices(len(self)))
ret = []
for k in indices:
x = a[(2 * k)]
y = a[((2 * k) + 1)]
ret.append(((int(x) if x.is_integer() else x), (int(y) if y.is_integer() else y)))
return ret
x = a[(2 * k)]
y = a[((2 * k) + 1)]
return ((int(x) if x.is_integer() else x), (int(y) if y.is_integer() else y))
def __setitem__(self, k, v):
if isinstance(k, slice):
indices = range(*k.indices(len(self)))
for (j, i) in enumerate(indices):
self[i] = v[j]
return
(self._a[(2 * k)], self._a[((2 * k) + 1)]) = v
def __delitem__(self, i):
i = ((2 * i) % len(self._a))
del self._a[i]
del self._a[i]
def __repr__(self):
return (('GlyphCoordinates([' + ','.join((str(c) for c in self))) + '])')
def append(self, p):
self._a.extend(tuple(p))
def extend(self, iterable):
for p in iterable:
self._a.extend(p)
def toInt(self, *, round=otRound):
if (round is noRound):
return
a = self._a
for i in range(len(a)):
a[i] = round(a[i])
def calcBounds(self):
a = self._a
if (not a):
return (0, 0, 0, 0)
xs = a[0::2]
ys = a[1::2]
return (min(xs), min(ys), max(xs), max(ys))
def calcIntBounds(self, round=otRound):
return tuple((round(v) for v in self.calcBounds()))
def relativeToAbsolute(self):
a = self._a
(x, y) = (0, 0)
for i in range(0, len(a), 2):
a[i] = x = (a[i] + x)
a[(i + 1)] = y = (a[(i + 1)] + y)
def absoluteToRelative(self):
a = self._a
(x, y) = (0, 0)
for i in range(0, len(a), 2):
nx = a[i]
ny = a[(i + 1)]
a[i] = (nx - x)
a[(i + 1)] = (ny - y)
x = nx
y = ny
def translate(self, p):
(x, y) = p
if ((x == 0) and (y == 0)):
return
a = self._a
for i in range(0, len(a), 2):
a[i] += x
a[(i + 1)] += y
def scale(self, p):
(x, y) = p
if ((x == 1) and (y == 1)):
return
a = self._a
for i in range(0, len(a), 2):
a[i] *= x
a[(i + 1)] *= y
def transform(self, t):
a = self._a
for i in range(0, len(a), 2):
x = a[i]
y = a[(i + 1)]
px = ((x * t[0][0]) + (y * t[1][0]))
py = ((x * t[0][1]) + (y * t[1][1]))
a[i] = px
a[(i + 1)] = py
def __eq__(self, other):
if (type(self) != type(other)):
return NotImplemented
return (self._a == other._a)
def __ne__(self, other):
result = self.__eq__(other)
return (result if (result is NotImplemented) else (not result))
def __pos__(self):
return self.copy()
def __neg__(self):
r = self.copy()
a = r._a
for i in range(len(a)):
a[i] = (- a[i])
return r
def __round__(self, *, round=otRound):
r = self.copy()
r.toInt(round=round)
return r
def __add__(self, other):
return self.copy().__iadd__(other)
def __sub__(self, other):
return self.copy().__isub__(other)
def __mul__(self, other):
return self.copy().__imul__(other)
def __truediv__(self, other):
return self.copy().__itruediv__(other)
__radd__ = __add__
__rmul__ = __mul__
def __rsub__(self, other):
return (other + (- self))
def __iadd__(self, other):
if isinstance(other, tuple):
assert (len(other) == 2)
self.translate(other)
return self
if isinstance(other, GlyphCoordinates):
other = other._a
a = self._a
assert (len(a) == len(other))
for i in range(len(a)):
a[i] += other[i]
return self
return NotImplemented
def __isub__(self, other):
if isinstance(other, tuple):
assert (len(other) == 2)
self.translate(((- other[0]), (- other[1])))
return self
if isinstance(other, GlyphCoordinates):
other = other._a
a = self._a
assert (len(a) == len(other))
for i in range(len(a)):
a[i] -= other[i]
return self
return NotImplemented
def __imul__(self, other):
if isinstance(other, tuple):
assert (len(other) == 2)
self.scale(other)
return self
if isinstance(other, Number):
if (other == 1):
return self
a = self._a
for i in range(len(a)):
a[i] *= other
return self
return NotImplemented
def __itruediv__(self, other):
if isinstance(other, Number):
other = (other, other)
if isinstance(other, tuple):
if (other == (1, 1)):
return self
assert (len(other) == 2)
self.scale(((1.0 / other[0]), (1.0 / other[1])))
return self
return NotImplemented
def __bool__(self):
return bool(self._a)
__nonzero__ = __bool__ |
class ValidatePkpTestCase(TestCase):
def test__validate_pkp_positive(self):
private_key_paths = mock.Mock()
private_key_paths.read_all = mock.Mock(return_value=[])
_validate_pkp(private_key_paths)
private_key_paths.read_all.assert_called_once()
def test__validate_pkp_negative(self):
private_key_paths = mock.Mock()
private_key_paths.read_all = mock.Mock(return_value=[1, 2])
with self.assertRaises(ClickException):
_validate_pkp(private_key_paths)
private_key_paths.read_all.assert_called_once() |
def interrupt_thread(thread, exctype=OSError):
if (not CPYTHON):
return False
if ((thread is None) or (not thread.is_alive())):
return True
import ctypes
tid = ctypes.c_long(thread.ident)
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
if (res == 0):
return False
elif (res == 1):
return True
else:
ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
return False |
def verify_link(link):
global main_domain
global host_name
global url_scheme
global link_full_path
global emails
global debug
global verbose
global splitters
try:
if debug:
print('\t\t\t\t\t> Entering to verify_link function')
for i in splitters:
try:
link.split(i)[1]
link = link.split(i)[0]
if (debug and verbose):
print("\t\t\t\t> Link has a '{0}' reference. It has been removed.".format(i))
if (link == ''):
return (- 1)
break
except:
pass
try:
email = link.split('mailto:')[1]
if (debug and verbose):
print('\t\t\t\t\t> Link have a "mailto:" reference. Email: {0}'.format(email))
if (email.find(main_domain) != (- 1)):
try:
email.split('?')[1]
email = email.split('?')[0]
except:
pass
if (email not in emails):
emails.append(email)
if (verbose and debug):
print('\n\t\t\t\t- Email found: {0}'.format(email), end=' ')
link = link.split('mailto:')[0]
except:
pass
link_parsed = urllib.parse.urlparse(link)
if link_parsed.scheme:
return link
try:
link = link.split('../')[1]
link = ((((url_scheme + '://') + main_domain) + '/') + link)
if (not link):
return (- 2)
return link
except:
pass
try:
link = link.split('./')[1]
link = ((((url_scheme + '://') + main_domain) + '/') + link)
if (not link):
return (- 2)
return link
except:
pass
try:
if link.startswith('//'):
link = link.replace('/', '', 2)
if (not link):
return (- 1)
link = ((((url_scheme + '://') + main_domain) + '/') + link)
return link
if link.startswith('/'):
link = link.replace('/', '', 1)
if (not link):
return (- 1)
if host_name.endswith('/'):
link = ((((url_scheme + '://') + main_domain) + '/') + link)
else:
link = ((((url_scheme + '://') + main_domain) + '/') + link)
return link
except:
pass
if link_full_path.endswith('/'):
link = (link_full_path + link)
else:
link = ((link_full_path + '/') + link)
return link
except:
return (- 1) |
def pql_fmt(s: T.string):
_s = cast_to_python_string(s)
tokens = re_split('\\$\\w+', _s)
string_parts = []
for (m, t) in tokens:
if m:
assert (t[0] == '$')
obj = get_var(t[1:])
inst = cast_to_instance(obj)
as_str = cast(inst, T.string)
string_parts.append(as_str)
elif t:
string_parts.append(objects.pyvalue_inst(t))
if (not string_parts):
return objects.pyvalue_inst('')
elif (len(string_parts) == 1):
return string_parts[0]
a = string_parts[0]
for b in string_parts[1:]:
a = ast.BinOp('+', [a, b])
return cast_to_instance(a) |
def extractRookietranslationsBlogspotCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class Property():
def __init__(self, json):
self.name = json['name']
self.attributes_string = json['attributes_string']
self.attributes = json['attributes']
def prettyPrintString(self):
attrs = []
if ('N' in self.attributes):
attrs.append('nonatomic')
else:
attrs.append('atomic')
if ('&' in self.attributes):
attrs.append('strong')
elif ('C' in self.attributes):
attrs.append('copy')
elif ('W' in self.attributes):
attrs.append('weak')
else:
attrs.append('assign')
if ('R' in self.attributes):
attrs.append('readonly')
if ('G' in self.attributes):
attrs.append('getter={}'.format(self.attributes['G']))
if ('S' in self.attributes):
attrs.append('setter={}'.format(self.attributes['S']))
return ' ({}) {} {};'.format(', '.join(attrs), decode(self.attributes['T']), self.name) |
def validate(schema: typing.Union[(dict, str, bytes)], format: str=None, encoding: str=None):
if (not isinstance(schema, (dict, str, bytes))):
raise ValueError(f'schema must be either str, bytes, or dict.')
if (format not in FORMAT_CHOICES):
raise ValueError(f'format must be one of {FORMAT_CHOICES!r}')
if (encoding not in ENCODING_CHOICES):
raise ValueError(f'encoding must be one of {ENCODING_CHOICES!r}')
if isinstance(schema, bytes):
schema = schema.decode('utf8', 'ignore')
if isinstance(schema, str):
if (encoding is None):
if INFER_YAML.match(schema):
encoding = 'yaml'
elif INFER_JSON.match(schema):
encoding = 'json'
else:
text = 'Could not determine if content is JSON or YAML.'
code = 'unknown_encoding'
position = typesystem.Position(line_no=1, column_no=1, char_index=0)
raise typesystem.ParseError(text=text, code=code, position=position)
tokenize = {'yaml': typesystem.tokenize_yaml, 'json': typesystem.tokenize_json}[encoding]
token = tokenize(schema)
value = token.value
else:
token = None
value = schema
if (format is None):
if (('openapi' in value) and ('swagger' not in value)):
format = 'openapi'
elif (('swagger' in value) and ('openapi' not in value)):
format = 'swagger'
validator = {'config': APISTAR_CONFIG, 'jsonschema': JSON_SCHEMA, 'openapi': OPEN_API, 'swagger': SWAGGER, None: AUTO_DETERMINE}[format]
if (token is not None):
value = typesystem.validate_with_positions(token=token, validator=validator)
else:
value = validator.validate(value)
if (format is None):
format = ('swagger' if ('swagger' in value) else 'openapi')
if (format == 'swagger'):
return Swagger().load(value)
elif (format == 'openapi'):
return OpenAPI().load(value)
return value |
def group_ordered(list_in):
if (list_in is None):
return None
order_list = make_order_list(list_in)
current = 0
for item in order_list:
search = (current + 1)
while True:
try:
if (list_in[search] != item):
search += 1
else:
current += 1
(list_in[current], list_in[search]) = (list_in[search], list_in[current])
search += 1
except IndexError:
break
return list_in |
def test_histogram(elasticapm_client, prometheus):
metricset = PrometheusMetrics(MetricsRegistry(elasticapm_client))
histo = prometheus_client.Histogram('histo', 'test histogram', buckets=[1, 10, 100, float('inf')])
histo_with_labels = prometheus_client.Histogram('histowithlabel', 'test histogram with labels', ['alabel', 'anotherlabel'], buckets=[1, 10, 100, float('inf')])
histo.observe(0.5)
histo.observe(0.6)
histo.observe(1.5)
histo.observe(26)
histo.observe(42)
histo.observe(12)
histo.observe(105)
histo_with_labels.labels(alabel='foo', anotherlabel='baz').observe(1)
histo_with_labels.labels(alabel='foo', anotherlabel='baz').observe(10)
histo_with_labels.labels(alabel='foo', anotherlabel='baz').observe(100)
histo_with_labels.labels(alabel='foo', anotherlabel='bazzinga').observe(1000)
data = list(metricset.collect())
assert (data[0]['samples']['prometheus.metrics.histo']['values'] == [0.5, 5.5, 55.0, 100.0])
assert (data[0]['samples']['prometheus.metrics.histo']['counts'] == [2, 1, 3, 1])
assert all((isinstance(v, int) for v in data[0]['samples']['prometheus.metrics.histo']['counts']))
assert (data[1]['samples']['prometheus.metrics.histowithlabel']['values'] == [0.5, 5.5, 55.0, 100.0])
assert (data[1]['samples']['prometheus.metrics.histowithlabel']['counts'] == [1, 1, 1, 0])
assert all((isinstance(v, int) for v in data[1]['samples']['prometheus.metrics.histowithlabel']['counts']))
assert (data[1]['tags'] == {'alabel': 'foo', 'anotherlabel': 'baz'})
assert (data[2]['samples']['prometheus.metrics.histowithlabel']['values'] == [0.5, 5.5, 55.0, 100.0])
assert (data[2]['samples']['prometheus.metrics.histowithlabel']['counts'] == [0, 0, 0, 1])
assert all((isinstance(v, int) for v in data[2]['samples']['prometheus.metrics.histowithlabel']['counts']))
assert (data[2]['tags'] == {'alabel': 'foo', 'anotherlabel': 'bazzinga'}) |
def logout_oauth_client(authorization: str=Security(oauth2_scheme), db: Session=Depends(get_db)) -> Optional[ClientDetail]:
if (authorization is None):
raise AuthenticationError(detail='Authentication Failure')
try:
token_data = json.loads(extract_payload(authorization, CONFIG.security.app_encryption_key))
except jose.exceptions.JWEParseError:
return None
client_id = token_data.get(JWE_PAYLOAD_CLIENT_ID)
if ((not client_id) or (client_id == CONFIG.security.oauth_root_client_id)):
return None
client = ClientDetail.get(db, object_id=client_id, config=CONFIG, scopes=SCOPE_REGISTRY)
return client |
('cuda.permute.gen_function')
def gen_function(func_attrs: Dict[(str, Any)]) -> str:
func_name = func_attrs['name']
x = func_attrs['inputs'][0]
rank = x._rank()
custom_libs = Target.current().get_custom_libs(os.path.dirname(__file__), 'permute.cuh')
dtype = x.dtype()
assert (dtype in ('float16', 'bfloat16', 'float32', 'float')), 'permute is only tested for floating point type'
backend_type = CUDASpec().dtype_to_backend_dtype[dtype]
return SRC_TEMPLATE.render(func_name=func_name, custom_libs=custom_libs, input_rank=rank, elem_type=backend_type) |
def test():
assert Span.has_extension('to_html'), 'Hast du die Span-Erweiterung korrekt registriert?'
ext = Span.get_extension('to_html')
assert (ext[1] is not None), 'Hast du die Methode korrekt angegeben?'
assert ('method=to_html' in __solution__), 'Hast du die Funktion to_html als Methode angegeben?'
assert ('span._.to_html("strong")' in __solution__), 'Greifst du auf das richtige Attribut zu?'
assert (span._.to_html('strong') == '<strong>Hallo Welt</strong>'), 'Es scheint, als ob deine Methode den falschen Wert zuruckgibt.'
__msg__.good('Perfekt! In der nachsten Ubung kannst du nun benutzerdefinierte Attribute mit benutzerdefinierten Pipeline-Komponenten kombinieren.') |
class Editor(QMainWindow):
finished_signal = Signal(list)
def __init__(self, filenames, search_text='', master_name='', parent=None):
QMainWindow.__init__(self, parent)
self.setObjectName(('Editor - %s' % utf8(filenames)))
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.setWindowFlags(Qt.Window)
self.mIcon = nm.settings().icon('crystal_clear_edit_launch.png')
self._error_icon = nm.settings().icon('warning.png')
self._info_icon = nm.settings().icon('info.png')
self._empty_icon = QIcon()
self.setWindowIcon(self.mIcon)
window_title = 'ROSLaunch Editor'
if filenames:
window_title = self.__getTabName(filenames[0])
self.setWindowTitle(('%s %s' % (window_title, master_name)))
self.init_filenames = filenames
self._search_node_count = 0
self._search_thread = None
self._last_search_request = None
self.files = []
self.main_widget = QWidget(self)
self.main_widget.setObjectName('editorMain')
self.verticalLayout = QVBoxLayout(self.main_widget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(1)
self.verticalLayout.setObjectName('verticalLayout')
self.tabWidget = EditorTabWidget(self)
self.tabWidget.setTabPosition(QTabWidget.North)
self.tabWidget.setDocumentMode(True)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setMovable(False)
self.tabWidget.setObjectName('tabWidget')
self.tabWidget.tabCloseRequested.connect(self.on_close_tab)
self.tabWidget.currentChanged.connect(self.on_tab_changed)
self.verticalLayout.addWidget(self.tabWidget)
self.log_dock = self._create_log_bar()
self.addDockWidget(Qt.BottomDockWidgetArea, self.log_dock)
self.buttons = self._create_buttons()
self.verticalLayout.addWidget(self.buttons)
self.setCentralWidget(self.main_widget)
self.find_dialog = TextSearchFrame(self.tabWidget, self)
self.find_dialog.found_signal.connect(self.on_search_result)
self.find_dialog.replace_signal.connect(self.on_replace)
self.addDockWidget(Qt.RightDockWidgetArea, self.find_dialog)
self.graph_view = GraphViewWidget(self.tabWidget, self)
self.graph_view.load_signal.connect(self.on_graph_load_file)
self.graph_view.goto_signal.connect(self.on_graph_goto)
self.graph_view.search_signal.connect(self.on_load_request)
self.graph_view.finished_signal.connect(self.on_graph_finished)
self.graph_view.info_signal.connect(self.on_graph_info)
self.addDockWidget(Qt.RightDockWidgetArea, self.graph_view)
self.readSettings()
self.find_dialog.setVisible(False)
self.graph_view.setVisible(False)
nm.nmd().file.changed_file.connect(self.on_changed_file)
nm.nmd().file.packages_available.connect(self._on_new_packages)
for f in filenames:
if f:
self.on_load_request(f, search_text, only_launch=True)
self.log_dock.setVisible(False)
try:
pal = self.tabWidget.palette()
self._default_color = pal.color(QPalette.Window)
color = QColor.fromRgb(nm.settings().host_color(master_name, self._default_color.rgb()))
bg_style_launch_dock = ('QWidget#editorMain { background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 %s, stop: 0.7 %s);}' % (color.name(), self._default_color.name()))
self.setStyleSheet(('%s' % bg_style_launch_dock))
except Exception as _:
pass
def _create_buttons(self):
self.buttons = QWidget(self)
self.horizontalLayout = QHBoxLayout(self.buttons)
self.horizontalLayout.setContentsMargins(3, 0, 3, 0)
self.horizontalLayout.setObjectName('horizontalLayout')
self.upperButton = QPushButton(self)
self.upperButton.setObjectName('upperButton')
self.upperButton.clicked.connect(self.on_upperButton_clicked)
self.upperButton.setIcon(nm.settings().icon('up.png'))
self.upperButton.setShortcut('Ctrl+U')
self.upperButton.setToolTip('Open the file which include the current file (Ctrl+U)')
self.upperButton.setFlat(True)
self.horizontalLayout.addWidget(self.upperButton)
self.gotoButton = QPushButton(self)
self.gotoButton.setObjectName('gotoButton')
self.gotoButton.clicked.connect(self.on_shortcut_goto)
self.gotoButton.setText(self._translate('&Goto line'))
self.gotoButton.setShortcut('Ctrl+G')
self.gotoButton.setToolTip('Open a goto dialog (Ctrl+G)')
self.gotoButton.setFlat(True)
self.horizontalLayout.addWidget(self.gotoButton)
self.tagButton = self._create_tag_button(self)
self.horizontalLayout.addWidget(self.tagButton)
self.saveButton = QPushButton(self)
self.saveButton.setObjectName('saveButton')
self.saveButton.setIcon(QIcon.fromTheme('document-save'))
self.saveButton.clicked.connect(self.on_saveButton_clicked)
self.saveButton.setText(self._translate('&Save'))
self.saveButton.setShortcut('Ctrl+S')
self.saveButton.setToolTip('Save the changes to the file (Ctrl+S)')
self.saveButton.setFlat(True)
self.horizontalLayout.addWidget(self.saveButton)
spacerItem = QSpacerItem(515, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.pos_label = QLabel()
self.horizontalLayout.addWidget(self.pos_label)
spacerItem = QSpacerItem(515, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.show_log_button = QPushButton('Log>>', self)
self.show_log_button.setObjectName('show_log_button')
self.show_log_button.clicked.connect(self.on_toggled_log)
self.show_log_button.setFlat(True)
self.show_log_button.setCheckable(True)
self.horizontalLayout.addWidget(self.show_log_button)
self.graphButton = QPushButton(self)
self.graphButton.setObjectName('graphButton')
self.graphButton.toggled.connect(self.on_toggled_graph)
self.graphButton.setText('Includ&e Graph >>')
self.graphButton.setCheckable(True)
self.graphButton.setShortcut('Ctrl+E')
self.graphButton.setToolTip('Shows include and include from files (Ctrl+E)')
self.graphButton.setFlat(True)
self.horizontalLayout.addWidget(self.graphButton)
self.searchButton = QPushButton(self)
self.searchButton.setObjectName('searchButton')
self.searchButton.toggled.connect(self.on_toggled_find)
self.searchButton.setText(self._translate('&Find >>'))
self.searchButton.setToolTip('Open a search dialog (Ctrl+F)')
self.searchButton.setFlat(True)
self.searchButton.setCheckable(True)
self.horizontalLayout.addWidget(self.searchButton)
self.replaceButton = QPushButton(self)
self.replaceButton.setObjectName('replaceButton')
self.replaceButton.toggled.connect(self.on_toggled_replace)
self.replaceButton.setText(self._translate('&Replace >>'))
self.replaceButton.setToolTip('Open a search&replace dialog (Ctrl+R)')
self.replaceButton.setFlat(True)
self.replaceButton.setCheckable(True)
self.horizontalLayout.addWidget(self.replaceButton)
return self.buttons
def _create_log_bar(self):
self.log_dock = QDockWidget(self)
self.log_dock.setObjectName('LogFrame')
self.log_dock.setFeatures((QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable))
self.log_bar = QWidget(self)
self.horizontal_layout_log_bar = QHBoxLayout(self.log_bar)
self.horizontal_layout_log_bar.setContentsMargins(2, 0, 2, 0)
self.horizontal_layout_log_bar.setObjectName('horizontal_layout_log_bar')
self._log_warning_count = 0
self.log_browser = QTextEdit()
self.log_browser.setObjectName('log_browser')
self.log_browser.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.log_browser.setLineWrapMode(QTextEdit.NoWrap)
color = QColor(255, 255, 235)
bg_style = ('QTextEdit#log_browser { background-color: %s;}' % color.name())
self.log_bar.setStyleSheet(('%s' % bg_style))
self.horizontal_layout_log_bar.addWidget(self.log_browser)
self.clear_log_button = QPushButton('clear', self)
self.clear_log_button.setObjectName('clear_log_button')
self.clear_log_button.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
self.clear_log_button.clicked.connect(self.on_clear_log_button_clicked)
self.clear_log_button.setFlat(True)
self.horizontal_layout_log_bar.addWidget(self.clear_log_button)
self.log_dock.setWidget(self.log_bar)
return self.log_dock
def keyPressEvent(self, event):
if (event.key() == Qt.Key_Escape):
self.reject()
elif ((event.modifiers() == Qt.ControlModifier) and (event.key() == Qt.Key_F)):
if self.tabWidget.currentWidget().hasFocus():
if (not self.searchButton.isChecked()):
self.searchButton.setChecked(True)
else:
self.on_toggled_find(True)
else:
self.searchButton.setChecked((not self.searchButton.isChecked()))
elif ((event.modifiers() == Qt.ControlModifier) and (event.key() == Qt.Key_R)):
if self.tabWidget.currentWidget().hasFocus():
if (not self.replaceButton.isChecked()):
self.replaceButton.setChecked(True)
else:
self.on_toggled_replace(True)
else:
self.replaceButton.setChecked((not self.replaceButton.isChecked()))
elif ((event.modifiers() == Qt.ControlModifier) and (event.key() == Qt.Key_E)):
if self.tabWidget.currentWidget().hasFocus():
if (not self.graphButton.isChecked()):
self.graphButton.setChecked(True)
else:
self.on_toggled_graph(True)
else:
self.graphButton.setChecked((not self.graphButton.isChecked()))
elif ((event.modifiers() == Qt.ControlModifier) and (event.key() == Qt.Key_W)):
self.on_close_tab(self.tabWidget.currentIndex())
elif ((event.modifiers() in [Qt.ControlModifier, Qt.AltModifier]) and (event.key() == Qt.Key_Up)):
self.on_upperButton_clicked()
elif ((event.modifiers() in [Qt.ControlModifier, Qt.AltModifier]) and (event.key() == Qt.Key_Down)):
self.on_downButton_clicked()
else:
event.accept()
QMainWindow.keyPressEvent(self, event)
def _translate(self, text):
if hasattr(QApplication, 'UnicodeUTF8'):
return QApplication.translate('Editor', text, None, QApplication.UnicodeUTF8)
else:
return QApplication.translate('Editor', text, None)
def readSettings(self):
if nm.settings().store_geometry:
settings = nm.settings().qsettings(nm.settings().CFG_GUI_FILE)
settings.beginGroup('editor')
maximized = (settings.value('maximized', 'false') == 'true')
if maximized:
self.showMaximized()
else:
self.resize(settings.value('size', QSize(800, 640)))
self.move(settings.value('pos', QPoint(0, 0)))
try:
self.restoreState(settings.value('window_state'))
except Exception:
import traceback
print(traceback.format_exc())
settings.endGroup()
def storeSetting(self):
if nm.settings().store_geometry:
settings = nm.settings().qsettings(nm.settings().CFG_GUI_FILE)
settings.beginGroup('editor')
settings.setValue('size', self.size())
settings.setValue('pos', self.pos())
settings.setValue('maximized', self.isMaximized())
settings.setValue('window_state', self.saveState())
settings.endGroup()
def on_load_request(self, filename, search_text='', insert_index=(- 1), goto_line=(- 1), only_launch=False, count_results=0):
if (not filename):
return
self.tabWidget.setUpdatesEnabled(False)
try:
if (filename not in self.files):
tab_name = self.__getTabName(filename)
editor = TextEdit(filename, parent=self)
linenumber_editor = LineNumberWidget(editor)
tab_index = 0
if (insert_index > (- 1)):
tab_index = self.tabWidget.insertTab(insert_index, linenumber_editor, tab_name)
else:
tab_index = self.tabWidget.addTab(linenumber_editor, tab_name)
self.files.append(filename)
editor.setCurrentPath(os.path.basename(filename))
editor.load_request_signal.connect(self.on_load_request)
editor.document().modificationChanged.connect(self.on_editor_modificationChanged)
editor.cursorPositionChanged.connect(self.on_editor_positionChanged)
editor.setFocus(Qt.OtherFocusReason)
editor.undoAvailable.connect(self.on_text_changed)
self.tabWidget.setCurrentIndex(tab_index)
else:
for i in range(self.tabWidget.count()):
if (self.tabWidget.widget(i).filename == filename):
self.tabWidget.setCurrentIndex(i)
break
self.tabWidget.setUpdatesEnabled(True)
if search_text:
if only_launch:
self.find_dialog.found_files_list.clear()
try:
self._search_thread.stop()
self._search_thread = None
except Exception:
pass
rospy.logdebug(("serach for '%s'" % search_text))
self._search_node_count = 0
self._search_thread = TextSearchThread(search_text, filename, recursive=True, only_launch=only_launch, count_results=count_results)
self._search_thread.search_result_signal.connect(self.on_search_result_on_open)
self._search_thread.warning_signal.connect(self.on_search_result_warning)
self._last_search_request = (filename, search_text, insert_index, goto_line, only_launch)
if (not self.graph_view.is_loading()):
self.on_graph_info(("search thread: start search for '%s'" % self._search_thread._search_text))
self._search_thread.start()
if (goto_line != (- 1)):
self.tabWidget.currentWidget().goto(goto_line, True)
self.upperButton.setEnabled((self.tabWidget.count() > 1))
except Exception as err:
self.tabWidget.setUpdatesEnabled(True)
import traceback
msg = ('Error while open %s: %s' % (filename, traceback.format_exc()))
rospy.logwarn(msg)
MessageBox.critical(self, 'Error', utf8(err), msg)
if (self.tabWidget.count() == 0):
self.close()
def on_graph_load_file(self, path, insert_after=True):
insert_index = (self.tabWidget.currentIndex() + 1)
if ((not insert_after) and (insert_index > 1)):
insert_index = self.tabWidget.currentIndex()
self.on_load_request(path, insert_index=insert_index)
def on_graph_goto(self, path, linenr):
if (path == self.tabWidget.currentWidget().filename):
if (linenr != (- 1)):
self.tabWidget.currentWidget().goto(linenr, True)
def on_graph_finished(self):
self.on_graph_info('build tree: finished', False)
if self.graph_view.has_warnings:
self.graphButton.setIcon(self._info_icon)
else:
self.graphButton.setIcon(self._empty_icon)
if self._search_thread:
try:
self._search_thread.find_args_not_set = True
self._search_thread.start()
self.on_graph_info(("search thread: start search for '%s'" % self._search_thread._search_text))
except Exception:
pass
def on_graph_info(self, msg, warning=False):
text_color = '#000000'
if warning:
self._log_warning_count += 1
if (self._log_warning_count == 1):
self.show_log_button.setIcon(self._error_icon)
text_color = '#FE9A2E'
text = ('<pre style="padding:10px;"><dt><font color="%s">%s</font></dt></pre>' % (text_color, msg))
self.log_browser.append(text)
def on_text_changed(self, value=''):
if self.tabWidget.currentWidget().hasFocus():
self.find_dialog.file_changed(self.tabWidget.currentWidget().filename)
self._last_search_request = None
def on_tab_changed(self, index):
if (index > (- 1)):
self.graph_view.set_file(self.tabWidget.widget(index).filename, self.tabWidget.widget(0).filename)
self._last_search_request = None
def on_close_tab(self, tab_index):
try:
doremove = True
w = self.tabWidget.widget(tab_index)
if w.document().isModified():
name = self.__getTabName(w.filename)
result = MessageBox.question(self, 'Unsaved Changes', '\n\n'.join(['Save the file before closing?', name]))
if (result == MessageBox.Yes):
self.tabWidget.currentWidget().save()
elif (result == MessageBox.No):
pass
elif rospy.is_shutdown():
doremove = False
if doremove:
if (w.filename in self.files):
self.files.remove(w.filename)
self.tabWidget.removeTab(tab_index)
if (not self.tabWidget.count()):
self.close()
self._last_search_request = None
except Exception:
import traceback
rospy.logwarn('Error while close tab %s: %s', str(tab_index), traceback.format_exc(1))
self.upperButton.setEnabled((self.tabWidget.count() > 1))
def reject(self):
if self.find_dialog.isVisible():
self.searchButton.setChecked((not self.searchButton.isChecked()))
else:
self.close()
def on_changed_file(self, grpc_path, mtime):
if (grpc_path in self.files):
for i in range(self.tabWidget.count()):
if (self.tabWidget.widget(i).filename == grpc_path):
self.tabWidget.widget(i).file_changed(mtime)
break
if (self._last_search_request is not None):
self.on_load_request(*self._last_search_request)
def closeEvent(self, event):
changed = []
for i in range(self.tabWidget.count()):
w = self.tabWidget.widget(i)
if w.document().isModified():
changed.append(self.__getTabName(w.filename))
if changed:
if self.isHidden():
buttons = (MessageBox.Yes | MessageBox.No)
else:
buttons = ((MessageBox.Yes | MessageBox.No) | MessageBox.Cancel)
result = MessageBox.question(self, 'Unsaved Changes', '\n\n'.join(['Save the file before closing?', '\n'.join(changed)]), buttons=buttons)
if (result == MessageBox.Yes):
for i in range(self.tabWidget.count()):
w = self.tabWidget.widget(i).save()
self.graph_view.clear_cache()
event.accept()
elif (result == MessageBox.No):
event.accept()
else:
event.ignore()
else:
event.accept()
if event.isAccepted():
self.storeSetting()
nm.nmd().file.changed_file.disconnect(self.on_changed_file)
nm.nmd().file.packages_available.connect(self._on_new_packages)
self.finished_signal.emit(self.init_filenames)
def on_editor_modificationChanged(self, value=None):
tab_name = self.__getTabName(self.tabWidget.currentWidget().filename)
if self.tabWidget.currentWidget().document().isModified():
tab_name = ('*%s' % tab_name)
self.tabWidget.setTabText(self.tabWidget.currentIndex(), tab_name)
def on_editor_positionChanged(self):
cursor = self.tabWidget.currentWidget().textCursor()
self.pos_label.setText((':%s:%s #%s' % ((cursor.blockNumber() + 1), cursor.columnNumber(), cursor.position())))
def __getTabName(self, lfile):
base = os.path.basename(lfile).replace('.launch', '')
(package, _) = package_name(os.path.dirname(lfile))
return ('%s [%s]' % (base, package))
def _on_new_packages(self, url):
try:
if (nmdurl.nmduri_from_path(url) == nmdurl.nmduri_from_path(self.tabWidget.currentWidget().filename)):
rospy.logdebug('packages updated, rebuild graph')
if self.graph_view.has_none_packages:
self.graph_view.clear_cache()
except Exception:
import traceback
print(traceback.format_exc())
def on_clear_log_button_clicked(self):
self._log_warning_count = 0
self.show_log_button.setIcon(self._empty_icon)
self.log_browser.clear()
self.log_dock.setVisible(False)
self.show_log_button.setChecked(False)
self.tabWidget.currentWidget().setFocus()
def on_upperButton_clicked(self):
if (self.tabWidget.currentIndex() != 0):
self.graph_view.find_parent_file()
def on_downButton_clicked(self):
if (self.tabWidget.currentIndex() < self.tabWidget.count()):
self.tabWidget.setCurrentIndex((self.tabWidget.currentIndex() + 1))
def on_saveButton_clicked(self):
(saved, errors, msg) = self.tabWidget.currentWidget().save()
if errors:
if msg:
rospy.logwarn(msg)
MessageBox.critical(self, 'Error', ('Error while save file: %s' % os.path.basename(self.tabWidget.currentWidget().filename)), detailed_text=msg)
self.tabWidget.setTabIcon(self.tabWidget.currentIndex(), self._error_icon)
self.tabWidget.setTabToolTip(self.tabWidget.currentIndex(), msg)
self.on_graph_info(('saved failed %s: %s' % (self.tabWidget.currentWidget().filename, msg)), True)
elif saved:
self.on_graph_info(('saved %s' % self.tabWidget.currentWidget().filename))
self.tabWidget.setTabIcon(self.tabWidget.currentIndex(), self._empty_icon)
self.tabWidget.setTabToolTip(self.tabWidget.currentIndex(), '')
self.graph_view.clear_cache()
def on_shortcut_find(self):
pass
def on_toggled_log(self, value):
if value:
self.log_dock.setVisible(True)
else:
self.log_dock.setVisible(False)
self.tabWidget.currentWidget().setFocus()
def on_toggled_graph(self, value):
if value:
self.graph_view.enable()
else:
self.graph_view.setVisible(False)
self.tabWidget.currentWidget().setFocus()
def on_toggled_find(self, value, only_results=False):
if value:
self.find_dialog.enable()
self.find_dialog.find_frame.setVisible((not only_results))
self.find_dialog.recursive_search_box.setVisible((not only_results))
if (not only_results):
if (not self.find_dialog.search_field.text()):
self.find_dialog.found_files_list.clear()
else:
self.replaceButton.setChecked(False)
self.find_dialog.setVisible(False)
self.tabWidget.currentWidget().setFocus()
def on_toggled_replace(self, value):
if value:
self.searchButton.setChecked(True)
self.find_dialog.set_replace_visible(value)
def on_shortcut_goto(self):
value = 1
ok = False
try:
(value, ok) = QInputDialog.getInt(self, 'Goto', self.tr('Line number:'), QLineEdit.Normal, minValue=1, step=1)
except Exception:
(value, ok) = QInputDialog.getInt(self, 'Goto', self.tr('Line number:'), QLineEdit.Normal, min=1, step=1)
if ok:
self.tabWidget.currentWidget().goto(value)
self.tabWidget.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
def on_search_result(self, search_text, found, path, startpos, endpos, linenr=(- 1), line_text=''):
if found:
if (self.tabWidget.currentWidget().filename != path):
focus_widget = QApplication.focusWidget()
self.on_load_request(path)
focus_widget.setFocus()
self.tabWidget.currentWidget().select(startpos, endpos, False)
def on_search_result_on_open(self, search_text, found, path, startpos, endpos, linenr, line_text):
if found:
self._search_node_count += 1
if (self._search_node_count > 1):
self.on_toggled_find(True, only_results=True)
self.find_dialog.current_search_text = search_text
self.find_dialog.on_search_result(search_text, found, path, startpos, endpos, linenr, line_text)
self.on_graph_info(("search thread: found %s in '%s:%d'" % (search_text, path, linenr)))
if (self.tabWidget.currentWidget().filename != path):
focus_widget = QApplication.focusWidget()
self.on_load_request(path)
if (focus_widget is not None):
focus_widget.setFocus()
self.tabWidget.currentWidget().select(startpos, endpos, True)
def on_search_result_warning(self, msg):
self.on_graph_info(('search thread: %s' % msg), True)
def on_replace(self, search_text, path, index, replaced_text):
cursor = self.tabWidget.currentWidget().textCursor()
if (cursor.selectedText() == search_text):
cursor.insertText(replaced_text)
def _show_custom_parameter_dialog(self):
methods = {'nm/associations': self._on_add_cp_associations, 'capability_group': self._on_add_cp_capability_group, 'nm/kill_on_stop': self._on_add_cp_kill_on_stop, 'autostart/delay': self._on_add_cp_as_delay, 'autostart/exclude': self._on_add_cp_as_exclude, 'autostart/required_publisher': self._on_add_cp_as_req_publisher, 'respawn/max': self._on_add_cp_r_max, 'respawn/min_runtime': self._on_add_cp_r_min_runtime, 'respawn/delay': self._on_add_cp_r_delay}
res = SelectDialog.getValue('Insert custom parameter', 'Select parameter to insert:', sorted(methods.keys()), exclusive=True, parent=self, select_if_single=False, store_geometry='insert_param')
tags2insert = res[0]
for tag in tags2insert:
methods[tag]()
def _create_tag_button(self, parent=None):
btn = QPushButton(parent)
btn.setObjectName('tagButton')
btn.setText(self._translate('Add &tag'))
btn.setToolTip('Adds a ROS launch tag to launch file')
btn.setMenu(self._create_tag_menu(btn))
btn.setFlat(True)
return btn
def _create_tag_menu(self, parent=None):
tag_menu = QMenu('ROS Tags', parent)
add_group_tag_action = QAction('<group>', self, statusTip='', triggered=self._on_add_group_tag)
add_group_tag_action.setShortcuts(QKeySequence('Ctrl+Shift+g'))
tag_menu.addAction(add_group_tag_action)
add_node_tag_action = QAction('<node>', self, statusTip='', triggered=self._on_add_node_tag)
add_node_tag_action.setShortcuts(QKeySequence('Ctrl+Shift+n'))
tag_menu.addAction(add_node_tag_action)
add_node_tag_all_action = QAction('<node all>', self, statusTip='', triggered=self._on_add_node_tag_all)
tag_menu.addAction(add_node_tag_all_action)
add_include_tag_all_action = QAction('<include>', self, statusTip='', triggered=self._on_add_include_tag_all)
add_include_tag_all_action.setShortcuts(QKeySequence('Ctrl+Shift+i'))
tag_menu.addAction(add_include_tag_all_action)
add_remap_tag_action = QAction('<remap>', self, statusTip='', triggered=self._on_add_remap_tag)
add_remap_tag_action.setShortcuts(QKeySequence('Ctrl+Shift+r'))
tag_menu.addAction(add_remap_tag_action)
add_env_tag_action = QAction('<env>', self, statusTip='', triggered=self._on_add_env_tag)
tag_menu.addAction(add_env_tag_action)
add_param_clipboard_tag_action = QAction('<param value>', self, statusTip='add value from clipboard', triggered=self._on_add_param_clipboard_tag)
add_param_clipboard_tag_action.setShortcuts(QKeySequence('Ctrl+Shift+p'))
tag_menu.addAction(add_param_clipboard_tag_action)
add_param_tag_action = QAction('<param>', self, statusTip='', triggered=self._on_add_param_tag)
add_param_tag_action.setShortcuts(QKeySequence('Ctrl+Shift+Alt+p'))
tag_menu.addAction(add_param_tag_action)
add_param_tag_all_action = QAction('<param all>', self, statusTip='', triggered=self._on_add_param_tag_all)
tag_menu.addAction(add_param_tag_all_action)
add_rosparam_tag_all_action = QAction('<rosparam>', self, statusTip='', triggered=self._on_add_rosparam_tag_all)
tag_menu.addAction(add_rosparam_tag_all_action)
add_arg_tag_default_action = QAction('<arg default>', self, statusTip='', triggered=self._on_add_arg_tag_default)
add_arg_tag_default_action.setShortcuts(QKeySequence('Ctrl+Shift+a'))
tag_menu.addAction(add_arg_tag_default_action)
add_arg_tag_value_action = QAction('<arg value>', self, statusTip='', triggered=self._on_add_arg_tag_value)
add_arg_tag_value_action.setShortcuts(QKeySequence('Ctrl+Alt+a'))
tag_menu.addAction(add_arg_tag_value_action)
add_test_tag_action = QAction('<test>', self, statusTip='', triggered=self._on_add_test_tag)
add_test_tag_action.setShortcuts(QKeySequence('Ctrl+Alt+t'))
tag_menu.addAction(add_test_tag_action)
add_test_tag_all_action = QAction('<test all>', self, statusTip='', triggered=self._on_add_test_tag_all)
tag_menu.addAction(add_test_tag_all_action)
sub_cp_menu = QMenu('Custom parameters', parent)
show_cp_dialog_action = QAction('Show Dialog', self, statusTip='', triggered=self._show_custom_parameter_dialog)
show_cp_dialog_action.setShortcuts(QKeySequence('Ctrl+Shift+d'))
sub_cp_menu.addAction(show_cp_dialog_action)
add_cp_associations_action = QAction('nm/associations', self, statusTip='', triggered=self._on_add_cp_associations)
add_cp_associations_action.setShortcuts(QKeySequence('Ctrl+Alt+a'))
sub_cp_menu.addAction(add_cp_associations_action)
sub_cp_as_menu = QMenu('Autostart', parent)
add_cp_as_delay_action = QAction('delay', self, statusTip='', triggered=self._on_add_cp_as_delay)
sub_cp_as_menu.addAction(add_cp_as_delay_action)
add_cp_as_exclude_action = QAction('exclude', self, statusTip='', triggered=self._on_add_cp_as_exclude)
sub_cp_as_menu.addAction(add_cp_as_exclude_action)
add_cp_as_req_publisher_action = QAction('required publisher', self, statusTip='', triggered=self._on_add_cp_as_req_publisher)
sub_cp_as_menu.addAction(add_cp_as_req_publisher_action)
sub_cp_menu.addMenu(sub_cp_as_menu)
sub_cp_r_menu = QMenu('Respawn', parent)
add_cp_r_max_action = QAction('max', self, statusTip='', triggered=self._on_add_cp_r_max)
sub_cp_r_menu.addAction(add_cp_r_max_action)
add_cp_r_min_runtime_action = QAction('min_runtime', self, statusTip='', triggered=self._on_add_cp_r_min_runtime)
sub_cp_r_menu.addAction(add_cp_r_min_runtime_action)
add_cp_r_delay_action = QAction('delay', self, statusTip='', triggered=self._on_add_cp_r_delay)
sub_cp_r_menu.addAction(add_cp_r_delay_action)
sub_cp_menu.addMenu(sub_cp_r_menu)
add_cp_capability_group_action = QAction('capability_group', self, statusTip='', triggered=self._on_add_cp_capability_group)
add_cp_capability_group_action.setShortcuts(QKeySequence('Ctrl+Alt+p'))
sub_cp_menu.addAction(add_cp_capability_group_action)
add_cp_kill_on_stop_action = QAction('nm/kill_on_stop', self, statusTip='True or time to wait in ms', triggered=self._on_add_cp_kill_on_stop)
add_cp_kill_on_stop_action.setShortcuts(QKeySequence('Ctrl+Shift+k'))
sub_cp_menu.addAction(add_cp_kill_on_stop_action)
tag_menu.addMenu(sub_cp_menu)
return tag_menu
def _insert_text(self, text, cursor_pose=None, selection_len=None):
if self.tabWidget.currentWidget().isReadOnly():
return
cursor = self.tabWidget.currentWidget().textCursor()
if (not cursor.isNull()):
cursor.beginEditBlock()
col = cursor.columnNumber()
spaces = ''.join([' ' for _ in range(col)])
curr_cursor_pos = cursor.position()
cursor.insertText(text.replace('\n', ('\n%s' % spaces)))
if (cursor_pose is not None):
cursor.setPosition((curr_cursor_pos + cursor_pose), QTextCursor.MoveAnchor)
if (selection_len is not None):
cursor.movePosition(QTextCursor.NextCharacter, QTextCursor.KeepAnchor, selection_len)
cursor.endEditBlock()
self.tabWidget.currentWidget().setTextCursor(cursor)
self.tabWidget.currentWidget().setFocus(Qt.OtherFocusReason)
def _on_add_group_tag(self):
self._insert_text('<group ns="namespace" clear_params="true|false">\n</group>', 11, 9)
def _get_package_dialog(self):
muri = masteruri_from_ros()
if self.init_filenames:
muri = nmdurl.masteruri(self.init_filenames[0])
return PackageDialog(muri)
def _on_add_node_tag(self):
dia = self._get_package_dialog()
if dia.exec_():
self._insert_text(('<node name="%s" pkg="%s" type="%s">\n</node>' % (dia.binary, dia.package, dia.binary)))
def _on_add_node_tag_all(self):
dia = self._get_package_dialog()
if dia.exec_():
self._insert_text(('<node name="%s" pkg="%s" type="%s"\n args="arg1" machine="machine_name"\n respawn="true" required="true"\n ns="foo" clear_params="true|false"\n output="log|screen" cwd="ROS_HOME|node"\n launch-prefix="prefix arguments">\n</node>' % (dia.binary, dia.package, dia.binary)))
def _on_add_include_tag_all(self):
self._insert_text('<include file="$(find pkg-name)/path/filename.xml"\n ns="foo" clear_params="true|false">\n</include>', 22, 27)
def _on_add_remap_tag(self):
self._insert_text('<remap from="original" to="new"/>', 13, 8)
def _on_add_env_tag(self):
self._insert_text('<env name="variable" value="value"/>', 11, 8)
def _on_add_param_clipboard_tag(self):
lines = QApplication.clipboard().mimeData().text().splitlines()
name = ''
if (len(lines) == 1):
name = lines[0]
self._insert_text(('<param name="%s" value="value" />' % name), (22 + len(name)), 5)
def _on_add_param_tag(self):
self._insert_text('<param name="name" value="value" />', 13, 4)
def _on_add_param_tag_all(self):
self._insert_text('<param name="name" value="value"\n type="str|int|double|bool"\n textfile="$(find pkg-name)/path/file.txt"\n binfile="$(find pkg-name)/path/file"\n command="$(find pkg-name)/exe \'$(find pkg-name)/arg.txt\'">\n</param>', 13, 4)
def _on_add_rosparam_tag_all(self):
self._insert_text('<rosparam param="name"\n file="$(find pkg-name)/path/foo.yaml"\n command="load|dump|delete"\n ns="namespace"\n subst_value="true|false">\n</rosparam>', 17, 4)
def _on_add_arg_tag_default(self):
self._insert_text('<arg name="foo" default="1" />', 11, 3)
def _on_add_arg_tag_value(self):
self._insert_text('<arg name="foo" value="bar" />', 11, 3)
def _on_add_test_tag(self):
dia = self._get_package_dialog()
if dia.exec_():
self._insert_text(('<test name="%s" pkg="%s" type="%s" test-name="test_%s">\n</test>' % (dia.binary, dia.package, dia.binary, dia.binary)))
def _on_add_test_tag_all(self):
dia = self._get_package_dialog()
if dia.exec_():
self._insert_text(('<test name="%s" pkg="%s" type="%s" test-name="test_%s">\n args="arg1" time-limit="60.0"\n ns="foo" clear_params="true|false"\n cwd="ROS_HOME|node" retry="0"\n launch-prefix="prefix arguments">\n</test>' % (dia.binary, dia.package, dia.binary, dia.binary)))
def _on_add_cp_capability_group(self):
self._insert_text('<param name="capability_group" value="demo" />', 38, 4)
def _on_add_cp_kill_on_stop(self):
self._insert_text('<param name="nm/kill_on_stop" value="100" hint="[ms]" />', 34, 3)
def _on_add_cp_associations(self):
self._insert_text('<param name="nm/associations" value="node1,node2" hint="list of nodes" />', 34, 11)
def _on_add_cp_as_delay(self):
self._insert_text('<param name="autostart/delay" value="1" hint="[seconds]" />', 37, 1)
def _on_add_cp_as_exclude(self):
self._insert_text('<param name="autostart/exclude" value="True" />', 39, 4)
def _on_add_cp_as_req_publisher(self):
self._insert_text('<param name="autostart/required/publisher" value="topic" />', 50, 5)
def _on_add_cp_r_max(self):
self._insert_text('<param name="respawn/max" value="10" />', 33, 2)
def _on_add_cp_r_min_runtime(self):
self._insert_text('<param name="respawn/min_runtime" value="10" hint="[seconds]" />', 41, 2)
def _on_add_cp_r_delay(self):
self._insert_text('<param name="respawn/delay" value="5" hint="[seconds]" />', 31, 2) |
class Menus():
def __init__(self, ui):
self.page = ui.page
def top(self, data: List[dict]=None, color: str=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(30, 'px'), html_code: str=None, helper: str=None, options: dict=None, profile: Union[(bool, dict)]=None):
width = Arguments.size(width, unit='%')
height = Arguments.size(height, unit='px')
dflt_options = {'tab_width': 100}
if (options is not None):
dflt_options.update(options)
(titles, panels) = ([], [])
for k in data:
if (not isinstance(k, dict)):
k = {'value': k}
titles.append(self.page.ui.text(k['value'], width=(dflt_options['tab_width'], 'px'), align='center'))
children = k.get('children', [])
col = self.page.ui.col(width=(dflt_options['tab_width'], 'px'))
col.style.css.display = None
col.style.css.padding = '0 2px'
col.style.css.background = self.page.theme.greys[0]
col.style.css.position = 'absolute'
if children:
items = []
for c in children:
if hasattr(c, 'options'):
items.append(c)
else:
if (not isinstance(c, dict)):
c = {'text': c}
link = self.page.ui.link(**c)
link.style.css.display = 'block'
items.append(link)
col.add(items)
panels.append(col)
html_list = html.HtmlList.List(self.page, [], color, width, height, html_code, helper, (options or {}), profile)
html_list.css({'list-style': 'none'})
html_div = self.page.ui.div()
html_div.style.css.background = self.page.theme.greys[1]
html_div.css({'position': 'fixed', 'margin': 0, 'left': 0})
html_div.style.css.margin_top = int(self.page.body.style.css.padding_top[:(- 2)])
html_div.style.css.top = 0
html_div.panels = panels
html_div.titles = titles
for (i, t) in enumerate(titles):
cont = self.page.ui.div([t, panels[i]], width=('auto', ''))
cont.mouse([panels[i].dom.show(display_value='block').r], [panels[i].dom.hide().r])
html_div.add(cont)
html_div.style.css.line_height = height[0]
if (self.page.body.style.css.padding_top is not None):
self.page.body.style.css.padding_top = ((int(self.page.body.style.css.padding_top[:(- 2)]) + height[0]) + 5)
else:
self.page.body.style.css.padding_top = (height[0] + 5)
html.Html.set_component_skin(html_div)
return html_div
def bottom(self, data: List[dict]=None, color: str=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(30, 'px'), html_code: str=None, helper: str=None, options: dict=None, profile: Union[(bool, dict)]=None):
width = Arguments.size(width, unit='%')
height = Arguments.size(height, unit='px')
dflt_options = {'tab_width': 100}
if (options is not None):
dflt_options.update(options)
(titles, panels) = ([], [])
for k in data:
if (not isinstance(k, dict)):
k = {'value': k}
titles.append(self.page.ui.text(k['value'], width=(dflt_options['tab_width'], 'px'), align='center'))
children = k.get('children', [])
col = self.page.ui.col(width=(dflt_options['tab_width'], 'px'))
col.style.css.display = None
col.style.css.bottom = height[0]
col.style.css.padding = '0 2px'
col.style.css.background = self.page.theme.greys[0]
col.style.css.position = 'absolute'
if children:
items = []
for c in children:
if hasattr(c, 'options'):
items.append(c)
else:
if (not isinstance(c, dict)):
c = {'text': c}
link = self.page.ui.link(**c)
link.style.css.display = 'block'
items.append(link)
col.add(items)
panels.append(col)
html_list = html.HtmlList.List(self.page, [], color, width, height, html_code, helper, (options or {}), profile)
html_list.css({'list-style': 'none'})
html_div = self.page.ui.div()
html_div.style.css.background = self.page.theme.greys[1]
html_div.css({'position': 'fixed', 'margin': 0, 'left': 0})
html_div.style.css.bottom = 0
html_div.panels = panels
html_div.titles = titles
for (i, t) in enumerate(titles):
cont = self.page.ui.div([panels[i], t], width=('auto', ''))
cont.mouse([panels[i].dom.show().r], [panels[i].dom.hide().r])
html_div.add(cont)
html_div.style.css.line_height = height[0]
if (self.page.body.style.css.padding_bottom is not None):
self.page.body.style.css.padding_bottom = ((int(self.page.body.style.css.padding_bottom[:(- 2)]) + height[0]) + 5)
else:
self.page.body.style.css.padding_bottom = (height[0] + 5)
html.Html.set_component_skin(html_div)
return html_div
def menu(self, data: list=None, color: str=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(None, 'px'), html_code: str=None, helper: str=None, options: dict=None, profile: Union[(bool, dict)]=None):
(menu_li, menu_title, menu_items, menu_divs) = ([], [], [], [])
records = []
for k in data:
if (not isinstance(k, dict)):
records.append({'value': k})
else:
records.append(k)
for k in records:
menu_li.append(k['value'])
title_text = k.get('title')
if (title_text is not None):
title_text = self.page.ui.title(title_text, level=4)
title_text.options.managed = False
menu_title.append(title_text)
menu_items.append(k.get('children', []))
html_list = self.page.ui.list(menu_li, color, width, height, html_code, helper, (options or {}), profile)
html_list.css({'list-style': 'none'})
for (i, m) in enumerate(menu_title):
if (menu_items[i] and isinstance(menu_items[i][0], list)):
grid = self.page.ui.div([])
for item in menu_items[i]:
grid.add(self.page.ui.col([m, *item], width=(None, 'px')).css({'padding': '0 5px', 'display': 'inline-block', 'vertical-align': 'top', 'margin': '2px 0'}))
html_div = self.page.ui.div(grid).css({'vertical-align': 'None'})
html_div.attr['name'] = ('divs_%s' % html_list.htmlCode)
html_div.style.display = None
else:
grid = self.page.ui.grid([self.page.ui.col([m, *menu_items[i]]).css({'padding': '0 5px'})])
html_div = self.page.ui.div(grid)
html_div.attr['name'] = ('divs_%s' % html_list.htmlCode)
html_div.style.display = None
menu_divs.append(html_div)
if records:
html_list.click_items(([self.page.js.getElementById(l.htmlCode).setAttribute('data-select', 'false') for l in html_list] + [self.page.js.objects.dom('this').setAttribute('data-select', 'true')]))
col = self.page.ui.col([html_list, *menu_divs])
col.css({'background-color': self.page.theme.greys[0], 'margin': 0})
html.Html.set_component_skin(col)
return col
def bar(self, data=None, align: str='left', position: str='top', color: str=None, width: Union[(tuple, int)]=(350, 'px'), height: Union[(tuple, int)]=(None, 'px'), options: dict=None, profile: Union[(bool, dict)]=None):
records = []
dfl_options = {'target': '_self'}
if (options is not None):
dfl_options.update(options)
for k in data:
if (not isinstance(k, dict)):
records.append({'value': k})
else:
records.append(k)
row = self.page.ui.row(color, width=width, height=height, options=dfl_options, profile=profile, position=position)
for _ in range(len(records)):
col = self.page.ui.col(align=align, position=position)
col.options.responsive = False
row.add(col)
for (i, k) in enumerate(records):
title_text = k.get('value')
if (title_text is not None):
title_text = self.page.ui.titles.section(title_text, align=align)
title_text.style.css.margin_top = 0
row[i].add(title_text)
if k.get('children', []):
items = self.page.ui.list()
for child in k.get('children', []):
if isinstance(child, dict):
if ('target' not in child):
child['options'] = {'target': dfl_options['target']}
else:
child['options'] = {'target': child['target']}
del child['target']
link = self.page.ui.link(**child)
link.style.css.white_space = 'nowrap'
li = self.page.ui.lists.item(link)
items.add(li)
else:
li = self.page.ui.lists.item(child)
items.add(li)
row[i].add(items)
html.Html.set_component_skin(row)
return row
def icons(self, data: List[Union[(str, dict)]]=None, width=(100, '%'), height: Union[(tuple, int)]=(None, 'px'), align: str='center', options: dict=None, profile: Union[(bool, dict)]=False):
dfl_options = {'margin-right': 5}
if (options is not None):
dfl_options.update(options)
div = self.page.ui.div(width=width, height=height, align=align, options=options, profile=profile)
div.style.css.text_align = 'right'
icons = []
if data:
for d in data:
if isinstance(d, dict):
if ('width' not in d):
d['width'] = (15, 'px')
if ('options' not in d):
d['options'] = {}
if ('icon_family' not in d['options']):
d['options']['icon_family'] = dfl_options.get('icon_family', self.page.icons.family)
icons.append(self.page.ui.icons.fluent(**d))
else:
icons.append(self.page.ui.icons.fluent(icon=d, text='', width=(15, 'px'), options={'icon_family': dfl_options.get('icon_family', self.page.icons.family)}))
icons[(- 1)].style.css.margin = ('0 %spx 0 0' % dfl_options['margin-right'])
div.add(icons[(- 1)])
html.Html.set_component_skin(div)
div.icons = icons
return div
def buttons(self, data: list=None, color: str=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(None, 'px'), html_code: str=None, helper: str=None, options: dict=None, profile: Union[(bool, dict)]=None):
width = Arguments.size(width, unit='%')
height = Arguments.size(height, unit='px')
dfl_button_css = {'button_css': {'border-radius': 0, 'border': '0px solid black'}}
options = (options or {})
dfl_button_css.update(options)
component = html.HtmlButton.Buttons(self.page, (data or []), color, width, height, html_code, helper, dfl_button_css, profile)
component.css({'border': ('1px solid %s' % component.page.theme.greys[4]), 'padding': '2px'})
html.Html.set_component_skin(component)
return component
def images(self, data: list=None, path: str=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(None, 'px'), align: str='center', options: dict=None, profile: Union[(bool, dict)]=False):
dfl_options = {'margin-left': 20, 'margin-right': 20, 'image-width': 50}
if (options is not None):
dfl_options.update(options)
div = self.page.ui.div(width=width, height=height, align=align, options=options, profile=profile)
if (data is not None):
for d in data:
img_attrs = {'width': (dfl_options['image-width'], 'px')}
if (not isinstance(d, dict)):
img_attrs['image'] = d
else:
img_attrs.update(d)
if (path is not None):
img_attrs['path'] = path
url = None
if ('url' in img_attrs):
url = img_attrs['url']
del img_attrs['url']
img = self.page.ui.img(**img_attrs)
if (url is not None):
img.goto(url)
img.style.css.display = 'inline-block'
div.add(img)
div[(- 1)].style.css.margin_right = dfl_options['margin-right']
html.Html.set_component_skin(div)
return div
def right(self, data=None, color: str=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(30, 'px'), html_code: str=None, helper: str=None, options: dict=None, profile: Union[(bool, dict)]=None):
width = Arguments.size(width, unit='%')
height = Arguments.size(height, unit='px')
dfl_options = {'tab_width': 100}
if (options is not None):
dfl_options.update(options)
(titles, panels) = ([], [])
for k in data:
if (not isinstance(k, dict)):
k = {'value': k}
titles.append(self.page.ui.text(k['value'], width=(dfl_options['tab_width'], 'px'), align='center'))
children = k.get('children', [])
col = self.page.ui.div(width=(dfl_options['tab_width'], 'px'))
col.style.css.display = None
col.style.css.bottom = height[0]
col.style.css.padding = '0 2px'
col.style.css.background = self.page.theme.greys[1]
col.style.css.position = 'absolute'
if children:
items = []
for c in children:
if hasattr(c, 'options'):
items.append(c)
else:
if (not isinstance(c, dict)):
c = {'value': c}
link = self.page.ui.link(*c)
items.append(link)
col.add(items)
panels.append(col)
html_list = html.HtmlList.List(self.page, [], color, width, height, html_code, helper, (options or {}), profile)
html_list.css({'list-style': 'none'})
html_div = self.page.ui.div()
html_div.style.css.background = self.page.theme.greys[0]
html_div.css({'position': 'fixed', 'margin': 0, 'left': 0})
html_div.style.css.bottom = 0
html_div.panels = panels
html_div.titles = titles
for (i, t) in enumerate(titles):
cont = self.page.ui.table([panels[i], t], width=('auto', ''))
cont.mouse([panels[i].dom.show().r], [panels[i].dom.hide().r])
html_div.add(cont)
html_div.style.css.line_height = height[0]
if (self.page.body.style.css.padding_bottom is not None):
self.page.body.style.css.padding_bottom = ((int(self.page.body.style.css.padding_bottom[:(- 2)]) + height[0]) + 5)
else:
self.page.body.style.css.padding_bottom = (height[0] + 5)
html.Html.set_component_skin(html_div)
return html_div
def divisor(self, data, divider: bool=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(None, 'px'), options: dict=None, profile: Union[(bool, dict)]=False):
if (divider is None):
divider = self.page.symbols.shapes.BLACK_RIGHT_POINTING_TRIANGLE
div = self.page.ui.div(width=width, height=height, options=options, profile=profile)
div.texts = []
for rec in data[:(- 1)]:
if (not isinstance(rec, dict)):
rec = {'text': rec}
div.texts.append(self.page.ui.link(*rec).css({'display': 'inline-block'}))
div += div.texts[(- 1)]
div += self.page.ui.text(divider).css({'display': 'inline-block', 'margin': '0 5px', 'font-size': self.page.body.style.globals.font.normal((- 2))})
rec = ({'text': data[(- 1)]} if (not isinstance(data[(- 1)], dict)) else data[(- 1)])
div += self.page.ui.link(*rec).css({'display': 'inline-block'})
html.Html.set_component_skin(div)
return div
def button(self, value, components: Union[(html.Html.Html, List[html.Html.Html])], symbol: str=None, width: Union[(tuple, int)]=('auto', ''), height: Union[(tuple, int)]=(None, 'px'), options: dict=None, profile: Union[(bool, dict)]=False):
div = self.page.ui.div(width=width, height=height, options=options, profile=profile)
div.items = (components if isinstance(components, list) else [components])
content = self.page.ui.div(div.items, width=('auto', ''))
content.style.css.display = None
content.style.css.padding = 5
content.style.css.background = self.page.theme.greys[0]
content.style.css.z_index = 5
content.style.css.position = 'absolute'
if (symbol is None):
symbol = self.page.symbols.shapes.BLACK_DOWN_POINTING_SMALL_TRIANGLE
but = self.page.ui.button(('%s %s' % (value, symbol)), width=width, profile=profile)
div += but
div += content
div.on('mouseover', [content.dom.css({'display': 'block'}).r])
div.on('mouseout', [content.dom.css({'display': 'none'}).r])
html.Html.set_component_skin(div)
return div
def toolbar(self, data: list=None, width: Union[(tuple, int)]=('auto', ''), height: Union[(tuple, int)]=(None, 'px'), options: dict=None, profile: Union[(bool, dict)]=False):
options = (options or {})
div = self.page.ui.div(width=width, height=height, options=options, profile=profile)
div.style.css.background = self.page.theme.greys[1]
div.style.css.margin = '2px 0 0 0'
if (data is not None):
for d in data:
div += self.page.ui.images.badge(icon=d, text='', width=(15, 'px'), options={'badge_position': 'right', 'icon_family': options.get('icon_family')})
div.style.css.padding = '0 2px 2px 2px'
div[(- 1)].style.clear(no_default=True)
div[(- 1)].attr['class'].add('badge')
div[(- 1)].style.css.width = 25
div[(- 1)].style.css.padding = 0
div[(- 1)].style.css.height = False
div[(- 1)].style.css.text_align = 'center'
div[(- 1)].style.css.cursor = 'pointer'
div[(- 1)].style.css.margin = 0
div[(- 1)].icon.style.css.float = None
html.Html.set_component_skin(div)
return div
def selections(self, data, width=(150, 'px'), height=('auto', ''), html_code: str=None, helper: str=None, options: dict=None, profile: Union[(bool, dict)]=None):
width = Arguments.size(width, unit='px')
height = Arguments.size(height, unit='px')
new_data = []
for d in data:
if (not isinstance(d, dict)):
new_data.append({'value': d})
else:
new_data.append(d)
html_pr = html.HtmlEvent.Menu(self.page, new_data, width, height, helper, (options or {}), html_code, profile)
html.Html.set_component_skin(html_pr)
return html_pr
def contextual(self, record: list=None, width: Union[(tuple, int)]=(None, '%'), height: Union[(tuple, int)]=(None, 'px'), html_code: str=None, visible: bool=False, options: dict=None, profile: Union[(bool, dict)]=None):
width = Arguments.size(width, unit='%')
height = Arguments.size(height, unit='px')
html_menu = html.HtmlMenu.ContextMenu(self.page, (record or []), width, height, visible, html_code, (options or {}), profile)
html.Html.set_component_skin(html_menu)
return html_menu
def pills(self, data: List=None, width: Union[(tuple, int)]=(100, '%'), height: Union[(tuple, int)]=(50, 'px'), html_code: str=None, helper: str=None, options: dict=None, profile: Union[(bool, dict)]=False):
container = self.page.ui.div(width=width, height=height, html_code=html_code, options=options, helper=helper, profile=profile)
if (data is not None):
for d in data:
pill = self.page.ui.div(d, width=('auto', ''))
pill.style.css.border = ('1px solid %s' % self.page.theme.greys[4])
pill.style.css.border_radius = 10
pill.style.css.cursor = 'pointer'
pill.style.css.padding = '2px 10px'
pill.style.css.margin_right = 5
pill.style.add_classes.div.color_hover()
container.add(pill)
container.style.css.overflow_x = 'auto'
container.style.css.white_space = 'nowrap'
container.style.css.display = 'inline-block'
container.style.css.margin_top = 10
container.style.css.margin_bottom = 10
html.Html.set_component_skin(container)
return container |
class Test_loopback_reply(unittest.TestCase):
def setUp(self):
self.md_lv = 1
self.version = 1
self.opcode = cfm.CFM_LOOPBACK_REPLY
self.flags = 0
self.first_tlv_offset = cfm.loopback_reply._TLV_OFFSET
self.transaction_id = 12345
self.tlvs = []
self.end_tlv = 0
self.ins = cfm.loopback_reply(self.md_lv, self.version, self.transaction_id, self.tlvs)
self.form = '!4BIB'
self.buf = struct.pack(self.form, ((self.md_lv << 5) | self.version), self.opcode, self.flags, self.first_tlv_offset, self.transaction_id, self.end_tlv)
def tearDown(self):
pass
def test_init(self):
eq_(self.md_lv, self.ins.md_lv)
eq_(self.version, self.ins.version)
eq_(self.transaction_id, self.ins.transaction_id)
eq_(self.tlvs, self.ins.tlvs)
def test_parser(self):
_res = cfm.loopback_reply.parser(self.buf)
if (type(_res) is tuple):
res = _res[0]
else:
res = _res
eq_(self.md_lv, res.md_lv)
eq_(self.version, res.version)
eq_(self.transaction_id, res.transaction_id)
eq_(self.tlvs, res.tlvs)
def test_serialize(self):
buf = self.ins.serialize()
res = struct.unpack_from(self.form, six.binary_type(buf))
eq_(self.md_lv, (res[0] >> 5))
eq_(self.version, (res[0] & 31))
eq_(self.opcode, res[1])
eq_(self.flags, res[2])
eq_(self.first_tlv_offset, res[3])
eq_(self.transaction_id, res[4])
eq_(self.end_tlv, res[5])
def test_len(self):
eq_(9, len(self.ins))
def test_default_args(self):
ins = cfm.loopback_reply()
buf = ins.serialize()
res = struct.unpack_from(cfm.loopback_reply._PACK_STR, six.binary_type(buf))
eq_((res[0] >> 5), 0)
eq_((res[0] & 31), 0)
eq_(res[1], 2)
eq_(res[2], 0)
eq_(res[3], 4)
eq_(res[4], 0) |
class Header():
parent_hash: Hash32
ommers_hash: Hash32
coinbase: Bytes20
state_root: Hash32
transactions_root: Hash32
receipt_root: Hash32
bloom: Bytes256
difficulty: Uint
number: Uint
gas_limit: Uint
gas_used: Uint
timestamp: U256
extra_data: Bytes
mix_digest: Bytes32
nonce: Bytes8
base_fee_per_gas: Optional[Uint]
withdrawals_root: Optional[Hash32]
def __init__(self, options: Any, body: Body, stdin: Any=None):
if (options.input_header == 'stdin'):
assert (stdin is not None)
data = stdin['header']
else:
with open(options.input_header) as f:
data = json.load(f)
self.parent_hash = Hash32(hex_to_bytes(data['parentHash']))
try:
self.ommers_hash = Hash32(hex_to_bytes(data['ommersHash']))
except KeyError:
self.ommers_hash = keccak256(rlp.encode(body.ommers))
self.coinbase = Bytes20(hex_to_bytes(data.get('miner', DEFAULT_COINBASE)))
self.state_root = Hash32(hex_to_bytes(data['stateRoot']))
self.transactions_root = Hash32(hex_to_bytes(data.get('transactionsRoot', DEFAULT_TRIE_ROOT)))
self.receipt_root = Hash32(hex_to_bytes(data.get('receiptsRoot', DEFAULT_TRIE_ROOT)))
self.bloom = Bytes256(hex_to_bytes(data['logsBloom']))
self.difficulty = parse_hex_or_int(data.get('difficulty', 0), Uint)
self.number = parse_hex_or_int(data['number'], Uint)
self.gas_limit = parse_hex_or_int(data['gasLimit'], Uint)
self.gas_used = parse_hex_or_int(data['gasUsed'], Uint)
self.timestamp = parse_hex_or_int(data['timestamp'], U256)
self.extra_data = hex_to_bytes(data.get('extraData', '0x'))
self.mix_digest = Bytes32(hex_to_bytes(data['mixHash']))
self.nonce = hex_to_bytes8(data.get('nonce', '0x'))
try:
self.base_fee_per_gas = parse_hex_or_int(data['baseFeePerGas'], Uint)
except KeyError:
self.base_fee_per_gas = None
try:
self.withdrawals_root = Hash32(hex_to_bytes(data['withdrawalsRoot']))
if (self.base_fee_per_gas is None):
self.base_fee_per_gas = Uint(0)
except KeyError:
self.withdrawals_root = None |
class UrlComponentCatalogConnector(ComponentCatalogConnector):
REQUEST_TIMEOUT = 30
def get_catalog_entries(self, catalog_metadata: Dict[(str, Any)]) -> List[Dict[(str, Any)]]:
return [{'url': url} for url in catalog_metadata.get('paths')]
def get_entry_data(self, catalog_entry_data: Dict[(str, Any)], catalog_metadata: Dict[(str, Any)]) -> Optional[EntryData]:
url = catalog_entry_data.get('url')
pr = urlparse(url)
auth = None
if (pr.scheme != 'file'):
auth_id = catalog_metadata.get('auth_id')
auth_password = catalog_metadata.get('auth_password')
if (auth_id and auth_password):
auth = HTTPBasicAuth(auth_id, auth_password)
elif (auth_id or auth_password):
self.log.error(f"Error. URL catalog connector '{catalog_metadata.get('display_name')}' is not configured properly. Authentication requires a user id and password or API key.")
return None
try:
requests_session = Session()
if (pr.scheme == 'file'):
requests_session.mount('file://', FileTransportAdapter())
res = requests_session.get(url, timeout=UrlComponentCatalogConnector.REQUEST_TIMEOUT, allow_redirects=True, auth=auth, verify=get_verify_parm())
except Exception as e:
self.log.error(f"Error. The URL catalog connector '{catalog_metadata.get('display_name')}' encountered an issue downloading '{url}': {e} ")
else:
if (res.status_code != HTTPStatus.OK):
self.log.error(f"Error. The URL catalog connector '{catalog_metadata.get('display_name')}' encountered an issue downloading '{url}'. HTTP response code: {res.status_code}")
else:
return EntryData(definition=res.text)
return None
def get_hash_keys(cls) -> List[Any]:
return ['url'] |
def _mock_gcp_resource_iter(resource_type):
resource = Resource(cai_resource_name=resource_type.get('resource').get('cai_resource_name'), cai_resource_type=resource_type.get('resource').get('cai_resource_type'), full_name=resource_type.get('resource').get('full_name'), type_name=resource_type.get('resource').get('type_name'), data=resource_type.get('resource').get('data'))
return resource |
def test_staticfiles_config_check_occurs_only_once(tmpdir, test_client_factory):
app = StaticFiles(directory=tmpdir)
client = test_client_factory(app)
assert (not app.config_checked)
with pytest.raises(HTTPException):
client.get('/')
assert app.config_checked
with pytest.raises(HTTPException):
client.get('/') |
class Solution():
def longestOnes(self, nums: List[int], K: int) -> int:
mmax = 0
start = 0
zeros = 0
for (i, n) in enumerate(nums):
if (n == 1):
mmax = max(mmax, ((i - start) + 1))
else:
zeros += 1
while (zeros > K):
if (nums[start] == 0):
zeros -= 1
start += 1
mmax = max(mmax, ((i - start) + 1))
return max(mmax, (len(nums) - start)) |
def extractDeeyosarecommendationWordpressCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('demonssweetheart', "demon's sweetheart", 'translated'), ("demon's sweetheart", "demon's sweetheart", 'translated'), ('fylmt', 'fortunately, you like me too', 'translated'), ('fortunately, you like me too', 'fortunately, you like me too', 'translated'), ('bnddsb', "brother next door, don't sleep on my bed", 'translated'), ("brother next door, don't sleep on my bed", "brother next door, don't sleep on my bed", 'translated'), ('sdwz', 'splendid dream of wanzhou', 'translated'), ('splendid dream of wanzhou', 'splendid dream of wanzhou', 'translated'), ('wife became a minor before divorce', 'wife became a minor before divorce', 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
def collate_fn_mspecNquant(batch):
r = hparams.outputs_per_step
seq_len = 4
max_offsets = [(x[1].shape[0] - seq_len) for x in batch]
mel_lengths = [x[1].shape[0] for x in batch]
mel_offsets = [np.random.randint(0, offset) for offset in max_offsets]
sig_offsets = [int((((offset * hparams.frame_shift_ms) * hparams.sample_rate) / 1000)) for offset in mel_offsets]
sig_lengths = [x[0]['coarse'].shape[0] for x in batch]
sig_length = int((((seq_len * hparams.frame_shift_ms) * hparams.sample_rate) / 1000))
coarse_clean = [x[0]['coarse'] for x in batch]
fine_clean = [x[0]['fine'] for x in batch]
coarse_float_clean = [x[0]['coarse_float'] for x in batch]
fine_float_clean = [x[0]['fine_float'] for x in batch]
mels_noisy = torch.FloatTensor([x[1][mel_offsets[i]:(mel_offsets[i] + seq_len)] for (i, x) in enumerate(batch)])
coarse_clean = torch.LongTensor([x[sig_offsets[i]:int((sig_offsets[i] + sig_length))] for (i, x) in enumerate(coarse_clean)])
fine_clean = torch.LongTensor([x[sig_offsets[i]:int((sig_offsets[i] + sig_length))] for (i, x) in enumerate(fine_clean)])
coarse_float_clean = torch.FloatTensor([x[sig_offsets[i]:int((sig_offsets[i] + sig_length))] for (i, x) in enumerate(coarse_float_clean)])
fine_float_clean = torch.FloatTensor([x[sig_offsets[i]:int((sig_offsets[i] + sig_length))] for (i, x) in enumerate(fine_float_clean)])
quants = {}
quants['coarse'] = coarse_clean
quants['fine'] = fine_clean
quants['coarse_float'] = coarse_float_clean
quants['fine_float'] = fine_float_clean
return (mels_noisy, quants) |
def serve_udp(engine=None, port=9007, logto=sys.stdout):
from mayavi import mlab
e = (engine or mlab.get_engine())
proto = M2UDP()
proto.engine = e
proto.scene = e.current_scene.scene
proto.mlab = mlab
if (logto is not None):
log.startLogging(logto)
log.msg('Serving Mayavi2 UDP server on port', port)
log.msg('Using Engine', e)
reactor.registerWxApp(wx.GetApp())
reactor.listenUDP(port, proto)
reactor.run() |
def get_one_column_drift(*, current_feature_data: SparkSeries, reference_feature_data: SparkSeries, datetime_column: Optional[str], column: ColumnName, options: DataDriftOptions, data_definition: DataDefinition, column_type: ColumnType) -> ColumnDataDriftMetrics:
if (column_type not in (ColumnType.Numerical, ColumnType.Categorical, ColumnType.Text)):
raise ValueError(f"Cannot calculate drift metric for column '{column}' with type {column_type}")
target = data_definition.get_target_column()
stattest = None
threshold = None
if column.is_main_dataset():
if (target and (column.name == target.column_name) and (column_type == ColumnType.Numerical)):
stattest = options.num_target_stattest_func
elif (target and (column.name == target.column_name) and (column_type == ColumnType.Categorical)):
stattest = options.cat_target_stattest_func
if (not stattest):
stattest = options.get_feature_stattest_func(column.name, column_type.value)
threshold = options.get_threshold(column.name, column_type.value)
current_column = current_feature_data
reference_column = reference_feature_data
reference_column = reference_column.replace([(- np.inf), np.inf], np.nan).dropna(subset=[column.name])
if reference_column.rdd.isEmpty():
raise ValueError(f"An empty column '{column.name}' was provided for drift calculation in the reference dataset.")
current_column = current_column.replace([(- np.inf), np.inf], np.nan).dropna(subset=[column.name])
if current_column.rdd.isEmpty():
raise ValueError(f"An empty column '{column.name}' was provided for drift calculation in the current dataset.")
current_distribution = None
reference_distribution = None
current_small_distribution = None
reference_small_distribution = None
current_correlations = None
reference_correlations = None
typical_examples_cur = None
typical_examples_ref = None
typical_words_cur = None
typical_words_ref = None
if (column_type == ColumnType.Numerical):
if (not is_numeric_column_dtype(reference_column, column)):
raise ValueError(f"Column '{column}' in reference dataset should contain numerical values only.")
if (not is_numeric_column_dtype(current_column, column)):
raise ValueError(f"Column '{column}' in current dataset should contain numerical values only.")
drift_test_function = get_stattest(reference_column, current_column, column_type.value, stattest)
drift_result = drift_test_function(reference_column, current_column, column_type, threshold, engine=SparkEngine, column_name=column.name)
scatter: Optional[Union[(ScatterField, ScatterAggField)]] = None
if (column_type == ColumnType.Numerical):
current_nbinsx = options.get_nbinsx(column.name)
current_small_distribution = get_histogram(current_column, column.name, current_nbinsx, density=True)
reference_small_distribution = get_histogram(reference_column, column.name, current_nbinsx, density=True)
current_scatter = {}
(df, prefix) = prepare_df_for_time_index_plot(current_column, column.name, datetime_column)
current_scatter['current (mean)'] = df
if (prefix is None):
x_name = 'Index binned'
else:
x_name = f'Timestamp ({prefix})'
plot_shape = {}
(reference_mean, reference_std) = calculate_stats(reference_column, column.name, sf.mean, sf.stddev)
plot_shape['y0'] = (reference_mean - reference_std)
plot_shape['y1'] = (reference_mean + reference_std)
scatter = ScatterAggField(scatter=current_scatter, x_name=x_name, plot_shape=plot_shape)
elif (column_type == ColumnType.Categorical):
current_vc = value_counts(current_column, column.name)
reference_vc = value_counts(reference_column, column.name)
keys = np.array(list(set(current_vc.keys()).union(reference_vc.keys())))
current_small_distribution = ([current_vc.get(k, 0) for k in keys], keys)
reference_small_distribution = ([reference_vc.get(k, 0) for k in keys], keys)
if (column_type != ColumnType.Text):
(current_distribution, reference_distribution) = get_distribution_for_column(column_type=column_type, column_name=column.name, current=current_column, reference=reference_column)
if (reference_distribution is None):
raise ValueError(f"Cannot calculate reference distribution for column '{column}'.")
elif ((column_type == ColumnType.Text) and drift_result.drifted):
(typical_examples_cur, typical_examples_ref, typical_words_cur, typical_words_ref) = get_text_data_for_plots(reference_column, current_column, column.name)
metrics = ColumnDataDriftMetrics(column_name=column.display_name, column_type=column_type.value, stattest_name=drift_test_function.display_name, drift_score=drift_result.drift_score, drift_detected=drift_result.drifted, stattest_threshold=drift_result.actual_threshold, current=DriftStatsField(distribution=current_distribution, small_distribution=(DistributionIncluded(x=current_small_distribution[1].tolist(), y=current_small_distribution[0]) if current_small_distribution else None), correlations=current_correlations, characteristic_examples=typical_examples_cur, characteristic_words=typical_words_cur), reference=DriftStatsField(distribution=reference_distribution, small_distribution=(DistributionIncluded(x=reference_small_distribution[1].tolist(), y=reference_small_distribution[0]) if reference_small_distribution else None), characteristic_examples=typical_examples_ref, characteristic_words=typical_words_ref, correlations=reference_correlations), scatter=scatter)
return metrics |
def extractWuxiadreamCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('Douluo Continent 2.5 - Legend of The Divine Realm', 'Douluo Continent 2.5 - Legend of The Divine Realm', 'translated'), ("The Legend of Eternal Night's Sovereign", "The Legend of Eternal Night's Sovereign", 'translated'), ('Ghost: "Catch the ghost!"', 'Ghost: "Catch the ghost!"', 'translated'), ('Repugnant Gateway', 'Repugnant Gateway', 'translated'), ("The Master's Legend", "The Master's Legend", 'translated'), ('Douluo Continent', 'Douluo Continent', 'translated'), ('God of Slaughter', 'God of Slaughter', 'translated'), ('Card Disciple', 'Card Disciple', 'translated'), ('King of Myriad Domain', 'King of Myriad Domain', 'translated'), ('Imperial God Emperor', 'Imperial God Emperor', 'translated'), ('Monarch of Eternal Night', 'Monarch of Eternal Night', 'translated'), ("Eternal Night's Sovereign", "Eternal Night's Sovereign", 'translated')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
.parametrize('argument, expected_param_name, default_value, param_type, expected_param_type, description', [('--option', 'option', 'value', str, 'str', 'An option argument'), ('-option', 'option', 'value', str, 'str', 'An option argument'), ('--num-gpu', 'num_gpu', 1, int, 'int', 'Number of GPUS'), ('--num_gpu', 'num_gpu', 1, int, 'int', 'Number of GPUS')])
def test_extract_parameter_details_option_argument(argument, expected_param_name, default_value, param_type, expected_param_type, description):
parser = create_parser()
parser.add_argument(argument, default=default_value, type=param_type, help=description)
descriptions = _extract_parameter_details(parser)
assert (len(descriptions) == 1)
desc = descriptions[0]
assert (desc.param_name == expected_param_name)
assert (desc.param_type == expected_param_type)
assert (desc.default_value == default_value)
assert (desc.description == description)
assert (desc.required == False)
assert (desc.valid_values is None) |
class OptionPlotoptionsBoxplotSonificationTracksMappingHighpassFrequency(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
.parametrize('app,expectation', [(app, pytest.raises(MultiPartException)), (Starlette(routes=[Mount('/', app=app)]), does_not_raise())])
def test_missing_boundary_parameter(app, expectation, test_client_factory) -> None:
client = test_client_factory(app)
with expectation:
res = client.post('/', data=b'Content-Disposition: form-data; name="file"; filename="\xe6\x96\x87\xe6\x9b\xb8.txt"\r\nContent-Type: text/plain\r\n\r\n<file content>\r\n', headers={'Content-Type': 'multipart/form-data; charset=utf-8'})
assert (res.status_code == 400)
assert (res.text == 'Missing boundary in multipart.') |
def _setup_teb_x64(uc: Uc, process_info: ProcessController) -> None:
MSG_IA32_GS_BASE =
teb_addr =
peb_addr =
uc.mem_map(teb_addr, process_info.page_size, (UC_PROT_READ | UC_PROT_WRITE))
uc.mem_map(peb_addr, process_info.page_size, (UC_PROT_READ | UC_PROT_WRITE))
uc.mem_write((teb_addr + 48), struct.pack(pointer_size_to_fmt(8), teb_addr))
uc.mem_write((teb_addr + 96), struct.pack(pointer_size_to_fmt(8), peb_addr))
uc.reg_write(UC_X86_REG_MSR, (MSG_IA32_GS_BASE, teb_addr)) |
def lab_to_xyz(lab: Vector, white: VectorLike) -> Vector:
(l, a, b) = lab
fy = ((l + 16) / 116)
fx = ((a / 500) + fy)
fz = (fy - (b / 200))
xyz = [((fx ** 3) if (fx > EPSILON3) else (((116 * fx) - 16) / KAPPA)), ((fy ** 3) if (l > KE) else (l / KAPPA)), ((fz ** 3) if (fz > EPSILON3) else (((116 * fz) - 16) / KAPPA))]
return alg.multiply(xyz, white, dims=alg.D1) |
def test_Image(base):
with pytest.raises(EtypeCastError):
Etype.Image(base.id, ['/tmp/notafile.txt'])
with pytest.raises(EtypeCastError):
Etype.Image(base.id, ['/tmp/nonexistent_image.png'])
with pytest.raises(EtypeCastError):
Etype.Image(base.id, [base.im1, base.im2])
im1 = Etype.Image(base.id, base.im1)
assert (len(im1.paths) == 1)
im1 = Etype.Image(base.id, [base.im1])
assert (len(im1.paths) == 1)
im2 = Etype.Image(base.id, base.im2)
assert (len(im1.paths) == 1)
im1_filtered = Etype.Image(base.id, [base.im1, base.txt1])
assert (len(im1.paths) == 1)
assert (im1.paths[0] == base.im1) |
.filterwarnings('ignore:Call to deprecated function compile_uri_template')
class TestUriTemplates():
.parametrize('value', (42, falcon.App))
def test_string_type_required(self, value):
with pytest.raises(TypeError):
routing.compile_uri_template(value)
.parametrize('value', ('this', 'this/that'))
def test_template_must_start_with_slash(self, value):
with pytest.raises(ValueError):
routing.compile_uri_template(value)
.parametrize('value', ('//', 'a//', '//b', 'a//b', 'a/b//', 'a/b//c'))
def test_template_may_not_contain_double_slash(self, value):
with pytest.raises(ValueError):
routing.compile_uri_template(value)
def test_root(self):
(fields, pattern) = routing.compile_uri_template('/')
assert (not fields)
assert (not pattern.match('/x'))
result = pattern.match('/')
assert result
assert (not result.groupdict())
.parametrize('path', ('/hello', '/hello/world', '/hi/there/how/are/you'))
def test_no_fields(self, path):
(fields, pattern) = routing.compile_uri_template(path)
assert (not fields)
assert (not pattern.match(path[:(- 1)]))
result = pattern.match(path)
assert result
assert (not result.groupdict())
def test_one_field(self):
(fields, pattern) = routing.compile_uri_template('/{name}')
assert (fields == {'name'})
result = pattern.match('/Kelsier')
assert result
assert (result.groupdict() == {'name': 'Kelsier'})
(fields, pattern) = routing.compile_uri_template('/character/{name}')
assert (fields == {'name'})
result = pattern.match('/character/Kelsier')
assert result
assert (result.groupdict() == {'name': 'Kelsier'})
(fields, pattern) = routing.compile_uri_template('/character/{name}/profile')
assert (fields == {'name'})
assert (not pattern.match('/character'))
assert (not pattern.match('/character/Kelsier'))
assert (not pattern.match('/character/Kelsier/'))
result = pattern.match('/character/Kelsier/profile')
assert result
assert (result.groupdict() == {'name': 'Kelsier'})
def test_one_field_with_digits(self):
(fields, pattern) = routing.compile_uri_template('/{name123}')
assert (fields == {'name123'})
result = pattern.match('/Kelsier')
assert result
assert (result.groupdict() == {'name123': 'Kelsier'})
def test_one_field_with_prefixed_digits(self):
(fields, pattern) = routing.compile_uri_template('/{37signals}')
assert (fields == set())
result = pattern.match('/s2n')
assert (not result)
.parametrize('postfix', ('', '/'))
def test_two_fields(self, postfix):
path = ('/book/{book_id}/characters/{n4m3}' + postfix)
(fields, pattern) = routing.compile_uri_template(path)
assert (fields == {'n4m3', 'book_id'})
result = pattern.match('/book//characters/Vin')
assert result
assert (result.groupdict() == {'n4m3': 'Vin', 'book_id': ''})
def test_three_fields(self):
(fields, pattern) = routing.compile_uri_template('/{a}/{b}/x/{c}')
assert (fields == set('abc'))
result = pattern.match('/one/2/x/3')
assert result
assert (result.groupdict() == {'a': 'one', 'b': '2', 'c': '3'})
def test_malformed_field(self):
(fields, pattern) = routing.compile_uri_template('/{a}/{1b}/x/{c}')
assert (fields == set('ac'))
result = pattern.match('/one/{1b}/x/3')
assert result
assert (result.groupdict() == {'a': 'one', 'c': '3'})
def test_deprecated_warning(self):
with pytest.warns(DeprecatedWarning, match='Call to deprecated function compile_uri_template().'):
routing.compile_uri_template('/') |
def test_dt_evaluation(dummy_titanic_dt, dummy_titanic):
model = dummy_titanic_dt
(X_train, y_train, X_test, y_test) = dummy_titanic
pred_train = model.predict(X_train)
pred_train_binary = np.round(pred_train)
acc_train = accuracy_score(y_train, pred_train_binary)
auc_train = roc_auc_score(y_train, pred_train)
assert (acc_train > 0.85), 'Accuracy on train should be > 0.85'
assert (auc_train > 0.9), 'AUC ROC on train should be > 0.90'
pred_test = model.predict(X_test)
pred_test_binary = np.round(pred_test)
acc_test = accuracy_score(y_test, pred_test_binary)
auc_test = roc_auc_score(y_test, pred_test)
assert (acc_test > 0.82), 'Accuracy on test should be > 0.82'
assert (auc_test > 0.84), 'AUC ROC on test should be > 0.84' |
class BasicErrorSelector(Selector):
out_etype = Etype.Any
def __init__(self, *args):
super().__init__(*args)
self.retryCount = 0
def index(self, config) -> LocalElementsIndex:
error = (config['error'] if ('error' in config) else '')
if (error == 'index'):
raise SelectorIndexError('test')
else:
elements = ['skip', 'retry3', 'retryN', 'pass']
return LocalElementsIndex(rows=scaffold_elementmap(elements))
def retrieve_element(self, element, config) -> LocalElement:
if (element.id == 'skip'):
raise ElementShouldSkipError('test')
elif ((element.id == 'retry3') and (self.retryCount < 3)):
self.retryCount += 1
raise ElementShouldRetryError('test')
elif (element.id == 'retryN'):
raise ElementShouldRetryError('test')
else:
return None |
class Person(HasTraits):
first_name = Str()
last_name = Str()
age = Range(0, 120)
misc = Instance(Spec)
gen_group = Group(Item(name='first_name'), Item(name='last_name'), Item(name='age'), label='General Info', show_border=True)
spec_group = Group(Group(Item(name='misc', style='custom'), show_labels=False), label='Additional Info', show_border=True)
view = View(Group(gen_group, '10', Label('Using Instances and a Handler:'), '10', spec_group), title='Personal Information', buttons=['OK'], resizable=True, width=300, handler=PersonHandler()) |
class EnumValue(EditableValue):
values = List()
format = Callable(str, update_value_type=True)
colors = Callable(None, update_value_type=True)
images = Callable(None, update_value_type=True)
def is_valid(self, model, row, column, value):
return (value in self.values)
def has_text(self, model, row, column):
return (self.format is not None)
def get_text(self, model, row, column):
return self.format(model.get_value(row, column))
def has_color(self, model, row, column):
return (self.colors is not None)
def get_color(self, model, row, column):
return self.colors(model.get_value(row, column))
def has_image(self, model, row, column):
return (self.images is not None)
def get_image(self, model, row, column):
return self.images(model.get_value(row, column)) |
def _get(namespace: Sequence[str]) -> Any:
global REGISTRY
if (not all((isinstance(name, str) for name in namespace))):
raise ValueError(f'Invalid namespace. Expected tuple of strings, but got: {namespace}')
namespace = tuple(namespace)
if (namespace not in REGISTRY):
raise RegistryError(f"Can't get namespace {namespace} (not in registry)")
return REGISTRY[namespace] |
class JsonDataset():
def __init__(self, args):
self.args = args
name = args.dataset
ds_im_dir = args.dataset_dir
ds_ann = args.dataset_ann
full_datasets = {}
if ((ds_im_dir is not None) and (ds_ann is not None)):
full_datasets[name] = {IM_DIR: ds_im_dir, ANN_FN: ds_ann}
assert (name in full_datasets.keys()), 'Unknown dataset name {}'.format(name)
logger.debug('Creating: {}'.format(name))
dataset = full_datasets[name]
logger.info('Loading dataset {}:\n{}'.format(name, dataset))
self.name = name
self.image_directory = dataset[IM_DIR]
self.image_prefix = dataset.get(IM_PREFIX, '')
self.COCO = COCO(dataset[ANN_FN])
logger.info('Dataset={}, Number of images={}'.format(name, len(self.COCO.getImgIds())))
category_ids = self.COCO.getCatIds()
categories = [c['name'] for c in self.COCO.loadCats(category_ids)]
self.category_ids = category_ids
self.category_to_id_map = dict(zip(categories, category_ids))
self.classes = (['__background__'] + categories)
self.num_classes = len(self.classes)
self.json_category_id_to_contiguous_id = {v: (i + 1) for (i, v) in enumerate(self.COCO.getCatIds())}
self.contiguous_category_id_to_json_id = {v: k for (k, v) in self.json_category_id_to_contiguous_id.items()}
def write_roidb(self):
coco = self.COCO
image_ids = self.COCO.getImgIds()
image_ids.sort()
roidb = copy.deepcopy(coco.loadImgs(image_ids))
for entry in roidb:
self._prep_roidb_entry(entry)
with open(self.args.output_file, 'w') as f:
for entry in roidb:
s = json.dumps(entry)
f.write((s + '\n'))
if self.args.output_image_file:
with open(self.args.output_image_file, 'w') as f:
for entry in roidb:
f.write((entry['image'] + '\n'))
def _prep_roidb_entry(self, entry):
entry['image'] = os.path.join(os.path.abspath(self.image_directory), (self.image_prefix + entry['file_name']))
for k in ['date_captured', 'license', 'file_name']:
if (k in entry):
del entry[k] |
def extractPrinceRevolution(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('Romance RPG', 'Romance RPG', 'translated'), ('The Legend of Sun Knight', 'The Legend of Sun Knight', 'translated'), ('Dominions End', 'Dominions End', 'translated'), ('12 Prince', '12 Prince', 'translated'), ('killvsprince', 'Kill No More VS 1/2 Prince', 'translated'), ('Illusions-Lies-Truth', 'Illusions, Lies, Truth', 'translated'), ('No Hero', 'No Hero', 'translated'), ('God', 'GOD', 'translated'), ('lsk - big and little sun go go', 'big and little sun go go', 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
def extractAllntrHomeBlog(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class Ui_OrganiserDialog(object):
def setupUi(self, OrganiserDialog):
OrganiserDialog.setObjectName('OrganiserDialog')
OrganiserDialog.resize(525, 536)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Policy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(OrganiserDialog.sizePolicy().hasHeightForWidth())
OrganiserDialog.setSizePolicy(sizePolicy)
self.verticalLayout = QVBoxLayout(OrganiserDialog)
self.verticalLayout.setObjectName('verticalLayout')
scan_path_gb = QGroupBox('1. Path of directory to scan')
scan_path_vb = QVBoxLayout()
self.scanPathLabel = QLabel(OrganiserDialog)
self.scanPathLabel.setObjectName('scanPathLabel')
self.dirPathLineEdit = QLineEdit(OrganiserDialog)
self.dirPathLineEdit.setObjectName('dirPathLineEdit')
scan_path_vb.addWidget(self.dirPathLineEdit)
scan_path_gb.setLayout(scan_path_vb)
self.verticalLayout.addWidget(scan_path_gb)
exclude_gb = QGroupBox('2. [Optional] Exclude Files and/or Folders')
exclude_vb = QVBoxLayout()
self.dirIgnoreLabel = QLabel(OrganiserDialog)
self.dirIgnoreLabel.setObjectName('dirIgnoreLabel')
exclude_vb.addWidget(self.dirIgnoreLabel)
self.gridLayout = QGridLayout()
self.gridLayout.setObjectName('gridLayout')
self.ignoreAllHiddenCheckbox = QCheckBox(OrganiserDialog)
self.ignoreAllHiddenCheckbox.setObjectName('ignoreAllHiddenCheckbox')
self.gridLayout.addWidget(self.ignoreAllHiddenCheckbox, 0, 0, 1, 1)
self.ignoreDirsRecursivelyCheckbox = QCheckBox(OrganiserDialog)
self.ignoreDirsRecursivelyCheckbox.setEnabled(True)
self.ignoreDirsRecursivelyCheckbox.setCheckable(True)
self.ignoreDirsRecursivelyCheckbox.setChecked(True)
self.ignoreDirsRecursivelyCheckbox.setObjectName('ignoreDirsRecursivelyCheckbox')
self.gridLayout.addWidget(self.ignoreDirsRecursivelyCheckbox, 0, 1, 1, 1)
exclude_vb.addLayout(self.gridLayout)
self.selectGridLayout = QGridLayout()
self.selectFilesPushButton = QPushButton('Select Files', parent=OrganiserDialog)
self.selectGridLayout.addWidget(self.selectFilesPushButton, 0, 0, 1, 1)
self.selectDirsPushButton = QPushButton('Select Directories', parent=OrganiserDialog)
self.selectGridLayout.addWidget(self.selectDirsPushButton, 0, 1, 1, 1)
exclude_vb.addLayout(self.selectGridLayout)
self.dirIgnoreLw = QListWidget(OrganiserDialog)
self.dirIgnoreLw.setObjectName('dirIgnoreLw')
exclude_vb.addWidget(self.dirIgnoreLw)
exclude_gb.setLayout(exclude_vb)
self.verticalLayout.addWidget(exclude_gb)
self.syncButton = QPushButton(OrganiserDialog)
self.syncButton.setObjectName('syncButton')
self.verticalLayout.addWidget(self.syncButton)
self.filesFoundLabel = QLabel(OrganiserDialog)
self.filesFoundLabel.setObjectName('dirIgnoreLabel')
self.verticalLayout.addWidget(self.filesFoundLabel)
self.filesFoundLw = QListWidget(OrganiserDialog)
self.filesFoundLw.setObjectName('filesFoundLw')
self.verticalLayout.addWidget(self.filesFoundLw)
self.retranslateUi(OrganiserDialog)
QMetaObject.connectSlotsByName(OrganiserDialog)
def retranslateUi(self, OrganiserDialog):
_translate = QCoreApplication.translate
OrganiserDialog.setWindowTitle(_translate('OrganiserDialog', 'External Files Anki Organiser'))
self.dirIgnoreLabel.setText(_translate('OrganiserDialog', 'Select subdirectories/files to ignore'))
self.ignoreAllHiddenCheckbox.setText(_translate('OrganiserDialog', "Ignore all directories starting with '.' in the scan"))
self.ignoreDirsRecursivelyCheckbox.setText(_translate('OrganiserDialog', 'Ignore selected directories recursively'))
self.syncButton.setText(_translate('OrganiserDialog', 'Import File Notes'))
self.filesFoundLabel.setText(_translate('OrganiserDialog', 'Files found:')) |
class ClientHandlers():
async def Handler_SpeakOnWorldRequest(player_id, request):
logging.info(f'Handler_SpeakOnWorldRequest:{player_id}, request:{request} ')
GamePlayerMgr().player_speak_on_world(player_id, request.name, request.content)
async def Handler_PlayerMoveRequest(player_id, request):
GamePlayerMgr().player_move(player_id, request)
async def Handler_PlayerJoinRoomRequest(player_id, request):
logging.info(f'Handler_PlayerJoinRoomRequest:{player_id}, request:{request} ')
GamePlayerMgr().player_join_room(player_id)
async def Handler_PlayerUpdateTransformRequest(player_id, request):
GamePlayerMgr().player_update_transform(player_id, request) |
class SimpleSliderEditor(BaseRangeEditor):
low = Any()
high = Any()
ui_changing = Bool(False)
def init(self, parent):
factory = self.factory
if (not factory.low_name):
self.low = factory.low
if (not factory.high_name):
self.high = factory.high
self.evaluate = factory.evaluate
self.sync_value(factory.evaluate_name, 'evaluate', 'from')
size = wx.DefaultSize
if (factory.label_width > 0):
size = wx.Size(factory.label_width, 20)
self.sync_value(factory.low_name, 'low', 'from')
self.sync_value(factory.high_name, 'high', 'from')
self.control = panel = TraitsUIPanel(parent, (- 1))
sizer = wx.BoxSizer(wx.HORIZONTAL)
fvalue = self.value
if (not (self.low <= fvalue <= self.high)):
fvalue_text = ''
fvalue = self.low
else:
try:
fvalue_text = self.string_value(fvalue)
except (ValueError, TypeError) as e:
fvalue_text = ''
ivalue = self._convert_to_slider(fvalue)
self._label_lo = wx.StaticText(panel, (- 1), '999999', size=size, style=(wx.ALIGN_RIGHT | wx.ST_NO_AUTORESIZE))
sizer.Add(self._label_lo, 0, wx.ALIGN_CENTER)
panel.slider = slider = Slider(panel, (- 1), ivalue, 0, 10000, size=wx.Size(80, 20), style=(wx.SL_HORIZONTAL | wx.SL_AUTOTICKS))
slider.SetTickFreq(1000)
slider.SetValue(1)
slider.SetPageSize(1000)
slider.SetLineSize(100)
slider.Bind(wx.EVT_SCROLL, self.update_object_on_scroll)
sizer.Add(slider, 1, wx.EXPAND)
self._label_hi = wx.StaticText(panel, (- 1), '999999', size=size)
sizer.Add(self._label_hi, 0, wx.ALIGN_CENTER)
panel.text = text = wx.TextCtrl(panel, (- 1), fvalue_text, size=wx.Size(56, 20), style=wx.TE_PROCESS_ENTER)
panel.Bind(wx.EVT_TEXT_ENTER, self.update_object_on_enter, id=text.GetId())
text.Bind(wx.EVT_KILL_FOCUS, self.update_object_on_enter)
sizer.Add(text, 0, (wx.LEFT | wx.EXPAND), 4)
low_label = factory.low_label
if (factory.low_name != ''):
low_label = self.string_value(self.low)
high_label = factory.high_label
if (factory.high_name != ''):
high_label = self.string_value(self.high)
self._label_lo.SetLabel(low_label)
self._label_hi.SetLabel(high_label)
self.set_tooltip(slider)
self.set_tooltip(self._label_lo)
self.set_tooltip(self._label_hi)
self.set_tooltip(text)
panel.SetSizerAndFit(sizer)
def update_object_on_scroll(self, event):
value = self._convert_from_slider(event.GetPosition())
event_type = event.GetEventType()
if ((event_type == wxEVT_SCROLL_ENDSCROLL) or (self.factory.auto_set and (event_type == wx.wxEVT_SCROLL_THUMBTRACK)) or (self.factory.enter_set and (event_type == wx.wxEVT_SCROLL_THUMBRELEASE))):
try:
self.ui_changing = True
self.control.text.SetValue(self.string_value(value))
self.value = value
except TraitError:
pass
finally:
self.ui_changing = False
def update_object_on_enter(self, event):
if isinstance(event, wx.FocusEvent):
event.Skip()
if (self.control is None):
return
try:
try:
value = self.control.text.GetValue().strip()
if self.factory.is_float:
value = float(value)
else:
value = int(value)
except Exception as ex:
value = self.value
self.control.text.SetValue(str(value))
if (not isinstance(value, (int, float))):
return
self.value = value
if (not self.ui_changing):
self.control.slider.SetValue(self._convert_to_slider(self.value))
self.control.text.SetBackgroundColour(OKColor)
self.control.text.Refresh()
if (self._error is not None):
self._error = None
self.ui.errors -= 1
except TraitError:
pass
def error(self, excp):
if (self._error is None):
self._error = True
self.ui.errors += 1
super().error(excp)
self.set_error_state(True)
def update_editor(self):
value = self.value
try:
text = self.string_value(value)
(1 // (self.low <= value <= self.high))
except:
text = ''
value = self.low
ivalue = self._convert_to_slider(value)
self.control.text.SetValue(text)
self.control.slider.SetValue(ivalue)
def _convert_to_slider(self, value):
if (self.high > self.low):
ivalue = int(((float((value - self.low)) / (self.high - self.low)) * 10000.0))
else:
ivalue = self.low
return ivalue
def _convert_from_slider(self, ivalue):
value = (self.low + ((float(ivalue) / 10000.0) * (self.high - self.low)))
if (not self.factory.is_float):
value = int(round(value))
return value
def get_error_control(self):
return self.control.text
def _low_changed(self, low):
if (self.value < low):
if self.factory.is_float:
self.value = float(low)
else:
self.value = int(low)
if (self._label_lo is not None):
self._label_lo.SetLabel(self.string_value(low))
self.update_editor()
def _high_changed(self, high):
if (self.value > high):
if self.factory.is_float:
self.value = float(high)
else:
self.value = int(high)
if (self._label_hi is not None):
self._label_hi.SetLabel(self.string_value(high))
self.update_editor() |
class LEDBackpack():
i2c = None
__HT16K33_REGISTER_DISPLAY_SETUP = 128
__HT16K33_REGISTER_SYSTEM_SETUP = 32
__HT16K33_REGISTER_DIMMING = 224
__HT16K33_ADDRESS_KEY_DATA = 64
__HT16K33_BLINKRATE_OFF = 0
__HT16K33_BLINKRATE_2HZ = 1
__HT16K33_BLINKRATE_1HZ = 2
__HT16K33_BLINKRATE_HALFHZ = 3
__buffer = [0, 0, 0, 0, 0, 0, 0, 0]
def __init__(self, address=112, i2cbusnum=(- 1), debug=False):
self.i2c = Adafruit_I2C(address=address, busnum=i2cbusnum)
self.i2cbn = i2cbusnum
self.address = address
self.debug = debug
self.i2c.write8((self.__HT16K33_REGISTER_SYSTEM_SETUP | 1), 0)
self.setBlinkRate(self.__HT16K33_BLINKRATE_OFF)
self.setBrightness(15)
self.clear()
def setBrightness(self, brightness):
if (brightness > 15):
brightness = 15
self.i2c.write8((self.__HT16K33_REGISTER_DIMMING | brightness), 0)
def setBlinkRate(self, blinkRate):
if (blinkRate > self.__HT16K33_BLINKRATE_HALFHZ):
blinkRate = self.__HT16K33_BLINKRATE_OFF
self.i2c.write8(((self.__HT16K33_REGISTER_DISPLAY_SETUP | 1) | (blinkRate << 1)), 0)
def setBufferRow(self, row, value, update=True):
if (row > 7):
return
self.__buffer[row] = value
if update:
self.writeDisplay()
def getBufferRow(self, row):
if (row > 7):
return
return self.__buffer[row]
def getBuffer(self):
bufferCopy = copy(self.__buffer)
return bufferCopy
def writeDisplay(self):
bytes = []
for item in self.__buffer:
bytes.append((item & 255))
bytes.append(((item >> 8) & 255))
self.i2c.writeList(0, bytes)
def getKeys(self, row):
if (row > 2):
return
return self.i2c.readU16((self.__HT16K33_ADDRESS_KEY_DATA + (row * 2)))
def clear(self, update=True):
self.__buffer = [0, 0, 0, 0, 0, 0, 0, 0]
if update:
self.writeDisplay() |
def _slice_between_surfaces(this, cube, sampling, other, other_position, zrange, ndiv, mask, attrlist, mthreshold, snapxy, showprogress=False, deadtraces=True):
npcollect = []
zincr = (zrange / float(ndiv))
zcenter = this.copy()
zcenter.slice_cube(cube, sampling=sampling, mask=mask, snapxy=snapxy, deadtraces=deadtraces)
npcollect.append(zcenter.values)
mul = ((- 1) if (other_position == 'above') else 1)
progress = XTGShowProgress(ndiv, show=showprogress, leadtext='progress: ')
for idv in range(ndiv):
progress.flush(idv)
ztmp = this.copy()
ztmp.values += ((zincr * (idv + 1)) * mul)
zvalues = ztmp.values.copy()
ztmp.slice_cube(cube, sampling=sampling, mask=mask, snapxy=snapxy, deadtraces=deadtraces)
diff = (mul * (other.values - zvalues))
values = ztmp.values
values = ma.masked_where((diff < 0.0), values)
npcollect.append(values)
stacked = ma.dstack(npcollect)
del npcollect
isovalues = (mul * (other.values - this.values))
attvalues = {}
for attr in attrlist:
attvaluestmp = _attvalues(attr, stacked)
attvalues[attr] = ma.masked_where((isovalues < mthreshold), attvaluestmp)
progress.finished()
return attvalues |
class TestGetSizes(unittest.TestCase):
def test_get_sizes_with_stepfactor(self):
beginSize = 32
endSize = 1024
stepFactor = 2
correct_list = [32, 64, 128, 256, 512, 1024]
result_list = comms_utils.getSizes(beginSize, endSize, stepFactor, stepBytes=0)
self.assertEqual(len(correct_list), len(result_list))
self.assertTrue((correct_list == result_list))
def test_get_sizes_with_stepbytes(self):
beginSize = 32
endSize = 256
stepFactor = 2
stepBytes = 32
correct_list = [32, 64, 96, 128, 160, 192, 224, 256]
result_list = comms_utils.getSizes(beginSize, endSize, stepFactor, stepBytes)
self.assertEqual(len(correct_list), len(result_list))
self.assertTrue((correct_list == result_list)) |
def extractZazaTranslations(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
if ('WATTT' in item['tags']):
return buildReleaseMessageWithType(item, 'WATTT', vol, chp, frag=frag, postfix=postfix)
return False |
def _import_irap_binary_purepy(mfile, values=True):
logger.info('Enter function %s', __name__)
if mfile.memstream:
mfile.file.seek(0)
buf = mfile.file.read()
else:
with open(mfile.file, 'rb') as fhandle:
buf = fhandle.read()
hed = unpack('>3i6f3i3f10i', buf[:100])
args = {}
args['nrow'] = hed[2]
args['xori'] = hed[3]
args['yori'] = hed[5]
args['xinc'] = hed[7]
args['yinc'] = hed[8]
args['ncol'] = hed[11]
args['rotation'] = hed[12]
args['yflip'] = 1
if (args['yinc'] < 0.0):
args['yinc'] *= (- 1)
args['yflip'] = (- 1)
if (not values):
return args
stv = 100
datav = []
while True:
blockv = unpack('>i', buf[stv:(stv + 4)])[0]
stv += 4
datav.append(np.array(unpack((('>' + str(int((blockv / 4)))) + 'f'), buf[stv:(blockv + stv)])))
stv += blockv
_ = unpack('>i', buf[stv:(stv + 4)])[0]
stv += 4
if (stv == len(buf)):
break
values = np.hstack(datav)
values = np.reshape(values, (args['ncol'], args['nrow']), order='F')
values = np.array(values, order='C')
values = np.ma.masked_greater_equal(values, UNDEF_MAP_IRAPB)
args['values'] = np.ma.masked_invalid(values)
del buf
return args |
('cuda.where.func_decl')
def gen_function_decl(func_attrs: Dict[(str, Any)]) -> str:
(_, input_tensor, other_tensor) = func_attrs['args']
backend_spec = CUDASpec()
return FUNC_DECL.render(func_name=func_attrs['name'], prefix=backend_spec.prefix, index_type=backend_spec.index_type, input_tensor_is_a_const_num=input_tensor.is_a_const_num(), other_tensor_is_a_const_num=other_tensor.is_a_const_num()) |
def get_opennem_capacity_data(session: Session) -> dict[(str, Any)]:
r: Response = session.get(CAPACITY_URL)
data = r.json()
capacity_df = pd.json_normalize(data)
capacity_df = capacity_df.loc[(capacity_df['dispatch_type'] == 'GENERATOR')]
capacity_df = capacity_df.loc[(capacity_df['status.code'] == 'operating')]
capacity_df = capacity_df[['network_region', 'capacity_registered', 'fueltech.code', 'created_at']]
capacity_df = capacity_df.rename(columns={'network_region': 'zone_key', 'capacity_registered': 'value', 'fueltech.code': 'mode', 'created_at': 'datetime'})
capacity_df['datetime'] = capacity_df['datetime'].apply((lambda x: pd.to_datetime(x).replace(month=1, day=1, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)))
return capacity_df |
def SetLayer(kwargs: dict) -> OutgoingMessage:
compulsory_params = ['id', 'layer']
optional_params = []
utility.CheckKwargs(kwargs, compulsory_params)
msg = OutgoingMessage()
msg.write_int32(kwargs['id'])
msg.write_string('SetLayer')
msg.write_int32(kwargs['layer'])
return msg |
def print_adposition_stats(logfile):
print('surcface', 'left', 'poss', 'right', 'none', 'total', sep='\t', file=logfile)
for (lemma, comps) in adposition_complements.items():
totals = {'all': 0}
lefts = {'all': 0}
poss = 0
rights = {'all': 0}
nones = 0
for case in adposition_complement_cases:
totals[case] = 0
lefts[case] = 0
rights[case] = 0
if ('left' in comps):
for case in adposition_complements[lemma]['left']:
lefts['all'] += adposition_complements[lemma]['left'][case]
totals[case] += adposition_complements[lemma]['left'][case]
lefts[case] = adposition_complements[lemma]['left'][case]
if ('right' in comps):
for case in adposition_complements[lemma]['right']:
rights['all'] += adposition_complements[lemma]['right'][case]
totals[case] += adposition_complements[lemma]['right'][case]
rights[case] = adposition_complements[lemma]['right'][case]
if ('poss' in comps):
poss += adposition_complements[lemma]['poss']
if ('none' in comps):
nones += adposition_complements[lemma]['none']
totals['all'] = (((lefts['all'] + poss) + rights['all']) + nones)
print(lemma, lefts['all'], poss, rights['all'], nones, totals['all'], file=logfile, sep='\t')
print(lemma, ('%.2f %%' % ((lefts['all'] / totals['all']) * 100)), ('%.2f %%' % ((poss / totals['all']) * 100)), ('%.2f %%' % ((rights['all'] / totals['all']) * 100)), ('%.2f %%' % ((nones / totals['all']) * 100)), ('%.2f %%' % ((totals['all'] / totals['all']) * 100)), file=logfile, sep='\t')
for case in adposition_complement_cases:
if (totals[case] > 0):
print(('%s %s' % (lemma, case)), lefts[case], '', rights[case], '', totals[case], file=logfile, sep='\t')
print(('%s %s %%' % (lemma, case)), ('%.2f %%' % ((lefts[case] / totals[case]) * 100)), '', ('%.2f %%' % ((rights[case] / totals[case]) * 100)), '', ('%.2f %%' % ((totals[case] / totals[case]) * 100)), file=logfile, sep='\t') |
class GridContainerExample(HasTraits):
plot = Instance(GridPlotContainer)
traits_view = View(Item('plot', editor=ComponentEditor(), show_label=False), width=1000, height=600, resizable=True)
def _plot_default(self):
container = GridPlotContainer(shape=(2, 3), spacing=(10, 5), valign='top', bgcolor='lightgray')
x = linspace((- 5), 15.0, 100)
pd = ArrayPlotData(index=x)
for i in range(6):
data_name = 'y{}'.format(i)
pd.set_data(data_name, jn(i, x))
plot = Plot(pd)
plot.plot(('index', data_name), color=COLOR_PALETTE[i], line_width=3.0)
plot.height = (((i % 3) + 1) * 50.0)
plot.resizable = 'h'
container.add(plot)
return container |
def test_schema_migration_remove_field():
schema = {'type': 'record', 'name': 'test_schema_migration_remove_field', 'fields': [{'name': 'test', 'type': 'string'}]}
new_schema = {'type': 'record', 'name': 'test_schema_migration_remove_field', 'fields': []}
new_file = BytesIO()
records = [{'test': 'test'}]
fastavro.writer(new_file, schema, records)
new_file.seek(0)
new_reader = fastavro.reader(new_file, new_schema)
new_records = list(new_reader)
assert (new_records == [{}]) |
class Call(expr):
_fields = ('func', 'args', 'keywords', 'starargs', 'kwargs')
_attributes = ('lineno', 'col_offset')
def __init__(self, func, args=[], keywords=[], starargs=None, kwargs=None, lineno=0, col_offset=0, **ARGS):
expr.__init__(self, **ARGS)
self.func = func
self.args = list(args)
self.keywords = list(keywords)
self.starargs = starargs
self.kwargs = kwargs
self.lineno = int(lineno)
self.col_offset = int(col_offset) |
class OptionSeriesLollipopZones(Options):
def className(self):
return self._config_get(None)
def className(self, text: str):
self._config(text, js_type=False)
def color(self):
return self._config_get(None)
def color(self, text: str):
self._config(text, js_type=False)
def dashStyle(self):
return self._config_get(None)
def dashStyle(self, text: str):
self._config(text, js_type=False)
def fillColor(self):
return self._config_get(None)
def fillColor(self, text: str):
self._config(text, js_type=False) |
class GeoFieldWrapper(str):
_rule_parens = re.compile('^(\\(+)(?:.+)$')
_json_geom_map = {'POINT': 'Point', 'LINESTRING': 'LineString', 'POLYGON': 'Polygon', 'MULTIPOINT': 'MultiPoint', 'MULTILINESTRING': 'MultiLineString', 'MULTIPOLYGON': 'MultiPolygon'}
def __new__(cls, value, *args: Any, **kwargs: Any):
(geometry, raw_coords) = value.strip()[:(- 1)].split('(', 1)
rv = super().__new__(cls, value, *args, **kwargs)
coords = cls._parse_coords_block(raw_coords)
str.__setattr__(rv, '_geometry', geometry.strip())
str.__setattr__(rv, '_coordinates', coords)
return rv
def _parse_coords_block(cls, v):
groups = []
parens_match = cls._rule_parens.match(v)
parens = (parens_match.group(1) if parens_match else '')
if parens:
for element in v.split(parens):
if (not element):
continue
element = element.strip()
shift = ((- 2) if element.endswith(',') else (- 1))
groups.append(f'{parens}{element}'[1:shift])
if (not groups):
return cls._parse_coords_group(v)
return tuple((cls._parse_coords_block(group) for group in groups))
def _parse_coords_group(v):
accum = []
for element in v.split(','):
accum.append(tuple((float(v) for v in element.split(' '))))
return (tuple(accum) if (len(accum) > 1) else accum[0])
def _repr_coords(self, val=None):
val = (val or self._coordinates)
if isinstance(val[0], tuple):
accum = []
for el in val:
(inner, plevel) = self._repr_coords(el)
inner = (f'({inner})' if (not plevel) else inner)
accum.append(inner)
return (','.join(accum), False)
return (('%f %f' % val), True)
def geometry(self):
return self._geometry
def coordinates(self):
return self._coordinates
def groups(self):
if (not self._geometry.startswith('MULTI')):
return tuple()
return tuple((self.__class__(f'{self._geometry[5:]}({self._repr_coords(coords)[0]})') for coords in self._coordinates))
def __json__(self):
return {'type': self._json_geom_map[self._geometry], 'coordinates': self._coordinates} |
def YlGn(range, **traits):
_data = dict(red=[(0.0, 1.0, 1.0), (0.125, 0., 0.), (0.25, 0., 0.), (0.375, 0., 0.), (0.5, 0., 0.), (0.625, 0., 0.), (0.75, 0., 0.), (0.875, 0.0, 0.0), (1.0, 0.0, 0.0)], green=[(0.0, 1.0, 1.0), (0.125, 0., 0.), (0.25, 0., 0.), (0.375, 0., 0.), (0.5, 0., 0.), (0.625, 0., 0.), (0.75, 0., 0.), (0.875, 0., 0.), (1.0, 0., 0.)], blue=[(0.0, 0., 0.), (0.125, 0., 0.), (0.25, 0., 0.), (0.375, 0., 0.), (0.5, 0., 0.), (0.625, 0., 0.), (0.75, 0., 0.), (0.875, 0., 0.), (1.0, 0., 0.)])
return ColorMapper.from_segment_map(_data, range=range, **traits) |
def process_files(options):
mapping_dict = emaps.fastq_emoji_map
mapping_text = ''
mapping_default = ':heart_eyes:'
mapping_spacer = ' '
if options.custom:
with open(options.custom) as f:
mapping_dict = ast.literal_eval(f.read())
mapping_text = ' (custom)'
logging.info('Custom emoji map:', options.custom)
elif options.noemoji:
mapping_dict = emaps.fastq_noemoji_map
mapping_text = ' (no-emoji)'
mapping_default = ''
mapping_spacer = ''
logging.info('Use no-emoji map')
elif options.bin:
mapping_dict = emaps.fastq_emoji_map_binned
mapping_text = ' (binned)'
logging.info('Binned emoji map')
else:
logging.info('Default emoji map')
OUTPUT_OPTIONS = CASE_NEITHER
if options.html:
if options.html_escape:
OUTPUT_OPTIONS = CASE_HTML_ESCAPE
logging.info('Output mean, min, max quality per position in html (escape)')
else:
OUTPUT_OPTIONS = CASE_HTML
logging.info('Output mean, min, max quality per position in html')
elif (options.max and options.min):
OUTPUT_OPTIONS = CASE_BOTH
logging.info('Calculate max quality per position')
logging.info('Calculate min quality per position')
elif options.max:
OUTPUT_OPTIONS = CASE_MAX
logging.info('Calculate max quality per position')
elif options.min:
OUTPUT_OPTIONS = CASE_MIN
logging.info('Calculate min quality per position')
else:
OUTPUT_OPTIONS = CASE_NEITHER
if options.output:
output_file = options.output
logging.info('Redirect output to:', options.output)
else:
output_file = sys.stdout
if options.long:
read_size = options.long
logging.info('Long read support up for bp up to:', options.long)
else:
read_size = DEFAULT_READ_LENGTH
if options.scale:
print_scale(emaps.all_qualities, mapping_dict, options.bin)
if options.fastq_files:
for fastq_filename in options.fastq_files:
logging.info('Processing FASTQ file from {}'.format(fastq_filename))
try:
if fastq_filename.endswith('.gz'):
fastq_file = gzip.open(fastq_filename, 'rt')
else:
fastq_file = open(fastq_filename)
except IOError as exception:
exit_with_error(str(exception), EXIT_FILE_IO_ERROR)
else:
with fastq_file:
stats = FastqStats().from_file(fastq_file, read_size, options.minlen)
print_output(stats, fastq_filename, mapping_dict, mapping_text, mapping_default, output_file, OUTPUT_OPTIONS, spacer=mapping_spacer, window=options.window)
else:
logging.info('Processing FASTQ file from stdin')
print('Processing FASTQ file from stdin, press Ctrl-C to cancel. fastqe --help for more info', file=sys.stderr)
if (binascii.hexlify(sys.stdin.buffer.peek(1)[:2]) == b'1f8b'):
stdin_file = gzip.open(sys.stdin.buffer, 'rt')
else:
stdin_file = sys.stdin
stats = FastqStats().from_file(stdin_file, read_size, options.minlen)
print_output(stats, '-', mapping_dict, mapping_text, mapping_default, output_file, OUTPUT_OPTIONS, spacer=mapping_spacer, window=options.window) |
def get_manifest_list(manifests_dir: str) -> List[str]:
yml_endings = ['yml', 'yaml']
if (isfile(manifests_dir) and (manifests_dir.split('.')[(- 1)] in yml_endings)):
return [manifests_dir]
manifest_list = []
for yml_ending in yml_endings:
manifest_list += glob.glob(f'{manifests_dir}/**/*.{yml_ending}', recursive=True)
return manifest_list |
def test_colors_whole_table_with_automatic_widths(data, header, footer, fg_colors, bg_colors):
result = table(data, header=header, footer=footer, divider=True, fg_colors=fg_colors, bg_colors=bg_colors)
if SUPPORTS_ANSI:
assert (result == '\n\x1b[48;5;2mCOL A \x1b[0m \x1b[38;5;3;48;5;23mCOL B\x1b[0m \x1b[38;5;87mCOL 3 \x1b[0m\n\x1b[48;5;2m\x1b[0m \x1b[38;5;3;48;5;23m-----\x1b[0m \x1b[38;5;87m\x1b[0m\n\x1b[48;5;2mHello \x1b[0m \x1b[38;5;3;48;5;23mWorld\x1b[0m \x1b[38;5;87m \x1b[0m\n\x1b[48;5;2mThis is a test\x1b[0m \x1b[38;5;3;48;5;23mWorld\x1b[0m \x1b[38;5;87m1234 \x1b[0m\n\x1b[48;5;2m\x1b[0m \x1b[38;5;3;48;5;23m-----\x1b[0m \x1b[38;5;87m\x1b[0m\n\x1b[48;5;2m \x1b[0m \x1b[38;5;3;48;5;23m \x1b[0m \x1b[38;5;87m2030203.00\x1b[0m\n')
else:
assert (result == '\nCOL A COL B COL 3 \n ----- \nHello World \nThis is a test World 1234 \n ----- \n 2030203.00\n') |
class ValveUnusedMeterTestCase(ValveTestBases.ValveTestNetwork):
CONFIG = ('\nmeters:\n unusedmeter:\n meter_id: 1\n entry:\n flags: "KBPS"\n bands:\n [\n {\n type: "DROP",\n rate: 1\n }\n ]\n usedmeter:\n meter_id: 2\n entry:\n flags: "KBPS"\n bands:\n [\n {\n type: "DROP",\n rate: 2\n }\n ]\nacls:\n meteracl:\n - rule:\n actions:\n meter: usedmeter\n allow: 1\ndps:\n s1:\n%s\n interfaces:\n p1:\n number: 1\n native_vlan: 0x100\n acls_in: [meteracl]\n' % DP1_CONFIG)
def setUp(self):
self.setup_valves(self.CONFIG)
def test_usedmeter(self):
valve = self.valves_manager.valves[self.DP_ID]
self.assertEqual(['usedmeter'], list(valve.dp.meters.keys())) |
def test_cell_facet_subdomains(square, forms):
from operator import add
V = FunctionSpace(square, 'CG', 1)
v = TestFunction(V)
u = TrialFunction(V)
forms = list(map(eval, forms))
full = reduce(add, forms)
full_mat = assemble(full).M.values
part_mat = reduce(add, map((lambda x: assemble(x).M.values), forms))
assert np.allclose(part_mat, full_mat) |
def event_info_from_pr_comment(data, base_url):
if (data['msg']['pullrequest']['status'] != 'Open'):
log.info('Pull-request not open, discarding.')
return False
if (not data['msg']['pullrequest']['comments']):
log.info("This is most odd, we're not seeing comments.")
return False
last_comment = data['msg']['pullrequest']['comments'][(- 1)]
if (not last_comment):
log.info('Can not access last comment, discarding.')
return False
if ((not ('comment' in last_comment)) or ('[copr-build]' not in last_comment['comment'])):
log.info('The [copr-build] is not present in the message.')
return False
return munch.Munch({'object_id': data['msg']['pullrequest']['id'], 'object_type': 'pull-request', 'base_project_url_path': data['msg']['pullrequest']['project']['url_path'], 'base_clone_url_path': data['msg']['pullrequest']['project']['fullname'], 'base_clone_url': (base_url + data['msg']['pullrequest']['project']['fullname']), 'project_url_path': data['msg']['pullrequest']['repo_from']['url_path'], 'clone_url_path': data['msg']['pullrequest']['repo_from']['fullname'], 'clone_url': (base_url + data['msg']['pullrequest']['repo_from']['fullname']), 'branch_from': data['msg']['pullrequest']['branch_from'], 'branch_to': data['msg']['pullrequest']['branch'], 'start_commit': data['msg']['pullrequest']['commit_start'], 'end_commit': data['msg']['pullrequest']['commit_stop'], 'user': data['msg']['pullrequest']['user']['name']}) |
.django_db
def test_program_activity_fresh_load():
call_command('load_program_activity', 'usaspending_api/references/tests/data/program_activity.csv')
expected_results = {'count': 6, 'program_activity_name_lowercase_found': False}
actual_results = {'count': RefProgramActivity.objects.count(), 'program_activity_name_lowercase_found': all((name.islower() for name in RefProgramActivity.objects.values_list('program_activity_name', flat=True)))}
assert (expected_results == actual_results) |
def process_rule(lines, rule):
doc = rule.__class__.__doc__.splitlines()
short_name = doc[0].strip()
assert (doc[1].strip() == '')
sections = [[]]
in_code = False
for l in doc[2:]:
if (l.strip() == '```'):
in_code = (not in_code)
if in_code:
sections.append(['```'])
else:
sections.append([])
elif l.strip():
sections[(- 1)].append(l)
else:
sections.append([])
sections = [s for s in sections if s]
if rule.mandatory:
lines.append((' <h4>%s</h4>' % short_name))
else:
lines.append((' <h4>%s ("%s")</h4>' % (short_name, rule.name)))
for s in sections:
lines.append(' <div>')
if (s[0] == '```'):
gobble = offset(s[1:])
lines.append('<pre>')
for l in s[1:]:
lines.append(html.escape(l[gobble:]))
lines.append('</pre>')
else:
for l in s:
lines.append(((' ' * 8) + html.escape(l.strip())))
lines.append(' </div>')
lines.append('')
if getattr(rule, 'parameters', None):
lines.append(' <div>')
lines.append(' Configuration parameters:')
lines.append(' <ul>')
for param in rule.parameters:
lines.append(' <li>')
lines.append((' <b>%s</b>: %s' % (param, rule.parameters[param]['help'])))
lines.append(' </li>')
lines.append(' </ul>')
lines.append(' </div>')
lines.append('') |
def test_compound_pair_of_lists():
adapter = GenericInputAdapter(input_type='compound', input_shape='pair of lists')
inp_csv = os.path.abspath(os.path.join(inputs_path, 'compound_pair_of_lists.csv'))
inp_json = os.path.abspath(os.path.join(inputs_path, 'compound_pair_of_lists.json'))
inp_py = compound_pair_of_lists_input
d_csv = [d for d in adapter.adapt_one_by_one(inp_csv)]
d_json = [d for d in adapter.adapt_one_by_one(inp_json)]
d_py = [d for d in adapter.adapt_one_by_one(inp_py)]
assert (d_csv == d_json == d_py) |
def save_checkpoint(model, optimizer, step, checkpoint_dir, epoch, spk_flag=None, ema=None):
step = str(step).zfill(7)
checkpoint_path = join(checkpoint_dir, 'checkpoint_step{}.pth'.format(step))
torch.save({'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), 'global_step': step, 'global_epoch': epoch}, checkpoint_path)
print('Saved checkpoint:', checkpoint_path)
if spk_flag:
visualize_speaker_embeddings(model, checkpoint_dir, step)
if (ema is not None):
model = clone_as_averaged_model(model, ema)
checkpoint_path = join(checkpoint_dir, 'checkpoint_step{}_ema.pth'.format(step))
torch.save({'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), 'global_step': step, 'global_epoch': epoch}, checkpoint_path)
print('Saved checkpoint:', checkpoint_path) |
class PrometheusAPI():
def __init__(self):
self.verify = False
self.session = None
self.prometheus_url = GlobalAttrs.env_prometheus_server
self.prometheus_url_query = (self.prometheus_url + '/api/v1/query')
def get_session(self):
try:
session = requests.Session()
Logging.log.info('Establishing a new connection with Prometheus')
self.session = session
session.verify = self.verify
prometheus_url = (self.prometheus_url + '/-/healthy')
if GlobalAttrs.debug:
print(f'DEBUG -- Connecting to Prometheus: {prometheus_url}')
Logging.log.info(f'Connecting to Prometheus: {prometheus_url}')
if GlobalAttrs.env_basic_auth_enabled:
req = session.get(prometheus_url, auth=(GlobalAttrs.env_prometheus_username, GlobalAttrs.env_prometheus_password))
else:
req = session.get(prometheus_url)
if (req.status_code == 200):
Logging.log.info(f'connected successfully, status_code: {req.status_code}')
if GlobalAttrs.debug:
print(f'DEBUG -- connected successfully, status_code: {req.status_code}')
print(f'''DEBUG -- Response:
{req.text}''')
else:
print(f'''ERROR -- Failed to connect to Prometheus '{GlobalAttrs.env_prometheus_server}'; status_code: {req.status_code}, reason: {req.reason}
''')
Logging.log.error(f'Failed to connect to Prometheus, status_code: {req.status_code}')
if GlobalAttrs.debug:
Logging.log.debug('Exiting.')
exit(1)
except requests.exceptions.Timeout as e:
print(f'''ERROR -- Failed to connect to Prometheus '{GlobalAttrs.env_prometheus_server}'; Timeout
''')
Logging.log.error(f'''Failed to connect to Prometheus '{GlobalAttrs.env_prometheus_server}'; Timeout
''')
Logging.log.error(e)
raise SystemExit(f'> {e}')
except requests.exceptions.TooManyRedirects:
print(f'''ERROR -- Failed to connect to Prometheus '{GlobalAttrs.env_prometheus_server}'; Too Many Redirects
''')
Logging.log.error(f'''Failed to connect to Prometheus '{GlobalAttrs.env_prometheus_server}'; Too Many Redirects
''')
Logging.log.error(e)
raise SystemExit(f'> {e}')
except Exception as e:
print(f'''ERROR -- Failed to connect to Prometheus '{GlobalAttrs.env_prometheus_server}'; Connection Failed
''')
Logging.log.error(f'''Failed to connect to Prometheus '{GlobalAttrs.env_prometheus_server}'; Connection Failed
''')
Logging.log.error(e)
raise SystemExit(f'> {e}')
def verify_prometheus_connection(self):
out = {'connected': False, 'status_code': '?', 'reason': '', 'fail_reason': ''}
session = requests.Session()
session.verify = self.verify
try:
if GlobalAttrs.debug:
print('DEBUG -- Checking Prometheus existing connection')
Logging.log.info('Checking Prometheus existing connection')
prometheus_url = (self.prometheus_url + '/-/healthy')
if GlobalAttrs.debug:
print(f'DEBUG -- Connecting to Prometheus: {prometheus_url}')
if GlobalAttrs.env_basic_auth_enabled:
req = session.get(prometheus_url, auth=(GlobalAttrs.env_prometheus_username, GlobalAttrs.env_prometheus_password))
else:
req = session.get(prometheus_url)
if (req.status_code == 200):
Logging.log.info(f'connected successfully, status_code: {req.status_code}')
if GlobalAttrs.debug:
print(f'DEBUG -- connected successfully, status_code: {req.status_code}')
out['connected'] = True
out['status_code'] = req.status_code
else:
out['status_code'] = req.status_code
out['reason'] = req.reason
out['fail_reason'] = f'Failed to connect to Prometheus. Reason: {req.reason}'
Logging.log.error(f'Failed to connect to Prometheus. Reason: {req.reason}')
except Exception as e:
out['fail_reason'] = f'Failed to connect to Prometheus; {e}'
out['reason'] = 'unable to connnect'
Logging.log.info(f'Failed to connect to Prometheus; {e}')
return out
def run_query(self, query):
if (self.session is None):
if GlobalAttrs.debug:
Logging.log.debug(f'While running a query .. establishing a new connection with Prometheus.')
print(f'DEBUG -- While running a query .. establishing a new connection with Prometheus.')
self.get_session()
try:
Logging.log.info(f'''Running Query:
=> {query}''')
if GlobalAttrs.env_basic_auth_enabled:
req = self.session.get(self.prometheus_url_query, params={'query': f'{query}'}, auth=(GlobalAttrs.env_prometheus_username, GlobalAttrs.env_prometheus_password))
else:
req = self.session.get(self.prometheus_url_query, params={'query': f'{query}'})
if (req.status_code == 200):
if GlobalAttrs.debug:
Logging.log.debug(f'''Query run successfully, exit_code: {req.status_code}; Result:
{json.loads(req.text)}''')
else:
Logging.log.info(f'Query run successfully, exit_code: {req.status_code}')
return json.loads(req.text)
else:
Logging.log.error(f'Query did NOT run successfully, exit_code: {req.status_code}')
return {}
except requests.exceptions.Timeout as e:
print(f'''ERROR -- Failed to connect to Prometheus: Timeout
''')
Logging.log.error(f'Query did NOT run successfully, {e}')
raise SystemExit(f'> {e}')
except requests.exceptions.TooManyRedirects:
print(f'''ERROR -- Failed to connect to Prometheus: Too Many Redirects
''')
Logging.log.error(f'Query did NOT run successfully, {e}')
raise SystemExit(f'> {e}')
except requests.exceptions.RequestException as e:
print(f'''ERROR -- Failed to connect to Prometheus: Connection Failed
''')
Logging.log.error(f'Query did NOT run successfully, {e}')
raise SystemExit(f'> {e}')
def verifyNodeExporter(self):
output = {'success': False, 'fail_reason': '', 'result': {}}
try:
query = 'sum(node_exporter_build_info) by (version)'
result = self.run_query(query)
if (not (result.get('status') == 'success')):
output['fail_reason'] = f'''could not get metric value:
{query}'''
return output
if (not result.get('data').get('result')):
output['fail_reason'] = f'''Query did not return any data:
{query}'''
return output
found_versions = {}
for v in result.get('data').get('result'):
found_versions[v.get('metric').get('version')] = v.get('value')[1]
output['result']['found_versions'] = found_versions
output['success'] = True
except (KeyError, AttributeError) as e:
output['success']: False
output['fail_reason'] = e
return output
def verifyKubernetesExporter(self):
output = {'success': False, 'fail_reason': '', 'result': {}}
try:
query = 'sum(kubernetes_build_info) by (git_version)'
result = self.run_query(query)
if (not (result.get('status') == 'success')):
output['fail_reason'] = f'''could not get metric value:
{query}'''
return output
if (not result.get('data').get('result')):
output['fail_reason'] = f'''Query did not return any data:
{query}'''
return output
found_versions = {}
for v in result.get('data').get('result'):
found_versions[v.get('metric').get('git_version')] = v.get('value')[1]
output['result']['found_git_versions'] = found_versions
output['success'] = True
except (KeyError, AttributeError) as e:
output['success']: False
output['fail_reason'] = e
return output
def verify_exporters(self):
print('')
rich.print('[underline]Verifying Prometheus connection:[/underline] ... ', end='\r')
prometheus_connection = self.verify_prometheus_connection()
if prometheus_connection['connected']:
rich.print('[underline]Verifying Prometheus connection:[/underline] [bold green]Connected ')
rich.print_json(data=prometheus_connection)
else:
rich.print('[underline]Verifying Prometheus connection:[/underline] [bold red]Unable to connect ')
rich.print_json(data=prometheus_connection)
exit(1)
print('')
rich.print('[underline]Verifying Prometheus Exporters:[/underline]')
print('')
rich.print('* Node Exporter: ... ', end='\r')
verify_node_exporter = self.verifyNodeExporter()
if verify_node_exporter.get('success'):
rich.print('* Node Exporter: [bold green]Found ', end='\r')
else:
rich.print('* Node Exporter: [bold red]Not Found ', end='\r')
print('')
rich.print_json(data=verify_node_exporter)
print('')
rich.print('* Kubernetes Exporter: ... ', end='\r')
verify_kubernetes_exporter = self.verifyKubernetesExporter()
if verify_kubernetes_exporter.get('success'):
rich.print('* Kubernetes Exporter: [bold green]Found ', end='\r')
else:
rich.print('* Kubernetes Exporter: [bold green]Not Found ', end='\r')
print('')
rich.print_json(data=verify_kubernetes_exporter)
print(' ')
def check_metrics(self):
node_exporter_metrics_lst = ['node_memory_MemFree_bytes', 'node_memory_MemAvailable_bytes', 'node_memory_MemTotal_bytes', 'node_memory_Cached_bytes', 'node_memory_Buffers_bytes', 'node_memory_SwapTotal_bytes', 'node_memory_SwapFree_bytes', 'node_memory_SwapCached_bytes', 'node_cpu_seconds_total', 'node_load1', 'node_load5', 'node_load15', 'machine_cpu_physical_cores', 'machine_cpu_sockets', 'up', 'node_boot_time_seconds', 'node_filesystem_size_bytes', 'node_filesystem_avail_bytes', 'node_filesystem_avail_bytes', 'node_network_receive_bytes_total', 'node_network_transmit_bytes_total', 'node_disk_written_bytes_total', 'node_disk_read_bytes_total', 'machine_cpu_cores', 'kubelet_running_pods']
kubernetes_exporter_metrics_lst = ['container_last_seen', 'container_memory_working_set_bytes', 'container_memory_max_usage_bytes', 'container_spec_memory_limit_bytes', 'container_memory_cache', 'container_spec_memory_swap_limit_bytes', 'container_cpu_load_average_10s', 'container_cpu_usage_seconds_total', 'container_cpu_system_seconds_total', 'container_cpu_user_seconds_total', 'container_spec_cpu_quota', 'kube_pod_spec_volumes_persistentvolumeclaims_info', 'kubelet_volume_stats_capacity_bytes', 'kubelet_volume_stats_used_bytes', 'kubelet_volume_stats_available_bytes', 'container_network_receive_bytes_total', 'container_network_transmit_bytes_total', 'container_start_time_seconds', 'container_file_descriptors', 'container_threads', 'container_processes', 'container_fs_reads_bytes_total', 'container_fs_writes_bytes_total', 'container_fs_writes_bytes_total']
table = [['METRIC', 'EXPORTER', 'STATE', 'COMMENT']]
self.progress_metrics_check = Progress(SpinnerColumn(), TimeElapsedColumn(), TimeRemainingColumn(), TextColumn('[progress.description]{task.description}'), BarColumn(bar_width=30), TaskProgressColumn(), TextColumn('{task.fields[status]}'))
self.task_metrics_check_percentage = self.progress_metrics_check.add_task(description=f'[b]Checking Metrics ', status='...', total=(len(node_exporter_metrics_lst) + len(kubernetes_exporter_metrics_lst)))
with Live(self.progress_metrics_check, auto_refresh=True, screen=False):
try:
cnt = 1
for m in node_exporter_metrics_lst:
exporter = 'node_exporter'
result = self.run_query(f'topk(1, {m})')
self.progress_metrics_check.update(task_id=self.task_metrics_check_percentage, status=f' [ [yellow]{m}[/yellow] ]', completed=cnt)
row = [m, exporter]
if (result.get('status') != 'success'):
row.append('not_available')
row.append('could not get metric value')
elif (len(result.get('data').get('result')) < 1):
row.append('not_available')
row.append('did NOT return any data')
else:
row.append('available')
row.append('')
table.append(row)
cnt += 1
for m in kubernetes_exporter_metrics_lst:
exporter = 'kubernetes'
result = self.run_query(f'topk(1, {m})')
self.progress_metrics_check.update(task_id=self.task_metrics_check_percentage, status=f' [ [yellow]{m}[/yellow] ]', completed=cnt)
row = [m, exporter]
if (result.get('status') != 'success'):
row.append('not_available')
row.append('could not get metric value')
elif (len(result.get('data').get('result')) < 1):
row.append('not_available')
row.append('did NOT return any data')
else:
row.append('available')
row.append('')
table.append(row)
cnt += 1
except Exception as e:
print(f'''Error while priting 'metrics_check' progress
{e}''')
tabulate.WIDE_CHARS_MODE = False
out = tabulate(table, headers='firstrow', tablefmt='grid', showindex=False)
print(out)
exit(1) |
class TransformFactory(ReprMixIn):
_modules: Dict[(str, _TransformFactoryModule)] = {}
_instances: Dict[(str, Any)] = {}
def __init__(self) -> None:
raise InternalError('TransformFactory constructor called.')
def _import_modules(cls, config: Config, modules: ConfigList) -> None:
for (index, module_dict) in enumerate(modules):
module = Config.get_from_dict(module_dict, 'module', types=str, full_name_override=modules.full_name, index=index)
name = Config.get_from_dict(module_dict, 'name', types=str, full_name_override=modules.full_name, index=index)
configuration = Config.get_from_dict(module_dict, 'configuration', None, types=dict, full_name_override=modules.full_name, index=index)
if (name in cls._modules):
raise ConfigurationError('Duplicate name "{}" in list {}.'.format(name, modules.full_name))
module = importlib.import_module('{}.{}'.format(__package__, module))
try:
configuration = config.validate(module=module.__name__, config=configuration)
except ConfigurationError as exception:
raise ConfigurationError('Configuration for transform {} is invalid.'.format(name)) from exception
cls._modules[name] = _TransformFactoryModule(module=module, arguments={'config': config, 'name': name, 'module_configuration': configuration})
def initialize(cls, config: Config) -> None:
cls._modules = {}
transforms: ConfigList = config.get('transforms', None, types=list)
if (transforms is not None):
cls._import_modules(config, transforms)
def close(cls) -> None:
cls._instances = {}
def get_by_name(cls, name: str) -> Any:
if (name not in cls._instances):
if (name not in cls._modules):
raise ConfigurationError('Transform name {} is undefined.'.format(name))
module = cls._modules[name].module
module_arguments = cls._modules[name].arguments
cls._instances[name] = module.Transform(**module_arguments)
return cls._instances[name] |
def direct(twitch_id):
print(twitch_id)
channel = twitch_id.split('')[0]
video_id = twitch_id.split('')[1]
command = ['yt-dlp', '-f', 'best', '--no-warnings', ' '--get-url']
twitch_url = w.worker(['yt-dlp', '-f', 'best', '--no-warnings', ' '--get-url']).output()
if ('ERROR' in twitch_url):
twitch_url = w.worker(['yt-dlp', '-f', 'best', '--no-warnings', ' '')), '--get-url']).output()
if ('ERROR' in twitch_url):
twitch_url = w.worker(['yt-dlp', '-f', 'best', '--no-warnings', ' '--get-url']).output()
return redirect(twitch_url, code=301) |
class AffiliationAddressModelTrainingDataGenerator(AbstractDocumentModelTrainingDataGenerator):
def get_main_model(self, document_context: TrainingDataDocumentContext) -> Model:
return document_context.fulltext_models.affiliation_address_model
def iter_model_layout_documents(self, layout_document: LayoutDocument, document_context: TrainingDataDocumentContext) -> Iterable[LayoutDocument]:
header_model = document_context.fulltext_models.header_model
segmentation_label_result = get_segmentation_label_result(layout_document, document_context=document_context)
header_layout_document = segmentation_label_result.get_filtered_document_by_label('<header>').remove_empty_blocks()
LOGGER.debug('header_layout_document: %r', header_layout_document)
if (not header_layout_document.pages):
return []
header_labeled_layout_tokens = get_labeled_layout_tokens_for_model_and_layout_document(model=header_model, layout_document=header_layout_document, document_context=document_context)
semantic_raw_aff_address_list = list(SemanticMixedContentWrapper(list(header_model.iter_semantic_content_for_labeled_layout_tokens(header_labeled_layout_tokens))).iter_by_type(SemanticRawAffiliationAddress))
LOGGER.info('semantic_raw_aff_address_list count: %d', len(semantic_raw_aff_address_list))
if (not semantic_raw_aff_address_list):
return []
return [LayoutDocument.for_blocks(list(semantic_raw_aff_address.iter_blocks())) for semantic_raw_aff_address in semantic_raw_aff_address_list] |
def template_hook(name, silent=True, is_markup=True, **kwargs):
try:
hook = getattr(current_app.pluggy.hook, name)
result = TemplateEventResult(hook(**kwargs))
except AttributeError:
if silent:
return ''
raise
if is_markup:
return Markup(result)
return result |
class OptLegend(Options):
def type(self):
return self._config_get()
def type(self, text):
self._config(text)
def direction(self):
return self._config_get()
def direction(self, text):
self._config(text)
def orient(self):
return self._config_get()
def orient(self, text):
self._config(text)
def fill(self):
return self._config_get()
def fill(self, text):
self._config(text)
def encode(self):
return self._config_sub_data('encode', OptLegendEncode)
def opacity(self):
return self._config_get()
def opacity(self, text):
self._config(text)
def shape(self):
return self._config_get()
def shape(self, text):
self._config(text)
def size(self):
return self._config_get()
def size(self, text):
self._config(text)
def stroke(self):
return self._config_get()
def stroke(self, text):
self._config(text)
def strokeDash(self):
return self._config_get()
def strokeDash(self, text):
self._config(text)
def strokeWidth(self):
return self._config_get()
def strokeWidth(self, text):
self._config(text)
def format(self):
return self._config_get()
def format(self, text):
self._config(text)
def formatType(self):
return self._config_get()
def formatType(self, text):
self._config(text)
def gridAlign(self):
return self._config_get()
def gridAlign(self, text):
self._config(text)
def clipHeight(self):
return self._config_get()
def clipHeight(self, num):
self._config(num)
def columns(self):
return self._config_get()
def columns(self, num):
self._config(num)
def columnPadding(self):
return self._config_get()
def columnPadding(self, num):
self._config(num)
def rowPadding(self):
return self._config_get()
def rowPadding(self, num):
self._config(num)
def cornerRadius(self):
return self._config_get()
def cornerRadius(self, num):
self._config(num)
def fillColor(self):
return self._config_get()
def fillColor(self, code):
self._config(code)
def offset(self):
return self._config_get()
def offset(self, num):
self._config(num)
def padding(self):
return self._config_get()
def padding(self, num):
self._config(num)
def strokeColor(self):
return self._config_get()
def strokeColor(self, code):
self._config(code)
def gradientLength(self):
return self._config_get()
def gradientLength(self, num):
self._config(num)
def gradientOpacity(self):
return self._config_get()
def gradientOpacity(self, num):
self._config(num)
def gradientThickness(self):
return self._config_get()
def gradientThickness(self, num):
self._config(num)
def gradientStrokeColor(self):
return self._config_get()
def gradientStrokeColor(self, code):
self._config(code)
def gradientStrokeWidth(self):
return self._config_get()
def gradientStrokeWidth(self, num):
self._config(num)
def labelAlign(self):
return self._config_get()
def labelAlign(self, text):
self._config(text)
def labelBaseline(self):
return self._config_get()
def labelBaseline(self, text):
self._config(text)
def labelColor(self):
return self._config_get()
def labelColor(self, code):
self._config(code)
def labelFont(self):
return self._config_get()
def labelFont(self, text):
self._config(text)
def labelFontSize(self):
return self._config_get()
def labelFontSize(self, num):
self._config(num)
def labelFontStyle(self):
return self._config_get()
def labelFontStyle(self, text):
self._config(text)
def labelFontWeight(self):
return self._config_get()
def labelFontWeight(self, text):
self._config(text)
def labelLimit(self):
return self._config_get()
def labelLimit(self, num):
self._config(num)
def labelOffset(self):
return self._config_get()
def labelOffset(self, num):
self._config(num)
def labelOpacity(self):
return self._config_get()
def labelOpacity(self, num):
self._config(num)
def labelOverlap(self):
return self._config_get()
def labelOverlap(self, text):
self._config(text)
def labelSeparation(self):
return self._config_get()
def labelSeparation(self, num):
self._config(num)
def legendX(self):
return self._config_get()
def legendX(self, num):
self._config(num)
def legendY(self):
return self._config_get()
def legendY(self, num):
self._config(num)
def symbolDash(self):
return self._config_get()
def symbolDash(self, values):
self._config(values)
def symbolDashOffset(self):
return self._config_get()
def symbolDashOffset(self, num):
self._config(num)
def symbolFillColor(self):
return self._config_get()
def symbolFillColor(self, code):
self._config(code)
def symbolLimit(self):
return self._config_get()
def symbolLimit(self, num):
self._config(num)
def symbolOffset(self):
return self._config_get()
def symbolOffset(self, num):
self._config(num)
def symbolOpacity(self):
return self._config_get()
def symbolOpacity(self, num):
self._config(num)
def symbolSize(self):
return self._config_get()
def symbolSize(self, num):
self._config(num)
def symbolStrokeColor(self):
return self._config_get()
def symbolStrokeColor(self, code):
self._config(code)
def symbolStrokeWidth(self):
return self._config_get()
def symbolStrokeWidth(self, num):
self._config(num)
def symbolType(self):
return self._config_get()
def symbolType(self, text):
self._config(text)
def tickCount(self):
return self._config_get()
def tickCount(self, text):
self._config(text)
def tickMinStep(self):
return self._config_get()
def tickMinStep(self, num):
self._config(num)
def title(self):
return self._config_get()
def title(self, text):
self._config(text)
def titleAnchor(self):
return self._config_get()
def titleAnchor(self, text):
self._config(text)
def titleAlign(self):
return self._config_get()
def titleAlign(self, text):
self._config(text)
def titleBaseline(self):
return self._config_get()
def titleBaseline(self, text):
self._config(text)
def titleColor(self):
return self._config_get()
def titleColor(self, code):
self._config(code)
def titleFont(self):
return self._config_get()
def titleFont(self, text):
self._config(text)
def titleFontSize(self):
return self._config_get()
def titleFontSize(self, num):
self._config(num)
def titleFontStyle(self):
return self._config_get()
def titleFontStyle(self, text):
self._config(text)
def titleFontWeight(self):
return self._config_get()
def titleFontWeight(self, text):
self._config(text)
def titleLimit(self):
return self._config_get()
def titleLimit(self, num):
self._config(num)
def titleLineHeight(self):
return self._config_get()
def titleLineHeight(self, num):
self._config(num)
def titleOpacity(self):
return self._config_get()
def titleOpacity(self, num):
self._config(num)
def titleOrient(self):
return self._config_get()
def titleOrient(self, text):
self._config(text)
def titlePadding(self):
return self._config_get()
def titlePadding(self, num):
self._config(num)
def values(self):
return self._config_get()
def values(self, values):
self._config(values)
def zindex(self):
return self._config_get()
def zindex(self, num):
self._config(num) |
class CssToastTimePickerSelect(CssStyle.Style):
classname = 'tui-timepicker-select'
_focus = {'outline': 0}
def customize(self):
self.focus.css({'border-color': self.page.theme.notch()})
self.css({'height': ('%spx' % Defaults.LINE_HEIGHT), 'padding': '0 0 0px 9px'}, important=True) |
def test_assert_dataclassjsonmixin_type():
pt = SchemaArgsAssert
lt = TypeEngine.to_literal_type(pt)
gt = TypeEngine.guess_python_type(lt)
pv = SchemaArgsAssert(x=ArgsAssert(x=3, y='hello'))
DataclassTransformer().assert_type(gt, pv)
DataclassTransformer().assert_type(SchemaArgsAssert, pv)
class Bar(DataClassJSONMixin):
x: int
pv = Bar(x=3)
with pytest.raises(TypeTransformerFailedError, match="Type of Val '<class 'int'>' is not an instance of <class '.*.ArgsAssert'>"):
DataclassTransformer().assert_type(gt, pv) |
class Entity(object):
def get_specification(cls):
entity_type = ((cls.__module__ + '/') + cls.__qualname__)
spec = cls.pre_make(entity_type, entity_type)
spec.initialize(cls)
return spec
def make(cls, *args: Any, **kwargs: Any):
pass
def info(cls, method: Optional[Union[(List[str], str)]]=None) -> str:
from eagerx.core import info
return info.get_info(cls, method)
def pre_make(cls, entity_id, entity_type):
from eagerx.core.specs import EntitySpec
return EntitySpec(dict(entity_id=entity_id, entity_type=entity_type))
def check_spec(cls, spec):
pass |
def test_call_with_context_kwargs():
provider = providers.Factory(Example, init_arg1=1)
instance1 = provider(init_arg2=22)
assert (instance1.init_arg1 == 1)
assert (instance1.init_arg2 == 22)
instance2 = provider(init_arg1=11, init_arg2=22)
assert (instance2.init_arg1 == 11)
assert (instance2.init_arg2 == 22) |
class RevisionsMap(object):
def __init__(self, app, generator):
self.app = app
self._generator = generator
def _revision_map(self):
rmap = {}
heads = OrderedSet()
_real_heads = OrderedSet()
self.bases = ()
self._real_bases = ()
for revision in self._generator():
if (revision.revision in rmap):
self.app.log.warn(('Revision %s is present more than once' % revision.revision))
rmap[revision.revision] = revision
heads.add(revision.revision)
_real_heads.add(revision.revision)
if revision.is_base:
self.bases += (revision.revision,)
self._real_bases += (revision.revision,)
for rev in rmap.values():
for downrev in rev._all_down_revisions:
if (downrev not in rmap):
self.app.log.warn(('Revision %s referenced from %s is not present' % (downrev, rev)))
down_revision = rmap[downrev]
down_revision.add_nextrev(rev)
if (downrev in rev._versioned_down_revisions):
heads.discard(downrev)
_real_heads.discard(downrev)
rmap[None] = rmap[()] = None
self.heads = tuple(heads)
self._real_heads = tuple(_real_heads)
return rmap
def heads(self):
self._revision_map
return self.heads
def bases(self):
self._revision_map
return self.bases
def _real_heads(self):
self._revision_map
return self._real_heads
def _real_bases(self):
self._revision_map
return self._real_bases
def get_current_head(self):
current_heads = self.heads
if (len(current_heads) > 1):
raise MultipleHeads(current_heads, 'head')
if current_heads:
return current_heads[0]
else:
return None
def _resolve_revision_number(self, rid):
self._revision_map
if (rid == 'heads'):
return self._real_heads
elif (rid == 'head'):
current_head = self.get_current_head()
if current_head:
return (current_head,)
return ()
elif ((rid == 'base') or (rid is None)):
return ()
else:
return to_tuple(rid, default=None)
def _revision_for_ident(self, resolved_id):
try:
revision = self._revision_map[resolved_id]
except KeyError:
revs = [x for x in self._revision_map if (x and x.startswith(resolved_id))]
if (not revs):
raise ResolutionError(("No such revision or branch '%s'" % resolved_id), resolved_id)
elif (len(revs) > 1):
raise ResolutionError(("Multiple revisions start with '%s': %s..." % (resolved_id, ', '.join((("'%s'" % r) for r in revs[0:3])))), resolved_id)
else:
revision = self._revision_map[revs[0]]
return revision
def get_revision(self, rid):
resolved_id = self._resolve_revision_number(rid)
if (len(resolved_id) > 1):
raise MultipleHeads(resolved_id, rid)
elif resolved_id:
resolved_id = resolved_id[0]
return self._revision_for_ident(resolved_id)
def get_revisions(self, rid):
if isinstance(rid, (list, tuple, set, frozenset)):
return sum([self.get_revisions(id_elem) for id_elem in rid], ())
else:
resolved_id = self._resolve_revision_number(rid)
return tuple((self._revision_for_ident(rev_id) for rev_id in resolved_id))
def add_revision(self, revision, _replace=False):
map_ = self._revision_map
if ((not _replace) and (revision.revision in map_)):
self.app.log.warn(('Revision %s is present more than once' % revision.revision))
elif (_replace and (revision.revision not in map_)):
raise Exception(('revision %s not in map' % revision.revision))
map_[revision.revision] = revision
if revision.is_base:
self.bases += (revision.revision,)
self._real_bases += (revision.revision,)
for downrev in revision._all_down_revisions:
if (downrev not in map_):
self.app.log.warn(('Revision %s referenced from %s is not present' % (downrev, revision)))
map_[downrev].add_nextrev(revision)
if revision._is_real_head:
self._real_heads = (tuple((head for head in self._real_heads if (head not in set(revision._all_down_revisions).union([revision.revision])))) + (revision.revision,))
if revision.is_head:
self.heads = (tuple((head for head in self.heads if (head not in set(revision._versioned_down_revisions).union([revision.revision])))) + (revision.revision,))
def iterate_revisions(self, upper, lower, implicit_base=False, inclusive=False):
return self._iterate_revisions(upper, lower, inclusive=inclusive, implicit_base=implicit_base)
def _get_ancestor_nodes(self, targets, map_=None, check=False):
fn = (lambda rev: rev._versioned_down_revisions)
return self._iterate_related_revisions(fn, targets, map_=map_, check=check)
def _get_descendant_nodes(self, targets, map_=None, check=False):
fn = (lambda rev: rev.nextrev)
return self._iterate_related_revisions(fn, targets, map_=map_, check=check)
def _iterate_related_revisions(self, fn, targets, map_, check=False):
if (map_ is None):
map_ = self._revision_map
seen = set()
todo = deque()
for target in targets:
todo.append(target)
if check:
per_target = set()
while todo:
rev = todo.pop()
if check:
per_target.add(rev)
if (rev in seen):
continue
seen.add(rev)
todo.extend((map_[rev_id] for rev_id in fn(rev)))
(yield rev)
if (check and per_target.intersection(targets).difference([target])):
raise RevisionError(('Requested revision %s overlaps with other requested revisions' % target.revision))
def _iterate_revisions(self, upper, lower, inclusive=True, implicit_base=False):
requested_lowers = self.get_revisions(lower)
uppers = dedupe_tuple(self.get_revisions(upper))
if ((not uppers) and (not requested_lowers)):
return
upper_ancestors = set(self._get_ancestor_nodes(uppers, check=True))
if (implicit_base and requested_lowers):
lower_ancestors = set(self._get_ancestor_nodes(requested_lowers))
lower_descendants = set(self._get_descendant_nodes(requested_lowers))
base_lowers = set()
candidate_lowers = upper_ancestors.difference(lower_ancestors).difference(lower_descendants)
for rev in candidate_lowers:
for downrev in rev._all_down_revisions:
if (self._revision_map[downrev] in candidate_lowers):
break
else:
base_lowers.add(rev)
lowers = base_lowers.union(requested_lowers)
elif implicit_base:
base_lowers = set(self.get_revisions(self._real_bases))
lowers = base_lowers.union(requested_lowers)
elif (not requested_lowers):
lowers = set(self.get_revisions(self._real_bases))
else:
lowers = requested_lowers
total_space = set((rev.revision for rev in upper_ancestors)).intersection((rev.revision for rev in self._get_descendant_nodes(lowers, check=True)))
if (not total_space):
raise RangeNotAncestorError(lower, upper)
branch_todo = set((rev for rev in (self._revision_map[rev] for rev in total_space) if (rev._is_real_branch_point and (len(total_space.intersection(rev._all_nextrev)) > 1))))
todo = deque((r for r in uppers if (r.revision in total_space)))
total_space_modified = True
while total_space:
if (not total_space_modified):
raise RevisionError("Dependency resolution failed; iteration can't proceed")
total_space_modified = False
if (not todo):
todo.extendleft(sorted((rev for rev in branch_todo if (not rev._all_nextrev.intersection(total_space))), key=(lambda rev: (0 if rev.is_branch_point else 1))))
branch_todo.difference_update(todo)
while todo:
rev = todo.popleft()
total_space.remove(rev.revision)
total_space_modified = True
todo.extendleft([self._revision_map[downrev] for downrev in reversed(rev._all_down_revisions) if ((self._revision_map[downrev] not in branch_todo) and (downrev in total_space))])
if ((not inclusive) and (rev in requested_lowers)):
continue
(yield rev)
assert (not branch_todo) |
class TestGetMultiAddressCommandConnectionIdURIAgentOverridesPositive(AEATestCaseEmpty):
def test_run(self, *mocks):
self.add_item('connection', str(P2P_CONNECTION_PUBLIC_ID))
self.generate_private_key(FetchAICrypto.identifier)
self.add_private_key(FetchAICrypto.identifier, connection=True)
port = 10101
host = '127.0.0.1'
self.run_cli_command('config', 'set', '--type', 'dict', 'vendor.fetchai.connections.p2p_libp2p.config', f'{{"public_uri": "{host}:{port}"}}', cwd=self.current_agent_context)
result = self.run_cli_command('get-multiaddress', FetchAICrypto.identifier, '--connection', '--connection-id', str(P2P_CONNECTION_PUBLIC_ID), '--uri-field', 'public_uri', cwd=self.current_agent_context)
assert (result.exit_code == 0)
expected_multiaddr_prefix = f'/dns4/{host}/tcp/{port}/p2p/'
assert (expected_multiaddr_prefix in result.stdout)
base58_addr = str(result.stdout).replace(expected_multiaddr_prefix, '')
base58.b58decode(base58_addr) |
def extractBeanylandCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('fight for love and peace', 'Fight for Peace and Love', 'translated'), ('im bearing my love rivals child', 'im bearing my love rivals child', 'translated'), ('turn on the love system', 'turn on the love system', 'translated'), ('crossing to the primitive', 'crossing to the primitive', 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class SysDescr(object):
name = (1, 3, 6, 1, 2, 1, 1, 1, 0)
def __eq__(self, other):
return (self.name == other)
def __ne__(self, other):
return (self.name != other)
def __lt__(self, other):
return (self.name < other)
def __le__(self, other):
return (self.name <= other)
def __gt__(self, other):
return (self.name > other)
def __ge__(self, other):
return (self.name >= other)
def __call__(self, protoVer):
return api.PROTOCOL_MODULES[protoVer].OctetString('PySNMP example command responder') |
class AugInput():
def __init__(self, image: Union[(np.ndarray, torch.Tensor)], *, boxes: Optional[Union[(np.ndarray, torch.Tensor, Boxes)]]=None, sem_seg: Optional[Union[(np.ndarray, torch.Tensor)]]=None):
self.image = image
self.boxes = boxes
self.sem_seg = sem_seg
def transform(self, tfm: Transform) -> None:
self.image = tfm.apply_image(self.image)
if (self.boxes is not None):
self.boxes = tfm.apply_box(self.boxes)
if (self.sem_seg is not None):
self.sem_seg = tfm.apply_segmentation(self.sem_seg)
def apply_augmentations(self, augmentations: List[Union[(Augmentation, Transform)]]) -> AugmentationList:
return AugmentationList(augmentations)(self) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.