code stringlengths 281 23.7M |
|---|
class OptionPlotoptionsDependencywheelSonificationContexttracksMappingRate(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
def _delete(id_):
if (id_ not in CONFIG.networks):
raise ValueError(f"Network '{color('bright magenta')}{id_}{color}' does not exist")
with _get_data_folder().joinpath('network-config.yaml').open() as fp:
networks = yaml.safe_load(fp)
if ('cmd' in CONFIG.networks[id_]):
networks['development'] = [i for i in networks['development'] if (i['id'] != id_)]
else:
target = next((i for i in networks['live'] for x in i['networks'] if (x['id'] == id_)))
target['networks'] = [i for i in target['networks'] if (i['id'] != id_)]
networks['live'] = [i for i in networks['live'] if i['networks']]
with _get_data_folder().joinpath('network-config.yaml').open('w') as fp:
yaml.dump(networks, fp)
notify('SUCCESS', f"Network '{color('bright magenta')}{id_}{color}' has been deleted") |
(IWizard)
class Wizard(MWizard, Dialog):
pages = Property(List(IWizardPage))
controller = Instance(IWizardController)
show_cancel = Bool(True)
title = Str('Wizard')
def next(self):
pass
def previous(self):
pass
def _create_contents(self, parent):
pass
def _create_control(self, parent):
control = _Wizard(parent, self)
control.setOptions((QtGui.QWizard.WizardOption.NoDefaultButton | QtGui.QWizard.WizardOption.NoBackButtonOnStartPage))
control.setModal((self.style == 'modal'))
control.setWindowTitle(self.title)
if (self.style == 'nonmodal'):
control.finished.connect(self._finished_fired)
if (self.size != ((- 1), (- 1))):
size = QtCore.QSize(*self.size)
control.setMinimumSize(size)
control.resize(size)
if (not self.show_cancel):
control.setOption(QtGui.QWizard.WizardOption.NoCancelButton)
if self.help_id:
control.setOption(QtGui.QWizard.WizardOption.HaveHelpButton)
control.helpRequested.connect(self._help_requested)
for page in self.pages:
page.pyface_wizard = self
control.addWizardPage(page)
control.setStartWizardPage()
return control
def _help_requested(self):
print('Show help for', self.help_id)
def _get_pages(self):
return self.controller.pages
def _set_pages(self, pages):
old_pages = self.pages
new_pages = []
for page in pages:
try:
old_pages.remove(page)
except ValueError:
new_pages.append(page)
for page in old_pages:
page.dispose_page()
if self.control:
for page in new_pages:
self.control.addWizardPage(page)
self.controller.pages = pages
def _controller_default(self):
from pyface.wizard.wizard_controller import WizardController
return WizardController() |
(urls.POLICY_POST_WEBHOOK_DETAIL, status_code=HTTP_200_OK, response_model=schemas.PolicyWebhookResponse, dependencies=[Security(verify_oauth_client, scopes=[scopes.WEBHOOK_READ])])
def get_policy_post_execution_webhook(*, db: Session=Depends(deps.get_db), policy_key: FidesKey, post_webhook_key: FidesKey) -> PolicyPostWebhook:
policy = get_policy_or_error(db, policy_key)
return get_policy_webhook_or_error(db, policy, post_webhook_key, PolicyPostWebhook) |
def profile_coordinates(point1, point2, size, extra_coords=None):
if (size <= 0):
raise ValueError("Invalid profile size '{}'. Must be > 0.".format(size))
diffs = [(i - j) for (i, j) in zip(point2, point1)]
separation = np.hypot(*diffs)
distances = np.linspace(0, separation, size)
angle = np.arctan2(*reversed(diffs))
coordinates = [(point1[0] + (distances * np.cos(angle))), (point1[1] + (distances * np.sin(angle)))]
if (extra_coords is not None):
for value in np.atleast_1d(extra_coords):
coordinates.append((np.ones_like(coordinates[0]) * value))
return (tuple(coordinates), distances) |
class RevokedFilter(BooleanListFilter):
title = _('Revoked')
parameter_name = 'revoked'
def queryset(self, request, queryset):
if (self.value() == 'yes'):
return queryset.filter(revoked__isnull=False)
if (self.value() == 'no'):
return queryset.filter(revoked__isnull=True) |
class OptionPlotoptionsOrganizationSonificationContexttracksMappingHighpassFrequency(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 TestTransactionSet(unittest.TestCase):
_configuration: Configuration
def setUpClass(cls) -> None:
TestTransactionSet._configuration = Configuration('./config/test_data.ini', US())
def setUp(self) -> None:
self.maxDiff = None
def test_good_transaction_set(self) -> None:
transaction_set: TransactionSet = TransactionSet(self._configuration, 'MIXED', 'B1')
count: int = 0
entry: AbstractEntry
transaction: AbstractTransaction
for entry in transaction_set:
transaction = cast(AbstractTransaction, entry)
count += 1
self.assertEqual(count, 0)
transaction3: InTransaction = InTransaction(self._configuration, '1/8/2021 8:42:43.883 -04:00', 'B1', 'Coinbase', 'Alice', 'bUy', RP2Decimal('1000'), RP2Decimal('3.0002'), fiat_fee=RP2Decimal('20'), fiat_in_no_fee=RP2Decimal('3000.2'), fiat_in_with_fee=RP2Decimal('3020.2'), internal_id=30)
transaction_set.add_entry(transaction3)
transaction2: InTransaction = InTransaction(self._configuration, '2021-01-02T08:42:43.882Z', 'B1', 'BlockFi', 'Bob', 'InTeREST', RP2Decimal('1000.0'), RP2Decimal('2.0002'), fiat_fee=RP2Decimal('0'), fiat_in_no_fee=RP2Decimal('2000.2'), fiat_in_with_fee=RP2Decimal('2000.2'), internal_id=20)
transaction_set.add_entry(transaction2)
timestamps: List[str] = ['2021-01-02T08:42:43.882Z', '1/8/2021 8:42:43.883 -04:00']
count = 0
timestamp: str
for (transaction, timestamp) in zip(transaction_set, timestamps):
self.assertEqual(transaction.timestamp, parse(timestamp))
count += 1
self.assertEqual(count, 2)
transaction1: OutTransaction = OutTransaction(self._configuration, '6/1/2020 3:59:59 -04:00', 'B1', 'Coinbase Pro', 'Bob', 'SeLL', RP2Decimal('900.9'), RP2Decimal('2.2'), RP2Decimal('0'), internal_id=10)
transaction_set.add_entry(transaction1)
transaction5: IntraTransaction = IntraTransaction(self._configuration, '2021-04-02T08:42:43.882Z', 'B1', 'Coinbase Pro', 'Bob', 'BlockFi', 'Alice', RP2Decimal('1000.0'), RP2Decimal('2.0002'), RP2Decimal('1.9998'), internal_id=50)
transaction_set.add_entry(transaction5)
transaction4: IntraTransaction = IntraTransaction(self._configuration, '2021-03-28T08:42:43.882Z', 'B1', 'Coinbase', 'Bob', 'Coinbase', 'Alice', RP2Decimal('100.0'), RP2Decimal('30'), RP2Decimal('30'), internal_id=40)
transaction_set.add_entry(transaction4)
self.assertEqual(transaction_set.entry_set_type, EntrySetType.MIXED)
self.assertEqual(transaction_set.asset, 'B1')
internal_ids: List[str] = ['10', '20', '30', '40', '50']
transactions: List[AbstractTransaction] = [transaction1, transaction2, transaction3, transaction4, transaction5]
parents: List[Optional[AbstractTransaction]] = [None, transaction1, transaction2, transaction3, transaction4]
timestamps = ['6/1/2020 3:59:59 -04:00', '2021-01-02T08:42:43.882Z', '1/8/2021 8:42:43.883 -04:00', '2021-03-28T08:42:43.882Z', '2021-04-02T08:42:43.882Z']
transaction_types: List[TransactionType] = [TransactionType.SELL, TransactionType.INTEREST, TransactionType.BUY, TransactionType.MOVE, TransactionType.MOVE]
fiat_taxable_amounts: List[RP2Decimal] = [RP2Decimal(s) for s in ['1981.98', '2000.2', '0', '0', '0.4']]
crypto_balance_changes: List[RP2Decimal] = [RP2Decimal(s) for s in ['2.2', '2.0002', '3.0002', '0', '0.0004']]
fiat_balance_changes: List[RP2Decimal] = [RP2Decimal(s) for s in ['1981.98', '2000.2', '3020.2', '0', '0.4']]
count = 0
expected_transaction: AbstractTransaction
parent: AbstractTransaction
internal_id: str
transaction_type: TransactionType
fiat_taxable_amount: RP2Decimal
crypto_balance_change: RP2Decimal
fiat_balance_change: RP2Decimal
for (transaction, expected_transaction, parent, internal_id, timestamp, transaction_type, fiat_taxable_amount, crypto_balance_change, fiat_balance_change) in zip(transaction_set, transactions, parents, internal_ids, timestamps, transaction_types, fiat_taxable_amounts, crypto_balance_changes, fiat_balance_changes):
self.assertEqual(transaction, expected_transaction)
self.assertEqual(transaction_set.get_parent(transaction), parent)
self.assertEqual(transaction.internal_id, internal_id)
self.assertEqual(transaction.timestamp, parse(timestamp))
self.assertEqual(transaction.transaction_type, transaction_type)
self.assertEqual(transaction.asset, 'B1')
self.assertEqual(transaction.fiat_taxable_amount, fiat_taxable_amount)
self.assertEqual(transaction.crypto_balance_change, crypto_balance_change)
self.assertEqual(transaction.fiat_balance_change, fiat_balance_change)
count += 1
self.assertEqual(count, 5)
self.assertTrue(str(transaction_set).startswith('TransactionSet:\n configuration=./config/test_data.ini\n entry_set_type=EntrySetType.MIXED'))
def test_bad_transaction_set(self) -> None:
in_transaction = InTransaction(self._configuration, '2021-01-02T08:42:43.882Z', 'B1', 'BlockFi', 'Bob', 'INTERest', RP2Decimal('1000.0'), RP2Decimal('2.0002'), fiat_fee=RP2Decimal('0'), fiat_in_with_fee=RP2Decimal('2000.2'), fiat_in_no_fee=RP2Decimal('2000.2'), internal_id=20)
in_transaction2 = InTransaction(self._configuration, '2021-01-02T08:42:43.882Z', 'B1', 'BlockFi', 'Bob', 'interEST', RP2Decimal('1000.0'), RP2Decimal('2.0002'), fiat_fee=RP2Decimal('0'), fiat_in_with_fee=RP2Decimal('2000.2'), fiat_in_no_fee=RP2Decimal('2000.2'), internal_id=20)
out_transaction = OutTransaction(self._configuration, '6/1/2020 3:59:59 -04:00', 'B1', 'Coinbase Pro', 'Bob', 'sELl', RP2Decimal('900.9'), RP2Decimal('2.2'), RP2Decimal('0'), internal_id=10)
intra_transaction = IntraTransaction(self._configuration, '2021-04-02T08:42:43.882Z', 'B1', 'Coinbase Pro', 'Bob', 'BlockFi', 'Alice', RP2Decimal('1000.0'), RP2Decimal('2.0002'), RP2Decimal('1.9998'), internal_id=50)
with self.assertRaisesRegex(RP2TypeError, "Parameter 'configuration' is not of type Configuration: .*"):
TransactionSet(None, 'IN', 'B1')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'configuration' is not of type Configuration: .*"):
TransactionSet(1111, 'IN', 'B1')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'entry_set_type' has non-string value .*"):
TransactionSet(self._configuration, None, 'B1')
with self.assertRaisesRegex(RP2ValueError, 'Parameter .* has invalid entry set type value: .*'):
TransactionSet(self._configuration, 'foobar', 'B1')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'entry_set_type' has non-string value .*"):
TransactionSet(self._configuration, 1111, 'B1')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'asset' has non-string value .*"):
TransactionSet(self._configuration, 'IN', None)
with self.assertRaisesRegex(RP2TypeError, "Parameter 'asset' has non-string value .*"):
TransactionSet(self._configuration, 'IN', 1111)
with self.assertRaisesRegex(RP2ValueError, "Parameter 'asset' value is not known: .*"):
TransactionSet(self._configuration, 'IN', 'Qwerty')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'from_date' is not of type date"):
TransactionSet(self._configuration, 'IN', 'B1', '2018')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'from_date' is not of type date"):
TransactionSet(self._configuration, 'IN', 'B1', 'foobar')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'from_date' is not of type date"):
TransactionSet(self._configuration, 'IN', 'B1', '2018-01-03', '2019-07')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'from_date' is not of type date"):
TransactionSet(self._configuration, 'IN', 'B1', '2018-01-03', 0)
in_transaction_set = TransactionSet(self._configuration, 'IN', 'B1')
out_transaction_set = TransactionSet(self._configuration, 'OUT', 'B1')
intra_transaction_set = TransactionSet(self._configuration, 'INTRA', 'B1')
with self.assertRaisesRegex(RP2TypeError, "Parameter 'entry' is not of type AbstractTransaction: .*"):
in_transaction_set.add_entry(None)
with self.assertRaisesRegex(RP2TypeError, "Parameter 'entry' is not of type AbstractTransaction: .*"):
in_transaction_set.add_entry(1111)
with self.assertRaisesRegex(RP2TypeError, 'Attempting to add a .* to a set of type IN'):
in_transaction_set.add_entry(out_transaction)
with self.assertRaisesRegex(RP2TypeError, 'Attempting to add a .* to a set of type OUT'):
out_transaction_set.add_entry(intra_transaction)
with self.assertRaisesRegex(RP2TypeError, 'Attempting to add a .* to a set of type INTRA'):
intra_transaction_set.add_entry(in_transaction)
with self.assertRaisesRegex(RP2TypeError, "Parameter 'entry' is not of type AbstractTransaction: .*"):
in_transaction_set.get_parent(None)
with self.assertRaisesRegex(RP2TypeError, "Parameter 'entry' is not of type AbstractTransaction: .*"):
in_transaction_set.get_parent(1111)
with self.assertRaisesRegex(RP2ValueError, 'Unknown entry:.*'):
in_transaction_set.get_parent(out_transaction)
with self.assertRaisesRegex(RP2ValueError, 'Unknown entry:.*'):
out_transaction_set.get_parent(intra_transaction)
with self.assertRaisesRegex(RP2ValueError, 'Unknown entry:.*'):
intra_transaction_set.get_parent(in_transaction)
with self.assertRaisesRegex(RP2ValueError, 'Entry already added: InTransaction'):
in_transaction_set = TransactionSet(self._configuration, 'IN', 'B1')
in_transaction_set.add_entry(in_transaction)
in_transaction_set.add_entry(in_transaction)
with self.assertRaisesRegex(RP2ValueError, 'Entry already added: InTransaction'):
in_transaction_set = TransactionSet(self._configuration, 'IN', 'B1')
in_transaction_set.add_entry(in_transaction)
in_transaction_set.add_entry(in_transaction2) |
class OptionPlotoptionsLineOnpointConnectoroptions(Options):
def dashstyle(self):
return self._config_get(None)
def dashstyle(self, text: str):
self._config(text, js_type=False)
def stroke(self):
return self._config_get(None)
def stroke(self, text: str):
self._config(text, js_type=False)
def width(self):
return self._config_get(1)
def width(self, num: float):
self._config(num, js_type=False) |
class OptionSonificationGlobalcontexttracksMappingTremoloSpeed(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 value(self):
return self._config_get(None)
def value(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 OptionPlotoptionsPieSonificationContexttracksMappingLowpassFrequency(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) |
('config, passthrough, err_msg', [param(OmegaConf.create({'_target_': AClass}), {}, re.escape(('Expected a callable target, got' + " '{'a': '???', 'b': '???', 'c': '???', 'd': 'default_value'}' of type 'DictConfig'")), id='instantiate-from-dataclass-in-dict-fails'), param(OmegaConf.create({'foo': {'_target_': AClass}}), {}, re.escape((('Expected a callable target, got' + " '{'a': '???', 'b': '???', 'c': '???', 'd': 'default_value'}' of type 'DictConfig'") + '\nfull_key: foo')), id='instantiate-from-dataclass-in-dict-fails-nested')])
def test_instantiate_from_dataclass_in_dict_fails(instantiate_func: Any, config: Any, passthrough: Any, err_msg: str) -> None:
with raises(InstantiationException, match=err_msg):
instantiate_func(config, **passthrough) |
class TestGetaliases(tests.LimitedTestCase):
def _make_mock_resolver(self):
base_resolver = _make_mock_base_resolver()
resolver = base_resolver()
resolver.aliases = ['cname.example.com']
return resolver
def setUp(self):
self._old_resolver = greendns.resolver
greendns.resolver = self._make_mock_resolver()
def tearDown(self):
greendns.resolver = self._old_resolver
def test_getaliases(self):
assert (greendns.getaliases('host.example.com') == ['cname.example.com']) |
class TestEventOrder(unittest.TestCase):
def test_lifo_order(self):
foo = Foo(cause='ORIGINAL')
bar = Bar(foo=foo, test=self)
baz = Baz(bar=bar, test=self)
self.events_delivered = []
foo.cause = 'CHANGE'
lifo = ['Bar._caused_changed', 'Baz._effect_changed', 'Baz._caused_changed']
self.assertEqual(self.events_delivered, lifo) |
def cmd_queue_list(jobs: Jobs, *, queueid: Optional[str]=None) -> None:
for _queue in jobs.queues:
queue = _queue.snapshot
if (queueid and (queueid != queue.id)):
continue
print(f'Queue ({queue.id})')
if queue.paused:
logger.warning('job queue is paused')
if (not len(queue)):
print('no jobs queued')
continue
for (i, reqid) in enumerate(queue, 1):
print(f'{i:>3} {reqid}')
print()
print(f'(total: {i})')
print() |
def extractWirkowritingsBlogspotCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
.django_db
def test_transactions_elasticsearch_query_only_covid_iija():
baker.make('references.DisasterEmergencyFundCode', code='A', public_law='PUBLIC LAW FOR CODE A', title='TITLE FOR CODE A', group_name=None, earliest_public_law_enactment_date=None)
baker.make('references.DisasterEmergencyFundCode', code='B', public_law='PUBLIC LAW FOR CODE B', title='TITLE FOR CODE B', group_name=None, earliest_public_law_enactment_date=None)
baker.make('references.DisasterEmergencyFundCode', code='L', public_law='PUBLIC LAW FOR CODE L', title='TITLE FOR CODE L', group_name='covid_19', earliest_public_law_enactment_date='2020-03-06')
baker.make('references.DisasterEmergencyFundCode', code='Z', public_law='PUBLIC LAW FOR CODE Z', title='TITLE FOR CODE Z', group_name='infrastructure', earliest_public_law_enactment_date='2021-11-15')
def_code_filters = ['L', 'Z']
def_codes_es_query = QueryWithFilters().generate_transactions_elasticsearch_query(filters={'def_codes': def_code_filters})
covid_iija_es_queries = [def_codes_es_query.to_dict()['bool']['must'][0]['bool']['should'][0]['bool']['must'], def_codes_es_query.to_dict()['bool']['must'][0]['bool']['should'][1]['bool']['must']]
assert ([{'match': {'disaster_emergency_fund_codes': 'L'}}, {'range': {'action_date': {'gte': '2020-03-06'}}}] in covid_iija_es_queries)
assert ([{'match': {'disaster_emergency_fund_codes': 'Z'}}, {'range': {'action_date': {'gte': '2021-11-15'}}}] in covid_iija_es_queries) |
class CoreGenerator():
def __init__(self, resource_path='./resources/', gpus=0):
self.gpus = gpus
core_generator = load_model((resource_path + 'core_generator.h5'), custom_objects={'Conv2D_r': Conv2D_r, 'InstanceNormalization': InstanceNormalization, 'tf': tf, 'ConvSN2D': ConvSN2D, 'DenseSN': DenseSN})
core_generator.name = 'core_generator'
core_generator.trainable = True
self.model = core_generator
self.save_model = core_generator |
_with_error(ValueError)
def parse_function_annotations(f: Callable[(..., Any)], keyword_only_in_message: bool=False, default_keyword_in_message: bool=False, deconstruct_dataclass_return_type: bool=True, single_return_param_name: str='sample', error: Callable[([str], None)]=(lambda x: None)) -> Tuple[(Optional[Dict[(str, type)]], Optional[Dict[(str, type)]], bool)]:
sig = signature(f)
name = f.__name__
argument_annotations = tuple((p for (_, p) in sig.parameters.items()))
return_annotation = sig.return_annotation
argument_types = parse_argument_annotations(argument_annotations, name, keyword_only_in_message, default_keyword_in_message, error)
(return_types, unpack_return) = parse_return_annotation(return_annotation, deconstruct_dataclass_return_type, single_return_param_name)
if ((argument_types is None) and (return_types is None)):
error(f'Function `{name}` does not take or return any values. The function must either take a value, return a value, or take and return a value to be converted to a Labgraph node.')
return (argument_types, return_types, unpack_return) |
def main():
global FLAG_FILENAME
parser = argparse.ArgumentParser(description='Generate encrypted flag file')
parser.add_argument('flag_file', help='Unencrypted flag file to encrypt', type=argparse.FileType('rb'))
parser.add_argument('--create-date', '-d', dest='creation_date', type=int)
args = parser.parse_args()
creation_time = (int(time.time()) if (not args.creation_date) else args.creation_date)
print('Using creation time as:', creation_time)
encrypted_data = encrypt_flag(args.flag_file.read(), creation_time)
temp_filename = (ENCRYPTED_OUTPUT_FILE + '.tmp')
with open(temp_filename, 'wb') as f:
f.write(encrypted_data)
os.utime(temp_filename, (creation_time, creation_time))
with zipfile.ZipFile(ENCRYPTED_OUTPUT_FILE, mode='w', compression=zipfile.ZIP_DEFLATED) as zf:
zf.write(temp_filename, FLAG_FILENAME, compress_type=zipfile.ZIP_DEFLATED)
os.remove(temp_filename)
print('Encrypted file has been written to:', ENCRYPTED_OUTPUT_FILE) |
def test_save_as_sets_the_version_extension_to_ma(create_test_data, create_maya_env):
data = create_test_data
maya_env = create_maya_env
version1 = Version(task=data['task6'])
version1.extension = '.ma'
version1.update_paths()
version1.extension = ''
maya_env.save_as(version1)
assert (version1.extension == '.ma') |
class RelationshipWafRules(ModelNormal):
allowed_values = {}
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 {'waf_rules': (RelationshipWafRuleWafRule,)}
_property
def discriminator():
return None
attribute_map = {'waf_rules': 'waf_rules'}
read_only_vars = {}
_composed_schemas = {}
_js_args_to_python_args
def _from_openapi_data(cls, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(OpenApiModel, cls).__new__(cls)
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
for (var_name, var_value) in kwargs.items():
if ((var_name not in self.attribute_map) and (self._configuration is not None) and self._configuration.discard_unknown_keys and (self.additional_properties_type is None)):
continue
setattr(self, var_name, var_value)
return self
required_properties = set(['_data_store', '_check_type', '_spec_property_naming', '_path_to_item', '_configuration', '_visited_composed_classes'])
_js_args_to_python_args
def __init__(self, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
for (var_name, var_value) in kwargs.items():
if ((var_name not in self.attribute_map) and (self._configuration is not None) and self._configuration.discard_unknown_keys and (self.additional_properties_type is None)):
continue
setattr(self, var_name, var_value)
if (var_name in self.read_only_vars):
raise ApiAttributeError(f'`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate class with read only attributes.') |
class OptionSeriesTimelineSonificationDefaultinstrumentoptionsMappingHighpassResonance(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
def make_ipa_multiproof(Cs, fs, indices, ys, display_times=True):
r = (ipa_utils.hash_to_field(((Cs + indices) + ys)) % MODULUS)
log_time_if_eligible(' Hashed to r', 30, display_times)
g = [0 for i in range(WIDTH)]
power_of_r = 1
for (f, index) in zip(fs, indices):
quotient = primefield.compute_inner_quotient_in_evaluation_form(f, index)
for i in range(WIDTH):
g[i] += (power_of_r * quotient[i])
power_of_r = ((power_of_r * r) % MODULUS)
for i in range(len(g)):
g[i] %= MODULUS
log_time_if_eligible(' Computed g polynomial', 30, display_times)
D = ipa_utils.pedersen_commit(g)
log_time_if_eligible(' Computed commitment D', 30, display_times)
t = (ipa_utils.hash_to_field([r, D]) % MODULUS)
h = [0 for i in range(WIDTH)]
power_of_r = 1
for (f, index) in zip(fs, indices):
denominator_inv = primefield.inv((t - primefield.DOMAIN[index]))
for i in range(WIDTH):
h[i] += (((power_of_r * f[i]) * denominator_inv) % MODULUS)
power_of_r = ((power_of_r * r) % MODULUS)
for i in range(len(h)):
h[i] %= MODULUS
log_time_if_eligible(' Computed h polynomial', 30, display_times)
h_minus_g = [((h[i] - g[i]) % primefield.MODULUS) for i in range(WIDTH)]
E = ipa_utils.pedersen_commit(h)
(y, ipa_proof) = ipa_utils.evaluate_and_compute_ipa_proof(E.dup().add(D.dup().mul((MODULUS - 1))), h_minus_g, t)
log_time_if_eligible(' Computed IPA proof', 30, display_times)
return (D.serialize(), ipa_proof) |
class Iproute2Builder(BuilderBase):
def __init__(self, build_opts, ctx, manifest, src_dir, build_dir, inst_dir) -> None:
super(Iproute2Builder, self).__init__(build_opts, ctx, manifest, src_dir, build_dir, inst_dir)
def _patch(self) -> None:
with open((self.build_dir + '/tc/tc_core.c'), 'r') as f:
data = f.read()
with open((self.build_dir + '/tc/tc_core.c'), 'w') as f:
f.write('#include <stdint.h>\n')
f.write(data)
def _build(self, install_dirs, reconfigure) -> None:
configure_path = os.path.join(self.src_dir, 'configure')
env = self.env.copy()
self._run_cmd([configure_path], env=env)
shutil.rmtree(self.build_dir)
shutil.copytree(self.src_dir, self.build_dir)
self._patch()
self._run_cmd(['make', ('-j%s' % self.num_jobs)], env=env)
install_cmd = ['make', 'install', ('DESTDIR=' + self.inst_dir)]
for d in ['include', 'lib']:
if (not os.path.isdir(os.path.join(self.inst_dir, d))):
shutil.copytree(os.path.join(self.build_dir, d), os.path.join(self.inst_dir, d))
self._run_cmd(install_cmd, env=env) |
class TestPartitionOptions():
test = CISAudit()
test_id = '1.1'
test_level = 1
option = 'noexec'
(CISAudit, '_shellexec', mock_option_set)
def test_partition_option_is_set(self):
state = self.test.audit_removable_partition_option_is_set(option=self.option)
assert (state == 0)
(CISAudit, '_shellexec', mock_option_not_set)
def test_partition_option_is_not_set(self):
state = self.test.audit_removable_partition_option_is_set(option=self.option)
assert (state == 1) |
class RatingWidget(Gtk.EventBox):
__gproperties__ = {'rating': (GObject.TYPE_INT, 'rating', 'The selected rating', 0, 65535, 0, GObject.ParamFlags.READWRITE)}
__gsignals__ = {'rating-changed': (GObject.SignalFlags.RUN_LAST, None, (GObject.TYPE_INT,))}
def __init__(self, rating=0, player=None):
Gtk.EventBox.__init__(self)
self._player = player
self.set_visible_window(False)
self.set_above_child(True)
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
self.set_can_focus(True)
self._image = Gtk.Image()
self.add(self._image)
self._rating = (- 1)
self.props.rating = rating
if (self._player is not None):
event.add_ui_callback(self.on_rating_update, 'playback_track_start', self._player)
event.add_ui_callback(self.on_rating_update, 'playback_track_end', self._player)
event.add_ui_callback(self.on_rating_update, 'rating_changed')
self.on_rating_update('rating_changed', None, None)
def destroy(self):
if (self._player is not None):
event.remove_callback(self.on_rating_update, 'playback_track_start', self._player)
event.remove_callback(self.on_rating_update, 'playback_track_end', self._player)
event.remove_callback(self.on_rating_update, 'rating_changed')
def do_get_property(self, property):
if (property.name == 'rating'):
return self._rating
else:
raise AttributeError(('unknown property %s' % property.name))
def do_set_property(self, property, value):
if (property.name == 'rating'):
if (value == self._rating):
value = 0
else:
value = clamp(value, 0, settings.get_option('rating/maximum', 5))
self._rating = value
self._image.set_from_pixbuf(icons.MANAGER.pixbuf_from_rating(value).pixbuf)
self.emit('rating-changed', value)
else:
raise AttributeError(('unknown property %s' % property.name))
def do_expose_event(self, event):
if self.is_focus():
self.style.paint_focus(window=self.window, state_type=self.get_state(), area=event.area, widget=self, detail='button', x=event.area.x, y=event.area.y, width=event.area.width, height=event.area.height)
Gtk.EventBox.do_expose_event(self, event)
def do_motion_notify_event(self, event):
if (self.get_state_flags() & Gtk.StateType.INSENSITIVE):
return
allocation = self.get_allocation()
maximum = settings.get_option('rating/maximum', 5)
pixbuf_width = self._image.get_pixbuf().get_width()
threshold = ((pixbuf_width / maximum) / 2)
position = ((event.x + threshold) / allocation.width)
rating = int((position * maximum))
self._image.set_from_pixbuf(icons.MANAGER.pixbuf_from_rating(rating).pixbuf)
def do_leave_notify_event(self, event):
if (self.get_state_flags() & Gtk.StateType.INSENSITIVE):
return
self._image.set_from_pixbuf(icons.MANAGER.pixbuf_from_rating(self._rating).pixbuf)
def do_button_release_event(self, event):
if (self.get_state_flags() & Gtk.StateType.INSENSITIVE):
return
allocation = self.get_allocation()
maximum = settings.get_option('rating/maximum', 5)
pixbuf_width = self._image.get_pixbuf().get_width()
threshold = ((pixbuf_width / maximum) / 2)
position = ((event.x + threshold) / allocation.width)
self.props.rating = int((position * maximum))
def do_key_press_event(self, event):
if (self.get_state_flags() & Gtk.StateType.INSENSITIVE):
return
if (not (event.get_state() & Gdk.ModifierType.MOD1_MASK)):
return
if (event.keyval in (Gdk.KEY_Up, Gdk.KEY_Right)):
rating = (self.props.rating + 1)
elif (event.keyval in (Gdk.KEY_Down, Gdk.KEY_Left)):
rating = (self.props.rating - 1)
else:
return
rating = max(0, rating)
if (rating == self.props.rating):
return
self.props.rating = rating
def on_rating_update(self, event_type, sender, data):
if (self._player.current is not None):
self._rating = self._player.current.get_rating()
self._image.set_from_pixbuf(icons.MANAGER.pixbuf_from_rating(self._rating).pixbuf)
self.set_sensitive(True)
else:
self.set_sensitive(False) |
class TapReadProcessor(ProcessorBase.ProcessorBase):
log_name = 'Main.Processor.TapRead'
def wants_url(lowerspliturl, mimetype):
if ('text/html' not in mimetype):
return False
return lowerspliturl.netloc.endswith('tapread.com')
def preprocess_content(self, url, lowerspliturl, mimetype, contentstr):
soup = WebRequest.as_soup(contentstr)
module = soup.body.attrs.get('page_module', None)
self.log.info('Page module: %s', module)
if (module == 'readBox'):
self.log.info('Chapter page. Inserting nav links')
soup = self.insert_chapter_nav_links(soup)
if (module == 'bookDetail'):
self.log.info('Chapter page. Inserting nav links')
soup = self.insert_toc_nav_links(soup)
soup = self._cleanup_content(soup)
return soup.prettify()
def _cleanup_content(self, soup):
bad_classes = ['signin-tip', 't-header-rig', 'person-box', 'recommend-wrapper', 'comment-wrapper', 'bot-handle', 'fix-nav', 'empty-container']
for bad_class in bad_classes:
for bogus in soup.find_all('div', class_=bad_class):
bogus.decompose()
return soup
def insert_toc_nav_links(self, soup):
book_id = soup.body.attrs.get('bookid', None)
if (not book_id):
self.log.warning('No book ID (%s)', book_id)
return soup
post_params = {'bookId': book_id}
extra_headers = {'X-Requested-With': 'XMLHttpRequest'}
cdat = self.wg.getJson(' postData=post_params, addlHeaders=extra_headers)
toc_goes_here = soup.find('div', class_='recommend')
if (not ((cdat.get('msg') == 'success') and toc_goes_here)):
self.log.error('Missing section -> %s, %s!', cdat.get('msg'), toc_goes_here)
return soup
toc_result = cdat['result']
contents_table = soup.new_tag('table')
for seg in toc_result['chapterList']:
if (seg['priceUnit'] != 0):
continue
row = soup.new_tag('tr')
td = soup.new_tag('td')
row.append(td)
newlink = soup.new_tag('a', href=PAGE_URL.format(book_id=book_id, chapter_id=seg['chapterId']))
newlink.string = seg['chapterName']
td.append(newlink)
td = soup.new_tag('td')
row.append(td)
td.string = seg['pubTime']
contents_table.append(row)
toc_goes_here.replace_with(contents_table)
return soup
def insert_chapter_nav_links(self, soup):
book_id = soup.body.attrs.get('bookid', None)
cur_id = soup.body.attrs.get('chapterid', None)
post_params = {'bookId': book_id, 'chapterId': cur_id}
extra_headers = {'X-Requested-With': 'XMLHttpRequest'}
if (not (book_id and cur_id)):
self.log.warning('No book ID and chapter ID (%s, %s)', book_id, cur_id)
return soup
cdat = self.wg.getJson(' postData=post_params, addlHeaders=extra_headers)
fill_div = soup.find('div', class_='section-list')
nav_div = soup.find('div', class_='section-end')
if (not ((cdat.get('msg') == 'success') and fill_div and nav_div)):
self.log.error('Missing section -> %s, %s, %s!', cdat.get('msg'), fill_div, nav_div)
return soup
chapter_result = cdat['result']
content = WebRequest.as_soup(chapter_result['content'])
content.html.unwrap()
content.body.unwrap()
chap_div = soup.new_tag('div')
chap_tit = soup.new_tag('h3')
chap_tit.string = chapter_result['chapterName']
chap_div.append(chap_tit)
chap_div.append(content)
fill_div.replace_with(chap_div)
chp_div = soup.new_tag('div')
prev_id = chapter_result['preChapterId']
next_id = chapter_result['nextChapterId']
if prev_id:
prev_chp_tag = soup.new_tag('a')
prev_chp_tag['href'] = PAGE_URL.format(book_id=book_id, chapter_id=prev_id)
prev_chp_tag.string = 'Previous Chapter'
chp_div.append(prev_chp_tag)
toc_chp_tag = soup.new_tag('a')
toc_chp_tag['href'] = TOC_URL.format(book_id=book_id)
toc_chp_tag.string = 'TOC'
chp_div.append(toc_chp_tag)
if next_id:
next_chp_tag = soup.new_tag('a')
next_chp_tag['href'] = PAGE_URL.format(book_id=book_id, chapter_id=next_id)
next_chp_tag.string = 'Next Chapter'
chp_div.append(next_chp_tag)
nav_div.replace_with(chp_div)
return soup |
_registry.register_env(name='SimpleRLEnv')
class SimpleRLEnv(habitat.RLEnv):
def __init__(self, config: Config, dataset: Optional[Dataset]=None):
super().__init__(config.TASK_CONFIG, dataset)
self._core_env_config = config
def get_reward_range(self):
return ((- np.inf), np.inf)
def get_reward(self, observations):
return self._env.get_metrics()[self._core_env_config.RL.REWARD_MEASURE]
def get_done(self, observations):
if self._env.episode_over:
return True
if self._env.get_metrics()[self._core_env_config.RL.SUCCESS_MEASURE]:
return True
return False
def get_info(self, observations):
return self._env.get_metrics() |
(_gemm_st_acc_i8)
def st_acc_i8(n: size, m: size, scale: f32, act: bool, src: ([i32][(n, 16)] GEMM_ACCUM), dst: ([i8][(n, m)] DRAM)):
assert (n <= 16)
assert (m <= 16)
assert (stride(dst, 1) == 1)
assert (stride(src, 0) == 16)
assert (stride(src, 1) == 1)
for i in seq(0, n):
for j in seq(0, m):
src_tmp: i32
src_tmp = src[(i, j)]
tmp: f32
acc_scale(src_tmp, tmp, scale)
tmp2: i8
clamp(tmp, tmp2)
if (act == True):
tmp2 = relu(tmp2)
dst[(i, j)] = tmp2 |
class NXTSetAsyncConfig(NiciraHeader):
def __init__(self, datapath, packet_in_mask, port_status_mask, flow_removed_mask):
super(NXTSetAsyncConfig, self).__init__(datapath, ofproto.NXT_SET_ASYNC_CONFIG)
self.packet_in_mask = packet_in_mask
self.port_status_mask = port_status_mask
self.flow_removed_mask = flow_removed_mask
def _serialize_body(self):
self.serialize_header()
msg_pack_into(ofproto.NX_ASYNC_CONFIG_PACK_STR, self.buf, ofproto.NICIRA_HEADER_SIZE, self.packet_in_mask[0], self.packet_in_mask[1], self.port_status_mask[0], self.port_status_mask[1], self.flow_removed_mask[0], self.flow_removed_mask[1]) |
class TableauCardWidget(Static):
can_focus = True
def __init__(self, card: Card, is_covered=False, **kwargs) -> None:
super().__init__(**kwargs)
self.card = card
self.is_covered = is_covered
self.last_time_clicked = None
def compose(self) -> ComposeResult:
(yield Static(card_render.draw_card(self.card, only_top=self.is_covered, add_rich_markup=True)))
def _post_click_message(self, click_type: ClickType) -> None:
self.post_message(CardClicked(self.id, self.card, click_type))
def on_click(self):
now = time.monotonic()
click_type = ClickType.from_click_times(now, self.last_time_clicked)
self.last_time_clicked = now
self._post_click_message(click_type)
def on_key(self, event: events.Key) -> None:
if (event.key == 'space'):
self.on_click()
if (event.key == 'enter'):
self._post_click_message(ClickType.DOUBLE)
elif ((event.key == 'left') or (event.key == 'h')):
self.post_message(MoveFocus(self.id, MoveDirection.LEFT, self.card))
elif ((event.key == 'right') or (event.key == 'l')):
self.post_message(MoveFocus(self.id, MoveDirection.RIGHT, self.card))
elif ((event.key == 'up') or (event.key == 'k')):
self.post_message(MoveFocus(self.id, MoveDirection.UP, self.card))
elif ((event.key == 'down') or (event.key == 'j')):
self.post_message(MoveFocus(self.id, MoveDirection.DOWN, self.card))
else:
return
event.stop() |
class AbstractModeMonitor(PlanarMonitor, FreqMonitor):
mode_spec: ModeSpec = pydantic.Field(..., title='Mode Specification', description='Parameters to feed to mode solver which determine modes measured by monitor.')
def plot(self, x: float=None, y: float=None, z: float=None, ax: Ax=None, **patch_kwargs) -> Ax:
ax = super().plot(x=x, y=y, z=z, ax=ax, **patch_kwargs)
kwargs_alpha = patch_kwargs.get('alpha')
arrow_alpha = (ARROW_ALPHA if (kwargs_alpha is None) else kwargs_alpha)
ax = self._plot_arrow(x=x, y=y, z=z, ax=ax, direction=self._dir_arrow, bend_radius=self.mode_spec.bend_radius, bend_axis=self._bend_axis, color=ARROW_COLOR_MONITOR, alpha=arrow_alpha, both_dirs=True)
return ax
_property
def _dir_arrow(self) -> Tuple[(float, float, float)]:
dx = (np.cos(self.mode_spec.angle_phi) * np.sin(self.mode_spec.angle_theta))
dy = (np.sin(self.mode_spec.angle_phi) * np.sin(self.mode_spec.angle_theta))
dz = np.cos(self.mode_spec.angle_theta)
return self.unpop_axis(dz, (dx, dy), axis=self.normal_axis)
_property
def _bend_axis(self) -> Axis:
if (self.mode_spec.bend_radius is None):
return None
in_plane = [0, 0]
in_plane[self.mode_spec.bend_axis] = 1
direction = self.unpop_axis(0, in_plane, axis=self.normal_axis)
return direction.index(1)
('mode_spec', always=True)
def _warn_num_modes(cls, val, values):
if (val.num_modes > WARN_NUM_MODES):
log.warning(f"A large number ({val.num_modes}) of modes requested in monitor '{values['name']}'. This can lead to solver slow-down and increased cost. Consider decreasing the number of modes and using 'ModeSpec.target_neff' to target the modes of interest. This may become a hard limit in future Tidy3D versions.", custom_loc=['mode_spec', 'num_modes'])
return val
def _storage_size_solver(self, num_cells: int, tmesh: ArrayFloat1D) -> int:
bytes_single = ((((BYTES_COMPLEX * num_cells) * len(self.freqs)) * self.mode_spec.num_modes) * 6)
if (self.mode_spec.precision == 'double'):
return (2 * bytes_single)
return bytes_single |
class TestCLIRestore(CuratorTestCase):
def test_restore(self):
indices = []
for i in range(1, 4):
self.add_docs(f'my_index{i}')
indices.append(f'my_index{i}')
snap_name = 'snapshot1'
self.create_snapshot(snap_name, ','.join(indices))
snapshot = get_snapshot(self.client, self.args['repository'], '*')
self.assertEqual(1, len(snapshot['snapshots']))
assert (1 == len(snapshot['snapshots']))
self.client.indices.delete(index=f"{','.join(indices)}")
self.assertEqual([], get_indices(self.client))
assert (not get_indices(self.client))
args = self.get_runner_args()
args += ['--config', self.args['configfile'], 'restore', '--repository', self.args['repository'], '--name', snap_name, '--index', indices[0], '--index', indices[1], '--index', indices[2], '--wait_interval', '1', '--max_wait', '3', '--filter_list', '{"filtertype":"none"}']
assert (0 == self.run_subprocess(args, logname='TestCLIRestore.test_restore'))
restored_indices = sorted(get_indices(self.client))
self.assertEqual(indices, restored_indices)
assert (indices == restored_indices)
time.sleep(0.5) |
def get_gradle_subdir(build_dir, paths):
first_gradle_dir = None
for path in paths:
if (not first_gradle_dir):
first_gradle_dir = path.parent.relative_to(build_dir)
if (path.exists() and SETTINGS_GRADLE_REGEX.match(str(path.name))):
for m in GRADLE_SUBPROJECT_REGEX.finditer(path.read_text(encoding='utf-8')):
for f in (path.parent / m.group(1)).glob('build.gradle*'):
with f.open(encoding='utf-8') as fp:
for line in fp.readlines():
if ANDROID_PLUGIN_REGEX.match(line):
return f.parent.relative_to(build_dir)
if (first_gradle_dir and (first_gradle_dir != Path('.'))):
return first_gradle_dir
return |
('info')
_context
def info(ctx: click.Context):
import flytekit
remote: FlyteRemote = get_and_save_remote_with_click_context(ctx, project='flytesnacks', domain='development')
c = Content.format(version=flytekit.__version__, endpoint=remote.client.url)
rich.print(Panel(c, title='Flytekit CLI Info', border_style='purple', padding=(1, 1, 1, 1))) |
()
def campaign_machine():
from statemachine import State
from statemachine import StateMachine
class CampaignMachine(StateMachine):
draft = State(initial=True)
producing = State('Being produced')
closed = State(final=True)
add_job = (draft.to(draft) | producing.to(producing))
produce = draft.to(producing)
deliver = producing.to(closed)
return CampaignMachine |
def extractSleepysmutCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class TestCallReqFrame(TestCase):
def test_read_write(self):
frame: Frame = Frame.read_frame(IOWrapper(BytesIO(SAMPLE_CALLREQ)))
self.assertEqual(3, frame.TYPE)
frame: CallReqFrame = frame
self.assertEqual(1, frame.id)
self.assertEqual(0, frame.flags)
self.assertEqual(1000, frame.ttl)
self.assertEqual(25, len(frame.tracing))
self.assertEqual('cadence-frontend', frame.service)
self.assertEqual(3, len(frame.headers.d))
self.assertEqual('thrift', frame.headers.d['as'])
self.assertEqual('c', frame.headers.d['re'])
self.assertEqual('cadence-client', frame.headers.d['cn'])
self.assertEqual(0, frame.csumtype)
self.assertEqual(3, len(frame.args))
self.assertEqual(False, frame.args[0].is_fragment)
self.assertEqual(39, len(frame.args[0].buf))
self.assertEqual(False, frame.args[1].is_fragment)
self.assertEqual(56, len(frame.args[1].buf))
self.assertEqual(False, frame.args[2].is_fragment)
self.assertEqual(195, len(frame.args[2].buf))
b = BytesIO()
frame.write(IOWrapper(b))
self.assertEqual(SAMPLE_CALLREQ, b.getvalue()) |
class TestACEScctSerialize(util.ColorAssertsPyTest):
COLORS = [('color(--acescct 0.1 0.3 0.75 / 0.5)', {}, 'color(--acescct 0.1 0.3 0.75 / 0.5)'), ('color(--acescct 0.1 0.3 0.75)', {'alpha': True}, 'color(--acescct 0.1 0.3 0.75 / 1)'), ('color(--acescct 0.1 0.3 0.75 / 0.5)', {'alpha': False}, 'color(--acescct 0.1 0.3 0.75)'), ('color(--acescct none 0.3 0.75)', {}, 'color(--acescct 0.07291 0.3 0.75)'), ('color(--acescct none 0.3 0.75)', {'none': True}, 'color(--acescct none 0.3 0.75)'), ('color(--acescct 1.5 0.2 0)', {}, 'color(--acescct 1.468 0.2 0.07291)'), ('color(--acescct 1.5 0.2 0)', {'fit': False}, 'color(--acescct 1.5 0.2 0)')]
.parametrize('color1,options,color2', COLORS)
def test_colors(self, color1, options, color2):
self.assertEqual(Color(color1).to_string(**options), color2) |
_oriented
class sph_solver():
def __init__(self, particle_list, wall_mark, grid, bound, alpha=0.5, dx=0.2, max_time=10000, max_steps=1000, gui=None):
self.max_time = max_time
self.max_steps = max_steps
self.gui = gui
self.g = (- 9.8)
self.alpha = alpha
self.rho_0 = 1000.0
self.CFL = 0.2
self.kernel_norm = 1.0
self.gamma = 7.0
self.c_0 = 20.0
self.w = 20
self.h = 10
self.w_bound = 22
self.h_bound = 12
assert (self.w_bound > self.w)
assert (self.h_bound > self.h)
self.x_min = ((self.w_bound - self.w) / 2.0)
self.y_min = ((self.h_bound - self.h) / 2.0)
self.x_max = (self.w_bound - ((self.w_bound - self.w) / 2.0))
self.y_max = (self.h_bound - ((self.h_bound - self.h) / 2.0))
self.top_bound = bound[0]
self.bottom_bound = bound[1]
self.left_bound = bound[2]
self.right_bound = bound[3]
self.df_fac = 1.3
self.dx = 0.2
self.dh = (self.dx * self.df_fac)
self.kernel_norm = (10.0 / ((7.0 * np.pi) * (self.dh ** 2)))
self.dim = 2
self.particle_numbers = len(particle_list)
self.grid_x = grid[0]
self.grid_y = grid[1]
self.old_positions = ti.Vector(self.dim, dt=ti.f32)
self.particle_positions = ti.Vector(self.dim, dt=ti.f32)
self.particle_velocity = ti.Vector(self.dim, dt=ti.f32)
self.particle_pressure = ti.Vector(1, dt=ti.f32)
self.particle_density = ti.Vector(1, dt=ti.f32)
self.wall_mark_list = ti.Vector(1, dt=ti.f32)
self.d_velocity = ti.Vector(self.dim, dt=ti.f32)
self.d_density = ti.Vector(1, dt=ti.f32)
self.dx = dx
self.m = ((self.dx ** 2) * 1000.0)
self.particle_list = np.array(particle_list, dtype=np.float32)
self.wall_mark = np.array(wall_mark, dtype=np.int32)
self.grid_num_particles = ti.var(ti.i32)
self.grid2particles = ti.var(ti.i32)
self.particle_num_neighbors = ti.var(ti.i32)
self.particle_neighbors = ti.var(ti.i32)
self.max_num_particles_per_cell = 100
self.max_num_neighbors = 100
ti.root.dense(ti.i, self.particle_numbers).place(self.old_positions, self.particle_positions, self.particle_velocity, self.particle_pressure, self.particle_density, self.d_velocity, self.d_density, self.wall_mark_list)
grid_snode = ti.root.dense(ti.ij, (self.grid_x, self.grid_y))
grid_snode.place(self.grid_num_particles)
grid_snode.dense(ti.k, self.max_num_particles_per_cell).place(self.grid2particles)
nb_node = ti.root.dense(ti.i, self.particle_numbers)
nb_node.place(self.particle_num_neighbors)
nb_node.dense(ti.j, self.max_num_neighbors).place(self.particle_neighbors)
def init(self, p_list: ti.types.ndarray(), w_list: ti.types.ndarray()):
for i in range(self.particle_numbers):
for j in ti.static(range(self.dim)):
self.particle_positions[i][j] = p_list[(i, j)]
self.particle_velocity[i][j] = ti.cast(0.0, ti.f32)
self.d_velocity[i][0] = ti.cast(0.0, ti.f32)
self.d_velocity[i][1] = ti.cast((- 9.8), ti.f32)
self.wall_mark_list[i][0] = w_list[i]
self.d_density[i][0] = ti.cast(0.0, ti.f32)
self.particle_pressure[i][0] = ti.cast(0.0, ti.f32)
self.particle_density[i][0] = ti.cast(1000.0, ti.f32)
def computeGridIndex(self, pos):
return (pos / (2 * dh)).cast(int)
def allocateParticles(self):
for p_i in self.particle_positions:
cell = self.computeGridIndex(self.particle_positions[p_i])
offs = self.grid_num_particles[cell].atomic_add(1)
self.grid2particles[(cell, offs)] = p_i
def is_in_grid(self, c):
return ((0 <= c[0]) and (c[0] < self.grid_x) and (0 <= c[1]) and (c[1] < self.grid_y))
def isFluid(self, p):
return self.wall_mark_list[p][0]
def search_neighbors(self):
for p_i in self.particle_positions:
pos_i = self.particle_positions[p_i]
nb_i = 0
if (self.isFluid(p_i) == 1):
cell = self.computeGridIndex(self.particle_positions[p_i])
for offs in ti.static(ti.grouped(ti.ndrange(((- 1), 2), ((- 1), 2)))):
cell_to_check = (cell + offs)
if self.is_in_grid(cell_to_check):
for j in range(self.grid_num_particles[cell_to_check]):
p_j = self.grid2particles[(cell_to_check, j)]
if ((nb_i < self.max_num_neighbors) and (p_j != p_i) and ((pos_i - self.particle_positions[p_j]).norm() < (self.dh * 2.0))):
self.particle_neighbors[(p_i, nb_i)] = p_j
nb_i += 1
self.particle_num_neighbors[p_i] = nb_i
def cubicKernel(self, r, h):
k = (10.0 / ((7.0 * np.pi) * (h ** 2)))
q = (r / h)
res = ti.cast(0.0, ti.f32)
if (q <= 1.0):
res = (k * ((1 - (1.5 * (q ** 2))) + (0.75 * (q ** 3))))
elif (q < 2.0):
res = ((k * 0.25) * ((2 - q) ** 3))
return res
def cubicKernelDerivative(self, r, h):
k = (10.0 / ((7.0 * np.pi) * (h ** 2)))
q = (r / h)
res = ti.cast(0.0, ti.f32)
if (q < 1.0):
res = ((k / h) * (((- 3) * q) + (2.25 * (q ** 2))))
elif (q < 2.0):
res = (((- 0.75) * (k / h)) * ((2 - q) ** 2))
return res
def rhoDerivative(self, ptc_i, ptc_j, r, r_mod):
return ((self.m * self.cubicKernelDerivative(r_mod, self.dh)) * (self.particle_velocity[ptc_i] - self.particle_velocity[ptc_j]).dot((r / r_mod)))
def pUpdate(self, rho, rho_0=1000, gamma=7.0, c_0=20.0):
b = ((rho_0 * (c_0 ** 2)) / gamma)
return (b * (((rho / rho_0) ** gamma) - 1.0))
def pressureForce(self, ptc_i, ptc_j, r, r_mod, mirror_pressure=0):
res = ti.Vector([0.0, 0.0])
res = (((((- self.m) * ((self.particle_pressure[ptc_i][0] / (self.particle_density[ptc_i][0] ** 2)) + (self.particle_pressure[ptc_j][0] / (self.particle_density[ptc_j][0] ** 2)))) * self.cubicKernelDerivative(r_mod, self.dh)) * r) / r_mod)
return res
def viscosityForce(self, ptc_i, ptc_j, r, r_mod):
res = ti.Vector([0.0, 0.0])
v_xy = (self.particle_velocity[ptc_i] - self.particle_velocity[ptc_j]).dot(r)
if (v_xy < 0):
vmu = (((((- 2.0) * self.alpha) * self.dx) * self.c_0) / (self.particle_density[ptc_i][0] + self.particle_density[ptc_j][0]))
res = (((((((- self.m) * vmu) * v_xy) / ((r_mod ** 2) + (0.01 * (self.dx ** 2)))) * self.cubicKernelDerivative(r_mod, self.dh)) * r) / r_mod)
return res
def simualteCollisions(self, ptc_i, vec, d):
c_f = 0.5
self.particle_positions[ptc_i] += (vec * d)
self.particle_velocity[ptc_i] -= (((1.0 + c_f) * self.particle_velocity[ptc_i].dot(vec)) * vec)
def enforceBoundary(self):
for p_i in self.particle_positions:
if (self.isFluid(p_i) == 1):
pos = self.particle_positions[p_i]
if (pos[0] < self.left_bound):
self.simualteCollisions(p_i, ti.Vector([1.0, 0.0]), (self.left_bound - pos[0]))
if (pos[0] > self.right_bound):
self.simualteCollisions(p_i, ti.Vector([(- 1.0), 0.0]), (pos[0] - self.right_bound))
if (pos[1] > self.top_bound):
self.simualteCollisions(p_i, ti.Vector([0.0, (- 1.0)]), (pos[1] - self.top_bound))
if (pos[1] < self.bottom_bound):
self.simualteCollisions(p_i, ti.Vector([0.0, 1.0]), (self.bottom_bound - pos[1]))
def computeDeltas(self):
for p_i in self.particle_positions:
pos_i = self.particle_positions[p_i]
d_v = ti.Vector([0.0, 0.0], dt=ti.f32)
d_rho = ti.cast(0.0, ti.f32)
for j in range(self.particle_num_neighbors[p_i]):
p_j = self.particle_neighbors[(p_i, j)]
pos_j = self.particle_positions[p_j]
r = (pos_i - pos_j)
r_mod = r.norm()
d_rho += self.rhoDerivative(p_i, p_j, r, r_mod)
if (self.isFluid(p_i) == 1):
d_v += self.viscosityForce(p_i, p_j, r, r_mod)
d_v += self.pressureForce(p_i, p_j, r, r_mod)
if (self.isFluid(p_i) == 1):
d_v += ti.Vector([0.0, self.g], dt=ti.f32)
self.d_velocity[p_i] = d_v
self.d_density[p_i][0] = d_rho
def updateTimeStep(self):
for p_i in self.particle_positions:
if (self.isFluid(p_i) == 1):
self.particle_positions[p_i] += (self.dt * self.particle_velocity[p_i])
self.particle_velocity[p_i] += (self.dt * self.d_velocity[p_i])
self.particle_density[p_i][0] += (self.dt * self.d_density[p_i][0])
self.particle_pressure[p_i][0] = self.pUpdate(self.particle_density[p_i][0], self.rho_0, self.gamma, self.c_0)
def solve(self, output=False):
self.dt = ((0.1 * self.dh) / self.c_0)
print('Time step: ', self.dt)
print(('Domain: (%s, %s, %s, %s)' % (self.x_min, self.x_max, self.y_min, self.y_max)))
print(('Fluid area: (%s, %s, %s, %s)' % (self.left_bound, self.right_bound, self.bottom_bound, self.top_bound)))
print(('Grid: (%d, %d)' % (self.grid_x, self.grid_y)))
step = 1
t = 0.0
total_start = time.process_time()
while ((t < self.max_time) and (step < self.max_steps)):
curr_start = time.process_time()
self.solveUpdate()
max_v = np.max(np.linalg.norm(self.particle_velocity.to_numpy(), 2, axis=1))
max_a = np.max(np.linalg.norm(self.d_velocity.to_numpy(), 2, axis=1))
max_rho = np.max(self.particle_density.to_numpy())
max_pressure = np.max(self.particle_pressure.to_numpy())
curr_end = time.process_time()
t += self.dt
step += 1
dt_cfl = (self.dh / max_v)
dt_f = np.sqrt((self.dh / max_a))
dt_a = (self.dh / (self.c_0 * np.sqrt(((max_rho / self.rho_0) ** self.gamma))))
self.dt = (self.CFL * np.min([dt_cfl, dt_f, dt_a]))
if ((step % 10) == 0):
print(('Step: %d, physics time: %s, progress: %s %%, time used: %s, total time used: %s' % (step, t, (100 * np.max([(t / self.max_time), (step / self.max_steps)])), (curr_end - curr_start), (curr_end - total_start))))
print(('Max velocity: %s, Max acceleration: %s, Max density: %s, Max pressure: %s' % (max_v, max_a, max_rho, max_pressure)))
print('Adaptive time step: ', self.dt)
self.render(step, self.gui, output)
total_end = time.process_time()
print(('Total time used: %s ' % (total_end - total_start)))
def solveUpdate(self):
self.grid_num_particles.fill(0)
self.particle_neighbors.fill((- 1))
self.allocateParticles()
self.search_neighbors()
self.computeDeltas()
self.updateTimeStep()
self.enforceBoundary()
def isFluidNP(self, p):
return self.wall_mark[p]
def render(self, step, gui, output=False):
canvas = gui.canvas
canvas.clear(bg_color)
pos_np = self.particle_positions.to_numpy()
fluid_p = []
wall_p = []
for (i, pos) in enumerate(pos_np):
if (self.isFluidNP(i) == 1):
fluid_p.append(pos)
else:
wall_p.append(pos)
fluid_p = np.array(fluid_p)
wall_p = np.array(wall_p)
for pos in fluid_p:
for j in range(self.dim):
pos[j] *= (screen_to_world_ratio / screen_res[j])
for pos in wall_p:
for j in range(self.dim):
pos[j] *= (screen_to_world_ratio / screen_res[j])
gui.circles(fluid_p, radius=particle_radius, color=particle_color)
gui.circles(wall_p, radius=particle_radius, color=boundary_color)
if output:
if ((step % 10) == 0):
gui.show(f'{step:04d}.png')
else:
gui.show() |
def safe_name_torrent(string):
string = string.lower()
string = re.sub(u'^\\[.*?\\]', u'', string)
string = re.sub(u'- ([0-9][0-9][0-9][0-9]) ', u' \\g<1>', (string + u' '))
string = re.sub(u'- ([0-9]+) ', u'- EP\\g<1>', (string + u' '))
if ('season' not in string.lower()):
string = string.lower().replace(u' episode ', u' - EP')
string = string.replace(u'1920x1080', u'1080p')
string = string.replace(u'1280x720', u'720p')
string = string.replace(u'853x480', u'480p')
string = string.replace(u'848x480', u'480p')
string = string.replace(u'704x480', u'480p')
string = string.replace(u'640x480', u'480p')
string = string.replace(u'microhd', u' microhd')
string = string.replace(u'dvdrip', u' dvdrip')
string = string.replace(u'1080p', u'')
string = string.replace(u'720p', u'')
string = string.replace(u'480p', u'')
string = safe_name(string)
return string.replace(u's h i e l d', u'SHIELD').replace(u'c s i', u'CSI') |
def funcparser_callable_pronoun(*args, caller=None, receiver=None, capitalize=False, **kwargs):
if (not args):
return ''
(pronoun, *options) = args
if (len(options) == 1):
options = options[0]
default_pronoun_type = 'subject pronoun'
default_gender = 'neutral'
default_viewpoint = '2nd person'
if hasattr(caller, 'gender'):
if callable(caller.gender):
default_gender = caller.gender()
else:
default_gender = caller.gender
if ('viewpoint' in kwargs):
default_viewpoint = kwargs['viewpoint']
(pronoun_1st_or_2nd_person, pronoun_3rd_person) = pronoun_to_viewpoints(pronoun, options, pronoun_type=default_pronoun_type, gender=default_gender, viewpoint=default_viewpoint)
if capitalize:
pronoun_1st_or_2nd_person = pronoun_1st_or_2nd_person.capitalize()
pronoun_3rd_person = pronoun_3rd_person.capitalize()
return (pronoun_1st_or_2nd_person if (caller == receiver) else pronoun_3rd_person) |
def test_broken_register_and_run_with_args(runner):
result = runner.invoke(broken_cli)
assert (result.exit_code == 0)
for ep in iter_entry_points('_test_click_plugins.broken_plugins'):
cmd_result = runner.invoke(broken_cli, [ep.name, '-a', 'b'])
assert (cmd_result.exit_code != 0)
assert ('Traceback' in cmd_result.output) |
class PiecewiseMechanism(LDPBase):
def __init__(self, epsilon, domain):
self._domain = domain
self._epsilon = epsilon
self._pm_encoder = PMBase(epsilon=epsilon)
def _transform(self, value):
value = self._check_value(value)
(a, b) = self._domain
return ((((2 * value) - b) - a) / (b - a))
def _transform_T(self, value):
(a, b) = self._domain
return ((((value * (b - a)) + a) + b) / 2)
def randomize(self, value):
value = self._transform(value)
value = self._pm_encoder.randomize(value)
value = self._transform_T(value)
return value
def _check_value(self, value):
if (not (self._domain[0] <= value <= self._domain[1])):
raise ValueError('the input value={} is not in domain={}'.format(value, self._domain))
return value |
def _assert_expected_output(generated: str, expected: str, expected_file: Path) -> None:
lines = [line for line in unified_diff(expected.splitlines(), generated.splitlines(), fromfile=str(expected_file), tofile='Generated')]
diff = '\n'.join(lines)
if (generated != expected):
print(diff)
assert False, f'Mismatch between {expected_file} and generated code' |
.django_db
def test_diff_agencies_using_monthly_and_quarterly():
baker.make('submissions.DABSSubmissionWindowSchedule', id=11, submission_fiscal_year=2020, submission_fiscal_month=9, is_quarter=False, submission_due_date='2020-07-30', submission_reveal_date='2020-07-31')
baker.make('submissions.DABSSubmissionWindowSchedule', id=22, submission_fiscal_year=2020, submission_fiscal_month=10, is_quarter=False, submission_due_date='2020-08-16', submission_reveal_date='2020-08-17')
baker.make('submissions.DABSSubmissionWindowSchedule', id=33, submission_fiscal_year=2020, submission_fiscal_month=9, is_quarter=True, submission_due_date='2020-08-14', submission_reveal_date='2020-08-15')
baker.make('submissions.DABSSubmissionWindowSchedule', id=44, submission_fiscal_year=2020, submission_fiscal_month=12, is_quarter=True, submission_due_date='2020-08-16', submission_reveal_date='2020-08-17')
baker.make('submissions.SubmissionAttributes', submission_id=1, toptier_code='A', reporting_fiscal_year=2020, reporting_fiscal_period=9, quarter_format_flag=True, submission_window_id=33)
baker.make('submissions.SubmissionAttributes', submission_id=2, toptier_code='A', reporting_fiscal_year=2020, reporting_fiscal_period=12, quarter_format_flag=True, submission_window_id=44)
baker.make('submissions.SubmissionAttributes', submission_id=3, toptier_code='B', reporting_fiscal_year=2020, reporting_fiscal_period=10, quarter_format_flag=False, submission_window_id=22)
baker.make('submissions.SubmissionAttributes', submission_id=4, toptier_code='B', reporting_fiscal_year=2020, reporting_fiscal_period=9, quarter_format_flag=True, submission_window_id=33)
call_command('populate_is_final_balances_for_fy')
agency_a_period_9 = SubmissionAttributes.objects.get(submission_id=1)
agency_a_quarter_4 = SubmissionAttributes.objects.get(submission_id=2)
agency_b_period_10 = SubmissionAttributes.objects.get(submission_id=3)
agency_b_quarter_3 = SubmissionAttributes.objects.get(submission_id=4)
assert (not agency_a_period_9.is_final_balances_for_fy)
assert agency_a_quarter_4.is_final_balances_for_fy
assert agency_b_period_10.is_final_balances_for_fy
assert (not agency_b_quarter_3.is_final_balances_for_fy) |
class Actions():
def get_toggle_actions(self):
return [('ToolsExplorerAction', self.toggle_explorer, '<Ctrl>e'), ('ViewFullScreenAction', self.toggle_full_screen, 'F11')]
def get_main_actions(self):
return [('FileOpenAction', self.open, '<Ctrl>o'), ('FileSaveAction', self.save, '<Ctrl>s'), ('FileSaveAsAction', self.saveas, '<Ctrl><Shift>s'), ('FileSaveImageAction', self.save_image, '<Ctrl>i'), ('FileSaveHighResImageAction', self.save_hires_image, '<Ctrl><Shift>i'), ('FileQuitAction', self.quit, '<Ctrl>q'), ('EditFractalSettingsAction', self.settings, '<Ctrl>f'), ('EditPreferencesAction', self.preferences, None), ('ToolsAutozoomAction', self.autozoom, '<Ctrl>a'), ('ToolsBrowserAction', self.browser, '<Ctrl>b'), ('ToolsDirectorAction', self.director, '<Ctrl>d'), ('ToolsRandomizeAction', self.randomize_colors, '<Ctrl>r'), ('ToolsPainterAction', self.painter, None), ('HelpContentsAction', self.contents, 'F1'), ('HelpReportBugAction', self.report_bug, None), ('HelpAboutAction', self.about, None), ('ImproveNow', self.improve_now, None)]
def get_edit_reset_actions(self):
return [('EditUndoAction', self.undo, '<Ctrl>z'), ('EditRedoAction', self.redo, '<Ctrl><Shift>z'), ('EditResetAction', self.reset, 'Home'), ('EditResetZoomAction', self.reset_zoom, '<Ctrl>Home'), ('EditPasteAction', self.paste, '<Ctrl>v')]
def get_arrow_actions(self):
return [('Left', self.on_key_left), ('Right', self.on_key_right), ('Up', self.on_key_up), ('Down', self.on_key_down)]
def get_fourd_actions(self):
return [('PlanesXYAction', self.set_xy_plane, '<Ctrl>1'), ('PlanesZWAction', self.set_zw_plane, '<Ctrl>2'), ('PlanesXZAction', self.set_xz_plane, '<Ctrl>3'), ('PlanesXWAction', self.set_xw_plane, '<Ctrl>4'), ('PlanesYZAction', self.set_yz_plane, '<Ctrl>5'), ('PlanesWYAction', self.set_wy_plane, '<Ctrl>6')]
def create_actions(self):
main_actions = (self.get_main_actions() + self.get_edit_reset_actions())
Gio.ActionMap.add_action_entries(self.application, [(name, callback) for (name, callback, accel) in main_actions])
for (name, callback, accel) in main_actions:
self.application.set_accels_for_action(f'app.{name}', [accel])
Gio.ActionMap.add_action_entries(self.application, [(*x, 'i') for x in self.get_arrow_actions()])
for key in [x[0] for x in self.get_arrow_actions()]:
self.application.set_accels_for_action(f'app.{key}(0)', [f'{key}'])
self.application.set_accels_for_action(f'app.{key}({int(Gdk.ModifierType.SHIFT_MASK)})', [f'<Shift>{key}'])
self.application.set_accels_for_action(f'app.{key}({int(Gdk.ModifierType.CONTROL_MASK)})', [f'<Control>{key}'])
self.application.set_accels_for_action(f'app.{key}({int((Gdk.ModifierType.SHIFT_MASK | Gdk.ModifierType.CONTROL_MASK))})', [f'<Shift><Control>{key}'])
Gio.ActionMap.add_action_entries(self.application, [(name, None, None, 'false', callback) for (name, callback, accel) in self.get_toggle_actions()])
for (name, callback, accel) in self.get_toggle_actions():
self.application.set_accels_for_action(f'app.{name}', [accel])
self.fourd_actiongroup = Gio.SimpleActionGroup()
self.fourd_actiongroup.add_action_entries([(name, callback) for (name, callback, accel) in self.get_fourd_actions()])
self.insert_action_group('app', self.fourd_actiongroup)
for (name, callback, accel) in self.get_fourd_actions():
self.application.set_accels_for_action(f'app.{name}', [accel])
self.model.seq.register_callbacks(self.application.lookup_action('EditRedoAction').set_enabled, self.application.lookup_action('EditUndoAction').set_enabled) |
_tuple
def get_resolvable_backends_for_uri(uri: URI) -> Generator[(Type[BaseURIBackend], None, None)]:
default_ipfs = get_ipfs_backend_class()
if ((default_ipfs in ALL_URI_BACKENDS) and default_ipfs().can_resolve_uri(uri)):
(yield default_ipfs)
else:
for backend_class in ALL_URI_BACKENDS:
if (backend_class is default_ipfs):
continue
else:
try:
if backend_class().can_resolve_uri(uri):
(yield backend_class)
except Exception as e:
_handle_optional_ipfs_backend_exception(e) |
def _parseKinetoUnitrace(in_trace: List, target_rank: int) -> List:
newCommsTrace = []
commsCnt = 0
for entry in in_trace:
marker = 'unknown'
pass
if (('name' in entry) and (entry['name'] == 'record_param_comms') and (entry['args']['rank'] == target_rank)):
newComm = commsArgs()
newComm.comms = comms_utils.paramToCommName(entry['args']['comms'].lower())
newComm.id = commsCnt
newComm.inMsgSize = entry['args']['in_msg_size']
newComm.outMsgSize = entry['args']['out_msg_size']
newComm.dtype = entry['args']['dtype'].lower()
newComm.inSplit = entry['args']['in_split']
newComm.outSplit = entry['args']['out_split']
newComm.markerStack = marker
newCommsTrace.append(newComm)
commsCnt += 1
return newCommsTrace |
class StringsTable(list):
def __init__(self, io):
super(StringsTable, self).__init__()
string_table_start = io.tell()
number_of_strings = read_u32(io)
strings_offsets_array = [read_u32(io) for _ in range(number_of_strings)]
strings = ([''] * number_of_strings)
for (i, offset) in enumerate(strings_offsets_array):
io.seek((string_table_start + offset), 0)
string_size = read_u32(io)
strings[i] = read_utf16(io, string_size)
self.extend(strings) |
('land')
('--force', is_flag=True, help='force land even if the PR is closed')
('pull_request', metavar='PR')
def land(force: bool, pull_request: str) -> None:
with cli_context() as (shell, config, github):
ghstack.land.main(pull_request=pull_request, github=github, sh=shell, github_url=config.github_url, remote_name=config.remote_name, force=force) |
class DbChatOutputParser(BaseOutputParser):
def __init__(self, is_stream_out: bool, **kwargs):
super().__init__(is_stream_out=is_stream_out, **kwargs)
def is_sql_statement(self, statement):
parsed = sqlparse.parse(statement)
if (not parsed):
return False
for stmt in parsed:
if (stmt.get_type() != 'UNKNOWN'):
return True
return False
def parse_prompt_response(self, model_out_text):
clean_str = super().parse_prompt_response(model_out_text)
logger.info(f'clean prompt response: {clean_str}')
if self.is_sql_statement(clean_str):
return SqlAction(clean_str, '', '')
else:
try:
response = json.loads(clean_str, strict=False)
for key in sorted(response):
if (key.strip() == 'sql'):
sql = response[key]
if (key.strip() == 'thoughts'):
thoughts = response[key]
if (key.strip() == 'display_type'):
display = response[key]
return SqlAction(sql, thoughts, display)
except Exception as e:
logger.error(f'json load failed:{clean_str}')
return SqlAction('', clean_str, '')
def parse_view_response(self, speak, data, prompt_response) -> str:
param = {}
api_call_element = ET.Element('chart-view')
err_msg = None
try:
if ((not prompt_response.sql) or (len(prompt_response.sql) <= 0)):
return f'{speak}'
df = data(prompt_response.sql)
param['type'] = prompt_response.display
param['sql'] = prompt_response.sql
param['data'] = json.loads(df.to_json(orient='records', date_format='iso', date_unit='s'))
view_json_str = json.dumps(param, default=serialize, ensure_ascii=False)
except Exception as e:
logger.error(('parse_view_response error!' + str(e)))
err_param = {}
err_param['sql'] = f'{prompt_response.sql}'
err_param['type'] = 'response_table'
err_param['data'] = []
err_msg = str(e)
view_json_str = json.dumps(err_param, default=serialize, ensure_ascii=False)
api_call_element.set('content', view_json_str)
result = ET.tostring(api_call_element, encoding='utf-8')
if err_msg:
return f'''{speak}
<span style="color:red">ERROR!</span>{err_msg}
{result.decode('utf-8')}'''
else:
return ((speak + '\n') + result.decode('utf-8')) |
class PublicKey(BaseKey, LazyBackend):
def __init__(self, public_key_bytes: bytes, backend: 'Union[BaseECCBackend, Type[BaseECCBackend], str, None]'=None) -> None:
validate_uncompressed_public_key_bytes(public_key_bytes)
self._raw_key = public_key_bytes
super().__init__(backend=backend)
def from_compressed_bytes(cls, compressed_public_key_bytes: bytes, backend: 'BaseECCBackend'=None) -> 'PublicKey':
validate_compressed_public_key_bytes(compressed_public_key_bytes)
if (backend is None):
backend = cls.get_backend()
uncompressed_key = backend.decompress_public_key_bytes(compressed_public_key_bytes)
return cls(uncompressed_key, backend)
def from_private(cls, private_key: 'PrivateKey', backend: 'BaseECCBackend'=None) -> 'PublicKey':
if (backend is None):
backend = cls.get_backend()
return backend.private_key_to_public_key(private_key)
def recover_from_msg(cls, message: bytes, signature: 'Signature', backend: 'BaseECCBackend'=None) -> 'PublicKey':
message_hash = keccak(message)
return cls.recover_from_msg_hash(message_hash, signature, backend)
def recover_from_msg_hash(cls, message_hash: bytes, signature: 'Signature', backend: 'BaseECCBackend'=None) -> 'PublicKey':
if (backend is None):
backend = cls.get_backend()
return backend.ecdsa_recover(message_hash, signature)
def verify_msg(self, message: bytes, signature: 'Signature') -> bool:
message_hash = keccak(message)
return self.verify_msg_hash(message_hash, signature)
def verify_msg_hash(self, message_hash: bytes, signature: 'Signature') -> bool:
return self.backend.ecdsa_verify(message_hash, signature, self)
def to_compressed_bytes(self) -> bytes:
return self.backend.compress_public_key_bytes(self.to_bytes())
def to_checksum_address(self) -> ChecksumAddress:
return to_checksum_address(public_key_bytes_to_address(self.to_bytes()))
def to_address(self) -> str:
return to_normalized_address(public_key_bytes_to_address(self.to_bytes()))
def to_canonical_address(self) -> bytes:
return public_key_bytes_to_address(self.to_bytes()) |
.ledger
('aea_ledger_fetchai._cosmos.requests.get')
('aea_ledger_fetchai._cosmos.requests.post')
def test_successful_faucet_operation(mock_post, mock_get):
address = 'a normal cosmos address would be here'
mock_post.return_value = MockRequestsResponse({'uuid': 'a-uuid-v4-would-be-here'})
mock_get.return_value = MockRequestsResponse({'status': 'ok', 'claim': {'createdAt': '2021-08-13T15:18:50.420Z', 'updatedAt': '2021-08-13T15:18:58.249Z', 'status': FetchAIFaucetApi.FAUCET_STATUS_COMPLETED, 'txStatus': {'hash': '0x transaction hash would be here', 'height': 123456}}})
faucet = FetchAIFaucetApi()
faucet.get_wealth(address)
mock_post.assert_has_calls([call(url=f'{FetchAIFaucetApi.testnet_faucet_url}/api/v3/claims', json={'address': address})])
mock_get.assert_has_calls([call(f'{FetchAIFaucetApi.testnet_faucet_url}/api/v3/claims/a-uuid-v4-would-be-here')]) |
('logs', cls=FandoghCommand)
('-i', '--image', 'image', prompt='Image name', help='The image name', default=(lambda : get_project_config().get('image.name')))
('--version', '-v', prompt='Image version', help='your image version')
('--with_timestamp', 'with_timestamp', is_flag=True, default=False, help='timestamp for each line of image build process')
def logs(image, version, with_timestamp):
show_image_logs(image, version, with_timestamp) |
def osci_change_ranking_dtd_df():
return pd.DataFrame([{OSCIChangeRankingSchema.company: 'Company', OSCIChangeRankingSchema.total: 10, OSCIChangeRankingSchema.active: 5, OSCIChangeRankingSchema.position: 4, OSCIChangeRankingSchema.position_change: 2, OSCIChangeRankingSchema.total_change: 7, OSCIChangeRankingSchema.active_change: 3}]) |
class ReportBot(Bot):
def react_to(self, who, mid, msg):
if (b'abuse' in msg.lower()):
self._handler._write_out(self._client.report(who, mid))
if self._client.server.should_exit():
sys.exit(0)
return None
else:
return b'Cool story bro' |
(params=[1, 2, 3], ids=['Interval', 'Rectangle', 'Box'])
def mesh(request):
distribution = {'overlap_type': (DistributedMeshOverlapType.VERTEX, 1)}
if (request.param == 1):
return IntervalMesh(3, 5, distribution_parameters=distribution)
if (request.param == 2):
return RectangleMesh(10, 20, 2, 3, distribution_parameters=distribution)
if (request.param == 3):
return BoxMesh(5, 3, 5, 1, 2, 3, distribution_parameters=distribution) |
class Ui_dlgG28_30_1(object):
def setupUi(self, dlgG28_30_1):
dlgG28_30_1.setObjectName('dlgG28_30_1')
dlgG28_30_1.setWindowModality(QtCore.Qt.ApplicationModal)
dlgG28_30_1.resize(403, 304)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(':/cn5X/images/XYZAB.svg'), QtGui.QIcon.Normal, QtGui.QIcon.Off)
dlgG28_30_1.setWindowIcon(icon)
self.gridLayout_2 = QtWidgets.QGridLayout(dlgG28_30_1)
self.gridLayout_2.setContentsMargins(4, 4, 4, 4)
self.gridLayout_2.setSpacing(4)
self.gridLayout_2.setObjectName('gridLayout_2')
self.lblPosition = QtWidgets.QLabel(dlgG28_30_1)
self.lblPosition.setObjectName('lblPosition')
self.gridLayout_2.addWidget(self.lblPosition, 0, 0, 1, 2)
self.frmMPos = QtWidgets.QFrame(dlgG28_30_1)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frmMPos.sizePolicy().hasHeightForWidth())
self.frmMPos.setSizePolicy(sizePolicy)
self.frmMPos.setMinimumSize(QtCore.QSize(0, 0))
self.frmMPos.setStyleSheet('background-color: rgb(248, 255, 192);\ncolor: rgb(0, 0, 63);')
self.frmMPos.setFrameShape(QtWidgets.QFrame.Box)
self.frmMPos.setObjectName('frmMPos')
self.gridLayout = QtWidgets.QGridLayout(self.frmMPos)
self.gridLayout.setContentsMargins(4, 0, 0, 0)
self.gridLayout.setSpacing(0)
self.gridLayout.setObjectName('gridLayout')
self.lblLblPosX = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblLblPosX.sizePolicy().hasHeightForWidth())
self.lblLblPosX.setSizePolicy(sizePolicy)
self.lblLblPosX.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblLblPosX.setFont(font)
self.lblLblPosX.setText('X')
self.lblLblPosX.setObjectName('lblLblPosX')
self.gridLayout.addWidget(self.lblLblPosX, 0, 0, 1, 1)
self.lblPosX = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(3)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblPosX.sizePolicy().hasHeightForWidth())
self.lblPosX.setSizePolicy(sizePolicy)
self.lblPosX.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblPosX.setFont(font)
self.lblPosX.setText('+00000.000')
self.lblPosX.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.lblPosX.setObjectName('lblPosX')
self.gridLayout.addWidget(self.lblPosX, 0, 1, 1, 1)
self.chkPosX = QtWidgets.QCheckBox(self.frmMPos)
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.chkPosX.setFont(font)
self.chkPosX.setStyleSheet('QCheckBox{margin-left: 6px;}\nQCheckBox::indicator{\n width: 24px;\n height: 24px;\n}\nQCheckBox::indicator:unchecked {\n image: url(:/cn5X/images/chkBoxUnChecked.svg);\n}\nQCheckBox::indicator:checked {\n image: url(:/cn5X/images/chkBoxChecked.svg);\n}')
self.chkPosX.setText('')
self.chkPosX.setIconSize(QtCore.QSize(24, 24))
self.chkPosX.setCheckable(True)
self.chkPosX.setChecked(True)
self.chkPosX.setObjectName('chkPosX')
self.gridLayout.addWidget(self.chkPosX, 0, 2, 1, 1)
self.lblLblPosY = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblLblPosY.sizePolicy().hasHeightForWidth())
self.lblLblPosY.setSizePolicy(sizePolicy)
self.lblLblPosY.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblLblPosY.setFont(font)
self.lblLblPosY.setText('Y')
self.lblLblPosY.setObjectName('lblLblPosY')
self.gridLayout.addWidget(self.lblLblPosY, 1, 0, 1, 1)
self.lblPosY = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(3)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblPosY.sizePolicy().hasHeightForWidth())
self.lblPosY.setSizePolicy(sizePolicy)
self.lblPosY.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblPosY.setFont(font)
self.lblPosY.setText('+00000.000')
self.lblPosY.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.lblPosY.setObjectName('lblPosY')
self.gridLayout.addWidget(self.lblPosY, 1, 1, 1, 1)
self.chkPosY = QtWidgets.QCheckBox(self.frmMPos)
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.chkPosY.setFont(font)
self.chkPosY.setStyleSheet('QCheckBox{margin-left: 6px;}\nQCheckBox::indicator{\n width: 24px;\n height: 24px;\n}\nQCheckBox::indicator:unchecked {\n image: url(:/cn5X/images/chkBoxUnChecked.svg);\n}\nQCheckBox::indicator:checked {\n image: url(:/cn5X/images/chkBoxChecked.svg);\n}')
self.chkPosY.setText('')
self.chkPosY.setIconSize(QtCore.QSize(24, 24))
self.chkPosY.setCheckable(True)
self.chkPosY.setChecked(True)
self.chkPosY.setObjectName('chkPosY')
self.gridLayout.addWidget(self.chkPosY, 1, 2, 1, 1)
self.lblLblPosZ = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblLblPosZ.sizePolicy().hasHeightForWidth())
self.lblLblPosZ.setSizePolicy(sizePolicy)
self.lblLblPosZ.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblLblPosZ.setFont(font)
self.lblLblPosZ.setText('Z')
self.lblLblPosZ.setObjectName('lblLblPosZ')
self.gridLayout.addWidget(self.lblLblPosZ, 2, 0, 1, 1)
self.lblPosZ = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(3)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblPosZ.sizePolicy().hasHeightForWidth())
self.lblPosZ.setSizePolicy(sizePolicy)
self.lblPosZ.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblPosZ.setFont(font)
self.lblPosZ.setText('+00000.000')
self.lblPosZ.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.lblPosZ.setObjectName('lblPosZ')
self.gridLayout.addWidget(self.lblPosZ, 2, 1, 1, 1)
self.chkPosZ = QtWidgets.QCheckBox(self.frmMPos)
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.chkPosZ.setFont(font)
self.chkPosZ.setStyleSheet('QCheckBox{margin-left: 6px;}\nQCheckBox::indicator{\n width: 24px;\n height: 24px;\n}\nQCheckBox::indicator:unchecked {\n image: url(:/cn5X/images/chkBoxUnChecked.svg);\n}\nQCheckBox::indicator:checked {\n image: url(:/cn5X/images/chkBoxChecked.svg);\n}')
self.chkPosZ.setText('')
self.chkPosZ.setIconSize(QtCore.QSize(24, 24))
self.chkPosZ.setCheckable(True)
self.chkPosZ.setChecked(True)
self.chkPosZ.setObjectName('chkPosZ')
self.gridLayout.addWidget(self.chkPosZ, 2, 2, 1, 1)
self.lblLblPosA = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblLblPosA.sizePolicy().hasHeightForWidth())
self.lblLblPosA.setSizePolicy(sizePolicy)
self.lblLblPosA.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblLblPosA.setFont(font)
self.lblLblPosA.setText('A')
self.lblLblPosA.setObjectName('lblLblPosA')
self.gridLayout.addWidget(self.lblLblPosA, 3, 0, 1, 1)
self.lblPosA = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(3)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblPosA.sizePolicy().hasHeightForWidth())
self.lblPosA.setSizePolicy(sizePolicy)
self.lblPosA.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblPosA.setFont(font)
self.lblPosA.setText('+00000.000')
self.lblPosA.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.lblPosA.setObjectName('lblPosA')
self.gridLayout.addWidget(self.lblPosA, 3, 1, 1, 1)
self.chkPosA = QtWidgets.QCheckBox(self.frmMPos)
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.chkPosA.setFont(font)
self.chkPosA.setStyleSheet('QCheckBox{margin-left: 6px;}\nQCheckBox::indicator{\n width: 24px;\n height: 24px;\n}\nQCheckBox::indicator:unchecked {\n image: url(:/cn5X/images/chkBoxUnChecked.svg);\n}\nQCheckBox::indicator:checked {\n image: url(:/cn5X/images/chkBoxChecked.svg);\n}')
self.chkPosA.setText('')
self.chkPosA.setIconSize(QtCore.QSize(24, 24))
self.chkPosA.setCheckable(True)
self.chkPosA.setChecked(True)
self.chkPosA.setObjectName('chkPosA')
self.gridLayout.addWidget(self.chkPosA, 3, 2, 1, 1)
self.lblLblPosB = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblLblPosB.sizePolicy().hasHeightForWidth())
self.lblLblPosB.setSizePolicy(sizePolicy)
self.lblLblPosB.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblLblPosB.setFont(font)
self.lblLblPosB.setText('B')
self.lblLblPosB.setObjectName('lblLblPosB')
self.gridLayout.addWidget(self.lblLblPosB, 4, 0, 1, 1)
self.lblPosB = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(3)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblPosB.sizePolicy().hasHeightForWidth())
self.lblPosB.setSizePolicy(sizePolicy)
self.lblPosB.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblPosB.setFont(font)
self.lblPosB.setText('+00000.000')
self.lblPosB.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.lblPosB.setObjectName('lblPosB')
self.gridLayout.addWidget(self.lblPosB, 4, 1, 1, 1)
self.chkPosB = QtWidgets.QCheckBox(self.frmMPos)
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.chkPosB.setFont(font)
self.chkPosB.setStyleSheet('QCheckBox{margin-left: 6px;}\nQCheckBox::indicator{\n width: 24px;\n height: 24px;\n}\nQCheckBox::indicator:unchecked {\n image: url(:/cn5X/images/chkBoxUnChecked.svg);\n}\nQCheckBox::indicator:checked {\n image: url(:/cn5X/images/chkBoxChecked.svg);\n}')
self.chkPosB.setText('')
self.chkPosB.setIconSize(QtCore.QSize(24, 24))
self.chkPosB.setCheckable(True)
self.chkPosB.setChecked(True)
self.chkPosB.setObjectName('chkPosB')
self.gridLayout.addWidget(self.chkPosB, 4, 2, 1, 1)
self.lblLblPosC = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblLblPosC.sizePolicy().hasHeightForWidth())
self.lblLblPosC.setSizePolicy(sizePolicy)
self.lblLblPosC.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblLblPosC.setFont(font)
self.lblLblPosC.setText('C')
self.lblLblPosC.setObjectName('lblLblPosC')
self.gridLayout.addWidget(self.lblLblPosC, 5, 0, 1, 1)
self.lblPosC = QtWidgets.QLabel(self.frmMPos)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(3)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lblPosC.sizePolicy().hasHeightForWidth())
self.lblPosC.setSizePolicy(sizePolicy)
self.lblPosC.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.lblPosC.setFont(font)
self.lblPosC.setText('+00000.000')
self.lblPosC.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.lblPosC.setObjectName('lblPosC')
self.gridLayout.addWidget(self.lblPosC, 5, 1, 1, 1)
self.chkPosC = QtWidgets.QCheckBox(self.frmMPos)
font = QtGui.QFont()
font.setFamily('LED Calculator')
font.setPointSize(20)
self.chkPosC.setFont(font)
self.chkPosC.setStyleSheet('QCheckBox{margin-left: 6px;}\nQCheckBox::indicator{\n width: 24px;\n height: 24px;\n}\nQCheckBox::indicator:unchecked {\n image: url(:/cn5X/images/chkBoxUnChecked.svg);\n}\nQCheckBox::indicator:checked {\n image: url(:/cn5X/images/chkBoxChecked.svg);\n}')
self.chkPosC.setText('')
self.chkPosC.setIconSize(QtCore.QSize(24, 24))
self.chkPosC.setCheckable(True)
self.chkPosC.setChecked(True)
self.chkPosC.setObjectName('chkPosC')
self.gridLayout.addWidget(self.chkPosC, 5, 2, 1, 1)
self.gridLayout_2.addWidget(self.frmMPos, 1, 0, 1, 3)
self.imageDeco = QtWidgets.QPushButton(dlgG28_30_1)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.imageDeco.sizePolicy().hasHeightForWidth())
self.imageDeco.setSizePolicy(sizePolicy)
self.imageDeco.setText('')
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(':/cn5X/images/questionG28.svg'), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.imageDeco.setIcon(icon1)
self.imageDeco.setIconSize(QtCore.QSize(48, 48))
self.imageDeco.setAutoDefault(False)
self.imageDeco.setFlat(True)
self.imageDeco.setObjectName('imageDeco')
self.gridLayout_2.addWidget(self.imageDeco, 2, 0, 1, 1)
self.lblMessage = QtWidgets.QLabel(dlgG28_30_1)
self.lblMessage.setWordWrap(True)
self.lblMessage.setObjectName('lblMessage')
self.gridLayout_2.addWidget(self.lblMessage, 2, 1, 1, 2)
self.chkDontShow = QtWidgets.QCheckBox(dlgG28_30_1)
self.chkDontShow.setObjectName('chkDontShow')
self.gridLayout_2.addWidget(self.chkDontShow, 3, 0, 1, 2)
self.buttonBox = QtWidgets.QDialogButtonBox(dlgG28_30_1)
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons((QtWidgets.QDialogButtonBox.Cancel | QtWidgets.QDialogButtonBox.Yes))
self.buttonBox.setObjectName('buttonBox')
self.gridLayout_2.addWidget(self.buttonBox, 3, 2, 1, 1)
self.retranslateUi(dlgG28_30_1)
QtCore.QMetaObject.connectSlotsByName(dlgG28_30_1)
def retranslateUi(self, dlgG28_30_1):
_translate = QtCore.QCoreApplication.translate
dlgG28_30_1.setWindowTitle(_translate('dlgG28_30_1', 'Define G28.1 absolute position'))
self.lblPosition.setText(_translate('dlgG28_30_1', 'Current machine position (MPos)'))
self.chkPosX.setToolTip(_translate('dlgG28_30_1', 'Uncheck to keep this axis at its current position'))
self.chkPosY.setToolTip(_translate('dlgG28_30_1', 'Uncheck to keep this axis at its current position'))
self.chkPosZ.setToolTip(_translate('dlgG28_30_1', 'Uncheck to keep this axis at its current position'))
self.chkPosA.setToolTip(_translate('dlgG28_30_1', 'Uncheck to keep this axis at its current position'))
self.chkPosB.setToolTip(_translate('dlgG28_30_1', 'Uncheck to keep this axis at its current position'))
self.chkPosC.setToolTip(_translate('dlgG28_30_1', 'Uncheck to keep this axis at its current position'))
self.lblMessage.setText(_translate('dlgG28_30_1', "Save the current machine position (MPos) in the G28.1 Grbl's location?"))
self.chkDontShow.setText(_translate('dlgG28_30_1', "Don't show confirmation again")) |
class OptionSeriesGaugeSonificationContexttracksMappingVolume(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
def main():
module_spec = schema_to_module_spec(versioned_schema)
mkeyname = 'id'
fields = {'access_token': {'required': False, 'type': 'str', 'no_log': True}, 'enable_log': {'required': False, 'type': 'bool', 'default': False}, 'vdom': {'required': False, 'type': 'str', 'default': 'root'}, 'member_path': {'required': False, 'type': 'str'}, 'member_state': {'type': 'str', 'required': False, 'choices': ['present', 'absent']}, 'state': {'required': True, 'type': 'str', 'choices': ['present', 'absent']}, 'firewall_region': {'required': False, 'type': 'dict', 'default': None, 'options': {}}}
for attribute_name in module_spec['options']:
fields['firewall_region']['options'][attribute_name] = module_spec['options'][attribute_name]
if (mkeyname and (mkeyname == attribute_name)):
fields['firewall_region']['options'][attribute_name]['required'] = True
module = AnsibleModule(argument_spec=fields, supports_check_mode=True)
check_legacy_fortiosapi(module)
is_error = False
has_changed = False
result = None
diff = None
versions_check_result = None
if module._socket_path:
connection = Connection(module._socket_path)
if ('access_token' in module.params):
connection.set_option('access_token', module.params['access_token'])
if ('enable_log' in module.params):
connection.set_option('enable_log', module.params['enable_log'])
else:
connection.set_option('enable_log', False)
fos = FortiOSHandler(connection, module, mkeyname)
versions_check_result = check_schema_versioning(fos, versioned_schema, 'firewall_region')
(is_error, has_changed, result, diff) = fortios_firewall(module.params, fos, module.check_mode)
else:
module.fail_json(**FAIL_SOCKET_MSG)
if (versions_check_result and (versions_check_result['matched'] is False)):
module.warn('Ansible has detected version mismatch between FortOS system and your playbook, see more details by specifying option -vvv')
if (not is_error):
if (versions_check_result and (versions_check_result['matched'] is False)):
module.exit_json(changed=has_changed, version_check_warning=versions_check_result, meta=result, diff=diff)
else:
module.exit_json(changed=has_changed, meta=result, diff=diff)
elif (versions_check_result and (versions_check_result['matched'] is False)):
module.fail_json(msg='Error in repo', version_check_warning=versions_check_result, meta=result)
else:
module.fail_json(msg='Error in repo', meta=result) |
(scope='function')
def custom_data_category(db: Session) -> Generator:
category = DataCategoryDbModel.create(db=db, data={'name': 'Example Custom Data Category', 'description': 'A custom data category for testing', 'fides_key': 'test_custom_data_category'})
(yield category)
category.delete(db) |
class TestMsgParser(unittest.TestCase):
def _test_msg_parser(self, xid, msg_len):
version = ofproto.OFP_VERSION
msg_type = ofproto.OFPT_HELLO
fmt = ofproto.OFP_HEADER_PACK_STR
buf = pack(fmt, version, msg_type, msg_len, xid)
c = msg_parser(_Datapath, version, msg_type, msg_len, xid, buf)
eq_(version, c.version)
eq_(msg_type, c.msg_type)
eq_(msg_len, c.msg_len)
eq_(xid, c.xid)
fmt = ofproto.OFP_HEADER_PACK_STR
res = struct.unpack(fmt, c.buf)
eq_(version, res[0])
eq_(msg_type, res[1])
eq_(msg_len, res[2])
eq_(xid, res[3])
def test_parser_mid(self):
xid =
msg_len = 8
self._test_msg_parser(xid, msg_len)
def test_parser_max(self):
xid =
msg_len = 65535
self._test_msg_parser(xid, msg_len)
def test_parser_min(self):
xid = 0
msg_len = 0
self._test_msg_parser(xid, msg_len) |
(scope='module', autouse=True)
def run_simple_deploy(reset_test_project, tmp_project, request):
if (sys.platform == 'win32'):
re_platform = '.*\\\\unit_tests\\\\platforms\\\\(.*?)\\\\.*'
else:
re_platform = '.*/unit_tests/platforms/(.*?)/.*'
test_module_path = request.path
m = re.match(re_platform, str(test_module_path))
if m:
platform = m.group(1)
else:
return
cmd = f'python manage.py simple_deploy'
msp.call_simple_deploy(tmp_project, cmd, platform) |
class PeriodicCaller():
def __init__(self, callback: Callable, period: float, start_at: Optional[datetime.datetime]=None, exception_callback: Optional[Callable[([Callable, Exception], None)]]=None, loop: Optional[AbstractEventLoop]=None) -> None:
self._loop = (loop or asyncio.get_event_loop())
self._periodic_callable = callback
self._start_at = (start_at or datetime.datetime.now())
self._period = period
self._timerhandle: Optional[TimerHandle] = None
self._exception_callback = exception_callback
def _callback(self) -> None:
self._schedule_call()
try:
self._periodic_callable()
except Exception as exception:
self.stop()
if (not self._exception_callback):
raise
self._exception_callback(self._periodic_callable, exception)
def _schedule_call(self) -> None:
if (self._timerhandle is None):
ts = time.mktime(self._start_at.timetuple())
delay = max(0, (ts - time.time()))
self._timerhandle = self._loop.call_later(delay, self._callback)
else:
self._timerhandle = self._loop.call_later(self._period, self._callback)
def start(self) -> None:
if self._timerhandle:
return
self._schedule_call()
def stop(self) -> None:
if (not self._timerhandle):
return
self._timerhandle.cancel()
self._timerhandle = None |
class TestGc():
def test_sets_options_for_pre_java_9(self):
gc = telemetry.Gc(telemetry_params={}, log_root='/var/log', java_major_version=random.randint(0, 8))
assert (gc.java_opts('/var/log/defaults-node-0.gc.log') == ['-Xloggc:/var/log/defaults-node-0.gc.log', '-XX:+PrintGCDetails', '-XX:+PrintGCDateStamps', '-XX:+PrintGCTimeStamps', '-XX:+PrintGCApplicationStoppedTime', '-XX:+PrintGCApplicationConcurrentTime', '-XX:+PrintTenuringDistribution'])
def test_sets_options_for_java_9_or_above(self):
gc = telemetry.Gc(telemetry_params={}, log_root='/var/log', java_major_version=random.randint(9, 999))
assert (gc.java_opts('/var/log/defaults-node-0.gc.log') == ['-Xlog:gc*=info,safepoint=info,age*=trace:file=/var/log/defaults-node-0.gc.log:utctime,uptimemillis,level,tags:filecount=0'])
def test_can_override_options_for_java_9_or_above(self):
gc = telemetry.Gc(telemetry_params={'gc-log-config': 'gc,safepoint'}, log_root='/var/log', java_major_version=random.randint(9, 999))
assert (gc.java_opts('/var/log/defaults-node-0.gc.log') == ['-Xlog:gc,safepoint:file=/var/log/defaults-node-0.gc.log:utctime,uptimemillis,level,tags:filecount=0']) |
class CatalogDiv(Catalog.CatalogGroup):
def basic(self) -> CssStylesDrop.CssDropFile:
return self._set_class(CssStylesDrop.CssDropFile)
def bubble(self) -> CssStylesDiv.CssDivBubble:
return self._set_class(CssStylesDiv.CssDivBubble)
def bubble_comment(self) -> CssStylesDiv.CssDivCommBubble:
return self._set_class(CssStylesDiv.CssDivCommBubble)
def left(self) -> CssStylesDiv.CssDivLeft:
return self._set_class(CssStylesDiv.CssDivLeft)
def right(self) -> CssStylesDiv.CssDivRight:
return self._set_class(CssStylesDiv.CssDivRight)
def pointer(self) -> CssStylesDiv.CssDivCursor:
return self._set_class(CssStylesDiv.CssDivCursor)
def banner(self) -> CssStylesDiv.CssDivBanner:
return self._set_class(CssStylesDiv.CssDivBanner)
def sub_banner(self) -> CssStylesDiv.CssDivSubBanner:
return self._set_class(CssStylesDiv.CssDivSubBanner)
def sub_label(self) -> CssStylesDiv.CssDivLabelPoint:
return self._set_class(CssStylesDiv.CssDivLabelPoint)
def no_border(self) -> CssStylesDiv.CssDivNoBorder:
return self._set_class(CssStylesDiv.CssDivNoBorder)
def border(self) -> CssStylesDiv.CssDivWithBorder:
return self._set_class(CssStylesDiv.CssDivWithBorder)
def border_shadow(self) -> CssStylesDiv.CssDivShadow:
return self._set_class(CssStylesDiv.CssDivShadow)
def border_dot(self) -> CssStylesDiv.CssDivBoxWithDotBorder:
return self._set_class(CssStylesDiv.CssDivBoxWithDotBorder)
def border_bottom(self) -> CssStylesDiv.CssDivBottomBorder:
return self._set_class(CssStylesDiv.CssDivBottomBorder)
def console(self) -> CssStylesDiv.CssDivConsole:
return self._set_class(CssStylesDiv.CssDivConsole)
def margin_with_border(self) -> CssStylesDiv.CsssDivBoxMarginBorder:
return self._set_class(CssStylesDiv.CsssDivBoxMarginBorder)
def no_margin(self) -> CssStylesDiv.CssDivNoMargin:
return self._set_class(CssStylesDiv.CssDivNoMargin)
def margin_vertical(self) -> CssStylesDiv.CsssDivBoxMarginVertical:
return self._set_class(CssStylesDiv.CsssDivBoxMarginVertical)
def content_center(self) -> CssStylesDiv.CssDivBoxCenter:
return self._set_class(CssStylesDiv.CssDivBoxCenter)
def color_hover(self, color: str=None) -> CssStylesDivEvents.CssDivOnHover:
if (color is not None):
cssObj = CssStylesDivEvents.CssDivOnHover(self.page, html_id=self._html_id)
cssObj.classname = ('%s_%s' % (cssObj.classname, color.replace('#', '')))
cssObj.hover.css({'color': color}, important=True)
return self._add_class(cssObj)
return self._set_class(CssStylesDivEvents.CssDivOnHover)
def danger_hover(self):
return self._set_class(CssStylesDivEvents.CssDivOnDangerHover)
def background_hover(self) -> CssStylesDivEvents.CssDivOnHoverBackgroundLight:
return self._set_class(CssStylesDivEvents.CssDivOnHoverBackgroundLight)
def color_background_hover(self, color: str=None) -> CssStylesDivEvents.CssDivOnHoverColor:
if (color is not None):
cssObj = CssStylesDivEvents.CssDivOnHoverColor(self.page, html_id=self._html_id)
cssObj.classname = ('%s_%s' % (cssObj.classname, color.replace('#', '')))
cssObj.hover.css({'background-color': color}, important=True)
return self._add_class(cssObj)
return self._set_class(CssStylesDivEvents.CssDivOnHoverColor)
def color_light_background_hover(self) -> CssStylesDivEvents.CssDivOnHoverLightColor:
return self._set_class(CssStylesDivEvents.CssDivOnHoverLightColor)
def width_hover(self) -> CssStylesDivEvents.CssDivOnHoverWidth:
return self._set_class(CssStylesDivEvents.CssDivOnHoverWidth)
def border_hover(self) -> CssStylesDivEvents.CssDivOnHoverBorder:
return self._set_class(CssStylesDivEvents.CssDivOnHoverBorder)
def span_close(self) -> CssStylesCommon.CssCloseSpan:
return self._set_class(CssStylesCommon.CssCloseSpan)
def modal(self) -> CssStylesDiv.CssDivModal:
return self._set_class(CssStylesDiv.CssDivModal)
def modal_content(self) -> CssStylesDiv.CssDivModalContent:
return self._set_class(CssStylesDiv.CssDivModalContent)
def stepper(self) -> CssStylesDiv.CssDivStepper:
return self._set_class(CssStylesDiv.CssDivStepper)
def bubble_container(self) -> CssStylesDivComms.CssSpeechBubble:
return self._set_class(CssStylesDivComms.CssSpeechBubble)
def bubble_content(self) -> CssStylesDivComms.CssSpeechBubbleContent:
return self._set_class(CssStylesDivComms.CssSpeechBubbleContent)
def bubble_arrow(self) -> CssStylesDivComms.CssSpeechBubbleArrow:
return self._set_class(CssStylesDivComms.CssSpeechBubbleArrow)
def rotate_vertical(self) -> CssStylesDiv.CssDivVerticalRotate:
return self._set_class(CssStylesDiv.CssDivVerticalRotate)
def rotate_horizontal(self) -> CssStylesDiv.CssDivHorizontalRotate:
return self._set_class(CssStylesDiv.CssDivHorizontalRotate)
def no_focus_outline(self) -> CssStylesDiv.CssDivNoFocusOutline:
return self._set_class(CssStylesDiv.CssDivNoFocusOutline)
def cut_corner(self) -> CssStylesDiv.CssDivCutCorner:
return self._set_class(CssStylesDiv.CssDivCutCorner) |
def main():
parser = make_arg_parser()
parsed_args = get_args(parser)
try:
validate_all_args(parsed_args)
json_data = get_json_data(os.path.abspath(parsed_args[JSON_ARG]))
doc = make_docxtemplate(os.path.abspath(parsed_args[TEMPLATE_ARG]))
doc = render_docx(doc, json_data)
save_file(doc, parsed_args)
except RuntimeError as e:
print(('Error: ' + e.__str__()))
return
finally:
if (not parsed_args[QUIET_ARG]):
print('Exiting program!') |
((LOOK_DEV_TYPES + ['model', 'rig', 'layout']))
def check_extra_cameras(progress_controller=None):
if (progress_controller is None):
progress_controller = ProgressControllerBase()
if (len(pm.ls(type='camera')) > 4):
progress_controller.complete()
raise PublishError('There should be no extra cameras in your scene!')
progress_controller.complete() |
def extractCircusTranslations(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
if ('German Translation' in item['tags']):
return None
if ('Turkish Translation' in item['tags']):
return None
if ('Spanish translation' in item['tags']):
return None
if (chp or vol):
return buildReleaseMessageWithType(item, 'Tensei Shitara Slime Datta Ken', vol, chp, frag=frag, postfix=postfix)
return False |
class OptionSeriesSplineOnpointConnectoroptions(Options):
def dashstyle(self):
return self._config_get(None)
def dashstyle(self, text: str):
self._config(text, js_type=False)
def stroke(self):
return self._config_get(None)
def stroke(self, text: str):
self._config(text, js_type=False)
def width(self):
return self._config_get(1)
def width(self, num: float):
self._config(num, js_type=False) |
def set_chat_permissions(token, chat_id, permissions, use_independent_chat_permissions=None):
method_url = 'setChatPermissions'
payload = {'chat_id': chat_id, 'permissions': permissions.to_json()}
if (use_independent_chat_permissions is not None):
payload['use_independent_chat_permissions'] = use_independent_chat_permissions
return _make_request(token, method_url, params=payload, method='post') |
class FrameBase():
def __init__(self, *args, **kwargs):
self.low_pc = kwargs['low_pc']
self.high_pc = kwargs['high_pc']
self.base_register = kwargs['base_register']
self.offset = kwargs['offset']
def __repr__(self):
return '{} {} {} {}'.format(self.base_register, self.offset, format(self.low_pc, '02x'), format(self.high_pc, '02x')) |
class Wireguard(IntervalModule):
color_up = '#00ff00'
color_down = '#FF0000'
status_up = ''
status_down = ''
format = '{vpn_name} {status}'
status_command = 'systemctl is-active wg-{vpn_name}'
vpn_up_command = 'sudo /bin/systemctl start wg-{vpn_name}.service'
vpn_down_command = 'sudo /bin/systemctl stop wg-{vpn_name}.service'
connected = False
label = ''
vpn_name = ''
settings = (('format', 'Format string'), ('color_up', 'VPN is up'), ('color_down', 'VPN is down'), ('status_down', 'Symbol to display when down'), ('status_up', 'Symbol to display when up'), ('vpn_name', 'Name of VPN'), ('vpn_up_command', 'Command to bring up the VPN - default requires editing /etc/sudoers'), ('vpn_down_command', 'Command to bring up the VPN - default requires editing /etc/sudoers'), ('status_command', 'command to find out if the VPN is active'))
def init(self):
if (not self.vpn_name):
raise Exception('vpn_name is required')
def toggle_connection(self):
if self.connected:
command = self.vpn_down_command
else:
command = self.vpn_up_command
run_through_shell(command.format(vpn_name=self.vpn_name))
def on_click(self, button, **kwargs):
self.toggle_connection()
def run(self):
command_result = run_through_shell(self.status_command.format(vpn_name=self.vpn_name))
self.connected = (command_result.rc == 0)
if self.connected:
(color, status) = (self.color_up, self.status_up)
else:
(color, status) = (self.color_down, self.status_down)
vpn_name = self.vpn_name
label = self.label
self.data = locals()
self.output = {'full_text': self.format.format(**self.data), 'color': color} |
class LoggingFtpAdditional(ModelNormal):
allowed_values = {}
validations = {}
_property
def additional_properties_type():
return (bool, date, datetime, dict, float, int, list, str, none_type)
_nullable = False
_property
def openapi_types():
return {'address': (str,), 'hostname': (str,), 'ipv4': (str,), 'password': (str,), 'path': (str,), 'public_key': (str, none_type), 'user': (str,)}
_property
def discriminator():
return None
attribute_map = {'address': 'address', 'hostname': 'hostname', 'ipv4': 'ipv4', 'password': 'password', 'path': 'path', 'public_key': 'public_key', 'user': 'user'}
read_only_vars = {}
_composed_schemas = {}
_js_args_to_python_args
def _from_openapi_data(cls, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(OpenApiModel, cls).__new__(cls)
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
for (var_name, var_value) in kwargs.items():
if ((var_name not in self.attribute_map) and (self._configuration is not None) and self._configuration.discard_unknown_keys and (self.additional_properties_type is None)):
continue
setattr(self, var_name, var_value)
return self
required_properties = set(['_data_store', '_check_type', '_spec_property_naming', '_path_to_item', '_configuration', '_visited_composed_classes'])
_js_args_to_python_args
def __init__(self, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
for (var_name, var_value) in kwargs.items():
if ((var_name not in self.attribute_map) and (self._configuration is not None) and self._configuration.discard_unknown_keys and (self.additional_properties_type is None)):
continue
setattr(self, var_name, var_value)
if (var_name in self.read_only_vars):
raise ApiAttributeError(f'`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate class with read only attributes.') |
def _worker(options, proc_num, auth=None):
cid = ('%s-%d' % (options.clientid, proc_num))
if options.bridge:
ts = beem.bridge.BridgingSender(options.host, options.port, cid, auth)
if auth:
cid = auth.split(':')[0]
else:
ts = beem.load.TrackingSender(options.host, options.port, cid)
msg_gen = beem.msgs.createGenerator(cid, options)
time.sleep(random.uniform(1, 10))
ts.run(msg_gen, qos=options.qos)
return ts.stats() |
def extractMeatbuntranslationBlogspotCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class OptionPlotoptionsWaterfallSonificationDefaultspeechoptionsPointgrouping(Options):
def algorithm(self):
return self._config_get('last')
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) |
class TestSalesInvoice(FrappeTestCase):
def test_set_healthcare_services_should_preserve_state(self):
invoice = frappe.copy_doc(test_records[0])
count = len(invoice.items)
item = invoice.items[0]
checked_values = [{'dt': 'Item', 'dn': item.item_name, 'item': item.item_code, 'qty': False, 'rate': False, 'income_account': False, 'description': False}]
invoice.set_healthcare_services(checked_values)
self.assertEqual((count + 1), len(invoice.items))
invoice.set_healthcare_services(checked_values)
self.assertEqual((count + 2), len(invoice.items)) |
def get_event_data(abi_codec: ABICodec, event_abi: ABIEvent, log_entry: LogReceipt) -> EventData:
if event_abi['anonymous']:
log_topics = log_entry['topics']
elif (not log_entry['topics']):
raise MismatchedABI('Expected non-anonymous event to have 1 or more topics')
elif (event_abi_to_log_topic(event_abi) != log_entry['topics'][0]):
raise MismatchedABI('The event signature did not match the provided ABI')
else:
log_topics = log_entry['topics'][1:]
log_topics_abi = get_indexed_event_inputs(event_abi)
log_topic_normalized_inputs = normalize_event_input_types(log_topics_abi)
log_topic_types = get_event_abi_types_for_decoding(log_topic_normalized_inputs)
log_topic_names = get_abi_input_names(ABIEvent({'inputs': log_topics_abi}))
if (len(log_topics) != len(log_topic_types)):
raise LogTopicError(f'Expected {len(log_topic_types)} log topics. Got {len(log_topics)}')
log_data = hexstr_if_str(to_bytes, log_entry['data'])
log_data_abi = exclude_indexed_event_inputs(event_abi)
log_data_normalized_inputs = normalize_event_input_types(log_data_abi)
log_data_types = get_event_abi_types_for_decoding(log_data_normalized_inputs)
log_data_names = get_abi_input_names(ABIEvent({'inputs': log_data_abi}))
duplicate_names = set(log_topic_names).intersection(log_data_names)
if duplicate_names:
raise InvalidEventABI(f"The following argument names are duplicated between event inputs: '{', '.join(duplicate_names)}'")
decoded_log_data = abi_codec.decode(log_data_types, log_data)
normalized_log_data = map_abi_data(BASE_RETURN_NORMALIZERS, log_data_types, decoded_log_data)
named_log_data = named_tree(log_data_normalized_inputs, normalized_log_data)
decoded_topic_data = [abi_codec.decode([topic_type], topic_data)[0] for (topic_type, topic_data) in zip(log_topic_types, log_topics)]
normalized_topic_data = map_abi_data(BASE_RETURN_NORMALIZERS, log_topic_types, decoded_topic_data)
event_args = dict(itertools.chain(zip(log_topic_names, normalized_topic_data), named_log_data.items()))
event_data = EventData(args=event_args, event=event_abi['name'], logIndex=log_entry['logIndex'], transactionIndex=log_entry['transactionIndex'], transactionHash=log_entry['transactionHash'], address=log_entry['address'], blockHash=log_entry['blockHash'], blockNumber=log_entry['blockNumber'])
if isinstance(log_entry, AttributeDict):
return cast(EventData, AttributeDict.recursive(event_data))
return event_data |
def keras_subclass(name: str, X: XType, Y: YType, input_shape: Tuple[(int, ...)], compile_args: Optional[Dict[(str, Any)]]=None) -> Callable[([InFunc], InFunc)]:
compile_defaults = {'optimizer': 'adam', 'loss': 'mse'}
if (compile_args is None):
compile_args = compile_defaults
else:
compile_args = {**compile_defaults, **compile_args}
def call_fn(clazz):
clazz.catalogue_name = property((lambda inst: name))
clazz.eg_shape = property((lambda inst: input_shape))
clazz.eg_compile = property((lambda inst: compile_args))
clazz.eg_x = property((lambda inst: X))
clazz.eg_y = property((lambda inst: Y))
_model_fns(name)
def create_component(*call_args, **call_kwargs):
return clazz(*call_args, **call_kwargs)
wrapped_init = clazz.__init__
def __init__(self, *args, **kwargs):
wrapped_init(self, *args, **kwargs)
try:
srsly.json_dumps(args)
srsly.json_dumps(kwargs)
except BaseException as _err:
raise ValueError(f'''In order to serialize Keras Subclass models, the constructor arguments must be serializable. This allows thinc to recreate the code-based model with the same configuration.
The encountered error is: {_err}''')
self.eg_args = ArgsKwargs(args, kwargs)
clazz.__init__ = __init__
return clazz
return call_fn |
class TestNamedTupleV3(TestCase):
def test_fixed_size(self):
class Book(NamedTuple, size=TupleSize.fixed):
title = 0
author = 1
genre = 2
b = Book('Teckla', 'Steven Brust', 'fantasy')
self.assertTrue(('Teckla' in b))
self.assertTrue(('Steven Brust' in b))
self.assertTrue(('fantasy' in b))
self.assertEqual(b.title, 'Teckla')
self.assertEqual(b.author, 'Steven Brust')
self.assertRaises(TypeError, Book, 'Teckla', 'Steven Brust')
self.assertRaises(TypeError, Book, 'Teckla')
def test_minimum_size(self):
class Book(NamedTuple, size=TupleSize.minimum):
title = 0
author = 1
b = Book('Teckla', 'Steven Brust', 'fantasy')
self.assertTrue(('Teckla' in b))
self.assertTrue(('Steven Brust' in b))
self.assertTrue(('fantasy' in b))
self.assertEqual(b.title, 'Teckla')
self.assertEqual(b.author, 'Steven Brust')
self.assertEqual(b[2], 'fantasy')
b = Book('Teckla', 'Steven Brust')
self.assertTrue(('Teckla' in b))
self.assertTrue(('Steven Brust' in b))
self.assertEqual(b.title, 'Teckla')
self.assertEqual(b.author, 'Steven Brust')
self.assertRaises(TypeError, Book, 'Teckla')
def test_variable_size(self):
class Book(NamedTuple, size=TupleSize.variable):
title = 0
author = 1
genre = 2
b = Book('Teckla', 'Steven Brust', 'fantasy')
self.assertTrue(('Teckla' in b))
self.assertTrue(('Steven Brust' in b))
self.assertTrue(('fantasy' in b))
self.assertEqual(b.title, 'Teckla')
self.assertEqual(b.author, 'Steven Brust')
self.assertEqual(b.genre, 'fantasy')
b = Book('Teckla', 'Steven Brust')
self.assertTrue(('Teckla' in b))
self.assertTrue(('Steven Brust' in b))
self.assertEqual(b.title, 'Teckla')
self.assertEqual(b.author, 'Steven Brust')
self.assertRaises(AttributeError, getattr, b, 'genre')
self.assertRaises(TypeError, Book, title='Teckla', genre='fantasy')
self.assertRaises(TypeError, Book, author='Steven Brust') |
class OptionSeriesErrorbarSonificationPointgrouping(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) |
class OptionSeriesVennDragdropGuideboxDefault(Options):
def className(self):
return self._config_get('highcharts-drag-box-default')
def className(self, text: str):
self._config(text, js_type=False)
def color(self):
return self._config_get('rgba(0, 0, 0, 0.1)')
def color(self, text: str):
self._config(text, js_type=False)
def cursor(self):
return self._config_get('move')
def cursor(self, text: str):
self._config(text, js_type=False)
def lineColor(self):
return self._config_get('#888')
def lineColor(self, text: str):
self._config(text, js_type=False)
def lineWidth(self):
return self._config_get(1)
def lineWidth(self, num: float):
self._config(num, js_type=False)
def zIndex(self):
return self._config_get(900)
def zIndex(self, num: float):
self._config(num, js_type=False) |
def shields_icons(conf: AppConfig, deps: list, full_name: str):
if (conf.git.source == GitService.LOCAL.host):
repo_host = GitService.LOCAL.host
else:
repo_host = GitService.extract_name_from_host(conf.git.source)
resource_path = utils.get_resource_path(__package__, conf.files.shields_icons)
md_badge_template = badge_template(conf)
shields_dict = FileHandler().read(resource_path)
shields_icons = md_badge_template.format(conf.md.align, build_html_badges(deps, repo_host, shields_dict).format(conf.md.badges_style), repo_host, full_name, conf.md.badges_style)
return (utils.remove_substring(shields_icons) if ('invalid' in full_name.lower()) else shields_icons) |
def test():
from instakit.utils.static import asset
from instakit.utils.mode import Mode
image_paths = list(map((lambda image_file: asset.path('img', image_file)), asset.listfiles('img')))
image_inputs = list(map((lambda image_path: Mode.RGB.open(image_path)), image_paths))
noises = [GaussianNoise, PoissonNoise, GaussianLocalVarianceNoise, SaltNoise, PepperNoise, SaltAndPepperNoise, SpeckleNoise]
for (idx, image_input) in enumerate((image_inputs + image_inputs[:2])):
for NoiseProcessor in noises:
NoiseProcessor().process(image_input).show()
print(image_paths) |
def rivet():
selection_list = pm.filterExpand(sm=32)
if ((selection_list is not None) and (len(selection_list) > 0)):
size = len(selection_list)
if (size != 2):
raise pm.MayaObjectError('No two edges selected')
edge1 = pm.PyNode(selection_list[0])
edge2 = pm.PyNode(selection_list[1])
edge1Index = edge1.indices()[0]
edge2Index = edge2.indices()[0]
shape = edge1.node()
cFME1 = pm.createNode('curveFromMeshEdge', n='rivetCurveFromMeshEdge#')
cFME1.setAttr('ihi', 1)
cFME1.setAttr('ei[0]', edge1Index)
cFME2 = pm.createNode('curveFromMeshEdge', n='rivetCurveFromMeshEdge#')
cFME2.setAttr('ihi', 1)
cFME2.setAttr('ei[0]', edge2Index)
loft = pm.createNode('loft', n='rivetLoft#')
loft.setAttr('ic', s=2)
loft.setAttr('u', 1)
loft.setAttr('rsn', 1)
pOSI = pm.createNode('pointOnSurfaceInfo', n='rivetPointOnSurfaceInfo#')
pOSI.setAttr('turnOnPercentage', 1)
pOSI.setAttr('parameterU', 0.5)
pOSI.setAttr('parameterV', 0.5)
(loft.attr('os') >> pOSI.attr('is'))
(cFME1.attr('oc') >> loft.attr('ic[0]'))
(cFME2.attr('oc') >> loft.attr('ic[1]'))
(shape.attr('w') >> cFME1.attr('im'))
(shape.attr('w') >> cFME2.attr('im'))
else:
selection_list = pm.filterExpand(sm=41)
if ((selection_list is not None) and (len(selection_list) > 0)):
size = len(selection_list)
if (size != 1):
raise pm.MayaObjectError('No one point selected')
point = pm.PyNode(selection_list[0])
shape = point.node()
u = float(point.name().split('][')[0].split('[')[1])
v = float(point.name().split('][')[1].split(']')[0])
pOSI = pm.createNode('pointOnSurfaceInfo', n='rivetPointOnSurfaceInfo#')
pOSI.setAttr('turnOnPercentage', 0)
pOSI.setAttr('parameterU', u)
pOSI.setAttr('parameterV', v)
(shape.attr('ws') >> pOSI.attr('is'))
else:
raise pm.MayaObjectError('No edges or point selected')
locator = pm.spaceLocator(n='rivet#')
aimCons = pm.createNode('aimConstraint', p=locator, n=(locator.name() + '_rivetAimConstraint#'))
aimCons.setAttr('tg[0].tw', 1)
aimCons.setAttr('a', (0, 1, 0))
aimCons.setAttr('u', (0, 0, 1))
aimCons.setAttr('v', k=0)
aimCons.setAttr('tx', k=0)
aimCons.setAttr('ty', k=0)
aimCons.setAttr('tz', k=0)
aimCons.setAttr('rx', k=0)
aimCons.setAttr('ry', k=0)
aimCons.setAttr('rz', k=0)
aimCons.setAttr('sx', k=0)
aimCons.setAttr('sy', k=0)
aimCons.setAttr('sz', k=0)
(pOSI.attr('position') >> locator.attr('translate'))
(pOSI.attr('n') >> aimCons.attr('tg[0].tt'))
(pOSI.attr('tv') >> aimCons.attr('wu'))
(aimCons.attr('crx') >> locator.attr('rx'))
(aimCons.attr('cry') >> locator.attr('ry'))
(aimCons.attr('crz') >> locator.attr('rz'))
pm.select(locator)
return locator |
class StreamLogger(AbstractLogger):
stream = sys.stderr
def init(self, *priv):
try:
handler = logging.StreamHandler(self.stream)
except AttributeError as exc:
raise SnmpsimError(('Stream logger failure: %s' % exc))
handler.setFormatter(logging.Formatter('%(message)s'))
self._logger.addHandler(handler) |
.integration_test
def test_field_param_update(tmpdir):
with tmpdir.as_cwd():
config = dedent('\n NUM_REALIZATIONS 5\n OBS_CONFIG observations\n\n FIELD MY_PARAM PARAMETER my_param.grdecl INIT_FILES:my_param.grdecl FORWARD_INIT:True\n GRID MY_EGRID.EGRID\n\n GEN_DATA MY_RESPONSE RESULT_FILE:gen_data_%d.out REPORT_STEPS:0 INPUT_FORMAT:ASCII\n INSTALL_JOB poly_eval POLY_EVAL\n SIMULATION_JOB poly_eval\n ')
with open('config.ert', 'w', encoding='utf-8') as fh:
fh.writelines(config)
NCOL = 5
NROW = 4
NLAY = 1
grid = xtgeo.create_box_grid(dimension=(NCOL, NROW, NLAY))
grid.to_file('MY_EGRID.EGRID', 'egrid')
with open('forward_model', 'w', encoding='utf-8') as f:
f.write(dedent('#!/usr/bin/env python\nimport xtgeo\nimport numpy as np\nimport os\n\nif __name__ == "__main__":\n if not os.path.exists("my_param.grdecl"):\n values = np.random.standard_normal(5*4)\n with open("my_param.grdecl", "w") as fout:\n fout.write("MY_PARAM\\n")\n fout.write(" ".join([str(val) for val in values]) + " /\\n")\n with open("my_param.grdecl", "r") as fin:\n for line_nr, line in enumerate(fin):\n if line_nr == 1:\n a, b, c, *_ = line.split()\n\n output = [float(a) * x**2 + float(b) * x + float(c) for x in range(10)]\n with open("gen_data_0.out", "w", encoding="utf-8") as f:\n f.write("\\n".join(map(str, output)))\n '))
os.chmod('forward_model', (((os.stat('forward_model').st_mode | stat.S_IXUSR) | stat.S_IXGRP) | stat.S_IXOTH))
with open('POLY_EVAL', 'w', encoding='utf-8') as fout:
fout.write('EXECUTABLE forward_model')
with open('observations', 'w', encoding='utf-8') as fout:
fout.write(dedent('\n GENERAL_OBSERVATION MY_OBS {\n DATA = MY_RESPONSE;\n INDEX_LIST = 0,2,4,6,8;\n RESTART = 0;\n OBS_FILE = obs.txt;\n };'))
with open('obs.txt', 'w', encoding='utf-8') as fobs:
fobs.write(dedent('\n 2. 0.6\n 8. 1.4\n 12. 3.0\n 25. 5.4\n 42. 8.6'))
parser = ArgumentParser(prog='test_main')
parsed = ert_parser(parser, [ENSEMBLE_SMOOTHER_MODE, '--current-case', 'prior', '--target-case', 'smoother_update', 'config.ert'])
run_cli(parsed)
config = ErtConfig.from_file('config.ert')
with open_storage(config.ens_path, mode='w') as storage:
prior = storage.get_ensemble_by_name('prior')
posterior = storage.get_ensemble_by_name('smoother_update')
prior_result = prior.load_parameters('MY_PARAM', list(range(5)))['values']
assert (len(prior_result.x) == NCOL)
assert (len(prior_result.y) == NROW)
assert (len(prior_result.z) == NLAY)
posterior_result = posterior.load_parameters('MY_PARAM', list(range(5)))['values']
assert (np.linalg.det(np.cov(prior_result.values.reshape(5, ((NCOL * NROW) * NLAY)).T[:3])) > np.linalg.det(np.cov(posterior_result.values.reshape(5, ((NCOL * NROW) * NLAY)).T[:3])))
assert (Path('simulations/realization-0/iter-0/my_param.grdecl').read_text(encoding='utf-8') != Path('simulations/realization-0/iter-1/my_param.grdecl').read_text(encoding='utf-8')) |
def parse_cjson(fn):
with open(fn) as handle:
cml = json.load(handle)
atms = cml['atoms']
coords = (np.array(atms['coords']['3d'], dtype=float) * ANG2BOHR)
atom_nums = atms['elements']['number']
atoms = tuple([INV_ATOMIC_NUMBERS[num].capitalize() for num in atom_nums])
return (atoms, coords.flatten()) |
.skipif((not torch.cuda.is_available()), reason='requires GPU access to train the model')
def test_normal_normal_guide_step_gpu():
device = torch.device('cuda:0')
model = NormalNormal(device=device)
def phi():
return torch.zeros(2).to(device)
_variable
def q_mu():
params = phi()
return dist.Normal(params[0], params[1].exp())
world = VariationalInfer(queries_to_guides={model.mu(): q_mu()}, observations={model.x(1): torch.tensor(9.0), model.x(2): torch.tensor(10.0)}, optimizer=(lambda params: torch.optim.Adam(params, lr=0.1)), device=device).infer(num_steps=1000)
mu_approx = world.get_variable(q_mu()).distribution
assert ((mu_approx.mean - 9.6).norm() < 1.0)
assert ((mu_approx.stddev - 0.7).norm() < 0.3) |
class OptionPlotoptionsColumnSonificationDefaultspeechoptions(Options):
def activeWhen(self) -> 'OptionPlotoptionsColumnSonificationDefaultspeechoptionsActivewhen':
return self._config_sub_data('activeWhen', OptionPlotoptionsColumnSonificationDefaultspeechoptionsActivewhen)
def language(self):
return self._config_get('en-US')
def language(self, text: str):
self._config(text, js_type=False)
def mapping(self) -> 'OptionPlotoptionsColumnSonificationDefaultspeechoptionsMapping':
return self._config_sub_data('mapping', OptionPlotoptionsColumnSonificationDefaultspeechoptionsMapping)
def pointGrouping(self) -> 'OptionPlotoptionsColumnSonificationDefaultspeechoptionsPointgrouping':
return self._config_sub_data('pointGrouping', OptionPlotoptionsColumnSonificationDefaultspeechoptionsPointgrouping)
def preferredVoice(self):
return self._config_get(None)
def preferredVoice(self, text: str):
self._config(text, js_type=False)
def showPlayMarker(self):
return self._config_get(True)
def showPlayMarker(self, flag: bool):
self._config(flag, js_type=False)
def type(self):
return self._config_get('speech')
def type(self, text: str):
self._config(text, js_type=False) |
def _run_command(cmd_args: list[str]) -> str:
logger.debug("Executing '%s'", ' '.join(cmd_args))
try:
creationflags = getattr(subprocess, 'CREATE_NO_WINDOW', None)
kwargs = ({'creationflags': creationflags} if creationflags else {})
proc = subprocess.run(cmd_args, capture_output=True, text=True, check=False, **kwargs)
_raise_on_error(proc)
out_str = proc.stdout
logger.debug('Tesseract command output: %s', out_str.replace(linesep, ' ').strip())
except FileNotFoundError as e:
raise FileNotFoundError('Could not find Tesseract binary') from e
return out_str |
class Solution():
def deleteDuplicates(self, head: ListNode) -> ListNode:
nh = ListNode(None)
(np, nc) = (None, nh)
curr = head
should_retreat = False
while (curr is not None):
if (curr.val == nc.val):
should_retreat = True
else:
if should_retreat:
np.next = curr
nc = curr
else:
nc.next = curr
np = nc
nc = curr
should_retreat = False
curr = curr.next
if should_retreat:
np.next = None
return nh.next |
(params=['scalar', 'vector', pytest.param('tensor', marks=pytest.mark.skip(reason='Prolongation fails for tensors'))])
def shapify(request):
if (request.param == 'scalar'):
return (lambda x: x)
elif (request.param == 'vector'):
return VectorElement
elif (request.param == 'tensor'):
return TensorElement
else:
raise RuntimeError |
def setup_switch_btn(editor: Editor):
if (hasattr(editor, 'parentWindow') and isinstance(editor.parentWindow, AddCards)):
win = aqt.dialogs._dialogs['AddCards'][1]
elif (hasattr(editor, 'parentWindow') and isinstance(editor.parentWindow, EditCurrent)):
if (not conf_or_def('useInEdit', False)):
return
win = aqt.dialogs._dialogs['EditCurrent'][1]
else:
win = aqt.dialogs._dialogs['AddCards'][1]
if (win is None):
return
box = win.form.buttonBox
if (hasattr(box, 'switch_btn') and (box.switch_btn is not None)):
return
button = QPushButton(conf_or_def('window_mode', 'Both'))
menu = QMenu(button)
a1 = menu.addAction('Show Both')
a1.triggered.connect(functools.partial(state.set_window_mode, 'Both', editor))
a2 = menu.addAction('Show Both, Auto-hide Fields')
a2.triggered.connect(functools.partial(state.set_window_mode, 'Autohide', editor))
a3 = menu.addAction('Show Only Fields')
a3.triggered.connect(functools.partial(state.set_window_mode, 'Fields', editor))
a4 = menu.addAction('Show Only Add-on')
a4.triggered.connect(functools.partial(state.set_window_mode, 'Addon', editor))
button.setMenu(menu)
box.layout().insertWidget(0, button)
box.switch_btn = button
win.update() |
class TestIssue3090(BaseEvenniaTest):
def test_long_aliases(self):
cmdset_g = _CmdSetG()
result = cmdparser.cmdparser('smile at', cmdset_g, None)[0]
self.assertEqual(result[0], 'smile at')
self.assertEqual(result[1], '')
self.assertEqual(result[2].__class__, _CmdG)
self.assertEqual(result[3], 8)
self.assertEqual(result[4], 1.0)
self.assertEqual(result[5], 'smile at') |
_bp.route((app.config['FLICKET'] + 'category_edit/<int:category_id>/'), methods=['GET', 'POST'])
_required
def category_edit(category_id=False):
if category_id:
form = CategoryForm()
category = FlicketCategory.query.filter_by(id=category_id).first()
form.department_id.data = category.department_id
if form.validate_on_submit():
category.category = form.category.data
db.session.commit()
flash('Category {} edited.'.format(form.category.data), category='success')
return redirect(url_for('flicket_bp.departments'))
form.category.data = category.category
title = gettext('Edit Category')
return render_template('flicket_category_edit.html', title=title, form=form, category=category, department=category.department.department)
return redirect(url_for('flicket_bp.departments')) |
def main():
perfolder = {}
for line2 in sys.stdin.readlines():
line = line2.strip()
if ('extract/' in line):
folders = line.split('/')
if (len(folders) < 3):
print('WARN', line)
pass
else:
folder = folders[2]
if (folder in perfolder):
perfolder[folder].append(line)
else:
perfolder[folder] = [line]
for (key, value) in sorted(perfolder.items(), key=(lambda x: len(x[1]))):
print(key, len(value)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.