code stringlengths 281 23.7M |
|---|
def test_def_function_implicit_result_variable():
string = write_rpc_request(1, 'initialize', {'rootPath': str(test_dir)})
file_path = ((test_dir / 'hover') / 'functions.f90')
string += def_request(file_path, 4, 18)
(errcode, results) = run_request(string)
assert (errcode == 0)
ref_res = [[3, 3, str(((test_dir / 'hover') / 'functions.f90'))]]
assert (len(ref_res) == (len(results) - 1))
for (i, res) in enumerate(ref_res):
validate_def(results[(i + 1)], res) |
def extractSakurahonyakuBlogspotCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
if (item['tags'] != []):
return None
titlemap = [('Hyouketsu Kyoukai no Eden Volume ', 'Hyouketsu Kyoukai no Eden', 'translated'), ('Master of Dungeon', 'Master of Dungeon', 'oel')]
for (titlecomponent, name, tl_type) in titlemap:
if (titlecomponent.lower() in item['title'].lower()):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
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 |
def format_argument(trait_name, trait_obj):
doc = ('\n :%s: ' % trait_name)
pad = ('\n' + ((len(doc) - 1) * ' '))
help = trait_obj.help
if (help is not None):
arg_desc = help
else:
arg_desc = ''
desc = trait_obj.desc
if (desc is not None):
arg_desc += desc.rstrip()
handler = trait_obj.handler
if (handler is not None):
if ((not hasattr(handler, 'aType')) or (not (handler.aType in (int, float)))):
arg_desc += (' Must be %s.' % handler.info())
default = trait_obj.default_value()[1]
if ((not (default in ('', None))) and (not trait_obj.array)):
arg_desc = (arg_desc.rstrip() + (' Default: %s' % str(default)))
desc_width = (75 - len(doc))
for line in wrap(arg_desc, width=desc_width):
doc += line
doc += pad
return doc |
(stability='beta')
class ResourceIdentifier(Serializable, ABC):
def str_identifier(self) -> str:
def __hash__(self) -> int:
return hash(self.str_identifier)
def __eq__(self, other: Any) -> bool:
if (not isinstance(other, ResourceIdentifier)):
return False
return (self.str_identifier == other.str_identifier) |
_renderer(wrap_type=ColumnMissingValuesMetric)
class ColumnMissingValuesMetricRenderer(MetricRenderer):
def _get_table_stat(stats: ColumnMissingValues) -> BaseWidgetInfo:
data = []
for (missed_value, count_of_missed) in stats.different_missing_values.items():
percent_of_missed = round(((count_of_missed / stats.number_of_rows) * 100), 3)
value = f'{count_of_missed} ({percent_of_missed}%)'
if (missed_value is None):
missed_value_str = 'Pandas and Numpy NA, NaN, etc.'
elif (not missed_value):
missed_value_str = 'Empty string'
else:
missed_value_str = str(missed_value)
data.append((missed_value_str, value))
matched_stat_headers = ['Missing values type', 'Count']
return table_data(title='', column_names=matched_stat_headers, data=data)
def _get_info_string(stats: ColumnMissingValues) -> str:
percents = round((stats.share_of_missing_values * 100), 3)
return f'{stats.number_of_missing_values} ({percents}%)'
def _get_details_missing_values_info(self, metric_result: ColumnMissingValuesMetricResult) -> BaseWidgetInfo:
counters = [CounterData.string('Missing values (Current data)', self._get_info_string(metric_result.current))]
if (metric_result.reference is not None):
counters.append(CounterData.string('Missing values (Reference data)', self._get_info_string(metric_result.reference)))
return counter(title='', counters=counters)
def render_html(self, obj: ColumnMissingValuesMetric) -> List[BaseWidgetInfo]:
metric_result = obj.get_result()
result = [header_text(label=f"Missing values in column '{metric_result.column_name}'"), self._get_details_missing_values_info(metric_result=metric_result)]
current_table = self._get_table_stat(metric_result.current)
if (metric_result.reference is not None):
tables = widget_tabs(tabs=[TabData(title='Current dataset', widget=current_table), TabData(title='Reference dataset', widget=self._get_table_stat(metric_result.reference))])
else:
tables = current_table
result.append(tables)
return result |
class GetHashIdModelMixin(object):
def __init__(self, *args, **kwargs):
self.model = kwargs.pop('model', None)
super(GetHashIdModelMixin, self).__init__(*args, **kwargs)
def get_model(self):
if (self.model is None):
custom_fn_name = 'get_{0}_model'.format(self.field_name)
if hasattr(self.parent, custom_fn_name):
return getattr(self.parent, custom_fn_name)()
else:
try:
return self.parent.Meta.model
except AttributeError:
raise AssertionError('No "model" value passed to field "{0}"'.format(type(self).__name__))
elif isinstance(self.model, str):
return utils.model_from_definition(self.model)
else:
return self.model |
def _is_deferrable(cls: Type):
try:
from airflow.providers.apache.beam.operators.beam import BeamBasePipelineOperator
if (not issubclass(cls, BeamBasePipelineOperator)):
return False
except ImportError:
logger.debug('Failed to import BeamBasePipelineOperator')
return True |
class ConvTranspose2dBiasRelu(ConvTranspose2dBiasAct):
def __init__(self, in_channels, out_channels, kernel_size, stride, padding=0, dilation=1, groups=1, dtype='float16'):
super().__init__('transposed_conv2d_bias_relu', in_channels, out_channels, kernel_size, stride, padding, dilation, groups, dtype) |
def planWidthAxis(glyphSetFunc, axisLimits, widths=None, samples=None, glyphs=None, designLimits=None, pins=None, sanitize=False):
if (widths is None):
widths = WIDTHS
return planAxis(measureWidth, normalizeLinear, interpolateLinear, glyphSetFunc, 'wdth', axisLimits, values=widths, samples=samples, glyphs=glyphs, designLimits=designLimits, pins=pins, sanitizeFunc=(sanitizeWidth if sanitize else None)) |
def wrap_text(text: str, width: int=80, initial_indent: str='', subsequent_indent: str='', **kwargs) -> str:
wrapper = TextWrapper(width=width, subsequent_indent=subsequent_indent, **kwargs)
paragraphs = []
for (i, paragraph) in enumerate(text.splitlines()):
paragraphs.extend(wrapper.wrap(f"{(((not i) and initial_indent) or '')}{((i and subsequent_indent) or '')}{paragraph}"))
return '\n'.join(paragraphs) |
class LanguageModel(QtCore.QAbstractTableModel):
def __init__(self, parent: Optional[QtCore.QObject]=None, languages: Optional[list]=None) -> None:
super().__init__(parent=parent)
self.languages: list = (languages or [])
def data(self, index: QtCore.QModelIndex, role: QtCore.Qt.ItemDataRole) -> Union[(str, QtCore.QSize, None)]:
if (role == QtCore.Qt.ItemDataRole.DisplayRole):
return self.languages[index.row()][index.column()]
return None
def rowCount(self, index: QtCore.QModelIndex) -> int:
return len(self.languages)
def columnCount(self, index: QtCore.QModelIndex) -> int:
return (len(self.languages[0]) if self.languages else 0) |
class OptionPlotoptionsErrorbarSonificationContexttracksMappingLowpassResonance(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) |
def test_generator(unused_tcp_port, ws):
async def handler(websocket, path):
(await websocket.send('one'))
(await websocket.send('two'))
(await websocket.send('three'))
(await websocket.send('four'))
ws('localhost', unused_tcp_port, handler)
with ExitStack() as stack:
duplexer = SyncWebsocketDuplexer(f'ws://localhost:{unused_tcp_port}', f'ws://localhost:{unused_tcp_port}', None, None)
stack.callback(duplexer.stop)
expected = ['one', 'two', 'three']
for msg in duplexer.receive():
assert (msg == expected.pop(0))
if (len(expected) == 1):
break |
class OptionSeriesWindbarbTooltip(Options):
def clusterFormat(self):
return self._config_get('Clustered points: {point.clusterPointsAmount}')
def clusterFormat(self, text: str):
self._config(text, js_type=False)
def dateTimeLabelFormats(self) -> 'OptionSeriesWindbarbTooltipDatetimelabelformats':
return self._config_sub_data('dateTimeLabelFormats', OptionSeriesWindbarbTooltipDatetimelabelformats)
def distance(self):
return self._config_get(6)
def distance(self, num: float):
self._config(num, js_type=False)
def followPointer(self):
return self._config_get(False)
def followPointer(self, flag: bool):
self._config(flag, js_type=False)
def followTouchMove(self):
return self._config_get(True)
def followTouchMove(self, flag: bool):
self._config(flag, js_type=False)
def footerFormat(self):
return self._config_get('')
def footerFormat(self, text: str):
self._config(text, js_type=False)
def format(self):
return self._config_get('undefined')
def format(self, text: str):
self._config(text, js_type=False)
def headerFormat(self):
return self._config_get(None)
def headerFormat(self, text: str):
self._config(text, js_type=False)
def nullFormat(self):
return self._config_get(None)
def nullFormat(self, text: str):
self._config(text, js_type=False)
def nullFormatter(self):
return self._config_get(None)
def nullFormatter(self, value: Any):
self._config(value, js_type=False)
def pointFormat(self):
return self._config_get('<span style="color:{point.color}"></span> {series.name}: <b>{point.value}</b> ({point.beaufort})<br/>')
def pointFormat(self, text: str):
self._config(text, js_type=False)
def pointFormatter(self):
return self._config_get(None)
def pointFormatter(self, value: Any):
self._config(value, js_type=False)
def valueDecimals(self):
return self._config_get(None)
def valueDecimals(self, num: float):
self._config(num, js_type=False)
def valuePrefix(self):
return self._config_get(None)
def valuePrefix(self, text: str):
self._config(text, js_type=False)
def valueSuffix(self):
return self._config_get(None)
def valueSuffix(self, text: str):
self._config(text, js_type=False)
def xDateFormat(self):
return self._config_get(None)
def xDateFormat(self, text: str):
self._config(text, js_type=False) |
class TensorFlowRecordFileTransformer(TypeTransformer[TFRecordFile]):
TENSORFLOW_FORMAT = 'TensorFlowRecord'
def __init__(self):
super().__init__(name='TensorFlow Record File', t=TFRecordFile)
def get_literal_type(self, t: Type[TFRecordFile]) -> LiteralType:
return LiteralType(blob=_core_types.BlobType(format=self.TENSORFLOW_FORMAT, dimensionality=_core_types.BlobType.BlobDimensionality.SINGLE))
def to_literal(self, ctx: FlyteContext, python_val: TFRecordFile, python_type: Type[TFRecordFile], expected: LiteralType) -> Literal:
meta = BlobMetadata(type=_core_types.BlobType(format=self.TENSORFLOW_FORMAT, dimensionality=_core_types.BlobType.BlobDimensionality.SINGLE))
local_dir = ctx.file_access.get_random_local_directory()
local_path = os.path.join(local_dir, '0000.tfrecord')
with tf.io.TFRecordWriter(local_path) as writer:
writer.write(python_val.SerializeToString())
remote_path = ctx.file_access.put_raw_data(local_path)
return Literal(scalar=Scalar(blob=Blob(metadata=meta, uri=remote_path)))
def to_python_value(self, ctx: FlyteContext, lv: Literal, expected_python_type: Type[TFRecordFile]) -> TFRecordDatasetV2:
(uri, metadata) = extract_metadata_and_uri(lv, expected_python_type)
local_path = ctx.file_access.get_random_local_path()
ctx.file_access.get_data(uri, local_path, is_multipart=False)
filenames = [local_path]
return tf.data.TFRecordDataset(filenames=filenames, compression_type=metadata.compression_type, buffer_size=metadata.buffer_size, num_parallel_reads=metadata.num_parallel_reads, name=metadata.name)
def guess_python_type(self, literal_type: LiteralType) -> Type[TFRecordFile]:
if ((literal_type.blob is not None) and (literal_type.blob.dimensionality == _core_types.BlobType.BlobDimensionality.SINGLE) and (literal_type.blob.format == self.TENSORFLOW_FORMAT)):
return TFRecordFile
raise ValueError(f'Transformer {self} cannot reverse {literal_type}') |
def test_resolve_nested():
m = mapping.Mapping()
m.field('n1', 'nested', properties={'n2': Nested(properties={'k1': Keyword()})})
m.field('k2', 'keyword')
(nested, field) = m.resolve_nested('n1.n2.k1')
assert (nested == ['n1', 'n1.n2'])
assert isinstance(field, Keyword)
(nested, field) = m.resolve_nested('k2')
assert (nested == [])
assert isinstance(field, Keyword) |
('cuda.index_select.func_call')
def gen_function_call(func_attrs, indent=' ') -> str:
backend_spec = CUDASpec()
x = func_attrs['inputs'][0]
dim_idxs = func_attrs['inputs'][1]
y = func_attrs['outputs'][0]
dim = func_attrs['dim']
dtype = backend_spec.dtype_to_backend_type(func_attrs['inputs'][0]._attrs['dtype'])
dim_idxs_ptr = backend_spec.cast_to_ptr_template.render(name=dim_idxs._attrs['name'], dtype=backend_spec.index_type)
input_ptr = backend_spec.cast_to_ptr_template.render(name=x._attrs['name'], dtype=dtype)
output_ptr = backend_spec.cast_to_ptr_template.render(name=y._attrs['name'], dtype=dtype)
x_dims = ', '.join((dim._attrs['name'] for dim in x._attrs['shape']))
dim_idxs_len = dim_idxs._attrs['shape'][0]._attrs['name']
return FUNC_CALL_TEMPLATE.render(indent=indent, index_type=backend_spec.index_type, x_dims=x_dims, input_type=dtype, func_name=func_attrs['name'], output=output_ptr, input=input_ptr, dim=dim, dim_idxs=dim_idxs_ptr, dim_idxs_len=dim_idxs_len) |
def detect_by_bom(path, default='utf-8'):
with open(path, 'rb') as f:
raw = f.read(4)
for (enc, boms) in (('utf-8-sig', (codecs.BOM_UTF8,)), ('utf-16', (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)), ('utf-32', (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE))):
if any((raw.startswith(bom) for bom in boms)):
return enc
return default |
class Test(unittest.TestCase):
def setUpClass(cls):
cls.G = fnss.glp_topology(n=50, m=1, m0=10, p=0.2, beta=(- 2), seed=1)
fnss.set_capacities_random(cls.G, {10: 0.5, 20: 0.3, 40: 0.2}, capacity_unit='Mbps')
fnss.set_delays_constant(cls.G, 2, delay_unit='ms')
fnss.set_weights_inverse_capacity(cls.G)
for node in [2, 4, 6]:
fnss.add_stack(cls.G, node, 'tcp', {'protocol': 'cubic', 'rcvwnd': 1024})
for node in [2, 4]:
fnss.add_application(cls.G, node, 'client', {'rate': 100, 'user-agent': 'fnss'})
fnss.add_application(cls.G, 2, 'server', {'port': 80, 'active': True, 'user-agent': 'fnss'})
def tearDownClass(cls):
pass
def setUp(self):
pass
def tearDown(self):
pass
def test_base_topology_class(self):
weight = 2
capacity = 3
delay = 4
buffer_size = 5
topology = fnss.Topology()
topology.add_path([1, 2, 3])
fnss.set_weights_constant(topology, weight)
fnss.set_capacities_constant(topology, capacity)
fnss.set_delays_constant(topology, delay)
fnss.set_buffer_sizes_constant(topology, buffer_size)
weights = topology.weights()
capacities = topology.capacities()
delays = topology.delays()
buffer_sizes = topology.buffers()
for e in topology.edges():
self.assertEqual(weight, weights[e])
self.assertEqual(capacity, capacities[e])
self.assertEqual(delay, delays[e])
self.assertEqual(buffer_size, buffer_sizes[e])
def test_topology_class(self):
topology = fnss.Topology()
topology.add_edge(1, 2)
self.assertEqual(1, topology.number_of_edges())
topology.add_edge(2, 1)
self.assertEqual(1, topology.number_of_edges())
topology.add_edge('1', '2')
topology.add_edge('2', '1')
self.assertEqual(2, topology.number_of_edges())
def test_directed_topology_class(self):
topology = fnss.DirectedTopology()
topology.add_edge(1, 2)
topology.add_edge(2, 1)
self.assertEqual(2, topology.number_of_edges())
def test_od_pairs_from_topology_directed(self):
dir_topology = fnss.DirectedTopology()
dir_topology.add_edge(0, 1)
dir_topology.add_edge(1, 0)
dir_topology.add_edge(1, 2)
dir_topology.add_edge(3, 2)
dir_topology.add_edge(8, 9)
expected_od_pairs = [(0, 1), (0, 2), (1, 0), (1, 2), (3, 2), (8, 9)]
od_pairs = fnss.od_pairs_from_topology(dir_topology)
self.assertEqual(len(expected_od_pairs), len(od_pairs))
for od in expected_od_pairs:
self.assertTrue((od in od_pairs))
def test_od_pairs_from_topology_undirected(self):
topology = fnss.ring_topology(3)
topology.add_path([7, 8, 9])
od_pairs = fnss.od_pairs_from_topology(topology)
expected_od_pairs = [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1), (7, 8), (7, 9), (8, 7), (8, 9), (9, 7), (9, 8)]
self.assertEqual(len(expected_od_pairs), len(od_pairs))
for od in expected_od_pairs:
self.assertTrue((od in od_pairs))
def test_fan_in_out_capacities_directed(self):
dir_topology = fnss.DirectedTopology()
dir_topology.add_edge(0, 1)
dir_topology.add_edge(1, 0)
dir_topology.add_edge(1, 2)
dir_topology.add_edge(3, 2)
fnss.set_capacities_constant(dir_topology, 10, 'Mbps')
(in_cap, out_cap) = fnss.fan_in_out_capacities(dir_topology)
self.assertEqual({0: 10, 1: 10, 2: 20, 3: 0}, in_cap)
self.assertEqual({0: 10, 1: 20, 2: 0, 3: 10}, out_cap)
def test_fan_in_out_capacities_undirected(self):
topology = fnss.star_topology(3)
fnss.set_capacities_constant(topology, 10, 'Mbps')
(in_cap, out_cap) = fnss.fan_in_out_capacities(topology)
self.assertEqual({0: 30, 1: 10, 2: 10, 3: 10}, in_cap)
self.assertEqual(in_cap, out_cap)
((TMP_DIR is None), 'Temp folder not present')
def test_read_write_topology(self):
tmp_topo_file = path.join(TMP_DIR, 'toporw.xml')
fnss.write_topology(self.G, tmp_topo_file)
self.assertTrue(path.exists(tmp_topo_file))
read_topo = fnss.read_topology(tmp_topo_file)
self.assertEqual(len(self.G), len(read_topo))
self.assertEqual(self.G.number_of_edges(), read_topo.number_of_edges())
self.assertEqual('tcp', fnss.get_stack(read_topo, 2)[0])
self.assertEqual(1024, fnss.get_stack(read_topo, 2)[1]['rcvwnd'])
self.assertEqual('cubic', fnss.get_stack(read_topo, 2)[1]['protocol'])
self.assertEqual(len(fnss.get_application_names(self.G, 2)), len(fnss.get_application_names(read_topo, 2)))
self.assertEqual('fnss', fnss.get_application_properties(read_topo, 2, 'server')['user-agent'])
self.assertEqual([2, 4, 6], [v for v in read_topo.nodes() if ((fnss.get_stack(read_topo, v) is not None) and (fnss.get_stack(read_topo, v)[0] == 'tcp'))])
self.assertEqual([2, 4], [v for v in read_topo.nodes() if ('client' in fnss.get_application_names(read_topo, v))])
self.assertEqual([2], [v for v in read_topo.nodes() if ('server' in fnss.get_application_names(read_topo, v))]) |
class OptionSeriesSunburstDragdrop(Options):
def draggableX(self):
return self._config_get(None)
def draggableX(self, flag: bool):
self._config(flag, js_type=False)
def draggableY(self):
return self._config_get(None)
def draggableY(self, flag: bool):
self._config(flag, js_type=False)
def dragHandle(self) -> 'OptionSeriesSunburstDragdropDraghandle':
return self._config_sub_data('dragHandle', OptionSeriesSunburstDragdropDraghandle)
def dragMaxX(self):
return self._config_get(None)
def dragMaxX(self, num: float):
self._config(num, js_type=False)
def dragMaxY(self):
return self._config_get(None)
def dragMaxY(self, num: float):
self._config(num, js_type=False)
def dragMinX(self):
return self._config_get(None)
def dragMinX(self, num: float):
self._config(num, js_type=False)
def dragMinY(self):
return self._config_get(None)
def dragMinY(self, num: float):
self._config(num, js_type=False)
def dragPrecisionX(self):
return self._config_get(0)
def dragPrecisionX(self, num: float):
self._config(num, js_type=False)
def dragPrecisionY(self):
return self._config_get(0)
def dragPrecisionY(self, num: float):
self._config(num, js_type=False)
def dragSensitivity(self):
return self._config_get(2)
def dragSensitivity(self, num: float):
self._config(num, js_type=False)
def groupBy(self):
return self._config_get(None)
def groupBy(self, text: str):
self._config(text, js_type=False)
def guideBox(self) -> 'OptionSeriesSunburstDragdropGuidebox':
return self._config_sub_data('guideBox', OptionSeriesSunburstDragdropGuidebox)
def liveRedraw(self):
return self._config_get(True)
def liveRedraw(self, flag: bool):
self._config(flag, js_type=False) |
class CamSaveMode(BaseMode):
name = Mode.cam_save
keymap = {Action.quit: False, Action.cam_save: True}
def enter(self):
mouse.mode(MouseMode.ABSOLUTE)
self.selection = None
self.register_keymap_event('escape', Action.quit, True)
self.register_keymap_event('1', Action.cam_save, True)
self.register_keymap_event('1-up', Action.cam_save, False)
self.render_camera_save_buttons()
tasks.add(self.cam_save_task, 'cam_save_task')
tasks.add(self.shared_task, 'shared_task')
def exit(self):
if self.selection:
cam.store_state(name=f'save_{self.selection}', overwrite=True)
tasks.remove('cam_save_task')
tasks.remove('shared_task')
mouse.touch()
self.cam_save_slots.hide()
del self.selection
def render_camera_save_buttons(self):
self.cam_save_slots = GenericMenu(title='Release key with moused hovered over desired save slot', frame_color=(0, 0, 0, 0.2), title_pos=(0, 0, 0.45))
pos = (- 1.2)
for slot in range(1, 10):
exists = (f'save_{slot}' in cam.states)
button = self.cam_save_slots.add_button(text=(f'{slot}', f'{slot}', ('replace' if exists else 'write'), f'{slot}'), command=(lambda : None), scale=0.1, text_scale=0.6, frameSize=((- 1.2), 1.2, (- 1.2), 1.2), frameColor=((0.3, 0.6, 0.6, 1.0) if exists else (0.8, 0.8, 0.8, 1.0)))
button.setPos((pos, 0, 0.25))
button.bind(DGG.WITHIN, self.update_save_selection, extraArgs=[slot])
button.bind(DGG.WITHOUT, self.update_save_selection, extraArgs=[None])
pos += 0.3
self.cam_save_slots.show()
def update_save_selection(self, state, coords):
self.selection = state
def cam_save_task(self, task):
if (not self.keymap[Action.cam_save]):
enter_kwargs = (dict(load_prev_cam=True) if (Global.mode_mgr.last_mode == Mode.aim) else dict())
Global.mode_mgr.change_mode(Global.mode_mgr.last_mode, enter_kwargs=enter_kwargs)
return task.cont |
class TestStatisticsHistoryBasedNotificationRuleOnIngress():
def test_stats_readings_south(self, clean_setup_fledge_packages, reset_fledge, start_south, start_notification, fledge_url, skip_verify_north_interface, wait_time, retries):
time.sleep((wait_time * 4))
verify_ping(fledge_url, skip_verify_north_interface, wait_time, retries)
get_url = '/fledge/audit?source=NTFSN'
resp1 = utils.get_request(fledge_url, get_url)
assert len(resp1['audit'])
assert ('test #1' in [s['details']['name'] for s in resp1['audit']])
for audit_detail in resp1['audit']:
if ('test #1' == audit_detail['details']['name']):
assert ('NTFSN' == audit_detail['source'])
time.sleep(60)
resp2 = utils.get_request(fledge_url, get_url)
assert ((len(resp2['audit']) - len(resp1['audit'])) == 2), 'ERROR: NTFSN not triggered properly'
get_url = '/fledge/statistics/history?minutes=10'
r = utils.get_request(fledge_url, get_url)
if ('READINGS' in r['statistics'][0]):
assert (0 < r['statistics'][0]['READINGS'])
def test_stats_south_asset_ingest(self, fledge_url, wait_time, skip_verify_north_interface, retries):
put_url = '/fledge/category/ruletest #1'
data = {'asset': 'Sine #1-Ingest'}
utils.put_request(fledge_url, urllib.parse.quote(put_url), data)
verify_ping(fledge_url, skip_verify_north_interface, wait_time, retries)
get_url = '/fledge/audit?source=NTFSN'
resp1 = utils.get_request(fledge_url, get_url)
assert len(resp1['audit'])
assert ('test #1' in [s['details']['name'] for s in resp1['audit']])
for audit_detail in resp1['audit']:
if ('test #1' == audit_detail['details']['name']):
assert ('NTFSN' == audit_detail['source'])
time.sleep(60)
resp2 = utils.get_request(fledge_url, get_url)
assert ((len(resp2['audit']) - len(resp1['audit'])) == 2), 'ERROR: NTFSN not triggered properly'
get_url = '/fledge/statistics/history?minutes=10'
r = utils.get_request(fledge_url, get_url)
if ('Sine #1-Ingest' in r['statistics'][0]):
assert (0 < r['statistics'][0]['Sine #1-Ingest'])
def test_stats_south_asset(self, fledge_url, wait_time, skip_verify_north_interface, retries):
put_url = '/fledge/category/ruletest #1'
data = {'asset': SOUTH_ASSET_NAME.upper()}
utils.put_request(fledge_url, urllib.parse.quote(put_url), data)
verify_ping(fledge_url, skip_verify_north_interface, wait_time, retries)
get_url = '/fledge/audit?source=NTFSN'
resp1 = utils.get_request(fledge_url, get_url)
assert len(resp1['audit'])
assert ('test #1' in [s['details']['name'] for s in resp1['audit']])
for audit_detail in resp1['audit']:
if ('test #1' == audit_detail['details']['name']):
assert ('NTFSN' == audit_detail['source'])
time.sleep(60)
resp2 = utils.get_request(fledge_url, get_url)
assert ((len(resp2['audit']) - len(resp1['audit'])) == 2), 'ERROR: NTFSN not triggered properly'
get_url = '/fledge/statistics/history?minutes=10'
r = utils.get_request(fledge_url, get_url)
if (SOUTH_ASSET_NAME.upper() in r['statistics'][0]):
assert (0 < r['statistics'][0][SOUTH_ASSET_NAME.upper()]) |
class ReadState(base_tests.SimpleProtocol):
def runTest(self):
logging.info('Running Read_State test')
of_ports = config['port_map'].keys()
of_ports.sort()
delete_all_flows(self.controller)
logging.info('Inserting a flow entry and then sending flow_stats request')
logging.info('Expecting the a flow_stats_reply without errors')
(pkt, match) = wildcard_all_except_ingress(self, of_ports)
get_flowstats(self, match) |
('aea.cli.reset_password._do_password_reset')
class ResetPasswordTestCase(TestCase):
def setUp(self):
self.runner = CliRunner()
def test_reset_password_positive(self, registry_reset_password_mock):
email = ''
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'reset_password', email], standalone_mode=False)
self.assertEqual(result.exit_code, 0)
registry_reset_password_mock.assert_called_once_with(email) |
.integration_postgres
.integration
.usefixtures('postgres_example_test_dataset_config_skipped_address_collection', 'postgres_integration_db', 'cache')
def test_create_and_process_access_request_with_invalid_skipped_collection(db, policy, run_privacy_request_task):
customer_email = 'customer-'
data = {'requested_at': '2021-08-30T16:09:37.359Z', 'policy_key': policy.key, 'identity': {'email': customer_email}}
pr = get_privacy_request_results(db, policy, run_privacy_request_task, data)
results = pr.get_results()
assert (len(results.keys()) == 0)
db.refresh(pr)
assert (pr.status == PrivacyRequestStatus.error) |
class SetSubscriptionsTest(unittest.TestCase):
('set_subscriptions.app.create_user', side_effect=mocked_create_user)
('set_subscriptions.app.subscribe', side_effect=mocked_subscribe)
('set_subscriptions.app.unsubscribe', side_effect=mocked_unsubscribe)
('user_service.query_single_user', side_effect=mocked_query_single_user)
def test_subscribe(self, query_single_user_mock, unsubscribe_mock, subscribe_mock, create_user_mock):
event_body = {'cognito_id': '123', 'email': '', 'character_set_preference': 'simplified', 'subscriptions': [{'list_id': '123', 'list_name': 'HSK Level 1', 'character_set': 'simplified'}, {'list_id': '234', 'list_name': 'HSK Level 2', 'character_set': 'simplified'}]}
response = lambda_handler(self.sub_apig_event(json.dumps(event_body)), '')
self.assertEqual(create_user_mock.call_count, 1)
self.assertEqual(query_single_user_mock.call_count, 1)
self.assertEqual(subscribe_mock.call_count, 2)
('set_subscriptions.app.create_user', side_effect=mocked_create_user)
('set_subscriptions.app.subscribe', side_effect=mocked_subscribe)
('set_subscriptions.app.unsubscribe', side_effect=mocked_unsubscribe)
('user_service.query_single_user', side_effect=mocked_query_single_user)
def test_unsubscribe_all(self, query_single_user_mock, unsubscribe_mock, subscribe_mock, create_user_mock):
event_body = {'cognito_id': '123', 'email': '', 'character_set_preference': 'simplified', 'subscriptions': []}
response = lambda_handler(self.sub_apig_event(json.dumps(event_body)), '')
self.assertEqual(create_user_mock.call_count, 1)
self.assertEqual(query_single_user_mock.call_count, 1)
self.assertEqual(unsubscribe_mock.call_count, 1)
def sub_apig_event(self, event_body):
return {'resource': '/set_subs', 'path': '/set_subs', 'body': event_body, ' 'POST', 'headers': {'Accept': 'application/json, text/plain, */*', 'accept-encoding': 'gzip, deflate, br', 'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh-HK;q=0.7,zh-MO;q=0.6,zh;q=0.5', 'Authorization': 'eyJraWQiOiJq1231235fOwKv46JpjurGKzvma17eqCoaw', 'CloudFront-Forwarded-Proto': ' 'CloudFront-Is-Desktop-Viewer': 'true', 'CloudFront-Is-Mobile-Viewer': 'false', 'CloudFront-Is-SmartTV-Viewer': 'false', 'CloudFront-Is-Tablet-Viewer': 'false', 'CloudFront-Viewer-Country': 'IE', 'Host': 'api.haohaotiantian.com', 'origin': ' 'Referer': ' 'sec-ch-ua': '" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"', 'sec-ch-ua-mobile': '?0', 'sec-fetch-dest': 'empty', 'sec-fetch-mode': 'cors', 'sec-fetch-site': 'cross-site', 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36', 'Via': '2.0 f8591238.cloudfront.net (CloudFront)', 'X-Amz-Cf-Id': 'rex4fmbUq5pvK123fj5bGvpw==', 'X-Amzn-Trace-Id': 'Root=1-60e123b7e7b70', 'X-Forwarded-For': '123', 'X-Forwarded-Port': '123', 'X-Forwarded-Proto': ' 'multiValueHeaders': {'Accept': ['application/json, text/plain, */*'], 'accept-encoding': ['gzip, deflate, br'], 'Accept-Language': ['en-US,en;q=0.9,zh-CN;q=0.8,zh-HK;q=0.7,zh-MO;q=0.6,zh;q=0.5'], 'Authorization': ['eyJraWQiOiJqVmhFdEN4Y123vZ25pdG123GKzvma17eqCoaw'], 'CloudFront-Forwarded-Proto': [' 'CloudFront-Is-Desktop-Viewer': ['true'], 'CloudFront-Is-Mobile-Viewer': ['false'], 'CloudFront-Is-SmartTV-Viewer': ['false'], 'CloudFront-Is-Tablet-Viewer': ['false'], 'CloudFront-Viewer-Country': ['IE'], 'Host': ['api.haohaotiantian.com'], 'origin': [' 'Referer': [' 'sec-ch-ua': ['" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"'], 'sec-ch-ua-mobile': ['?0'], 'sec-fetch-dest': ['empty'], 'sec-fetch-mode': ['cors'], 'sec-fetch-site': ['cross-site'], 'User-Agent': ['Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36'], 'Via': ['2.0 123.cloudfront.net (CloudFront)'], 'X-Amz-Cf-Id': ['rex4fmbU123BVnGAOV9sfj5bGvpw=='], 'X-Amzn-Trace-Id': ['Root=1-60e6d123b70'], 'X-Forwarded-For': ['123'], 'X-Forwarded-Port': ['443'], 'X-Forwarded-Proto': [' 'queryStringParameters': 'None', 'multiValueQueryStringParameters': 'None', 'pathParameters': 'None', 'stageVariables': 'None', 'requestContext': {'resourceId': '123', 'authorizer': {'claims': {'sub': '', 'aud': '123123', 'email_verified': 'true', 'event_id': 'cc6a7b68-e1bc-417b-9344-123', 'token_use': 'id', 'auth_time': '', 'iss': ' 'cognito:username': '', 'exp': 'Thu Jul 08 11:38:59 UTC 2021', 'iat': 'Thu Jul 08 10:38:59 UTC 2021', 'email': ''}}, 'resourcePath': '/user_data', ' 'GET', 'extendedRequestId': 'CJZWoF123FT_Q=', 'requestTime': '08/Jul/2021:10:38:59 +0000', 'path': '/user_data', 'accountId': '123', 'protocol': 'HTTP/1.1', 'stage': 'Prod', 'domainPrefix': 'api', 'requestTimeEpoch': 123, 'requestId': '11875c1237fec0aab', 'identity': {'cognitoIdentityPoolId': 'None', 'accountId': 'None', 'cognitoIdentityId': 'None', 'caller': 'None', 'sourceIp': '54', 'principalOrgId': 'None', 'accessKey': 'None', 'cognitoAuthenticationType': 'None', 'cognitoAuthenticationProvider': 'None', 'userArn': 'None', 'userAgent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36', 'user': 'None'}, 'domainName': 'api.haohaotiantian.com', 'apiId': '123'}, 'isBase64Encoded': False}
if (__name__ == '__main__'):
unittest.main() |
_os(*metadata.platforms)
def main():
appdata = os.getenv('LOCALAPPDATA')
path = (Path(appdata) / '\\Microsoft\\Event Viewer')
recentfiles = (path / '\\RecentViews')
if path.is_dir():
common.copy_file(EXE_FILE, recentfiles)
common.remove_file(recentfiles)
else:
path.mkdir()
common.copy_file(EXE_FILE, recentfiles)
common.remove_file(recentfiles)
path.rmdir() |
class TestAccess(unittest.TestCase):
def test_defaults(self):
it = parse_accesses(['123'], None)
self.assertEqual(1, len(it))
it = it[0]
self.assertEqual('h', it.modbus_type)
self.assertEqual(123, it.address())
self.assertEqual('!H', it.pack_type())
self.assertEqual(None, it.presenter())
self.assertEqual(1, it.size())
def test_full(self):
it = parse_accesses(['/<4H:STATUS'], None)
self.assertEqual(1, len(it))
it = it[0]
self.assertEqual('i', it.modbus_type)
self.assertEqual(123, it.address())
self.assertEqual('<4H', it.pack_type())
self.assertEqual(':STATUS', it.presenter())
self.assertEqual(4, it.size())
def test_grouping(self):
it = parse_accesses(['123', '124'], None)
self.assertEqual(1, len(it))
it = it[0]
self.assertEqual('h', it.modbus_type)
self.assertEqual(123, it.address())
self.assertEqual('!H', it.pack_type())
self.assertEqual(None, it.presenter())
self.assertEqual(2, it.size())
def test_read_input_registers(self):
modbus = mocked_modbus()
modbus.receive = Mock(return_value=[4660, 22136])
access = Access('i', [123, 124], ['!H', '!H'])
access.perform(modbus)
modbus.protocol.read_input_registers.assert_called_once_with(42, 123, 2)
modbus.send.assert_called_once()
self.assertEqual([(4660,), (22136,)], access.values)
def test_read_holding_registers(self):
modbus = mocked_modbus()
modbus.receive = Mock(return_value=[4660, 22136])
access = Access('h', [123, 124], ['!H', '!H'])
access.perform(modbus)
modbus.protocol.read_holding_registers.assert_called_once_with(42, 123, 2)
modbus.send.assert_called_once()
self.assertEqual([(4660,), (22136,)], access.values)
def test_read_discrete_inputs(self):
modbus = mocked_modbus()
modbus.receive = Mock(return_value=[1, 0])
access = Access('d', [123, 124], ['!B', '!B'])
access.perform(modbus)
modbus.protocol.read_discrete_inputs.assert_called_once_with(42, 123, 2)
modbus.send.assert_called_once()
self.assertEqual([(1,), (0,)], access.values)
def test_read_coils(self):
modbus = mocked_modbus()
modbus.receive = Mock(return_value=[1, 0])
access = Access('c', [123, 124], ['!B', '!B'])
access.perform(modbus)
modbus.protocol.read_coils.assert_called_once_with(42, 123, 2)
modbus.send.assert_called_once()
self.assertEqual([(1,), (0,)], access.values)
def test_write_registers(self):
modbus = mocked_modbus()
access = Access('h', [123, 124], ['!H', '!H'], values=['10', '11'])
access.perform(modbus)
modbus.protocol.write_multiple_registers.assert_called_once_with(42, 123, [10, 11])
modbus.send.assert_called_once()
def test_write_coils(self):
modbus = mocked_modbus()
access = Access('c', [123, 124], ['!B', '!B'], values=['1', '0'])
access.perform(modbus)
modbus.protocol.write_multiple_coils.assert_called_once_with(42, 123, [1, 0])
modbus.send.assert_called_once()
def test_presenter(self):
pass
def test_endianness_read(self):
modbus = mocked_modbus()
modbus.receive = Mock(return_value=[4386, 13124])
def perform(byte_order, fields):
addresses = list(range(len(fields)))
access = Access('h', addresses, fields, byte_order=byte_order)
access.perform(modbus)
return access.values
self.assertEqual(perform('be', ['>H', '>H']), [(4386,), (13124,)])
self.assertEqual(perform('be', ['>I']), [(,)])
self.assertEqual(perform('le', ['<H', '<H']), [(8721,), (17459,)])
self.assertEqual(perform('le', ['<I']), [(,)])
self.assertEqual(perform('mixed', ['<H', '<H']), [(4386,), (13124,)])
self.assertEqual(perform('mixed', ['<I']), [(,)])
def test_endianness_write(self):
modbus = mocked_modbus()
values16 = ['0x1122', '0x3344']
values32 = ['0x']
def perform(byte_order, fields, values):
addresses = list(range(len(fields)))
access = Access('h', addresses, fields, values=values, byte_order=byte_order)
access.perform(modbus)
return modbus.protocol.write_multiple_registers.call_args.args[2]
self.assertEqual(perform('be', ['>H', '>H'], values16), [4386, 13124])
self.assertEqual(perform('be', ['>I'], values32), [4386, 13124])
self.assertEqual(perform('le', ['<H', '<H'], values16), [8721, 17459])
self.assertEqual(perform('le', ['<I'], values32), [17459, 8721])
self.assertEqual(perform('mixed', ['<H', '<H'], values16), [4386, 13124])
self.assertEqual(perform('mixed', ['<I'], values32), [13124, 4386]) |
def compare_responses(feature: str, subfeature: str, response, phase: str=''):
if phase:
response_path = os.path.join(features_path, feature, subfeature, phase, f'{subfeature}_{phase}_response.json')
else:
response_path = os.path.join(features_path, feature, subfeature, f'{subfeature}_response.json')
ignore_keys = []
try:
key_ignore_function_name = (((feature + '__') + subfeature) + '_ignore')
subfeature_normalized = subfeature.replace('_async', '')
imp = import_module(f'edenai_apis.features.{feature}.{subfeature_normalized}.ignore_keys')
ignore_keys = getattr(imp, key_ignore_function_name)()
except Exception:
pass
with open(response_path, 'r', encoding='utf-8') as f:
standard_response = json.load(f)
if ('original_response' in standard_response):
raise TypeError(f'Please remove original_response in {response_path}')
assert_standarization(standard_response, response, ignore_keys=ignore_keys)
return True |
class ProbabilityDistribution(ABC):
def neg_log_prob(self, actions: Any) -> Any:
return (- self.log_prob(actions))
def log_prob(self, actions: Any) -> Any:
raise NotImplementedError
def entropy(self) -> Any:
raise NotImplementedError
def kl(self, other: 'ProbabilityDistribution') -> Any:
raise NotImplementedError
def sample(self) -> Any:
raise NotImplementedError
def deterministic_sample(self) -> Any:
raise NotImplementedError |
class SecurityClient(NamespacedClient):
_rewrite_parameters(body_fields=('grant_type', 'access_token', 'password', 'username'))
def activate_user_profile(self, *, grant_type: t.Optional[t.Union[("t.Literal['access_token', 'password']", str)]]=None, access_token: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, password: t.Optional[str]=None, pretty: t.Optional[bool]=None, username: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if ((grant_type is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'grant_type'")
__path = '/_security/profile/_activate'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (grant_type is not None):
__body['grant_type'] = grant_type
if (access_token is not None):
__body['access_token'] = access_token
if (password is not None):
__body['password'] = password
if (username is not None):
__body['username'] = username
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters()
def authenticate(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/_authenticate'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters(body_fields=('password', 'password_hash'))
def change_password(self, *, username: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, password: t.Optional[str]=None, password_hash: t.Optional[str]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if (username not in SKIP_IN_PATH):
__path = f'/_security/user/{_quote(username)}/_password'
else:
__path = '/_security/user/_password'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
if (not __body):
if (password is not None):
__body['password'] = password
if (password_hash is not None):
__body['password_hash'] = password_hash
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters()
def clear_api_key_cache(self, *, ids: t.Union[(str, t.Sequence[str])], error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (ids in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'ids'")
__path = f'/_security/api_key/{_quote(ids)}/_clear_cache'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers)
_rewrite_parameters()
def clear_cached_privileges(self, *, application: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (application in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'application'")
__path = f'/_security/privilege/{_quote(application)}/_clear_cache'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers)
_rewrite_parameters()
def clear_cached_realms(self, *, realms: t.Union[(str, t.Sequence[str])], error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, usernames: t.Optional[t.Sequence[str]]=None) -> ObjectApiResponse[t.Any]:
if (realms in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'realms'")
__path = f'/_security/realm/{_quote(realms)}/_clear_cache'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (usernames is not None):
__query['usernames'] = usernames
__headers = {'accept': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers)
_rewrite_parameters()
def clear_cached_roles(self, *, name: t.Union[(str, t.Sequence[str])], error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/role/{_quote(name)}/_clear_cache'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers)
_rewrite_parameters()
def clear_cached_service_tokens(self, *, namespace: str, service: str, name: t.Union[(str, t.Sequence[str])], error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (namespace in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'namespace'")
if (service in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'service'")
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/service/{_quote(namespace)}/{_quote(service)}/credential/token/{_quote(name)}/_clear_cache'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers)
_rewrite_parameters(body_fields=('expiration', 'metadata', 'name', 'role_descriptors'))
def create_api_key(self, *, error_trace: t.Optional[bool]=None, expiration: t.Optional[t.Union[('t.Literal[-1]', 't.Literal[0]', str)]]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, metadata: t.Optional[t.Mapping[(str, t.Any)]]=None, name: t.Optional[str]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None, role_descriptors: t.Optional[t.Mapping[(str, t.Mapping[(str, t.Any)])]]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/api_key'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
if (not __body):
if (expiration is not None):
__body['expiration'] = expiration
if (metadata is not None):
__body['metadata'] = metadata
if (name is not None):
__body['name'] = name
if (role_descriptors is not None):
__body['role_descriptors'] = role_descriptors
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters()
def create_service_token(self, *, namespace: str, service: str, name: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (namespace in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'namespace'")
if (service in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'service'")
if ((namespace not in SKIP_IN_PATH) and (service not in SKIP_IN_PATH) and (name not in SKIP_IN_PATH)):
__path = f'/_security/service/{_quote(namespace)}/{_quote(service)}/credential/token/{_quote(name)}'
__method = 'PUT'
elif ((namespace not in SKIP_IN_PATH) and (service not in SKIP_IN_PATH)):
__path = f'/_security/service/{_quote(namespace)}/{_quote(service)}/credential/token'
__method = 'POST'
else:
raise ValueError("Couldn't find a path for the given parameters")
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request(__method, __path, params=__query, headers=__headers)
_rewrite_parameters()
def delete_privileges(self, *, application: str, name: t.Union[(str, t.Sequence[str])], error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (application in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'application'")
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/privilege/{_quote(application)}/{_quote(name)}'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('DELETE', __path, params=__query, headers=__headers)
_rewrite_parameters()
def delete_role(self, *, name: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/role/{_quote(name)}'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('DELETE', __path, params=__query, headers=__headers)
_rewrite_parameters()
def delete_role_mapping(self, *, name: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/role_mapping/{_quote(name)}'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('DELETE', __path, params=__query, headers=__headers)
_rewrite_parameters()
def delete_service_token(self, *, namespace: str, service: str, name: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (namespace in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'namespace'")
if (service in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'service'")
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/service/{_quote(namespace)}/{_quote(service)}/credential/token/{_quote(name)}'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('DELETE', __path, params=__query, headers=__headers)
_rewrite_parameters()
def delete_user(self, *, username: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (username in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'username'")
__path = f'/_security/user/{_quote(username)}'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('DELETE', __path, params=__query, headers=__headers)
_rewrite_parameters()
def disable_user(self, *, username: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (username in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'username'")
__path = f'/_security/user/{_quote(username)}/_disable'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers)
_rewrite_parameters()
def disable_user_profile(self, *, uid: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (uid in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'uid'")
__path = f'/_security/profile/{_quote(uid)}/_disable'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers)
_rewrite_parameters()
def enable_user(self, *, username: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (username in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'username'")
__path = f'/_security/user/{_quote(username)}/_enable'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers)
_rewrite_parameters()
def enable_user_profile(self, *, uid: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if (uid in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'uid'")
__path = f'/_security/profile/{_quote(uid)}/_enable'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__headers = {'accept': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers)
_rewrite_parameters()
def enroll_kibana(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/enroll/kibana'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def enroll_node(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/enroll/node'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_api_key(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, id: t.Optional[str]=None, name: t.Optional[str]=None, owner: t.Optional[bool]=None, pretty: t.Optional[bool]=None, realm_name: t.Optional[str]=None, username: t.Optional[str]=None, with_limited_by: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/api_key'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (id is not None):
__query['id'] = id
if (name is not None):
__query['name'] = name
if (owner is not None):
__query['owner'] = owner
if (pretty is not None):
__query['pretty'] = pretty
if (realm_name is not None):
__query['realm_name'] = realm_name
if (username is not None):
__query['username'] = username
if (with_limited_by is not None):
__query['with_limited_by'] = with_limited_by
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_builtin_privileges(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/privilege/_builtin'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_privileges(self, *, application: t.Optional[str]=None, name: t.Optional[t.Union[(str, t.Sequence[str])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if ((application not in SKIP_IN_PATH) and (name not in SKIP_IN_PATH)):
__path = f'/_security/privilege/{_quote(application)}/{_quote(name)}'
elif (application not in SKIP_IN_PATH):
__path = f'/_security/privilege/{_quote(application)}'
else:
__path = '/_security/privilege'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_role(self, *, name: t.Optional[t.Union[(str, t.Sequence[str])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (name not in SKIP_IN_PATH):
__path = f'/_security/role/{_quote(name)}'
else:
__path = '/_security/role'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_role_mapping(self, *, name: t.Optional[t.Union[(str, t.Sequence[str])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (name not in SKIP_IN_PATH):
__path = f'/_security/role_mapping/{_quote(name)}'
else:
__path = '/_security/role_mapping'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_service_accounts(self, *, namespace: t.Optional[str]=None, service: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if ((namespace not in SKIP_IN_PATH) and (service not in SKIP_IN_PATH)):
__path = f'/_security/service/{_quote(namespace)}/{_quote(service)}'
elif (namespace not in SKIP_IN_PATH):
__path = f'/_security/service/{_quote(namespace)}'
else:
__path = '/_security/service'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_service_credentials(self, *, namespace: str, service: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (namespace in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'namespace'")
if (service in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'service'")
__path = f'/_security/service/{_quote(namespace)}/{_quote(service)}/credential'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters(body_fields=('grant_type', 'kerberos_ticket', 'password', 'refresh_token', 'scope', 'username'))
def get_token(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, grant_type: t.Optional[t.Union[("t.Literal['_kerberos', 'client_credentials', 'password', 'refresh_token']", str)]]=None, human: t.Optional[bool]=None, kerberos_ticket: t.Optional[str]=None, password: t.Optional[str]=None, pretty: t.Optional[bool]=None, refresh_token: t.Optional[str]=None, scope: t.Optional[str]=None, username: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/oauth2/token'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (grant_type is not None):
__body['grant_type'] = grant_type
if (kerberos_ticket is not None):
__body['kerberos_ticket'] = kerberos_ticket
if (password is not None):
__body['password'] = password
if (refresh_token is not None):
__body['refresh_token'] = refresh_token
if (scope is not None):
__body['scope'] = scope
if (username is not None):
__body['username'] = username
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters()
def get_user(self, *, username: t.Optional[t.Union[(str, t.Sequence[str])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, with_profile_uid: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (username not in SKIP_IN_PATH):
__path = f'/_security/user/{_quote(username)}'
else:
__path = '/_security/user'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (with_profile_uid is not None):
__query['with_profile_uid'] = with_profile_uid
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_user_privileges(self, *, application: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, priviledge: t.Optional[str]=None, username: t.Optional[t.Union[(None, str)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/user/_privileges'
__query: t.Dict[(str, t.Any)] = {}
if (application is not None):
__query['application'] = application
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (priviledge is not None):
__query['priviledge'] = priviledge
if (username is not None):
__query['username'] = username
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters()
def get_user_profile(self, *, uid: t.Union[(str, t.Sequence[str])], data: t.Optional[t.Union[(str, t.Sequence[str])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (uid in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'uid'")
__path = f'/_security/profile/{_quote(uid)}'
__query: t.Dict[(str, t.Any)] = {}
if (data is not None):
__query['data'] = data
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters(body_fields=('api_key', 'grant_type', 'access_token', 'password', 'run_as', 'username'), ignore_deprecated_options={'api_key'})
def grant_api_key(self, *, api_key: t.Optional[t.Mapping[(str, t.Any)]]=None, grant_type: t.Optional[t.Union[("t.Literal['access_token', 'password']", str)]]=None, access_token: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, password: t.Optional[str]=None, pretty: t.Optional[bool]=None, run_as: t.Optional[str]=None, username: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if ((api_key is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'api_key'")
if ((grant_type is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'grant_type'")
__path = '/_security/api_key/grant'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (api_key is not None):
__body['api_key'] = api_key
if (grant_type is not None):
__body['grant_type'] = grant_type
if (access_token is not None):
__body['access_token'] = access_token
if (password is not None):
__body['password'] = password
if (run_as is not None):
__body['run_as'] = run_as
if (username is not None):
__body['username'] = username
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('application', 'cluster', 'index'))
def has_privileges(self, *, user: t.Optional[str]=None, application: t.Optional[t.Sequence[t.Mapping[(str, t.Any)]]]=None, cluster: t.Optional[t.Sequence[t.Union[("t.Literal['all', 'cancel_task', 'create_snapshot', 'grant_api_key', 'manage', 'manage_api_key', 'manage_ccr', 'manage_enrich', 'manage_ilm', 'manage_index_templates', 'manage_ingest_pipelines', 'manage_logstash_pipelines', 'manage_ml', 'manage_oidc', 'manage_own_api_key', 'manage_pipeline', 'manage_rollup', 'manage_saml', 'manage_security', 'manage_service_account', 'manage_slm', 'manage_token', 'manage_transform', 'manage_user_profile', 'manage_watcher', 'monitor', 'monitor_ml', 'monitor_rollup', 'monitor_snapshot', 'monitor_text_structure', 'monitor_transform', 'monitor_watcher', 'read_ccr', 'read_ilm', 'read_pipeline', 'read_slm', 'transport_client']", str)]]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, index: t.Optional[t.Sequence[t.Mapping[(str, t.Any)]]]=None, pretty: t.Optional[bool]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if (user not in SKIP_IN_PATH):
__path = f'/_security/user/{_quote(user)}/_has_privileges'
else:
__path = '/_security/user/_has_privileges'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (application is not None):
__body['application'] = application
if (cluster is not None):
__body['cluster'] = cluster
if (index is not None):
__body['index'] = index
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('privileges', 'uids'))
def has_privileges_user_profile(self, *, privileges: t.Optional[t.Mapping[(str, t.Any)]]=None, uids: t.Optional[t.Sequence[str]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if ((privileges is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'privileges'")
if ((uids is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'uids'")
__path = '/_security/profile/_has_privileges'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (privileges is not None):
__body['privileges'] = privileges
if (uids is not None):
__body['uids'] = uids
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('id', 'ids', 'name', 'owner', 'realm_name', 'username'))
def invalidate_api_key(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, id: t.Optional[str]=None, ids: t.Optional[t.Sequence[str]]=None, name: t.Optional[str]=None, owner: t.Optional[bool]=None, pretty: t.Optional[bool]=None, realm_name: t.Optional[str]=None, username: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/api_key'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (id is not None):
__body['id'] = id
if (ids is not None):
__body['ids'] = ids
if (name is not None):
__body['name'] = name
if (owner is not None):
__body['owner'] = owner
if (realm_name is not None):
__body['realm_name'] = realm_name
if (username is not None):
__body['username'] = username
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('DELETE', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('realm_name', 'refresh_token', 'token', 'username'))
def invalidate_token(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, realm_name: t.Optional[str]=None, refresh_token: t.Optional[str]=None, token: t.Optional[str]=None, username: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/oauth2/token'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (realm_name is not None):
__body['realm_name'] = realm_name
if (refresh_token is not None):
__body['refresh_token'] = refresh_token
if (token is not None):
__body['token'] = token
if (username is not None):
__body['username'] = username
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('DELETE', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_name='privileges')
def put_privileges(self, *, privileges: t.Optional[t.Mapping[(str, t.Mapping[(str, t.Mapping[(str, t.Any)])])]]=None, body: t.Optional[t.Mapping[(str, t.Mapping[(str, t.Mapping[(str, t.Any)])])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None) -> ObjectApiResponse[t.Any]:
if ((privileges is None) and (body is None)):
raise ValueError("Empty value passed for parameters 'privileges' and 'body', one of them should be set.")
elif ((privileges is not None) and (body is not None)):
raise ValueError("Cannot set both 'privileges' and 'body'")
__path = '/_security/privilege'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
__body = (privileges if (privileges is not None) else body)
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('applications', 'cluster', 'global_', 'indices', 'metadata', 'run_as', 'transient_metadata'), parameter_aliases={'global': 'global_'})
def put_role(self, *, name: str, applications: t.Optional[t.Sequence[t.Mapping[(str, t.Any)]]]=None, cluster: t.Optional[t.Sequence[t.Union[("t.Literal['all', 'cancel_task', 'create_snapshot', 'grant_api_key', 'manage', 'manage_api_key', 'manage_ccr', 'manage_enrich', 'manage_ilm', 'manage_index_templates', 'manage_ingest_pipelines', 'manage_logstash_pipelines', 'manage_ml', 'manage_oidc', 'manage_own_api_key', 'manage_pipeline', 'manage_rollup', 'manage_saml', 'manage_security', 'manage_service_account', 'manage_slm', 'manage_token', 'manage_transform', 'manage_user_profile', 'manage_watcher', 'monitor', 'monitor_ml', 'monitor_rollup', 'monitor_snapshot', 'monitor_text_structure', 'monitor_transform', 'monitor_watcher', 'read_ccr', 'read_ilm', 'read_pipeline', 'read_slm', 'transport_client']", str)]]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, global_: t.Optional[t.Mapping[(str, t.Any)]]=None, human: t.Optional[bool]=None, indices: t.Optional[t.Sequence[t.Mapping[(str, t.Any)]]]=None, metadata: t.Optional[t.Mapping[(str, t.Any)]]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None, run_as: t.Optional[t.Sequence[str]]=None, transient_metadata: t.Optional[t.Mapping[(str, t.Any)]]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/role/{_quote(name)}'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
if (not __body):
if (applications is not None):
__body['applications'] = applications
if (cluster is not None):
__body['cluster'] = cluster
if (global_ is not None):
__body['global'] = global_
if (indices is not None):
__body['indices'] = indices
if (metadata is not None):
__body['metadata'] = metadata
if (run_as is not None):
__body['run_as'] = run_as
if (transient_metadata is not None):
__body['transient_metadata'] = transient_metadata
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('enabled', 'metadata', 'roles', 'rules', 'run_as'))
def put_role_mapping(self, *, name: str, enabled: t.Optional[bool]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, metadata: t.Optional[t.Mapping[(str, t.Any)]]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None, roles: t.Optional[t.Sequence[str]]=None, rules: t.Optional[t.Mapping[(str, t.Any)]]=None, run_as: t.Optional[t.Sequence[str]]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if (name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'name'")
__path = f'/_security/role_mapping/{_quote(name)}'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
if (not __body):
if (enabled is not None):
__body['enabled'] = enabled
if (metadata is not None):
__body['metadata'] = metadata
if (roles is not None):
__body['roles'] = roles
if (rules is not None):
__body['rules'] = rules
if (run_as is not None):
__body['run_as'] = run_as
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('email', 'enabled', 'full_name', 'metadata', 'password', 'password_hash', 'roles'))
def put_user(self, *, username: str, email: t.Optional[t.Union[(None, str)]]=None, enabled: t.Optional[bool]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, full_name: t.Optional[t.Union[(None, str)]]=None, human: t.Optional[bool]=None, metadata: t.Optional[t.Mapping[(str, t.Any)]]=None, password: t.Optional[str]=None, password_hash: t.Optional[str]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None, roles: t.Optional[t.Sequence[str]]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if (username in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'username'")
__path = f'/_security/user/{_quote(username)}'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
if (not __body):
if (email is not None):
__body['email'] = email
if (enabled is not None):
__body['enabled'] = enabled
if (full_name is not None):
__body['full_name'] = full_name
if (metadata is not None):
__body['metadata'] = metadata
if (password is not None):
__body['password'] = password
if (password_hash is not None):
__body['password_hash'] = password_hash
if (roles is not None):
__body['roles'] = roles
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('from_', 'query', 'search_after', 'size', 'sort'), parameter_aliases={'from': 'from_'})
def query_api_keys(self, *, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, from_: t.Optional[int]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, query: t.Optional[t.Mapping[(str, t.Any)]]=None, search_after: t.Optional[t.Sequence[t.Union[(None, bool, float, int, str, t.Any)]]]=None, size: t.Optional[int]=None, sort: t.Optional[t.Union[(t.Sequence[t.Union[(str, t.Mapping[(str, t.Any)])]], t.Union[(str, t.Mapping[(str, t.Any)])])]]=None, with_limited_by: t.Optional[bool]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/_query/api_key'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if ((sort is not None) and ((isinstance(sort, str) and (':' in sort)) or (isinstance(sort, (list, tuple)) and all((isinstance(_x, str) for _x in sort)) and any(((':' in _x) for _x in sort))))):
__query['sort'] = sort
sort = None
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (with_limited_by is not None):
__query['with_limited_by'] = with_limited_by
if (not __body):
if (from_ is not None):
__body['from'] = from_
if (query is not None):
__body['query'] = query
if (search_after is not None):
__body['search_after'] = search_after
if (size is not None):
__body['size'] = size
if (sort is not None):
__body['sort'] = sort
if (not __body):
__body = None
__headers = {'accept': 'application/json'}
if (__body is not None):
__headers['content-type'] = 'application/json'
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('content', 'ids', 'realm'))
def saml_authenticate(self, *, content: t.Optional[str]=None, ids: t.Optional[t.Union[(str, t.Sequence[str])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, realm: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if ((content is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'content'")
if ((ids is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'ids'")
__path = '/_security/saml/authenticate'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (content is not None):
__body['content'] = content
if (ids is not None):
__body['ids'] = ids
if (realm is not None):
__body['realm'] = realm
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('ids', 'realm', 'content', 'query_string'))
def saml_complete_logout(self, *, ids: t.Optional[t.Union[(str, t.Sequence[str])]]=None, realm: t.Optional[str]=None, content: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, query_string: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if ((ids is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'ids'")
if ((realm is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'realm'")
__path = '/_security/saml/complete_logout'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (ids is not None):
__body['ids'] = ids
if (realm is not None):
__body['realm'] = realm
if (content is not None):
__body['content'] = content
if (query_string is not None):
__body['query_string'] = query_string
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('query_string', 'acs', 'realm'))
def saml_invalidate(self, *, query_string: t.Optional[str]=None, acs: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, realm: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if ((query_string is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'query_string'")
__path = '/_security/saml/invalidate'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (query_string is not None):
__body['query_string'] = query_string
if (acs is not None):
__body['acs'] = acs
if (realm is not None):
__body['realm'] = realm
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('token', 'refresh_token'))
def saml_logout(self, *, token: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, refresh_token: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if ((token is None) and (body is None)):
raise ValueError("Empty value passed for parameter 'token'")
__path = '/_security/saml/logout'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (token is not None):
__body['token'] = token
if (refresh_token is not None):
__body['refresh_token'] = refresh_token
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('acs', 'realm', 'relay_state'))
def saml_prepare_authentication(self, *, acs: t.Optional[str]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None, realm: t.Optional[str]=None, relay_state: t.Optional[str]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/saml/prepare'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (acs is not None):
__body['acs'] = acs
if (realm is not None):
__body['realm'] = realm
if (relay_state is not None):
__body['relay_state'] = relay_state
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters()
def saml_service_provider_metadata(self, *, realm_name: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, pretty: t.Optional[bool]=None) -> ObjectApiResponse[t.Any]:
if (realm_name in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'realm_name'")
__path = f'/_security/saml/metadata/{_quote(realm_name)}'
__query: t.Dict[(str, t.Any)] = {}
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
__headers = {'accept': 'application/json'}
return self.perform_request('GET', __path, params=__query, headers=__headers)
_rewrite_parameters(body_fields=('data', 'hint', 'name', 'size'))
def suggest_user_profiles(self, *, data: t.Optional[t.Union[(str, t.Sequence[str])]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, hint: t.Optional[t.Mapping[(str, t.Any)]]=None, human: t.Optional[bool]=None, name: t.Optional[str]=None, pretty: t.Optional[bool]=None, size: t.Optional[int]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
__path = '/_security/profile/_suggest'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (data is not None):
__body['data'] = data
if (hint is not None):
__body['hint'] = hint
if (name is not None):
__body['name'] = name
if (size is not None):
__body['size'] = size
if (not __body):
__body = None
__headers = {'accept': 'application/json'}
if (__body is not None):
__headers['content-type'] = 'application/json'
return self.perform_request('POST', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('metadata', 'role_descriptors'))
def update_api_key(self, *, id: str, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, metadata: t.Optional[t.Mapping[(str, t.Any)]]=None, pretty: t.Optional[bool]=None, role_descriptors: t.Optional[t.Mapping[(str, t.Mapping[(str, t.Any)])]]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if (id in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'id'")
__path = f'/_security/api_key/{_quote(id)}'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (pretty is not None):
__query['pretty'] = pretty
if (not __body):
if (metadata is not None):
__body['metadata'] = metadata
if (role_descriptors is not None):
__body['role_descriptors'] = role_descriptors
if (not __body):
__body = None
__headers = {'accept': 'application/json'}
if (__body is not None):
__headers['content-type'] = 'application/json'
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body)
_rewrite_parameters(body_fields=('data', 'labels'))
def update_user_profile_data(self, *, uid: str, data: t.Optional[t.Mapping[(str, t.Any)]]=None, error_trace: t.Optional[bool]=None, filter_path: t.Optional[t.Union[(str, t.Sequence[str])]]=None, human: t.Optional[bool]=None, if_primary_term: t.Optional[int]=None, if_seq_no: t.Optional[int]=None, labels: t.Optional[t.Mapping[(str, t.Any)]]=None, pretty: t.Optional[bool]=None, refresh: t.Optional[t.Union[("t.Literal['false', 'true', 'wait_for']", bool, str)]]=None, body: t.Optional[t.Dict[(str, t.Any)]]=None) -> ObjectApiResponse[t.Any]:
if (uid in SKIP_IN_PATH):
raise ValueError("Empty value passed for parameter 'uid'")
__path = f'/_security/profile/{_quote(uid)}/_data'
__query: t.Dict[(str, t.Any)] = {}
__body: t.Dict[(str, t.Any)] = (body if (body is not None) else {})
if (error_trace is not None):
__query['error_trace'] = error_trace
if (filter_path is not None):
__query['filter_path'] = filter_path
if (human is not None):
__query['human'] = human
if (if_primary_term is not None):
__query['if_primary_term'] = if_primary_term
if (if_seq_no is not None):
__query['if_seq_no'] = if_seq_no
if (pretty is not None):
__query['pretty'] = pretty
if (refresh is not None):
__query['refresh'] = refresh
if (not __body):
if (data is not None):
__body['data'] = data
if (labels is not None):
__body['labels'] = labels
__headers = {'accept': 'application/json', 'content-type': 'application/json'}
return self.perform_request('PUT', __path, params=__query, headers=__headers, body=__body) |
class OptionPlotoptionsColumnpyramidSonificationTracksActivewhen(Options):
def crossingDown(self):
return self._config_get(None)
def crossingDown(self, num: float):
self._config(num, js_type=False)
def crossingUp(self):
return self._config_get(None)
def crossingUp(self, num: float):
self._config(num, 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 prop(self):
return self._config_get(None)
def prop(self, text: str):
self._config(text, js_type=False) |
def upgrade():
with op.batch_alter_table('groups', schema=None) as batch_op:
batch_op.add_column(sa.Column('makehidden', sa.Boolean(), nullable=True, default=False))
batch_op.add_column(sa.Column('viewhidden', sa.Boolean(), nullable=True, default=False))
with op.batch_alter_table('groups', schema=None) as batch_op:
groups = sa.sql.table('groups', sa.sql.column('viewhidden'), sa.sql.column('makehidden'), sa.sql.column('admin'), sa.sql.column('super_mod'), sa.sql.column('mod'))
batch_op.execute(groups.update().where(sa.or_((groups.c.admin == True), (groups.c.mod == True), (groups.c.super_mod == True))).values(viewhidden=True, makehidden=True))
batch_op.execute(groups.update().where(sa.and_((groups.c.admin != True), (groups.c.mod != True), (groups.c.super_mod != True))).values(viewhidden=False, makehidden=False))
batch_op.alter_column('viewhidden', existing_type=sa.Boolean(), nullable=False)
batch_op.alter_column('makehidden', existing_type=sa.Boolean(), nullable=False)
with op.batch_alter_table('posts', schema=None) as batch_op:
batch_op.add_column(sa.Column('hidden', sa.Boolean(), nullable=True, default=False))
batch_op.add_column(sa.Column('hidden_at', flaskbb.utils.database.UTCDateTime(timezone=True), nullable=True))
batch_op.add_column(sa.Column('hidden_by_id', sa.Integer(), nullable=True))
batch_op.create_foreign_key('fk_Post_hidden_by', 'users', ['hidden_by_id'], ['id'])
with op.batch_alter_table('posts', schema=None) as batch_op:
posts = sa.sql.table('posts', sa.sql.column('hidden'))
batch_op.execute(posts.update().values(hidden=False))
batch_op.alter_column('hidden', existing_type=sa.Boolean(), nullable=False)
with op.batch_alter_table('topics', schema=None) as batch_op:
batch_op.add_column(sa.Column('hidden', sa.Boolean(), nullable=True))
batch_op.add_column(sa.Column('hidden_at', flaskbb.utils.database.UTCDateTime(timezone=True), nullable=True))
batch_op.add_column(sa.Column('hidden_by_id', sa.Integer(), nullable=True))
batch_op.create_foreign_key('fk_Topic_hidden_by', 'users', ['hidden_by_id'], ['id'])
with op.batch_alter_table('topics', schema=None) as batch_op:
topics = sa.sql.table('topics', sa.sql.column('hidden'))
batch_op.execute(topics.update().values(hidden=False))
batch_op.alter_column('hidden', existing_type=sa.Boolean(), nullable=False) |
class FakeObjectGenerator():
def __init__(self, graph: Optional[TraceGraph]=None, run_id: int=0) -> None:
self.reinit(run_id)
self.graph = graph
def reinit(self, run_id) -> None:
self.saver = BulkSaver()
self.handle = 0
self.source_name_id = 0
self.sink_name_id = 0
self.shared_text_name_id = 0
self.run_id = run_id
def save_all(self, db, before_save: Optional[Callable[([], None)]]=None) -> None:
if self.graph:
self.graph.update_bulk_saver(self.saver)
self.saver.save_all(db, before_save=before_save)
self.saver = BulkSaver()
def issue(self, callable: str='Foo.barMethod', handle=None, code=None, status: str='uncategorized'):
self.handle += 1
now = datetime.datetime.now()
callable = self.callable(callable)
result = Issue.Record(id=IssueDBID(), handle=(str(self.handle) if (not handle) else handle), code=(code or (6015 + self.handle)), callable_id=callable.id, status=status, detected_time=now.timestamp())
if self.graph:
self.graph.add_issue(result)
else:
self.saver.add(result)
return result
def precondition(self, caller: str='double_meh', caller_port: str='at the end of universe', callee: str='triple_meh', callee_port: str='at the beginning of time', filename: str='lib/server/posts/request.py', location=(4, 5, 6), leaves=None, reachability=FrameReachability.UNREACHABLE, preserves_type_context: bool=False, type_interval_lower: int=5, type_interval_upper: int=7, run_id=None):
leaves = (leaves or [])
filename_record = self.filename(filename)
caller_record = self.callable(caller)
callee_record = self.callable(callee)
trace_frame = TraceFrame.Record(extra_fields=['leaf_mapping'], leaf_mapping={LeafMapping(leaf.id.local_id, leaf.id.local_id, leaf.id.local_id) for (leaf, _) in leaves if ((leaf.kind == SharedTextKind.source) or (leaf.kind == SharedTextKind.sink))}, id=DBID(), kind=TraceKind.PRECONDITION, caller_id=caller_record.id, caller_port=caller_port, callee_id=callee_record.id, callee_port=callee_port, callee_location=SourceLocation(location[0], location[1], location[2]), filename_id=filename_record.id, titos=[], run_id=(run_id or self.run_id), type_interval_lower=type_interval_lower, type_interval_upper=type_interval_upper, preserves_type_context=preserves_type_context, reachability=reachability)
if self.graph:
self.graph.add_trace_frame(trace_frame)
for (leaf, depth) in leaves:
self.graph.add_trace_frame_leaf_assoc(trace_frame, leaf, depth)
else:
self.saver.add(trace_frame)
return trace_frame
def postcondition(self, caller: str='quadruple_meh', caller_port: str='caller_meh', callee: str='quintuple_meh', callee_port: str='callee_meh', filename: str='lib/server/posts/response.py', location=(4, 5, 6), leaves=None, preserves_type_context: bool=False, type_interval_lower: int=5, type_interval_upper: int=7, run_id=None):
leaves = (leaves or [])
filename_record = self.filename(filename)
caller_record = self.callable(caller)
callee_record = self.callable(callee)
trace_frame = TraceFrame.Record(extra_fields=['leaf_mapping'], leaf_mapping={LeafMapping(leaf.id.local_id, leaf.id.local_id, leaf.id.local_id) for (leaf, _) in leaves if ((leaf.kind == SharedTextKind.source) or (leaf.kind == SharedTextKind.sink))}, id=DBID(), kind=TraceKind.POSTCONDITION, caller_id=caller_record.id, caller_port=caller_port, callee_id=callee_record.id, callee_port=callee_port, callee_location=SourceLocation(location[0], location[1], location[2]), filename_id=filename_record.id, titos=[], run_id=(run_id or self.run_id), type_interval_lower=type_interval_lower, type_interval_upper=type_interval_upper, preserves_type_context=preserves_type_context, reachability=FrameReachability.UNREACHABLE)
if self.graph:
self.graph.add_trace_frame(trace_frame)
for (leaf, depth) in leaves:
self.graph.add_trace_frame_leaf_assoc(trace_frame, leaf, depth)
else:
self.saver.add(trace_frame)
return trace_frame
def shared_text(self, contents, kind):
if self.graph:
shared_text = self.graph.get_shared_text(kind, contents)
if (shared_text is not None):
return shared_text
result = SharedText.Record(id=DBID(), contents=contents, kind=kind)
if self.graph:
self.graph.add_shared_text(result)
else:
self.saver.add(result)
return result
def run(self, differential_id=None, job_id=None, kind=None):
self.run_id += 1
return Run(id=DBID(self.run_id), date=datetime.datetime.now(), hh_version='', revision_id=12345, differential_id=differential_id, job_id=job_id, kind=kind)
def metarun(self, status=RunStatus.FINISHED, kind='test_metarun'):
self.metarun_id += 1
return MetaRun(id=DBID(self.metarun_id), date=datetime.datetime.now(), kind=kind, status=status)
def feature(self, name: str='via:feature'):
return self.shared_text(contents=name, kind=SharedTextKind.FEATURE)
def source(self, name: str='source'):
return self.shared_text(contents=name, kind=SharedTextKind.SOURCE)
def source_detail(self, name: str='source_detail'):
return self.shared_text(contents=name, kind=SharedTextKind.SOURCE_DETAIL)
def sink(self, name: str='sink'):
return self.shared_text(contents=name, kind=SharedTextKind.SINK)
def sink_detail(self, name: str='sink_detail'):
return self.shared_text(contents=name, kind=SharedTextKind.SINK_DETAIL)
def filename(self, name: str='/r/some/filename.py'):
return self.shared_text(contents=name, kind=SharedTextKind.FILENAME)
def callable(self, name: str='Foo.barMethod'):
return self.shared_text(contents=name, kind=SharedTextKind.CALLABLE)
def message(self, name: str='this is bad'):
return self.shared_text(contents=name, kind=SharedTextKind.MESSAGE)
def instance(self, message: str='this is bad', filename: str='/r/some/filename.py', callable: str='Foo.barMethod', issue_id=None, min_trace_length_to_sources=None, min_trace_length_to_sinks=None, purge_status=PurgeStatusForInstance.none, run_id=None, archive_if_new_issue=True):
issue_id = (issue_id if (issue_id is not None) else DBID(1))
filename = self.filename(filename)
message = self.message(message)
callable = self.callable(callable)
result = IssueInstance.Record(id=DBID(), location=SourceLocation(6, 7, 8), filename_id=filename.id, message_id=message.id, callable_id=callable.id, run_id=(run_id or self.run_id), issue_id=issue_id, min_trace_length_to_sources=min_trace_length_to_sources, min_trace_length_to_sinks=min_trace_length_to_sinks, purge_status=purge_status, archive_if_new_issue=archive_if_new_issue)
if self.graph:
self.graph.add_issue_instance(result)
else:
self.saver.add(result)
return result
def fix_info(self):
result = IssueInstanceFixInfo.Record(id=DBID(), fix_info='fixthis')
if self.graph:
self.graph.add_fix_info(result)
else:
self.saver.add(result)
return result
def class_type_interval(self, class_name: str='\\Foo', lower_bound: int=0, upper_bound: int=100, run_id=None) -> ClassTypeInterval:
interval = ClassTypeInterval.Record(id=DBID(), run_id=(run_id or self.run_id), class_name=class_name, lower_bound=lower_bound, upper_bound=upper_bound)
if self.graph:
self.graph.add_class_type_interval(interval)
else:
self.saver.add(interval)
return interval |
class OptionSeriesTilemapSonificationDefaultinstrumentoptionsMapping(Options):
def frequency(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingFrequency':
return self._config_sub_data('frequency', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingFrequency)
def gapBetweenNotes(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingGapbetweennotes':
return self._config_sub_data('gapBetweenNotes', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingGapbetweennotes)
def highpass(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingHighpass':
return self._config_sub_data('highpass', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingHighpass)
def lowpass(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingLowpass':
return self._config_sub_data('lowpass', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingLowpass)
def noteDuration(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingNoteduration':
return self._config_sub_data('noteDuration', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingNoteduration)
def pan(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingPan':
return self._config_sub_data('pan', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingPan)
def pitch(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingPitch':
return self._config_sub_data('pitch', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingPitch)
def playDelay(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingPlaydelay':
return self._config_sub_data('playDelay', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingPlaydelay)
def time(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingTime':
return self._config_sub_data('time', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingTime)
def tremolo(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingTremolo':
return self._config_sub_data('tremolo', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingTremolo)
def volume(self) -> 'OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingVolume':
return self._config_sub_data('volume', OptionSeriesTilemapSonificationDefaultinstrumentoptionsMappingVolume) |
class DateConverter(FancyValidator):
accept_day = True
month_style = 'mdy'
separator = '/'
datetime_module = None
_month_names = {'jan': 1, 'january': 1, 'feb': 2, 'febuary': 2, 'mar': 3, 'march': 3, 'apr': 4, 'april': 4, 'may': 5, 'jun': 6, 'june': 6, 'jul': 7, 'july': 7, 'aug': 8, 'august': 8, 'sep': 9, 'sept': 9, 'september': 9, 'oct': 10, 'october': 10, 'nov': 11, 'november': 11, 'dec': 12, 'december': 12}
_date_re = dict(dmy=re.compile(('^\\s*(\\d\\d?)[\\-\\./\\\\](\\d\\d?|%s)[\\-\\./\\\\](\\d\\d\\d?\\d?)\\s*$' % '|'.join(_month_names)), re.I), mdy=re.compile(('^\\s*(\\d\\d?|%s)[\\-\\./\\\\](\\d\\d?)[\\-\\./\\\\](\\d\\d\\d?\\d?)\\s*$' % '|'.join(_month_names)), re.I), ymd=re.compile(('^\\s*(\\d\\d\\d?\\d?)[\\-\\./\\\\](\\d\\d?|%s)[\\-\\./\\\\](\\d\\d?)\\s*$' % '|'.join(_month_names)), re.I), my=re.compile(('^\\s*(\\d\\d?|%s)[\\-\\./\\\\](\\d\\d\\d?\\d?)\\s*$' % '|'.join(_month_names)), re.I), ym=re.compile(('^\\s*(\\d\\d\\d?\\d?)[\\-\\./\\\\](\\d\\d?|%s)\\s*$' % '|'.join(_month_names)), re.I))
_formats = dict(d='%d', m='%m', y='%Y')
_human_formats = dict(d=_('DD'), m=_('MM'), y=_('YYYY'))
_monthDays = {1: 31, 2: 29, 3: 31, 4: 30, 5: 31, 6: 30, 7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
messages = dict(badFormat=_('Please enter the date in the form %(format)s'), monthRange=_('Please enter a month from 1 to 12'), invalidDay=_('Please enter a valid day'), dayRange=_('That month only has %(days)i days'), invalidDate=_('That is not a valid day (%(exception)s)'), unknownMonthName=_('Unknown month name: %(month)s'), invalidYear=_('Please enter a number for the year'), fourDigitYear=_('Please enter a four-digit year after 1899'), wrongFormat=_('Please enter the date in the form %(format)s'))
def __init__(self, *args, **kw):
super(DateConverter, self).__init__(*args, **kw)
month_style = (self.month_style or DateConverter.month_style).lower()
accept_day = bool(self.accept_day)
self.accept_day = self.accept_day
if (month_style in ('mdy', 'md', 'mm/dd/yyyy', 'mm/dd', 'us', 'american')):
month_style = 'mdy'
elif (month_style in ('dmy', 'dm', 'dd/mm/yyyy', 'dd/mm', 'euro', 'european')):
month_style = 'dmy'
elif (month_style in ('ymd', 'ym', 'yyyy/mm/dd', 'yyyy/mm', 'iso', 'china', 'chinese')):
month_style = 'ymd'
else:
raise TypeError(('Bad month_style: %r' % month_style))
self.month_style = month_style
separator = self.separator
if ((not separator) or (separator == 'auto')):
separator = dict(mdy='/', dmy='.', ymd='-')[month_style]
elif (separator not in ('-', '.', '/', '\\')):
raise TypeError(('Bad separator: %r' % separator))
self.separator = separator
self.format = separator.join((self._formats[part] for part in month_style if ((part != 'd') or accept_day)))
self.human_format = separator.join((self._human_formats[part] for part in month_style if ((part != 'd') or accept_day)))
def _convert_to_python(self, value, state):
self.assert_string(value, state)
month_style = self.month_style
if (not self.accept_day):
month_style = ('ym' if (month_style == 'ymd') else 'my')
match = self._date_re[month_style].search(value)
if (not match):
raise Invalid(self.message('badFormat', state, format=self.human_format), value, state)
groups = match.groups()
if self.accept_day:
if (month_style == 'mdy'):
(month, day, year) = groups
elif (month_style == 'dmy'):
(day, month, year) = groups
else:
(year, month, day) = groups
day = int(day)
if (not (1 <= day <= 31)):
raise Invalid(self.message('invalidDay', state), value, state)
else:
day = 1
if (month_style == 'my'):
(month, year) = groups
else:
(year, month) = groups
month = self.make_month(month, state)
if (not (1 <= month <= 12)):
raise Invalid(self.message('monthRange', state), value, state)
if (self._monthDays[month] < day):
raise Invalid(self.message('dayRange', state, days=self._monthDays[month]), value, state)
year = self.make_year(year, state)
dt_mod = import_datetime(self.datetime_module)
try:
return datetime_makedate(dt_mod, year, month, day)
except ValueError as v:
raise Invalid(self.message('invalidDate', state, exception=str(v)), value, state)
def make_month(self, value, state):
try:
return int(value)
except ValueError:
try:
return self._month_names[value.lower().strip()]
except KeyError:
raise Invalid(self.message('unknownMonthName', state, month=value), value, state)
def make_year(self, year, state):
try:
year = int(year)
except ValueError:
raise Invalid(self.message('invalidYear', state), year, state)
if (year <= 20):
year += 2000
elif (50 <= year < 100):
year += 1900
if ((20 < year < 50) or (99 < year < 1900)):
raise Invalid(self.message('fourDigitYear', state), year, state)
return year
def _convert_from_python(self, value, state):
if ((self.if_empty is not NoDefault) and (not value)):
return ''
return value.strftime(self.format) |
class TestRelational(unittest.TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
(**filter_test_cases_by_params({TestEnv.CUDA_LESS_THAN_SM80: [param(ops.le, 'le', 'float16', 3), param(ops.le, 'lt', 'float16', 3)], TestEnv.CUDA_SM80: [param(ops.le, 'le', 'bfloat16', 3), param(ops.le, 'lt', 'bfloat16', 3), param(ops.gt, 'gt', 'float32', 8), param(ops.ne, 'ne', 'float', 1), param(ops.eq, 'eq', 'float', 16)], TestEnv.ROCM: [param(ops.le, 'le', 'float16', 3), param(ops.le, 'lt', 'float16', 3)]}))
def test_end_to_end(self, operator: type, test_name: str, dtype: str, M: int) -> None:
dim = IntVar([2, 3, 128])
X1 = gen_input_tensor([dim, M], name='X1', dtype=dtype)
X2 = gen_input_tensor([dim, M], name='X2', dtype=dtype)
add = ops.elementwise(FuncEnum.ADD)(X1, X2)
X3 = gen_input_tensor([dim, M], name='X3', dtype=dtype)
Y = operator()(add, X3)
Y._attrs['name'] = 'Y'
Y._attrs['is_output'] = True
target = detect_target()
model = compile_model(Y, target, './tmp', f'test_relational_{test_name}')
for batch in dim._attrs['values']:
x1_pt = get_random_torch_tensor([batch, M], dtype)
x2_pt = get_random_torch_tensor([batch, M], dtype)
x3_pt = get_random_torch_tensor([batch, M], dtype)
add_pt = (x1_pt + x2_pt)
y_pt = ait_to_torch_map[operator](add_pt, x3_pt)
y = get_torch_empty_tensor(y_pt.size(), dtype='bool')
inputs = {'X1': x1_pt, 'X2': x2_pt, 'X3': x3_pt}
model.run_with_tensors(inputs, [y])
self.assertEqual(y_pt.tolist(), y.tolist())
def test_unsupport_type_promotion(self) -> None:
dim = IntVar([1, 128])
X1 = Tensor([dim, 10], name='X1', is_input=True, dtype='float16')
X2 = Tensor([dim, 10], name='X2', is_input=True, dtype='float32')
with self.assertRaisesRegex(AssertionError, 'Type promotions are not supported'):
ops.ge()(X1, X2)
def test_unsupport_different_shapes(self) -> None:
X1 = Tensor([IntVar([1, 128]), 10], name='X1', is_input=True, dtype='float16')
X2 = Tensor([IntVar([10, 128]), 10], name='X2', is_input=True, dtype='float16')
with self.assertRaisesRegex(AssertionError, 'Relational does not support broadcasting yet. It expects tensor of same shape'):
ops.ge()(X1, X2)
def test_constant(self) -> None:
X1 = Tensor([IntVar([1, 128]), 10], name='X1', is_input=True, dtype='float16')
X2 = 2
Y = ops.ge()(X1, X2)
Y._attrs['name'] = 'Y'
Y._attrs['is_output'] = True
target = detect_target()
model = compile_model(Y, target, './tmp', 'test_relational_test_constant')
x1_pt = get_random_torch_tensor([128, 10], dtype='float16')
inputs = {'X1': x1_pt}
y_pt = ait_to_torch_map[ops.ge](x1_pt, 2)
y = get_torch_empty_tensor(y_pt.size(), dtype='bool')
model.run_with_tensors(inputs, [y])
self.assertEqual(y_pt.tolist(), y.tolist())
([param('int32', 3), param('int32', 2), param('int64', 3), param('int64', 2)])
def test_int_support(self, dtype: str, M: int) -> None:
dim = IntVar([2, 3, 128])
X1 = gen_input_tensor([dim, M], name='X1', dtype=dtype)
X2 = gen_input_tensor([dim, M], name='X2', dtype=dtype)
Y = ops.ge()(X1, X2)
Y._attrs['name'] = 'Y'
Y._attrs['is_output'] = True
target = detect_target()
model = compile_model(Y, target, './tmp', f'test_relational_int_{dtype}_{M}')
for batch in dim._attrs['values']:
x1_pt = get_random_torch_tensor([batch, M], 'float32').to((torch.int32 if (dtype == 'int32') else torch.int64))
x2_pt = get_random_torch_tensor([batch, M], 'float32').to((torch.int32 if (dtype == 'int32') else torch.int64))
y_pt = ait_to_torch_map[ops.ge](x1_pt, x2_pt)
y = get_torch_empty_tensor(y_pt.size(), dtype='bool')
inputs = {'X1': x1_pt, 'X2': x2_pt}
model.run_with_tensors(inputs, [y])
self.assertEqual(y_pt.tolist(), y.tolist()) |
class OptionPlotoptionsAreasplineSonificationContexttracksMappingTremolo(Options):
def depth(self) -> 'OptionPlotoptionsAreasplineSonificationContexttracksMappingTremoloDepth':
return self._config_sub_data('depth', OptionPlotoptionsAreasplineSonificationContexttracksMappingTremoloDepth)
def speed(self) -> 'OptionPlotoptionsAreasplineSonificationContexttracksMappingTremoloSpeed':
return self._config_sub_data('speed', OptionPlotoptionsAreasplineSonificationContexttracksMappingTremoloSpeed) |
def extractTailor31415WordpressCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('YBPGVW', 'You Boys Play Games Very Well~', 'translated'), ('Egg is Lost', 'President, Our Egg Is Lost', 'translated'), ('pay attention to me', 'pay attention to me', '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)
titlemap = [('YBPGVW', 'You Boys Play Games Very Well~', 'translated'), ('Tensei Shoujo no Rirekisho', 'Tensei Shoujo no Rirekisho', 'translated'), ('Master of Dungeon', 'Master of Dungeon', 'oel')]
for (titlecomponent, name, tl_type) in titlemap:
if (titlecomponent.lower() in item['title'].lower()):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class OptionSeriesVariablepieData(Options):
def accessibility(self) -> 'OptionSeriesVariablepieDataAccessibility':
return self._config_sub_data('accessibility', OptionSeriesVariablepieDataAccessibility)
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 colorIndex(self):
return self._config_get(None)
def colorIndex(self, num: float):
self._config(num, js_type=False)
def custom(self):
return self._config_get(None)
def custom(self, value: Any):
self._config(value, js_type=False)
def dataLabels(self) -> 'OptionSeriesVariablepieDataDatalabels':
return self._config_sub_data('dataLabels', OptionSeriesVariablepieDataDatalabels)
def description(self):
return self._config_get(None)
def description(self, text: str):
self._config(text, js_type=False)
def dragDrop(self) -> 'OptionSeriesVariablepieDataDragdrop':
return self._config_sub_data('dragDrop', OptionSeriesVariablepieDataDragdrop)
def drilldown(self):
return self._config_get(None)
def drilldown(self, text: str):
self._config(text, js_type=False)
def events(self) -> 'OptionSeriesVariablepieDataEvents':
return self._config_sub_data('events', OptionSeriesVariablepieDataEvents)
def id(self):
return self._config_get(None)
def id(self, text: str):
self._config(text, js_type=False)
def labelrank(self):
return self._config_get(None)
def labelrank(self, num: float):
self._config(num, js_type=False)
def legendIndex(self):
return self._config_get(None)
def legendIndex(self, num: float):
self._config(num, js_type=False)
def name(self):
return self._config_get(None)
def name(self, text: str):
self._config(text, js_type=False)
def selected(self):
return self._config_get(False)
def selected(self, flag: bool):
self._config(flag, js_type=False)
def sliced(self):
return self._config_get(None)
def sliced(self, flag: bool):
self._config(flag, js_type=False)
def y(self):
return self._config_get(None)
def y(self, num: float):
self._config(num, js_type=False) |
class AngrHarness(Harness):
def angr_load_registers(self, uc: Uc, state: angr.SimState) -> None:
angr_regs = dir(state.regs)
unicorn_regs = self.arch.reg_names
if (self.arch == X86):
angr_regs += ['cr0', 'mxcsr']
elif (self.arch == X86_64):
angr_regs += ['cr0', 'mxcsr', 'fs_base', 'gs_base']
supported_regs = set(angr_regs)
for reg in unicorn_regs:
if (reg not in supported_regs):
print('Unicorn reg not supported in angr(?): {}'.format(reg))
else:
name = reg
value = self.uc_reg_read(uc, reg)
if (name == 'mxcsr'):
state.regs.sseround = ((value & 1536) >> 9)
elif (name == 'cr0'):
x86g_dirtyhelper_write_cr0(state, value)
else:
name = name.replace('_base', '_const')
try:
state.registers.store(name, value)
except Exception as ex:
print('Failed to retrieve register {}: {}'.format(reg, ex))
def __init__(self, config) -> None:
super().__init__(config)
def angr_fetch_and_load(self, state: angr.SimState, addr: int, length: Base=claripy.BVV(1, 32)) -> None:
if (not hasattr(state, 'ucf_mapped_addrs')):
state.ucf_mapped_addrs = set()
try:
len_concrete = state.solver.eval(length)
except Exception as ex:
print("[!] Couldn't solve len for mem at 0x{:016x}: 0x{:0x16x} - falling back to len 1".format(addr, ex))
len_concrete = 1
for sub_addr in range(addr, (addr + len_concrete), self.config.PAGE_SIZE):
if (self.get_base(sub_addr) in state.ucf_mapped_addrs):
return
print('[+] Fetching page for addr 0x{:016x} from `ucf attach`'.format(sub_addr))
(base_addr, content) = self.fetch_page_blocking(sub_addr)
angr_store_mem(state, base_addr, content)
def angr_load_mapped_pages(self, uc: Uc, state: angr.SimState) -> List[Tuple[(int, int, int)]]:
mapped = []
for (begin, end, perms) in uc.mem_regions():
mapped += (begin, ((end - begin) + 1), perms)
angr_store_mem(state, begin, bytes(uc.mem_read(begin, ((end - begin) + 1))))
return mapped
def get_angry(self, input_file: str) -> None:
(uc, pc, exits) = self.uc_init(input_file, wait=True)
print('Starting angrification at 0x{:016x}'.format(pc))
(base_addr, content) = self.fetch_page_blocking(pc)
pagepath = self.path_for_page(pc)
p = angr.Project(pagepath, load_options={'main_opts': {'backend': 'blob', 'base_addr': base_addr, 'arch': self.arch.angr_arch, 'page_size': self.config.PAGE_SIZE}})
state = p.factory.blank_state(addr=pc, add_options=((angr.options.unicorn | {angr.options.REPLACEMENT_SOLVER}) | {angr.options.ZERO_FILL_UNCONSTRAINED_REGISTERS}))
state.ucf_mapped_addrs = set()
self.angr_load_mapped_pages(uc, state)
self.angr_load_registers(uc, state)
state.inspect.b('mem_read', when=angr.BP_AFTER, action=(lambda x: self.angr_fetch_and_load(x, x.inspect.mem_read_address, x.inspect.mem_read_length)))
state.inspect.b('mem_write', when=angr.BP_AFTER, action=(lambda x: self.angr_fetch_and_load(x, x.inspect.mem_write_address, x.inspect.mem_write_length)))
rdi = self.uc_reg_read(uc, 'rdi')
(base_addr, content) = self.fetch_page_blocking(rdi)
with open(input_file, 'rb') as f:
in_content = f.read()
input_symbolic = claripy.BVS('input', (len(in_content) * 8))
state.preconstrainer.preconstrain(in_content, input_symbolic)
state.regs.rsi = len(in_content)
state.memory.store(rdi, input_symbolic)
simgr = p.factory.simulation_manager(state)
simgr.use_technique(PageForwardingExplorer(self.fetch_page_blocking))
simgr.use_technique(angr.exploration_techniques.DFS())
while simgr.active:
print(simgr)
print(simgr.active)
print(simgr.errored)
simgr.step()
return |
class OptionSeriesBarSonificationContexttracksActivewhen(Options):
def crossingDown(self):
return self._config_get(None)
def crossingDown(self, num: float):
self._config(num, js_type=False)
def crossingUp(self):
return self._config_get(None)
def crossingUp(self, num: float):
self._config(num, 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 prop(self):
return self._config_get(None)
def prop(self, text: str):
self._config(text, js_type=False) |
.gui()
.skipif(utils.has_grim_support(), reason='Non-grim compatible platform test')
def test_capture_with_grim_mocked(monkeypatch, caplog, qapp):
called_kwargs = {}
test_image_size = (640, 480)
def mocked_which(*args):
return '/some/path'
def mocked_run(args, **kwargs):
called_kwargs['args'] = args
called_kwargs['kwargs'] = kwargs
image_path = args[(- 1)]
screenshot = QtGui.QImage(QtCore.QSize(*test_image_size), QtGui.QImage.Format.Format_RGB32)
screenshot.save(image_path)
return subprocess.CompletedProcess(args='', returncode=0, stdout='', stderr='')
monkeypatch.setattr(utils.shutil, 'which', mocked_which)
monkeypatch.setattr(utils.subprocess, 'run', mocked_run)
monkeypatch.setattr(grim.subprocess, 'run', mocked_run)
assert utils.has_grim_support()
images = capture()
assert images
assert all((isinstance(i, QtGui.QImage) for i in images))
assert all(((i.size().toTuple() != (0, 0)) for i in images)) |
class TestDictFieldWithNullChild(FieldValues):
valid_inputs = [({'a': None, 'b': '2', 3: 3}, {'a': None, 'b': '2', '3': '3'})]
invalid_inputs = []
outputs = [({'a': None, 'b': '2', 3: 3}, {'a': None, 'b': '2', '3': '3'})]
field = serializers.DictField(child=serializers.CharField(allow_null=True)) |
.parametrize('internal', (True, False))
class TestStringVisitor():
def test_route_method(self, internal):
sv = inspect.StringVisitor(False, internal)
rm = inspect.inspect_routes(make_app())[0].methods[0]
assert (sv.process(rm) == '{0.method} - {0.function_name}'.format(rm))
def test_route_method_verbose(self, internal):
sv = inspect.StringVisitor(True, internal)
rm = inspect.inspect_routes(make_app())[0].methods[0]
assert (sv.process(rm) == '{0.method} - {0.function_name} ({0.source_info})'.format(rm))
def test_route(self, internal):
sv = inspect.StringVisitor(False, internal)
r = inspect.inspect_routes(make_app())[0]
ml = [' {}'.format(sv.process(m)) for m in r.methods if ((not m.internal) or internal)][:(- 1)]
ml += [' {}'.format(sv.process(m)) for m in r.methods if ((not m.internal) or internal)][(- 1):]
exp = ' {0.path} - {0.class_name}:\n{1}'.format(r, '\n'.join(ml))
assert (sv.process(r) == exp)
def test_route_verbose(self, internal):
sv = inspect.StringVisitor(True, internal)
r = inspect.inspect_routes(make_app())[0]
ml = [' {}'.format(sv.process(m)) for m in r.methods if ((not m.internal) or internal)][:(- 1)]
ml += [' {}'.format(sv.process(m)) for m in r.methods if ((not m.internal) or internal)][(- 1):]
exp = ' {0.path} - {0.class_name} ({0.source_info}):\n{1}'.format(r, '\n'.join(ml))
assert (sv.process(r) == exp)
def test_route_no_methods(self, internal):
sv = inspect.StringVisitor(False, internal)
r = inspect.inspect_routes(make_app())[0]
r.methods.clear()
exp = ' {0.path} - {0.class_name}'.format(r)
assert (sv.process(r) == exp)
.parametrize('verbose', (True, False))
def test_static_route(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
sr = inspect.inspect_static_routes(make_app())
no_file = sr[1]
assert (sv.process(no_file) == ' {0.prefix} {0.directory}'.format(no_file))
with_file = sr[0]
exp = ' {0.prefix} {0.directory} [{0.fallback_filename}]'.format(with_file)
assert (sv.process(with_file) == exp)
def test_sink(self, internal):
sv = inspect.StringVisitor(False, internal)
s = inspect.inspect_sinks(make_app())[0]
assert (sv.process(s) == ' {0.prefix} {0.name}'.format(s))
def test_sink_verbose(self, internal):
sv = inspect.StringVisitor(True, internal)
s = inspect.inspect_sinks(make_app())[0]
assert (sv.process(s) == ' {0.prefix} {0.name} ({0.source_info})'.format(s))
def test_error_handler(self, internal):
sv = inspect.StringVisitor(False, internal)
e = inspect.inspect_error_handlers(make_app())[0]
assert (sv.process(e) == ' {0.error} {0.name}'.format(e))
def test_error_handler_verbose(self, internal):
sv = inspect.StringVisitor(True, internal)
e = inspect.inspect_error_handlers(make_app())[0]
assert (sv.process(e) == ' {0.error} {0.name} ({0.source_info})'.format(e))
def test_middleware_method(self, internal):
sv = inspect.StringVisitor(False, internal)
mm = inspect.inspect_middleware(make_app()).middleware_classes[0].methods[0]
assert (sv.process(mm) == '{0.function_name}'.format(mm))
def test_middleware_method_verbose(self, internal):
sv = inspect.StringVisitor(True, internal)
mm = inspect.inspect_middleware(make_app()).middleware_classes[0].methods[0]
assert (sv.process(mm) == '{0.function_name} ({0.source_info})'.format(mm))
def test_middleware_class(self, internal):
sv = inspect.StringVisitor(False, internal)
mc = inspect.inspect_middleware(make_app()).middleware_classes[0]
mml = [' {}'.format(sv.process(m)) for m in mc.methods][:(- 1)]
mml += [' {}'.format(sv.process(m)) for m in mc.methods][(- 1):]
exp = ' {0.name}:\n{1}'.format(mc, '\n'.join(mml))
assert (sv.process(mc) == exp)
def test_middleware_class_verbose(self, internal):
sv = inspect.StringVisitor(True, internal)
mc = inspect.inspect_middleware(make_app()).middleware_classes[0]
mml = [' {}'.format(sv.process(m)) for m in mc.methods][:(- 1)]
mml += [' {}'.format(sv.process(m)) for m in mc.methods][(- 1):]
exp = ' {0.name} ({0.source_info}):\n{1}'.format(mc, '\n'.join(mml))
assert (sv.process(mc) == exp)
def test_middleware_class_no_methods(self, internal):
sv = inspect.StringVisitor(False, internal)
mc = inspect.inspect_middleware(make_app()).middleware_classes[0]
mc.methods.clear()
exp = ' {0.name}'.format(mc)
assert (sv.process(mc) == exp)
.parametrize('verbose', (True, False))
def test_middleware_tree_item(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
mt = inspect.inspect_middleware(make_app()).middleware_tree
for (r, s) in ((mt.request[0], ''), (mt.resource[0], ''), (mt.response[0], '')):
assert (sv.process(r) == '{0} {1.class_name}.{1.name}'.format(s, r))
.parametrize('verbose', (True, False))
def test_middleware_tree(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
mt = inspect.inspect_middleware(make_app()).middleware_tree
lines = []
space = ''
for r in mt.request:
lines.append((space + sv.process(r)))
space += ' '
lines.append('')
for r in mt.resource:
lines.append((space + sv.process(r)))
space += ' '
lines.append('')
lines.append((space + ' Process route responder'))
lines.append('')
for r in mt.response:
space = space[:(- 2)]
lines.append((space + sv.process(r)))
assert (sv.process(mt) == '\n'.join(lines))
def test_middleware_tree_response_only(self, internal):
sv = inspect.StringVisitor(False, internal)
mt = inspect.inspect_middleware(make_app()).middleware_tree
mt.request.clear()
mt.resource.clear()
lines = []
space = (' ' * len(mt.response))
lines.append('')
lines.append((space + ' Process route responder'))
lines.append('')
for r in mt.response:
space = space[:(- 2)]
lines.append((space + sv.process(r)))
assert (sv.process(mt) == '\n'.join(lines))
def test_middleware_tree_no_response(self, internal):
sv = inspect.StringVisitor(False, internal)
mt = inspect.inspect_middleware(make_app()).middleware_tree
mt.response.clear()
lines = []
space = ''
for r in mt.request:
lines.append((space + sv.process(r)))
space += ' '
lines.append('')
for r in mt.resource:
lines.append((space + sv.process(r)))
space += ' '
lines.append('')
lines.append((space + ' Process route responder'))
assert (sv.process(mt) == '\n'.join(lines))
def test_middleware_tree_no_resource(self, internal):
sv = inspect.StringVisitor(False, internal)
mt = inspect.inspect_middleware(make_app()).middleware_tree
mt.resource.clear()
lines = []
space = ' '
for r in mt.request:
lines.append((space + sv.process(r)))
space += ' '
lines.append('')
lines.append((space + ' Process route responder'))
lines.append('')
for r in mt.response:
space = space[:(- 2)]
lines.append((space + sv.process(r)))
assert (sv.process(mt) == '\n'.join(lines))
def test_middleware(self, internal):
sv = inspect.StringVisitor(False, internal)
m = inspect.inspect_middleware(make_app())
assert (sv.process(m) == sv.process(m.middleware_tree))
def test_middleware_verbose(self, internal):
sv = inspect.StringVisitor(True, internal)
m = inspect.inspect_middleware(make_app())
mt = sv.process(m.middleware_tree)
sv.indent += 4
mc = '\n'.join((sv.process(cls) for cls in m.middleware_classes))
exp = '{}\n- Middleware classes:\n{}'.format(mt, mc)
assert (inspect.StringVisitor(True).process(m) == exp)
def make(self, sv, app, v, i, r=True, m=True, sr=True, s=True, e=True):
text = 'Falcon App (WSGI)'
sv.indent = 4
if r:
text += '\n Routes:\n{}'.format('\n'.join((sv.process(r) for r in app.routes)))
if m:
mt = sv.process(app.middleware)
text += '\n Middleware ({}):\n{}'.format(app.middleware.independent_text, mt)
if sr:
sr = '\n'.join((sv.process(sr) for sr in app.static_routes))
text += '\n Static routes:\n{}'.format(sr)
if s:
text += '\n Sinks:\n{}'.format('\n'.join((sv.process(s) for s in app.sinks)))
if e:
err = '\n'.join((sv.process(e) for e in app.error_handlers if ((not e.internal) or i)))
text += '\n Error handlers:\n{}'.format(err)
return text
.parametrize('verbose', (True, False))
def test_app(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
app = inspect.inspect_app(make_app())
assert (inspect.StringVisitor(verbose, internal).process(app) == self.make(sv, app, verbose, internal))
.parametrize('verbose', (True, False))
def test_app_no_routes(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
app = inspect.inspect_app(make_app())
app.routes.clear()
assert (inspect.StringVisitor(verbose, internal).process(app) == self.make(sv, app, verbose, internal, r=False))
.parametrize('verbose', (True, False))
def test_app_no_middleware(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
app = inspect.inspect_app(make_app())
app.middleware.middleware_classes.clear()
app.middleware.middleware_tree.request.clear()
app.middleware.middleware_tree.resource.clear()
app.middleware.middleware_tree.response.clear()
assert (inspect.StringVisitor(verbose, internal).process(app) == self.make(sv, app, verbose, internal, m=False))
.parametrize('verbose', (True, False))
def test_app_static_routes(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
app = inspect.inspect_app(make_app())
app.static_routes.clear()
assert (inspect.StringVisitor(verbose, internal).process(app) == self.make(sv, app, verbose, internal, sr=False))
.parametrize('verbose', (True, False))
def test_app_no_sink(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
app = inspect.inspect_app(make_app())
app.sinks.clear()
assert (inspect.StringVisitor(verbose, internal).process(app) == self.make(sv, app, verbose, internal, s=False))
.parametrize('verbose', (True, False))
def test_app_no_errors(self, verbose, internal):
sv = inspect.StringVisitor(verbose, internal)
app = inspect.inspect_app(make_app())
app.error_handlers.clear()
assert (inspect.StringVisitor(verbose, internal).process(app) == self.make(sv, app, verbose, internal, e=False))
def test_app_name(self, internal):
sv = inspect.StringVisitor(False, internal, name='foo')
app = inspect.inspect_app(make_app())
s = sv.process(app).splitlines()[0]
assert (s == 'foo (WSGI)')
assert (app.to_string(name='bar').splitlines()[0] == 'bar (WSGI)') |
class BogusTask(Task):
id = 'tests.bogus_task'
name = 'Bogus Task'
dock_panes = List()
def create_central_pane(self):
return TaskPane(id='tests.bogus_task.central_pane')
def create_dock_panes(self):
self.dock_panes = dock_panes = [DockPane(id='tests.bogus_task.dock_pane_2', name='Dock Pane 2'), DockPane(id='tests.bogus_task.dock_pane_1', name='Dock Pane 1')]
return dock_panes
def _menu_bar_default(self):
menu_bar = SMenuBar(SMenu(SGroup(group_factory=DockPaneToggleGroup, id='tests.bogus_task.DockPaneToggleGroup'), id='View', name='&View'))
return menu_bar |
class IPv6Network(BaseV6, BaseNet):
def __init__(self, address):
BaseNet.__init__(self, address)
BaseV6.__init__(self, address)
if isinstance(address, int):
self._ip = address
self.ip = IPv6Address(self._ip)
self._prefixlen = 128
self.netmask = IPv6Address(self._ALL_ONES)
if ((address < 0) or (address > self._ALL_ONES)):
raise IPv6IpValidationError(address)
return
if _compat_has_real_bytes:
if (isinstance(address, bytes) and (len(address) == 16)):
tmp = struct.unpack('!QQ', address)
self._ip = ((tmp[0] << 64) | tmp[1])
self.ip = IPv6Address(self._ip)
self._prefixlen = 128
self.netmask = IPv6Address(self._ALL_ONES)
return
addr = str(address).split('/')
if (len(addr) > 2):
raise IPv6IpValidationError(ipaddr)
if (not self._is_valid_ip(addr[0])):
raise IPv6IpValidationError(addr[0])
if (len(addr) == 2):
if self._is_valid_netmask(addr[1]):
self._prefixlen = int(addr[1])
else:
raise IPv6NetmaskValidationError(addr[1])
else:
self._prefixlen = 128
self.netmask = IPv6Address(self._ip_int_from_prefix(self._prefixlen))
if (not self._is_valid_ip(addr[0])):
raise IPv6IpValidationError(addr[0])
self._ip = self._ip_int_from_string(addr[0])
self.ip = IPv6Address(self._ip)
def _is_valid_netmask(self, prefixlen):
try:
prefixlen = int(prefixlen)
except ValueError:
return False
return (0 <= prefixlen <= 128) |
.parametrize('types, data, expected', [(['bool[2]', 'bytes'], [[True, False], b'\x00\xff'], [('bool[2]', [('bool', True), ('bool', False)]), ('bytes', b'\x00\xff')]), (['uint256[]'], [[0, ((2 ** 256) - 1)]], [('uint256[]', [('uint256', 0), ('uint256', ((2 ** 256) - 1))])])])
def test_abi_data_tree(types, data, expected):
assert (abi_data_tree(types, data) == expected) |
class ANKRTest(unittest.TestCase):
def setUpClass(cls):
cls.maxDiff = None
cls.font = FakeFont(['.notdef', 'A', 'B', 'C', 'D'])
def decompileToXML(self, data, xml):
table = newTable('ankr')
table.decompile(data, self.font)
self.assertEqual(getXML(table.toXML), xml)
def compileFromXML(self, xml, data):
table = newTable('ankr')
for (name, attrs, content) in parseXML(xml):
table.fromXML(name, attrs, content, font=self.font)
self.assertEqual(hexStr(table.compile(self.font)), hexStr(data))
def roundtrip(self, data, xml):
self.decompileToXML(data, xml)
self.compileFromXML(xml, data)
def testFormat0(self):
self.roundtrip(ANKR_FORMAT_0_DATA, ANKR_FORMAT_0_XML)
def testFormat0_stray(self):
self.decompileToXML(ANKR_FORMAT_0_STRAY_DATA, ANKR_FORMAT_0_XML)
def testFormat0_sharing(self):
self.roundtrip(ANKR_FORMAT_0_SHARING_DATA, ANKR_FORMAT_0_SHARING_XML) |
.usefixtures('parent_child_reindex_setup')
def test_children_are_reindexed_correctly(sync_client):
helpers.reindex(sync_client, 'test-index', 'real-index')
q = sync_client.get(index='real-index', id=42)
assert ({'_id': '42', '_index': 'real-index', '_primary_term': 1, '_seq_no': 0, '_source': {'question_answer': 'question'}, '_version': 1, 'found': True} == q)
q = sync_client.get(index='test-index', id=47, routing=42)
assert ({'_routing': '42', '_id': '47', '_index': 'test-index', '_primary_term': 1, '_seq_no': 1, '_source': {'some': 'data', 'question_answer': {'name': 'answer', 'parent': 42}}, '_version': 1, 'found': True} == q) |
def _dgc(config_env: Dict) -> Sign1Message:
if (COSE in config_env.keys()):
cbor_bytes = unhexlify(config_env[COSE])
cbor_object = loads(cbor_bytes, object_hook=_object_hook)
if isinstance(cbor_object, CBORTag):
if isinstance(cbor_object.value, CBORTag):
decoded = Sign1Message.from_cose_obj(cbor_object.value.value)
else:
decoded = Sign1Message.decode(cbor_bytes)
else:
decoded = Sign1Message.from_cose_obj(cbor_object)
return decoded |
def get_datetime():
req: Response = get_session_with_legacy_adapter().get(DATETIME_LINK)
soup = BeautifulSoup(req.text, 'html.parser')
data_table = soup.find('div', {'class': 'Widget-Base Widget-ANMGraph'})
last_updated = data_table.find('div', {'class': 'button'}).contents
raw_dt = last_updated[(- 1)].strip().split(' ', 1)[(- 1)]
naive_dt = arrow.get(raw_dt, 'DD MMMM YYYY HH:mm:ss')
aware_dt = naive_dt.replace(tzinfo=dateutil.tz.gettz(TZ))
current_time = arrow.now(TZ)
diff = (current_time - aware_dt)
if (diff.total_seconds() > 7200):
raise ValueError('Orkney data is too old to use, data is {} hours old.'.format((diff.total_seconds() / 3600)))
return aware_dt.datetime |
class OptionPlotoptionsVariablepieSonificationPointgrouping(Options):
def algorithm(self):
return self._config_get('minmax')
def algorithm(self, text: str):
self._config(text, js_type=False)
def enabled(self):
return self._config_get(True)
def enabled(self, flag: bool):
self._config(flag, js_type=False)
def groupTimespan(self):
return self._config_get(15)
def groupTimespan(self, num: float):
self._config(num, js_type=False)
def prop(self):
return self._config_get('y')
def prop(self, text: str):
self._config(text, js_type=False) |
def assembleAuxiliaryVariables(domain):
domain.auxiliaryVariables = {'dissipation': [], 'kappa': [], 'ls': [], 'ls_consrv': [], 'moveMesh': [], 'redist': [], 'twp': [], 'vof': [], 'thp': [], 'vos': [], 'SWFlow': []}
zones_global = {}
start_region = 0
start_rflag = 0
start_flag = 0
for shape in domain.shape_list:
aux = domain.auxiliaryVariables
if ('RigidBody' in list(shape.auxiliaryVariables.keys())):
body = shape.auxiliaryVariables['RigidBody']
aux['twp'] += [body]
for boundcond in shape.BC_list:
boundcond.setRigidBodyMoveMesh(body)
body.i_start = (start_flag + 1)
body.i_end = ((start_flag + 1) + len(shape.BC_list))
if ('ChRigidBody' in list(shape.auxiliaryVariables.keys())):
body = shape.auxiliaryVariables['ChRigidBody']
for boundcond in shape.BC_list:
boundcond.setChMoveMesh(body)
if (not body.boundaryFlags):
flags = []
for (tag, flag) in shape.boundaryTags.items():
flags += [(start_flag + flag)]
body.setBoundaryFlags(flags)
if ('WallFunction' in list(shape.auxiliaryVariables.keys())):
wall = shape.auxiliaryVariables['WallFunction']
for ii in range(len(wall)):
aux['twp'] += [wall[ii]]
logEvent(('WALL ATTACHED TO AUXVAR --> %s' % wall[ii]))
if ('kWallFunction' in list(shape.auxiliaryVariables.keys())):
kWall = shape.auxiliaryVariables['kWallFunction']
for ii in range(len(kWall)):
aux['kappa'] += [kWall[ii]]
logEvent(('kWALL ATTACHED TO AUXVAR --> %s' % kWall[ii]))
if ('RelaxZones' in list(shape.auxiliaryVariables.keys())):
if (not zones_global):
aux['twp'] += [bc.RelaxationZoneWaveGenerator(zones_global, domain.nd)]
aux['SWFlow'] += [bc.RelaxationZoneWaveGenerator(zones_global, domain.nd)]
if (not hasattr(domain, 'porosityTypes')):
domain.porosityTypes = np.ones((len(domain.regionFlags) + 1))
domain.dragAlphaTypes = np.zeros((len(domain.regionFlags) + 1))
domain.dragBetaTypes = np.zeros((len(domain.regionFlags) + 1))
domain.epsFact_porous = np.zeros((len(domain.regionFlags) + 1))
i0 = (start_region + 1)
for (flag, zone) in list(shape.zones.items()):
ind = [i for (i, f) in enumerate(shape.regionFlags) if (f == flag)]
for i1 in ind:
domain.porosityTypes[(i0 + i1)] = zone.porosity
domain.dragAlphaTypes[(i0 + i1)] = zone.dragAlpha
domain.dragBetaTypes[(i0 + i1)] = zone.dragBeta
domain.epsFact_porous[(i0 + i1)] = zone.epsFact_porous
key = (flag + start_rflag)
zones_global[key] = zone
start_flag += len(shape.BC_list)
gauge_dict = {key: shape.auxiliaryVariables.get(key, []) for key in list(shape.auxiliaryVariables.keys()) if str(key).startswith('Gauge_')}
for key in list(gauge_dict.keys()):
key_name = key.split('_', 1)[1]
if (key_name not in aux):
raise ValueError('ERROR: Gauge key ', key_name, ' is not a recognized model by SpatialTools.', ' The known models in our dictionary are ', str(list(aux.keys())))
else:
aux[key_name] += gauge_dict[key]
if (shape.regions is not None):
start_region += len(shape.regions)
start_rflag = max(domain.regionFlags[0:start_region]) |
def HumanIKTargetDoRotate(kwargs: dict) -> OutgoingMessage:
compulsory_params = ['id', 'index', 'vector3', 'duration']
optional_params = ['speed_based', 'relative']
utility.CheckKwargs(kwargs, compulsory_params)
msg = OutgoingMessage()
msg.write_int32(kwargs['id'])
msg.write_string('HumanIKTargetDoRotateQuaternion')
msg.write_int32(kwargs['index'])
msg.write_float32(kwargs['vector3'][0])
msg.write_float32(kwargs['vector3'][1])
msg.write_float32(kwargs['vector3'][2])
msg.write_float32(kwargs['duration'])
if ('speed_based' in kwargs):
msg.write_bool(kwargs['speed_based'])
else:
msg.write_bool(True)
if ('relative' in kwargs):
msg.write_bool(kwargs['relative'])
else:
msg.write_bool(False)
return msg |
class MiningChainAPI(ChainAPI):
header: BlockHeaderAPI
def __init__(self, base_db: AtomicDatabaseAPI, header: BlockHeaderAPI=None) -> None:
...
def set_header_timestamp(self, timestamp: int) -> None:
...
def mine_all(self, transactions: Sequence[SignedTransactionAPI], *args: Any, parent_header: BlockHeaderAPI=None, **kwargs: Any) -> Tuple[(BlockImportResult, Tuple[(ReceiptAPI, ...)], Tuple[(ComputationAPI, ...)])]:
...
def apply_transaction(self, transaction: SignedTransactionAPI) -> Tuple[(BlockAPI, ReceiptAPI, ComputationAPI)]:
...
def mine_block(self, *args: Any, **kwargs: Any) -> BlockAPI:
...
def mine_block_extended(self, *args: Any, **kwargs: Any) -> BlockAndMetaWitness:
... |
class OptionSeriesTreegraphSonificationContexttracksMappingTremoloSpeed(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) |
def mark_as_read_up_to(note: SiacNote, page: int, num_pages: int):
now = _date_now_str()
start = (note.extract_start if (note.extract_start is not None) else 1)
end = (min((note.extract_end + 1), (page + 1)) if (note.extract_start is not None) else (page + 1))
if (end <= start):
return
conn = _get_connection()
existing = [r[0] for r in conn.execute(('select page from read where page > -1 and nid = %s' % note.id)).fetchall()]
to_insert = [(p, note.id, num_pages, now) for p in range(start, end) if (p not in existing)]
conn.executemany('insert into read (page, nid, pagestotal, created) values (?, ?, ?, ?)', to_insert)
conn.commit()
conn.close() |
def load_etc_file(filename: str) -> Union[(str, dict)]:
path = (ETC_DIR / filename)
contents = path.read_text()
if (path.suffix == '.txt'):
return contents
elif (path.suffix == '.json'):
return json.loads(contents)
elif (path.suffix in ('.yaml', '.yml')):
return yaml.safe_load(contents) |
class MDialog(HasTraits):
def open(self):
if (self.control is None):
self.create()
if (self.style == 'modal'):
self.return_code = self._show_modal()
self.close()
else:
self.show(True)
self.return_code = OK
return self.return_code
def create(self, parent=None):
super().create(parent=parent)
self._create_contents(self.control) |
def get_all_quaternion_curves(object):
fcurves = object.animation_data.action.fcurves
if fcurves.find('rotation_quaternion'):
(yield (fcurves.find('rotation_quaternion', index=0), fcurves.find('rotation_quaternion', index=1), fcurves.find('rotation_quaternion', index=2), fcurves.find('rotation_quaternion', index=3)))
if (object.type == 'ARMATURE'):
for bone in object.pose.bones:
data_path = (('pose.bones["' + bone.name) + '"].rotation_quaternion')
if fcurves.find(data_path):
(yield (fcurves.find(data_path, index=0), fcurves.find(data_path, index=1), fcurves.find(data_path, index=2), fcurves.find(data_path, index=3))) |
def test_array():
memview = None
compare('np.ndarray[np.int_t, ndim=2, mode="c"]', int, '2d', memview, 'C')
compare('np.ndarray[np.int_t, ndim=3]', int, '3d', memview, 'strided')
compare('np.ndarray[np.int32_t, ndim=2, mode="f"]', np.int32, '2d', memview, 'F')
compare('np.ndarray[np.int_t, ndim=2, negative_indices=False]', int, '2d', memview, positive_indices='positive_indices') |
def test_airy_multiple_layers_array(basement, water_array, sediments_array):
(thickness_water, density_water) = water_array
(thickness_sediments, density_sediments) = sediments_array
layers = {'water': (thickness_water, density_water), 'sediments': (thickness_sediments, density_sediments)}
root = isostatic_moho_airy(basement, layers=layers, density_crust=np.array([1, 2, 1, 1, 2, 1], dtype=float), density_mantle=np.array([3, 3, 3, 3, 3, 3], dtype=float), reference_depth=0)
true_root = np.array([(- 0.12), (- 0.1), 0.38, 0.5, 5.14, 1.5])
npt.assert_allclose(root, true_root, rtol=1e-10, atol=0)
if isinstance(root, xr.DataArray):
assert (root.attrs['density_water'] == density_water).all()
assert (root.attrs['density_sediments'] == density_sediments).all() |
def generation_from_decoded_mask(epoch, save_path, fname, features, checkpoints_dir, color_mode, netG, model_type, classname, feat_num=3, original_mask=False, update=True, debug=True, from_avg=False, remove_background=False):
gan_opt = initialize_option(classname, decode=(not original_mask))
gan_opt.checkpoints_dir = checkpoints_dir
gan_opt.model = model_type
gan_opt.feat_num = feat_num
if (model_type.startswith('cvae') or model_type.startswith('bicycle')):
gan_opt.use_vae = True
if (netG == 'local'):
gan_opt.netG = 'local'
print('local')
gan_util.mkdirs(save_path)
model = gan_create_model(gan_opt)
if from_avg:
with open(os.path.join(checkpoints_dir, classname, 'train_avg_features.p'), 'rb') as readfile:
avg_features = pickle.load(readfile)
model.set_avg_features(avg_features)
if original_mask:
raise NotImplementedError
else:
if update:
path = os.path.join(os.path.abspath(save_path).replace('generation', 'separate_vae'), ('%s_%s.png' % (epoch, fname)))
else:
raise NotImplementedError
label = Image.open(path)
if label:
params = get_params(gan_opt, label.size)
transform_label = get_transform(gan_opt, params, method=Image.NEAREST, normalize=False)
label_tensor = (transform_label(label) * 255.0)
inst_tensor = transform_label(label)
else:
print(('%s not exist!' % fname))
exit()
generated = model.inference_given_feature(label_tensor.unsqueeze(0), inst_tensor.unsqueeze(0), features, from_avg=from_avg)
if (color_mode == 'Lab'):
if remove_background:
gan_util.save_image(gan_util.tensor2LABim_nobackground(generated.data[0], label_tensor.data), os.path.join(save_path, ('%s_%s.jpg' % (epoch, fname))))
else:
gan_util.save_image(gan_util.tensor2LABim(generated.data[0]), os.path.join(save_path, ('%s_%s.jpg' % (epoch, fname))))
else:
gan_util.save_image(gan_util.tensor2im(generated.data[0]), os.path.join(save_path, ('%s_%s.jpg' % (epoch, fname)))) |
class CpuUsage(IntervalModule, ColorRangeModule):
format = '{usage:02}%'
format_all = '{core}:{usage:02}%'
exclude_average = False
interval = 1
color = '#FFFFFF'
dynamic_color = False
upper_limit = 100
settings = (('format', 'format string.'), ('format_all', 'format string used for {usage_all} per core. Available formaters are {core} and {usage}. '), ('exclude_average', 'If True usage average of all cores will not be in format_all.'), ('color', 'HTML color code #RRGGBB'), ('dynamic_color', 'Set color dynamically based on CPU usage. Note: this overrides color_up'), ('start_color', "Hex or English name for start of color range, eg '#00FF00' or 'green'"), ('end_color', "Hex or English name for end of color range, eg '#FF0000' or 'red'"))
def init(self):
self.prev_total = defaultdict(int)
self.prev_busy = defaultdict(int)
self.formatter = Formatter()
self.key = re.findall('usage_cpu\\d+', self.format)
if (len(self.key) == 1):
self.key = self.key[0]
else:
self.key = 'usage_cpu'
if (not self.dynamic_color):
self.start_color = self.color
self.end_color = self.color
self.colors = self.get_hex_color_range(self.start_color, self.end_color, int(self.upper_limit))
def get_cpu_timings(self):
timings = {}
with open('/proc/stat', 'r') as file_obj:
for line in file_obj:
if ('cpu' in line):
line = line.strip().split()
timings[line[0]] = [int(x) for x in line[1:]]
return timings
def calculate_usage(self, cpu, total, busy):
diff_total = (total - self.prev_total[cpu])
diff_busy = (busy - self.prev_busy[cpu])
self.prev_total[cpu] = total
self.prev_busy[cpu] = busy
if (diff_total == 0):
return 0
else:
return int(((diff_busy / diff_total) * 100))
def gen_format_all(self, usage):
format_string = ' '
core_strings = []
for (core, usage) in usage.items():
if ((core == 'usage_cpu') and self.exclude_average):
continue
elif (core == 'usage'):
continue
core = core.replace('usage_', '')
string = self.formatter.format(self.format_all, core=core, usage=usage)
core_strings.append(string)
core_strings = sorted(core_strings)
return format_string.join(core_strings)
def get_usage(self):
usage = {}
for (cpu, timings) in self.get_cpu_timings().items():
cpu_total = sum(timings)
del timings[3:5]
cpu_busy = sum(timings)
cpu_usage = self.calculate_usage(cpu, cpu_total, cpu_busy)
usage[('usage_' + cpu)] = cpu_usage
usage['usage'] = usage['usage_cpu']
return usage
def run(self):
usage = self.get_usage()
usage['usage_all'] = self.gen_format_all(usage)
color = self.get_gradient(usage[self.key], self.colors, int(self.upper_limit))
self.data = usage
self.output = {'full_text': self.format.format_map(usage), 'color': color} |
class FileWatcher():
def __init__(self, path: str, on_change: Callable[([ChangeSet], Awaitable[None])]) -> None:
self._path = path
self._on_change = on_change
self._task: Optional[asyncio.Task] = None
def _should_exit(self) -> asyncio.Event:
if (not hasattr(self, '_should_exit_obj')):
self._should_exit_obj = asyncio.Event()
return self._should_exit_obj
async def _watch(self) -> None:
async for changes in watchfiles.awatch(self._path):
changeset: ChangeSet = {}
for (event, group) in itertools.groupby(changes, key=(lambda item: item[0])):
label = CHANGE_EVENT_LABELS[event]
changeset[label] = [path for (_, path) in group]
(await self._on_change(changeset))
async def _main(self) -> None:
tasks = [asyncio.create_task(self._watch()), asyncio.create_task(self._should_exit.wait())]
(done, pending) = (await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED))
[task.cancel() for task in pending]
[task.result() for task in done]
async def startup(self) -> None:
assert (self._task is None)
self._task = asyncio.create_task(self._main())
logger.info(f'Started watching file changes at {self._path!r}')
async def shutdown(self) -> None:
assert (self._task is not None)
logger.info('Stopping file watching...')
self._should_exit.set()
(await self._task)
self._task = None |
(imputer_dict_=_imputer_dict_docstring, variables_=_variables_attribute_docstring, feature_names_in_=_feature_names_in_docstring, n_features_in_=_n_features_in_docstring, fit=_fit_not_learn_docstring, transform=_transform_imputers_docstring, fit_transform=_fit_transform_docstring)
class ArbitraryNumberImputer(BaseImputer):
def __init__(self, arbitrary_number: Union[(int, float)]=999, variables: Union[(None, int, str, List[Union[(str, int)]])]=None, imputer_dict: Optional[dict]=None) -> None:
if (isinstance(arbitrary_number, int) or isinstance(arbitrary_number, float)):
self.arbitrary_number = arbitrary_number
else:
raise ValueError('arbitrary_number must be numeric of type int or float')
_check_numerical_dict(imputer_dict)
self.variables = _check_variables_input_value(variables)
self.imputer_dict = imputer_dict
def fit(self, X: pd.DataFrame, y: Optional[pd.Series]=None):
X = check_X(X)
if self.imputer_dict:
self.variables_ = check_numerical_variables(X, list(self.imputer_dict.keys()))
self.imputer_dict_ = self.imputer_dict
else:
if (self.variables is None):
self.variables_ = find_numerical_variables(X)
else:
self.variables_ = check_numerical_variables(X, self.variables)
self.imputer_dict_ = {var: self.arbitrary_number for var in self.variables_}
self._get_feature_names_in(X)
return self |
class Text(ModuleFactory):
width = Trait(None, None, CFloat, adapts='width', help='width of the text.')
z = Trait(None, None, CFloat, help='Optional z position. When specified, the\n text is positioned in 3D')
_target = Instance(modules.Text, ())
opacity = CFloat(1, adapts='property.opacity', help='The opacity of the text.')
def __init__(self, x, y, text, **kwargs):
if (('z' in kwargs) and (kwargs['z'] is not None)):
self._target.z_position = kwargs['z']
self._target.position_in_3d = True
elif (not ((x <= 1.0) and (x >= 0.0) and (y >= 0.0) and (y <= 1.0))):
raise ValueError('Text positions should be in [0, 1] if no zposition is given')
super(Text, self).__init__(None, **kwargs)
self._target.text = text
self._target.x_position = x
self._target.y_position = y |
def fqdns_from_hosts(hosts, domains, timeout=2):
result = set()
addrs = {}
for host in list(hosts):
resolves_to = dnsx.resolve(host)
if resolves_to:
for addr in resolves_to:
addrs[addr] = (set(addrs.get(addr, [])) | set(host))
for (addr, fqdns) in addrs.items():
shodan_result = shodan_get_result(addr)
if (not shodan_result):
continue
for port in shodan_result['data']:
if (port['transport'] != 'tcp'):
continue
if ('ssl' not in port):
continue
logging.info('connecting to {}:{}'.format(addr, port['port']))
for fqdn in fqdns:
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
try:
with socket.create_connection((str(addr), int(port['port'])), timeout=timeout) as sock:
with context.wrap_socket(sock) as ssock:
cert = ssock.getpeercert(binary_form=True)
fqdns_in_cert = set(fqdns_from_certificate(cert))
logging.debug('obtained fqdns: {}'.format(', '.join(fqdns_in_cert)))
result |= fqdns_in_cert
except Exception as e:
break
for fqdn in list(result):
if (not any([fqdn.endswith(domain) for domain in domains])):
result.remove(fqdn)
return result |
class NotModifiedResponse(Response):
NOT_MODIFIED_HEADERS = ('cache-control', 'content-location', 'date', 'etag', 'expires', 'vary')
def __init__(self, headers: Headers):
super().__init__(status_code=304, headers={name: value for (name, value) in headers.items() if (name in self.NOT_MODIFIED_HEADERS)}) |
class UserResourcePermissionService(BaseService):
def get(cls, user_id, resource_id, perm_name, db_session=None):
db_session = get_db_session(db_session)
return db_session.query(cls.model).get([user_id, resource_id, perm_name])
def by_resource_user_and_perm(cls, user_id, perm_name, resource_id, db_session=None):
db_session = get_db_session(db_session)
query = db_session.query(cls.model).filter((cls.model.user_id == user_id))
query = query.filter((cls.model.resource_id == resource_id))
query = query.filter((cls.model.perm_name == perm_name))
return query.first() |
(IAdvancedEditorAreaPane)
class AdvancedEditorAreaPane(TaskPane, MEditorAreaPane):
_main_window_layout = Instance(MainWindowLayout)
_connections_to_remove = List(Tuple(Any, Callable))
def create(self, parent):
self.control = EditorAreaWidget(self, parent)
self._filter = EditorAreaDropFilter(self)
self.control.installEventFilter(self._filter)
if (sys.platform == 'darwin'):
next_seq = 'Ctrl+}'
prev_seq = 'Ctrl+{'
else:
next_seq = 'Ctrl+PgDown'
prev_seq = 'Ctrl+PgUp'
shortcut = QtGui.QShortcut(QtGui.QKeySequence(next_seq), self.control)
shortcut.activated.connect(self._next_tab)
self._connections_to_remove.append((shortcut.activated, self._next_tab))
shortcut = QtGui.QShortcut(QtGui.QKeySequence(prev_seq), self.control)
shortcut.activated.connect(self._previous_tab)
self._connections_to_remove.append((shortcut.activated, self._previous_tab))
mod = ('Ctrl+' if (sys.platform == 'darwin') else 'Alt+')
mapper = QtCore.QSignalMapper(self.control)
if (is_pyside and is_qt6):
mapper.mappedInt.connect(self._activate_tab)
self._connections_to_remove.append((mapper.mappedInt, self._activate_tab))
else:
mapper.mapped.connect(self._activate_tab)
self._connections_to_remove.append((mapper.mapped, self._activate_tab))
for i in range(1, 10):
sequence = QtGui.QKeySequence((mod + str(i)))
shortcut = QtGui.QShortcut(sequence, self.control)
shortcut.activated.connect(mapper.map)
self._connections_to_remove.append((shortcut.activated, mapper.map))
mapper.setMapping(shortcut, (i - 1))
def destroy(self):
if (self.control is not None):
self.control.removeEventFilter(self._filter)
self.control._remove_event_listeners()
self._filter = None
for editor in self.editors:
editor_widget = editor.control.parent()
self.control.destroy_editor_widget(editor_widget)
editor.editor_area = None
self.active_editor = None
while self._connections_to_remove:
(signal, handler) = self._connections_to_remove.pop()
signal.disconnect(handler)
super().destroy()
def activate_editor(self, editor):
editor_widget = editor.control.parent()
editor_widget.setVisible(True)
editor_widget.raise_()
editor.control.setFocus()
self.active_editor = editor
def add_editor(self, editor):
editor.editor_area = self
editor_widget = EditorWidget(editor, self.control)
self.control.add_editor_widget(editor_widget)
self.editors.append(editor)
def remove_editor(self, editor):
editor_widget = editor.control.parent()
self.editors.remove(editor)
self.control.remove_editor_widget(editor_widget)
editor.editor_area = None
if (not self.editors):
self.active_editor = None
def get_layout(self):
return self._main_window_layout.get_layout_for_area(QtCore.Qt.DockWidgetArea.LeftDockWidgetArea)
def set_layout(self, layout):
if (layout is not None):
self._main_window_layout.set_layout_for_area(layout, QtCore.Qt.DockWidgetArea.LeftDockWidgetArea)
def _activate_tab(self, index):
widgets = self.control.get_dock_widgets_ordered()
if (index < len(widgets)):
self.activate_editor(widgets[index].editor)
def _next_tab(self):
if self.active_editor:
widgets = self.control.get_dock_widgets_ordered()
index = (widgets.index(self.active_editor.control.parent()) + 1)
if (index < len(widgets)):
self.activate_editor(widgets[index].editor)
def _previous_tab(self):
if self.active_editor:
widgets = self.control.get_dock_widgets_ordered()
index = (widgets.index(self.active_editor.control.parent()) - 1)
if (index >= 0):
self.activate_editor(widgets[index].editor)
def _get_label(self, editor):
label = editor.name
if editor.dirty:
label = ('*' + label)
return label
def __main_window_layout_default(self):
return EditorAreaMainWindowLayout(editor_area=self)
('editors:items:[dirty, name]')
def _update_label(self, event):
editor = event.object
editor.control.parent().update_title()
('editors:items:tooltip')
def _update_tooltip(self, event):
editor = event.object
editor.control.parent().update_tooltip() |
class Test_get_xdg_config_home(object):
def test_environ_not_set(self, monkeypatch):
monkeypatch.delenv('XDG_CONFIG_HOME', raising=False)
monkeypatch.setenv('HOME', '/tmp')
assert (mouse_settings.get_xdg_config_home() == '/tmp/.config')
def test_environ_set(self, monkeypatch):
monkeypatch.setenv('XDG_CONFIG_HOME', '/tmp/foo/bar')
assert (mouse_settings.get_xdg_config_home() == '/tmp/foo/bar') |
class TestRulesEditor():
def setup_method(self):
white_icon = QtGui.QIcon('../res/icon-white.svg')
self.rd = RulesEditorDialog(appicon=white_icon)
self.rd.show()
self.rd.ruleNameEdit.setText('xxx')
self.rd.nodesCombo.addItem('unix:/tmp/osui.sock')
self.rd.nodesCombo.setCurrentText('unix:/tmp/osui.sock')
self.rd._nodes._nodes['unix:/tmp/osui.sock'] = {}
def test_rule_no_fields(self, qtbot):
qtbot.addWidget(self.rd)
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() != '')
def test_fields_empty(self, qtbot):
self.rd.pidCheck.setChecked(True)
self.rd.pidLine.setText('')
(result, error) = self.rd._save_rule()
assert (error != None)
self.rd.pidCheck.setChecked(False)
self.rd.uidCheck.setChecked(True)
self.rd.uidLine.setText('')
(result, error) = self.rd._save_rule()
assert (error != None)
self.rd.uidCheck.setChecked(False)
self.rd.procCheck.setChecked(True)
self.rd.procLine.setText('')
(result, error) = self.rd._save_rule()
assert (error != None)
self.rd.procCheck.setChecked(False)
self.rd.cmdlineCheck.setChecked(True)
self.rd.cmdlineLine.setText('')
(result, error) = self.rd._save_rule()
assert (error != None)
self.rd.cmdlineCheck.setChecked(False)
self.rd.dstPortCheck.setChecked(True)
self.rd.dstPortLine.setText('')
(result, error) = self.rd._save_rule()
assert (error != None)
self.rd.dstPortCheck.setChecked(False)
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('')
(result, error) = self.rd._save_rule()
assert (error != None)
self.rd.dstHostCheck.setChecked(False)
self.rd.dstListsCheck.setChecked(True)
self.rd.dstListsLine.setText('')
(result, error) = self.rd._save_rule()
assert (error != None)
def test_add_basic_rule(self, qtbot):
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test.com')
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('www.test.com')
self.rd.durationCombo.setCurrentIndex(self.rd._load_duration(Config.DURATION_UNTIL_RESTART))
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_SIMPLE)
assert (self.rd.rule.operator.operand == 'dest.host')
assert (self.rd.rule.operator.data == 'www.test.com')
assert (self.rd.rule.duration == Config.DURATION_UNTIL_RESTART)
def test_add_complex_rule(self, qtbot):
self.rd.WORK_MODE = self.rd.ADD_RULE
self.rd._reset_state()
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test-complex.com')
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('www.test-complex.com')
self.rd.dstPortCheck.setChecked(True)
self.rd.dstPortLine.setText('443')
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test-complex.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test-complex.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_LIST)
assert (self.rd.rule.operator.operand == Config.RULE_TYPE_LIST)
json_rule = json.loads(self.rd.rule.operator.data)
assert (json_rule[0]['type'] == 'simple')
assert (json_rule[0]['operand'] == 'dest.port')
assert (json_rule[0]['data'] == '443')
assert (json_rule[1]['type'] == 'simple')
assert (json_rule[1]['operand'] == 'dest.host')
assert (json_rule[1]['data'] == 'www.test-complex.com')
def test_add_reject_rule(self, qtbot):
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test-reject.com')
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('www.test-reject.com')
self.rd.actionRejectRadio.setChecked(True)
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test-reject.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test-reject.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_SIMPLE)
assert (self.rd.rule.operator.operand == 'dest.host')
assert (self.rd.rule.operator.data == 'www.test-reject.com')
assert (self.rd.rule.action == Config.ACTION_REJECT)
def test_add_deny_rule(self, qtbot):
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test-deny.com')
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('www.test-deny.com')
self.rd.actionDenyRadio.setChecked(True)
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test-deny.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test-deny.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_SIMPLE)
assert (self.rd.rule.operator.operand == 'dest.host')
assert (self.rd.rule.operator.data == 'www.test-deny.com')
assert (self.rd.rule.action == Config.ACTION_DENY)
def test_add_allow_rule(self, qtbot):
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test-allow.com')
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('www.test-allow.com')
self.rd.actionAllowRadio.setChecked(True)
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test-allow.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test-allow.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_SIMPLE)
assert (self.rd.rule.operator.operand == 'dest.host')
assert (self.rd.rule.operator.data == 'www.test-allow.com')
assert (self.rd.rule.action == Config.ACTION_ALLOW)
def test_add_rule_name_conflict(self, qtbot):
assert (self.rd._db.get_rule('www.test.com', self.rd.nodesCombo.currentText()).next() == True)
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test.com')
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('www.test.com')
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() != '')
def test_load_rule(self, qtbot):
self.rd.WORK_MODE = self.rd.ADD_RULE
self.rd._reset_state()
records = self.rd._db.get_rule('www.test.com', self.rd.nodesCombo.currentText())
assert (records.next() == True)
self.rd.edit_rule(records, self.rd.nodesCombo.currentText())
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.ruleNameEdit.text() == 'www.test.com')
assert (self.rd.dstHostCheck.isChecked() == True)
assert (self.rd.dstHostLine.text() == 'www.test.com')
assert (self.rd.durationCombo.currentIndex() == self.rd._load_duration(Config.DURATION_UNTIL_RESTART))
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
def test_edit_and_rename_rule(self, qtbot):
self.rd.WORK_MODE = self.rd.ADD_RULE
self.rd._reset_state()
records = self.rd._db.get_rule('www.test.com', self.rd.nodesCombo.currentText())
assert (records.next() == True)
self.rd.edit_rule(records, self.rd.nodesCombo.currentText())
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.ruleNameEdit.text() == 'www.test.com')
assert (self.rd.dstHostCheck.isChecked() == True)
assert (self.rd.dstHostLine.text() == 'www.test.com')
self.rd.ruleNameEdit.setText('www.test-renamed.com')
self.rd.dstHostLine.setText('www.test-renamed.com')
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
records = self.rd._db.get_rule('www.test.com', self.rd.nodesCombo.currentText())
assert (records.next() == False)
records = self.rd._db.get_rule('www.test-renamed.com', self.rd.nodesCombo.currentText())
assert (records.next() == True)
def test_durations(self, qtbot):
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test-duration.com')
self.rd.dstHostCheck.setChecked(True)
self.rd.dstHostLine.setText('www.test-duration.com')
self.rd.actionDenyRadio.setChecked(True)
self.rd.durationCombo.setCurrentIndex(self.rd._load_duration(Config.DURATION_ALWAYS))
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test-duration.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test-duration.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_SIMPLE)
assert (self.rd.rule.operator.operand == 'dest.host')
assert (self.rd.rule.operator.data == 'www.test-duration.com')
assert (self.rd.rule.action == Config.ACTION_DENY)
assert (self.rd.rule.duration == Config.DURATION_ALWAYS)
def test_rule_LANs(self, qtbot):
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test-rule-LAN.com')
self.rd.dstIPCheck.setChecked(True)
self.rd.dstIPCombo.setCurrentText(self.rd.LAN_LABEL)
self.rd.actionDenyRadio.setChecked(True)
self.rd.durationCombo.setCurrentIndex(self.rd._load_duration(Config.DURATION_ALWAYS))
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test-rule-LAN.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test-rule-LAN.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_REGEXP)
assert (self.rd.rule.operator.operand == 'dest.ip')
assert (self.rd.rule.operator.data == self.rd.LAN_RANGES)
assert (self.rd.rule.action == Config.ACTION_DENY)
assert (self.rd.rule.duration == Config.DURATION_ALWAYS)
def test_rule_networks(self, qtbot):
self.rd.statusLabel.setText('')
self.rd.ruleNameEdit.setText('www.test-rule-networks.com')
self.rd.dstIPCheck.setChecked(True)
self.rd.dstIPCombo.setCurrentText('192.168.111.0/24')
self.rd.actionDenyRadio.setChecked(True)
self.rd.durationCombo.setCurrentIndex(self.rd._load_duration(Config.DURATION_ALWAYS))
def handle_dialog():
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Apply), QtCore.Qt.LeftButton)
qtbot.mouseClick(self.rd.buttonBox.button(QtWidgets.QDialogButtonBox.Close), QtCore.Qt.LeftButton)
QtCore.QTimer.singleShot(100, handle_dialog)
self.rd.exec_()
assert (self.rd.statusLabel.text() == '')
assert (self.rd._db.get_rule('www.test-rule-networks.com', self.rd.nodesCombo.currentText()).next() == True)
assert (self.rd._old_rule_name == 'www.test-rule-networks.com')
assert (self.rd.WORK_MODE == self.rd.EDIT_RULE)
assert (self.rd.rule.operator.type == Config.RULE_TYPE_NETWORK)
assert (self.rd.rule.operator.operand == 'dest.network')
assert (self.rd.rule.operator.data == '192.168.111.0/24')
assert (self.rd.rule.action == Config.ACTION_DENY)
assert (self.rd.rule.duration == Config.DURATION_ALWAYS) |
class OptionPlotoptionsLineSonificationDefaultinstrumentoptionsMappingHighpassFrequency(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) |
def test_tree_annotation():
t = PhyloTree('((9598,9606),10090);', sp_naming_function=(lambda name: name))
t.annotate_ncbi_taxa(dbfile=DATABASE_PATH)
assert (t.props['sci_name'] == 'Euarchontoglires')
homi = t['9606'].up
assert (homi.props['sci_name'] == 'Homininae')
assert (homi.props['taxid'] == 207598)
assert (homi.props['rank'] == 'subfamily')
assert (homi.props['named_lineage'] == ['root', 'cellular organisms', 'Eukaryota', 'Opisthokonta', 'Metazoa', 'Eumetazoa', 'Bilateria', 'Deuterostomia', 'Chordata', 'Craniata', 'Vertebrata', 'Gnathostomata', 'Teleostomi', 'Euteleostomi', 'Sarcopterygii', 'Dipnotetrapodomorpha', 'Tetrapoda', 'Amniota', 'Mammalia', 'Theria', 'Eutheria', 'Boreoeutheria', 'Euarchontoglires', 'Primates', 'Haplorrhini', 'Simiiformes', 'Catarrhini', 'Hominoidea', 'Hominidae', 'Homininae'])
assert (homi.props['lineage'] == [1, 131567, 2759, 33154, 33208, 6072, 33213, 33511, 7711, 89593, 7742, 7776, 117570, 117571, 8287, 1338369, 32523, 32524, 40674, 32525, 9347, 1437010, 314146, 9443, 376913, 314293, 9526, 314295, 9604, 207598])
human = t['9606']
assert (human.props['sci_name'] == 'Homo sapiens')
assert (human.props['taxid'] == 9606)
assert (human.props['rank'] == 'species')
assert (human.props['named_lineage'] == ['root', 'cellular organisms', 'Eukaryota', 'Opisthokonta', 'Metazoa', 'Eumetazoa', 'Bilateria', 'Deuterostomia', 'Chordata', 'Craniata', 'Vertebrata', 'Gnathostomata', 'Teleostomi', 'Euteleostomi', 'Sarcopterygii', 'Dipnotetrapodomorpha', 'Tetrapoda', 'Amniota', 'Mammalia', 'Theria', 'Eutheria', 'Boreoeutheria', 'Euarchontoglires', 'Primates', 'Haplorrhini', 'Simiiformes', 'Catarrhini', 'Hominoidea', 'Hominidae', 'Homininae', 'Homo', 'Homo sapiens'])
assert (human.props['lineage'] == [1, 131567, 2759, 33154, 33208, 6072, 33213, 33511, 7711, 89593, 7742, 7776, 117570, 117571, 8287, 1338369, 32523, 32524, 40674, 32525, 9347, 1437010, 314146, 9443, 376913, 314293, 9526, 314295, 9604, 207598, 9605, 9606]) |
(STORAGE_BY_KEY, status_code=HTTP_204_NO_CONTENT, dependencies=[Security(verify_oauth_client, scopes=[STORAGE_DELETE])])
def delete_config_by_key(config_key: FidesKey, *, db: Session=Depends(deps.get_db)) -> None:
logger.info("Finding storage config with key '{}'", config_key)
storage_config: Optional[StorageConfig] = StorageConfig.get_by(db, field='key', value=config_key)
if (not storage_config):
raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail=f'No configuration with key {config_key}.')
if storage_config.is_default:
raise HTTPException(status_code=HTTP_400_BAD_REQUEST, detail='Default storage configurations cannot be deleted.')
logger.info("Deleting storage config with key '{}'", config_key)
storage_config.delete(db) |
def write_to_config(thisconfig, key, value=None, config_file=None):
if (value is None):
origkey = (key + '_orig')
value = (thisconfig[origkey] if (origkey in thisconfig) else thisconfig[key])
if config_file:
cfg = config_file
elif (os.path.exists('config.py') and (not os.path.exists('config.yml'))):
cfg = 'config.py'
else:
cfg = 'config.yml'
if (not os.path.exists(cfg)):
open(cfg, 'a').close()
logging.info(('Creating empty ' + cfg))
with open(cfg, 'r') as f:
lines = f.readlines()
if (len(lines) > 0):
if (not lines[(- 1)].endswith('\n')):
lines[(- 1)] += '\n'
if cfg.endswith('.py'):
pattern = re.compile((('^[\\s#]*' + key) + '\\s*=\\s*"[^"]*"'))
repl = (((key + ' = "') + value) + '"')
pattern2 = re.compile((('^[\\s#]*' + key) + "\\s*=\\s*'[^']*'"))
repl2 = (((key + " = '") + value) + "'")
else:
pattern = re.compile((('^[\\s#]*' + key) + ':.*'))
repl = yaml.dump({key: value}, default_flow_style=False)
pattern2 = pattern
repl2 = repl
didRepl = False
with open(cfg, 'w') as f:
for line in lines:
if (pattern.match(line) or pattern2.match(line)):
if (not didRepl):
line = pattern.sub(repl, line)
line = pattern2.sub(repl2, line)
f.write(line)
didRepl = True
else:
f.write(line)
if (not didRepl):
f.write('\n')
f.write(repl)
f.write('\n') |
def build_consent_dataset_graph(datasets: List[DatasetConfig]) -> DatasetGraph:
consent_datasets: List[GraphDataset] = []
for dataset_config in datasets:
connection_type: ConnectionType = dataset_config.connection_config.connection_type
saas_config: Optional[Dict] = dataset_config.connection_config.saas_config
if ((connection_type == ConnectionType.saas) and saas_config and saas_config.get('consent_requests')):
consent_datasets.append(dataset_config.get_dataset_with_stubbed_collection())
return DatasetGraph(*consent_datasets) |
class OptionPlotoptionsTimelineSonificationTracksMappingLowpassFrequency(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) |
def run_webviz_ert(args: Namespace, _: Optional[ErtPluginManager]=None) -> None:
try:
import webviz_ert
except ImportError as err:
raise ValueError('Running `ert vis` requires that webviz_ert is installed') from err
kwargs: Dict[(str, Any)] = {'verbose': args.verbose}
if args.config:
ert_config = ErtConfig.from_file(args.config)
os.chdir(ert_config.config_path)
ens_path = ert_config.ens_path
kwargs['ert_config'] = os.path.basename(args.config)
kwargs['project'] = os.path.abspath(ens_path)
with StorageService.init_service(**kwargs) as storage:
storage.wait_until_ready()
print('\n\n\nStarting up Webviz-ERT. This might take more than a minute.\n\n\n')
webviz_kwargs = {'experimental_mode': args.experimental_mode, 'verbose': args.verbose, 'title': kwargs.get('ert_config', 'ERT - Visualization tool'), 'project': kwargs.get('project', os.getcwd())}
with WebvizErt.start_server(**webviz_kwargs) as webviz_ert_server:
webviz_ert_server.wait() |
def test_migrate_gen_kw_config(setup_case, set_ert_config):
ert_config = setup_case('block_storage/version-3/poly_example', 'poly.ert')
with open_storage(ert_config.ens_path, 'w') as storage:
experiment = list(storage.experiments)[0]
assert ('template_file_path' not in experiment.parameter_configuration) |
_handler((lambda query: (query.query == 'text')))
def query_text(inline_query):
try:
r = types.InlineQueryResultArticle('1', 'Result1', types.InputTextMessageContent('hi'))
r2 = types.InlineQueryResultArticle('2', 'Result2', types.InputTextMessageContent('hi'))
bot.answer_inline_query(inline_query.id, [r, r2])
except Exception as e:
print(e) |
class OptionSeriesPictorialSonificationDefaultinstrumentoptionsMappingLowpassFrequency(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) |
class OptionPlotoptionsFunnelSonificationContexttracksMappingLowpassResonance(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) |
def _parse_wiki_sql_dump_line(line):
line = line.decode('latin1')
if line.startswith('INSERT INTO'):
el_end = 0
el_start = 0
curr_tuple = []
is_escaping = False
is_string_open = False
line_start = line.index('(')
for i in range(line_start, len(line)):
c = line[i]
if (not is_string_open):
if (c == '('):
el_start = (i + 1)
continue
if (c == ')'):
el_end = (i if (el_end == 0) else el_end)
el = ('' if (el_start == el_end) else line[el_start:el_end])
curr_tuple.append(el)
el_end = 0
el_start = 0
if curr_tuple:
(yield tuple(curr_tuple))
curr_tuple = []
continue
if (c == ','):
if (el_start > 0):
el_end = (i if (el_end == 0) else el_end)
el = ('' if (el_start == el_end) else line[el_start:el_end])
curr_tuple.append(el)
el_end = 0
el_start = (i + 1)
continue
if (c == "'"):
el_start = (i + 1)
is_string_open = True
continue
elif (c == '\\'):
is_escaping = (not is_escaping)
elif ((c == "'") and (not is_escaping)):
el_end = i
is_string_open = False
continue
else:
is_escaping = False |
def make_env_and_dataset(env_name: str, seed: int, batch_size: int) -> Tuple[(gym.Env, Iterator[types.Transition])]:
env = gym.make(env_name)
env.seed(seed)
env = wrappers.wrap_all(env, [wrappers.GymWrapper, wrappers.SinglePrecisionWrapper])
dataset = dataset_utils.D4RLDataset(env)
if ('antmaze' in env_name):
dataset.rewards = ((dataset.rewards - 0.5) * 4.0)
elif (('halfcheetah' in env_name) or ('walker2d' in env_name) or ('hopper' in env_name)):
normalize(dataset)
return (env, _make_dataset_iterator(dataset, batch_size)) |
class OptionPlotoptionsSeriesOnpointConnectoroptions(Options):
def dashstyle(self):
return self._config_get(None)
def dashstyle(self, text: str):
self._config(text, js_type=False)
def stroke(self):
return self._config_get(None)
def stroke(self, text: str):
self._config(text, js_type=False)
def width(self):
return self._config_get(1)
def width(self, num: float):
self._config(num, js_type=False) |
def load_config():
config = {}
current_directory = os.getcwd()
while True:
try:
with open(os.path.join(current_directory, 'stellar.yaml'), 'rb') as fp:
config = yaml.safe_load(fp)
break
except IOError:
pass
current_directory = os.path.abspath(os.path.join(current_directory, '..'))
if (current_directory == '/'):
break
if (not config):
raise MissingConfig()
for (k, v) in default_config.items():
if (k not in config):
config[k] = v
try:
return schema.validate(config)
except SchemaError as e:
raise InvalidConfig(e) |
class Node(Service, Generic[TPeer]):
_full_chain: FullChain = None
_event_server: PeerPoolEventServer[TPeer] = None
def __init__(self, event_bus: EndpointAPI, metrics_service: MetricsServiceAPI, trinity_config: TrinityConfig) -> None:
self.trinity_config = trinity_config
self._base_db = DBClient.connect(trinity_config.database_ipc_path)
self._headerdb = AsyncHeaderDB(self._base_db)
self._jsonrpc_ipc_path: Path = trinity_config.jsonrpc_ipc_path
self._network_id = trinity_config.network_id
self.event_bus = event_bus
self.metrics_service = metrics_service
async def handle_network_id_requests(self) -> None:
async for req in self.event_bus.stream(NetworkIdRequest):
(await self.event_bus.broadcast(NetworkIdResponse(self._network_id), req.broadcast_config()))
_chain_config: Eth1ChainConfig = None
def chain_config(self) -> Eth1ChainConfig:
if (self._chain_config is None):
app_config = self.trinity_config.get_app_config(Eth1AppConfig)
self._chain_config = app_config.get_chain_config()
return self._chain_config
def get_chain(self) -> AsyncChainAPI:
...
def get_full_chain(self) -> FullChain:
if (self._full_chain is None):
chain_class = self.chain_config.full_chain_class
self._full_chain = chain_class(self._base_db)
return self._full_chain
def get_event_server(self) -> PeerPoolEventServer[TPeer]:
...
def get_peer_pool(self) -> BasePeerPool:
...
def get_p2p_server(self) -> ServiceAPI:
...
def base_db(self) -> AtomicDatabaseAPI:
return self._base_db
def headerdb(self) -> BaseAsyncHeaderDB:
return self._headerdb
async def run(self) -> None:
with self._base_db:
self.manager.run_daemon_task(self.handle_network_id_requests)
self.manager.run_daemon_child_service(self.get_p2p_server())
self.manager.run_daemon_child_service(self.get_event_server())
self.manager.run_daemon_child_service(self.metrics_service)
(await self.manager.wait_finished()) |
def test_config_from_mapping():
app = flask.Flask(__name__)
app.config.from_mapping({'SECRET_KEY': 'config', 'TEST_KEY': 'foo'})
common_object_test(app)
app = flask.Flask(__name__)
app.config.from_mapping([('SECRET_KEY', 'config'), ('TEST_KEY', 'foo')])
common_object_test(app)
app = flask.Flask(__name__)
app.config.from_mapping(SECRET_KEY='config', TEST_KEY='foo')
common_object_test(app)
app = flask.Flask(__name__)
with pytest.raises(TypeError):
app.config.from_mapping({}, {}) |
class ExecutedFirstMiddleware():
def process_request(self, req, resp):
global context
context['executed_methods'].append('{}.{}'.format(self.__class__.__name__, 'process_request'))
def process_resource(self, req, resp, resource, params):
global context
context['executed_methods'].append('{}.{}'.format(self.__class__.__name__, 'process_resource'))
def process_response(self, req, resp, resource, req_succeeded):
global context
context['executed_methods'].append('{}.{}'.format(self.__class__.__name__, 'process_response'))
context['req'] = req
context['resp'] = resp
context['resource'] = resource |
class JQVMap(JsPackage):
lib_alias = {'js': 'jqvmap', 'css': 'jqvmap'}
lib_set_var = False
def zoomIn(self):
return JsUtils.jsWrap(("%s.vectorMap('zoomIn')" % self.varName))
def zoomOut(self):
return JsUtils.jsWrap(("%s.vectorMap('zoomOut')" % self.varName))
def getPin(self, alias):
return JsUtils.jsWrap(("%s.vectorMap('getPin', %s)" % (self.varName, JsUtils.jsConvertData(alias, None))))
def removePin(self, alias):
return JsUtils.jsWrap(("%s.vectorMap('getPin', %s)" % (self.varName, JsUtils.jsConvertData(alias, None))))
def getPins(self):
return JsUtils.jsWrap(("%s.vectorMap('getPins')" % self.varName))
def removePins(self):
return JsUtils.jsWrap(("%s.vectorMap('removePins')" % self.varName))
def set(self, key, value):
key = JsUtils.jsConvertData(key, None)
value = JsUtils.jsConvertData(value, None)
return JsUtils.jsWrap(("%s.vectorMap('set', %s, %s)" % (self.varName, key, value))) |
class TestOFPErrorExperimenterMsg(unittest.TestCase):
def test_init(self):
c = OFPErrorExperimenterMsg(_Datapath)
eq_(c.type, 65535)
eq_(c.exp_type, None)
eq_(c.experimenter, None)
eq_(c.data, None)
def _test_parser(self, exp_type, experimenter, data=None):
version = ofproto.OFP_VERSION
msg_type = ofproto.OFPT_ERROR
msg_len = ofproto.OFP_ERROR_MSG_SIZE
xid =
fmt = ofproto.OFP_HEADER_PACK_STR
buf = pack(fmt, version, msg_type, msg_len, xid)
type_ = 65535
fmt = ofproto.OFP_ERROR_EXPERIMENTER_MSG_PACK_STR
buf += pack(fmt, type_, exp_type, experimenter)
if (data is not None):
buf += data
res = OFPErrorMsg.parser(object, version, msg_type, msg_len, xid, buf)
eq_(res.version, version)
eq_(res.msg_type, msg_type)
eq_(res.msg_len, msg_len)
eq_(res.xid, xid)
eq_(res.type, type_)
eq_(res.exp_type, exp_type)
eq_(res.experimenter, experimenter)
if (data is not None):
eq_(res.data, data)
def test_parser_mid(self):
exp_type = 32768
experimenter =
data = b'Error Experimenter Message.'
self._test_parser(exp_type, experimenter, data)
def test_parser_max(self):
exp_type = 65535
experimenter =
data = b'Error Experimenter Message.'.ljust(65519)
self._test_parser(exp_type, experimenter, data)
def test_parser_min(self):
exp_type = 0
experimenter = 0
self._test_parser(exp_type, experimenter) |
def test_manual_load(yaml_config_file):
class ContainerWithConfig(containers.DeclarativeContainer):
auto_load_config = False
config = providers.Configuration(yaml_files=[yaml_config_file])
container = ContainerWithConfig()
assert (container.config.section1.value1() is None)
container.load_config()
assert (container.config.section1.value1() == 'yaml-loaded') |
class BinaryView(QtWidgets.QTableWidget):
MODE_FLOAT = 1
MODE_INT = 2
def __init__(self, force_float_fn, n_bits=32, mode=MODE_INT):
QtWidgets.QTableWidget.__init__(self)
self.setTextElideMode(QtCore.Qt.TextElideMode.ElideNone)
self.callbacks = []
self.table_elements = []
self.mode = mode
self.error_message = None
self.previously_clicked_cell = None
self.n_cols = 32
self.force_float_fn = force_float_fn
self.itemEntered.connect(self._on_item_entered)
self.set_new_bit_width(n_bits)
def new_mode(self, mode, check_64b_checked):
if (mode == self.mode):
return
self.mode = mode
self.set_new_bit_width((64 if check_64b_checked else 32))
def get_value(self):
as_uint = 0
for item in self.table_elements:
if item.value:
as_uint += (1 << item.index)
bit_limit = self.get_sign_bit_index()
if (bit_limit is not None):
as_int = self._twos_complement(as_uint, (bit_limit + 1))
else:
as_int = None
if (self.mode == self.MODE_INT):
return (as_uint, as_int, None)
elif (self.mode == self.MODE_FLOAT):
(as_float, _) = to_float(as_uint)
return (as_uint, as_int, as_float)
def set_value(self, value):
if isinstance(value, str):
self.error_message = value
self._callback()
return
if ((self.mode == self.MODE_INT) and isinstance(value, float)):
self.force_float_fn()
self._callback()
return
if (self.mode == self.MODE_FLOAT):
tmp = struct.pack('>f', value)
value = int(tmp.hex(), 16)
for bit in self.table_elements:
bit.set_is_bit_limit(False)
value = int(value)
if (value >= (2 ** self.n_bits)):
self.error_message = f'''
Out of {self.n_bits} bit range'''
self._callback()
return
elif (value < 0):
self.table_elements[(- 1)].set_is_bit_limit(True)
for bit in range(self.n_bits):
if ((1 << bit) & value):
self.table_elements[bit].force_to(True)
else:
self.table_elements[bit].force_to(False)
self._callback()
def connect(self, callback):
self.callbacks.append(callback)
def set_sign_bit_index(self, index):
for bit in self.table_elements:
if (bit.index == index):
bit.toggle_is_bit_limit()
else:
bit.set_is_bit_limit(False)
self._callback()
def mousePressEvent(self, event):
cell = self.itemAt(event.pos())
if (not isinstance(cell, BinaryTableItem)):
return
if (event.button() == QtCore.Qt.MouseButton.LeftButton):
cell.toggle()
self.previously_clicked_cell = cell
self._callback()
elif (event.button() == QtCore.Qt.MouseButton.RightButton):
if (self.mode == self.MODE_INT):
self.previously_clicked_cell = cell
self.set_sign_bit_index(cell.index)
def set_new_bit_width(self, n_bits):
if (n_bits not in [32, 64]):
print('invalid number of bits requested, choose from 32, 64')
return
while (self.rowCount() > 0):
self.removeRow(0)
self.table_elements = []
self.n_bits = n_bits
self.width = int((n_bits / 2))
self.n_spacers = int(((self.width / 8) - 1))
self.n_cols = (self.width + self.n_spacers)
if (self.mode == self.MODE_FLOAT):
self._init_table_properties_float()
self._populate_table_float()
elif (self.mode == self.MODE_INT):
self._init_table_properties_int()
self._populate_table_int()
def _init_table_properties_float(self):
self.setRowCount(4)
self.n_cols = 34
self.setColumnCount(self.n_cols)
self.horizontalHeader().setMaximumSectionSize(25)
self._set_visual_properties()
def _init_table_properties_int(self):
self.setRowCount(4)
self.setColumnCount(self.n_cols)
self.horizontalHeader().setMaximumSectionSize(25)
self._set_visual_properties()
def _set_visual_properties(self):
self.horizontalHeader().setVisible(False)
self.verticalHeader().setVisible(False)
self.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
self.setShowGrid(False)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
self.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.SizeAdjustPolicy.AdjustToContents)
self.resizeColumnsToContents()
def _populate_table_float(self):
digit_index = 0
for col in range(self.n_cols):
reverse_index = ((self.n_cols - 1) - col)
if ((col == 32) or (col == 23)):
self.setItem(0, reverse_index, BinaryTableSpacer())
self.setItem(1, reverse_index, BinaryTableSpacer())
else:
item = BinaryTableItem(digit_index)
self.table_elements.append(item)
self.setItem(1, reverse_index, item)
item = BinaryTableLegend(digit_index)
self.setItem(0, reverse_index, item)
digit_index += 1
self.setSpan(2, 0, 1, 2)
self.setSpan(2, 2, 1, 3)
self.setSpan(2, 11, 1, 3)
self.setItem(2, 0, BinaryTableLabel('Sign'))
self.setItem(2, 2, BinaryTableLabel('Exponent'))
self.setItem(2, 11, BinaryTableLabel('Mantissa'))
def _populate_table_int(self):
digit_index = 0
for col in range(self.n_cols):
reverse_index = ((self.n_cols - 1) - col)
if ((col == 8) or (col == 17) or (col == 26)):
self.setItem(2, reverse_index, BinaryTableSpacer())
self.setItem(3, reverse_index, BinaryTableSpacer())
else:
item = BinaryTableItem(digit_index)
self.table_elements.append(item)
self.setItem(3, reverse_index, item)
item = BinaryTableLegend(digit_index)
self.setItem(2, reverse_index, item)
digit_index += 1
for col in range(self.n_cols):
reverse_index = ((self.n_cols - 1) - col)
if ((col == 8) or (col == 17) or (col == 26)):
self.setItem(0, reverse_index, BinaryTableSpacer())
self.setItem(1, reverse_index, BinaryTableSpacer())
else:
item = BinaryTableItem(digit_index)
self.table_elements.append(item)
self.setItem(1, reverse_index, item)
item = BinaryTableLegend(digit_index)
self.setItem(0, reverse_index, item)
digit_index += 1
def _on_item_entered(self, item):
if (not isinstance(item, BinaryTableItem)):
return
if (item == self.previously_clicked_cell):
return
item.notify_entered_while_pressed()
self._callback()
def get_sign_bit_index(self):
limit = None
for bit in self.table_elements:
if bit.is_bit_limit:
limit = bit.index
return limit
def _callback(self):
(signed, unsigned, flt) = self.get_value()
for cb in self.callbacks:
cb(signed, unsigned, flt, self.error_message)
self.error_message = None
def _twos_complement(self, ones_complement, nBits):
if ((ones_complement & (1 << (nBits - 1))) == 0):
return ones_complement
else:
return ((((~ ones_complement) + 1) & ((1 << nBits) - 1)) * (- 1)) |
class RssProcessor(WebMirror.OutputFilters.rss.FeedDataParser.DataParser):
wanted_mimetypes = ['application/atom+xml', 'application/xhtml+xml', 'application/rdf+xml', 'application/rss+xml', 'application/xml', 'text/xml']
want_priority = 50
loggerPath = 'Main.Text.RssProcessor'
_no_ret = False
def wantsFromContent(content):
try:
feed = feedparser.parse(content)
return bool(feed['version'])
except Exception:
return False
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._no_ret = False
self.kwargs = kwargs
self.loggerPath = (kwargs['loggerPath'] + '.RssProcessor')
self.pageUrl = kwargs['pageUrl']
self.content = kwargs['pgContent']
self.type = kwargs['type']
self.log.info('Processing RSS Item')
def parseFeed(self, rawFeed):
return feedparser.parse(rawFeed)
def extractFeedContents(self, feedUrl, contentDat):
if isinstance(contentDat, str):
contentDat = [{'value': contentDat, 'type': 'text/html'}]
if (len(contentDat) != 1):
print(contentDat)
raise ValueError('How can one post have multiple contents?')
contentDat = contentDat[0]
if (not contentDat['value']):
return 'No content for post!'
params = self.kwargs.copy()
params['pgContent'] = contentDat['value']
params['mimeType'] = contentDat['type']
scraper = WebMirror.processor.HtmlProcessor.HtmlPageProcessor(extra_msg='for rss filter', extra_logger='-RSS', **params)
extracted = scraper.extractContent()
assert (contentDat['type'] in ['text/html', 'application/xhtml+xml']), ('Content is not html? Type: %s' % contentDat['type'])
content = extracted['contents']
soup = bs4.BeautifulSoup(content, 'html.parser')
if soup.html:
soup.html.unwrap()
if soup.body:
soup.body.unwrap()
try:
cont = soup.prettify()
except RuntimeError:
try:
cont = str(soup)
except RuntimeError:
cont = '<H2>WARNING - Failure when cleaning and extracting content!</H2><br><br>'
cont += content
return content
def processFeed(self, feed, feedUrl):
if ('://pumanovels.com/' in feedUrl):
return []
if ('://comrademao.com/' in feedUrl):
return []
meta = feed['feed']
entries = feed['entries']
ret = []
for entry in entries:
if (not ('title' in entry)):
continue
if entry['title'].startswith('User:'):
continue
if (not ('guid' in entry)):
entry['guid'] = (entry['link'] + entry['title'])
if (not ('authors' in entry)):
entry['authors'] = ''
kv_id = ((feedUrl + ' ') + entry['guid'])
item = common.database.get_from_db_key_value_store(kv_id)
if item:
self.log.info('Using cached parse output!')
else:
item['feedtype'] = self.type
item['title'] = entry['title']
item['guid'] = entry['guid']
item['linkUrl'] = urlFuncs.cleanUrl(entry['link'])
item['authors'] = entry['authors']
item['feedUrl'] = urlFuncs.cleanUrl(feedUrl)
if (('updated_parsed' in entry) and entry['updated_parsed']):
item['updated'] = calendar.timegm(entry['updated_parsed'])
if (('published_parsed' in entry) and entry['published_parsed']):
item['published'] = calendar.timegm(entry['published_parsed'])
if ('updated' not in item):
item['updated'] = time.time()
if (('published' not in item) or (('updated' in item) and (item['published'] > item['updated']))):
item['published'] = item['updated']
item['tags'] = []
if ('tags' in entry):
for tag in entry['tags']:
item['tags'].append(tag['term'])
if ('content' in entry):
item['content'] = entry['content']
item['contents'] = self.extractFeedContents(feedUrl, entry['content'])
elif ('summary' in entry):
item['contents'] = self.extractFeedContents(feedUrl, entry['summary'])
else:
self.log.warning('Empty item in feed?')
self.log.warning('Feed url: %s', feedUrl)
item['contents'] = ''
common.database.set_in_db_key_value_store(kv_id, item)
self.processFeedData(self.db_sess, item)
assert isinstance(item['published'], (float, int)), ("Wrong type for item['published']. Expected '%s', received '%s'" % ((float, int), type(item['published'])))
assert isinstance(item['updated'], (float, int, type(None))), ("Wrong type for item['updated']. Expected '%s', received '%s'" % ((float, int, type(None)), type(item['updated'])))
ret.append(item)
return ret
def extractContent(self):
feed = self.parseFeed(self.content)
try:
data = self.processFeed(feed, self.pageUrl)
except Exception as e:
self.log.critical('Failure parsing RSS feed!')
for line in traceback.format_exc().split('\n'):
self.log.critical(line)
raise e
plainLinks = []
rsrcLinks = []
if ('entries' in feed):
for post in feed['entries']:
if (hasattr(post, 'contenturl') and post.contenturl.startswith('tag:blogger.com')):
continue
if (hasattr(post, 'contenturl') and post.contenturl and (not ('#comment_' in post.contenturl))):
plainLinks.append(post.contenturl)
if (hasattr(post, 'contents') and post.contents and (post.contents != 'Disabled?') and (post.contents != 'wat')):
soup = WebRequest.as_soup(post.contents)
soup = urlFuncs.canonizeUrls(soup, post.contenturl)
plainLinks.extend(self.extractLinks(soup, post.contenturl))
rsrcLinks.extend(self.extractImages(soup, post.contenturl))
if ('links' in post):
for link in post['links']:
if ('href' in link):
plainLinks.append(link['href'])
if ('link' in post):
plainLinks.append(post['link'])
output = bs4.BeautifulSoup('<html><body></body></html>', 'lxml')
output.html.body.append(output.new_tag('h3', text=("RSS Feed for url '%s'" % self.pageUrl)))
for feed_item in data:
itemdiv = output.new_tag('div')
temp = output.new_tag('h5')
temp.string = feed_item['title']
itemdiv.append(temp)
temp = output.new_tag('a', href=feed_item['linkUrl'])
temp.string = feed_item['linkUrl']
itemdiv.append(temp)
temp = output.new_tag('p')
temp.string = ', '.join([str(author) for author in feed_item['authors']])
itemdiv.append(temp)
temp = output.new_tag('p')
temp.string = feed_item['contents']
itemdiv.append(temp)
output.html.body.append(itemdiv)
ret = {}
ret['title'] = ("RSS Feed for url '%s'" % self.pageUrl)
ret['contents'] = output.html.body.prettify()
ret['mimeType'] = 'text/html'
ret['rss-content'] = data
ret['plainLinks'] = plainLinks
ret['rsrcLinks'] = rsrcLinks
return ret |
class ReadOnlyId(ModelNormal):
allowed_values = {}
validations = {}
additional_properties_type = None
_nullable = False
_property
def openapi_types():
return {}
_property
def discriminator():
return None
attribute_map = {}
read_only_vars = {}
_composed_schemas = {}
_js_args_to_python_args
def _from_openapi_data(cls, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(OpenApiModel, cls).__new__(cls)
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
for (var_name, var_value) in kwargs.items():
if ((var_name not in self.attribute_map) and (self._configuration is not None) and self._configuration.discard_unknown_keys and (self.additional_properties_type is None)):
continue
setattr(self, var_name, var_value)
return self
required_properties = set(['_data_store', '_check_type', '_spec_property_naming', '_path_to_item', '_configuration', '_visited_composed_classes'])
_js_args_to_python_args
def __init__(self, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
for (var_name, var_value) in kwargs.items():
if ((var_name not in self.attribute_map) and (self._configuration is not None) and self._configuration.discard_unknown_keys and (self.additional_properties_type is None)):
continue
setattr(self, var_name, var_value)
if (var_name in self.read_only_vars):
raise ApiAttributeError(f'`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate class with read only attributes.') |
def extractRuinohonyakuWordpressCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('kondo wa zettai ni jama shimasen!', "I Swear I Won't Bother You Again!", 'translated'), ("I won't be a bother for sure this time!", "I Swear I Won't Bother You Again!", 'translated'), ('!', "I Swear I Won't Bother You Again!", 'translated'), ('Haikei Heika, Nidome no Ouhii wa Okotowari', 'Haikei Heika, Nidome no Ouhii wa Okotowari', '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 |
.skip
def test_deployments_mainnet(tp_path, deployments, mainnet_uri):
package_config = ETHPM_CONFIG.copy()
package_config['settings']['deployment_networks'] = ['mainnet']
(manifest, _) = ethpm.create_manifest(tp_path, package_config)
assert (manifest['deployments'] == {mainnet_uri: DEPLOYMENTS_MAINNET}) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.