code stringlengths 281 23.7M |
|---|
def _cmd_reference(args):
usage_err_msg = 'Give .cnn samples OR targets and (optionally) antitargets.'
if args.targets:
assert (not args.references), usage_err_msg
ref_probes = reference.do_reference_flat(args.targets, args.antitargets, args.fasta, args.male_reference)
elif args.references:
assert ((not args.targets) and (not args.antitargets)), usage_err_msg
filenames = []
for path in args.references:
if os.path.isdir(path):
filenames.extend((os.path.join(path, f) for f in os.listdir(path) if f.endswith('targetcoverage.cnn')))
else:
filenames.append(path)
targets = [f for f in filenames if ('antitarget' not in f)]
antitargets = [f for f in filenames if ('antitarget' in f)]
logging.info('Number of target and antitarget files: %d, %d', len(targets), len(antitargets))
female_samples = ((args.sample_sex.lower() not in ['y', 'm', 'male']) if args.sample_sex else None)
ref_probes = reference.do_reference(targets, antitargets, args.fasta, args.male_reference, args.diploid_parx_genome, female_samples, args.do_gc, args.do_edge, args.do_rmask, args.cluster, args.min_cluster_size)
else:
raise ValueError(usage_err_msg)
ref_fname = (args.output or 'cnv_reference.cnn')
core.ensure_path(ref_fname)
tabio.write(ref_probes, ref_fname) |
def test_equal_szts_more_images():
kwargs = copy.copy(KWARGS)
kwargs['images'] = 7
convergence = {'rms_force_thresh': 2.4}
kwargs['convergence'] = convergence
szts_equal = SimpleZTS(get_geoms(), param='equal')
opt = run_cos_opt(szts_equal, SteepestDescent, **kwargs)
assert opt.is_converged
assert (opt.cur_cycle == 21)
return opt |
def apispec_to_template(app, spec, definitions=None, paths=None):
definitions = (definitions or [])
paths = (paths or [])
with app.app_context():
for definition in definitions:
if isinstance(definition, (tuple, list)):
(name, schema) = definition
else:
schema = definition
name = schema.__name__.replace('Schema', '')
spec.components.schema(name, schema=schema)
for path in paths:
spec.path(view=path)
spec_dict = spec.to_dict()
ret = ordered_dict_to_dict(spec_dict)
return ret |
class GetSentencesTest(unittest.TestCase):
('get_sentences.app.pull_user_sentences', side_effect=mocked_pull_user_sentences)
def test_build(self, pull_user_sentences_mock):
response = lambda_handler(self.sub_apig_event(), '')
def sub_apig_event(self):
return {'resource': '/sentence', 'path': '/sentence', 'body': '', ' 'GET', 'headers': {'Accept': 'application/json, text/plain, */*', 'accept-encoding': 'gzip, deflate, br', 'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh-HK;q=0.7,zh-MO;q=0.6,zh;q=0.5', 'Authorization': 'eyJraWQiOiJq1231235fOwKv46JpjurGKzvma17eqCoaw', 'CloudFront-Forwarded-Proto': ' 'CloudFront-Is-Desktop-Viewer': 'true', 'CloudFront-Is-Mobile-Viewer': 'false', 'CloudFront-Is-SmartTV-Viewer': 'false', 'CloudFront-Is-Tablet-Viewer': 'false', 'CloudFront-Viewer-Country': 'IE', 'Host': 'api.haohaotiantian.com', 'origin': ' 'Referer': ' 'sec-ch-ua': '" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"', 'sec-ch-ua-mobile': '?0', 'sec-fetch-dest': 'empty', 'sec-fetch-mode': 'cors', 'sec-fetch-site': 'cross-site', 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36', 'Via': '2.0 f8591238.cloudfront.net (CloudFront)', 'X-Amz-Cf-Id': 'rex4fmbUq5pvK123fj5bGvpw==', 'X-Amzn-Trace-Id': 'Root=1-60e123b7e7b70', 'X-Forwarded-For': '123', 'X-Forwarded-Port': '123', 'X-Forwarded-Proto': ' 'multiValueHeaders': {'Accept': ['application/json, text/plain, */*'], 'accept-encoding': ['gzip, deflate, br'], 'Accept-Language': ['en-US,en;q=0.9,zh-CN;q=0.8,zh-HK;q=0.7,zh-MO;q=0.6,zh;q=0.5'], 'Authorization': ['eyJraWQiOiJqVmhFdEN4Y123vZ25pdG123GKzvma17eqCoaw'], 'CloudFront-Forwarded-Proto': [' 'CloudFront-Is-Desktop-Viewer': ['true'], 'CloudFront-Is-Mobile-Viewer': ['false'], 'CloudFront-Is-SmartTV-Viewer': ['false'], 'CloudFront-Is-Tablet-Viewer': ['false'], 'CloudFront-Viewer-Country': ['IE'], 'Host': ['api.haohaotiantian.com'], 'origin': [' 'Referer': [' 'sec-ch-ua': ['" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"'], 'sec-ch-ua-mobile': ['?0'], 'sec-fetch-dest': ['empty'], 'sec-fetch-mode': ['cors'], 'sec-fetch-site': ['cross-site'], 'User-Agent': ['Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36'], 'Via': ['2.0 123.cloudfront.net (CloudFront)'], 'X-Amz-Cf-Id': ['rex4fmbU123BVnGAOV9sfj5bGvpw=='], 'X-Amzn-Trace-Id': ['Root=1-60e6d123b70'], 'X-Forwarded-For': ['123'], 'X-Forwarded-Port': ['443'], 'X-Forwarded-Proto': [' 'queryStringParameters': 'None', 'multiValueQueryStringParameters': 'None', 'pathParameters': 'None', 'stageVariables': 'None', 'requestContext': {'resourceId': '123', 'authorizer': {'claims': {'sub': '', 'aud': '123123', 'email_verified': 'true', 'event_id': 'cc6a7b68-e1bc-417b-9344-123', 'token_use': 'id', 'auth_time': '', 'iss': ' 'cognito:username': '', 'exp': 'Thu Jul 08 11:38:59 UTC 2021', 'iat': 'Thu Jul 08 10:38:59 UTC 2021', 'email': ''}}, 'resourcePath': '/user_data', ' 'GET', 'extendedRequestId': 'CJZWoF123FT_Q=', 'requestTime': '08/Jul/2021:10:38:59 +0000', 'path': '/user_data', 'accountId': '123', 'protocol': 'HTTP/1.1', 'stage': 'Prod', 'domainPrefix': 'api', 'requestTimeEpoch': 123, 'requestId': '11875c1237fec0aab', 'identity': {'cognitoIdentityPoolId': 'None', 'accountId': 'None', 'cognitoIdentityId': 'None', 'caller': 'None', 'sourceIp': '54', 'principalOrgId': 'None', 'accessKey': 'None', 'cognitoAuthenticationType': 'None', 'cognitoAuthenticationProvider': 'None', 'userArn': 'None', 'userAgent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36', 'user': 'None'}, 'domainName': 'api.haohaotiantian.com', 'apiId': '123'}, 'isBase64Encoded': False}
if (__name__ == '__main__'):
unittest.main() |
class TetrisMainWindow(QMainWindow):
def __init__(self, parent=None):
super(TetrisMainWindow, self).__init__(parent)
self.setWindowTitle(('PyQtris v%s' % pyqtris_version))
self.setWindowIcon(QIcon(get_icon_pixmap()))
self.figurebank = self.make_figure_bank()
self.create_main_frame()
self.create_menu()
self.create_status_bar()
self.timer = QTimer()
self.timer_interval = 1000
self.connect(self.timer, SIGNAL('timeout()'), self.on_timer)
self.timer.start(self.timer_interval)
self.init_highscores()
self.restart_game()
def on_restart(self):
if (self.state == GameState.gameover):
self.restart_game()
else:
saved_state = self.state
self.pause_game()
reply = QMessageBox.question(self, 'Restart confirmation', 'Are you sure you want to restart the game?', (QMessageBox.Yes | QMessageBox.No))
if (reply == QMessageBox.Yes):
self.restart_game()
else:
self.set_game_state(saved_state)
def on_pause(self):
if (self.state == GameState.paused):
self.resume_game()
elif (self.state == GameState.running):
self.pause_game()
def on_about(self):
saved_state = self.state
self.pause_game()
dialog = AboutDialog(self)
dialog.exec_()
self.set_game_state(saved_state)
def on_highscores(self):
saved_state = self.state
self.pause_game()
self.show_highscores()
self.set_game_state(saved_state)
def set_game_state(self, state):
if (state == GameState.paused):
self.pause_game()
elif (state == GameState.running):
self.resume_game()
elif (state == GameState.gameover):
self.state = GameState.gameover
self.status_text.setText('Game over!')
self.timer.stop()
else:
assert False
def pause_game(self):
self.state = GameState.paused
self.status_text.setText('Paused')
self.pause_button.setText('Resume')
self.timer.stop()
def resume_game(self):
self.state = GameState.running
self.status_text.setText('Playing')
self.pause_button.setText('Pause')
self.timer.start(self.timer_interval)
def game_over(self):
self.state = GameState.gameover
self.status_text.setText('Game over!')
self.timer.stop()
if (self.game_score > self.highscores.lowest_score()):
(text, ok) = QInputDialog.getText(self, 'High score!', 'Your name:')
if (ok and (not text.isEmpty())):
self.highscores.add_score(text, self.game_score)
self.save_highscores()
self.show_highscores()
def restart_game(self):
self.game_level = 1
self.game_lines = 0
self.game_score = 0
self.timer_interval = 1000
self.resume_game()
self.update_stats()
self.board_widget.restart(self.figurebank.get_random())
self.preview_figure = self.figurebank.get_random()
self.preview_widget.set_figure(self.preview_figure)
self.timer.start(self.timer_interval)
def on_timer(self):
if (self.state == GameState.running):
result = self.board_widget.timer_tick(self.preview_figure)
num_rows = len(result.completed_rows)
if (result.state == 'gameover'):
self.game_over()
elif (result.state == 'newfigure'):
old_line_count = self.game_lines
self.game_lines += num_rows
score_bonus = (result.drop_height + ((num_rows ** 2) * 30))
score_bonus = int((score_bonus * (1 + (0.1 * (self.game_level - 1)))))
self.game_score += score_bonus
self.preview_figure = self.figurebank.get_random()
self.preview_widget.set_figure(self.preview_figure)
if ((num_rows > 0) and (((old_line_count % 10) + num_rows) >= 10)):
self.game_level += 1
self.timer_interval = (1000 - (self.game_level * 100))
if (self.timer_interval < 100):
self.timer_interval = 100
self.timer.stop()
self.timer.start(self.timer_interval)
self.update_stats()
def update_stats(self):
self.level_text.setText(str(self.game_level))
self.lines_text.setText(str(self.game_lines))
self.score_text.setText(str(self.game_score))
def create_main_frame(self):
self.board_widget = MainTetrisWidget(self, nrows=20, ncols=10, blocksize=25, startfigure=self.figurebank.get_random())
self.board_widget.setFocus()
self.control_panel = QFrame(self)
self.control_panel.setFrameStyle((QFrame.Panel | QFrame.Sunken))
self.control_panel.setFocusPolicy(Qt.NoFocus)
self.populate_control_panel()
main_layout = QHBoxLayout()
main_layout.addWidget(self.board_widget)
main_layout.addWidget(self.control_panel)
main_layout.setSizeConstraint(QLayout.SetFixedSize)
main_frame = QWidget()
main_frame.setLayout(main_layout)
self.setCentralWidget(main_frame)
def populate_control_panel(self):
self.preview_widget = TetrisPreviewWidget(self.control_panel, nrows=7, ncols=7, blocksize=10)
preview_group = QGroupBox('Preview')
preview_box = QHBoxLayout()
preview_box.addWidget(self.preview_widget)
preview_group.setLayout(preview_box)
preview_layout = QHBoxLayout()
preview_layout.addStretch()
preview_layout.addWidget(preview_group)
preview_layout.addStretch()
text_layout = QGridLayout()
level_label = StatsLabel('Level')
self.level_text = StatsLabel('1', True)
lines_label = StatsLabel('Lines')
self.lines_text = StatsLabel('0', True)
score_label = StatsLabel('Score')
self.score_text = StatsLabel('0', True)
text_layout.addWidget(level_label, 0, 0)
text_layout.addWidget(self.level_text, 0, 1)
text_layout.addWidget(lines_label, 1, 0)
text_layout.addWidget(self.lines_text, 1, 1)
text_layout.addWidget(score_label, 2, 0)
text_layout.addWidget(self.score_text, 2, 1)
self.pause_button = SizedButton('&Pause', QSize(90, 40))
self.pause_button.setFocusPolicy(Qt.NoFocus)
self.connect(self.pause_button, SIGNAL('clicked()'), self.on_pause)
self.restart_button = SizedButton('&New game', QSize(90, 40))
self.restart_button.setFocusPolicy(Qt.NoFocus)
self.connect(self.restart_button, SIGNAL('clicked()'), self.on_restart)
button_layout = QHBoxLayout()
button_layout.addWidget(self.pause_button)
button_layout.addSpacing(40)
button_layout.addWidget(self.restart_button)
vbox = QVBoxLayout()
vbox.addSpacing(15)
vbox.addLayout(preview_layout)
vbox.addSpacing(40)
vbox.addLayout(text_layout)
vbox.addSpacing(40)
vbox.addLayout(button_layout)
vbox.addStretch()
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addLayout(vbox)
hbox.addStretch()
self.control_panel.setLayout(hbox)
def create_status_bar(self):
self.status_text = QLabel('Playing')
self.statusBar().addWidget(self.status_text, 1)
def create_menu(self):
self.game_menu = self.menuBar().addMenu('&Game')
self.help_menu = self.menuBar().addMenu('&Help')
new_game_action = self.create_action('&New', shortcut='Ctrl+N', slot=self.on_restart, tip='New game')
pause_game_action = self.create_action('&Pause', shortcut='Ctrl+P', slot=self.on_pause, tip='Pause game')
highscores_action = self.create_action('&High Scores', shortcut='Ctrl+H', slot=self.on_highscores, tip='Pause game')
quit_action = self.create_action('&Quit', shortcut='Ctrl+Q', slot=self.close, tip='Quit')
about_action = self.create_action('&About', shortcut='F1', slot=self.on_about, tip='About PyQtris')
self.add_actions(self.game_menu, (new_game_action, pause_game_action, None, highscores_action, None, quit_action))
self.add_actions(self.help_menu, (about_action,))
def add_actions(self, target, actions):
for action in actions:
if (action is None):
target.addSeparator()
else:
target.addAction(action)
def create_action(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal='triggered()'):
action = QAction(text, self)
if (icon is not None):
action.setIcon(QIcon((':/%s.png' % icon)))
if (shortcut is not None):
action.setShortcut(shortcut)
if (tip is not None):
action.setToolTip(tip)
action.setStatusTip(tip)
if (slot is not None):
self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
def make_figure_bank(self):
S = Figure([(0, 0), ((- 1), 0), (0, (- 1)), ((- 1), 1)], color=QColor(122, 197, 205))
Z = Figure([(0, 0), (0, 1), ((- 1), (- 1)), ((- 1), 0)], color=QColor(0, 205, 0))
T = Figure([(0, 0), (0, 1), (0, (- 1)), (1, 0)], color=QColor(238, 238, 0))
I = Figure([(0, 0), (0, (- 1)), (0, 1), (0, 2)], color=QColor(238, 118, 33))
O = Figure([(0, 0), ((- 1), 0), ((- 1), 1), (0, 1)], rotatable=False, color=QColor(238, 44, 44))
L = Figure([(0, 0), (0, (- 1)), (0, 1), (1, (- 1))], color=QColor(0, 0, 225))
J = Figure([(0, 0), (0, (- 1)), (0, 1), (1, 1)], color=QColor(148, 0, 211))
return FigureBank([S, Z, T, I, O, L, J])
def keyPressEvent(self, event):
if (self.state == GameState.running):
self.board_widget.keyPressEvent(event)
HS_FILENAME = 'pyqtris_highscores'
def init_highscores(self):
self.highscores = HighScores(10)
if os.path.exists(self.HS_FILENAME):
self.highscores.load_from_file(self.HS_FILENAME)
def save_highscores(self):
self.highscores.save_to_file(self.HS_FILENAME)
def show_highscores(self):
dialog = HighscoresDialog(self.highscores.get_list(), self)
dialog.exec_() |
class OptionPlotoptionsTimelineMarker(Options):
def enabled(self):
return self._config_get(None)
def enabled(self, flag: bool):
self._config(flag, js_type=False)
def enabledThreshold(self):
return self._config_get(0)
def enabledThreshold(self, num: float):
self._config(num, js_type=False)
def fillColor(self):
return self._config_get(None)
def fillColor(self, text: str):
self._config(text, js_type=False)
def height(self):
return self._config_get(15)
def height(self, num: float):
self._config(num, js_type=False)
def lineColor(self):
return self._config_get('#ffffff')
def lineColor(self, text: str):
self._config(text, js_type=False)
def lineWidth(self):
return self._config_get(2)
def lineWidth(self, num: float):
self._config(num, js_type=False)
def radius(self):
return self._config_get(6)
def radius(self, num: float):
self._config(num, js_type=False)
def states(self) -> 'OptionPlotoptionsTimelineMarkerStates':
return self._config_sub_data('states', OptionPlotoptionsTimelineMarkerStates)
def symbol(self):
return self._config_get('square')
def symbol(self, text: str):
self._config(text, js_type=False)
def width(self):
return self._config_get(None)
def width(self, num: float):
self._config(num, js_type=False) |
class BigBlueButton():
api_url: str
secret: str
def build_url(self, action: str, params: Optional[Dict[(str, str)]]=None) -> str:
url = (((self.api_url + '/') + action) + '?')
params = (params or {})
params = {key: val for (key, val) in params.items() if val}
query = urlencode(params)
url += ((query + '&checksum=') + self._checksum(action, query))
return url
def _checksum(self, action: str, query: str):
key = ((action + query) + self.secret)
return sha1(key.encode('utf-8')).hexdigest()
def request(self, action: str, params: Optional[Dict[(str, str)]]=None) -> Result:
return Result.create(requests.get(self.build_url(action, params))) |
(once={'graceful': True}, base=QueueOnce)
def weekly_reload_all_aos():
logger.info(' Weekly (%s) reload of all AOs ', datetime.date.today().strftime('%A'))
load_advisory_opinions()
logger.info(' Weekly (%s) reload of all AOs completed successfully', datetime.date.today().strftime('%A'))
slack_message = 'Weekly reload of all AOs completed successfully in {0} space'.format(get_app_name())
utils.post_to_slack(slack_message, SLACK_BOTS) |
class MyTestCase(unittest.TestCase):
('netplot.config.config.Config')
def test_tcp_incoming_arg_incoming_True(self, config):
packets = sniff(offline='./test/packets/tcp_incoming.pcap')
config.incoming = True
provider = DomainProvider(config)
provider.get_domain = MagicMock(return_value='fake.domain')
processor = HostProcessor(config, provider)
processor.process(packets[0])
provider.get_domain.assert_called_with('208.80.154.224')
self.assertEqual(['fake.domain'], processor.data)
('netplot.config.config.Config')
def test_tcp_outgoing_arg_incoming_False(self, config):
packets = sniff(offline='./test/packets/tcp_outgoing.pcap')
config.incoming = False
provider = DomainProvider(config)
provider.get_domain = MagicMock(return_value='fake.domain')
processor = HostProcessor(config, provider)
processor.process(packets[0])
provider.get_domain.assert_called_with('208.80.154.224')
self.assertEqual(['fake.domain'], processor.data) |
def extractBlackhatmagickCom(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 |
('/users', response_model=schemas.User, status_code=status.HTTP_201_CREATED, summary='Create a user')
def create_new_user(user: schemas.UserCreate, db: Session=Depends(get_db)) -> Any:
db_username = get_user_by_username(db, username=user.username)
db_email = get_user_by_email(db, email=user.email)
if db_username:
raise HTTPException(status_code=400, detail='Username already registered')
elif db_email:
raise HTTPException(status_code=400, detail='Email already registered')
return create_user(db=db, user=user) |
def assert_output_has_error(cmd, expected_error, env):
env['HOME'] = '.'
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
has_error = False
output = ''
for line in (list(p.stdout) + list(p.stderr)):
line = line.decode('utf-8').strip()
output += (line + '\n')
if ((expected_error is not None) and (expected_error in line)):
has_error = True
p.terminate()
p.wait()
if (expected_error is None):
assert (p.returncode == 0), 'Expected process to exit with code 0, but got {} with output:\n{}'.format(p.returncode, output)
else:
assert has_error, "Expected process output to contain '{}', but got {}".format(expected_error, output)
assert (p.returncode != 0), 'Expected process to exit with non-zero code, but got {}'.format(p.returncode) |
def runForDuration(cmdline, duration, loggingDir):
outLogFile = logFile(loggingDir)
teeCommand = ['tee', '-a', outLogFile]
cmdline = [str(x) for x in cmdline]
print(cmdline)
try:
p1 = subprocess.Popen(cmdline, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
_ = subprocess.Popen(teeCommand, stdin=p1.stdout)
time.sleep(duration)
p1.terminate()
except OSError as e:
log((' OS Error during command: ' + ' '.join(cmdline)), style=bc.FAIL)
log((' OS Error: ' + e.strerror), style=bc.FAIL) |
class UpdateNamespaceRequest(betterproto.Message):
name: str = betterproto.string_field(1)
update_info: v1namespace.UpdateNamespaceInfo = betterproto.message_field(2)
config: v1namespace.NamespaceConfig = betterproto.message_field(3)
replication_config: v1replication.NamespaceReplicationConfig = betterproto.message_field(4)
security_token: str = betterproto.string_field(5)
delete_bad_binary: str = betterproto.string_field(6) |
class OptionPlotOptionsBar(Options):
def horizontal(self):
return self._config_get()
def horizontal(self, flag: bool):
self._config(flag)
def barHeight(self):
return self._config_get()
def barHeight(self, value: int):
self._config(value)
def dataLabels(self) -> OptionDataLabels:
return self._config_sub_data('dataLabels', OptionDataLabels) |
()
_context
('--no-pull', is_flag=True, help='Use a local image instead of trying to pull from DockerHub.')
('--no-init', is_flag=True, help='Disable the initialization of the Fides CLI, to run in headless mode.')
('--env-file', type=click.Path(exists=True), help='Use a custom ENV file for the Fides container to override settings.')
('--image', type=str, help="Use a custom image for the Fides container instead of the default ('ethyca/fides').")
def up(ctx: click.Context, no_pull: bool=False, no_init: bool=False, env_file: Optional[click.Path]=None, image: Optional[str]=None) -> None:
check_virtualenv()
try:
check_docker_version()
except:
response = click.confirm('WARNING: Encountered an error while checking Docker versions. Would you like to attempt a deploy anyway?')
if (not response):
raise SystemExit('Deploy aborted!')
else:
echo_green('Docker version is compatible, starting deploy...')
config = ctx.obj['CONFIG']
if (not no_pull):
pull_specific_docker_image()
if env_file:
print(f'> Using custom ENV file from: {env_file}')
environ['FIDES_DEPLOY_ENV_FILE'] = str(env_file)
if image:
print(f'> Using custom image: {image}')
environ['FIDES_DEPLOY_IMAGE'] = image
try:
check_fides_uploads_dir()
print('> Starting application...')
start_application()
click.clear()
if (not no_init):
echo_green('Deployment successful! Initializing fides...')
create_and_update_config_file(config=config)
else:
echo_green("Deployment successful! Skipping CLI initialization (run 'fides init' to initialize)")
print_divider()
print_deploy_success()
except CalledProcessError:
teardown_application()
raise SystemExit(1) |
def parse_args():
parser = argparse.ArgumentParser(description='LiteScope Client utility')
parser.add_argument('-r', '--rising-edge', action='append', help='Add rising edge trigger.')
parser.add_argument('-f', '--falling-edge', action='append', help='Add falling edge trigger.')
parser.add_argument('-v', '--value-trigger', action='append', nargs=2, help='Add conditional trigger with given value.', metavar=('TRIGGER', 'VALUE'))
parser.add_argument('-l', '--list', action='store_true', help='List signal choices.')
parser.add_argument('--host', default='localhost', help='Host ip address')
parser.add_argument('--csv', default='analyzer.csv', help='Analyzer CSV file.')
parser.add_argument('--csr-csv', default='csr.csv', help='SoC CSV file.')
parser.add_argument('--group', default=0, type=int, help='Capture Group.')
parser.add_argument('--subsampling', default=1, type=int, help='Capture Subsampling.')
parser.add_argument('--offset', default='32', help='Capture Offset.')
parser.add_argument('--length', default=None, help='Capture Length.')
parser.add_argument('--dump', default='dump.vcd', help='Capture Filename.')
parser.add_argument('--gui', action='store_true', help='Run Gui.')
args = parser.parse_args()
return args |
class DUNS(models.Model):
awardee_or_recipient_uniqu = models.TextField(null=True, blank=True)
legal_business_name = models.TextField(null=True, blank=True)
dba_name = models.TextField(null=True, blank=True)
ultimate_parent_unique_ide = models.TextField(null=True, blank=True)
ultimate_parent_legal_enti = models.TextField(null=True, blank=True)
address_line_1 = models.TextField(null=True, blank=True)
address_line_2 = models.TextField(null=True, blank=True)
city = models.TextField(null=True, blank=True)
state = models.TextField(null=True, blank=True)
zip = models.TextField(null=True, blank=True)
zip4 = models.TextField(null=True, blank=True)
country_code = models.TextField(null=True, blank=True)
congressional_district = models.TextField(null=True, blank=True)
business_types_codes = ArrayField(base_field=models.TextField(), default=list, size=None, null=True)
entity_structure = models.TextField(null=True, blank=True)
broker_duns_id = models.TextField(primary_key=True)
update_date = models.DateField()
uei = models.TextField(null=True, blank=True)
ultimate_parent_uei = models.TextField(null=True, blank=True)
class Meta():
db_table = 'duns'
indexes = [Index(name='duns_awardee_b30104_partial', fields=['awardee_or_recipient_uniqu'], condition=Q(awardee_or_recipient_uniqu__isnull=False)), Index(name='duns_uei_bee37a_partial', fields=['uei'], condition=Q(uei__isnull=False))] |
class Migration(migrations.Migration):
dependencies = [('search', '0033_add_total_outlays_column')]
operations = [migrations.AddField(model_name='subawardsearch', name='legal_entity_congressional_current', field=models.TextField(blank=True, null=True)), migrations.AddField(model_name='subawardsearch', name='place_of_performance_congressional_current', field=models.TextField(blank=True, null=True)), migrations.AddField(model_name='subawardsearch', name='sub_legal_entity_congressional_current', field=models.TextField(blank=True, null=True)), migrations.AddField(model_name='subawardsearch', name='sub_place_of_performance_congressional_current', field=models.TextField(blank=True, null=True))] |
def run_async_local_bwd(folder_name: str, path_dir: str, callback_url: str, verbose: bool, num_workers: int, task_name_suffix: str, res: tuple, batch_data_vjp: Tuple[(JaxSimulationData, ...)]) -> Tuple[Dict[(str, JaxSimulation)]]:
(batch_data_fwd,) = res
task_name_suffix_adj = _task_name_adj('')
grad_data_fwd = {}
grad_eps_data_fwd = {}
for (i, sim_data_fwd) in enumerate(batch_data_fwd):
grad_data_fwd[i] = sim_data_fwd.grad_data_symmetry
grad_eps_data_fwd[i] = sim_data_fwd.grad_eps_data_symmetry
sims_adj = []
for (i, sim_data_fwd) in enumerate(batch_data_fwd):
fwidth_adj = sim_data_fwd.simulation._fwidth_adjoint
run_time_adj = sim_data_fwd.simulation._run_time_adjoint
sim_data_vjp = batch_data_vjp[i]
sim_adj = sim_data_vjp.make_adjoint_simulation(fwidth=fwidth_adj, run_time=run_time_adj)
sims_adj.append(sim_adj)
batch_data_adj = run_async_local(simulations=sims_adj, folder_name=folder_name, path_dir=path_dir, callback_url=callback_url, verbose=verbose, num_workers=num_workers, task_name_suffix=task_name_suffix_adj)
sims_vjp = []
for (i, (sim_data_fwd, sim_data_adj)) in enumerate(zip(batch_data_fwd, batch_data_adj)):
sim_data_adj = sim_data_adj.normalize_adjoint_fields()
grad_data_fwd = sim_data_fwd.grad_data_symmetry
grad_data_adj = sim_data_adj.grad_data_symmetry
grad_data_eps_fwd = sim_data_fwd.grad_eps_data_symmetry
sim_data_vjp = batch_data_vjp[i]
sim_vjp = sim_data_vjp.simulation.store_vjp(grad_data_fwd, grad_data_adj, grad_data_eps_fwd)
sims_vjp.append(sim_vjp)
return (sims_vjp,) |
class GzipTest(AmbassadorTest):
target: ServiceType
def init(self):
self.target = HTTP()
def config(self) -> Generator[(Union[(str, Tuple[(Node, str)])], None, None)]:
(yield (self, self.format('\n---\napiVersion: getambassador.io/v3alpha1\nkind: Module\nname: ambassador\nconfig:\n gzip:\n min_content_length: 32\n window_bits: 15\n content_type:\n - text/plain\n')))
(yield (self, self.format('\n---\napiVersion: getambassador.io/v3alpha1\nkind: Mapping\nname: {self.target.path.k8s}\nhostname: "*"\nprefix: /target/\nservice: {self.target.path.fqdn}\n')))
def queries(self):
(yield Query(self.url('target/'), headers={'Accept-Encoding': 'gzip'}, expected=200))
def check(self):
assert (self.results[0].headers['Content-Encoding'] == ['gzip']) |
def write_navbar(htmlhandle, brandname, nav_list, activelink=None):
htmlhandle.write('\n <nav class="navbar navbar-inverse navbar-fixed-top">\n <div class="container-fluid">\n <div class="navbar-header">\n <a class="navbar-brand">{}</a>\n </div>\n <ul class="nav navbar-nav navbar-right">\n '.format(brandname))
for nav_dict in nav_list:
activeclass = (' class="active"' if (nav_dict['href'] == activelink) else '')
htmlhandle.write('<li{}><a href="{}">{}</a></li>\n'.format(activeclass, nav_dict['href'], nav_dict['label']))
htmlhandle.write(' </ul>\n </div>\n</nav>\n') |
class OptionSeriesTreemapSonificationDefaultspeechoptionsPointgrouping(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 ClassificationDetail(Base):
__tablename__ = 'cls_classification_detail'
instance_id = Column(String(255))
status = Column(Text)
dataset = Column(Text)
collection = Column(Text)
field = Column(Text)
labels = Column(JSON)
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now()) |
def extractDevildante777SBlog(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
if ('WATTT' in item['tags']):
return buildReleaseMessageWithType(item, 'WATTT', vol, chp, frag=frag, postfix=postfix)
return False |
(TCP_OPTION_KIND_USER_TIMEOUT, 4)
class TCPOptionUserTimeout(TCPOption):
_PACK_STR = '!BBH'
def __init__(self, granularity, user_timeout, kind=None, length=None):
super(TCPOptionUserTimeout, self).__init__(kind, length)
self.granularity = granularity
self.user_timeout = user_timeout
def parse(cls, buf):
(_, _, body) = struct.unpack_from(cls._PACK_STR, buf)
granularity = (body >> 15)
user_timeout = (body & 32767)
return (cls(granularity, user_timeout, cls.cls_kind, cls.cls_length), buf[cls.cls_length:])
def serialize(self):
body = ((self.granularity << 15) | self.user_timeout)
return struct.pack(self._PACK_STR, self.kind, self.length, body) |
def migrate_property(name, property, property_info, class_dict):
get = _property_method(class_dict, ('_get_' + name))
set = _property_method(class_dict, ('_set_' + name))
val = _property_method(class_dict, ('_validate_' + name))
if ((get is not None) or (set is not None) or (val is not None)):
(old_get, old_set, old_val) = property_info
return Property((get or old_get), (set or old_set), (val or old_val), True, **property.__dict__)
return property |
class Encoder(nn.Module):
def __init__(self, d_input=320, n_layers=6, n_head=8, d_k=64, d_v=64, d_model=512, d_inner=2048, dropout=0.1, pe_maxlen=5000):
super(Encoder, self).__init__()
self.d_input = d_input
self.n_layers = n_layers
self.n_head = n_head
self.d_k = d_k
self.d_v = d_v
self.d_model = d_model
self.d_inner = d_inner
self.dropout_rate = dropout
self.pe_maxlen = pe_maxlen
self.linear_in = nn.Linear(d_input, d_model)
self.layer_norm_in = nn.LayerNorm(d_model)
self.positional_encoding = PositionalEncoding(d_model, max_len=pe_maxlen)
self.dropout = nn.Dropout(dropout)
self.layer_stack = nn.ModuleList([EncoderLayer(d_model, d_inner, n_head, d_k, d_v, dropout=dropout) for _ in range(n_layers)])
def forward(self, padded_input, input_lengths, return_attns=False):
enc_slf_attn_list = []
non_pad_mask = get_non_pad_mask(padded_input, input_lengths=input_lengths)
length = padded_input.size(1)
slf_attn_mask = get_attn_pad_mask(padded_input, input_lengths, length)
enc_output = self.dropout((self.layer_norm_in(self.linear_in(padded_input)) + self.positional_encoding(padded_input)))
for enc_layer in self.layer_stack:
(enc_output, enc_slf_attn) = enc_layer(enc_output, non_pad_mask=non_pad_mask, slf_attn_mask=slf_attn_mask)
if return_attns:
enc_slf_attn_list += [enc_slf_attn]
if return_attns:
return (enc_output, enc_slf_attn_list)
return (enc_output,) |
class Polyline():
def __init__(self, positions, color, alpha, edge_width, visible):
self.positions = positions
self.color = color
self.alpha = alpha
self.edge_width = edge_width
self.visible = visible
def get_properties(self, binary_filename):
json_dict = {'type': 'polyline', 'positions': self.positions.tolist(), 'color': self.color.tolist(), 'alpha': float(self.alpha), 'edge_width': float(self.edge_width), 'visible': self.visible}
return json_dict
def write_binary(self, path):
return |
class PyTest(TestCommand):
user_options = [('pytest-args=', 'a', 'Arguments to pass to py.test')]
def initialize_options(self) -> None:
TestCommand.initialize_options(self)
self.pytest_args = []
def finalize_options(self) -> None:
TestCommand.finalize_options(self)
self.test_args = []
self.test_suite = True
def run_tests(self) -> None:
import pytest
errno = pytest.main(self.pytest_args)
sys.exit(errno) |
class PresidentialBySize(db.Model):
__table_args__ = {'schema': 'public'}
__tablename__ = 'ofec_presidential_by_size_vw'
idx = db.Column(db.Integer, primary_key=True)
candidate_id = db.Column(db.String(0), doc=docs.CANDIDATE_ID_PRESIDENTIAL)
contribution_receipt_amount = db.Column(db.Numeric(30, 2), doc=docs.CONTRIBUTION_RECEIPTS)
election_year = db.Column(db.Integer, doc=docs.ELECTION_YEAR)
size_range_id = db.Column(db.Integer, doc=docs.SIZE_RANGE_ID)
size = db.Column(db.Integer, doc=docs.SIZE) |
def _serialize_and_read_object(pb_obj):
with tempfile.NamedTemporaryFile(mode='w', delete=True) as tmp:
_write_object_to_disk(pb_obj, tmp.name)
with open(tmp.name, 'r') as json_file:
json_object = json.loads(json_file.read())
assert (json_object is not None)
assert (json_object != {}) |
class TestPathAccessors(unittest.TestCase):
def test_001_simple_put(self):
out = {}
path_put(out, 'foo', 'bar')
self.assertEqual(out, {'foo': 'bar'})
self.assertEqual(path_get(out, 'foo'), 'bar')
def test_002_nested_put(self):
out = {}
path_put(out, 'foo.bar', 'baz')
self.assertEqual(out, {'foo': {'bar': 'baz'}})
self.assertEqual(path_get(out, 'foo.bar'), 'baz')
def test_003_bracket_name_put(self):
out = {}
path_put(out, 'foo.{bar.baz}', 'moo')
self.assertEqual(out, {'foo': {'bar.baz': 'moo'}})
self.assertEqual(path_get(out, 'foo.{bar.baz}'), 'moo')
def test_004_bracket_name_then_more_depth(self):
out = {}
path_put(out, 'foo.{bar.baz}.gar', 'moo')
self.assertEqual(out, {'foo': {'bar.baz': {'gar': 'moo'}}})
self.assertEqual(path_get(out, 'foo.{bar.baz}.gar'), 'moo')
def test_005_simple_array_put(self):
out = {}
path_put(out, 'foo.bar.0', 'thing')
self.assertEqual(out, {'foo': {'bar': ['thing']}})
self.assertEqual(path_get(out, 'foo.bar.0'), 'thing')
def test_005_02_bracket_name_then_list(self):
out = {}
path_put(out, 'foo.bar.{thing.in.bracket}.0', 'la la la')
self.assertEqual(out, {'foo': {'bar': {'thing.in.bracket': ['la la la']}}})
self.assertEqual(path_get(out, 'foo.bar.{thing.in.bracket}.0'), 'la la la')
def test_006_array_with_nested_dict(self):
out = {}
path_put(out, 'foo.bar.0.baz', 'thing')
self.assertEqual(out, {'foo': {'bar': [{'baz': 'thing'}]}})
self.assertEqual(path_get(out, 'foo.bar.0.baz'), 'thing')
def test_007_array_with_nested_array(self):
out = {}
path_put(out, 'foo.bar.0.0.baz', 'thing')
self.assertEqual(out, {'foo': {'bar': [[{'baz': 'thing'}]]}})
self.assertEqual(path_get(out, 'foo.bar.0.0.baz'), 'thing')
def test_008_array_with_missing_index(self):
out = {}
path_put(out, 'foo.bar.2.baz', 'thing')
self.assertEqual(out, {'foo': {'bar': [{}, {}, {'baz': 'thing'}]}})
self.assertEqual(path_get(out, 'foo.bar.2.baz'), 'thing')
def test_009_numeric_dictionary_keys(self):
out = {}
path_put(out, 'foo.bar.{2}.baz', 'thing')
self.assertEqual(out, {'foo': {'bar': {'2': {'baz': 'thing'}}}})
self.assertEqual(path_get(out, 'foo.bar.{2}.baz'), 'thing')
def test_010_path_get_missing_key(self):
with self.assertRaises(KeyError):
path_get({}, 'foo')
def test_011_path_get_missing_nested_key(self):
with self.assertRaises(KeyError):
path_get({'foo': {'bar': 'baz'}}, 'foo.blah')
def test_012_path_get_missing_array(self):
with self.assertRaises(KeyError):
path_get({'foo': {'bar': 'baz'}}, 'foo.0')
def test_013_path_get_missing_array_further_index(self):
with self.assertRaises(IndexError):
path_get({'foo': [{}, {}]}, 'foo.2')
def test_014_path_get_missing_nested_array(self):
with self.assertRaises(IndexError):
path_get({'foo': [[]]}, 'foo.0.0')
def test_015_path_get_missing_nested_array_further_index(self):
with self.assertRaises(IndexError):
path_get({'foo': [[{}, {}]]}, 'foo.0.4')
def test_016_escaped_array_index_key(self):
out = {}
path_put(out, '{record_transaction.0}.inputs.foo', 'bar')
self.assertEqual(out, {'record_transaction.0': {'inputs': {'foo': 'bar'}}})
self.assertEqual(path_get(out, '{record_transaction.0}.inputs.foo'), 'bar')
def test_017_escaped_array_of_dict(self):
out = {}
path_put(out, 'transaction.metadata.references.0.reference_type', 'FOO')
path_put(out, 'transaction.metadata.references.0.reference_ids.0', '1234')
self.assertEqual(out, {'transaction': {'metadata': {'references': [{'reference_type': 'FOO', 'reference_ids': ['1234']}]}}})
self.assertEqual(path_get(out, 'transaction.metadata.references.0.reference_type'), 'FOO')
self.assertEqual(path_get(out, 'transaction.metadata.references.0.reference_ids.0'), '1234')
def test_018_complex_path_list(self):
path_list = ['foo.bar', 'foo.{bar.baz}', 'foo.{yea_bar.baz}.gar', 'foo.aba_bar.0', 'foo.sba_bar.0.baz', 'foo.nu_bar.0.0.baz', 'foo.ba_bar.0.baz', 'foo.ba_bar.1.baz', 'foo.ba_bar.2.baz', 'foo.re_bar.{2}.baz', '{record_transaction.0}.inputs.foo', 'transaction.metadata.references.0.reference_type', 'transaction.metadata.references.0.reference_ids.0']
out = {}
for path in path_list:
path_put(out, path, 'blah_blah')
self.assertEqual(sorted(path_list), sorted(get_all_paths(out)))
def test_019_nested_brackets(self):
out = {}
path_put(out, 'charge.cost_components.{{item.gross}}', {'MISSING'})
self.assertEqual(out, {'charge': {'cost_components': {'{item.gross}': {'MISSING'}}}})
self.assertEqual(path_get(out, 'charge.cost_components.{{item.gross}}'), {'MISSING'})
def test_020_path_listing_for_complex_dict(self):
data = {'foo': {'aba_bar': ['test'], 'ba_bar': [{}, {'baz': 'test'}, {}], 'bar': 'test', 'bar.baz': 'test', 'nu_bar': [[{'baz': 'test'}]], 're_bar': {'2': {'baz': 'test'}}, 'sba_bar': [{'baz': 'test'}, [], {}], 'yea_bar.baz': {'gar': 'test'}}, 'record_transaction.0': {'inputs': {'bar': [], 'foo': 'test', 're_bar': {}}}, 'transaction': {'metadata': {'references': [{'reference_ids': ['blah_blah'], 'reference_type': 'blah_blah'}, {}]}}}
actual = get_all_paths(data, allow_blank=True)
expected = ['foo.aba_bar.0', 'foo.ba_bar.0', 'foo.ba_bar.1.baz', 'foo.ba_bar.2', 'foo.bar', 'foo.nu_bar.0.0.baz', 'foo.re_bar.{2}.baz', 'foo.sba_bar.0.baz', 'foo.sba_bar.1', 'foo.sba_bar.2', 'foo.{bar.baz}', 'foo.{yea_bar.baz}.gar', 'transaction.metadata.references.0.reference_ids.0', 'transaction.metadata.references.0.reference_type', 'transaction.metadata.references.1', '{record_transaction.0}.inputs.bar', '{record_transaction.0}.inputs.foo', '{record_transaction.0}.inputs.re_bar']
self.assertEqual(sorted(actual), sorted(expected))
def test_021_path_listing_for_empty_structures(self):
self.assertEqual(get_all_paths({}), [])
self.assertEqual(get_all_paths([]), []) |
def normalize_url(url):
if (not re.match('^[a-z]+://', url, re.I)):
url = (' % url)
purl = urlsplit(url)
if (not purl.path):
return ('%s/' % purl.geturl())
new_path = re.sub('/+', '/', purl.path)
new_path = posixpath.normpath(new_path)
if (purl.path.endswith('/') and (not new_path.endswith('/'))):
new_path += '/'
purl = purl._replace(path=new_path)
return purl.geturl() |
class UpdateBackupForm(BackupForm):
disk_id = forms.TypedChoiceField(label=_('Disk ID'), required=True, coerce=int, widget=forms.Select(attrs={'class': 'input-select2 narrow', 'disabled': 'disabled'}))
name = forms.CharField(label=_('Backup Name'), required=True, max_length=24, widget=forms.TextInput(attrs={'class': 'input-transparent narrow uneditable-input', 'disabled': 'disabled'}))
def __init__(self, *args, **kwargs):
super(UpdateBackupForm, self).__init__(*args, **kwargs)
if self._vm:
self.fields['disk_id'].choices = vm_disk_id_choices(self._vm)
else:
self.fields['disk_id'].choices = [(i, (_('Disk') + (' %d' % i))) for i in range(1, (DISK_ID_MAX_BHYVE + 1))]
def _get_real_disk_id(self):
return Backup.get_disk_id(self._vm, self.cleaned_data['disk_id'])
def get_backup(self):
try:
return Backup.objects.get(vm=self._vm, name=self.cleaned_data['name'], disk_id=self._get_real_disk_id())
except Backup.DoesNotExist:
return None
def save(self, bkp):
if (bkp.note == self.cleaned_data['note']):
return False
bkp.note = self.cleaned_data['note']
bkp.save(update_fields=('note', 'changed'))
return True |
class memoize(object):
def __init__(self, ttl):
self.cache = {}
self.ttl = ttl
def __call__(self, f):
(f)
def wrapped_f(*args):
now = time.time()
try:
(value, last_update) = self.cache[args]
if ((self.ttl > 0) and ((now - last_update) > self.ttl)):
raise AttributeError
return value
except (KeyError, AttributeError):
value = f(*args)
self.cache[args] = (value, now)
return value
except TypeError:
return f(*args)
return wrapped_f |
def push_script(data_hex: str) -> str:
data = bfh(data_hex)
data_len = len(data)
if ((data_len == 0) or ((data_len == 1) and (data[0] == 0))):
return bh2u(bytes([Ops.OP_0]))
elif ((data_len == 1) and (data[0] <= 16)):
return bh2u(bytes([((Ops.OP_1 - 1) + data[0])]))
elif ((data_len == 1) and (data[0] == 129)):
return bh2u(bytes([Ops.OP_1NEGATE]))
return (op_push(data_len) + bh2u(data)) |
class AbstractForum(MPTTModel, DatedModel):
parent = TreeForeignKey('self', null=True, blank=True, related_name='children', on_delete=models.CASCADE, verbose_name=_('Parent'))
name = models.CharField(max_length=100, verbose_name=_('Name'))
slug = models.SlugField(max_length=255, verbose_name=_('Slug'))
description = MarkupTextField(verbose_name=_('Description'), null=True, blank=True)
image = ExtendedImageField(null=True, blank=True, upload_to=get_forum_image_upload_to, verbose_name=_('Forum image'), **machina_settings.DEFAULT_FORUM_IMAGE_SETTINGS)
link = models.URLField(verbose_name=_('Forum link'), null=True, blank=True)
link_redirects = models.BooleanField(default=False, verbose_name=_('Track link redirects count'), help_text=_('Records the number of times a forum link was clicked'))
(FORUM_POST, FORUM_CAT, FORUM_LINK) = (0, 1, 2)
TYPE_CHOICES = ((FORUM_POST, _('Default forum')), (FORUM_CAT, _('Category forum')), (FORUM_LINK, _('Link forum')))
type = models.PositiveSmallIntegerField(choices=TYPE_CHOICES, verbose_name=_('Forum type'), db_index=True)
direct_posts_count = models.PositiveIntegerField(editable=False, blank=True, default=0, verbose_name=_('Direct number of posts'))
direct_topics_count = models.PositiveIntegerField(editable=False, blank=True, default=0, verbose_name=_('Direct number of topics'))
link_redirects_count = models.PositiveIntegerField(editable=False, blank=True, default=0, verbose_name=_('Track link redirects count'))
last_post = models.ForeignKey('forum_conversation.Post', editable=False, related_name='+', blank=True, null=True, on_delete=models.SET_NULL, verbose_name=_('Last post'))
last_post_on = models.DateTimeField(verbose_name=_('Last post added on'), blank=True, null=True)
display_sub_forum_list = models.BooleanField(default=True, verbose_name=_('Display in parent-forums legend'), help_text=_('Displays this forum on the legend of its parent-forum (sub forums list)'))
class Meta():
abstract = True
app_label = 'forum'
ordering = ['tree_id', 'lft']
verbose_name = _('Forum')
verbose_name_plural = _('Forums')
def __str__(self):
return self.name
def margin_level(self):
return (self.level * 2)
def is_category(self):
return (self.type == self.FORUM_CAT)
def is_forum(self):
return (self.type == self.FORUM_POST)
def is_link(self):
return (self.type == self.FORUM_LINK)
def clean(self):
super().clean()
if (self.parent and self.parent.is_link):
raise ValidationError(_('A forum can not have a link forum as parent'))
if (self.is_category and self.parent and self.parent.is_category):
raise ValidationError(_('A category can not have another category as parent'))
if (self.is_link and (not self.link)):
raise ValidationError(_('A link forum must have a link associated with it'))
def get_image_upload_to(self, filename):
(dummy, ext) = os.path.splitext(filename)
return os.path.join(machina_settings.FORUM_IMAGE_UPLOAD_TO, '{id}{ext}'.format(id=str(uuid.uuid4()).replace('-', ''), ext=ext))
def save(self, *args, **kwargs):
old_instance = None
if self.pk:
old_instance = self.__class__._default_manager.get(pk=self.pk)
self.slug = slugify(force_str(self.name), allow_unicode=True)
super().save(*args, **kwargs)
if (old_instance and (old_instance.parent != self.parent)):
self.update_trackers()
signals.forum_moved.send(sender=self, previous_parent=old_instance.parent)
def update_trackers(self):
direct_approved_topics = self.topics.filter(approved=True).order_by('-last_post_on')
self.direct_topics_count = direct_approved_topics.count()
self.direct_posts_count = (direct_approved_topics.aggregate(total_posts_count=Sum('posts_count'))['total_posts_count'] or 0)
if direct_approved_topics.exists():
self.last_post_id = direct_approved_topics[0].last_post_id
self.last_post_on = direct_approved_topics[0].last_post_on
else:
self.last_post_id = None
self.last_post_on = None
self._simple_save()
def _simple_save(self, *args, **kwargs):
super().save(*args, **kwargs) |
def test_remove_component_success():
dep_manager = _DependenciesManager()
protocol = ProtocolConfig('a_protocol', 'author', '0.1.0', protocol_specification_id='some/author:0.1.0')
skill = SkillConfig('skill', 'author', '0.1.0', protocols=[protocol.public_id])
dep_manager.add_component(protocol)
dep_manager.add_component(skill)
dep_manager.remove_component(skill.component_id) |
class VampireKissHandler(THBEventHandler):
interested = ['action_apply', 'calcdistance']
def handle(self, evt_type, act):
if ((evt_type == 'action_apply') and isinstance(act, Damage)):
(src, tgt) = (act.source, act.target)
if (not (src and src.has_skill(VampireKiss))):
return act
if (src.life >= src.maxlife):
return act
g = self.game
pact = g.action_stack[(- 1)]
if (not isinstance(pact, Attack)):
return act
card = pact.associated_card
if ((not card) or (card.color != Card.RED)):
return act
g.process_action(VampireKissAction(src, tgt))
elif (evt_type == 'calcdistance'):
(src, card, dist) = act
if (not card.is_card(AttackCard)):
return act
if (not src.has_skill(VampireKiss)):
return act
if (card.color != Card.RED):
return act
for p in dist:
dist[p] -= 99999
return act |
class TextualInversionConfig(BaseModel):
placeholder_token: str = '*'
initializer_token: (str | None) = None
style_mode: bool = False
def apply_textual_inversion_to_target(self, text_encoder: CLIPTextEncoder) -> None:
adapter = ConceptExtender(target=text_encoder)
tokenizer = text_encoder.ensure_find(CLIPTokenizer)
token_encoder = text_encoder.ensure_find(TokenEncoder)
if (self.initializer_token is not None):
bpe = tokenizer.byte_pair_encoding(token=self.initializer_token)
assert (' ' not in bpe), 'This initializer_token is not a single token.'
token = Tensor([tokenizer.token_to_id_mapping[bpe]]).int().to(text_encoder.device)
init_embedding = token_encoder(token).squeeze(0)
else:
token_encoder = text_encoder.ensure_find(TokenEncoder)
init_embedding = randn(token_encoder.embedding_dim)
adapter.add_concept(self.placeholder_token, init_embedding)
adapter.inject() |
class Thumbnailer():
_MAX_WORKERS = 2
def __init__(self):
self._pending = {}
self._executor = ThreadPoolExecutor(max_workers=self._MAX_WORKERS)
def generate(self, uuid, iter_, image_path, callback):
if (uuid in self._pending):
return
def _thumbnail_callback(future):
if (uuid not in self._pending):
return
try:
pixbuf = future.result()
except OSError as error:
print(("E: An error occurred when generating thumbnail for '%s': %s" % (image_path, str(error))))
pixbuf = THUMBNAIL_BROKEN
except CancelledError:
return
self._pending[uuid]['callback'](iter_, pixbuf)
del self._pending[uuid]
cached_thumbnail_path = get_cached_thumbnail_path(image_path)
if cached_thumbnail_path:
future = self._executor.submit(preview_gdk_pixbuf_from_thumbnail, cached_thumbnail_path)
else:
future = self._executor.submit(preview_gdk_pixbuf_from_image, image_path)
future.add_done_callback(_thumbnail_callback)
self._pending[uuid] = {'future': future, 'iter': iter_, 'callback': callback}
def cancel(self, uuid):
if (uuid not in self._pending):
return
self._pending[uuid]['future'].cancel()
del self._pending[uuid]
def cancel_all(self):
if ((sys.version_info.major >= 3) and (sys.version_info.minor < 9)):
for future in [p['future'] for p in self._pending.values()]:
future.cancel()
self._executor.shutdown(wait=False)
else:
self._executor.shutdown(wait=False, cancel_futures=True)
self._pending = {}
self._executor = ThreadPoolExecutor(max_workers=self._MAX_WORKERS) |
class ImgCarousel(Html.Html):
name = 'Carousel'
_option_cls = OptImg.OptionsImage
def __init__(self, page, images, path, selected, width, height, options, profile):
(self.items, self.__click_items) = ([], [])
super(ImgCarousel, self).__init__(page, '', css_attrs={'width': width, 'height': height}, profile=profile)
self.attr['data-current_picture'] = 0
for (i, rec) in enumerate(images):
if (not hasattr(rec, 'options')):
if (not isinstance(rec, dict)):
rec = {'image': rec, 'title': ('picture %s' % (i + 1))}
if ('path' not in rec):
rec['path'] = path
if (rec.get('selected') is not None):
selected = i
img = page.ui.img(rec['image'], path=rec['path'], width=width, height=(((height[0] - 60) if (height[0] is not None) else None), height[1]))
img_title = page.ui.tags.h3(rec['title'])
div = page.ui.layouts.div([img_title, img], html_code=('%s_img_%s' % (self.htmlCode, i))).css({'display': 'none', 'text-align': 'center'})
div.title = img_title
div.img = img
else:
div = page.ui.layouts.div(rec, html_code=('%s_img_%s' % (self.htmlCode, i))).css({'display': 'none', 'text-align': 'center'})
div.set_attrs(name='name', value=('%s_img' % self.htmlCode))
div.options.managed = False
self.items.append(div)
self.__point_display = options.get('points', True)
self.infinity = options.get('infinity', False)
self.container = self.page.ui.layouts.div().css({'display': 'block', 'width': '100%', 'text-align': 'center'})
self.container.options.managed = False
if ('arrows' in options):
self.next = self.page.ui.icon(options.get('arrows-right', 'fas fa-chevron-right')).css({'position': 'absolute', 'font-size': '35px', 'padding': '8px', 'right': '10px', 'top': '50%'})
self.next.options.managed = False
self.previous = self.page.ui.icon(options.get('arrows-left', 'fas fa-chevron-left')).css({'position': 'absolute', 'font-size': '35px', 'padding': '8px', 'left': '10px', 'top': '50%'})
self.previous.options.managed = False
if options.get('keyboard', False):
self.page.body.keyup.left([self.previous.dom.events.trigger('click')])
self.page.body.keyup.right([self.next.dom.events.trigger('click')])
else:
(self.next, self.previous) = ('', '')
if (not options.get('arrows', True)):
self.next.style.css.display = 'none'
self.previous.style.css.display = 'none'
if self.items:
self.items[selected].css({'display': 'block'})
self.set_nav_dots()
self.css({'padding-top': '20px', 'padding': '2px', 'margin': 0, 'position': 'relative'})
def __getitem__(self, i) -> Html.Html:
return self.items[i]
def add_plot(self, plot, title: str='', width: types.SIZE_TYPE='auto'):
img = self.page.ui.img(width=width)
img.from_plot(plot)
title = self.page.ui.tags.h3(title)
div = self.page.ui.layouts.div([title, img], html_code=('%s_img_%s' % (self.htmlCode, len(self.items)))).css({'display': 'none', 'text-align': 'center'})
div.title = title
div.img = img
div.set_attrs(name='name', value=('%s_img' % self.htmlCode))
div.options.managed = False
self.items.append(div)
return self
def set_nav_dots(self, selected: int=0):
self.items[selected].css({'display': 'block'})
self.points = self.page.ui.navigation.points(len(self.items), html_code=('%s_points' % self.htmlCode), options={'managed': False})
return self
def from_base64_list(self, values: List[str], width: Union[(str, tuple)]='auto'):
for val in values:
img = self.page.ui.img(width=width)
img.from_base64(val)
div = self.page.ui.layouts.div([img], html_code=('%s_img_%s' % (self.htmlCode, len(self.items)))).css({'display': 'none', 'text-align': 'center'})
div.img = img
div.set_attrs(name='name', value=('%s_img' % self.htmlCode))
div.options.managed = False
self.items.append(div)
return self
def click(self, js_funcs: types.JS_FUNCS_TYPES, profile: types.PROFILE_TYPE=None, source_event: str=None, on_ready: bool=False):
if (not isinstance(js_funcs, list)):
js_funcs = [js_funcs]
self.__click_items.extend(js_funcs)
return self
def __str__(self):
self.container._vals = self.items
self.attr['data-last_picture'] = (len(self.items) - 1)
self.points.style.css.cursor = 'pointer'
if (not self.__point_display):
self.points.style.css.display = 'none'
self.points.click(([self.page.js.getElementsByName(('%s_img' % self.htmlCode)).css({'display': 'none'}), self.page.js.getElementById(("%s_img_' + data.position +'" % self.htmlCode)).css({'display': 'block'})] + self.__click_items))
if hasattr(self.next, 'html'):
self.next.click([data.primitives.float(self.dom.attr('data-current_picture').toString().parseFloat().add(1), 'picture_index'), self.js.if_((self.page.js.object('picture_index') <= self.dom.attr('data-last_picture')), [self.dom.attr('data-current_picture', self.page.js.object('picture_index')), ("(function(){var clickEvent = new Event('click'); %s.dispatchEvent(clickEvent)})()" % self.page.js.getElementsByName(('%s_points' % self.htmlCode))[self.dom.getAttribute('data-current_picture').toString().parseFloat()])]).else_(([self.dom.attr('data-current_picture', (- 1)), self.next.dom.events.trigger('click')] if self.infinity else None))])
if hasattr(self.previous, 'html'):
self.previous.click([data.primitives.float(self.dom.attr('data-current_picture').toString().parseFloat().add((- 1)), 'picture_index'), self.js.if_((self.page.js.object('picture_index') >= 0), [self.dom.attr('data-current_picture', self.page.js.object('picture_index')), ("(function(){var clickEvent = new Event('click'); %s.dispatchEvent(clickEvent) })()" % self.page.js.getElementsByName(('%s_points' % self.htmlCode))[self.dom.getAttribute('data-current_picture').toString().parseFloat()])]).else_(([self.dom.attr('data-current_picture', len(self.items)), self.previous.dom.events.trigger('click')] if self.infinity else None))])
return ('<div %(strAttr)s>%(img_cont)s%(points)s%(next)s%(previous)s</div>\n ' % {'strAttr': self.get_attrs(css_class_names=self.style.get_classes()), 'img_cont': self.container.html(), 'points': self.points.html(), 'next': (self.next.html() if hasattr(self.next, 'html') else ''), 'previous': (self.previous.html() if hasattr(self.previous, 'html') else '')}) |
def test_literal_types():
obj = _types.LiteralType(simple=_types.SimpleType.INTEGER)
assert (obj.simple == _types.SimpleType.INTEGER)
assert (obj.schema is None)
assert (obj.collection_type is None)
assert (obj.map_value_type is None)
assert (obj == _types.LiteralType.from_flyte_idl(obj.to_flyte_idl()))
schema_type = _types.SchemaType([_types.SchemaType.SchemaColumn('a', _types.SchemaType.SchemaColumn.SchemaColumnType.INTEGER), _types.SchemaType.SchemaColumn('b', _types.SchemaType.SchemaColumn.SchemaColumnType.FLOAT), _types.SchemaType.SchemaColumn('c', _types.SchemaType.SchemaColumn.SchemaColumnType.STRING), _types.SchemaType.SchemaColumn('d', _types.SchemaType.SchemaColumn.SchemaColumnType.DATETIME), _types.SchemaType.SchemaColumn('e', _types.SchemaType.SchemaColumn.SchemaColumnType.DURATION), _types.SchemaType.SchemaColumn('f', _types.SchemaType.SchemaColumn.SchemaColumnType.BOOLEAN)])
obj = _types.LiteralType(schema=schema_type)
assert (obj.simple is None)
assert (obj.schema == schema_type)
assert (obj.collection_type is None)
assert (obj.map_value_type is None)
assert (obj == _types.LiteralType.from_flyte_idl(obj.to_flyte_idl())) |
class Ship():
def __init__(self, ss_game):
self.screen = ss_game.screen
self.settings = ss_game.settings
self.screen_rect = ss_game.screen.get_rect()
self.image = pygame.image.load('images/rocket_small.png')
self.rect = self.image.get_rect()
self.center_ship()
self.moving_up = False
self.moving_down = False
def update(self):
if (self.moving_up and (self.rect.top > 0)):
self.y -= self.settings.ship_speed
if (self.moving_down and (self.rect.bottom < self.screen_rect.bottom)):
self.y += self.settings.ship_speed
self.rect.y = self.y
def center_ship(self):
self.rect.midleft = self.screen_rect.midleft
self.y = float(self.rect.y)
def blitme(self):
self.screen.blit(self.image, self.rect) |
_to_return_value(b'|'.join)
_tuple
def bytes_repr(value):
if is_bytes(value):
(yield value)
elif is_text(value):
(yield to_bytes(text=value))
elif is_list_like(value):
(yield b''.join((b'(', b','.join((bytes_repr(item) for item in value)), b')')))
elif is_dict(value):
(yield b''.join((b'{', b','.join((b':'.join((bytes_repr(key), bytes_repr(item))) for (key, item) in value.items())), b'}')))
elif is_integer(value):
(yield to_bytes(value))
elif is_null(value):
(yield '{}'.format(id(value)))
else:
raise TypeError('Unsupported type for bytes_repr: {}'.format(type(value))) |
class RuleAppliesTo(object):
SELF = 'self'
CHILDREN = 'children'
SELF_AND_CHILDREN = 'self_and_children'
apply_types = frozenset([SELF, CHILDREN, SELF_AND_CHILDREN])
def verify(cls, applies_to):
if (applies_to not in cls.apply_types):
raise audit_errors.InvalidRulesSchemaError('Invalid applies_to: {}'.format(applies_to))
return applies_to |
def unpack_function(file_path, tmp_dir):
decrypted_file = Path(tmp_dir, 'decrypted_image')
extraction_command = f'python3 {TOOL_PATH} -i {file_path} -o {decrypted_file}'
process = run(split(extraction_command), stdout=PIPE, stderr=STDOUT, text=True, check=False)
return {'output': process.stdout} |
def extractMesmerizingmemoirsCom(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 |
def filter_ips_sensor_data(json):
option_list = ['block_malicious_url', 'comment', 'entries', 'extended_log', 'filter', 'name', 'override', 'replacemsg_group', 'scan_botnet_connections']
json = remove_invalid_fields(json)
dictionary = {}
for attribute in option_list:
if ((attribute in json) and (json[attribute] is not None)):
dictionary[attribute] = json[attribute]
return dictionary |
class TestEngine():
def __init__(self, args):
self.args = args
self.ds = JsonDataset(args)
self.all_results = self.emptyResults(self.ds.num_classes, args.total_num)
self.all_boxes = self.all_results['all_boxes']
self.all_segms = self.all_results['all_segms']
self.index = 0
def emptyResults(self, num_classes, num_images):
ret = {'all_boxes': [[[] for _ in range(num_images)] for _ in range(num_classes)]}
ret['all_segms'] = [[[] for _ in range(num_images)] for _ in range(num_classes)]
return ret
def extendResults(self, index, all_res, im_res):
for j in range(1, len(im_res)):
all_res[j][index] = im_res[j]
def extendResultsWithClasses(self, index, all_boxes, box_ids):
(boxes, classids) = box_ids
for (j, classid) in enumerate(classids):
classid = int(classid)
assert (classid <= len(all_boxes)), '{} classid out of range!class id: {}, boxes: {}'.format(j, classid, boxes)
if (type(all_boxes[classid][index]) is np.ndarray):
all_boxes[classid][index] = np.vstack((all_boxes[classid][index], boxes[j]))
else:
all_boxes[classid][index] = np.array([boxes[j]])
def extendSegResultsWithClasses(self, index, all_segms, segs_ids):
(im_masks_rle, classids) = segs_ids
for (j, classid) in enumerate(classids):
classid = int(classid)
assert (classid <= len(all_segms)), '{} classid out of range!class id: {}, segms: {}'.format(j, classid, im_masks_rle)
all_segms[classid][index].append(im_masks_rle[j])
def evaluateResults(self):
for i in range(self.args.limit_files):
filename = os.path.join(self.args.input_dir, (((self.args.result_prefix + '_') + str(i)) + '.pkl'))
with open(filename, 'r') as f:
results = pickle.load(f)
for ret in results:
self.extendResultsWithClasses(self.index, self.all_boxes, (ret['boxes'], ret['classids']))
self.extendSegResultsWithClasses(self.index, self.all_segms, (ret['im_masks'], ret['classids']))
self.index = (self.index + 1)
def aggregateResults(self):
if (not os.path.exists(self.args.output_dir)):
os.makedirs(self.args.output_dir)
logger.info('Evaluating detections')
evaluateBoxes(self.ds, self.all_boxes, self.args.output_dir, use_salt=False)
logger.info('Evaluating segmentations')
evaluateMasks(self.ds, self.all_boxes, self.all_segms, self.args.output_dir, use_salt=False)
def run(self):
self.evaluateResults()
self.aggregateResults() |
class TestMockConstructorIntegration(TestDSLBase):
def test_mock_constructor_integration(self):
def fail_top(context):
_context
def fail_sub_context(context):
def expect_fail(self):
self.mock_constructor('subprocess', 'Popen').for_call(['cmd']).to_return_value('mocked_popen').and_assert_called_once()
def pass_top(context):
_context
def pass_sub_context(context):
def expect_pass(self):
self.mock_constructor('subprocess', 'Popen').for_call(['cmd']).to_return_value('mocked_popen').and_assert_called_once()
assert (subprocess.Popen(['cmd']) == 'mocked_popen')
examples = _get_name_to_examples()
self.run_example(examples['expect pass'])
with self.assertRaisesRegex(AssertionError, 'calls did not match assertion'):
self.run_example(examples['expect fail']) |
class View(MView):
def create_control(self, parent):
from pyface.qt import QtGui
control = QtGui.QWidget(parent)
palette = control.palette()
palette.setColor(QtGui.QPalette.ColorRole.Window, QtGui.QColor('red'))
control.setPalette(palette)
control.setAutoFillBackground(True)
return control
def destroy_control(self):
if (self.control is not None):
self.control.hide()
self.control.deleteLater()
self.control = None
def set_focus(self):
if (self.control is not None):
self.control.setFocus()
return |
class ModeManager():
def __init__(self, mode_classes):
self.mode_classes = mode_classes
self.baseline_events = []
self.modes = None
self.last_mode = None
self.mode_stroked_from = None
self.mode = None
_showbase
def init_modes(self):
self.modes = {name: mode() for (name, mode) in self.mode_classes.items()}
def update_event_baseline(self):
self.baseline_events = Global.base.messenger.get_events()
def change_mode(self, mode, exit_kwargs={}, enter_kwargs={}):
assert (mode in Mode)
self.end_mode(**exit_kwargs)
self.start_mode(mode, **enter_kwargs)
def end_mode(self, **kwargs):
self.last_mode = self.mode
self.remove_mode_events()
if (self.mode is not None):
self.modes[self.mode].exit(**kwargs)
self.modes[self.mode].reset_action_states()
self.mode = None
def start_mode(self, mode, **kwargs):
self.mode = mode
self.modes[mode].enter(**kwargs)
def get_keymap(self):
assert self.mode
return self.modes[self.mode].keymap
def remove_mode_events(self):
for event in Global.base.messenger.get_events():
if (event in self.baseline_events):
continue
Global.base.ignore(event) |
('method', ['resize', 'sample'])
def test_resize_and_sample(method):
with Image(filename='wizard:') as img:
with img.clone() as a:
assert (a.size == (480, 640))
getattr(a, method)(100, 100)
assert (a.size == (100, 100))
with img.clone() as b:
assert (b.size == (480, 640))
getattr(b, method)(height=100)
assert (b.size == (480, 100))
with img.clone() as c:
assert (c.size == (480, 640))
getattr(c, method)(width=100)
assert (c.size == (100, 640)) |
class ModelField():
def __init__(self, primary_key: bool=False, index: bool=False, unique: bool=False, **kwargs: typing.Any) -> None:
if primary_key:
kwargs['read_only'] = True
self.allow_null = kwargs.get('allow_null', False)
self.primary_key = primary_key
self.index = index
self.unique = unique
self.validator = self.get_validator(**kwargs)
def get_column(self, name: str) -> sqlalchemy.Column:
column_type = self.get_column_type()
constraints = self.get_constraints()
return sqlalchemy.Column(name, column_type, *constraints, primary_key=self.primary_key, nullable=(self.allow_null and (not self.primary_key)), index=self.index, unique=self.unique)
def get_validator(self, **kwargs) -> typesystem.Field:
raise NotImplementedError()
def get_column_type(self) -> sqlalchemy.types.TypeEngine:
raise NotImplementedError()
def get_constraints(self):
return []
def expand_relationship(self, value):
return value |
class SimpleChatIO(ChatIO):
def prompt_for_input(self, role: str) -> str:
return input(f'{role}: ')
def prompt_for_output(self, role: str) -> str:
print(f'{role}: ', end='', flush=True)
def stream_output(self, output_stream, skip_echo_len: int):
pre = 0
for outputs in output_stream:
outputs = outputs[skip_echo_len:].strip()
now = (len(outputs) - 1)
if (now > pre):
print(' '.join(outputs[pre:now]), end=' ', flush=True)
pre = now
print(' '.join(outputs[pre:]), flush=True)
return ' '.join(outputs) |
def get_z3vars(f):
r = set()
def collect(f):
if z3.is_const(f):
if ((f.decl().kind() == z3.Z3_OP_UNINTERPRETED) and (not (askey(f) in r))):
r.add(askey(f))
else:
for c in f.children():
collect(c)
collect(f)
return r |
def medals(save_stats: dict[(str, Any)]) -> dict[(str, Any)]:
medal_stats = save_stats['medals']
remove = (user_input_handler.colored_input('Do you want to add or remove medals? (&a&/&r&):') == 'r')
names = get_medal_names(helper.check_data_is_jp(save_stats))
if (names is None):
return save_stats
helper.colored_list(names)
ids = user_input_handler.get_range(user_input_handler.colored_input('Enter medal ids (You can enter all to get &all&, a range e.g &1&-&50&, or ids separate by spaces e.g &5 4 7&):'), (len(names) + 1))
if remove:
medal_stats = remove_medals(medal_stats, ids)
else:
medal_stats = set_medals(medal_stats, ids)
save_stats['medals'] = medal_stats
print(f"Successfully {('gave' if (not remove) else 'removed')} medals")
return save_stats |
class Tag(SimpleEntity):
__auto_name__ = False
__tablename__ = 'Tags'
__mapper_args__ = {'polymorphic_identity': 'Tag'}
tag_id = Column('id', Integer, ForeignKey('SimpleEntities.id'), primary_key=True)
def __init__(self, **kwargs):
super(Tag, self).__init__(**kwargs)
def __eq__(self, other):
return (super(Tag, self).__eq__(other) and isinstance(other, Tag))
def __hash__(self):
return super(Tag, self).__hash__() |
class BaseMessage(object):
__slots__ = ['_body', '_channel', '_method', '_properties']
def __init__(self, channel, **message):
self._channel = channel
self._body = message.get('body', None)
self._method = message.get('method', None)
self._properties = message.get('properties', {'headers': {}})
def __iter__(self):
for attribute in ['_body', '_channel', '_method', '_properties']:
(yield (attribute[1:], getattr(self, attribute)))
def to_dict(self):
return {'body': self._body, 'method': self._method, 'properties': self._properties, 'channel': self._channel}
def to_tuple(self):
return (self._body, self._channel, self._method, self._properties) |
def extractMyWayHoneyBlogspotCom(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 |
.parametrize('local_head,remote_forkid,expected_error', [(7987396, ForkID(hash=to_bytes(hexstr='0x668db0af'), next=0), None), (7987396, ForkID(hash=to_bytes(hexstr='0x668db0af'), next=sys.maxsize), None), (7279999, ForkID(hash=to_bytes(hexstr='0xa00bc324'), next=0), None), (7279999, ForkID(hash=to_bytes(hexstr='0xa00bc324'), next=7280000), None), (7279999, ForkID(hash=to_bytes(hexstr='0xa00bc324'), next=sys.maxsize), None), (7987396, ForkID(hash=to_bytes(hexstr='0xa00bc324'), next=7280000), None), (7987396, ForkID(hash=to_bytes(hexstr='0x3edd5b10'), next=4370000), None), (7279999, ForkID(hash=to_bytes(hexstr='0x668db0af'), next=0), None), (4369999, ForkID(hash=to_bytes(hexstr='0xa00bc324'), next=0), None), (7987396, ForkID(hash=to_bytes(hexstr='0xa00bc324'), next=0), RemoteChainIsStale), (7987396, ForkID(hash=to_bytes(hexstr='0x5cddc0e1'), next=0), LocalChainIncompatibleOrStale), (7279999, ForkID(hash=to_bytes(hexstr='0x5cddc0e1'), next=0), LocalChainIncompatibleOrStale), (7987396, ForkID(hash=to_bytes(hexstr='0xafec6b27'), next=0), LocalChainIncompatibleOrStale), (, ForkID(hash=to_bytes(hexstr='0xeb440f6'), next=), LocalChainIncompatibleOrStale), (7279999, ForkID(hash=to_bytes(hexstr='0xa00bc324'), next=7279999), LocalChainIncompatibleOrStale)])
def test_forkid_validation(local_head, remote_forkid, expected_error):
fork_blocks = extract_fork_blocks(MAINNET_VM_CONFIGURATION)
if expected_error:
with pytest.raises(expected_error):
validate_forkid(remote_forkid, MAINNET_GENESIS_HASH, local_head, fork_blocks)
else:
validate_forkid(remote_forkid, MAINNET_GENESIS_HASH, local_head, fork_blocks) |
def get_icon_for_mime(mime_type: (str | None)) -> str:
if (mime_type is None):
return MIME_TO_ICON_PATH['unknown']
if (mime_type.replace('/', '-') in MIME_TO_ICON_PATH):
return MIME_TO_ICON_PATH[mime_type.replace('/', '-')]
if (mime_type in ARCHIVE_FILE_TYPES):
return MIME_TO_ICON_PATH['package-x-generic']
for (mime_category, icon_path) in TYPE_CATEGORY_TO_ICON.items():
if mime_type.startswith(mime_category):
return icon_path
return MIME_TO_ICON_PATH['unknown'] |
def test_integration_parse_arg_outformat_text(caplog):
args = [path.relpath(__file__), '--debug', '--outformat', 'text']
cis_audit.parse_arguments(argv=args)
status = False
for record in caplog.records:
if (record.msg == 'Going to use "text" outputter'):
status = True
break
assert status |
('/nu_api/', methods=['GET', 'POST'])
_required
def nu_api():
if (not request.json):
js = {'error': True, 'message': 'This endpoint only accepts JSON POST requests.'}
resp = jsonify(js)
resp.status_code = 200
resp.mimetype = 'application/json'
return resp
print('API Request!')
print('session:', g.session)
print('Request method: ', request.method)
print('Request json: ', request.json)
if (('op' in request.json) and ('data' in request.json) and (request.json['op'] in ops)):
data = ops[request.json['op']](g.session, request.json['data'])
else:
data = {'wat': 'wat'}
response = jsonify(data)
print('ResponseData: ', data)
print('Response: ', response)
response.status_code = 200
response.mimetype = 'application/json'
g.session.commit()
g.session.expire_all()
return response |
class TensorAccessorTestCase(unittest.TestCase):
def test_dim_mapping_for_stride(self):
tc = TensorAccessor(Tensor(shape=[2, 2, 4]))
self.assertListEqual(tc._dim_mapping, [([0], [0]), ([1], [1]), ([2], [2])])
tc.update_base_tensor(Tensor(shape=[2, 2, 4]), stride_dim=2, stride_dim_offset=10)
self.assertListEqual(tc._dim_mapping, [([0], [0]), ([1], [1]), ([2], [2])])
def _test_dim_mapping_helper(self, original_shape, new_shape, expected_dim_mapping, test_reverse=False):
tc = TensorAccessor(Tensor(shape=original_shape))
tc.update_base_tensor_shape(Tensor(shape=new_shape))
self.assertEqual(tc._dim_mapping, expected_dim_mapping)
if test_reverse:
tc = TensorAccessor(Tensor(shape=new_shape))
tc.update_base_tensor_shape(Tensor(shape=original_shape))
expected_dim_mapping = ([(mapping[1], mapping[0]) for mapping in expected_dim_mapping] if (expected_dim_mapping is not None) else None)
self.assertEqual(tc._dim_mapping, expected_dim_mapping)
def test_dim_mapping_for_reshape_basic(self):
self._test_dim_mapping_helper(original_shape=[2, 2, 4], new_shape=[2, 2, 4], expected_dim_mapping=[([0], [0]), ([1], [1]), ([2], [2])], test_reverse=True)
self._test_dim_mapping_helper(original_shape=[2, 2, 4], new_shape=[2, 8], expected_dim_mapping=[([0], [0]), ([1, 2], [1])], test_reverse=True)
self._test_dim_mapping_helper(original_shape=[2, 2, 4], new_shape=[4, 4], expected_dim_mapping=[([0, 1], [0]), ([2], [1])], test_reverse=True)
self._test_dim_mapping_helper(original_shape=[2, 2, 4], new_shape=[16], expected_dim_mapping=[([0, 1, 2], [0])], test_reverse=True)
self._test_dim_mapping_helper(original_shape=[2, 2, 4], new_shape=[8, 2], expected_dim_mapping=[([0, 1, 2], [0, 1])], test_reverse=True)
def test_dim_mapping_for_reshape_ones(self):
self._test_dim_mapping_helper(original_shape=[1, 1, 1, 1], new_shape=[1, 1, 1], expected_dim_mapping=[([0], []), ([1], []), ([2], []), ([3], []), ([], [0]), ([], [1]), ([], [2])], test_reverse=False)
self._test_dim_mapping_helper(original_shape=[1, 3, 1, 1, 5, 1], new_shape=[1, 3, 5, 1, 1], expected_dim_mapping=[([0], []), ([], [0]), ([1], [1]), ([2], []), ([3], []), ([4], [2]), ([5], []), ([], [3]), ([], [4])], test_reverse=False)
def test_dim_mapping_for_reshape_dynamic(self):
batch_dim = IntVar([1, 2], name='batch_size')
self._test_dim_mapping_helper(original_shape=[batch_dim, 2, 4], new_shape=[batch_dim, 2, 4], expected_dim_mapping=[([0], [0]), ([1], [1]), ([2], [2])], test_reverse=True)
self._test_dim_mapping_helper(original_shape=[batch_dim, 2, 4], new_shape=[batch_dim, 8], expected_dim_mapping=[([0], [0]), ([1, 2], [1])], test_reverse=True)
self._test_dim_mapping_helper(original_shape=[batch_dim, 2, 4], new_shape=[4, batch_dim], expected_dim_mapping=None, test_reverse=True)
self._test_dim_mapping_helper(original_shape=[batch_dim, 2, 4], new_shape=[1, 1, batch_dim, 8], expected_dim_mapping=[([], [0]), ([], [1]), ([0], [2]), ([1, 2], [3])], test_reverse=True)
self._test_dim_mapping_helper(original_shape=[1, 1, 1, batch_dim, 1, 1], new_shape=[batch_dim], expected_dim_mapping=[([0], []), ([1], []), ([2], []), ([3], [0]), ([4], []), ([5], [])], test_reverse=True)
def _test_get_stride_str_helper(self, original_shape, view_shape: Optional[str], stride_shape: str, stride_dim, dim, dim_names: Optional[List[str]], expected_stride_strs):
tc = TensorAccessor(Tensor(shape=original_shape))
if (view_shape is not None):
tc.update_base_tensor_shape(Tensor(shape=view_shape))
tc.update_base_tensor(Tensor(shape=stride_shape), stride_dim, stride_dim_offset=0)
self.assertEqual(tc.try_get_stride_strs(dim, dim_names), expected_stride_strs)
def test_stride_strs_basic(self):
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=None, stride_shape=[2, 8, 2], stride_dim=1, dim=2, dim_names=None, expected_stride_strs=[])
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=None, stride_shape=[2, 8, 2], stride_dim=1, dim=1, dim_names=None, expected_stride_strs=['2'])
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=None, stride_shape=[2, 8, 2], stride_dim=1, dim=0, dim_names=None, expected_stride_strs=['8', '2'])
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=[2, 4, 2], stride_shape=[2, 8, 2], stride_dim=1, dim=0, dim_names=None, expected_stride_strs=['8', '2'])
def test_stride_strs_static_mapping(self):
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=[2, 8], stride_shape=[2, 16], stride_dim=1, dim=0, dim_names=None, expected_stride_strs=['16'])
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=[2, 8], stride_shape=[2, 16], stride_dim=1, dim=1, dim_names=None, expected_stride_strs=None)
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=[2, 8], stride_shape=[2, 16], stride_dim=1, dim=2, dim_names=None, expected_stride_strs=[])
self._test_get_stride_str_helper(original_shape=[2, 2, 4], view_shape=[2, 2, 2, 2], stride_shape=[2, 2, 2, 4], stride_dim=3, dim=1, dim_names=None, expected_stride_strs=None)
self._test_get_stride_str_helper(original_shape=[2, 2, 4], view_shape=[2, 2, 2, 2], stride_shape=[2, 2, 4, 2], stride_dim=2, dim=1, dim_names=None, expected_stride_strs=['4', '2'])
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=[2, 8, 1, 1], stride_shape=[2, 8, 1, 2], stride_dim=3, dim=2, dim_names=None, expected_stride_strs=['2'])
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=[2, 8, 1, 1], stride_shape=[2, 8, 1, 2], stride_dim=3, dim=1, dim_names=['a', 'b', 'c'], expected_stride_strs=['2', '2'])
self._test_get_stride_str_helper(original_shape=[2, 4, 2], view_shape=[2, 8, 1, 1], stride_shape=[2, 8, 1, 2], stride_dim=3, dim=0, dim_names=None, expected_stride_strs=['4', '2', '2'])
def test_stride_strs_dynamic_mapping(self):
batch_dim = IntVar([1, 2], name='batch_size')
emb_dim = IntVar([1, 2], name='emb_dim')
self._test_get_stride_str_helper(original_shape=[batch_dim, emb_dim, 2], view_shape=None, stride_shape=[batch_dim, emb_dim, 4], stride_dim=2, dim=0, dim_names=['a', 'b', 'c'], expected_stride_strs=['b', '4'])
self._test_get_stride_str_helper(original_shape=[batch_dim, emb_dim, 2], view_shape=[batch_dim, emb_dim, 2], stride_shape=[batch_dim, emb_dim, 4], stride_dim=2, dim=0, dim_names=['a', 'b', 'c'], expected_stride_strs=['b', '4'])
self._test_get_stride_str_helper(original_shape=[batch_dim, 4, 2], view_shape=[batch_dim, 8], stride_shape=[batch_dim, 16], stride_dim=1, dim=0, dim_names=['a', 'b', 'c'], expected_stride_strs=['16'])
self._test_get_stride_str_helper(original_shape=[batch_dim, 4, 2], view_shape=[batch_dim, 8], stride_shape=[batch_dim, 16], stride_dim=1, dim=1, dim_names=None, expected_stride_strs=None)
self._test_get_stride_str_helper(original_shape=[batch_dim, 4, 2], view_shape=[batch_dim, 8], stride_shape=[batch_dim, 16], stride_dim=1, dim=2, dim_names=None, expected_stride_strs=[])
self._test_get_stride_str_helper(original_shape=[batch_dim, 4, 2], view_shape=[batch_dim, 8, 1, 1], stride_shape=[batch_dim, 8, 1, 2], stride_dim=3, dim=2, dim_names=None, expected_stride_strs=['2'])
self._test_get_stride_str_helper(original_shape=[batch_dim, 8], view_shape=[batch_dim, 4, 2], stride_shape=[batch_dim, 4, 4], stride_dim=2, dim=0, dim_names=['a', 'b'], expected_stride_strs=None)
self._test_get_stride_str_helper(original_shape=[batch_dim, 8], view_shape=[batch_dim, 4, 2], stride_shape=[batch_dim, 4, 4], stride_dim=2, dim=1, dim_names=['a', 'b'], expected_stride_strs=[]) |
.parametrize('media_type', media_types, ids=str)
def test_verify_media_msg(chat, master_channel, media_type):
with NamedTemporaryFile() as f:
msg = Message(deliver_to=master_channel, author=chat.other, chat=chat, type=media_type, file=f, filename='test.bin', path=f.name, mime='application/octet-stream')
msg.verify() |
class LidHoleEdge(FingerHoleEdge):
char = 'L'
description = 'Edge for slide on lid (box back)'
def __call__(self, length, bedBolts=None, bedBoltSettings=None, **kw) -> None:
hole_width = self.settings.hole_width
if (hole_width > 0):
super().__call__(((length - hole_width) / 2))
self.edge(hole_width)
super().__call__(((length - hole_width) / 2))
else:
super().__call__(length) |
def test_get_vfps_in_parent(common_db, backend_db):
(fo, fw) = create_fw_with_child_fo()
fo_2 = create_test_file_object(uid='fo_2')
add_included_file(fo_2, fw, fw, ['/foo', '/bar'])
backend_db.insert_multiple_objects(fw, fo, fo_2)
result = common_db.get_vfps_in_parent(fw.uid)
assert (fo.uid in result)
assert (fo_2.uid in result)
assert (result[fo.uid] == fo.virtual_file_path[fw.uid])
assert (set(result[fo_2.uid]) == set(fo_2.virtual_file_path[fw.uid])) |
class RecursivelyCensoredDictWrapper(object):
SENSITIVE_FIELDS = frozenset({'password', 'pass', 'passwd', 'passphrase', 'pass_phrase', 'pass-phrase', 'passPhrase', 'passwords', 'passwds', 'passphrases', 'pass_phrases', 'pass-phrases', 'passPhrases', 'private', 'private_key', 'private-key', 'privateKey', 'privates', 'private_keys', 'private-keys', 'privateKeys', 'secret', 'secret_key', 'secret-key', 'secretKey', 'secrets', 'secret_keys', 'secret-keys', 'secretKeys', 'security_code', 'security-code', 'securityCode', 'security_codes', 'security-codes', 'securityCodes', 'auth', 'token', 'auth_token', 'auth-token', 'authToken', 'authorization', 'authorization_token', 'authorization-token', 'authorizationToken', 'authentication', 'authentication_token', 'authentication-token', 'authenticationToken', 'credit_card', 'credit-card', 'creditCard', 'credit_card_number', 'credit-card-number', 'creditCardNumber', 'card_number', 'card-number', 'cardNumber', 'cc_number', 'cc-number', 'ccNumber', 'ccn', 'credit_cards', 'credit-cards', 'creditCards', 'credit_card_numbers', 'credit-card-numbers', 'creditCardNumbers', 'card_numbers', 'card-numbers', 'cardNumbers', 'cc_numbers', 'cc-numbers', 'ccNumbers', 'ccns', 'cid', 'csc', 'csn', 'cvc', 'cvc2', 'cvd', 'cve', 'cvn2', 'cvv', 'cvv2', 'icvv', 'cids', 'cscs', 'csns', 'cvcs', 'cvc2s', 'cvds', 'cves', 'cvn2s', 'cvvs', 'cvv2s', 'icvvs', 'card_id', 'card-id', 'cardId', 'card_identification', 'card-identification', 'cardIdentification', 'card_ids', 'card-ids', 'cardIds', 'card_identifications', 'card-identifications', 'cardIdentifications', 'card_identification_code', 'card-identification-code', 'cardIdentificationCode', 'card_identification_codes', 'card-identification-codes', 'cardIdentificationCodes', 'card_identification_number', 'card-identification-number', 'cardIdentificationNumber', 'card_identification_numbers', 'card-identification-numbers', 'cardIdentificationNumbers', 'card_identification_value', 'card-identification-value', 'cardIdentificationValue', 'card_identification_values', 'card-identification-values', 'cardIdentificationValues', 'card_security', 'card-security', 'cardSecurity', 'card_securities', 'card-securities', 'cardSecurities', 'card_security_code', 'card-security-code', 'cardSecurityCode', 'card_security_codes', 'card-security-codes', 'cardSecurityCodes', 'card_security_number', 'card-security-number', 'cardSecurityNumber', 'card_security_numbers', 'card-security-numbers', 'cardSecurityNumbers', 'card_security_value', 'card-security-value', 'cardSecurityValue', 'card_security_values', 'card-security-values', 'cardSecurityValues', 'card_validation', 'card-validation', 'cardValidation', 'card_validations', 'card-validations', 'cardValidations', 'card_validation_code', 'card-validation-code', 'cardValidationCode', 'card_validation_codes', 'card-validation-codes', 'cardValidationCodes', 'card_validation_number', 'card-validation-number', 'cardValidationNumber', 'card_validation_numbers', 'card-validation-numbers', 'cardValidationNumbers', 'card_validation_value', 'card-validation-value', 'cardValidationValue', 'card_validation_values', 'card-validation-values', 'cardValidationValues', 'card_verification', 'card-verification', 'cardVerification', 'card_verifications', 'card-verifications', 'cardVerifications', 'card_verification_code', 'card-verification-code', 'cardVerificationCode', 'card_verification_codes', 'card-verification-codes', 'cardVerificationCodes', 'card_verification_number', 'card-verification-number', 'cardVerificationNumber', 'card_verification_numbers', 'card-verification-numbers', 'cardVerificationNumbers', 'card_verification_value', 'card-verification-value', 'cardVerificationValue', 'card_verification_values', 'card-verification-values', 'cardVerificationValues', 'account_number', 'account-number', 'accountNumber', 'account_numbers', 'account-numbers', 'accountNumbers', 'bank_account', 'bank-account', 'bankAccount', 'bank_accounts', 'bank-accounts', 'bankAccounts', 'bank_account_number', 'bank-account-number', 'bankAccountNumber', 'bank_account_numbers', 'bank-account-numbers', 'bankAccountNumbers', 'pin', 'pin_code', 'pin-code', 'pinCode', 'pin_number', 'pin-number', 'pinNumber', 'pins', 'pin_codes', 'pin-codes', 'pinCodes', 'pin_numbers', 'pin-numbers', 'pinNumbers', 'personal_id_number', 'personal-id-number', 'personalIdNumber', 'personal_id_numbers', 'personal-id-numbers', 'personalIdNumbers', 'personal_identification_number', 'personal-identification-number', 'personalIdentificationNumber', 'personal_identification_numbers', 'personal-identification-numbers', 'personalIdentificationNumbers'})
CENSOR_TYPES = (cast(Tuple[(Type, ...)], six.string_types) + cast(Tuple[(Type, ...)], six.integer_types))
CENSORED_STRING = ''
def __init__(self, wrapped_dict):
if (not isinstance(wrapped_dict, dict)):
raise ValueError('wrapped_dict must be a dict')
self._wrapped_dict = wrapped_dict
self._dict_cache = None
self._repr_cache = None
def _get_repr_cache(self):
if (not self._dict_cache):
self._dict_cache = self._copy_and_censor_dict(self._wrapped_dict)
return repr(self._dict_cache)
def __repr__(self):
if (not self._repr_cache):
self._repr_cache = self._get_repr_cache()
return self._repr_cache
def __str__(self):
return self.__repr__()
def __bytes__(self):
return cast(six.text_type, self.__str__()).encode('utf-8')
def __unicode__(self):
return cast(six.binary_type, self.__str__()).decode('utf-8')
def _copy_and_censor_unknown_value(cls, v, should_censor_values):
if isinstance(v, dict):
return cls._copy_and_censor_dict(v)
if isinstance(v, (list, tuple, set, frozenset)):
return cls._copy_and_censor_iterable(v, should_censor_values)
if (should_censor_values and v and isinstance(v, cls.CENSOR_TYPES) and (not isinstance(v, bool))):
return cls.CENSORED_STRING
return v
def _copy_and_censor_dict(cls, d):
return {k: cls._copy_and_censor_unknown_value(v, (k in cls.SENSITIVE_FIELDS)) for (k, v) in six.iteritems(d)}
def _copy_and_censor_iterable(cls, i, should_censor_values):
return type(i)((cls._copy_and_censor_unknown_value(v, should_censor_values) for v in i)) |
class RecipientOverView(APIView):
endpoint_doc = 'usaspending_api/api_contracts/contracts/v2/recipient/recipient_id.md'
_response()
def get(self, request, recipient_id):
get_request = request.query_params
year = validate_year(get_request.get('year', 'latest'))
(recipient_hash, recipient_level) = validate_recipient_id(recipient_id)
(recipient_duns, recipient_uei, recipient_name) = extract_duns_uei_name_from_hash(recipient_hash)
if (not (recipient_name or recipient_duns or recipient_uei)):
raise InvalidParameterException("Recipient Hash not found: '{}'.".format(recipient_hash))
alternate_names = RecipientLookup.objects.filter(recipient_hash=recipient_hash).values('alternate_names').first()
alternate_names = sorted(alternate_names.get('alternate_names', []))
parents = []
if (recipient_level == 'C'):
parents = extract_parents_from_hash(recipient_hash)
elif (recipient_level == 'P'):
parents = [{'parent_id': recipient_id, 'parent_duns': recipient_duns, 'parent_uei': recipient_uei, 'parent_name': recipient_name}]
location = extract_location(recipient_hash)
business_types = extract_business_categories(recipient_name, recipient_uei, recipient_hash)
results = obtain_recipient_totals(recipient_id, year=year)
recipient_totals = (results[0] if results else {})
(parent_id, parent_name, parent_duns, parent_uei) = (None, None, None, None)
if parents:
parent_id = parents[0].get('parent_id')
parent_name = parents[0].get('parent_name')
parent_duns = parents[0].get('parent_duns')
parent_uei = parents[0].get('parent_uei')
result = {'name': recipient_name, 'alternate_names': alternate_names, 'duns': recipient_duns, 'uei': recipient_uei, 'recipient_id': recipient_id, 'recipient_level': recipient_level, 'parent_id': parent_id, 'parent_name': parent_name, 'parent_duns': parent_duns, 'parent_uei': parent_uei, 'parents': parents, 'business_types': business_types, 'location': location, 'total_transaction_amount': recipient_totals.get('total_obligation_amount', 0), 'total_transactions': recipient_totals.get('total_obligation_count', 0), 'total_face_value_loan_amount': recipient_totals.get('total_face_value_loan_amount', 0), 'total_face_value_loan_transactions': recipient_totals.get('total_face_value_loan_count', 0)}
return Response(result) |
def test_revert_removes_journal_entries(journal_db):
checkpoint_a = journal_db.record()
assert journal_db.has_checkpoint(checkpoint_a)
checkpoint_b = journal_db.record()
assert journal_db.has_checkpoint(checkpoint_a)
assert journal_db.has_checkpoint(checkpoint_b)
journal_db.discard(checkpoint_b)
assert journal_db.has_checkpoint(checkpoint_a)
assert (not journal_db.has_checkpoint(checkpoint_b))
checkpoint_b2 = journal_db.record()
assert journal_db.has_checkpoint(checkpoint_a)
assert journal_db.has_checkpoint(checkpoint_b2)
checkpoint_c = journal_db.record()
assert journal_db.has_checkpoint(checkpoint_a)
assert journal_db.has_checkpoint(checkpoint_b2)
assert journal_db.has_checkpoint(checkpoint_c)
checkpoint_d = journal_db.record()
assert journal_db.has_checkpoint(checkpoint_a)
assert journal_db.has_checkpoint(checkpoint_b2)
assert journal_db.has_checkpoint(checkpoint_c)
assert journal_db.has_checkpoint(checkpoint_d)
journal_db.discard(checkpoint_b2)
assert journal_db.has_checkpoint(checkpoint_a)
assert (not journal_db.has_checkpoint(checkpoint_b2))
assert (not journal_db.has_checkpoint(checkpoint_c))
assert (not journal_db.has_checkpoint(checkpoint_d)) |
class DeliveryCheckExtraInfo(AbstractObject):
def __init__(self, api=None):
super(DeliveryCheckExtraInfo, self).__init__()
self._isDeliveryCheckExtraInfo = True
self._api = api
class Field(AbstractObject.Field):
adgroup_ids = 'adgroup_ids'
campaign_ids = 'campaign_ids'
countries = 'countries'
_field_types = {'adgroup_ids': 'list<string>', 'campaign_ids': 'list<string>', 'countries': 'list<string>'}
def _get_field_enum_info(cls):
field_enum_info = {}
return field_enum_info |
def convert_image(value, level=3):
if (not isinstance(value, str)):
return value
key = value
is_pyface_image = value.startswith('')
if (not is_pyface_image):
search_path = get_resource_path(level)
key = ('%s[%s]' % (value, search_path))
result = image_resource_cache.get(key)
if (result is None):
if is_pyface_image:
try:
from .image.image import ImageLibrary
result = ImageLibrary.image_resource(value)
except Exception as exc:
logger.error(("Can't load image resource '%s'." % value))
logger.exception(exc)
result = None
else:
from pyface.image_resource import ImageResource
result = ImageResource(value, search_path=[search_path])
image_resource_cache[key] = result
return result |
class TestUtil(unittest.TestCase):
def test_compare_coords(self):
self.assertTrue(util.cmp_coords([1, 2, 3], [1, 2, 3]))
self.assertTrue(util.cmp_coords([1, NaN, 3], [1, NaN, 3]))
self.assertFalse(util.cmp_coords([1, 3, 2], [1, 2, 3]))
self.assertFalse(util.cmp_coords([1, 2, NaN], [1, NaN, 3]))
self.assertFalse(util.cmp_coords([1, 2, 3, 4], [1, 2, 3])) |
def extractTofutranslations1090WordpressCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
if (item['tags'] == ['Uncategorized']):
titlemap = [('Ah, Senior Brother is Actually a Sister!', 'Ah, Senior Brother is Actually a Sister!', 'translated'), ('Tensei Shoujo no Rirekisho', 'Tensei Shoujo no Rirekisho', 'translated'), ('Master of Dungeon', 'Master of Dungeon', 'oel')]
for (titlecomponent, name, tl_type) in titlemap:
if (titlecomponent.lower() in item['title'].lower()):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
tagmap = [('asbas', 'Ah, Senior Brother is Actually a Sister!', 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
def simulate_request_post_query_params(client, path, query_string, **kwargs):
if client.app._ASGI:
pytest.skip('The ASGI implementation does not support RequestOptions.auto_parse_form_urlencoded')
headers = kwargs.setdefault('headers', {})
headers['Content-Type'] = 'application/x-www-form-urlencoded'
if ('method' not in kwargs):
kwargs['method'] = 'POST'
return client.simulate_request(path=path, body=query_string, **kwargs) |
class Migration(migrations.Migration):
dependencies = [('typeclasses', '0013_auto__1922')]
operations = [migrations.AlterField(model_name='tag', name='db_category', field=models.CharField(blank=True, db_index=True, help_text='tag category', max_length=64, null=True, verbose_name='category'))] |
.parametrize('with_spiders', [True, False])
def test_vlti_aperture(with_spiders):
name = 'vlti/pupil'
name += ('_without_spiders' if (not with_spiders) else '')
check_aperture(make_vlti_aperture, 125.0, name, check_normalization=False, check_segmentation=True, with_spiders=with_spiders, zenith_angle=0.0, azimuth=0.0)
name = 'vlti/pupil_non_zenith'
name += ('_without_spiders' if (not with_spiders) else '')
check_aperture(make_vlti_aperture, 125.0, name, check_normalization=False, check_segmentation=True, with_spiders=with_spiders, zenith_angle=(np.pi / 4), azimuth=(np.pi / 4)) |
def node():
global frontiers, mapData, global1, global2, global3, globalmaps
rospy.init_node('assigner', anonymous=False)
map_topic = rospy.get_param('~map_topic', 'map')
info_radius = rospy.get_param('~info_radius', 1.0)
info_multiplier = rospy.get_param('~info_multiplier', 3.0)
hysteresis_radius = rospy.get_param('~hysteresis_radius', 3.0)
hysteresis_gain = rospy.get_param('~hysteresis_gain', 2.0)
frontiers_topic = rospy.get_param('~frontiers_topic', '/filtered_points')
n_robots = rospy.get_param('~n_robots', 1)
namespace = rospy.get_param('~namespace', '')
namespace_init_count = rospy.get_param('namespace_init_count', 1)
delay_after_assignement = rospy.get_param('~delay_after_assignement', 0.5)
rateHz = rospy.get_param('~rate', 100)
rate = rospy.Rate(rateHz)
rospy.Subscriber(map_topic, OccupancyGrid, mapCallBack)
rospy.Subscriber(frontiers_topic, PointArray, callBack)
while (len(frontiers) < 1):
pass
centroids = copy(frontiers)
while (len(mapData.data) < 1):
pass
robots = []
if (len(namespace) > 0):
for i in range(0, n_robots):
robots.append(robot((namespace + str((i + namespace_init_count)))))
elif (len(namespace) == 0):
robots.append(robot(namespace))
for i in range(0, n_robots):
robots[i].sendGoal(robots[i].getPosition())
while (not rospy.is_shutdown()):
centroids = copy(frontiers)
infoGain = []
for ip in range(0, len(centroids)):
infoGain.append(informationGain(mapData, [centroids[ip][0], centroids[ip][1]], info_radius))
na = []
nb = []
for i in range(0, n_robots):
if (robots[i].getState() == 1):
nb.append(i)
else:
na.append(i)
rospy.loginfo(('available robots: ' + str(na)))
for i in (nb + na):
infoGain = discount(mapData, robots[i].assigned_point, centroids, infoGain, info_radius)
revenue_record = []
centroid_record = []
id_record = []
for ir in na:
for ip in range(0, len(centroids)):
cost = norm((robots[ir].getPosition() - centroids[ip]))
threshold = 1
information_gain = infoGain[ip]
if (norm((robots[ir].getPosition() - centroids[ip])) <= hysteresis_radius):
information_gain *= hysteresis_gain
revenue = ((information_gain * info_multiplier) - cost)
revenue_record.append(revenue)
centroid_record.append(centroids[ip])
id_record.append(ir)
if (len(na) < 1):
revenue_record = []
centroid_record = []
id_record = []
for ir in nb:
for ip in range(0, len(centroids)):
cost = norm((robots[ir].getPosition() - centroids[ip]))
threshold = 1
information_gain = infoGain[ip]
if (norm((robots[ir].getPosition() - centroids[ip])) <= hysteresis_radius):
information_gain *= hysteresis_gain
if (norm((centroids[ip] - robots[ir].assigned_point)) < hysteresis_radius):
information_gain = (informationGain(mapData, [centroids[ip][0], centroids[ip][1]], info_radius) * hysteresis_gain)
revenue = ((information_gain * info_multiplier) - cost)
revenue_record.append(revenue)
centroid_record.append(centroids[ip])
id_record.append(ir)
rospy.loginfo(('revenue record: ' + str(revenue_record)))
rospy.loginfo(('centroid record: ' + str(centroid_record)))
rospy.loginfo(('robot IDs record: ' + str(id_record)))
if (len(id_record) > 0):
winner_id = revenue_record.index(max(revenue_record))
robots[id_record[winner_id]].sendGoal(centroid_record[winner_id])
rospy.loginfo((((namespace + str((namespace_init_count + id_record[winner_id]))) + ' assigned to ') + str(centroid_record[winner_id])))
rospy.sleep(delay_after_assignement)
rate.sleep() |
class App(qt.QWidget):
SAMPLE_RATES = {rate: i for (i, rate) in enumerate([8000, 11025, 16000, 22050, 44100, 48000, 88200, 96000, 176400, 192000, 352800, 384000])}
def __init__(self):
super().__init__()
self.paused = False
self.analyzer = None
self.refAnalyzer = None
self.calibration = None
self.target = None
self.saveDir = Path.home()
self.loop = asyncio.get_event_loop_policy().get_event_loop()
self.task = self.loop.create_task(wrap_coro(self.analyze()))
self.stack = qt.QStackedWidget()
self.stack.addWidget(self.spectrumWidget())
self.stack.addWidget(self.irWidget())
self.stack.currentChanged.connect(self.plot)
vbox = qt.QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(self.stack)
vbox.addWidget(self.sharedControls())
self.resetAudio()
self.setLayout(vbox)
self.setWindowTitle('HiFi Scan')
self.resize(1800, 900)
self.show()
async def analyze(self):
while True:
self.audioChanged = False
try:
rate = int(self.rateCombo.currentText())
audio = None
audio = hifi.Audio(rate)
while (not self.audioChanged):
lo = self.lo.value()
hi = self.hi.value()
secs = self.secs.value()
ampl = (self.ampl.value() / 100)
ch = self.channelCombo.currentIndex()
if (self.paused or (lo >= hi) or (secs <= 0) or (not ampl)):
(await asyncio.sleep(0.1))
continue
analyzer = hifi.Analyzer(lo, hi, secs, audio.rate, ampl, self.calibration, self.target)
sound = analyzer.chirp
if ch:
silence = np.zeros_like(sound)
sound = ([sound, silence] if (ch == 1) else [silence, sound])
audio.play(sound)
async for recording in audio.record():
if self.paused:
audio.cancelPlay()
break
if analyzer.findMatch(recording):
self.analyzer = analyzer
self.plot()
break
if analyzer.timedOut():
break
except Exception as exc:
qt.QMessageBox.critical(self, 'Error', str(exc))
self.resetAudio()
finally:
if audio:
audio.close()
def resetAudio(self):
defaultDevice = next((dev for dev in sd.query_devices() if (dev['name'] == 'default')), None)
defaultRate = (defaultDevice.get('default_samplerate', 0) if defaultDevice else 0)
if (not defaultRate):
defaultRate = sd.default.samplerate
if (defaultRate not in self.SAMPLE_RATES):
defaultRate = 48000
index = self.SAMPLE_RATES[defaultRate]
self.rateCombo.setCurrentIndex(index)
self.audioChanged = True
def plot(self, *_):
if (self.stack.currentIndex() == 0):
self.plotSpectrum()
else:
self.plotIR()
def plotSpectrum(self):
smoothing = self.spectrumSmoothing.value()
if self.analyzer:
spectrum = self.analyzer.spectrum(smoothing)
self.spectrumPlot.setData(*spectrum)
target = self.analyzer.targetSpectrum(spectrum)
if target:
self.targetPlot.setData(*target)
else:
self.targetPlot.clear()
if self.refAnalyzer:
spectrum = self.refAnalyzer.spectrum(smoothing)
self.refSpectrumPlot.setData(*spectrum)
def plotIR(self):
if (self.refAnalyzer and (self.useCombo.currentIndex() == 0)):
analyzer = self.refAnalyzer
else:
analyzer = self.analyzer
if (not analyzer):
return
secs = (self.msDuration.value() / 1000)
dbRange = self.dbRange.value()
beta = self.kaiserBeta.value()
smoothing = self.irSmoothing.value()
causality = (self.causality.value() / 100)
(t, ir) = analyzer.h_inv(secs, dbRange, beta, smoothing, causality)
self.irPlot.setData((1000 * t), ir)
logIr = np.log10((1e-08 + np.abs(ir)))
self.logIrPlot.setData((1000 * t), logIr)
corrFactor = analyzer.correctionFactor(ir)
self.correctionPlot.setData(*corrFactor)
(spectrum, spectrum_resamp) = analyzer.correctedSpectrum(corrFactor)
self.simPlot.setData(*spectrum)
self.avSimPlot.setData(*spectrum_resamp)
target = analyzer.targetSpectrum(spectrum)
if target:
self.targetSimPlot.setData(*target)
else:
self.targetSimPlot.clear()
def screenshot(self):
timestamp = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
name = f'HiFiScan {timestamp}.png'
(path, _) = qt.QFileDialog.getSaveFileName(self, 'Save screenshot', str((self.saveDir / name)), 'PNG (*.png)')
if path:
self.stack.grab().save(path)
self.saveDir = Path(path).parent
def saveIR(self):
if (self.refAnalyzer and (self.useCombo.currentIndex() == 0)):
analyzer = self.refAnalyzer
else:
analyzer = self.analyzer
if (not analyzer):
return
ms = int(self.msDuration.value())
db = int(self.dbRange.value())
beta = int(self.kaiserBeta.value())
smoothing = int(self.irSmoothing.value())
causality = int(self.causality.value())
(_, irInv) = analyzer.h_inv((ms / 1000), db, beta, smoothing, (causality / 100))
name = f'IR_{ms}ms_{db}dB_{beta}t_{smoothing}s_{causality}c.wav'
(path, _) = qt.QFileDialog.getSaveFileName(self, 'Save inverse impulse response', str((self.saveDir / name)), 'WAV (*.wav)')
if path:
data = np.vstack([irInv, irInv])
hifi.write_wav(path, data, analyzer.rate)
self.saveDir = Path(path).parent
def run(self):
def updateQt():
qApp = qtgui.QGuiApplication.instance()
qApp.processEvents()
self.loop.call_later(0.03, updateQt)
signal.signal(signal.SIGINT, (lambda *args: self.close()))
updateQt()
self.loop.run_forever()
self.loop.run_until_complete(self.task)
os._exit(0)
def closeEvent(self, ev):
self.task.cancel()
self.loop.stop()
def spectrumWidget(self) -> qt.QWidget:
topWidget = qt.QWidget()
vbox = qt.QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
topWidget.setLayout(vbox)
axes = {ori: Axis(ori) for ori in ['bottom', 'left', 'top', 'right']}
for ax in axes.values():
ax.setGrid(200)
self.spectrumPlotWidget = pw = pg.PlotWidget(axisItems=axes)
pw.setLabel('left', 'Relative Power [dB]')
pw.setLabel('bottom', 'Frequency [Hz]')
pw.setLogMode(x=True)
self.targetPlot = pw.plot(pen=(255, 0, 0), stepMode='right')
self.refSpectrumPlot = pw.plot(pen=(255, 100, 0), stepMode='right')
self.spectrumPlot = pw.plot(pen=(0, 255, 255), stepMode='right')
self.spectrumPlot.curve.setCompositionMode(qtgui.QPainter.CompositionMode.CompositionMode_Plus)
vbox.addWidget(pw)
self.lo = pg.SpinBox(value=20, step=5, bounds=[5, 40000], suffix='Hz')
self.hi = pg.SpinBox(value=20000, step=100, bounds=[5, 40000], suffix='Hz')
self.secs = pg.SpinBox(value=1.0, step=0.1, bounds=[0.1, 30], suffix='s')
self.ampl = pg.SpinBox(value=40, step=1, bounds=[0, 100], suffix='%')
self.channelCombo = qt.QComboBox()
self.channelCombo.addItems(['Stereo', 'Left', 'Right'])
self.spectrumSmoothing = pg.SpinBox(value=15, step=1, bounds=[0, 30])
self.spectrumSmoothing.sigValueChanging.connect(self.plot)
hbox = qt.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(qt.QLabel('Low: '))
hbox.addWidget(self.lo)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('High: '))
hbox.addWidget(self.hi)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('Duration: '))
hbox.addWidget(self.secs)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('Amplitude: '))
hbox.addWidget(self.ampl)
hbox.addWidget(self.channelCombo)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('Smoothing: '))
hbox.addWidget(self.spectrumSmoothing)
hbox.addStretch(1)
vbox.addLayout(hbox)
return topWidget
def irWidget(self) -> qt.QWidget:
topWidget = qt.QWidget()
vbox = qt.QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
topWidget.setLayout(vbox)
splitter = qt.QSplitter(qtcore.Qt.Orientation.Vertical)
vbox.addWidget(splitter)
self.irPlotWidget = pw = pg.PlotWidget()
pw.showGrid(True, True, 0.8)
self.irPlot = pw.plot(pen=(0, 255, 255))
pw.setLabel('left', 'Inverse IR')
splitter.addWidget(pw)
self.logIrPlotWidget = pw = pg.PlotWidget()
pw.showGrid(True, True, 0.8)
pw.setLabel('left', 'Log Inverse IR')
self.logIrPlot = pw.plot(pen=(0, 255, 100))
splitter.addWidget(pw)
self.correctionPlotWidget = pw = pg.PlotWidget()
pw.showGrid(True, True, 0.8)
pw.setLabel('left', 'Correction Factor')
self.correctionPlot = pw.plot(pen=(255, 255, 200), fillLevel=0, fillBrush=(255, 0, 0, 100))
splitter.addWidget(pw)
axes = {ori: Axis(ori) for ori in ['bottom', 'left']}
for ax in axes.values():
ax.setGrid(200)
self.simPlotWidget = pw = pg.PlotWidget(axisItems=axes)
pw.showGrid(True, True, 0.8)
pw.setLabel('left', 'Corrected Spectrum')
self.simPlot = pg.PlotDataItem(pen=(150, 100, 60), stepMode='right')
pw.addItem(self.simPlot, ignoreBounds=True)
self.avSimPlot = pw.plot(pen=(255, 255, 200), stepMode='right')
self.targetSimPlot = pw.plot(pen=(255, 0, 0), stepMode='right')
pw.setLogMode(x=True)
splitter.addWidget(pw)
self.msDuration = pg.SpinBox(value=50, step=1, bounds=[1, 1000], suffix='ms')
self.msDuration.sigValueChanging.connect(self.plot)
self.dbRange = pg.SpinBox(value=24, step=1, bounds=[0, 100], suffix='dB')
self.dbRange.sigValueChanging.connect(self.plot)
self.kaiserBeta = pg.SpinBox(value=5, step=1, bounds=[0, 100])
self.kaiserBeta.sigValueChanging.connect(self.plot)
self.irSmoothing = pg.SpinBox(value=15, step=1, bounds=[0, 30])
self.irSmoothing.sigValueChanging.connect(self.plot)
causalityLabel = qt.QLabel('Causality: ')
causalityLabel.setToolTip('0% = Zero phase, 100% = Zero latency')
self.causality = pg.SpinBox(value=0, step=5, bounds=[0, 100], suffix='%')
self.causality.sigValueChanging.connect(self.plot)
self.useCombo = qt.QComboBox()
self.useCombo.addItems(['Stored measurements', 'Last measurement'])
self.useCombo.currentIndexChanged.connect(self.plot)
exportButton = qt.QPushButton('Export as WAV')
exportButton.setShortcut('E')
exportButton.setToolTip('<Key E>')
exportButton.clicked.connect(self.saveIR)
hbox = qt.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(qt.QLabel('Duration: '))
hbox.addWidget(self.msDuration)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('Range: '))
hbox.addWidget(self.dbRange)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('Tapering: '))
hbox.addWidget(self.kaiserBeta)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('Smoothing: '))
hbox.addWidget(self.irSmoothing)
hbox.addSpacing(32)
hbox.addWidget(causalityLabel)
hbox.addWidget(self.causality)
hbox.addSpacing(32)
hbox.addWidget(qt.QLabel('Use: '))
hbox.addWidget(self.useCombo)
hbox.addStretch(1)
hbox.addWidget(exportButton)
vbox.addLayout(hbox)
return topWidget
def stereoTool(self):
def leftPressed():
(path, _) = qt.QFileDialog.getOpenFileName(self, 'Load left channel', str(self.saveDir), 'WAV (*.wav)')
leftLabel.setText(path)
self.saveDir = Path(path).parent
def rightPressed():
(path, _) = qt.QFileDialog.getOpenFileName(self, 'Load right channel', str(self.saveDir), 'WAV (*.wav)')
rightLabel.setText(path)
self.saveDir = Path(path).parent
def save():
try:
L = hifi.read_wav(leftLabel.text())
R = hifi.read_wav(rightLabel.text())
left = L.data[0]
right = R.data[(1 if (len(R) > 1) else 0)]
if ((L.rate != R.rate) or (left.size != right.size)):
raise ValueError('L and R must have same size and rate')
stereo = [left, right]
except Exception as e:
msg = qt.QMessageBox(qt.QMessageBox.Icon.Critical, 'Error', str(e), parent=dialog)
msg.exec()
else:
(path, _) = qt.QFileDialog.getSaveFileName(self, 'Save stereo channels', str(self.saveDir), 'WAV (*.wav)')
if path:
self.saveDir = Path(path).parent
hifi.write_wav(path, stereo, L.rate)
leftLabel = qt.QLabel('')
leftButton = qt.QPushButton('Load')
leftButton.pressed.connect(leftPressed)
rightLabel = qt.QLabel('')
rightButton = qt.QPushButton('Load')
rightButton.pressed.connect(rightPressed)
saveButton = qt.QPushButton('Save')
saveButton.pressed.connect(save)
grid = qt.QGridLayout()
grid.setColumnMinimumWidth(2, 400)
grid.addWidget(qt.QLabel('Left in: '), 0, 0)
grid.addWidget(leftButton, 0, 1)
grid.addWidget(leftLabel, 0, 2)
grid.addWidget(qt.QLabel('Right in: '), 1, 0)
grid.addWidget(rightButton, 1, 1)
grid.addWidget(rightLabel, 1, 2)
grid.addWidget(qt.QLabel('Stereo out: '), 2, 0)
grid.addWidget(saveButton, 2, 1, 1, 2)
dialog = qt.QDialog(self)
dialog.setWindowTitle('Convert Left + Right to Stereo')
dialog.setLayout(grid)
dialog.exec()
def causalityTool(self):
def load():
(path, _) = qt.QFileDialog.getOpenFileName(self, 'Load Impulse Response', str(self.saveDir), 'WAV (*.wav)')
inputLabel.setText(path)
self.saveDir = Path(path).parent
def save():
caus = (causality.value() / 100)
try:
irIn = hifi.read_wav(inputLabel.text())
out = [hifi.transform_causality(channel, caus) for channel in irIn.data]
except Exception as e:
msg = qt.QMessageBox(qt.QMessageBox.Icon.Critical, 'Error', str(e), parent=dialog)
msg.exec()
else:
name = (Path(inputLabel.text()).stem + f'_{causality.value():.0f}c.wav')
(path, _) = qt.QFileDialog.getSaveFileName(self, 'Save Impulse Response', str((self.saveDir / name)), 'WAV (*.wav)')
if path:
self.saveDir = Path(path).parent
hifi.write_wav(path, out, irIn.rate)
causality = pg.SpinBox(value=0, step=5, bounds=[0, 100], suffix='%')
inputLabel = qt.QLabel('')
loadButton = qt.QPushButton('Load')
loadButton.pressed.connect(load)
saveButton = qt.QPushButton('Save')
saveButton.pressed.connect(save)
grid = qt.QGridLayout()
grid.setColumnMinimumWidth(2, 400)
grid.addWidget(qt.QLabel('Input IR: '), 0, 0)
grid.addWidget(loadButton, 0, 1)
grid.addWidget(inputLabel, 0, 2)
grid.addWidget(qt.QLabel('New causality: '), 1, 0)
grid.addWidget(causality, 1, 1)
grid.addWidget(qt.QLabel('Output IR: '), 2, 0)
grid.addWidget(saveButton, 2, 1, 2, 2)
dialog = qt.QDialog(self)
dialog.setWindowTitle('Change causality of Impulse Response')
dialog.setLayout(grid)
dialog.exec()
def sharedControls(self) -> qt.QWidget:
topWidget = qt.QWidget()
vbox = qt.QVBoxLayout()
topWidget.setLayout(vbox)
self.buttons = buttons = qt.QButtonGroup()
buttons.setExclusive(True)
spectrumButton = qt.QRadioButton('Spectrum')
irButton = qt.QRadioButton('Impulse Response')
buttons.addButton(spectrumButton, 0)
buttons.addButton(irButton, 1)
spectrumButton.setChecked(True)
buttons.idClicked.connect(self.stack.setCurrentIndex)
def setAudioChanged():
self.audioChanged = True
self.rateCombo = qt.QComboBox()
self.rateCombo.addItems((str(rate) for rate in self.SAMPLE_RATES))
self.rateCombo.currentIndexChanged.connect(setAudioChanged)
def toolsPressed():
tools.popup(toolsButton.mapToGlobal(qtcore.QPoint(0, 0)))
tools = qt.QMenu()
tools.addAction('Convert L + R to Stereo', self.stereoTool)
tools.addAction('Change IR causality', self.causalityTool)
toolsButton = qt.QPushButton('Tools...')
toolsButton.pressed.connect(toolsPressed)
def loadCalibration():
(path, _) = qt.QFileDialog.getOpenFileName(self, 'Load mic calibration', str(self.saveDir))
if path:
cal = hifi.read_correction(path)
if cal:
self.calibration = cal
calAction.setText((calTxt + path))
self.saveDir = Path(path).parent
else:
clearCalibration()
def clearCalibration():
self.calibration = None
calAction.setText((calTxt + 'None'))
def loadTarget():
(path, _) = qt.QFileDialog.getOpenFileName(self, 'Load target curve', str(self.saveDir))
if path:
target = hifi.read_correction(path)
if target:
self.target = target
targetAction.setText((targetTxt + path))
self.saveDir = Path(path).parent
else:
clearTarget()
def clearTarget():
self.target = None
targetAction.setText((targetTxt + 'None'))
def correctionsPressed():
corr.popup(correctionsButton.mapToGlobal(qtcore.QPoint(0, 0)))
calTxt = 'Mic Calibration: '
targetTxt = 'Target Curve: '
corr = qt.QMenu()
calAction = corr.addAction((calTxt + 'None'), loadCalibration)
corr.addAction('Load', loadCalibration)
corr.addAction('Clear', clearCalibration)
corr.addSeparator()
targetAction = corr.addAction((targetTxt + 'None'), loadTarget)
corr.addAction('Load', loadTarget)
corr.addAction('Clear', clearTarget)
correctionsButton = qt.QPushButton('Corrections...')
correctionsButton.pressed.connect(correctionsPressed)
def storeButtonClicked():
if self.analyzer:
if self.analyzer.isCompatible(self.refAnalyzer):
self.refAnalyzer.addMeasurements(self.analyzer)
else:
self.refAnalyzer = copy.copy(self.analyzer)
setMeasurementsText()
self.plot()
def clearButtonClicked():
self.refAnalyzer = None
self.refSpectrumPlot.clear()
setMeasurementsText()
self.plot()
def setMeasurementsText():
num = (self.refAnalyzer.numMeasurements if self.refAnalyzer else 0)
measurementsLabel.setText(f"Measurements: {(num if num else '')}")
measurementsLabel = qt.QLabel('')
setMeasurementsText()
storeButton = qt.QPushButton('Store')
storeButton.clicked.connect(storeButtonClicked)
storeButton.setShortcut('S')
storeButton.setToolTip('<Key S>')
clearButton = qt.QPushButton('Clear')
clearButton.clicked.connect(clearButtonClicked)
clearButton.setShortcut('C')
clearButton.setToolTip('<Key C>')
def load():
(path, _) = qt.QFileDialog.getOpenFileName(self, 'Load measurements', str(self.saveDir))
if path:
with open(path, 'rb') as f:
self.refAnalyzer = pickle.load(f)
setMeasurementsText()
self.plot()
def loadStore():
(path, _) = qt.QFileDialog.getOpenFileName(self, 'Load and Store measurements', str(self.saveDir))
if path:
with open(path, 'rb') as f:
analyzer: hifi.Analyzer = pickle.load(f)
if (analyzer and analyzer.isCompatible(self.refAnalyzer)):
self.refAnalyzer.addMeasurements(analyzer)
else:
self.refAnalyzer = analyzer
setMeasurementsText()
self.plot()
def save():
analyzer = (self.refAnalyzer or self.analyzer)
timestamp = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
name = f'Measurements={analyzer.numMeasurements}, {timestamp}'
(path, _) = qt.QFileDialog.getSaveFileName(self, 'Save measurements', str((self.saveDir / name)))
if path:
self.saveDir = Path(path).parent
with open(path, 'wb') as f:
pickle.dump(analyzer, f)
self.plot()
def filePressed():
fileMenu.popup(fileButton.mapToGlobal(qtcore.QPoint(0, 0)))
fileMenu = qt.QMenu()
fileMenu.addAction('Load', load)
fileMenu.addAction('Load and Store', loadStore)
fileMenu.addAction('Save', save)
fileButton = qt.QPushButton('File...')
fileButton.clicked.connect(filePressed)
screenshotButton = qt.QPushButton('Screenshot')
screenshotButton.clicked.connect(self.screenshot)
def setPaused():
self.paused = (not self.paused)
pauseButton = qt.QPushButton('Pause')
pauseButton.setShortcut('Space')
pauseButton.setToolTip('<Space>')
pauseButton.setFocusPolicy(qtcore.Qt.FocusPolicy.NoFocus)
pauseButton.clicked.connect(setPaused)
exitButton = qt.QPushButton('Exit')
exitButton.setShortcut('Ctrl+Q')
exitButton.setToolTip('Ctrl+Q')
exitButton.clicked.connect(self.close)
hbox = qt.QHBoxLayout()
hbox.addWidget(spectrumButton)
hbox.addSpacing(16)
hbox.addWidget(irButton)
hbox.addSpacing(64)
hbox.addWidget(toolsButton)
hbox.addSpacing(32)
hbox.addWidget(correctionsButton)
hbox.addStretch(1)
hbox.addWidget(measurementsLabel)
hbox.addWidget(storeButton)
hbox.addWidget(clearButton)
hbox.addWidget(fileButton)
hbox.addStretch(1)
hbox.addWidget(qt.QLabel('Sample rate:'))
hbox.addWidget(self.rateCombo)
hbox.addStretch(1)
hbox.addWidget(screenshotButton)
hbox.addWidget(pauseButton)
hbox.addWidget(exitButton)
vbox.addLayout(hbox)
return topWidget |
class TestHCTGamut(util.ColorAsserts, unittest.TestCase):
def test_blue(self):
hct = Color('#0000ff').convert('hct')
tones = [100, 95, 90, 80, 70, 60, 50, 40, 30, 20, 10, 0]
expect = ['#ffffff', '#f1efff', '#e0e0ff', '#bec2ff', '#9da3ff', '#7c84ff', '#5a64ff', '#343dff', '#0000ef', '#0001ac', '#00006e', '#000000']
options = {'method': 'hct-chroma', 'jnd': 0.0}
for (tone, answer) in zip(tones, expect):
s1 = [(c * 255) for c in hct.clone().set('tone', tone).convert('srgb').fit(**options)[:(- 1)]]
s2 = [(c * 255) for c in Color(answer)[:(- 1)]]
for (c1, c2) in zip(s1, s2):
self.assertTrue(math.isclose(c1, c2, abs_tol=1.0))
hct.set('chroma', 16)
expect = ['#ffffff', '#f1efff', '#e1e0f9', '#c5c4dd', '#a9a9c1', '#8f8fa6', '#75758b', '#5c5d72', '#444559', '#2e2f42', '#191a2c', '#000000']
for (tone, answer) in zip(tones, expect):
s1 = [(c * 255) for c in hct.clone().set('tone', tone).convert('srgb').fit(**options)[:(- 1)]]
s2 = [(c * 255) for c in Color(answer)[:(- 1)]]
for (c1, c2) in zip(s1, s2):
self.assertTrue(math.isclose(c1, c2, abs_tol=1.0))
def test_inside_but_high_chroma(self):
self.assertColorEqual(Color('hct', [270, 30, 0]).fit('srgb', method='hct-chroma'), Color('hct', [float('nan'), 0, 0])) |
class ChatMessage(JSONSerializable):
human_message: Optional[BaseMessage] = None
ai_message: Optional[BaseMessage] = None
def add_user_message(self, message: str, metadata: Optional[dict]=None):
if self.human_message:
logging.info('Human message already exists in the chat message, overwritting it with new message.')
self.human_message = BaseMessage(content=message, created_by='human', metadata=metadata)
def add_ai_message(self, message: str, metadata: Optional[dict]=None):
if self.ai_message:
logging.info('AI message already exists in the chat message, overwritting it with new message.')
self.ai_message = BaseMessage(content=message, created_by='ai', metadata=metadata)
def __str__(self) -> str:
return f'''{self.human_message}
{self.ai_message}''' |
def gethead(url, data=None, referer=None, h=None):
if h:
headers.update(h)
req = urllib2.Request(url, headers=headers)
if referer:
req.add_header('Referer', referer)
req.get_method = (lambda : 'HEAD')
opener = urllib2.build_opener(PassRedirectHandler)
return opener.open(req, timeout=30) |
def test_fill_transaction_defaults_for_all_params(w3):
default_transaction = fill_transaction_defaults(w3, {})
assert (default_transaction == {'chainId': w3.eth.chain_id, 'data': b'', 'gas': w3.eth.estimate_gas({}), 'maxFeePerGas': (w3.eth.max_priority_fee + (2 * w3.eth.get_block('latest')['baseFeePerGas'])), 'maxPriorityFeePerGas': w3.eth.max_priority_fee, 'value': 0}) |
class EfuseDefineFields(EfuseFieldsBase):
def __init__(self) -> None:
self.EFUSES = []
self.KEYBLOCKS = []
self.BLOCK2_CALIBRATION_EFUSES = []
self.CALC = []
dir_name = os.path.dirname(os.path.abspath(__file__))
(dir_name, file_name) = os.path.split(dir_name)
file_name = (file_name + '.yaml')
(dir_name, _) = os.path.split(dir_name)
efuse_file = os.path.join(dir_name, 'efuse_defs', file_name)
efuse_file = efuse_file.replace('esp32s3beta2', 'esp32s3')
with open(f'{efuse_file}', 'r') as r_file:
e_desc = yaml.safe_load(r_file)
super().__init__(e_desc)
for (i, efuse) in enumerate(self.ALL_EFUSES):
if (efuse.name in ['BLOCK_USR_DATA', 'BLOCK_KEY0', 'BLOCK_KEY1', 'BLOCK_KEY2', 'BLOCK_KEY3', 'BLOCK_KEY4', 'BLOCK_KEY5', 'BLOCK_SYS_DATA2']):
if (efuse.name == 'BLOCK_USR_DATA'):
efuse.bit_len = 256
efuse.type = 'bytes:32'
self.KEYBLOCKS.append(efuse)
self.ALL_EFUSES[i] = None
elif (efuse.category == 'calibration'):
self.BLOCK2_CALIBRATION_EFUSES.append(efuse)
self.ALL_EFUSES[i] = None
f = Field()
f.name = 'WAFER_VERSION_MINOR'
f.block = 0
f.bit_len = 4
f.type = f'uint:{f.bit_len}'
f.category = 'identity'
f.class_type = 'wafer'
f.description = 'calc WAFER VERSION MINOR = WAFER_VERSION_MINOR_HI << 3 + WAFER_VERSION_MINOR_LO (read only)'
self.CALC.append(f)
for efuse in self.ALL_EFUSES:
if (efuse is not None):
self.EFUSES.append(efuse)
self.ALL_EFUSES = [] |
class CatalogButton(Catalog.CatalogGroup):
def basic(self) -> CssStylesButton.CssButtonBasic:
return self._set_class(CssStylesButton.CssButtonBasic)
def important(self) -> CssStylesButton.CssButtonImportant:
return self._set_class(CssStylesButton.CssButtonImportant)
def reset(self) -> CssStylesButton.CssButtonReset:
return self._set_class(CssStylesButton.CssButtonReset)
def success(self) -> CssStylesButton.CssButtonSuccess:
return self._set_class(CssStylesButton.CssButtonSuccess)
def content(self) -> CssStylesButton.CssButtonContentHover:
return self._set_class(CssStylesButton.CssButtonContentHover)
def content_link(self) -> CssStylesButton.CssButtonContentAHover:
return self._set_class(CssStylesButton.CssButtonContentAHover) |
class TestFlinkRowWriter(unittest.TestCase):
def setUp(self) -> None:
super().setUp()
self.env = StreamExecutionEnvironment.get_execution_environment()
self.env.add_jars('file://{}'.format(find_jar_path()))
self.env.set_parallelism(1)
self.t_env = StreamTableEnvironment.create(self.env)
self.statement_set = self.t_env.create_statement_set()
def test_inference(self):
config = TFClusterConfig.new_builder().set_worker_count(1).set_node_entry(inference_func).set_property('output_types', 'INT_32,INT_64,FLOAT_32,FLOAT_64,STRING').build()
schema = Schema.new_builder().column('f0', 'INT').column('f1', 'BIGINT').column('f2', 'FLOAT').column('f3', 'DOUBLE').column('f4', 'STRING').build()
input_table = self.t_env.from_data_stream(self.env.from_collection([]))
output_table = inference(self.statement_set, input_table, config, schema)
self.statement_set.add_insert(TableDescriptor.for_connector('print').build(), output_table)
self.statement_set.execute().wait() |
class OptionSeriesVennSonificationTracks(Options):
def activeWhen(self) -> 'OptionSeriesVennSonificationTracksActivewhen':
return self._config_sub_data('activeWhen', OptionSeriesVennSonificationTracksActivewhen)
def instrument(self):
return self._config_get('piano')
def instrument(self, text: str):
self._config(text, js_type=False)
def mapping(self) -> 'OptionSeriesVennSonificationTracksMapping':
return self._config_sub_data('mapping', OptionSeriesVennSonificationTracksMapping)
def midiName(self):
return self._config_get(None)
def midiName(self, text: str):
self._config(text, js_type=False)
def pointGrouping(self) -> 'OptionSeriesVennSonificationTracksPointgrouping':
return self._config_sub_data('pointGrouping', OptionSeriesVennSonificationTracksPointgrouping)
def roundToMusicalNotes(self):
return self._config_get(True)
def roundToMusicalNotes(self, flag: bool):
self._config(flag, js_type=False)
def showPlayMarker(self):
return self._config_get(True)
def showPlayMarker(self, flag: bool):
self._config(flag, js_type=False)
def type(self):
return self._config_get('instrument')
def type(self, text: str):
self._config(text, js_type=False) |
class PlotToolbar(Container, AbstractOverlay):
buttons = List(Type(ToolbarButton))
hiding = Bool(True)
auto_hide = Bool(True)
end_radius = Float(4.0)
button_spacing = Float(5.0)
horizontal_padding = Float(5.0)
vertical_padding = Float(5.0)
location = Enum('top', 'right', 'bottom', 'left')
show_tooltips = Bool(False)
def __init__(self, component=None, *args, **kw):
super().__init__(*args, **kw)
self.component = component
if ((component is not None) and hasattr(component, 'toolbar_location')):
self.location = component.toolbar_location
for buttontype in self.buttons:
self.add_button(buttontype())
hover_tool = PlotToolbarHover(component=self, callback=self.on_hover)
self.tools.append(hover_tool)
if (self.location in ['top', 'bottom']):
self._calculate_width()
else:
self._calculate_height()
def _buttons_default(self):
return [IndexAxisLogButton, ValueAxisLogButton, SaveAsButton, CopyToClipboardButton, ExportDataToClipboardButton, ZoomResetButton]
def add_button(self, button):
self.add(button)
button.toolbar_overlay = self
self._layout_needed = True
def normal_mouse_move(self, event):
self.on_hover('')
if self.hiding:
self.hiding = False
def on_hover(self, tooltip):
if self.show_tooltips:
self.component.window.set_tooltip(tooltip)
def normal_left_down(self, event):
if self.hiding:
return
else:
for button in self.components:
if button.is_in(event.x, event.y):
button.perform(event)
event.handled = True
break
def overlay(self, other_component, gc, view_bounds=None, mode='normal'):
starting_color = numpy.array([0.0, 1.0, 1.0, 1.0, 0.5])
ending_color = numpy.array([1.0, 0.0, 0.0, 0.0, 0.5])
x = self.x
y = self.y
height = self.height
with gc:
gc.begin_path()
gc.move_to((x + self.end_radius), y)
gc.arc_to((x + self.width), y, (x + self.width), (y + self.end_radius), self.end_radius)
gc.arc_to((x + self.width), (y + height), ((x + self.width) - self.end_radius), (y + height), self.end_radius)
gc.arc_to(x, (y + height), x, ((y + height) - self.end_radius), self.end_radius)
gc.arc_to(x, y, (x + self.end_radius), y, self.end_radius)
if (self.location in ['top', 'bottom']):
gc.linear_gradient(x, y, x, (y + 100), numpy.array([starting_color, ending_color]), 'pad')
else:
gc.linear_gradient(x, y, (x + 100), y, numpy.array([starting_color, ending_color]), 'pad')
gc.draw_path()
if (not self.hiding):
for button in self.components:
button.draw(gc)
def is_in(self, x, y):
if (((x >= self.x) and (x <= self.x2)) and ((y >= self.y) and (y <= self.y2))):
return True
return False
def _do_layout(self, component=None):
if (component is None):
component = self.component
if (self.location in ['top', 'bottom']):
if self.hiding:
self.height = height = 10
else:
tallest_button = max([button.height for button in self.components])
self.height = height = (tallest_button + (self.vertical_padding * 2))
elif self.hiding:
self.width = width = 10
else:
widest_button = max([button.width for button in self.components])
self.width = width = (widest_button + (self.horizontal_padding * 2))
if (component is not None):
(cx, cy) = component.outer_position
if (self.location == 'top'):
self.x = ((cx + ((component.width - self.width) / 2)) + component.padding_left)
self.y = ((((cy + component.height) + component.padding_bottom) - height) - 2)
elif (self.location == 'bottom'):
self.x = ((cx + ((component.width - self.width) / 2)) + component.padding_left)
self.y = ((cy + component.padding_bottom) + 2)
elif (self.location == 'left'):
self.x = ((cx + component.padding_left) + 2)
self.y = ((cy + ((component.height - self.height) / 2)) + component.padding_bottom)
else:
self.x = ((((cx + component.width) + component.padding_left) - width) - 2)
self.y = ((cy + ((component.height - self.height) / 2)) + component.padding_bottom)
if (self.location in ['top', 'bottom']):
v_position = (self.y + (self.vertical_padding * 2))
last_button_position = ((self.x + self.horizontal_padding) + self.button_spacing)
for button in self.components:
button.x = last_button_position
button.y = v_position
last_button_position += (button.width + (self.button_spacing * 2))
else:
h_position = (self.x + self.horizontal_padding)
last_button_position = ((self.y + self.vertical_padding) + self.button_spacing)
for button in reversed(self.components):
h_offset = ((self.width - button.width) / 2)
button.y = last_button_position
button.x = (h_position + h_offset)
last_button_position += (button.height + (self.button_spacing * 2))
def _dispatch_stateful_event(self, event, suffix):
if self.is_in(event.x, event.y):
if (suffix == 'mouse_move'):
self.normal_mouse_move(event)
elif (suffix == 'left_down'):
self.normal_left_down(event)
event.handled = True
elif self.auto_hide:
self.hiding = True
('components, location')
def _calculate_width(self, event=None):
if (self.location in ['top', 'bottom']):
width = (self.horizontal_padding * 2)
for button in self.components:
width += (button.width + (self.button_spacing * 2))
self.width = max(10, width)
self._layout_needed = True
self.request_redraw()
('components, location')
def _calculate_height(self, event=None):
if (self.location in ['left', 'right']):
height = (self.vertical_padding * 2)
for button in self.components:
height += (button.height + (self.button_spacing * 2))
self.height = max(10, height)
self._layout_needed = True
self.request_redraw()
('hiding')
def _set_layout_needed_and_redraw(self, event):
self._layout_needed = True
self.request_redraw()
('auto_hide')
def _set_hiding_and_redraw(self, event):
self.hiding = self.auto_hide
self.request_redraw() |
def unwrap_edges_pipe(self, context, padding):
me = bpy.context.active_object.data
bm = bmesh.from_edit_mesh(me)
uv_layers = bm.loops.layers.uv.verify()
for face in bm.faces:
if face.select:
bpy.ops.mesh.select_all(action='DESELECT')
self.report({'INFO'}, 'No faces should be selected, only edge rings')
return
bpy.ops.mesh.loop_multi_select(ring=False)
selected_edges = {edge for edge in bm.edges if edge.select}
if (len(selected_edges) == 0):
bpy.ops.mesh.select_all(action='DESELECT')
return
bpy.ops.mesh.select_linked(delimit=set())
bpy.ops.mesh.mark_seam(clear=True)
selected_faces = {face for face in bm.faces if face.select}
if (not selected_faces):
bpy.ops.mesh.select_all(action='DESELECT')
self.report({'INFO'}, "It's not possible to perform the unwrap on loose edges")
return
for edge in selected_edges:
edge.seam = True
bpy.context.scene.tool_settings.use_uv_select_sync = False
bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.uv.select_all(action='DESELECT')
for face in selected_faces:
face.select = True
for loop in face.loops:
loop[uv_layers].select = True
bpy.ops.uv.unwrap(method='ANGLE_BASED', margin=padding)
islands = utilities_uv.getSelectionIslands(bm, uv_layers, extend_selection_to_islands=True, selected_faces=selected_faces)
for island in islands:
unrectified_faces = set()
rectified_faces = set()
face_loops = {face: [loop for loop in face.loops] for face in island}
active = {bm.faces.active}
count = 3
while (count > 0):
if (count == 3):
unrectified_faces = op_rectify.main(me, bm, uv_layers, island, face_loops, return_discarded_faces=True)
rectified_faces = island.difference(unrectified_faces)
for face in unrectified_faces:
face.select_set(False)
else:
for f in rectified_faces:
if (f not in active):
bm.faces.active = f
active.add(f)
break
bpy.ops.mesh.select_all(action='DESELECT')
for face in rectified_faces:
face.select_set(True)
for loop in face.loops:
loop[uv_layers].select = True
bpy.ops.uv.unwrap(method='ANGLE_BASED', margin=padding)
op_rectify.main(me, bm, uv_layers, island, face_loops)
if (not rectified_faces):
count = 0
continue
bpy.ops.uv.select_all(action='DESELECT')
bpy.ops.uv.select_overlap(extend=False)
for f in rectified_faces:
if f.loops[0][uv_layers].select:
count -= 1
else:
count = 0
break
if unrectified_faces:
bpy.ops.mesh.select_all(action='DESELECT')
for face in unrectified_faces:
face.select_set(True)
for loop in face.loops:
loop[uv_layers].select = True
bpy.ops.uv.unwrap(method='ANGLE_BASED', margin=padding)
for face in selected_faces:
face.select_set(True)
for loop in face.loops:
loop[uv_layers].select = True |
class meter_features_stats_reply(stats_reply):
version = 4
type = 19
stats_type = 11
def __init__(self, xid=None, flags=None, features=None):
if (xid != None):
self.xid = xid
else:
self.xid = None
if (flags != None):
self.flags = flags
else:
self.flags = 0
if (features != None):
self.features = features
else:
self.features = ofp.meter_features()
return
def pack(self):
packed = []
packed.append(struct.pack('!B', self.version))
packed.append(struct.pack('!B', self.type))
packed.append(struct.pack('!H', 0))
packed.append(struct.pack('!L', self.xid))
packed.append(struct.pack('!H', self.stats_type))
packed.append(struct.pack('!H', self.flags))
packed.append(('\x00' * 4))
packed.append(self.features.pack())
length = sum([len(x) for x in packed])
packed[2] = struct.pack('!H', length)
return ''.join(packed)
def unpack(reader):
obj = meter_features_stats_reply()
_version = reader.read('!B')[0]
assert (_version == 4)
_type = reader.read('!B')[0]
assert (_type == 19)
_length = reader.read('!H')[0]
orig_reader = reader
reader = orig_reader.slice(_length, 4)
obj.xid = reader.read('!L')[0]
_stats_type = reader.read('!H')[0]
assert (_stats_type == 11)
obj.flags = reader.read('!H')[0]
reader.skip(4)
obj.features = ofp.meter_features.unpack(reader)
return obj
def __eq__(self, other):
if (type(self) != type(other)):
return False
if (self.xid != other.xid):
return False
if (self.flags != other.flags):
return False
if (self.features != other.features):
return False
return True
def pretty_print(self, q):
q.text('meter_features_stats_reply {')
with q.group():
with q.indent(2):
q.breakable()
q.text('xid = ')
if (self.xid != None):
q.text(('%#x' % self.xid))
else:
q.text('None')
q.text(',')
q.breakable()
q.text('flags = ')
value_name_map = {1: 'OFPSF_REPLY_MORE'}
q.text(util.pretty_flags(self.flags, value_name_map.values()))
q.text(',')
q.breakable()
q.text('features = ')
q.pp(self.features)
q.breakable()
q.text('}') |
class TestC(TestCase):
def test_quadratic(self):
dimensions = 1
M = 12
param = Parameter(distribution='Uniform', lower=0, upper=1.0, order=2)
myParameters = [param for i in range(dimensions)]
x_train = np.asarray([0.0, 0.0714, 0.1429, 0.2857, 0.3571, 0.4286, 0.5714, 0.6429, 0.7143, 0.7857, 0.9286, 1.0])
y_train = np.asarray([6.8053, (- 1.5184), 1.6416, 6.3543, 14.3442, 16.4426, 18.1953, 28.9913, 27.2246, 40.3759, 55.3726, 72.0])
x_train = np.reshape(x_train, (M, 1))
y_train = np.reshape(y_train, (M, 1))
myBasis = Basis('univariate')
poly = Poly(myParameters, myBasis, method='least-squares', sampling_args={'sample-points': x_train, 'sample-outputs': y_train})
poly.set_model()
coefficients = poly.get_coefficients().reshape(3)
true_coefficients = np.asarray([22., 17., 4.])
np.testing.assert_array_almost_equal(coefficients, true_coefficients, decimal=4, err_msg='Problem!')
def test_robust(self):
methods = ['huber', 'least-absolute-residual']
opts = ['osqp', 'scipy']
f = (lambda x: ((((((- 0.3) * (x ** 4)) - (3 * (x ** 3))) + (0.6 * (x ** 2))) + (2.4 * x)) - 0.5))
N = 50
n = 4
state = 15
noise_var = 0.1
x = np.sort(np.random.RandomState(state).uniform((- 1), 1, N))
y = (f(x) + np.random.RandomState(state).normal(0, noise_var, size=N).T)
pos = ((x > 0) * (x < 0.3)).nonzero()[0]
x = np.delete(x, pos)
y = np.delete(y, pos)
randrange = range(10, 17)
y[randrange] = (y[randrange] + np.random.RandomState(1).normal(0, (4 ** 2), len(randrange)))
x = x.reshape((- 1), 1)
xtest = np.linspace((- 1), 1, 100).reshape((- 1), 1)
ytest = f(xtest)
param = Parameter(distribution='uniform', lower=(- 1), upper=1, order=n)
basis = Basis('univariate')
for method in methods:
for opt in opts:
if ((method != 'huber') and (opt != 'scipy')):
poly = Poly(parameters=param, basis=basis, method=method, sampling_args={'mesh': 'user-defined', 'sample-points': x.reshape((- 1), 1), 'sample-outputs': y.reshape((- 1), 1)}, solver_args={'M': (0.2 ** 2), 'verbose': False, 'optimiser': opt})
poly.set_model()
(_, r2) = poly.get_polyscore(X_test=xtest, y_test=ytest)
self.assertTrue((r2 > 0.997), msg=('Poly method = %a, optimiser = %a' % (method, opt)))
def test_ElasticNet_linear(self):
data = np.load('./tests/test_data/linear_data.npz')
X_train = data['X_train']
y_train = data['y_train']
X_test = data['X_test']
y_test = data['y_test']
s = Parameter(distribution='uniform', lower=(- 1), upper=1, order=1, endpoints='both')
param = [s for _ in range(X_train.shape[1])]
basis = Basis('total-order')
poly_OLS = Poly(parameters=param, basis=basis, method='least-squares', sampling_args={'mesh': 'user-defined', 'sample-points': X_train, 'sample-outputs': y_train.reshape((- 1), 1)})
poly_OLS.set_model()
(_, r2_OLS) = poly_OLS.get_polyscore(X_test=X_test, y_test=y_test)
poly_EN = poly = Poly(parameters=param, basis=basis, method='elastic-net', sampling_args={'mesh': 'user-defined', 'sample-points': X_train, 'sample-outputs': y_train.reshape((- 1), 1)}, solver_args={'path': False, 'lambda': 0.0, 'alpha': 0.5})
poly_EN.set_model()
(_, r2_EN) = poly_EN.get_polyscore(X_test=X_test, y_test=y_test)
np.testing.assert_array_almost_equal(r2_OLS, r2_EN, decimal=4, err_msg='Problem!')
poly_LASSO = Poly(parameters=param, basis=basis, method='elastic-net', sampling_args={'mesh': 'user-defined', 'sample-points': X_train, 'sample-outputs': y_train.reshape((- 1), 1)}, solver_args={'path': False, 'lambda': 0.015, 'alpha': 1.0})
poly_LASSO.set_model()
(_, r2_LASSO) = poly_LASSO.get_polyscore(X_test=X_test, y_test=y_test)
self.assertTrue((r2_LASSO > r2_OLS))
coeffs = poly_LASSO.get_coefficients().squeeze()
ideal_coeffs = 3
idx = np.abs(coeffs).argsort()[::(- 1)]
irrelevent_coeffs = (np.sum(np.abs(coeffs[idx[ideal_coeffs:]])) / np.sum(np.abs(coeffs)))
self.assertTrue((irrelevent_coeffs < 1e-05), msg=('irrelevent_coeffs = %.2e' % irrelevent_coeffs))
def test_ElasticNet_friedman(self):
data = np.load('./tests/test_data/friedman_data.npz')
X_train = data['X_train']
y_train = data['y_train']
X_test = data['X_test']
y_test = data['y_test']
s = Parameter(distribution='uniform', lower=(- 1), upper=1, order=2, endpoints='both')
param = [s for _ in range(X_train.shape[1])]
basis = Basis('total-order')
poly_OLS = Poly(parameters=param, basis=basis, method='least-squares', sampling_args={'mesh': 'user-defined', 'sample-points': X_train, 'sample-outputs': y_train.reshape((- 1), 1)})
poly_OLS.set_model()
(_, r2_OLS) = poly_OLS.get_polyscore(X_test=X_test, y_test=y_test)
print('running elastic net')
poly_LASSO = Poly(parameters=param, basis=basis, method='elastic-net', sampling_args={'mesh': 'user-defined', 'sample-points': X_train, 'sample-outputs': y_train.reshape((- 1), 1)}, solver_args={'path': True, 'alpha': 1.0})
poly_LASSO.set_model()
(_, r2_LASSO) = poly_LASSO.get_polyscore(X_test=X_test, y_test=y_test)
self.assertTrue((r2_LASSO > r2_OLS))
print(r2_LASSO, r2_OLS)
coeffs_OLS = poly_OLS.get_coefficients().squeeze()
coeffs_LASSO = poly_LASSO.get_coefficients().squeeze()
l1_OLS = np.linalg.norm(coeffs_OLS, ord=1)
l1_LASSO = np.linalg.norm(coeffs_LASSO, ord=1)
self.assertTrue((l1_LASSO < l1_OLS), msg=('l1_LASSO = %.2e, l1_OLS = %.2e' % (l1_LASSO, l1_OLS)))
def test_polyuq_empirical(self):
n = 1
data = np.load('./tests/test_data/linear_data.npz')
X_train = data['X_train']
y_train = data['y_train']
(N, dim) = X_train.shape
param = Parameter(distribution='Uniform', lower=(- 1), upper=1, order=n)
myParameters = [param for i in range(dim)]
myBasis = Basis('total-order')
poly = Poly(myParameters, myBasis, method='least-squares', sampling_args={'sample-points': X_train, 'sample-outputs': y_train.reshape((- 1), 1)})
poly.set_model()
(y_pred, y_std) = poly.get_polyfit(X_train, uq=True)
np.testing.assert_array_almost_equal(y_std.mean(), 0.67484, decimal=5, err_msg='Problem!')
def test_polyuq_prescribed(self):
dim = 1
n = 5
N = 100
our_function = (lambda x: (((((0.3 * (x ** 4)) - (1.6 * (x ** 3))) + (0.6 * (x ** 2))) + (2.4 * x)) - 0.5))
X = np.linspace((- 1), 1, N)
y = our_function(X)
y_var = ((0.1 * our_function(X)) * X)
param = Parameter(distribution='Uniform', lower=(- 1), upper=1, order=n)
myParameters = [param for i in range(dim)]
myBasis = Basis('univariate')
poly = Poly(myParameters, myBasis, method='least-squares', sampling_args={'sample-points': X.reshape((- 1), 1), 'sample-outputs': y.reshape((- 1), 1), 'sample-output-variances': y_var})
poly.set_model()
(y_pred, y_std) = poly.get_polyfit(X, uq=True)
np.testing.assert_array_almost_equal(y_std.mean(), 0.64015, decimal=5, err_msg='Problem!') |
def test_missing_other_thlr(tmpdir, merge_lis_prs, assert_log):
fpath = os.path.join(str(tmpdir), 'missing_other_th.lis')
content = ['data/lis/records/RHLR-1.lis.part', 'data/lis/records/THLR-1.lis.part', 'data/lis/records/FHLR-1.lis.part', 'data/lis/records/FTLR-1.lis.part', 'data/lis/records/TTLR-1.lis.part', 'data/lis/records/RTLR-1.lis.part', 'data/lis/records/RHLR-2.lis.part', 'data/lis/records/FHLR-2.lis.part', 'data/lis/records/FTLR-2.lis.part', 'data/lis/records/TTLR-2.lis.part', 'data/lis/records/RTLR-2.lis.part']
merge_lis_prs(fpath, content)
with lis.load(fpath) as (f1, f2, *tail):
assert (len(tail) == 0)
assert (f1.header().file_name == 'LISTST.001')
assert (f1.trailer().file_name == 'LISTST.001')
assert (f1.tape.header().prev_tape_name == (' ' * 8))
assert (f1.tape.trailer().next_tape_name == 'Tape0002')
assert (f1.reel.header().prev_reel_name == (' ' * 8))
assert (f1.reel.trailer().next_reel_name == 'Reel5678')
assert (f2.header().file_name == 'LISTST.002')
assert (f2.trailer().file_name == 'LISTST.002')
assert (f2.tape.header() == None)
assert_log('Missing Header Record')
assert (f2.tape.trailer().next_tape_name == (' ' * 8))
assert (f2.reel.header().prev_reel_name == 'Reel1234')
assert (f2.reel.trailer().next_reel_name == (' ' * 8)) |
def double_fpds_awards_with_same_special_case_recipients(award_count_sub_schedule, award_count_submission, defc_codes):
transaction_fpds_1 = baker.make('search.TransactionSearch', transaction_id=7, award_id=600, type='A', action_date='2022-05-01', fiscal_action_date='2022-09-01', is_fpds=True, recipient_name='MULTIPLE RECIPIENTS', recipient_unique_id='123', recipient_hash='01c03484-d1bd-41cc-2aca-4b427a2d0611')
_normal_faba(baker.make('search.AwardSearch', award_id=600, latest_transaction_id=transaction_fpds_1.transaction_id, type='A', action_date='2020-10-01', is_fpds=True, recipient_name='MULTIPLE RECIPIENTS', recipient_unique_id='123', recipient_hash='01c03484-d1bd-41cc-2aca-4b427a2d0611', disaster_emergency_fund_codes=['M'], total_covid_outlay=8, total_covid_obligation=0, covid_spending_by_defc=[{'defc': 'M', 'outlay': 8, 'obligation': 0}]))
transaction_fpds_2 = baker.make('search.TransactionSearch', transaction_id=8, award_id=700, type='A', action_date='2022-05-01', fiscal_action_date='2022-09-01', is_fpds=True, recipient_name='MULTIPLE RECIPIENTS', recipient_unique_id='456')
_normal_faba(baker.make('search.AwardSearch', award_id=700, latest_transaction_id=transaction_fpds_2.transaction_id, type='A', action_date='2020-10-01', is_fpds=True, recipient_name='MULTIPLE RECIPIENTS', recipient_unique_id='456', recipient_hash='1c4e7c2a-efe3-1b7e-2190-6f4487f808ac', disaster_emergency_fund_codes=['M'], total_covid_outlay=8, total_covid_obligation=0, covid_spending_by_defc=[{'defc': 'M', 'outlay': 8, 'obligation': 0}])) |
def test_generate_gpu_will_end_up_with_an_empty_scene(create_test_data, store_local_session, create_pymel, create_maya_env):
data = create_test_data
pm = create_pymel
gen = RepresentationGenerator(version=data['building1_yapi_model_main_v003'])
gen.generate_gpu()
assert (pm.sceneName() == '') |
def m2_tests(verbose=1):
if (verbose > 0):
print(('-' * 70))
print('Running TVTK tests.')
tests = find_tests(['tvtk'])
err = run(tests, verbose)
if (verbose > 0):
print(('-' * 70))
print('Running Mayavi tests.')
tests = find_tests(['mayavi'])
err += run(tests, verbose)
return err |
def test_nested_and_object_inner_doc():
class MySubDocWithNested(MyDoc):
nested_inner = field.Nested(MyInner)
props = MySubDocWithNested._doc_type.mapping.to_dict()['properties']
assert (props == {'created_at': {'type': 'date'}, 'inner': {'properties': {'old_field': {'type': 'text'}}, 'type': 'object'}, 'name': {'type': 'text'}, 'nested_inner': {'properties': {'old_field': {'type': 'text'}}, 'type': 'nested'}, 'title': {'type': 'keyword'}}) |
class Monitors(object):
swagger_types = {'embedded': 'MonitorsEmbedded'}
attribute_map = {'embedded': '_embedded'}
def __init__(self, embedded=None):
self._embedded = None
self.discriminator = None
if (embedded is not None):
self.embedded = embedded
def embedded(self):
return self._embedded
def embedded(self, embedded):
self._embedded = embedded
def to_dict(self):
result = {}
for (attr, _) in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map((lambda x: (x.to_dict() if hasattr(x, 'to_dict') else x)), value))
elif hasattr(value, 'to_dict'):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map((lambda item: ((item[0], item[1].to_dict()) if hasattr(item[1], 'to_dict') else item)), value.items()))
else:
result[attr] = value
if issubclass(Monitors, dict):
for (key, value) in self.items():
result[key] = value
return result
def to_str(self):
return pprint.pformat(self.to_dict())
def __repr__(self):
return self.to_str()
def __eq__(self, other):
if (not isinstance(other, Monitors)):
return False
return (self.__dict__ == other.__dict__)
def __ne__(self, other):
return (not (self == other)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.