code stringlengths 281 23.7M |
|---|
class BaseBuilder():
def __init__(self, manager: source_manager.SourceManager) -> None:
self._source_manager = manager
temp_dir = os.getenv('SALVO_HOMEDIR', constants.SALVO_TMP)
self._cache_dir = file_ops.get_random_dir(temp_dir)
self._build_dir = None
os.environ['HOME'] = self._cache_dir.name
log.debug(f"Using HOME={os.environ['HOME']}")
bazel_setup.setup_clang_env()
def set_build_dir(self, source_directory: str) -> None:
self._build_dir = source_directory
def _validate(self) -> None:
raise NotImplementedError('Method should be overridden')
def _run_bazel_clean(self) -> None:
assert self._build_dir
cmd_params = cmd_exec.CommandParameters(cwd=self._build_dir)
cmd = 'bazel clean'
output = cmd_exec.run_command(cmd, cmd_params)
log.debug(f'Clean output: {output}')
def _generate_bazel_options(self, source_id: proto_source.SourceRepository.SourceIdentity) -> str:
options = []
optimized_builds = True
source_repo = self._source_manager.get_source_repository(source_id)
bazel_options = source_repo.bazel_options
for option in bazel_options:
if (option.parameter not in options):
options.append(option.parameter)
if (optimized_builds and option.parameter.startswith('-c')):
optimized_builds = False
if optimized_builds:
options.append('-c opt')
return ' '.join(options) |
def get_download_fn(core, url, msgId):
params = {'msgid': msgId, 'skey': core.loginInfo['skey']}
headers = {'User-Agent': core.user_agent}
def download_fn(downloadDir=None):
r = core.s.get(url, params=params, stream=True, headers=headers)
tempStorage = io.BytesIO()
for block in r.iter_content(1024):
tempStorage.write(block)
if (downloadDir is None):
return tempStorage.getvalue()
with open(downloadDir, 'wb') as f:
f.write(tempStorage.getvalue())
tempStorage.seek(0)
return ReturnValue({'BaseResponse': {'ErrMsg': 'Successfully downloaded', 'Ret': 0}, 'PostFix': utils.get_image_postfix(tempStorage.read(20))})
return download_fn |
def diff_files(filen1, filen2, verbose=False):
reporter = Md5CheckReporter()
reporter.add_result(filen1, Md5Checker.md5cmp_files(filen1, filen2))
if verbose:
if reporter.n_ok:
print('OK: MD5 sums match')
elif reporter.n_failed:
print("FAILED: MD5 sums don't match")
else:
print('ERROR: unable to compute one or both MD5 sums')
return reporter.status |
_command
def trim_video(dm: DataManager, key: str, start: int=0, end: int=0, overwrite: bool=False):
ds = dm.datasets[key]
root = dm.get_local_data_path(key)
image_dir = (root / 'rgb_1x')
end = (end if (end > 0) else len(multi_glob_sorted(image_dir, ['*.png', '*.jpg'])))
def copy_files_trimmed(src: Path, dst: Path):
files = multi_glob_sorted(src, '*.*')
files = files[start:end]
dst.mkdir(parents=True, exist_ok=True)
for file in files:
if (isfile((dst / file.name)) and (not overwrite)):
continue
shutil.copy2(file, (dst / file.name))
out_root = (root.parent / f'{ds.video}_{start}_{end}')
logger.info('Copy images')
copy_files_trimmed(image_dir, (out_root / 'rgb_1x'))
logger.info('Copy flow')
copy_files_trimmed((root / 'flow/confidence'), (out_root / 'flow/confidence'))
copy_files_trimmed((root / 'flow/flow'), (out_root / 'flow/flow'))
for layer_dir in filter_dirs(multi_glob_sorted((root / 'masks'), '*/*')):
subpath = ((Path('masks') / layer_dir.parent.name) / layer_dir.name)
logger.info(f'Copy masks: {subpath}')
copy_files_trimmed(layer_dir, (out_root / subpath))
for pose_folder in ['colmap', 'rodynrf']:
if isdir((root / pose_folder)):
(out_root / pose_folder).mkdir(exist_ok=True)
poses = np.load(((root / pose_folder) / 'poses_bounds.npy'))[start:end]
logger.info(f'Save {pose_folder} poses ({poses.shape})')
np.save(((out_root / pose_folder) / 'poses_bounds.npy'), poses) |
class KeolisSTARStation(BikeShareStation):
def __init__(self, fields):
name = fields['nom']
(latitude, longitude) = map(float, fields['coordonnees'])
bikes = int(fields['nombrevelosdisponibles'])
free = int(fields['nombreemplacementsdisponibles'])
extra = {'slots': fields['nombreemplacementsactuels'], 'status': fields['etat'], 'uid': str(fields['idstation']), 'last_update': fields['lastupdate'], 'online': (fields['etat'] == 'En fonctionnement'), 'payment-terminal': True}
super(KeolisSTARStation, self).__init__(name, latitude, longitude, bikes, free, extra) |
class MultiPersonClassifier(object):
def __init__(self, model_path, classes):
self.dict_id2clf = {}
self._create_classifier = (lambda human_id: ClassifierOnlineTest(model_path, classes, WINDOW_SIZE, human_id))
def classify(self, dict_id2skeleton):
old_ids = set(self.dict_id2clf)
cur_ids = set(dict_id2skeleton)
humans_not_in_view = list((old_ids - cur_ids))
for human in humans_not_in_view:
del self.dict_id2clf[human]
id2label = {}
for (id, skeleton) in dict_id2skeleton.items():
if (id not in self.dict_id2clf):
self.dict_id2clf[id] = self._create_classifier(id)
classifier = self.dict_id2clf[id]
id2label[id] = classifier.predict(skeleton)
return id2label
def get_classifier(self, id):
if (len(self.dict_id2clf) == 0):
return None
if (id == 'min'):
id = min(self.dict_id2clf.keys())
return self.dict_id2clf[id] |
def test_data(flatpak_builder: FlatpakBuilder) -> None:
DATA_STR = 'abc'
DATA_BYTES = b'def\x00ghi'
with ManifestGenerator() as gen:
gen.add_data_source(DATA_STR, Path('str-file'))
gen.add_data_source(DATA_BYTES, Path('bytes-file'))
flatpak_builder.build(sources=gen.ordered_sources())
assert ((flatpak_builder.module_dir / 'str-file').read_text() == DATA_STR)
assert ((flatpak_builder.module_dir / 'bytes-file').read_bytes() == DATA_BYTES) |
def _livereload(host, port, languages, builder, site_dir):
_init_asyncio_patch()
from livereload import Server
import livereload.handlers
class LiveReloadServer(Server):
def _setup_logging(self):
logger = logging.getLogger('livereload')
logger.setLevel(logging.INFO)
return
def get_web_handlers(self, script):
handlers = []
for lang in languages:
handlers.append((f'/{lang}/(.*)', _get_handler(os.path.join(site_dir, lang), livereload.handlers.StaticFileHandler), {'path': os.path.join(site_dir, lang), 'default_filename': self.default_filename}))
handlers.append(('/(.*)', _get_redirect_handler(languages[0])))
return handlers
server = LiveReloadServer()
def full_builder_func():
for lang in languages:
builder(lang)
server.watch('shared', full_builder_func, delay=0)
for lang in languages:
server.watch(lang, create_builder(builder, lang), delay=0)
server.serve(root=site_dir, host=host, port=port, restart_delay=0) |
class Schedule(BaseObject):
def __init__(self, api=None, created_at=None, id=None, intervals=None, name=None, time_zone=None, updated_at=None, url=None, **kwargs):
self.api = api
self.created_at = created_at
self.id = id
self.intervals = intervals
self.name = name
self.time_zone = time_zone
self.updated_at = updated_at
self.url = url
for (key, value) in kwargs.items():
setattr(self, key, value)
for key in self.to_dict():
if (getattr(self, key) is None):
try:
self._dirty_attributes.remove(key)
except KeyError:
continue
def created(self):
if self.created_at:
return dateutil.parser.parse(self.created_at)
def created(self, created):
if created:
self.created_at = created
def updated(self):
if self.updated_at:
return dateutil.parser.parse(self.updated_at)
def updated(self, updated):
if updated:
self.updated_at = updated |
class TestDefaultSettingsUpdateHandler(object):
def test_raises_persistence_error_if_save_fails(self, mocker, user, plugin_manager):
settings_update = SettingsUpdate(language='python', theme='molokai')
db = mocker.Mock()
db.session.commit.side_effect = Exception('no')
hook_impl = mocker.Mock(spec=ChangeSetPostProcessor)
plugin_manager.register(self.impl(hook_impl))
handler = DefaultSettingsUpdateHandler(db=db, plugin_manager=plugin_manager)
with pytest.raises(PersistenceError) as excinfo:
handler.apply_changeset(user, settings_update)
assert ('Could not update settings' in str(excinfo.value))
hook_impl.post_process_changeset.assert_not_called()
def test_actually_updates_password(self, user, database, mocker, plugin_manager):
settings_update = SettingsUpdate(language='python', theme='molokai')
hook_impl = mocker.Mock(spec=ChangeSetPostProcessor)
plugin_manager.register(self.impl(hook_impl))
handler = DefaultSettingsUpdateHandler(db=database, plugin_manager=plugin_manager)
handler.apply_changeset(user, settings_update)
same_user = User.query.get(user.id)
assert (same_user.theme == 'molokai')
assert (same_user.language == 'python')
hook_impl.post_process_changeset.assert_called_once_with(user=user, settings_update=settings_update)
def impl(post_processor):
class Impl():
('flaskbb')
def flaskbb_settings_updated(self, user, settings_update):
post_processor.post_process_changeset(user=user, settings_update=settings_update)
return Impl() |
def unimorph2omor(unimorphstring):
unimorphs = unimorphstring.split(',')
omors = ''
for unimorph in unimorphs:
if ('pos' not in unimorph):
continue
if (unimorph in u2o):
omors += u2o[unimorph]
else:
print('missing', unimorph)
exit(1)
for unimorph in unimorphs:
if (('comp' not in unimorph) and ('voice' not in unimorph)):
continue
if (unimorph in u2o):
omors += u2o[unimorph]
else:
print('missing', unimorph)
exit(1)
for unimorph in unimorphs:
if (('mood' not in unimorph) and ('aspect' not in unimorph) and ('finite' not in unimorph)):
continue
if (unimorph in u2o):
omors += u2o[unimorph]
else:
print('missing', unimorph)
exit(1)
for unimorph in unimorphs:
if ('tense' not in unimorph):
continue
if (unimorph in u2o):
omors += u2o[unimorph]
else:
print('missing', unimorph)
exit(1)
for unimorph in unimorphs:
if ('per' not in unimorph):
continue
if (unimorph in u2o):
omors += u2o[unimorph]
else:
print('missing', unimorph)
exit(1)
for unimorph in unimorphs:
if ('num' not in unimorph):
continue
if (unimorph in u2o):
omors += u2o[unimorph]
else:
print('missing', unimorph)
exit(1)
for unimorph in unimorphs:
if ('case' not in unimorph):
continue
if (unimorph in u2o):
omors += u2o[unimorph]
else:
print('missing', unimorph)
exit(1)
omors = omors.replace('UPOS=ADJ][NUM', 'UPOS=ADJ][CMP=POS][NUM')
omors = omors.replace('UPOS=VERB][MOOD', 'UPOS=VERB][VOICE=ACT][MOOD')
omors = omors.replace('PERS=__1][NUM=SG]', 'PERS=SG1]')
omors = omors.replace('PERS=__2][NUM=SG]', 'PERS=SG2]')
omors = omors.replace('PERS=__3][NUM=SG]', 'PERS=SG3]')
omors = omors.replace('PERS=__1][NUM=PL]', 'PERS=PL1]')
omors = omors.replace('PERS=__2][NUM=PL]', 'PERS=PL2]')
omors = omors.replace('PERS=__3][NUM=PL]', 'PERS=PL3]')
omors = omors.replace('COND][TENSE=PAST]', 'COND]')
omors = omors.replace('IMPV][TENSE=PAST]', 'IMPV]')
omors = omors.replace('POTN][TENSE=PAST]', 'POTN]')
omors = omors.replace('IMPV][TENSE=PRESENT]', 'IMPV]')
omors = omors.replace('POTN][TENSE=PRESENT]', 'POTN]')
omors = omors.replace('COND][TENSE=PRESENT]', 'COND]')
omors = omors.replace('NUM=PL][CASE=COM]', 'CASE=COM]')
if ('VOICE=PSS' in omors):
omors += '[PERS=PE4]'
if (('CMP=SUP' in omors) or ('CMP=CMP' in omors)):
omors += '[NUM=SG][CASE=NOM]'
if ('CASE=ACC' in omors):
if ('NUM=SG' in omors):
omors = omors.replace('CASE=ACC', 'CASE=GEN')
elif ('NUM=PL' in omors):
omors = omors.replace('CASE=ACC', 'CASE=NOM')
else:
print('ARGEGEFREAFEFFWA')
exit(2)
if (('CASE=COM' in omors) and ('UPOS=NOUN' in omors)):
omors += '[POSS=3]'
return omors |
class MullerBrownSympyPot2D(AnaPotBase2D):
def __init__(self):
A = ((- 200), (- 100), (- 170), 15)
x0 = (1.0, 0.0, (- 0.5), (- 1.0))
y0 = (0.0, 0.5, 1.5, 1.0)
a = ((- 1.0), (- 1.0), (- 6.5), 0.7)
b = (0.0, 0.0, 11.0, 0.6)
c = ((- 10.0), (- 10.0), (- 6.5), 0.7)
V_str_base = '{Ai}*exp({ai}*(x-{xi})**2 + {bi}*(x-{xi})*(y-{yi}) + {ci}*(y-{yi})**2)'
V_str = ''
V_strs = [V_str_base.format(Ai=A[i], ai=a[i], xi=x0[i], bi=b[i], yi=y0[i], ci=c[i]) for i in range(4)]
V_str = ' + '.join(V_strs)
super(MullerBrownSympyPot2D, self).__init__(V_str=V_str)
def __str__(self):
return 'MullerBrownSympyPot2D calculator' |
def test():
dataset = []
for (key, value) in test_data:
if (len(value) == 2):
(e_chp, e_vol) = value
dataset.append((key, (e_vol, e_chp, None, None)))
elif (len(value) == 4):
(e_vol, e_chp, e_frag, e_post) = value
dataset.append((key, (e_vol, e_chp, e_frag, e_post)))
else:
print('Wat?', key, value)
print('Loaded {} item dataset'.format(len(dataset)))
dataset.sort(key=(lambda x: x[0]))
bins = {}
for row in dataset:
prefix = row[0].lower()
if prefix:
prefix = prefix[0]
bins.setdefault(prefix, [])
bins[prefix].append(row)
print('Prefix bins: {}'.format(len(bins)))
outdir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'title_data'))
print('Output dir:', outdir)
small_bin = []
for key in list(bins.keys()):
if (len(bins[key]) < 10):
dat = bins.pop(key)
small_bin.extend(dat)
bins['other'] = small_bin
print('Prefix bins after consolidation: {}'.format(len(bins)))
mod_list = []
for prefix in bins.keys():
mod = create_data_file(prefix, outdir, bins[prefix])
mod_list.append(mod)
load_test_data() |
class PrivateComputationPAforPDStageFlow(PrivateComputationBaseStageFlow):
_order_ = 'CREATED PC_PRE_VALIDATION PID_SHARD PID_PREPARE ID_MATCH ID_MATCH_POST_PROCESS ID_SPINE_COMBINER RESHARD PCF2_ATTRIBUTION PCF2_AGGREGATION ANONYMIZATION_DATA_PREP'
CREATED = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.CREATION_INITIALIZED, started_status=PrivateComputationInstanceStatus.CREATION_STARTED, completed_status=PrivateComputationInstanceStatus.CREATED, failed_status=PrivateComputationInstanceStatus.CREATION_FAILED, is_joint_stage=False)
PC_PRE_VALIDATION = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.PC_PRE_VALIDATION_INITIALIZED, started_status=PrivateComputationInstanceStatus.PC_PRE_VALIDATION_STARTED, completed_status=PrivateComputationInstanceStatus.PC_PRE_VALIDATION_COMPLETED, failed_status=PrivateComputationInstanceStatus.PC_PRE_VALIDATION_FAILED, is_joint_stage=False)
PID_SHARD = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.PID_SHARD_INITIALIZED, started_status=PrivateComputationInstanceStatus.PID_SHARD_STARTED, completed_status=PrivateComputationInstanceStatus.PID_SHARD_COMPLETED, failed_status=PrivateComputationInstanceStatus.PID_SHARD_FAILED, is_joint_stage=False)
PID_PREPARE = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.PID_PREPARE_INITIALIZED, started_status=PrivateComputationInstanceStatus.PID_PREPARE_STARTED, completed_status=PrivateComputationInstanceStatus.PID_PREPARE_COMPLETED, failed_status=PrivateComputationInstanceStatus.PID_PREPARE_FAILED, is_joint_stage=False)
ID_MATCH = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.ID_MATCHING_INITIALIZED, started_status=PrivateComputationInstanceStatus.ID_MATCHING_STARTED, completed_status=PrivateComputationInstanceStatus.ID_MATCHING_COMPLETED, failed_status=PrivateComputationInstanceStatus.ID_MATCHING_FAILED, is_joint_stage=True, is_retryable=True, timeout=DEFAULT_RUN_PID_TIMEOUT_IN_SEC)
ID_MATCH_POST_PROCESS = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.ID_MATCHING_POST_PROCESS_INITIALIZED, started_status=PrivateComputationInstanceStatus.ID_MATCHING_POST_PROCESS_STARTED, completed_status=PrivateComputationInstanceStatus.ID_MATCHING_POST_PROCESS_COMPLETED, failed_status=PrivateComputationInstanceStatus.ID_MATCHING_POST_PROCESS_FAILED, is_joint_stage=False)
ID_SPINE_COMBINER = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.ID_SPINE_COMBINER_INITIALIZED, started_status=PrivateComputationInstanceStatus.ID_SPINE_COMBINER_STARTED, completed_status=PrivateComputationInstanceStatus.ID_SPINE_COMBINER_COMPLETED, failed_status=PrivateComputationInstanceStatus.ID_SPINE_COMBINER_FAILED, is_joint_stage=False)
RESHARD = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.RESHARD_INITIALIZED, started_status=PrivateComputationInstanceStatus.RESHARD_STARTED, completed_status=PrivateComputationInstanceStatus.RESHARD_COMPLETED, failed_status=PrivateComputationInstanceStatus.RESHARD_FAILED, is_joint_stage=False)
PCF2_ATTRIBUTION = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.PCF2_ATTRIBUTION_INITIALIZED, started_status=PrivateComputationInstanceStatus.PCF2_ATTRIBUTION_STARTED, completed_status=PrivateComputationInstanceStatus.PCF2_ATTRIBUTION_COMPLETED, failed_status=PrivateComputationInstanceStatus.PCF2_ATTRIBUTION_FAILED, is_joint_stage=True)
PCF2_AGGREGATION = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.PCF2_AGGREGATION_INITIALIZED, started_status=PrivateComputationInstanceStatus.PCF2_AGGREGATION_STARTED, completed_status=PrivateComputationInstanceStatus.PCF2_AGGREGATION_COMPLETED, failed_status=PrivateComputationInstanceStatus.PCF2_AGGREGATION_FAILED, is_joint_stage=True)
ANONYMIZATION_DATA_PREP = PrivateComputationStageFlowData(initialized_status=PrivateComputationInstanceStatus.ANONYMIZATION_DATA_PREP_INITIALIZED, started_status=PrivateComputationInstanceStatus.ANONYMIZATION_DATA_PREP_STARTED, completed_status=PrivateComputationInstanceStatus.ANONYMIZATION_DATA_PREP_COMPLETED, failed_status=PrivateComputationInstanceStatus.ANONYMIZATION_DATA_PREP_FAILED, is_joint_stage=True)
def get_stage_service(self, args: PrivateComputationStageServiceArgs) -> PrivateComputationStageService:
if (self is self.PCF2_ATTRIBUTION):
return PCF2AttributionStageService(args.onedocker_binary_config_map, args.mpc_svc)
elif (self is self.PCF2_AGGREGATION):
return PCF2AggregationStageService(args.onedocker_binary_config_map, args.mpc_svc)
elif (self is self.ANONYMIZATION_DATA_PREP):
return AnonymizationDataPrepStageService(args.onedocker_svc, args.onedocker_binary_config_map)
else:
return self.get_default_stage_service(args) |
def _files_as_str(filenames: Union[(Path, str, List[Union[(Path, str)]])]) -> str:
if (isinstance(filenames, str) or isinstance(filenames, Path)):
return _render_path(filenames)
elif isinstance(filenames, list):
return '\n'.join([f' {_render_path(filename)}' for filename in filenames])
else:
raise TypeError() |
def proteusRun(runRoutines):
import optparse
if (sys.version_info[1] >= 5):
import cProfile as profiler
else:
import profile as profiler
import pstats
usage = 'usage: %prog [options] pFile.py [nFile.py]'
parser = optparse.OptionParser(usage=usage)
parser.add_option('-i', '--interactive', help='Read input from stdin', action='store_true', dest='interactive', default='')
parser.add_option('-M', '--masterModel', help='Set the model that controls the time step', action='store', type='int', dest='masterModel', default=0)
parser.add_option('-V', '--viewer', help='Set the application to use for viewing results. Can be gnuplot or matlab', action='store', type='string', dest='viewer', default=False)
parser.add_option('-b', '--batchFile', help='Read input from a file', action='store', type='string', dest='batchFileName', default='')
parser.add_option('-p', '--profile', help='Generate a profile of the run', action='store_true', dest='profile', default=False)
parser.add_option('-m', '--memory', help='Track memory usage of the run', action='callback', callback=Profiling.memProfOn_callback)
parser.add_option('-l', '--log', help='Store information about what the code is doing,0=none,10=everything', action='store', type='int', dest='logLevel', default=1)
parser.add_option('-v', '--verbose', help='Print logging information to standard out', action='callback', callback=Profiling.verboseOn_callback)
parser.add_option('-E', '--ensight', help='write data in ensight format', action='store_true', dest='ensight', default=False)
parser.add_option('-w', '--wait', help='stop after each time step', action='store_true', dest='wait', default=False)
parser.add_option('--probDir', default='.', help='where to find problem descriptions')
(opts, args) = parser.parse_args()
probDir = str(opts.probDir)
if (probDir not in sys.path):
sys.path.insert(0, probDir)
if (len(args) < 1):
raise RuntimeError('No input file specified')
if (len(args) > 1):
raise RuntimeError('Must specify so-file containing p and n filenames')
pList = []
nList = []
pNameList = []
soFile = open(args[0], 'r')
lines = soFile.readlines()
for mLine in lines:
filenames = mLine.split()
if (len(filenames) == 2):
pList.append(__import__(filenames[0][:(- 3)]))
pNameList.append((filenames[0][:(- 3)] + filenames[1][:(- 3)]))
nList.append(__import__(filenames[1][:(- 3)]))
if (opts.batchFileName != ''):
inputStream = open(opts.batchFileName, 'r')
else:
inputStream = sys.stdin
pNameAll = ''
for pName in pNameList:
pNameAll += pName
if (opts.logLevel > 0):
Profiling.openLog((pNameAll + '.log'), opts.logLevel)
if opts.viewer:
Viewers.viewerOn(pNameAll, opts.viewer)
running = True
while running:
if opts.interactive:
userInput = True
sys.stdout.write('Enter python commands or (s)tart/(q)quit\n>>>')
elif (opts.batchFileName != ''):
userInput = True
else:
userInput = False
run = True
running = False
while userInput:
line = inputStream.readline()
if line:
if ((line.split()[0] == 's') or (line.split()[0] == 'start')):
userInput = False
run = True
elif ((line.split()[0] == 'q') or (line.split()[0] == 'quit')):
userInput = False
run = False
running = False
else:
userInput = True
exec(line)
sys.stdout.write('>>>')
else:
userInput = False
run = False
running = False
if run:
if opts.profile:
profiler.runctx('runRoutines(pNameAll,pNameList,pList,nList,opts)', {'runRoutines': runRoutines}, {'pNameAll': pNameAll, 'pNameList': pNameList, 'pList': pList, 'nList': nList, 'opts': opts}, (pNameAll + '_prof'))
stats = pstats.Stats((pNameAll + '_prof'))
stats.strip_dirs()
stats.dump_stats((pNameAll + '_prof_c'))
stats.sort_stats('cumulative')
if Profiling.verbose:
stats.print_stats(30)
stats.sort_stats('time')
if Profiling.verbose:
stats.print_stats(30)
else:
runRoutines(pNameAll, pNameList, pList, nList, opts)
os.chdir('../../')
if opts.viewer:
input('\nPress return to close windows and exit... \n')
if (Viewers.viewerType == 'matlab'):
Viewers.viewerPipe.write('quit \n') |
('copr.v3.proxies.build.BuildProxy.get')
('copr_cli.main.config_from_file', return_value=mock_config)
def test_debug_by_status_response(config_from_file, build_proxy_get, capsys):
response_status = 'foobar'
build_proxy_get.return_value = MagicMock(state=response_status)
log = logging.getLogger()
old_handlers = list(log.handlers)
main.main(argv=['--debug', 'status', '123'])
(stdout, stderr) = capsys.readouterr()
assert ('{0}\n'.format(response_status) in stdout)
assert ('Debug log enabled ' in stderr)
log.handlers = old_handlers |
def init_node(ns, rate_node, node, inputs, outputs, feedthrough=tuple(), state_inputs=tuple(), targets=tuple()):
event_scheduler = EventLoopScheduler()
eps_disp = CompositeDisposable()
reset_disp = CompositeDisposable(eps_disp)
sync = node.sync
real_time_factor = node.real_time_factor
simulate_delays = node.simulate_delays
node_inputs = []
node_outputs = []
R = Subject()
reset_input = dict(name='reset', address=(ns + '/reset'), dtype='int64', msg=R)
node_inputs.append(reset_input)
RR = Subject()
real_reset_input = dict(name='real_reset', address=(ns + '/real_reset'), dtype='int64', msg=RR)
node_inputs.append(real_reset_input)
E = Subject()
end_reset = dict(name='end_reset', address=(ns + '/end_reset'), dtype='float64', msg=E)
node_inputs.append(end_reset)
node_reset = dict(name=node.ns_name, dtype='bool')
node_reset['address'] = (node.ns_name + '/end_reset')
node_reset['msg'] = Subject()
node_outputs.append(node_reset)
state_outputs = []
real_reset = (len(feedthrough) > 0)
assert ((not real_reset) or (real_reset and (len(targets) > 0))), 'Cannot initialize real reset node (%s). If len(feedthroughs) is provided, then len(targets) > 0. must hold.'
flags = []
for i in inputs:
Ir = Subject()
i['msg'] = Ir
Is = Subject()
i['reset'] = Is
flag = i['reset'].pipe(flag_dict(i['name']), ops.first(), ops.merge(rx.never()))
flags.append(flag)
for i in outputs:
i['msg'] = Subject()
i['reset'] = Subject()
for i in feedthrough:
Ar = Subject()
i['msg'] = Ar
As = Subject()
i['reset'] = As
flag = i['reset'].pipe(flag_dict(i['address']), ops.first(), ops.merge(rx.never()))
flags.append(flag)
for i in state_inputs:
S = Subject()
i['msg'] = S
D = Subject()
i['done'] = D
for i in targets:
S = Subject()
i['msg'] = S
D = Subject()
i['done'] = D
done_output = dict(name=i['name'], address=(i['address'] + '/done'), dtype='bool', msg=D)
state_outputs.append(done_output)
F_init = rx.zip(*flags).pipe(spy('zip', node), ops.map((lambda x: merge_dicts({}, x))))
F = Subject()
f = rx.merge(F, F_init)
ss_flags = init_state_inputs_channel(ns, state_inputs, event_scheduler, node=node)
(check_SS_CL, SS_CL, SS_CL_ho) = switch_with_check_pipeline(init_ho=ss_flags)
latched_ss_flags = rx.combine_latest(SS_CL, ss_flags).pipe(ops.map((lambda x: x[1])), ops.take(1))
(check_SS, SS, SS_ho) = switch_with_check_pipeline(init_ho=latched_ss_flags)
Rn_ho = BehaviorSubject(BehaviorSubject((0, 0, True)))
Rn = Rn_ho.pipe(ops.switch_latest(), ops.map((lambda x: x[0])))
Rr = R.pipe(ops.map((lambda x: True)))
RrRn = rx.zip(Rr.pipe(spy('Rr', node)), Rn.pipe(spy('Rn', node))).pipe(ops.map((lambda x: x[1])), spy('SEND_FLAGS', node), ops.share())
for i in outputs:
d = RrRn.subscribe(i['reset'])
reset_disp.add(d)
reset_trigger = rx.zip(RrRn, f.pipe(spy('F', node)), SS.pipe(spy('SS', node))).pipe(with_latest_from(SS_CL), ops.map((lambda x: (x[0][:(- 1)] + (x[1],)))), spy('RENEW_PIPE', node), ops.map((lambda x: x[(- 1)])), ops.share())
reset_obs = reset_trigger.pipe(ops.map((lambda x: init_node_pipeline(ns, rate_node, node, inputs, outputs, F, SS_ho, SS_CL_ho, R, RR, E, real_reset, feedthrough, state_inputs, state_outputs, targets, cb_ft, sync, real_time_factor, simulate_delays, eps_disp, event_scheduler=event_scheduler))), trace_observable('init_node_pipeline', node), ops.share())
d = reset_obs.pipe(ops.pluck('Rn')).subscribe(Rn_ho)
reset_disp.add(d)
reset_msg = reset_obs.pipe(ops.pluck('dispose'), ops.buffer_with_count(2, skip=1), ops.start_with(None), ops.zip(reset_trigger, Rn_ho.pipe(ops.skip(1)), check_SS, check_SS_CL), ops.map((lambda x: x[1])), ops.share(), spy('RESET', node, log_level=DEBUG), ops.map((lambda x: node.reset_cb(**x))), trace_observable('cb_reset', node), ops.share())
d = reset_msg.pipe(ops.map((lambda x: True))).subscribe(node_reset['msg'])
reset_disp.add(d)
rx_objects = dict(inputs=inputs, outputs=outputs, feedthrough=feedthrough, state_inputs=state_inputs, state_outputs=state_outputs, targets=targets, node_inputs=node_inputs, node_outputs=node_outputs, disposable=reset_disp)
return rx_objects |
def merge(left, right):
if (len(left) == 0):
return right
if (len(right) == 0):
return left
result = []
index_left = index_right = 0
while (len(result) < (len(left) + len(right))):
if (left[index_left] <= right[index_right]):
result.append(left[index_left])
index_left += 1
else:
result.append(right[index_right])
index_right += 1
if (index_right == len(right)):
result += left[index_left:]
break
if (index_left == len(left)):
result += right[index_right:]
break
return result |
def brain_check(speed, salts):
logger.debug('Running brain check')
logger.debug('Salts Count: {}'.format(salts))
logger.debug('Relative estimated speed: {}'.format(speed))
if (salts > 0):
if ((speed / salts) < 500000):
logger.debug('Brain engaged!')
brain = True
else:
brain = False
logger.debug('Brain disabled due to bottleneck (fast candidates)')
elif (speed < 500000):
logger.debug('Brain engaged!')
brain = True
else:
brain = False
logger.debug('Brain disabled due to bottleneck (fast candidates)')
return brain |
class BuildExecutor(metaclass=abc.ABCMeta):
def __subclasshook__(cls, subclass):
return ((hasattr(subclass, 'run') and callable(subclass.run)) or NotImplemented)
def __init__(self):
self._transition_state = BenchmarkTransitionState.RUN
self._resume_op_run_id = None
self._stop_op_run_id = None
def run(self, op_config: OperatorConfig, build_input_config: Dict[(str, Any)], config_build_id: str):
raise NotImplementedError
def set_resume_op_run_id(self, resume_op_run_id: str):
logger.debug(f'resume_op_run_id: {resume_op_run_id}')
self._resume_op_run_id = resume_op_run_id
if self._resume_op_run_id:
self._transition_state = BenchmarkTransitionState.SKIP
logger.debug(f'_resume_op_run_id: {self._resume_op_run_id}')
logger.debug(f'_transition_state: {self._transition_state}')
def set_stop_op_run_id(self, stop_op_run_id: str):
logger.debug(f'stop_op_run_id: {stop_op_run_id}')
self._stop_op_run_id = stop_op_run_id
logger.debug(f'_stop_op_run_id: {self._stop_op_run_id}')
logger.debug(f'_transition_state: {self._transition_state}')
def get_transition_state(self, op_run_id: str):
if (self._transition_state == BenchmarkTransitionState.SKIP):
if (op_run_id == self._resume_op_run_id):
self._transition_state = BenchmarkTransitionState.RUN
logger.info(f'Resume benchmark check matched [{op_run_id}]')
if (op_run_id == self._stop_op_run_id):
self._transition_state = BenchmarkTransitionState.STOP
logger.info(f'Stop benchmark check matched [{op_run_id}]')
logger.debug(f'op_run_id: {op_run_id}')
logger.debug(f'_transition_state: {self._transition_state}')
return self._transition_state |
class SpoofAttributes():
def __init__(self, spoof_target: Union[(SignedTransactionAPI, UnsignedTransactionAPI)], **overrides: Any) -> None:
self.spoof_target = spoof_target
self.overrides = overrides
if ('from_' in overrides):
if hasattr(spoof_target, 'sender'):
raise TypeError('A from_ parameter can only be supplied when the spoof target does not have a sender attribute. SpoofTransaction will not attempt to override the sender of a signed transaction.')
overrides['sender'] = overrides['from_']
overrides['get_sender'] = (lambda : overrides['from_'])
for (attr, value) in SPOOF_ATTRIBUTES_DEFAULTS.items():
if (not hasattr(spoof_target, attr)):
overrides[attr] = value
def __getattr__(self, attr: str) -> Any:
if (attr in self.overrides):
return self.overrides[attr]
else:
return getattr(self.spoof_target, attr)
def copy(self: T, **kwargs: Any) -> T:
new_target = self.spoof_target.copy(**kwargs)
new_overrides = merge(self.overrides, kwargs)
return type(self)(new_target, **new_overrides) |
class RemoteValidator(RemoteConnector):
def __init__(self, parse_config: bool=False):
super(RemoteValidator, self).__init__(parse_config=parse_config)
_property
def get_validate_methods(self) -> List[str]:
exempt = ('validate_rule', 'validate_rules')
methods = [m for m in self.__dir__() if (m.startswith('validate_') and (m not in exempt))]
return methods
def get_validate_method(self, name: str) -> callable:
assert (name in self.get_validate_methods), f'validate method {name} not found'
return getattr(self, name)
def prep_for_preview(contents: TOMLRuleContents) -> dict:
end_time = datetime.utcnow().isoformat()
dumped = contents.to_api_format().copy()
dumped.update(timeframeEnd=end_time, invocationCount=1)
return dumped
def engine_preview(self, contents: TOMLRuleContents) -> dict:
dumped = self.prep_for_preview(contents)
return self.kibana_client.post('/api/detection_engine/rules/preview', json=dumped)
def validate_rule(self, contents: TOMLRuleContents) -> RemoteValidationResult:
method = self.get_validate_method(f'validate_{contents.data.type}')
query_results = method(contents)
engine_results = self.engine_preview(contents)
rule_version = contents.autobumped_version
stack_version = load_current_package_version()
return RemoteValidationResult(contents.data.rule_id, contents.data.name, contents.to_api_format(), rule_version, stack_version, query_results, engine_results)
def validate_rules(self, rules: List[TOMLRule], threads: int=5) -> Dict[(str, RemoteValidationResult)]:
responses = {}
def request(c: TOMLRuleContents):
try:
responses[c.data.rule_id] = self.validate_rule(c)
except ValidationError as e:
responses[c.data.rule_id] = e.messages
pool = ThreadPool(processes=threads)
pool.map(request, [r.contents for r in rules])
pool.close()
pool.join()
return responses
def validate_esql(self, contents: TOMLRuleContents) -> dict:
query = contents.data.query
rule_id = contents.data.rule_id
headers = {'accept': 'application/json', 'content-type': 'application/json'}
body = {'query': f'{query} | LIMIT 0'}
try:
response = self.es_client.perform_request('POST', '/_query', headers=headers, params={'pretty': True}, body=body)
except Exception as exc:
if isinstance(exc, elasticsearch.BadRequestError):
raise ValidationError(f'''ES|QL query failed: {exc} for rule: {rule_id}, query:
{query}''')
else:
raise Exception(f'''ES|QL query failed for rule: {rule_id}, query:
{query}''') from exc
return response.body
def validate_eql(self, contents: TOMLRuleContents) -> dict:
query = contents.data.query
rule_id = contents.data.rule_id
index = contents.data.index
time_range = {'range': {'': {'gt': 'now-1h/h', 'lte': 'now', 'format': 'strict_date_optional_time'}}}
body = {'query': query}
try:
response = self.es_client.eql.search(index=index, body=body, ignore_unavailable=True, filter=time_range)
except Exception as exc:
if isinstance(exc, elasticsearch.BadRequestError):
raise ValidationError(f'''EQL query failed: {exc} for rule: {rule_id}, query:
{query}''')
else:
raise Exception(f'''EQL query failed for rule: {rule_id}, query:
{query}''') from exc
return response.body
def validate_query(self, contents: TOMLRuleContents) -> dict:
return {'results': 'Unable to remote validate query rules'}
def validate_threshold(self, contents: TOMLRuleContents) -> dict:
return {'results': 'Unable to remote validate threshold rules'}
def validate_new_terms(self, contents: TOMLRuleContents) -> dict:
return {'results': 'Unable to remote validate new_terms rules'}
def validate_threat_match(self, contents: TOMLRuleContents) -> dict:
return {'results': 'Unable to remote validate threat_match rules'}
def validate_machine_learning(self, contents: TOMLRuleContents) -> dict:
return {'results': 'Unable to remote validate machine_learning rules'} |
def test_disposing_method_handler2():
class Foo(event.Component):
('xx')
def handle_xx(self, *events):
pass
foo = Foo()
assert foo.get_event_handlers('xx')
foo.emit('xx', {})
foo_ref = weakref.ref(foo)
del foo
gc.collect()
assert (foo_ref() is not None)
loop.iter()
gc.collect()
assert (foo_ref() is None) |
class OptionSeriesSankeySonificationTracksMappingLowpass(Options):
def frequency(self) -> 'OptionSeriesSankeySonificationTracksMappingLowpassFrequency':
return self._config_sub_data('frequency', OptionSeriesSankeySonificationTracksMappingLowpassFrequency)
def resonance(self) -> 'OptionSeriesSankeySonificationTracksMappingLowpassResonance':
return self._config_sub_data('resonance', OptionSeriesSankeySonificationTracksMappingLowpassResonance) |
def _load_cached_results(filename: str) -> Dict[(str, CachedResult)]:
with open(filename) as f:
content = f.read()
loaded = yaml.safe_load(content)
assert isinstance(loaded, dict), f'Wrong format: {content}'
results = {filename: CachedResult(**result_dic) for (filename, result_dic) in loaded.items()}
return results |
def unwrap_workflow_trigger_list_response(response):
if (response.return_code == str(SUCCESS)):
trigger_list_proto = Parse(response.data, WorkflowTriggerListProto())
return ProtoToMeta.proto_to_workflow_trigger_meta_list(trigger_list_proto.workflow_triggers)
elif (response.return_code == str(RESOURCE_DOES_NOT_EXIST)):
return None
else:
raise AIFlowException(response.error_msg) |
class NodeArraySetElement(NodeArrayElement):
def __init__(self, ids_map_list, token_id, node_expression_index, assign_token, node_expression_value):
Node.__init__(self, ids_map_list)
self.token_id = token_id
self.node_expression_index = node_expression_index
if (assign_token.data == '='):
self.assign_token = assign_token
self.node_expression_value = node_expression_value
else:
assert (assign_token.data in ['+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '&=', '|=', '^='])
self.assign_token = Token(Token.ASSIGN, assign_token.line, assign_token.column, data='=')
op_node = self.assign_token_to_op_token(assign_token)
op_node.left = NodeArrayGetElement(self.ids_map_list, token_id, node_expression_index)
op_node.right = node_expression_value
self.node_expression_value = op_node
def get_code(self, current_pointer, *args, **kwargs):
code = self.node_expression_index.get_code(current_pointer)
code += '[-]'
code += '>'
code += self.node_expression_value.get_code((current_pointer + 2))
code += '<<<'
code += '['
code += '>>>'
code += '[-]'
code += '<'
code += '[>+<-]'
code += '<'
code += '+'
code += '[>+<-]'
code += '<'
code += '-'
code += '[>+<-]'
code += '>'
code += ']'
code += '>>'
code += get_copy_to_variable_code(self.ids_map_list, self.token_id, (current_pointer + 2))
code += '[<<+>>-]'
code += '<'
code += '['
code += '<'
code += '[<+>-]'
code += '>'
code += '-'
code += '[<+>-]'
code += '<'
code += ']'
return code |
def test_from_file_warns(any_well, tmp_path):
if (version.parse(xtgeo_version) < version.parse('2.16')):
pytest.skip()
any_well.to_file((tmp_path / 'mywell.w'))
with pytest.warns(DeprecationWarning, match='from_file is deprecated'):
any_well.from_file((tmp_path / 'mywell.w')) |
.skipif(('pandas' not in sys.modules), reason='Pandas is not installed.')
def test_pd_dataframe_hash():
import pandas as pd
def hash_pd_dataframe(df: pd.DataFrame) -> str:
return str(pd.util.hash_pandas_object(df))
def uncached_data_reading_task() -> Annotated[(pd.DataFrame, HashMethod(hash_pd_dataframe))]:
return pd.DataFrame({'column_1': [1, 2, 3]})
(cache=True, cache_version='0.1')
def cached_data_processing_task(data: pd.DataFrame) -> pd.DataFrame:
global n_cached_task_calls
n_cached_task_calls += 1
return (data * 2)
def my_workflow():
raw_data = uncached_data_reading_task()
cached_data_processing_task(data=raw_data)
assert (n_cached_task_calls == 0)
my_workflow()
assert (n_cached_task_calls == 1)
my_workflow()
assert (n_cached_task_calls == 1) |
class Factory(Generic[T]):
def __init__(self, fake: Opt[FakerFactory]=None):
self.fake = (fake or FakerFactory.create(locale))
self.field_types = field_mappings.mappings_types
self.field_names = field_mappings.mappings_names
def _serialize_instance(self, instance: models.Model) -> FieldMap:
model_fields = dict(get_model_fields(instance))
attrs: FieldMap = {}
for (k, v) in model_to_dict(instance).items():
if (k == instance._meta.pk.name):
continue
if isinstance(v, (list, models.QuerySet)):
continue
if (isinstance(model_fields[k], models.ForeignKey) and (not isinstance(v, models.Model))):
attrs[(k + '_id')] = v
continue
attrs[k] = v
return attrs
def seed(self, seed: Seed, set_global: bool=False) -> None:
self.fake.seed(seed)
if set_global:
random.seed(seed)
def blueprint(self, model: Union[(str, models.Model)], *args, **kwargs) -> Blueprint:
return Blueprint(get_model(model), *args, **kwargs)
def build_one(self, model: str, fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], seed: Opt[Seed], make_fks: bool, iteration: Opt[int]) -> LazyBuilt:
pass
def build_one(self, model: T, fields: Opt[FieldMap], pre_save: Opt[SaveHooks], seed: Opt[Seed], make_fks: bool, iteration: Opt[int]) -> Built:
pass
def build_one(self, model, fields=None, pre_save=None, seed=None, make_fks=False, iteration=None):
if (fields is None):
fields = {}
if (pre_save is None):
pre_save = []
if seed:
fake = FakerFactory.create(locale)
fake.seed(seed)
else:
fake = self.fake
evaluator = Evaluator(fake, factory=self, iteration=iteration, mappings_types=self.field_types, mappings_names=self.field_names)
model = get_model(model)
instance = model()
m2ms = {}
lazies = []
model_fields = get_model_fields(model)
for (_field_name, model_field) in model_fields:
value = Empty
field_name = _field_name
if (_field_name.endswith('_id') and model_field.is_relation):
continue
if isinstance(model_field, models.AutoField):
continue
if isinstance(model_field, (GenericForeignKey, GenericRelation)):
continue
if ((field_name not in fields) and (model_field.null or (model_field.default != NOT_PROVIDED))):
continue
if ((field_name not in fields) and isinstance(model_field, models.ManyToManyField)):
continue
value = fields.get(field_name, Empty)
if isinstance(model_field, models.ForeignKey):
if (value is Empty):
value = fields.get((field_name + '_id'), Empty)
if (value == rels.SELECT):
model = model_field.related_model
qs = model.objects.all()
cache_key = model
value = fks_cache.get(cache_key, Empty)
if (value is Empty):
try:
value = qs[0]
except IndexError:
value = evaluator.fake_value(model, model_field)
fks_cache[cache_key] = value
if ((not make_fks) and ((value is Empty) or (value and (value.pk is None)))):
raise ForeignKeyError("Field {} is a required ForeignKey, but the related {}.{} model doesn't have the necessary primary key.".format(field_name, model_field.related_model._meta.app_label, model_field.related_model._meta.model_name))
field_name += '_id'
if (value is not Empty):
value = evaluator.evaluate(value)
elif model_field.choices:
value = fake.random_element(model_field.choices)[0]
else:
value = evaluator.fake_value(model, model_field)
if isinstance(value, Lazy):
lazies.append((field_name, value))
continue
if isinstance(model_field, models.ForeignKey):
value = (value.pk if hasattr(value, 'pk') else value)
if isinstance(model_field, models.ManyToManyField):
m2ms[field_name] = value
if ((model == user_model) and (field_name == 'password')):
instance.set_password(value)
elif (field_name not in m2ms):
setattr(instance, field_name, value)
for (field_name, lazy) in lazies:
value = getattr(instance, lazy.name)
if callable(value):
value = value(*lazy.args, **lazy.kwargs)
setattr(instance, field_name, value)
for func in pre_save:
func(instance)
return (instance, m2ms)
def build(self, model: str, fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: None, make_fks: bool) -> LazyBuilt:
pass
def build(self, model: T, fields: Opt[FieldMap], pre_save: Opt[SaveHooks], seed: Opt[SaveHooks], quantity: None, make_fks: bool) -> Built:
pass
def build(self, model: str, fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: int, make_fks: bool) -> List[LazyBuilt]:
pass
def build(self, model: T, fields: Opt[FieldMap], pre_save: Opt[SaveHooks], seed: Opt[Seed], quantity: Opt[int], make_fks: bool) -> List[Built]:
pass
def build(self, model, fields=None, pre_save=None, seed=None, quantity=None, make_fks=False):
if (fields is None):
fields = {}
if (quantity is None):
return self.build_one(model, fields, pre_save, seed, make_fks)[0]
else:
return [self.build_one(model, fields, pre_save, seed, make_fks, i)[0] for i in range(quantity)]
def make_one(self, model: str, fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed], iteration: Opt[int]) -> models.Model:
pass
def make_one(self, model: T, fields: Opt[FieldMap], pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed], iteration: Opt[int]) -> T:
pass
def make_one(self, model, fields=None, pre_save=None, post_save=None, seed=None, iteration=None):
if (fields is None):
fields = {}
if (post_save is None):
post_save = []
(instance, m2ms) = self.build_one(model, fields, pre_save, seed, make_fks=True, iteration=iteration)
instance.save(force_insert=True)
for (field, relateds) in m2ms.items():
set_related(instance, field, relateds)
for func in post_save:
func(instance)
return instance
def get_or_make(self, model: str, lookup: Opt[Lookup], fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed]) -> Tuple[(models.Model, bool)]:
pass
def get_or_make(self, model: T, lookup: Opt[Lookup], fields: Opt[FieldMap], pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed]) -> Tuple[(T, bool)]:
pass
def get_or_make(self, model, lookup=None, fields=None, pre_save=None, post_save=None, seed=None):
if (lookup is None):
lookup = {}
if (fields is None):
fields = {}
if (post_save is None):
post_save = []
(instance, m2ms) = self.build_one(model, fields, pre_save, seed, make_fks=True)
attrs = self._serialize_instance(instance)
for k in lookup:
attrs.pop(k, None)
(instance, created) = get_model(model).objects.get_or_create(defaults=attrs, **lookup)
for (field, relateds) in m2ms.items():
set_related(instance, field, relateds)
for func in post_save:
func(instance)
return (instance, created)
def g_m(self, model: str, lookup: Opt[Lookup], pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed]) -> Callable[(..., models.Model)]:
pass
def g_m(self, model: T, lookup: Opt[Lookup], pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed]) -> Callable[(..., T)]:
pass
def g_m(self, model, lookup=None, pre_save=None, post_save=None, seed=None):
build = partial(self.get_or_make, model=model, lookup=lookup, pre_save=pre_save, post_save=post_save, seed=seed)
def fn(**kwargs):
return build(fields=kwargs)
return fn
def update_or_make(self, model: str, lookup: Opt[Lookup], fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed]) -> Tuple[(models.Model, bool)]:
pass
def update_or_make(self, model: T, lookup: Opt[Lookup], fields: Opt[FieldMap], pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed]) -> Tuple[(T, bool)]:
pass
def update_or_make(self, model, lookup=None, fields=None, pre_save=None, post_save=None, seed=None):
if (lookup is None):
lookup = {}
if (fields is None):
fields = {}
if (post_save is None):
post_save = []
model_class = get_model(model)
try:
instance = model_class.objects.get(**lookup)
except model_class.DoesNotExist:
created = True
params = {k: v for (k, v) in lookup.items() if ('__' not in k)}
params.update(fields)
instance = self.make(model, params, pre_save, post_save, seed)
else:
created = False
for (k, v) in fields.items():
if ((model_class == user_model) and (k == 'password')):
instance.set_password(v)
else:
setattr(instance, k, v)
instance.save()
for func in post_save:
func(instance)
return (instance, created)
def u_m(self, model: str, lookup: Opt[Lookup], pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed]) -> Callable[(..., models.Model)]:
pass
def u_m(self, model: T, lookup: Opt[Lookup], pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed]) -> Callable[(..., T)]:
pass
def u_m(self, model, lookup=None, pre_save=None, post_save=None, seed=None):
build = partial(self.update_or_make, model=model, lookup=lookup, pre_save=pre_save, post_save=post_save, seed=seed)
def fn(**kwargs):
return build(fields=kwargs)
return fn
def make(self, model: str, fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: None) -> models.Model:
pass
def make(self, model: T, fields: Opt[FieldMap], pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed], quantity: None) -> T:
pass
def make(self, model: str, fields: Opt[FieldMap], pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: Opt[int]) -> List[models.Model]:
pass
def make(self, model: T, fields: Opt[FieldMap], pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed], quantity: Opt[int]) -> List[T]:
pass
def make(self, model, fields=None, pre_save=None, post_save=None, seed=None, quantity=None):
if (fields is None):
fields = {}
if (quantity is None):
return self.make_one(model, fields, pre_save, post_save, seed)
else:
return [self.make_one(model, fields, pre_save, post_save, seed, i) for i in range(quantity)]
def m(self, model: str, pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: None) -> Callable[(..., models.Model)]:
pass
def m(self, model: T, pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed], quantity: None) -> Callable[(..., T)]:
pass
def m(self, model: str, pre_save: Opt[LazySaveHooks], post_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: Opt[int]) -> Callable[(..., List[models.Model])]:
pass
def m(self, model: T, pre_save: Opt[SaveHooks], post_save: Opt[SaveHooks], seed: Opt[Seed], quantity: Opt[int]) -> Callable[(..., List[T])]:
pass
def m(self, model, pre_save=None, post_save=None, seed=None, quantity=None):
make = partial(self.make, model=model, pre_save=pre_save, post_save=post_save, seed=seed, quantity=quantity)
def fn(**kwargs):
return make(fields=kwargs)
return fn
def b(self, model: str, pre_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: None, make_fks: bool) -> Callable[(..., LazyBuilt)]:
pass
def b(self, model: T, pre_save: Opt[SaveHooks], seed: Opt[Seed], quantity: None, make_fks: bool) -> Callable[(..., Built)]:
pass
def b(self, model: str, pre_save: Opt[LazySaveHooks], seed: Opt[Seed], quantity: Opt[int], make_fks: bool) -> Callable[(..., List[LazyBuilt])]:
pass
def b(self, model: T, pre_save: Opt[SaveHooks], seed: Opt[Seed], quantity: Opt[int], make_fks: bool) -> Callable[(..., List[Built])]:
pass
def b(self, model, pre_save=None, seed=None, quantity=None, make_fks=False):
build = partial(self.build, model=model, pre_save=pre_save, seed=seed, quantity=quantity, make_fks=make_fks)
def fn(**kwargs):
return build(fields=kwargs)
return fn |
class free_count(bsn_tlv):
type = 215
def __init__(self, value=None):
if (value != None):
self.value = value
else:
self.value = 0
return
def pack(self):
packed = []
packed.append(struct.pack('!H', self.type))
packed.append(struct.pack('!H', 0))
packed.append(struct.pack('!L', self.value))
length = sum([len(x) for x in packed])
packed[1] = struct.pack('!H', length)
return ''.join(packed)
def unpack(reader):
obj = free_count()
_type = reader.read('!H')[0]
assert (_type == 215)
_length = reader.read('!H')[0]
orig_reader = reader
reader = orig_reader.slice(_length, 4)
obj.value = reader.read('!L')[0]
return obj
def __eq__(self, other):
if (type(self) != type(other)):
return False
if (self.value != other.value):
return False
return True
def pretty_print(self, q):
q.text('free_count {')
with q.group():
with q.indent(2):
q.breakable()
q.text('value = ')
q.text(('%#x' % self.value))
q.breakable()
q.text('}') |
()
('-i', '--interactive', is_flag=True)
('query', required=False)
('paths', type=click.Path(exists=True), nargs=(- 1), required=False)
def do(interactive: bool, query: str, paths: List[str]) -> None:
if ((not query) or (query == '-')):
namespace = {'Query': Query, 'START': START, 'SYMBOL': SYMBOL, 'TOKEN': TOKEN}
try:
import IPython
IPython.start_ipython(argv=[], user_ns=namespace)
except ImportError:
import code as _code
_code.interact(local=namespace)
finally:
return
code = compile(query, '<console>', 'eval')
result = eval(code)
if isinstance(result, Query):
if result.retcode:
exc = click.ClickException('query failed')
exc.exit_code = result.retcode
raise exc
result.diff(interactive=interactive)
elif result:
click.echo(repr(result)) |
def test_flash(app, mocker):
mock_flash = mocker.patch('flask_simplelogin.flash')
app.extensions['simplelogin'].flash('login_success')
app.extensions['simplelogin'].flash('login_failure')
app.extensions['simplelogin'].flash('auth_error', 'nasty bug')
mock_flash.assert_has_calls((call('login success!', 'success'), call('invalid credentials', 'danger'), call('Authentication Error: nasty bug', 'primary'))) |
class TestNestedDefaultFromConfig():
def arg_builder(monkeypatch):
with monkeypatch.context() as m:
m.setattr(sys, 'argv', ['', '--config', './tests/conf/yaml/test_nested.yaml'])
config = ConfigArgBuilder(Train, TrainProcess, AnotherNested, desc='Test Builder')
return config.generate()
def test_default_nesting(self, arg_builder):
assert (arg_builder.Train.train_process.nest.something == 1)
assert (arg_builder.Train.train_process.epochs == 5) |
class TestCamera(object):
def test_film_advance_increments_counter(self):
c = Camera()
c.film_advance_mechanism.advance()
c.exposure_control_system.shutter.trip()
assert (c.frame_counter == 1)
def test_selected_shutter_speeds_are_applied(self):
c = Camera()
c.shutter_speed = (1 / 500)
assert (c.exposure_control_system.shutter.timer == (1 / 512))
c.shutter_speed = (1 / 15)
assert (c.exposure_control_system.shutter.timer == (1 / 16))
c.shutter_speed = (1 / 125)
assert (c.exposure_control_system.shutter.timer == (1 / 128))
with pytest.raises(c.NonExistentShutterSpeed):
c.shutter_speed = (1 / 10)
def test_selected_film_speeds_are_applied(self):
c = Camera()
c.film_speed = 400
assert (c.film_speed == 400)
with pytest.raises(c.NonExistentFilmSpeed):
c.film_speed = 130
def test_selected_aperture_settings_are_applied_to_exposure_control_system(self):
c = Camera()
c.aperture = 8
assert (c.exposure_control_system.aperture_set_lever.aperture == 8)
def test_selected_aperture_settings_are_applied_when_shutter_is_cocked(self):
c = Camera()
c.exposure_control_system.shutter.cocked = True
c.aperture = 8
assert (c.exposure_control_system.iris.aperture == 8)
c.aperture = 2
assert (c.exposure_control_system.iris.aperture == 2)
c.aperture = 16
assert (c.exposure_control_system.iris.aperture == 16)
def test_only_decreasing_aperture_settings_are_applied_when_shutter_is_uncocked(self):
c = Camera()
c.exposure_control_system.shutter.cocked = False
c.aperture = 8
c.exposure_control_system.iris.aperture = 8
assert (c.exposure_control_system.iris.aperture == 8)
c.aperture = 2
assert (c.exposure_control_system.iris.aperture == 8)
c.aperture = 16
assert (c.exposure_control_system.iris.aperture == 16)
def test_aperture_setting_is_applied_as_soon_as_shutter_is_cocked(self):
c = Camera()
c.exposure_control_system.shutter.cocked = False
c.aperture = 8
c.exposure_control_system.iris.aperture = 16
assert (c.exposure_control_system.iris.aperture == 16)
c.exposure_control_system.shutter.cock()
assert (c.exposure_control_system.iris.aperture == 8)
def test_invalid_aperture_settings_are_rejected(self):
c = Camera()
with pytest.raises(c.ApertureOutOfRange):
c.aperture = 1.2
with pytest.raises(c.ApertureOutOfRange):
c.aperture = 22 |
def get_device(cf):
device_type = cf.get('device_type', 'lookup')
if (device_type == 'lookup'):
local_address = cf.get('local_address', None)
lookup_timeout = cf.get('lookup_timeout', 20)
devices = (broadlink.discover(timeout=lookup_timeout) if (local_address is None) else broadlink.discover(timeout=lookup_timeout, local_ip_address=local_address))
if (len(devices) == 0):
logging.error('No Broadlink device found')
sys.exit(2)
if (len(devices) > 1):
logging.error((('More than one Broadlink device found (' + ', '.join([((((d.type + '/') + d.host[0]) + '/') + ':'.join((format(s, '02x') for s in d.mac[::(- 1)]))) for d in devices])) + ')'))
sys.exit(2)
return configure_device(devices[0], topic_prefix)
elif (device_type == 'multiple_lookup'):
local_address = cf.get('local_address', None)
lookup_timeout = cf.get('lookup_timeout', 20)
devices = (broadlink.discover(timeout=lookup_timeout) if (local_address is None) else broadlink.discover(timeout=lookup_timeout, local_ip_address=local_address))
if (len(devices) == 0):
logging.error('No Broadlink devices found')
sys.exit(2)
mqtt_multiple_prefix_format = cf.get('mqtt_multiple_subprefix_format', None)
devices_dict = {}
for device in devices:
mqtt_subprefix = mqtt_multiple_prefix_format.format(type=device.type, host=device.host[0], mac='_'.join((format(s, '02x') for s in device.mac)), mac_nic='_'.join((format(s, '02x') for s in device.mac[3:])))
device = configure_device(device, (topic_prefix + mqtt_subprefix))
devices_dict[mqtt_subprefix] = device
return devices_dict
elif (device_type == 'test'):
return configure_device(TestDevice(cf), topic_prefix)
else:
host = (cf.get('device_host'), 80)
mac = bytearray.fromhex(cf.get('device_mac').replace(':', ' '))
if (device_type == 'rm'):
device = broadlink.rm(host=host, mac=mac, devtype=10002)
elif (device_type == 'rm4'):
device = broadlink.rm4(host=host, mac=mac, devtype=20954)
elif (device_type == 'sp1'):
device = broadlink.sp1(host=host, mac=mac, devtype=0)
elif (device_type == 'sp2'):
device = broadlink.sp2(host=host, mac=mac, devtype=10001)
elif (device_type == 'sp3s'):
device = broadlink.sp3s(host=host, mac=mac, devtype=38010)
elif (device_type == 'a1'):
device = broadlink.a1(host=host, mac=mac, devtype=10004)
elif (device_type == 'mp1'):
device = broadlink.mp1(host=host, mac=mac, devtype=20149)
elif (device_type == 'dooya'):
device = broadlink.dooya(host=host, mac=mac, devtype=20045)
elif (device_type == 'bg1'):
device = broadlink.bg1(host=host, mac=mac, devtype=20963)
else:
logging.error(('Incorrect device configured: ' + device_type))
sys.exit(2)
return configure_device(device, topic_prefix) |
class AbstractPersistentModel(ABC):
def __init__(self):
self._state = None
def __repr__(self):
return f'{type(self).__name__}(state={self.state})'
def state(self):
if (self._state is None):
self._state = self._read_state()
return self._state
def state(self, value):
self._state = value
self._write_state(value)
def _read_state(self):
...
def _write_state(self, value):
... |
class strip_vlan_on_egress(bsn_tlv):
type = 73
def __init__(self, flags=None):
if (flags != None):
self.flags = flags
else:
self.flags = 0
return
def pack(self):
packed = []
packed.append(struct.pack('!H', self.type))
packed.append(struct.pack('!H', 0))
packed.append(struct.pack('!B', self.flags))
length = sum([len(x) for x in packed])
packed[1] = struct.pack('!H', length)
return ''.join(packed)
def unpack(reader):
obj = strip_vlan_on_egress()
_type = reader.read('!H')[0]
assert (_type == 73)
_length = reader.read('!H')[0]
orig_reader = reader
reader = orig_reader.slice(_length, 4)
obj.flags = reader.read('!B')[0]
return obj
def __eq__(self, other):
if (type(self) != type(other)):
return False
if (self.flags != other.flags):
return False
return True
def pretty_print(self, q):
q.text('strip_vlan_on_egress {')
with q.group():
with q.indent(2):
q.breakable()
q.text('flags = ')
value_name_map = {1: 'OFP_BSN_STRIP_VLAN_FIRST', 2: 'OFP_BSN_STRIP_VLAN_SECOND', 4: 'OFP_BSN_STRIP_VLAN_THIRD'}
q.text(util.pretty_flags(self.flags, value_name_map.values()))
q.breakable()
q.text('}') |
def dipole3d_00(ax, da, A, bx, db, B, R):
result = numpy.zeros((3, 1, 1), dtype=float)
x0 = ((ax + bx) ** (- 1.0))
x1 = ((ax * bx) * x0)
x2 = ((((5. * da) * db) * (x0 ** 1.5)) * numpy.exp(((- x1) * ((((A[0] - B[0]) ** 2) + ((A[1] - B[1]) ** 2)) + ((A[2] - B[2]) ** 2)))))
result[(0, 0, 0)] = numpy.sum((x2 * ((x0 * ((ax * A[0]) + (bx * B[0]))) - R[0])))
result[(1, 0, 0)] = numpy.sum((x2 * ((x0 * ((ax * A[1]) + (bx * B[1]))) - R[1])))
result[(2, 0, 0)] = numpy.sum((x2 * ((x0 * ((ax * A[2]) + (bx * B[2]))) - R[2])))
return result |
class OptionPlotoptionsVectorSonificationTracksPointgrouping(Options):
def algorithm(self):
return self._config_get('minmax')
def algorithm(self, text: str):
self._config(text, js_type=False)
def enabled(self):
return self._config_get(True)
def enabled(self, flag: bool):
self._config(flag, js_type=False)
def groupTimespan(self):
return self._config_get(15)
def groupTimespan(self, num: float):
self._config(num, js_type=False)
def prop(self):
return self._config_get('y')
def prop(self, text: str):
self._config(text, js_type=False) |
class OptionPlotoptionsPackedbubbleSonificationDefaultinstrumentoptionsMappingLowpassResonance(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
class Softplus(Fixed):
codomain = constraints.positive
def _forward(self, x: torch.Tensor, params: Optional[Sequence[torch.Tensor]]) -> Tuple[(torch.Tensor, Optional[torch.Tensor])]:
y = F.softplus(x)
ladj = self._log_abs_det_jacobian(x, y, params)
return (y, ladj)
def _inverse(self, y: torch.Tensor, params: Optional[Sequence[torch.Tensor]]) -> Tuple[(torch.Tensor, Optional[torch.Tensor])]:
x = flowtorch.ops.softplus_inv(y)
ladj = self._log_abs_det_jacobian(x, y, params)
return (x, ladj)
def _log_abs_det_jacobian(self, x: torch.Tensor, y: torch.Tensor, params: Optional[Sequence[torch.Tensor]]) -> torch.Tensor:
return (- F.softplus((- x))) |
('cuda.bmm_rrr_permute.gen_profiler')
def gen_profiler(func_attrs, workdir, profiler_filename, dim_info_dict):
a_dims = bmm_common.reverse_dim_info_mapping(dim_info_dict, gemm_common.Source.INPUT, 0)
b_dims = bmm_common.reverse_dim_info_mapping(dim_info_dict, gemm_common.Source.INPUT, 1)
c_dims = bmm_common.reverse_dim_info_mapping(dim_info_dict, gemm_common.Source.OUTPUT, 0)
args_parser = bmm_common.ARGS_PARSER_TEMPLATE.render(a_dims=a_dims, b_dims=b_dims, c_dims=c_dims)
default_mm_info = bmm_common.get_default_problem_info(PROBLEM_ARGS, alpha_value=func_attrs.get('alpha', 1))
a_shapes = func_attrs['input_accessors'][0].original_shapes
b_shapes = func_attrs['input_accessors'][1].original_shapes
bmm_common._update_stride_info(default_mm_info, a_shapes, b_shapes)
problem_args = bmm_common.PROBLEM_ARGS_TEMPLATE.render(mm_info=default_mm_info)
return bmm_permute_common.gen_profiler(func_attrs, workdir, profiler_filename, dim_info_dict, common.SRC_TEMPLATE, problem_args, args_parser, emit_kernel=True, extra_code=common_permute.EXTRA_CODE.render()) |
def test_background_task(test_client_factory):
accessed_error_handler = False
def error_handler(request, exc):
nonlocal accessed_error_handler
accessed_error_handler = True
def raise_exception():
raise Exception('Something went wrong')
async def endpoint(request):
task = BackgroundTask(raise_exception)
return Response(status_code=204, background=task)
app = Starlette(routes=[Route('/', endpoint=endpoint)], exception_handlers={Exception: error_handler})
client = test_client_factory(app, raise_server_exceptions=False)
response = client.get('/')
assert (response.status_code == 204)
assert accessed_error_handler |
class FutureResponse(object):
def __init__(self, callback=None, timeout=None):
self._timeout = timeout
self._response = None
self._lock = threading.Condition()
self._callback = callback
def set_response(self, response):
try:
if (self._callback is not None):
self._callback(response)
except Exception as ex:
traceback.print_exc()
finally:
self._lock.acquire()
self._response = response
self._lock.notifyAll()
self._lock.release()
def get_response(self):
self._lock.acquire()
if (self._response is not None):
self._lock.release()
return self._response
self._lock.wait(self._timeout)
self._lock.release()
return self._response
response = property(get_response, set_response) |
_dict
def __contains__(self, other):
if (not isinstance(other, self.__class__)):
raise TypeError(("unsupported operand type(s) for 'in': '%s' and '%s'" % (type(other).__name__, self.__class__.__name__)))
if ((other._value_ == 0) or (self._value_ == 0)):
return False
return ((other._value_ & self._value_) == other._value_) |
class DaapLibrary(collection.Library):
def __init__(self, daap_share, col=None):
location = (' % (daap_share.server, daap_share.port))
collection.Library.__init__(self, location)
self.daap_share = daap_share
def rescan(self, notify_interval=None, force_update=False):
if (self.collection is None):
return True
if self.scanning:
return
t = time.time()
logger.info(('Scanning library: %s' % self.daap_share.name))
self.scanning = True
self.daap_share.reload()
if self.daap_share.all:
count = len(self.daap_share.all)
else:
count = 0
if (count > 0):
logger.info(('Adding %d tracks from %s. (%f s)' % (count, self.daap_share.name, (time.time() - t))))
self.collection.add_tracks(self.daap_share.all)
if (notify_interval is not None):
event.log_event('tracks_scanned', self, count)
self.scanning = False
def _count_files(self):
count = 0
if self.daap_share:
count = len(self.daap_share.all)
return count |
def test_default_sort():
(app, db, admin) = setup()
(M1, _) = create_models(db)
M1(test1='c', test2='x').save()
M1(test1='b', test2='x').save()
M1(test1='a', test2='y').save()
assert (M1.objects.count() == 3)
view = CustomModelView(M1, column_default_sort='test1')
admin.add_view(view)
(_, data) = view.get_list(0, None, None, None, None)
assert (data[0].test1 == 'a')
assert (data[1].test1 == 'b')
assert (data[2].test1 == 'c')
order = [('test2', False), ('test1', False)]
view2 = CustomModelView(M1, column_default_sort=order, endpoint='m1_2')
admin.add_view(view2)
(_, data) = view2.get_list(0, None, None, None, None)
assert (len(data) == 3)
assert (data[0].test1 == 'b')
assert (data[1].test1 == 'c')
assert (data[2].test1 == 'a') |
class Declarative(metaclass=DeclarativeMeta):
__unpackargs__ = ()
__mutableattributes__ = ()
__singletonmethods__ = ()
counter = count()
def __classinit__(cls, new_attrs):
pass
def __init__(self, *args, **kw):
if (self.__unpackargs__ and (self.__unpackargs__[0] == '*')):
assert (len(self.__unpackargs__) == 2), ("When using __unpackargs__ = ('*', varname), you must only provide a single variable name (you gave %r)" % self.__unpackargs__)
name = self.__unpackargs__[1]
if (name in kw):
if args:
raise TypeError(("keyword parameter '%s' was given by position and name" % name))
else:
kw[name] = args
else:
if (len(args) > len(self.__unpackargs__)):
raise TypeError(('%s() takes at most %i arguments (%i given)' % (self.__class__.__name__, len(self.__unpackargs__), len(args))))
for (name, arg) in zip(self.__unpackargs__, args):
if (name in kw):
raise TypeError(("keyword parameter '%s' was given by position and name" % name))
kw[name] = arg
for name in self.__mutableattributes__:
if (name not in kw):
setattr(self, name, copy.copy(getattr(self, name)))
for (name, value) in kw.items():
setattr(self, name, value)
if ('declarative_count' not in kw):
self.declarative_count = next(self.counter)
self.__initargs__(kw)
def __initargs__(self, new_attrs):
pass
def __call__(self, *args, **kw):
current = self.__dict__.copy()
current.update(kw)
return self.__class__(*args, **current)
def singleton(cls):
name = ('_%s__singleton' % cls.__name__)
if (not hasattr(cls, name)):
try:
setattr(cls, name, cls(declarative_count=cls.declarative_count))
except TypeError:
setattr(cls, name, cls)
return getattr(cls, name)
def __sourcerepr__(self, source, binding=None):
if (binding and (len(self.__dict__) > 3)):
return self._source_repr_class(source, binding=binding)
vals = self.__dict__.copy()
if ('declarative_count' in vals):
del vals['declarative_count']
args = []
if (self.__unpackargs__ and (self.__unpackargs__[0] == '*') and (self.__unpackargs__[1] in vals)):
v = vals[self.__unpackargs__[1]]
if isinstance(v, (list, int)):
args.extend(list(map(source.makeRepr, v)))
del v[self.__unpackargs__[1]]
for name in self.__unpackargs__:
if (name in vals):
args.append(source.makeRepr(vals[name]))
del vals[name]
else:
break
args.extend((('%s=%s' % (name, source.makeRepr(value))) for (name, value) in vals.items()))
return ('%s(%s)' % (self.__class__.__name__, ', '.join(args)))
def _source_repr_class(self, source, binding=None):
d = self.__dict__.copy()
if ('declarative_count' in d):
del d['declarative_count']
return source.makeClass(self, binding, d, (self.__class__,))
def __classsourcerepr__(cls, source, binding=None):
d = cls.__dict__.copy()
del d['declarative_count']
return source.makeClass(cls, (binding or cls.__name__), d, cls.__bases__)
def __repr__(self, cls):
if self:
name = ('%s object' % self.__class__.__name__)
v = self.__dict__.copy()
else:
name = ('%s class' % cls.__name__)
v = cls.__dict__.copy()
if ('declarative_count' in v):
name = ('%s %i' % (name, v.pop('declarative_count')))
names = sorted(v)
args = [(('%s=self' % n) if (v[n] is self) else ('%s=%r' % (n, v[n]))) for n in self._repr_vars(names)]
if (not args):
return ('<%s>' % name)
return ('<%s %s>' % (name, ' '.join(args)))
def _repr_vars(dictNames):
return sorted((n for n in dictNames if ((not n.startswith('_')) and (n != 'declarative_count')))) |
def analyze_read_segments(primary, supplementaries, bam, options):
read_name = primary.query_name
alignments = ([primary] + supplementaries)
alignment_list = []
for alignment in alignments:
if alignment.is_reverse:
inferred_read_length = alignment.infer_read_length()
if (inferred_read_length is None):
logging.warning('Skipping alignment because pysam was unable to infer length of read from CIGAR string (alignment.infer_read_length() returned None). Query name: {0}, CIGAR: {1}'.format(alignment.query_name, alignment.cigarstring))
continue
q_start = (inferred_read_length - alignment.query_alignment_end)
q_end = (inferred_read_length - alignment.query_alignment_start)
else:
q_start = alignment.query_alignment_start
q_end = alignment.query_alignment_end
new_alignment_dict = {'q_start': q_start, 'q_end': q_end, 'ref_id': alignment.reference_id, 'ref_start': alignment.reference_start, 'ref_end': alignment.reference_end, 'is_reverse': alignment.is_reverse}
alignment_list.append(new_alignment_dict)
sorted_alignment_list = sorted(alignment_list, key=(lambda aln: (aln['q_start'], aln['q_end'])))
sv_signatures = []
translocation_signatures_all_bnds = []
tandem_duplications = []
translocations = []
for index in range((len(sorted_alignment_list) - 1)):
alignment_current = sorted_alignment_list[index]
alignment_next = sorted_alignment_list[(index + 1)]
distance_on_read = (alignment_next['q_start'] - alignment_current['q_end'])
if (alignment_current['ref_id'] == alignment_next['ref_id']):
ref_chr = bam.getrname(alignment_current['ref_id'])
if (alignment_current['is_reverse'] == alignment_next['is_reverse']):
if alignment_current['is_reverse']:
distance_on_reference = (alignment_current['ref_start'] - alignment_next['ref_end'])
else:
distance_on_reference = (alignment_next['ref_start'] - alignment_current['ref_end'])
if (distance_on_read >= (- options.segment_overlap_tolerance)):
if (distance_on_reference >= (- options.segment_overlap_tolerance)):
deviation = (distance_on_read - distance_on_reference)
if (deviation >= options.min_sv_size):
if (distance_on_reference <= options.segment_gap_tolerance):
if (not alignment_current['is_reverse']):
try:
insertion_seq = primary.query_sequence[alignment_current['q_end']:(alignment_current['q_end'] + deviation)]
except TypeError:
insertion_seq = ''
sv_signatures.append(SignatureInsertion(ref_chr, alignment_current['ref_end'], (alignment_current['ref_end'] + deviation), 'suppl', read_name, insertion_seq))
else:
try:
insertion_seq = primary.query_sequence[(primary.infer_read_length() - alignment_next['q_start']):((primary.infer_read_length() - alignment_next['q_start']) + deviation)]
except TypeError:
insertion_seq = ''
sv_signatures.append(SignatureInsertion(ref_chr, alignment_current['ref_start'], (alignment_current['ref_start'] + deviation), 'suppl', read_name, insertion_seq))
elif ((- options.max_sv_size) <= deviation <= (- options.min_sv_size)):
if (distance_on_read <= options.segment_gap_tolerance):
if (not alignment_current['is_reverse']):
sv_signatures.append(SignatureDeletion(ref_chr, alignment_current['ref_end'], (alignment_current['ref_end'] - deviation), 'suppl', read_name))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, (alignment_current['ref_end'] - deviation), 'fwd', 'suppl', read_name))
else:
sv_signatures.append(SignatureDeletion(ref_chr, alignment_next['ref_end'], (alignment_next['ref_end'] - deviation), 'suppl', read_name))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, (alignment_next['ref_end'] - 1), 'fwd', ref_chr, (alignment_next['ref_end'] - deviation), 'fwd', 'suppl', read_name))
elif (deviation < (- options.max_sv_size)):
if (distance_on_read <= options.segment_gap_tolerance):
if (not alignment_current['is_reverse']):
sv_signatures.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
translocations.append(('fwd', 'fwd', ref_chr, (alignment_current['ref_end'] - 1), ref_chr, alignment_next['ref_start']))
else:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
translocations.append(('rev', 'rev', ref_chr, alignment_current['ref_start'], ref_chr, (alignment_next['ref_end'] - 1)))
elif (distance_on_reference <= (- options.min_sv_size)):
if (not alignment_current['is_reverse']):
if (alignment_next['ref_end'] > alignment_current['ref_start']):
tandem_duplications.append((ref_chr, alignment_next['ref_start'], alignment_current['ref_end'], True, True))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
elif (distance_on_reference >= (- options.max_sv_size)):
tandem_duplications.append((ref_chr, alignment_next['ref_start'], alignment_current['ref_end'], False, True))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
else:
sv_signatures.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
translocations.append(('fwd', 'fwd', ref_chr, (alignment_current['ref_end'] - 1), ref_chr, alignment_next['ref_start']))
elif (alignment_next['ref_start'] < alignment_current['ref_end']):
tandem_duplications.append((ref_chr, alignment_current['ref_start'], alignment_next['ref_end'], True, False))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
elif (distance_on_reference >= (- options.max_sv_size)):
tandem_duplications.append((ref_chr, alignment_current['ref_start'], alignment_next['ref_end'], False, False))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
else:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
translocations.append(('rev', 'rev', ref_chr, alignment_current['ref_start'], ref_chr, (alignment_next['ref_end'] - 1)))
else:
if ((not alignment_current['is_reverse']) and alignment_next['is_reverse']):
if ((- options.segment_overlap_tolerance) <= distance_on_read <= options.segment_gap_tolerance):
if ((alignment_next['ref_start'] - alignment_current['ref_end']) >= (- options.segment_overlap_tolerance)):
if (options.min_sv_size <= (alignment_next['ref_end'] - alignment_current['ref_end']) <= options.max_sv_size):
sv_signatures.append(SignatureInversion(ref_chr, alignment_current['ref_end'], alignment_next['ref_end'], 'suppl', read_name, 'left_fwd'))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
elif ((alignment_next['ref_end'] - alignment_current['ref_end']) > options.max_sv_size):
sv_signatures.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
translocations.append(('fwd', 'rev', ref_chr, (alignment_current['ref_end'] - 1), ref_chr, (alignment_next['ref_end'] - 1)))
elif ((alignment_current['ref_start'] - alignment_next['ref_end']) >= (- options.segment_overlap_tolerance)):
if (options.min_sv_size <= (alignment_current['ref_end'] - alignment_next['ref_end']) <= options.max_sv_size):
sv_signatures.append(SignatureInversion(ref_chr, alignment_next['ref_end'], alignment_current['ref_end'], 'suppl', read_name, 'left_rev'))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
elif ((alignment_current['ref_end'] - alignment_next['ref_end']) > options.max_sv_size):
sv_signatures.append(SignatureTranslocation(ref_chr, (alignment_current['ref_end'] - 1), 'fwd', ref_chr, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
translocations.append(('fwd', 'rev', ref_chr, (alignment_current['ref_end'] - 1), ref_chr, (alignment_next['ref_end'] - 1)))
else:
pass
if (alignment_current['is_reverse'] and (not alignment_next['is_reverse'])):
if ((- options.segment_overlap_tolerance) <= distance_on_read <= options.segment_gap_tolerance):
if ((alignment_next['ref_start'] - alignment_current['ref_end']) >= (- options.segment_overlap_tolerance)):
if (options.min_sv_size <= (alignment_next['ref_start'] - alignment_current['ref_start']) <= options.max_sv_size):
sv_signatures.append(SignatureInversion(ref_chr, alignment_current['ref_start'], alignment_next['ref_start'], 'suppl', read_name, 'right_fwd'))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
elif ((alignment_next['ref_start'] - alignment_current['ref_start']) > options.max_sv_size):
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
translocations.append(('rev', 'fwd', ref_chr, alignment_current['ref_start'], ref_chr, alignment_next['ref_start']))
elif ((alignment_current['ref_start'] - alignment_next['ref_end']) >= (- options.segment_overlap_tolerance)):
if (options.min_sv_size <= (alignment_current['ref_start'] - alignment_next['ref_start']) <= options.max_sv_size):
sv_signatures.append(SignatureInversion(ref_chr, alignment_next['ref_start'], alignment_current['ref_start'], 'suppl', read_name, 'right_rev'))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
elif ((alignment_current['ref_start'] - alignment_next['ref_start']) > options.max_sv_size):
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
translocations.append(('rev', 'fwd', ref_chr, alignment_current['ref_start'], ref_chr, alignment_next['ref_start']))
else:
pass
else:
ref_chr_current = bam.getrname(alignment_current['ref_id'])
ref_chr_next = bam.getrname(alignment_next['ref_id'])
if (alignment_current['is_reverse'] == alignment_next['is_reverse']):
if (distance_on_read >= (- options.segment_overlap_tolerance)):
if (distance_on_read <= options.segment_gap_tolerance):
if (not alignment_current['is_reverse']):
sv_signatures.append(SignatureTranslocation(ref_chr_current, (alignment_current['ref_end'] - 1), 'fwd', ref_chr_next, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
translocations.append(('fwd', 'fwd', ref_chr_current, (alignment_current['ref_end'] - 1), ref_chr_next, alignment_next['ref_start']))
else:
sv_signatures.append(SignatureTranslocation(ref_chr_current, alignment_current['ref_start'], 'rev', ref_chr_next, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
translocations.append(('rev', 'rev', ref_chr_current, alignment_current['ref_start'], ref_chr_next, (alignment_next['ref_end'] - 1)))
else:
pass
elif (distance_on_read >= (- options.segment_overlap_tolerance)):
if (distance_on_read <= options.segment_gap_tolerance):
if (not alignment_current['is_reverse']):
sv_signatures.append(SignatureTranslocation(ref_chr_current, (alignment_current['ref_end'] - 1), 'fwd', ref_chr_next, (alignment_next['ref_end'] - 1), 'rev', 'suppl', read_name))
translocations.append(('fwd', 'rev', ref_chr_current, (alignment_current['ref_end'] - 1), ref_chr_next, (alignment_next['ref_end'] - 1)))
else:
sv_signatures.append(SignatureTranslocation(ref_chr_current, alignment_current['ref_start'], 'rev', ref_chr_next, alignment_next['ref_start'], 'fwd', 'suppl', read_name))
translocations.append(('rev', 'fwd', ref_chr_current, alignment_current['ref_start'], ref_chr_next, alignment_next['ref_start']))
else:
pass
current_chromosome = None
current_starts = []
current_ends = []
current_copy_number = 0
current_fully_covered = []
for tandem_duplication in tandem_duplications:
if (current_chromosome == None):
current_chromosome = tandem_duplication[0]
current_starts.append(tandem_duplication[1])
current_ends.append(tandem_duplication[2])
current_copy_number = 1
current_fully_covered.append(tandem_duplication[3])
current_direction = tandem_duplication[4]
elif (is_similar(current_chromosome, mean(current_starts), mean(current_ends), tandem_duplication[0], tandem_duplication[1], tandem_duplication[2]) and (current_direction == tandem_duplication[4])):
current_starts.append(tandem_duplication[1])
current_ends.append(tandem_duplication[2])
current_copy_number += 1
current_fully_covered.append(tandem_duplication[3])
else:
fully_covered = (True if sum(current_fully_covered) else False)
sv_signatures.append(SignatureDuplicationTandem(current_chromosome, int(mean(current_starts)), int(mean(current_ends)), current_copy_number, fully_covered, 'suppl', read_name))
current_chromosome = tandem_duplication[0]
current_starts = [tandem_duplication[1]]
current_ends = [tandem_duplication[2]]
current_copy_number = 1
current_fully_covered = [tandem_duplication[3]]
if (current_chromosome != None):
fully_covered = (True if sum(current_fully_covered) else False)
sv_signatures.append(SignatureDuplicationTandem(current_chromosome, int(mean(current_starts)), int(mean(current_ends)), current_copy_number, fully_covered, 'suppl', read_name))
for this_index in range(len(translocations)):
this_dir1 = translocations[this_index][0]
this_dir2 = translocations[this_index][1]
this_chr1 = translocations[this_index][2]
this_pos1 = translocations[this_index][3]
this_chr2 = translocations[this_index][4]
this_pos2 = translocations[this_index][5]
for (before_dir1, before_dir2, before_chr1, before_pos1, before_chr2, before_pos2) in translocations[:this_index]:
if ((before_dir1 == this_dir2) and (before_dir2 == this_dir1)):
if is_similar(before_chr1, before_pos1, (before_pos1 + 1), this_chr2, this_pos2, (this_pos2 + 1), span_position_treshold=0.1):
if (before_chr2 == this_chr1):
if (before_dir2 == before_dir1):
if (before_dir1 == 'fwd'):
if (options.min_sv_size <= ((this_pos1 - before_pos2) + 1) <= options.max_sv_size):
sv_signatures.append(SignatureInsertionFrom(before_chr2, before_pos2, (this_pos1 + 1), before_chr1, int(mean([(before_pos1 + 1), this_pos2])), 'suppl', read_name))
elif (before_dir1 == 'rev'):
if (options.min_sv_size <= (before_pos2 - this_pos1) <= options.max_sv_size):
sv_signatures.append(SignatureInsertionFrom(before_chr2, this_pos1, (before_pos2 + 1), before_chr1, int(mean([before_pos1, (this_pos2 + 1)])), 'suppl', read_name))
else:
pass
return (sv_signatures, translocation_signatures_all_bnds) |
class OptionSeriesScatterTooltip(Options):
def clusterFormat(self):
return self._config_get('Clustered points: {point.clusterPointsAmount}')
def clusterFormat(self, text: str):
self._config(text, js_type=False)
def dateTimeLabelFormats(self) -> 'OptionSeriesScatterTooltipDatetimelabelformats':
return self._config_sub_data('dateTimeLabelFormats', OptionSeriesScatterTooltipDatetimelabelformats)
def distance(self):
return self._config_get(16)
def distance(self, num: float):
self._config(num, js_type=False)
def followPointer(self):
return self._config_get(False)
def followPointer(self, flag: bool):
self._config(flag, js_type=False)
def followTouchMove(self):
return self._config_get(True)
def followTouchMove(self, flag: bool):
self._config(flag, js_type=False)
def footerFormat(self):
return self._config_get('')
def footerFormat(self, text: str):
self._config(text, js_type=False)
def format(self):
return self._config_get('undefined')
def format(self, text: str):
self._config(text, js_type=False)
def headerFormat(self):
return self._config_get('<span style="color:{point.color}"></span> <span style="font-size: 0.8em"> {series.name}</span><br/>')
def headerFormat(self, text: str):
self._config(text, js_type=False)
def nullFormat(self):
return self._config_get(None)
def nullFormat(self, text: str):
self._config(text, js_type=False)
def nullFormatter(self):
return self._config_get(None)
def nullFormatter(self, value: Any):
self._config(value, js_type=False)
def pointFormat(self):
return self._config_get('x: <b>{point.x}</b><br/>y: <b>{point.y}</b><br/>')
def pointFormat(self, text: str):
self._config(text, js_type=False)
def pointFormatter(self):
return self._config_get(None)
def pointFormatter(self, value: Any):
self._config(value, js_type=False)
def valueDecimals(self):
return self._config_get(None)
def valueDecimals(self, num: float):
self._config(num, js_type=False)
def valuePrefix(self):
return self._config_get(None)
def valuePrefix(self, text: str):
self._config(text, js_type=False)
def valueSuffix(self):
return self._config_get(None)
def valueSuffix(self, text: str):
self._config(text, js_type=False)
def xDateFormat(self):
return self._config_get(None)
def xDateFormat(self, text: str):
self._config(text, js_type=False) |
def translate(item: Item, installed_languages, low_memory: bool=False) -> Translation:
text = str((item.content if item.content else item.title))
language = _detect(text, low_memory)
try:
if (language['lang'] != 'en'):
translated = translation(language['lang'], 'en', installed_languages).translate(text)
else:
translated = item.content
return Translation(language=Language(language['lang']), translation=Translated(translated))
except Exception as err:
logging.error(f"Error translating from {language['lang']} ({item}) : {err}")
return Translation(language=Language(language['lang']), translation=Translated(item.content)) |
def run(py_version):
_run_command('rm /home/ubuntu/ray_bootstrap_config.yaml')
_run_command(f'conda create -n hydra_{py_version} python={py_version} -y')
pip_path = f'/home/ubuntu/anaconda3/envs/hydra_{py_version}/bin/pip'
for d in dependencies:
_run_command(f'{pip_path} install {d}') |
class MultiClientTestCase(ClientTestCase):
remote_path_file = '/.txt'
remote_path_file2 = '/2.txt'
remote_compressed_path_file = '/.txt'
remote_inner_path_file = '//.txt'
remote_path_dir = ''
remote_path_dir2 = '2'
remote_inner_path_dir = '/'
inner_dir_name = ''
local_base_dir = 'tests/'
local_file = '.txt'
local_file_path = (local_base_dir + '.txt')
local_path_dir = (local_base_dir + 'res/')
pulled_file = ((local_path_dir + os.sep) + local_file) |
def webapi_run_async_adjoint_fwd(simulations: Tuple[(Simulation, ...)], jax_infos: Tuple[(JaxInfo, ...)], folder_name: str, path_dir: str, callback_url: str, verbose: bool) -> Tuple[(BatchData, Dict[(str, str)])]:
task_names = [str(_task_name_orig(i)) for i in range(len(simulations))]
simulations = dict(zip(task_names, simulations))
jax_infos = dict(zip(task_names, jax_infos))
batch = AdjointBatch(simulations=simulations, jax_infos=jax_infos, folder_name=folder_name, callback_url=callback_url, verbose=verbose, simulation_type='adjoint_fwd')
batch_data_orig = batch.run(path_dir=path_dir)
return (batch_data_orig, tuple(batch_data_orig.task_ids.values())) |
class TabularModel(QtCore.QAbstractTableModel):
def __init__(self, editor, parent=None):
QtCore.QAbstractTableModel.__init__(self, parent)
self._editor = editor
def data(self, mi, role):
editor = self._editor
adapter = editor.adapter
(obj, name) = (editor.object, editor.name)
(row, column) = (mi.row(), mi.column())
if ((role == QtCore.Qt.ItemDataRole.DisplayRole) or (role == QtCore.Qt.ItemDataRole.EditRole)):
return adapter.get_text(obj, name, row, column)
elif (role == QtCore.Qt.ItemDataRole.DecorationRole):
image = editor._get_image(adapter.get_image(obj, name, row, column))
if (image is not None):
return image
elif (role == QtCore.Qt.ItemDataRole.ToolTipRole):
tooltip = adapter.get_tooltip(obj, name, row, column)
if tooltip:
return tooltip
elif (role == QtCore.Qt.ItemDataRole.FontRole):
font = adapter.get_font(obj, name, row, column)
if (font is not None):
return QtGui.QFont(font)
elif (role == QtCore.Qt.ItemDataRole.TextAlignmentRole):
string = adapter.get_alignment(obj, name, column)
alignment = alignment_map.get(string, QtCore.Qt.AlignmentFlag.AlignLeft)
return int((alignment | QtCore.Qt.AlignmentFlag.AlignVCenter))
elif (role == QtCore.Qt.ItemDataRole.BackgroundRole):
color = adapter.get_bg_color(obj, name, row, column)
if (color is not None):
if isinstance(color, SequenceTypes):
q_color = QtGui.QColor(*color)
else:
q_color = QtGui.QColor(color)
return QtGui.QBrush(q_color)
elif (role == QtCore.Qt.ItemDataRole.ForegroundRole):
color = adapter.get_text_color(obj, name, row, column)
if (color is not None):
if isinstance(color, SequenceTypes):
q_color = QtGui.QColor(*color)
else:
q_color = QtGui.QColor(color)
return QtGui.QBrush(q_color)
return None
def setData(self, mi, value, role):
if (role != QtCore.Qt.ItemDataRole.EditRole):
return False
editor = self._editor
(obj, name) = (editor.object, editor.name)
(row, column) = (mi.row(), mi.column())
editor.adapter.set_text(obj, name, row, column, value)
self.dataChanged.emit(mi, mi)
return True
def flags(self, mi):
editor = self._editor
row = mi.row()
column = mi.column()
if (not mi.isValid()):
return QtCore.Qt.ItemFlag.ItemIsDropEnabled
flags = QtCore.Qt.ItemFlag.ItemIsEnabled
if editor.factory.selectable:
flags |= QtCore.Qt.ItemFlag.ItemIsSelectable
if (editor.factory.editable and ('edit' in editor.factory.operations) and hasattr(editor.adapter, 'get_can_edit_cell')):
if editor.adapter.get_can_edit_cell(editor.object, editor.name, row, column):
flags |= QtCore.Qt.ItemFlag.ItemIsEditable
elif (editor.factory.editable and ('edit' in editor.factory.operations) and editor.adapter.get_can_edit(editor.object, editor.name, row)):
flags |= QtCore.Qt.ItemFlag.ItemIsEditable
if (editor.adapter.get_drag(editor.object, editor.name, row) is not None):
flags |= QtCore.Qt.ItemFlag.ItemIsDragEnabled
if editor.factory.editable:
flags |= QtCore.Qt.ItemFlag.ItemIsDropEnabled
return flags
def headerData(self, section, orientation, role):
if (role != QtCore.Qt.ItemDataRole.DisplayRole):
return None
editor = self._editor
label = None
if (orientation == QtCore.Qt.Orientation.Vertical):
label = editor.adapter.get_row_label(section, editor.object)
elif (orientation == QtCore.Qt.Orientation.Horizontal):
label = editor.adapter.get_label(section, editor.object)
return label
def rowCount(self, mi):
editor = self._editor
return editor.adapter.len(editor.object, editor.name)
def columnCount(self, mi):
editor = self._editor
return len(editor.adapter.columns)
def insertRow(self, row, parent=QtCore.QModelIndex(), obj=None):
editor = self._editor
adapter = editor.adapter
if (obj is None):
obj = adapter.get_default_value(editor.object, editor.name)
self.beginInsertRows(parent, row, row)
editor.callx(editor.adapter.insert, editor.object, editor.name, row, obj)
self.endInsertRows()
return True
def insertRows(self, row, count, parent=QtCore.QModelIndex()):
editor = self._editor
adapter = editor.adapter
self.beginInsertRows(parent, row, ((row + count) - 1))
for i in range(count):
value = adapter.get_default_value(editor.object, editor.name)
editor.callx(adapter.insert, editor.object, editor.name, row, value)
self.endInsertRows()
return True
def removeRows(self, row, count, parent=QtCore.QModelIndex()):
editor = self._editor
adapter = editor.adapter
self.beginRemoveRows(parent, row, ((row + count) - 1))
for i in range(count):
editor.callx(adapter.delete, editor.object, editor.name, row)
self.endRemoveRows()
n = self.rowCount(None)
if (not editor.factory.multi_select):
editor.selected_row = (row if (row < n) else (row - 1))
else:
editor.multi_selected_rows = []
return True
def mimeTypes(self):
return [tabular_mime_type, PyMimeData.MIME_TYPE, PyMimeData.NOPICKLE_MIME_TYPE]
def mimeData(self, indexes):
rows = sorted({index.row() for index in indexes})
items = [self._editor.adapter.get_drag(self._editor.object, self._editor.name, row) for row in rows]
mime_data = PyMimeData.coerce(items)
data = QtCore.QByteArray(str(id(self)).encode('utf8'))
for row in rows:
data.append((' %i' % row).encode('utf8'))
mime_data.setData(tabular_mime_type, data)
return mime_data
def dropMimeData(self, mime_data, action, row, column, parent):
if (action == QtCore.Qt.DropAction.IgnoreAction):
return False
if (row == (- 1)):
if parent.isValid():
row = parent.row()
else:
row = max(0, (self.rowCount(None) - 1))
data = mime_data.data(tabular_mime_type)
if ((not data.isNull()) and (action == QtCore.Qt.DropAction.MoveAction)):
id_and_rows = [int(s) for s in data.data().decode('utf8').split(' ')]
table_id = id_and_rows[0]
if (table_id == id(self)):
current_rows = id_and_rows[1:]
self.moveRows(current_rows, row)
return True
data = PyMimeData.coerce(mime_data).instance()
if (data is not None):
if (not isinstance(data, list)):
data = [data]
editor = self._editor
object = editor.object
name = editor.name
adapter = editor.adapter
if all((adapter.get_can_drop(object, name, row, item) for item in data)):
for item in reversed(data):
self.dropItem(item, row)
return True
return False
def supportedDropActions(self):
return (QtCore.Qt.DropAction.MoveAction | QtCore.Qt.DropAction.CopyAction)
def dropItem(self, item, row):
editor = self._editor
object = editor.object
name = editor.name
adapter = editor.adapter
destination = adapter.get_dropped(object, name, row, item)
if (destination == 'after'):
row += 1
adapter.insert(object, name, row, item)
def moveRow(self, old_row, new_row):
return self.moveRows([old_row], new_row)
def moveRows(self, current_rows, new_row):
editor = self._editor
if (new_row == (- 1)):
logger.debug('Received invalid row %d. Adjusting to the last row.', new_row)
new_row = max(0, (self.rowCount(None) - 1))
current_rows.sort()
current_rows.reverse()
if (current_rows[(- 1)] < new_row):
new_row += 1
objects = []
for row in current_rows:
if (row <= new_row):
new_row -= 1
obj = editor.adapter.get_item(editor.object, editor.name, row)
objects.insert(0, obj)
self.removeRow(row)
for (i, obj) in enumerate(objects):
self.insertRow((new_row + i), obj=obj)
if editor.factory.multi_select:
editor.setx(multi_selected=objects)
editor.multi_selected_rows = list(range(new_row, (new_row + len(objects))))
else:
editor.setx(selected=objects[0])
editor.selected_row = new_row |
class TestSenderWithTimeout(unittest.TestCase):
def setUp(self):
super(TestSenderWithTimeout, self).setUp()
self._server = mockserver.MockRecvServer('localhost')
self._sender = fluent.asyncsender.FluentSender(tag='test', port=self._server.port, queue_timeout=0.04)
def tearDown(self):
try:
self._sender.close()
finally:
self._server.close()
def get_data(self):
return self._server.get_received()
def test_simple(self):
with self._sender as sender:
sender.emit('foo', {'bar': 'baz'})
data = self.get_data()
eq = self.assertEqual
eq(1, len(data))
eq(3, len(data[0]))
eq('test.foo', data[0][0])
eq({'bar': 'baz'}, data[0][2])
self.assertTrue(data[0][1])
self.assertTrue(isinstance(data[0][1], int))
def test_simple_with_timeout_props(self):
with self._sender as sender:
sender.emit('foo', {'bar': 'baz'})
data = self.get_data()
eq = self.assertEqual
eq(1, len(data))
eq(3, len(data[0]))
eq('test.foo', data[0][0])
eq({'bar': 'baz'}, data[0][2])
self.assertTrue(data[0][1])
self.assertTrue(isinstance(data[0][1], int)) |
class TestCreateSnapshotRepository():
('elasticsearch.Elasticsearch')
.asyncio
async def test_create_snapshot_repository(self, es):
es.snapshot.create_repository = mock.AsyncMock()
params = {'repository': 'backups', 'body': {'type': 'fs', 'settings': {'location': '/var/backups'}}}
r = runner.CreateSnapshotRepository()
(await r(es, params))
es.snapshot.create_repository.assert_called_once_with(name='backups', body={'type': 'fs', 'settings': {'location': '/var/backups'}}, params={}) |
class OptionSeriesVectorSonificationDefaultinstrumentoptionsActivewhen(Options):
def crossingDown(self):
return self._config_get(None)
def crossingDown(self, num: float):
self._config(num, js_type=False)
def crossingUp(self):
return self._config_get(None)
def crossingUp(self, num: float):
self._config(num, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def prop(self):
return self._config_get(None)
def prop(self, text: str):
self._config(text, js_type=False) |
def prepare_data_for_date_num(date_curr, date_ref, datetime_name, num_name, num_curr, num_ref):
(prefix, freq) = choose_agg_period(date_curr, date_ref)
current_period_data = date_curr.dt.to_period(freq=freq)
df_for_time_plot_ref = None
reference_period_data = None
if (date_ref is not None):
reference_period_data = date_ref.dt.to_period(freq=freq)
df_for_time_plot_curr = transform_df_to_time_mean_view(current_period_data, datetime_name, date_curr, num_name, num_curr)
if (reference_period_data is not None):
df_for_time_plot_ref = transform_df_to_time_mean_view(reference_period_data, datetime_name, date_ref, num_name, num_ref)
return (df_for_time_plot_curr, df_for_time_plot_ref, prefix) |
class BhRemoveBracketsCommand(sublime_plugin.TextCommand):
def remove_brackets(self, value):
if (value != (- 1)):
menu_item = MENU[value]
indent = (menu_item == MENU.block_indent)
block = ((menu_item == MENU.block) or (menu_item == MENU.block_indent))
content = (menu_item == MENU.content)
self.view.run_command('bh_key', {'plugin': {'type': ['__all__'], 'command': 'bh_modules.bracketremove', 'args': {'remove_indent': indent, 'remove_block': block, 'remove_content': content}}})
def run(self, edit):
self.window = self.view.window()
self.window.show_quick_panel(list(MENU), self.remove_brackets) |
class OptionSeriesPieDataEvents(Options):
def click(self):
return self._config_get(None)
def click(self, value: Any):
self._config(value, js_type=False)
def drag(self):
return self._config_get(None)
def drag(self, value: Any):
self._config(value, js_type=False)
def dragStart(self):
return self._config_get(None)
def dragStart(self, value: Any):
self._config(value, js_type=False)
def drop(self):
return self._config_get(None)
def drop(self, value: Any):
self._config(value, js_type=False)
def mouseOut(self):
return self._config_get(None)
def mouseOut(self, value: Any):
self._config(value, js_type=False)
def mouseOver(self):
return self._config_get(None)
def mouseOver(self, value: Any):
self._config(value, js_type=False)
def remove(self):
return self._config_get(None)
def remove(self, value: Any):
self._config(value, js_type=False)
def select(self):
return self._config_get(None)
def select(self, value: Any):
self._config(value, js_type=False)
def unselect(self):
return self._config_get(None)
def unselect(self, value: Any):
self._config(value, js_type=False)
def update(self):
return self._config_get(None)
def update(self, value: Any):
self._config(value, js_type=False) |
def migrate_schema(base, dao_classes):
tables = base.metadata.tables
schema_update_actions_method = 'get_schema_update_actions'
for dao_class in dao_classes:
get_schema_update_actions = getattr(dao_class, schema_update_actions_method, None)
if (not callable(get_schema_update_actions)):
LOGGER.info(f'Table {dao_class.__tablename__} has not implemented the get_schema_update_actions method.')
continue
if (dao_class.__tablename__ not in tables):
LOGGER.info(f'Table {dao_class.__tablename__} not found in existing database tables.')
continue
LOGGER.info('Updating table %s', dao_class.__tablename__)
table = tables.get(dao_class.__tablename__)
schema_update_actions = get_schema_update_actions()
for (column_action, columns) in schema_update_actions.items():
if (column_action in [ColumnAction.CREATE, ColumnAction.DROP]):
_create_or_drop_columns(column_action, columns, table)
elif (column_action in [ColumnAction.ALTER]):
_alter_columns(column_action, columns, table)
else:
LOGGER.warning('Unknown column action: %s', column_action) |
def test_defaults():
c = Config('testconfig', x01=(3, int, 'an int'), x02=(3, float, 'a float'), x03=('yes', bool, 'a bool'), x04=((1, 2, 3), str, 'A list of ints, as a string'), x05=((1, 2, 3), (int,), 'A list of ints, as a tuple'), x06=((1, 2, 3), (str,), 'A list of strings, as a tuple'))
assert (len(c) == 6)
for name in c:
assert (name in ('x01', 'x02', 'x03', 'x04', 'x05', 'x06'))
assert (set(dir(c)) == set([name for name in c]))
assert (c.x01 == 3)
assert (c.x02 == 3.0)
assert (c.x03 == True)
assert (c.x04 == '(1, 2, 3)')
assert (c.x05 == (1, 2, 3))
assert (c.x06 == ('1', '2', '3'))
i1 = c.__doc__.find('x01')
i2 = c.__doc__.find('x02')
i3 = c.__doc__.find('x03')
i4 = c.__doc__.find('x04')
assert (i1 > 0)
assert (i2 > i1)
assert (i3 > i2)
assert (i4 > i3)
assert ('x01 (int): ' in c.__doc__)
assert ('x04 (str): ' in c.__doc__)
assert ('x05 (int-tuple): ' in c.__doc__)
assert ('x06 (str-tuple): ' in c.__doc__) |
def test_ensure_connected():
connection = TConnection(MagicMock(public_id=TConnection.connection_id), MagicMock())
assert (not connection.is_connected)
with pytest.raises(ConnectionError, match='Connection is not connected! Connect first!'):
connection._ensure_connected()
connection._state.set(ConnectionStates.connected)
connection._ensure_connected() |
def get_ert_parser(parser: Optional[ArgumentParser]=None) -> ArgumentParser:
if (parser is None):
parser = ArgumentParser(description='ERT - Ensemble Reservoir Tool')
parser.add_argument('--version', action='version', version=f'{ert.shared.__version__}')
parser.add_argument('--logdir', required=False, type=str, default='./logs', help='Directory where ERT will store the logs. Default is ./logs')
parser.add_argument('--read-only', action='store_true', help='Start ERT in read-only mode')
subparsers = parser.add_subparsers(title='Available user entries', description='ERT can be accessed through a GUI or CLI interface. Include one of the following arguments to change between the interfaces. Note that different sub commands may require different additional arguments. See the help section for each sub command for more details.', help='Available sub commands', dest='mode')
subparsers.required = True
config_help = 'ERT configuration file'
gui_parser = subparsers.add_parser('gui', description='Opens an independent graphical user interface for the user to interact with ERT.')
gui_parser.set_defaults(func=run_gui_wrapper)
gui_parser.add_argument('config', type=valid_file, help=config_help)
gui_parser.add_argument('--verbose', action='store_true', help='Show verbose output.', default=False)
FeatureToggling.add_feature_toggling_args(gui_parser)
lint_parser = subparsers.add_parser('lint', description='Find and print errors in existing .ert configuration, including errors related to files used in the ert config.')
lint_parser.set_defaults(func=run_lint_wrapper)
lint_parser.add_argument('config', type=valid_file, help=config_help)
lint_parser.add_argument('--verbose', action='store_true', help='Show verbose output.', default=False)
ert_api_parser = subparsers.add_parser('api', description='Expose ERT data through an HTTP server')
ert_api_parser.set_defaults(func=run_ert_storage)
ert_api_add_parser_options(ert_api_parser)
ert_vis_parser = subparsers.add_parser('vis', description='Launch webviz-driven visualization tool.')
ert_vis_parser.set_defaults(func=run_webviz_ert)
ert_vis_parser.add_argument('--name', '-n', type=str, default='Webviz-ERT')
ert_vis_parser.add_argument('--experimental-mode', action='store_true', help='Feature flag for enabling experimental plugins')
ert_api_add_parser_options(ert_vis_parser)
test_run_description = f"Run '{TEST_RUN_MODE}' in cli"
test_run_parser = subparsers.add_parser(TEST_RUN_MODE, help=test_run_description, description=test_run_description)
test_run_parser.add_argument('--current-case', type=valid_name, default='default', help='Name of the case where the results for the experiment using the prior parameters will be stored.')
ensemble_experiment_description = 'Run experiments in cli without performing any updates on the parameters.'
ensemble_experiment_parser = subparsers.add_parser(ENSEMBLE_EXPERIMENT_MODE, description=ensemble_experiment_description, help=ensemble_experiment_description)
ensemble_experiment_parser.add_argument('--realizations', type=valid_realizations, help="These are the realizations that will be used to perform experiments. For example, if 'Number of realizations:50 and Active realizations is 0-9', then only realizations 0,1,2,3,...,9 will be used to perform experiments while realizations 10,11, 12,...,49 will be excluded.")
ensemble_experiment_parser.add_argument('--current-case', type=valid_case, default='default', help='Name of the case where the results for the experiment using the prior parameters will be stored.')
ensemble_experiment_parser.add_argument('--iter-num', type=valid_iter_num, default=0, required=False, help='Specification of which iteration number is about to be made. Use iter-num to avoid recomputing the priors.')
ensemble_smoother_description = 'Run experiments in cli while performing one update on the parameters by using the ensemble smoother algorithm.'
ensemble_smoother_parser = subparsers.add_parser(ENSEMBLE_SMOOTHER_MODE, description=ensemble_smoother_description, help=ensemble_smoother_description)
ensemble_smoother_parser.add_argument('--target-case', type=valid_name, required=True, help='Name of the case where the results for the updated parameters will be stored.')
ensemble_smoother_parser.add_argument('--realizations', type=valid_realizations, help="These are the realizations that will be used to perform experiments.For example, if 'Number of realizations:50 and Active realizations is 0-9', then only realizations 0,1,2,3,...,9 will be used to perform experiments while realizations 10,11, 12,...,49 will be excluded")
ensemble_smoother_parser.add_argument('--current-case', type=valid_name, default='default', help='Name of the case where the results for the experiment using the prior parameters will be stored.')
iterative_ensemble_smoother_description = 'Run experiments in cli while performing updates on the parameters using the iterative ensemble smoother algorithm.'
iterative_ensemble_smoother_parser = subparsers.add_parser(ITERATIVE_ENSEMBLE_SMOOTHER_MODE, description=iterative_ensemble_smoother_description, help=iterative_ensemble_smoother_description)
iterative_ensemble_smoother_parser.add_argument('--target-case', type=valid_name_format, required=True, help="The iterative ensemble smoother creates multiple cases for the different iterations. The case names will follow the specified format. For example, 'Target case format: iter_%%d' will generate cases with the names iter_0, iter_1, iter_2, iter_3, ....")
iterative_ensemble_smoother_parser.add_argument('--realizations', type=valid_realizations, help="These are the realizations that will be used to perform experiments.For example, if 'Number of realizations:50 and active realizations are 0-9', then only realizations 0,1,2,3,...,9 will be used to perform experiments while realizations 10,11, 12,...,49 will be excluded.")
iterative_ensemble_smoother_parser.add_argument('--current-case', type=valid_name, default='default', help='Name of the case where the results for the experiment using the prior parameters will be stored.')
iterative_ensemble_smoother_parser.add_argument('--num-iterations', type=valid_num_iterations, required=False, help='The number of iterations to run.')
es_mda_description = f"Run '{ES_MDA_MODE}' in cli"
es_mda_parser = subparsers.add_parser(ES_MDA_MODE, description=es_mda_description, help=es_mda_description)
es_mda_parser.add_argument('--target-case', type=valid_name_format, help="The es_mda creates multiple cases for the different iterations. The case names will follow the specified format. For example, 'Target case format: iter-%%d' will generate cases with the names iter-0, iter-1, iter-2, iter-3, ....")
es_mda_parser.add_argument('--realizations', type=valid_realizations, help="These are the realizations that will be used to perform experiments.For example, if 'Number of realizations:50 and active realizations are 0-9', then only realizations 0,1,2,3,...,9 will be used to perform experiments while realizations 10,11, 12,...,49 will be excluded.")
es_mda_parser.add_argument('--weights', type=valid_weights, default=MultipleDataAssimilation.default_weights, help="Example custom relative weights: '8,4,2,1'. This means multiple data assimilation ensemble smoother will half the weight applied to the observation errors from one iteration to the next across 4 iterations.")
es_mda_parser.add_argument('--restart-case', type=valid_name, default=None, help='Name of the case where the results for the experiment using the prior parameters will be stored. Iteration number is read from this case. If provided this will be a restart a run')
workflow_description = 'Executes the workflow given'
workflow_parser = subparsers.add_parser(WORKFLOW_MODE, help=workflow_description, description=workflow_description)
workflow_parser.add_argument(help='Name of workflow', dest='name')
workflow_parser.add_argument('--ensemble', help='Which ensemble to use', default=None)
for cli_parser in [test_run_parser, ensemble_experiment_parser, ensemble_smoother_parser, iterative_ensemble_smoother_parser, es_mda_parser, workflow_parser]:
cli_parser.set_defaults(func=run_cli)
cli_parser.add_argument('--verbose', action='store_true', help='Show verbose output.', default=False)
cli_parser.add_argument('--color-always', action='store_true', help=('Force coloring of monitor output, which is automatically' + ' disabled if the output stream is not a terminal.'), default=False)
cli_parser.add_argument('--disable-monitoring', action='store_true', help=(('Monitoring will continuously print the status of the realisations' + ' classified into Waiting, Pending, Running, Failed, Finished') + ' and Unknown.'), default=False)
cli_parser.add_argument('--port-range', type=valid_port_range, required=False, help='Port range [a,b] to be used by the evaluator. Format: a-b')
cli_parser.add_argument('config', type=valid_file, help=config_help)
FeatureToggling.add_feature_toggling_args(cli_parser)
return parser |
class LayoutAnnotation(DataClass):
def xanchor(self):
return self._attrs['xanchor']
def xanchor(self, val):
self._attrs['xanchor'] = val
def ax(self):
return self._attrs['ax']
def ax(self, val):
self._attrs['ax'] = val
def ay(self):
return self._attrs['ay']
def ay(self, val):
self._attrs['ay'] = val
def text(self):
return self._attrs['text']
def text(self, val):
self._attrs['text'] = val
def showarrow(self):
return self._attrs['showarrow']
def showarrow(self, val):
self._attrs['showarrow'] = val
def x(self):
return self._attrs['x']
def x(self, val):
self._attrs['x'] = val
def y(self):
return self._attrs['y']
def y(self, val):
self._attrs['y'] = val
def xref(self):
return self._attrs['xref']
def xref(self, val):
self._attrs['xref'] = val
def yref(self):
return self._attrs['yref']
def yref(self, val):
self._attrs['yref'] = val
def font(self):
return self.sub_data('font', DataFont) |
class OptionPlotoptionsBellcurveZones(Options):
def className(self):
return self._config_get(None)
def className(self, text: str):
self._config(text, js_type=False)
def color(self):
return self._config_get(None)
def color(self, text: str):
self._config(text, js_type=False)
def dashStyle(self):
return self._config_get(None)
def dashStyle(self, text: str):
self._config(text, js_type=False)
def fillColor(self):
return self._config_get(None)
def fillColor(self, text: str):
self._config(text, js_type=False) |
class OptionSeriesFunnel3dSonificationTracksMappingFrequency(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
class UserLoginSerializer(serializers.Serializer):
username = serializers.CharField(required=True)
password = serializers.CharField(required=True)
default_error_messages = {'inactive_account': _('User account is disabled.'), 'invalid_credentials': _('Unable to login with provided credentials.')}
def __init__(self, *args, **kwargs):
super(UserLoginSerializer, self).__init__(*args, **kwargs)
self.user = None
def validate(self, attrs):
self.user = authenticate(username=attrs.get('username'), password=attrs.get('password'))
if self.user:
if (not self.user.is_active):
raise serializers.ValidationError(self.error_messages['inactive_account'])
return attrs
else:
raise serializers.ValidationError(self.error_messages['invalid_credentials']) |
class ApiTokenTests(DatabaseTestCase):
def test_token_default(self):
user = models.User(email='', username='user')
user_social_auth = social_models.UserSocialAuth(user_id=user.id, user=user)
self.session.add(user)
self.session.add(user_social_auth)
token = models.ApiToken(user=user)
self.session.add(token)
self.session.commit()
self.assertEqual(40, len(token.token))
def test_user_relationship(self):
user = models.User(email='', username='user')
user_social_auth = social_models.UserSocialAuth(user_id=user.id, user=user)
self.session.add(user)
self.session.add(user_social_auth)
token = models.ApiToken(user=user)
self.session.add(token)
self.session.commit()
self.assertEqual(user.api_tokens, [token]) |
def determine_rbd_info_from_pv(pv: kubernetes.client.models.v1_persistent_volume.V1PersistentVolume) -> Optional[_RBDInfo]:
rbd_info = None
if keys_exist(pv.spec, ['rbd.pool', 'rbd.image']):
rbd_info = _RBDInfo(pool=key_get(pv.spec, 'rbd.pool'), image=key_get(pv.spec, 'rbd.image'), mount_point=NODE_RBD_MOUNT_PATH_FORMAT.format(image=key_get(pv.spec, 'rbd.image')))
elif (keys_exist(pv.spec, ['flex_volume.options.pool', 'flex_volume.options.image', 'flex_volume.driver']) and key_get(pv.spec, 'flex_volume.driver').startswith('ceph.rook.io/')):
rbd_info = _RBDInfo(pool=key_get(pv.spec, 'flex_volume.options.pool'), image=key_get(pv.spec, 'flex_volume.options.image'))
elif (keys_exist(pv.spec, ['csi.driver', 'csi.volume_handle', 'csi.volume_attributes.pool', 'csi.volume_attributes.imageName']) and ((key_get(pv.spec, 'csi.driver') == 'rbd.csi.ceph.com') or key_get(pv.spec, 'csi.driver').endswith('.rbd.csi.ceph.com'))):
kubernetes_1_24 = ((1 * 1000) + 24)
if (server_version() < kubernetes_1_24):
mount_point = NODE_CSI_MOUNT_PATH_FORMAT_LT_1_24.format(pv=pv.metadata.name, volume_handle=key_get(pv.spec, 'csi.volume_handle'))
else:
volume_handle = key_get(pv.spec, 'csi.volume_handle')
volume_handle_hash = hashlib.sha256(volume_handle.encode()).hexdigest()
mount_point = NODE_CSI_MOUNT_PATH_FORMAT_GE_1_24.format(pv=pv.metadata.name, csi_driver=key_get(pv.spec, 'csi.driver'), volume_handle_hash=volume_handle_hash, volume_handle=volume_handle)
rbd_info = _RBDInfo(pool=key_get(pv.spec, 'csi.volume_attributes.pool'), namespace=key_get(pv.spec, 'csi.volume_attributes.radosNamespace', ''), image=key_get(pv.spec, 'csi.volume_attributes.imageName'), mount_point=mount_point)
return rbd_info |
class Switch_Statement(Compound_Statement):
def __init__(self, t_kw, n_switch_expr):
super().__init__()
assert isinstance(t_kw, MATLAB_Token)
assert ((t_kw.kind == 'KEYWORD') and (t_kw.value == 'switch'))
assert isinstance(n_switch_expr, Expression)
self.t_kw = t_kw
self.t_kw.set_ast(self)
self.n_expr = n_switch_expr
self.n_expr.set_parent(self)
self.l_actions = []
self.has_otherwise = False
def loc(self):
return self.t_kw.location
def add_action(self, n_action):
assert isinstance(n_action, Action)
assert (n_action.kind() in ('case', 'otherwise'))
assert (not self.has_otherwise)
n_action.set_parent(self)
self.l_actions.append(n_action)
if (n_action.kind() == 'otherwise'):
self.has_otherwise = True
def visit(self, parent, function, relation):
self._visit(parent, function, relation)
self.n_expr.visit(self, function, 'Guard')
self._visit_list(self.l_actions, function, 'Action')
self._visit_end(parent, function, relation) |
def test_output_longer_than_max_msg_size_is_split_into_multiple_msgs_when_returned(dummy_execute_and_send):
(dummy, m) = dummy_execute_and_send
dummy.bot_config.MESSAGE_SIZE_LIMIT = len(LONG_TEXT_STRING)
dummy._execute_and_send(cmd='return_long_output', args=['foo', 'bar'], match=None, msg=m, template_name=dummy.return_long_output._err_command_template)
for i in range(3):
assert (LONG_TEXT_STRING.strip() == dummy.pop_message().body)
with pytest.raises(Empty):
dummy.pop_message(block=False) |
def rich_config(help_config: Optional[Union[(Mapping[(str, Any)], RichHelpConfiguration)]]=None, *, console: Optional[Console]=None) -> Callable[([FC], FC)]:
if (isinstance(help_config, Console) and (console is None)):
import warnings
warnings.warn("`rich_config()`'s args have been swapped. Please set the config first, and use a kwarg to set ", DeprecationWarning, stacklevel=2)
console = help_config
elif isinstance(help_config, Console):
import warnings
warnings.warn('We have no idea what just happened. Tread carefully.', RuntimeWarning, stacklevel=2)
if CLICK_IS_BEFORE_VERSION_8X:
def decorator_with_warning(obj: FC) -> FC:
import warnings
warnings.warn('`rich_config()` does not work with versions of click prior to version 8.0.0. Please update to a newer version of click to use this functionality.', RuntimeWarning, stacklevel=2)
return obj
return decorator_with_warning
def decorator(obj: FC) -> FC:
extra: Dict[(str, Any)] = {}
if (console is not None):
extra['rich_console'] = console
if (help_config is not None):
extra['rich_help_config'] = help_config
if isinstance(obj, (RichCommand, RichGroup)):
obj.context_settings.update(extra)
elif (callable(obj) and (not isinstance(obj, (Command, Group)))):
if hasattr(obj, '__rich_context_settings__'):
obj.__rich_context_settings__.update(extra)
else:
setattr(obj, '__rich_context_settings__', extra)
else:
raise NotSupportedError('`rich_config` requires a `RichCommand` or `RichGroup`. Try using the cls keyword')
return obj
return decorator |
def transact_block(request, connection):
error = connection.send(request)
reply = None
if error:
return (error, reply)
ovs_poller = poller.Poller()
while (not error):
ovs_poller.immediate_wake()
(error, reply) = connection.recv()
if (error != errno.EAGAIN):
break
if (reply and (reply.id == request.id) and (reply.type in (jsonrpc.Message.T_REPLY, jsonrpc.Message.T_ERROR))):
break
connection.run()
connection.wait(ovs_poller)
connection.recv_wait(ovs_poller)
ovs_poller.block()
hub.sleep(0)
return (error, reply) |
.parametrize('test_file', ['en_pud-ud-test.json', 'masc-penn-treebank-sample.json'])
def test_en_parser_depset(NLP, test_file):
gold_deps = set(NLP.get_pipe('parser').labels)
data_path = (TEST_FILES_DIR / test_file)
if (not data_path.exists()):
raise FileNotFoundError('Test corpus not found', data_path)
examples = json_path_to_examples(data_path, NLP)
pred_deps = set()
parser = NLP.get_pipe('parser')
for example in examples:
doc = example.predicted
parser(doc)
pred_deps = pred_deps.union(set([t.dep_ for t in doc]))
assert (len((pred_deps - gold_deps)) == 0) |
def is_mouth_covered(mouth, palms):
if is_missing(palms):
return False
dxL = (mouth[0]['x'] - palms[0]['x'])
dyL = (mouth[0]['y'] - palms[0]['y'])
dxR = (mouth[1]['x'] - palms[1]['x'])
dyR = (mouth[1]['y'] - palms[1]['y'])
return all(((abs(d) < MOUTH_COVER_THRESHOLD) for d in [dxL, dyL, dxR, dyR])) |
class DrawPointsTool(BaseTool):
xdata = Instance(ArrayDataSource)
ydata = Instance(ArrayDataSource)
activated = Bool(True)
def __init__(self, **kwtraits):
BaseTool.__init__(self, **kwtraits)
self.xdata = self.component.value1
self.ydata = self.component.value2
def normal_left_down(self, event):
(x, y) = (event.x, event.y)
(data_x, data_y) = self.component.map_data((x, y))
self._append_data(self.xdata, data_x)
self._append_data(self.ydata, data_y)
self.component.request_redraw()
def _activate(self):
self.activated = True
def _deactivate(self):
self.activated = False
def _append_data(self, datasource, data):
olddata = array(datasource.get_data(), float64)
newdata = hstack((olddata, data))
datasource.set_data(newdata) |
class Block():
def __init__(self, parent, slot, proposer):
self.contents = os.urandom(32)
self.parent_hash = (parent.hash if parent else (b'\x00' * 32))
self.hash = sha3((self.parent_hash + self.contents))
self.height = ((parent.height + 1) if parent else 0)
assert ((slot % NOTARIES) == proposer)
self.proposer = proposer
self.slot = slot
def min_timestamp(self):
return (SLOT_SIZE * self.slot) |
class OptionSeriesBoxplotSonificationDefaultspeechoptionsMapping(Options):
def pitch(self) -> 'OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingPitch':
return self._config_sub_data('pitch', OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingPitch)
def playDelay(self) -> 'OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingPlaydelay':
return self._config_sub_data('playDelay', OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingPlaydelay)
def rate(self) -> 'OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingRate':
return self._config_sub_data('rate', OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingRate)
def text(self):
return self._config_get(None)
def text(self, text: str):
self._config(text, js_type=False)
def time(self) -> 'OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingTime':
return self._config_sub_data('time', OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingTime)
def volume(self) -> 'OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingVolume':
return self._config_sub_data('volume', OptionSeriesBoxplotSonificationDefaultspeechoptionsMappingVolume) |
def main():
module_spec = schema_to_module_spec(versioned_schema)
mkeyname = None
fields = {'access_token': {'required': False, 'type': 'str', 'no_log': True}, 'enable_log': {'required': False, 'type': 'bool', 'default': False}, 'vdom': {'required': False, 'type': 'str', 'default': 'root'}, 'member_path': {'required': False, 'type': 'str'}, 'member_state': {'type': 'str', 'required': False, 'choices': ['present', 'absent']}, 'log_fortianalyzer_cloud_override_filter': {'required': False, 'type': 'dict', 'default': None, 'options': {}}}
for attribute_name in module_spec['options']:
fields['log_fortianalyzer_cloud_override_filter']['options'][attribute_name] = module_spec['options'][attribute_name]
if (mkeyname and (mkeyname == attribute_name)):
fields['log_fortianalyzer_cloud_override_filter']['options'][attribute_name]['required'] = True
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
check_legacy_fortiosapi(module)
is_error = False
has_changed = False
result = None
diff = None
versions_check_result = None
if module._socket_path:
connection = Connection(module._socket_path)
if ('access_token' in module.params):
connection.set_option('access_token', module.params['access_token'])
if ('enable_log' in module.params):
connection.set_option('enable_log', module.params['enable_log'])
else:
connection.set_option('enable_log', False)
fos = FortiOSHandler(connection, module, mkeyname)
versions_check_result = check_schema_versioning(fos, versioned_schema, 'log_fortianalyzer_cloud_override_filter')
(is_error, has_changed, result, diff) = fortios_log_fortianalyzer_cloud(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
if (versions_check_result and (versions_check_result['matched'] is False)):
module.warn('Ansible has detected version mismatch between FortOS system and your playbook, see more details by specifying option -vvv')
if (not is_error):
if (versions_check_result and (versions_check_result['matched'] is False)):
module.exit_json(changed=has_changed, version_check_warning=versions_check_result, meta=result, diff=diff)
else:
module.exit_json(changed=has_changed, meta=result, diff=diff)
elif (versions_check_result and (versions_check_result['matched'] is False)):
module.fail_json(msg='Error in repo', version_check_warning=versions_check_result, meta=result)
else:
module.fail_json(msg='Error in repo', meta=result) |
class AnalysisBasePlugin(BasePlugin):
FILE = None
NAME = None
DESCRIPTION = None
VERSION = None
RECURSIVE = True
TIMEOUT = 300
SYSTEM_VERSION = None
MIME_BLACKLIST = []
MIME_WHITELIST = []
ANALYSIS_STATS_LIMIT = 1000
def __init__(self, no_multithread=False, view_updater=None):
super().__init__(plugin_path=self.FILE, view_updater=view_updater)
self._check_plugin_attributes()
self.additional_setup()
self.in_queue = Queue()
self.out_queue = Queue()
self.stop_condition = Value('i', 0)
self.workers = []
self.thread_count = (1 if no_multithread else self._get_thread_count())
self.active = [Value('i', 0) for _ in range(self.thread_count)]
self.manager = Manager()
self.analysis_stats = Array(ctypes.c_float, self.ANALYSIS_STATS_LIMIT)
self.analysis_stats_count = Value('i', 0)
self.analysis_stats_index = Value('i', 0)
def _get_thread_count(self):
default_process_count = config.backend.plugin_defaults.processes
plugin_config = config.backend.plugin.get(self.NAME, None)
return getattr(plugin_config, 'processes', default_process_count)
def additional_setup(self):
def start(self):
for process_index in range(self.thread_count):
self.workers.append(start_single_worker(process_index, 'Analysis', self.worker))
logging.debug(f'{self.NAME}: {len(self.workers)} worker threads started')
def shutdown(self):
logging.debug('Shutting down...')
self.stop_condition.value = 1
self.in_queue.close()
stop_processes(self.workers, timeout=10.0)
self.out_queue.close()
self.manager.shutdown()
def _check_plugin_attributes(self):
for attribute in ['FILE', 'NAME', 'VERSION']:
if (getattr(self, attribute, None) is None):
raise PluginInitException(f'Plugin {self.NAME} is missing {attribute} in configuration', plugin=self)
self._check_version(self.VERSION)
if self.SYSTEM_VERSION:
self._check_version(self.SYSTEM_VERSION, label='System version')
def _check_version(self, version: str, label: str='Version'):
try:
parse_version(version)
except InvalidVersion:
raise PluginInitException(f'{label} "{version}" of plugin {self.NAME} is invalid', plugin=self)
def add_job(self, fw_object: FileObject):
if self._dependencies_are_unfulfilled(fw_object):
logging.error(f'{fw_object.uid}: dependencies of plugin {self.NAME} not fulfilled')
elif self._analysis_depth_not_reached_yet(fw_object):
self.in_queue.put(fw_object)
return
self.out_queue.put(fw_object)
def _dependencies_are_unfulfilled(self, fw_object: FileObject):
return any(((dep not in fw_object.processed_analysis) for dep in self.DEPENDENCIES))
def _analysis_depth_not_reached_yet(self, fo):
return (self.RECURSIVE or (fo.depth == 0))
def process_object(self, file_object):
return file_object
def analyze_file(self, file_object):
fo = self.process_object(file_object)
return self._add_plugin_version_and_timestamp_to_analysis_result(fo)
def _add_plugin_version_and_timestamp_to_analysis_result(self, fo):
fo.processed_analysis[self.NAME].update(self.init_dict())
return fo
def add_analysis_tag(self, file_object, tag_name, value, color=TagColor.LIGHT_BLUE, propagate=False):
new_tag = {tag_name: {'value': value, 'color': color, 'propagate': propagate}, 'root_uid': file_object.root_uid}
if ('tags' not in file_object.processed_analysis[self.NAME]):
file_object.processed_analysis[self.NAME]['tags'] = new_tag
else:
file_object.processed_analysis[self.NAME]['tags'].update(new_tag)
def init_dict(self) -> dict:
result_update = {'analysis_date': time(), 'plugin_version': self.VERSION, 'result': {}}
if self.SYSTEM_VERSION:
result_update.update({'system_version': self.SYSTEM_VERSION})
return result_update
def process_next_object(self, task, result):
task.processed_analysis.update({self.NAME: {}})
finished_task = self.analyze_file(task)
result.append(finished_task)
def timeout_happened(process):
return process.is_alive()
def worker_processing_with_timeout(self, worker_id, next_task: FileObject):
result = self.manager.list()
process = ExceptionSafeProcess(target=self.process_next_object, args=(next_task, result), reraise=False)
start = time()
process.start()
process.join(timeout=self.TIMEOUT)
duration = (time() - start)
if (duration > 120):
logging.info(f'Analysis {self.NAME} on {next_task.uid} is slow: took {duration:.1f} seconds')
self._update_duration_stats(duration)
if self.timeout_happened(process):
result_fo = self._handle_failed_analysis(next_task, process, worker_id, 'Timeout')
elif process.exception:
(_, trace) = process.exception
result_fo = self._handle_failed_analysis(next_task, process, worker_id, 'Exception', trace=trace)
else:
result_fo = result.pop()
logging.debug(f'Worker {worker_id}: Finished {self.NAME} analysis on {next_task.uid}')
processed_analysis_entry = result_fo.processed_analysis.pop(self.NAME)
result_fo.processed_analysis[self.NAME] = sanitize_processed_analysis(processed_analysis_entry)
self.out_queue.put(result_fo)
def _update_duration_stats(self, duration):
with self.analysis_stats.get_lock():
self.analysis_stats[self.analysis_stats_index.value] = duration
self.analysis_stats_index.value += 1
if (self.analysis_stats_index.value >= self.ANALYSIS_STATS_LIMIT):
self.analysis_stats_index.value = 0
if (self.analysis_stats_count.value < self.ANALYSIS_STATS_LIMIT):
self.analysis_stats_count.value += 1
def _handle_failed_analysis(self, fw_object, process, worker_id, cause: str, trace: (str | None)=None):
terminate_process_and_children(process)
fw_object.analysis_exception = (self.NAME, f'{cause} occurred during analysis')
message = f'Worker {worker_id}: {cause} during analysis {self.NAME} on {fw_object.uid}'
if trace:
message += f''':
{trace}'''
logging.error(message)
return fw_object
def worker(self, worker_id):
logging.debug(f'started {self.NAME} worker {worker_id} (pid={os.getpid()})')
while (self.stop_condition.value == 0):
try:
next_task = self.in_queue.get(timeout=float(config.backend.block_delay))
logging.debug(f'Worker {worker_id}: Begin {self.NAME} analysis on {next_task.uid}')
except Empty:
self.active[worker_id].value = 0
else:
self.active[worker_id].value = 1
next_task.processed_analysis.update({self.NAME: {}})
self.worker_processing_with_timeout(worker_id, next_task)
logging.debug(f'worker {worker_id} stopped')
def check_exceptions(self):
return check_worker_exceptions(self.workers, 'Analysis', self.worker) |
class SmartSymbolsExtension(Extension):
def __init__(self, *args, **kwargs):
self.config = {'trademark': [True, 'Trademark'], 'copyright': [True, 'Copyright'], 'registered': [True, 'Registered'], 'plusminus': [True, 'Plus/Minus'], 'arrows': [True, 'Arrows'], 'notequal': [True, 'Not Equal'], 'fractions': [True, 'Fractions'], 'ordinal_numbers': [True, 'Ordinal Numbers'], 'care_of': [True, 'Care/of']}
super(SmartSymbolsExtension, self).__init__(*args, **kwargs)
def add_pattern(self, patterns, md):
self.patterns.register(SmartSymbolsPattern(patterns[1], patterns[2], md), patterns[0], 30)
def extendMarkdown(self, md):
configs = self.getConfigs()
self.patterns = Registry()
for (k, v) in REPL.items():
if configs[k]:
self.add_pattern(v, md)
inline_processor = treeprocessors.InlineProcessor(md)
inline_processor.inlinePatterns = self.patterns
md.treeprocessors.register(inline_processor, 'smart-symbols', 2.1) |
def configure_dataset_creation(cfg):
dataset_from_list_offload_method = SharedList
if cfg.D2GO_DATA.DATASETS.DISK_CACHE.ENABLED:
from d2go.data.disk_cache import DiskCachedList
dataset_from_list_offload_method = DiskCachedList
load_dataset_from_local_master = cfg.D2GO_DATA.DATASETS.DISK_CACHE.ENABLED
with contextlib.ExitStack() as stack:
ctx_managers = [set_default_dataset_from_list_serialize_method(dataset_from_list_offload_method)]
if load_dataset_from_local_master:
ctx_managers.append(mock.patch('detectron2.data.build.get_detection_dataset_dicts', side_effect=local_master_get_detection_dataset_dicts))
for ctx in ctx_managers:
stack.enter_context(ctx)
(yield) |
def extractMcstoriesCom(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 |
_flow_update_event(ofproto.OFPFME_INITIAL, ofproto.OFP_FLOW_UPDATE_FULL_SIZE)
_flow_update_event(ofproto.OFPFME_ADDED, ofproto.OFP_FLOW_UPDATE_FULL_SIZE)
_flow_update_event(ofproto.OFPFME_REMOVED, ofproto.OFP_FLOW_UPDATE_FULL_SIZE)
_flow_update_event(ofproto.OFPFME_MODIFIED, ofproto.OFP_FLOW_UPDATE_FULL_SIZE)
class OFPFlowUpdateFull(OFPFlowUpdateHeader):
def __init__(self, length=None, event=None, table_id=None, reason=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None, match=None, instructions=None):
instructions = (instructions if instructions else [])
super(OFPFlowUpdateFull, self).__init__(length, event)
self.table_id = table_id
self.reason = reason
self.idle_timeout = idle_timeout
self.hard_timeout = hard_timeout
self.priority = priority
self.cookie = cookie
self.match = match
assert ((event != ofproto.OFPFME_REMOVED) or (len(instructions) == 0))
for i in instructions:
assert isinstance(i, OFPInstruction)
self.instructions = instructions
def parser(cls, buf, offset):
(length, event, table_id, reason, idle_timeout, hard_timeout, priority, cookie) = struct.unpack_from(ofproto.OFP_FLOW_UPDATE_FULL_0_PACK_STR, buf, offset)
offset += ofproto.OFP_FLOW_UPDATE_FULL_0_SIZE
assert (cls.cls_flow_update_length <= length)
assert (cls.cls_flow_update_event == event)
match = OFPMatch.parser(buf, offset)
match_length = utils.round_up(match.length, 8)
offset += match_length
inst_length = ((length - ofproto.OFP_FLOW_UPDATE_FULL_0_SIZE) - match_length)
instructions = []
while (inst_length > 0):
inst = OFPInstruction.parser(buf, offset)
instructions.append(inst)
offset += inst.len
inst_length -= inst.len
return cls(length, event, table_id, reason, idle_timeout, hard_timeout, priority, cookie, match, instructions) |
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName('MainWindow')
MainWindow.setWindowModality(QtCore.Qt.NonModal)
MainWindow.setEnabled(True)
MainWindow.resize(1434, 935)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(MainWindow.sizePolicy().hasHeightForWidth())
MainWindow.setSizePolicy(sizePolicy)
MainWindow.setMinimumSize(QtCore.QSize(1434, 935))
MainWindow.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
MainWindow.setWindowTitle('scAnt')
self.centralwidget = QtWidgets.QWidget(MainWindow)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.centralwidget.sizePolicy().hasHeightForWidth())
self.centralwidget.setSizePolicy(sizePolicy)
self.centralwidget.setMinimumSize(QtCore.QSize(1434, 892))
self.centralwidget.setObjectName('centralwidget')
self.gridLayout_15 = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout_15.setObjectName('gridLayout_15')
self.tabWidget = QtWidgets.QTabWidget(self.centralwidget)
self.tabWidget.setEnabled(True)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.tabWidget.sizePolicy().hasHeightForWidth())
self.tabWidget.setSizePolicy(sizePolicy)
self.tabWidget.setMinimumSize(QtCore.QSize(1412, 872))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(False)
font.setWeight(50)
self.tabWidget.setFont(font)
self.tabWidget.setTabPosition(QtWidgets.QTabWidget.North)
self.tabWidget.setObjectName('tabWidget')
self.tab_scan_parameters = QtWidgets.QWidget()
self.tab_scan_parameters.setEnabled(True)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.tab_scan_parameters.sizePolicy().hasHeightForWidth())
self.tab_scan_parameters.setSizePolicy(sizePolicy)
self.tab_scan_parameters.setMinimumSize(QtCore.QSize(1405, 840))
self.tab_scan_parameters.setObjectName('tab_scan_parameters')
self.gridLayout_14 = QtWidgets.QGridLayout(self.tab_scan_parameters)
self.gridLayout_14.setObjectName('gridLayout_14')
self.frame = QtWidgets.QFrame(self.tab_scan_parameters)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame.sizePolicy().hasHeightForWidth())
self.frame.setSizePolicy(sizePolicy)
self.frame.setFrameShape(QtWidgets.QFrame.Box)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setObjectName('frame')
self.gridLayout_7 = QtWidgets.QGridLayout(self.frame)
self.gridLayout_7.setObjectName('gridLayout_7')
self.label_liveView = QtWidgets.QLabel(self.frame)
self.label_liveView.setEnabled(True)
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setItalic(False)
font.setWeight(75)
self.label_liveView.setFont(font)
self.label_liveView.setAlignment(QtCore.Qt.AlignCenter)
self.label_liveView.setObjectName('label_liveView')
self.gridLayout_7.addWidget(self.label_liveView, 0, 0, 1, 1)
self.gridLayout_14.addWidget(self.frame, 0, 0, 1, 1)
self.frame_cameraSettings = QtWidgets.QFrame(self.tab_scan_parameters)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_cameraSettings.sizePolicy().hasHeightForWidth())
self.frame_cameraSettings.setSizePolicy(sizePolicy)
self.frame_cameraSettings.setFrameShape(QtWidgets.QFrame.Box)
self.frame_cameraSettings.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_cameraSettings.setObjectName('frame_cameraSettings')
self.gridLayout_2 = QtWidgets.QGridLayout(self.frame_cameraSettings)
self.gridLayout_2.setObjectName('gridLayout_2')
self.label_selectCamera = QtWidgets.QLabel(self.frame_cameraSettings)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_selectCamera.setFont(font)
self.label_selectCamera.setObjectName('label_selectCamera')
self.gridLayout_2.addWidget(self.label_selectCamera, 2, 0, 1, 1)
self.pushButton_startLiveView = QtWidgets.QPushButton(self.frame_cameraSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_startLiveView.sizePolicy().hasHeightForWidth())
self.pushButton_startLiveView.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_startLiveView.setFont(font)
self.pushButton_startLiveView.setObjectName('pushButton_startLiveView')
self.gridLayout_2.addWidget(self.pushButton_startLiveView, 4, 0, 1, 1)
self.comboBox_selectCamera = QtWidgets.QComboBox(self.frame_cameraSettings)
self.comboBox_selectCamera.setObjectName('comboBox_selectCamera')
self.gridLayout_2.addWidget(self.comboBox_selectCamera, 2, 1, 1, 1)
self.pushButton_captureImage = QtWidgets.QPushButton(self.frame_cameraSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_captureImage.sizePolicy().hasHeightForWidth())
self.pushButton_captureImage.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_captureImage.setFont(font)
self.pushButton_captureImage.setObjectName('pushButton_captureImage')
self.gridLayout_2.addWidget(self.pushButton_captureImage, 4, 1, 1, 1)
self.stacked_camera_settings = QtWidgets.QStackedWidget(self.frame_cameraSettings)
self.stacked_camera_settings.setAccessibleDescription('')
self.stacked_camera_settings.setObjectName('stacked_camera_settings')
self.FLIR = QtWidgets.QWidget()
self.FLIR.setObjectName('FLIR')
self.gridLayout_3 = QtWidgets.QGridLayout(self.FLIR)
self.gridLayout_3.setObjectName('gridLayout_3')
self.label_highlightExposure = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_highlightExposure.setFont(font)
self.label_highlightExposure.setObjectName('label_highlightExposure')
self.gridLayout_3.addWidget(self.label_highlightExposure, 7, 0, 1, 1)
self.doubleSpinBox_balanceRatioRed = QtWidgets.QDoubleSpinBox(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_balanceRatioRed.setFont(font)
self.doubleSpinBox_balanceRatioRed.setDecimals(2)
self.doubleSpinBox_balanceRatioRed.setMinimum(0.25)
self.doubleSpinBox_balanceRatioRed.setMaximum(4.0)
self.doubleSpinBox_balanceRatioRed.setSingleStep(0.1)
self.doubleSpinBox_balanceRatioRed.setProperty('value', 1.58)
self.doubleSpinBox_balanceRatioRed.setObjectName('doubleSpinBox_balanceRatioRed')
self.gridLayout_3.addWidget(self.doubleSpinBox_balanceRatioRed, 5, 1, 1, 1)
self.checkBox_highlightExposure = QtWidgets.QCheckBox(self.FLIR)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.checkBox_highlightExposure.sizePolicy().hasHeightForWidth())
self.checkBox_highlightExposure.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.checkBox_highlightExposure.setFont(font)
self.checkBox_highlightExposure.setText('')
self.checkBox_highlightExposure.setObjectName('checkBox_highlightExposure')
self.gridLayout_3.addWidget(self.checkBox_highlightExposure, 7, 1, 1, 1)
self.doubleSpinBox_balanceRatioBlue = QtWidgets.QDoubleSpinBox(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_balanceRatioBlue.setFont(font)
self.doubleSpinBox_balanceRatioBlue.setDecimals(2)
self.doubleSpinBox_balanceRatioBlue.setMinimum(0.25)
self.doubleSpinBox_balanceRatioBlue.setMaximum(4.0)
self.doubleSpinBox_balanceRatioBlue.setSingleStep(0.1)
self.doubleSpinBox_balanceRatioBlue.setProperty('value', 1.79)
self.doubleSpinBox_balanceRatioBlue.setObjectName('doubleSpinBox_balanceRatioBlue')
self.gridLayout_3.addWidget(self.doubleSpinBox_balanceRatioBlue, 6, 1, 1, 1)
self.doubleSpinBox_gainLevel = QtWidgets.QDoubleSpinBox(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_gainLevel.setFont(font)
self.doubleSpinBox_gainLevel.setDecimals(2)
self.doubleSpinBox_gainLevel.setMinimum(0.0)
self.doubleSpinBox_gainLevel.setMaximum(25.0)
self.doubleSpinBox_gainLevel.setProperty('value', 1.83)
self.doubleSpinBox_gainLevel.setObjectName('doubleSpinBox_gainLevel')
self.gridLayout_3.addWidget(self.doubleSpinBox_gainLevel, 3, 1, 1, 1)
self.label_gamma = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_gamma.setFont(font)
self.label_gamma.setObjectName('label_gamma')
self.gridLayout_3.addWidget(self.label_gamma, 4, 0, 1, 1)
self.label_gainAuto = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_gainAuto.setFont(font)
self.label_gainAuto.setObjectName('label_gainAuto')
self.gridLayout_3.addWidget(self.label_gainAuto, 2, 0, 1, 1)
self.doubleSpinBox_gamma = QtWidgets.QDoubleSpinBox(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_gamma.setFont(font)
self.doubleSpinBox_gamma.setDecimals(2)
self.doubleSpinBox_gamma.setMinimum(0.1)
self.doubleSpinBox_gamma.setMaximum(4.0)
self.doubleSpinBox_gamma.setSingleStep(0.1)
self.doubleSpinBox_gamma.setProperty('value', 0.8)
self.doubleSpinBox_gamma.setObjectName('doubleSpinBox_gamma')
self.gridLayout_3.addWidget(self.doubleSpinBox_gamma, 4, 1, 1, 1)
self.checkBox_exposureAuto = QtWidgets.QCheckBox(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.checkBox_exposureAuto.setFont(font)
self.checkBox_exposureAuto.setText('')
self.checkBox_exposureAuto.setChecked(False)
self.checkBox_exposureAuto.setObjectName('checkBox_exposureAuto')
self.gridLayout_3.addWidget(self.checkBox_exposureAuto, 0, 1, 1, 1)
self.label_gainLevel = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_gainLevel.setFont(font)
self.label_gainLevel.setObjectName('label_gainLevel')
self.gridLayout_3.addWidget(self.label_gainLevel, 3, 0, 1, 1)
self.label_balanceRatioRed = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_balanceRatioRed.setFont(font)
self.label_balanceRatioRed.setObjectName('label_balanceRatioRed')
self.gridLayout_3.addWidget(self.label_balanceRatioRed, 5, 0, 1, 1)
self.doubleSpinBox_exposureTime = QtWidgets.QDoubleSpinBox(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_exposureTime.setFont(font)
self.doubleSpinBox_exposureTime.setDecimals(0)
self.doubleSpinBox_exposureTime.setMinimum(100.0)
self.doubleSpinBox_exposureTime.setMaximum(1000000.0)
self.doubleSpinBox_exposureTime.setSingleStep(1000.0)
self.doubleSpinBox_exposureTime.setProperty('value', 90000.0)
self.doubleSpinBox_exposureTime.setObjectName('doubleSpinBox_exposureTime')
self.gridLayout_3.addWidget(self.doubleSpinBox_exposureTime, 1, 1, 1, 1)
self.checkBox_gainAuto = QtWidgets.QCheckBox(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.checkBox_gainAuto.setFont(font)
self.checkBox_gainAuto.setText('')
self.checkBox_gainAuto.setObjectName('checkBox_gainAuto')
self.gridLayout_3.addWidget(self.checkBox_gainAuto, 2, 1, 1, 1)
self.label_balanceRatioBlue = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_balanceRatioBlue.setFont(font)
self.label_balanceRatioBlue.setObjectName('label_balanceRatioBlue')
self.gridLayout_3.addWidget(self.label_balanceRatioBlue, 6, 0, 1, 1)
self.label_exposureTime = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_exposureTime.setFont(font)
self.label_exposureTime.setObjectName('label_exposureTime')
self.gridLayout_3.addWidget(self.label_exposureTime, 1, 0, 1, 1)
self.label_exposureAuto = QtWidgets.QLabel(self.FLIR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_exposureAuto.setFont(font)
self.label_exposureAuto.setObjectName('label_exposureAuto')
self.gridLayout_3.addWidget(self.label_exposureAuto, 0, 0, 1, 1)
self.stacked_camera_settings.addWidget(self.FLIR)
self.DSLR = QtWidgets.QWidget()
self.DSLR.setObjectName('DSLR')
self.gridLayout_4 = QtWidgets.QGridLayout(self.DSLR)
self.gridLayout_4.setObjectName('gridLayout_4')
self.label_shutterSpeed = QtWidgets.QLabel(self.DSLR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_shutterSpeed.setFont(font)
self.label_shutterSpeed.setObjectName('label_shutterSpeed')
self.gridLayout_4.addWidget(self.label_shutterSpeed, 0, 0, 1, 1)
self.comboBox_shutterSpeed = QtWidgets.QComboBox(self.DSLR)
self.comboBox_shutterSpeed.setObjectName('comboBox_shutterSpeed')
self.gridLayout_4.addWidget(self.comboBox_shutterSpeed, 0, 1, 1, 1)
self.label_aperture = QtWidgets.QLabel(self.DSLR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_aperture.setFont(font)
self.label_aperture.setObjectName('label_aperture')
self.gridLayout_4.addWidget(self.label_aperture, 1, 0, 1, 1)
self.comboBox_aperture = QtWidgets.QComboBox(self.DSLR)
self.comboBox_aperture.setObjectName('comboBox_aperture')
self.gridLayout_4.addWidget(self.comboBox_aperture, 1, 1, 1, 1)
self.label_iso = QtWidgets.QLabel(self.DSLR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_iso.setFont(font)
self.label_iso.setObjectName('label_iso')
self.gridLayout_4.addWidget(self.label_iso, 2, 0, 1, 1)
self.comboBox_iso = QtWidgets.QComboBox(self.DSLR)
self.comboBox_iso.setObjectName('comboBox_iso')
self.gridLayout_4.addWidget(self.comboBox_iso, 2, 1, 1, 1)
self.label_whiteBalance = QtWidgets.QLabel(self.DSLR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_whiteBalance.setFont(font)
self.label_whiteBalance.setObjectName('label_whiteBalance')
self.gridLayout_4.addWidget(self.label_whiteBalance, 3, 0, 1, 1)
self.comboBox_whiteBalance = QtWidgets.QComboBox(self.DSLR)
self.comboBox_whiteBalance.setObjectName('comboBox_whiteBalance')
self.gridLayout_4.addWidget(self.comboBox_whiteBalance, 3, 1, 1, 1)
self.label_compression = QtWidgets.QLabel(self.DSLR)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_compression.setFont(font)
self.label_compression.setObjectName('label_compression')
self.gridLayout_4.addWidget(self.label_compression, 4, 0, 1, 1)
self.comboBox_compression = QtWidgets.QComboBox(self.DSLR)
self.comboBox_compression.setObjectName('comboBox_compression')
self.gridLayout_4.addWidget(self.comboBox_compression, 4, 1, 1, 1)
self.stacked_camera_settings.addWidget(self.DSLR)
self.gridLayout_2.addWidget(self.stacked_camera_settings, 3, 0, 1, 2)
self.label_cameraSettings = QtWidgets.QLabel(self.frame_cameraSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_cameraSettings.sizePolicy().hasHeightForWidth())
self.label_cameraSettings.setSizePolicy(sizePolicy)
self.label_cameraSettings.setMinimumSize(QtCore.QSize(0, 40))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
font.setKerning(True)
self.label_cameraSettings.setFont(font)
self.label_cameraSettings.setObjectName('label_cameraSettings')
self.gridLayout_2.addWidget(self.label_cameraSettings, 0, 0, 1, 1)
self.gridLayout_14.addWidget(self.frame_cameraSettings, 0, 1, 1, 1)
self.frame_outputSettings = QtWidgets.QFrame(self.tab_scan_parameters)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_outputSettings.sizePolicy().hasHeightForWidth())
self.frame_outputSettings.setSizePolicy(sizePolicy)
self.frame_outputSettings.setMinimumSize(QtCore.QSize(271, 0))
self.frame_outputSettings.setMaximumSize(QtCore.QSize(, ))
self.frame_outputSettings.setFrameShape(QtWidgets.QFrame.Box)
self.frame_outputSettings.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_outputSettings.setObjectName('frame_outputSettings')
self.gridLayout_12 = QtWidgets.QGridLayout(self.frame_outputSettings)
self.gridLayout_12.setObjectName('gridLayout_12')
self.label_folderName = QtWidgets.QLabel(self.frame_outputSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_folderName.sizePolicy().hasHeightForWidth())
self.label_folderName.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_folderName.setFont(font)
self.label_folderName.setObjectName('label_folderName')
self.gridLayout_12.addWidget(self.label_folderName, 5, 0, 1, 1)
self.pushButton_browseOutput = QtWidgets.QPushButton(self.frame_outputSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_browseOutput.sizePolicy().hasHeightForWidth())
self.pushButton_browseOutput.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_browseOutput.setFont(font)
self.pushButton_browseOutput.setObjectName('pushButton_browseOutput')
self.gridLayout_12.addWidget(self.pushButton_browseOutput, 3, 0, 1, 1)
self.label_outputSettings = QtWidgets.QLabel(self.frame_outputSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_outputSettings.sizePolicy().hasHeightForWidth())
self.label_outputSettings.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.label_outputSettings.setFont(font)
self.label_outputSettings.setObjectName('label_outputSettings')
self.gridLayout_12.addWidget(self.label_outputSettings, 0, 0, 1, 1)
self.lineEdit_projectName = QtWidgets.QLineEdit(self.frame_outputSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_projectName.sizePolicy().hasHeightForWidth())
self.lineEdit_projectName.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.lineEdit_projectName.setFont(font)
self.lineEdit_projectName.setObjectName('lineEdit_projectName')
self.gridLayout_12.addWidget(self.lineEdit_projectName, 9, 0, 1, 1)
self.label_projectName = QtWidgets.QLabel(self.frame_outputSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_projectName.sizePolicy().hasHeightForWidth())
self.label_projectName.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_projectName.setFont(font)
self.label_projectName.setObjectName('label_projectName')
self.gridLayout_12.addWidget(self.label_projectName, 7, 0, 1, 1)
self.lineEdit_outputLocation = QtWidgets.QLineEdit(self.frame_outputSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_outputLocation.sizePolicy().hasHeightForWidth())
self.lineEdit_outputLocation.setSizePolicy(sizePolicy)
self.lineEdit_outputLocation.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setItalic(True)
font.setWeight(50)
self.lineEdit_outputLocation.setFont(font)
self.lineEdit_outputLocation.setObjectName('lineEdit_outputLocation')
self.gridLayout_12.addWidget(self.lineEdit_outputLocation, 6, 0, 1, 1)
self.label_outputFolder = QtWidgets.QLabel(self.frame_outputSettings)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_outputFolder.sizePolicy().hasHeightForWidth())
self.label_outputFolder.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_outputFolder.setFont(font)
self.label_outputFolder.setObjectName('label_outputFolder')
self.gridLayout_12.addWidget(self.label_outputFolder, 2, 0, 1, 1)
self.gridLayout_14.addWidget(self.frame_outputSettings, 0, 2, 1, 2)
self.frame_info = QtWidgets.QFrame(self.tab_scan_parameters)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_info.sizePolicy().hasHeightForWidth())
self.frame_info.setSizePolicy(sizePolicy)
self.frame_info.setFrameShape(QtWidgets.QFrame.Box)
self.frame_info.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_info.setObjectName('frame_info')
self.gridLayout_9 = QtWidgets.QGridLayout(self.frame_info)
self.gridLayout_9.setObjectName('gridLayout_9')
self.listWidget_log = QtWidgets.QListWidget(self.frame_info)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.listWidget_log.sizePolicy().hasHeightForWidth())
self.listWidget_log.setSizePolicy(sizePolicy)
self.listWidget_log.setMinimumSize(QtCore.QSize(0, 0))
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(False)
font.setWeight(50)
self.listWidget_log.setFont(font)
self.listWidget_log.setFlow(QtWidgets.QListView.TopToBottom)
self.listWidget_log.setObjectName('listWidget_log')
self.gridLayout_9.addWidget(self.listWidget_log, 5, 0, 1, 1)
self.progressBar_total = QtWidgets.QProgressBar(self.frame_info)
self.progressBar_total.setEnabled(False)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.progressBar_total.sizePolicy().hasHeightForWidth())
self.progressBar_total.setSizePolicy(sizePolicy)
self.progressBar_total.setMaximumSize(QtCore.QSize(, 40))
self.progressBar_total.setProperty('value', 0)
self.progressBar_total.setObjectName('progressBar_total')
self.gridLayout_9.addWidget(self.progressBar_total, 3, 0, 1, 1)
self.label_log = QtWidgets.QLabel(self.frame_info)
self.label_log.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_log.setFont(font)
self.label_log.setObjectName('label_log')
self.gridLayout_9.addWidget(self.label_log, 4, 0, 1, 1)
self.label_progressTotal = QtWidgets.QLabel(self.frame_info)
self.label_progressTotal.setEnabled(False)
self.label_progressTotal.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_progressTotal.setFont(font)
self.label_progressTotal.setObjectName('label_progressTotal')
self.gridLayout_9.addWidget(self.label_progressTotal, 2, 0, 1, 1)
self.label_info = QtWidgets.QLabel(self.frame_info)
self.label_info.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.label_info.setFont(font)
self.label_info.setObjectName('label_info')
self.gridLayout_9.addWidget(self.label_info, 1, 0, 1, 1)
self.gridLayout_14.addWidget(self.frame_info, 1, 2, 1, 2)
self.frame_stepperControl = QtWidgets.QFrame(self.tab_scan_parameters)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_stepperControl.sizePolicy().hasHeightForWidth())
self.frame_stepperControl.setSizePolicy(sizePolicy)
self.frame_stepperControl.setMinimumSize(QtCore.QSize(1108, 351))
self.frame_stepperControl.setFrameShape(QtWidgets.QFrame.Box)
self.frame_stepperControl.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_stepperControl.setObjectName('frame_stepperControl')
self.gridLayout_6 = QtWidgets.QGridLayout(self.frame_stepperControl)
self.gridLayout_6.setObjectName('gridLayout_6')
self.label_yAxis = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_yAxis.setFont(font)
self.label_yAxis.setObjectName('label_yAxis')
self.gridLayout_6.addWidget(self.label_yAxis, 5, 0, 1, 1)
self.label_setRangeZMin = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeZMin.sizePolicy().hasHeightForWidth())
self.label_setRangeZMin.setSizePolicy(sizePolicy)
self.label_setRangeZMin.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeZMin.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeZMin.setFont(font)
self.label_setRangeZMin.setObjectName('label_setRangeZMin')
self.gridLayout_6.addWidget(self.label_setRangeZMin, 9, 3, 1, 1)
self.label_xAxisSliderMin = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.label_xAxisSliderMin.setFont(font)
self.label_xAxisSliderMin.setObjectName('label_xAxisSliderMin')
self.gridLayout_6.addWidget(self.label_xAxisSliderMin, 3, 0, 1, 1)
self.label_zAxisSliderMin = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.label_zAxisSliderMin.setFont(font)
self.label_zAxisSliderMin.setObjectName('label_zAxisSliderMin')
self.gridLayout_6.addWidget(self.label_zAxisSliderMin, 9, 0, 1, 1)
self.label_zAxisSliderMax = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.label_zAxisSliderMax.setFont(font)
self.label_zAxisSliderMax.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.label_zAxisSliderMax.setObjectName('label_zAxisSliderMax')
self.gridLayout_6.addWidget(self.label_zAxisSliderMax, 9, 1, 1, 1)
self.label_setRangeXMin = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeXMin.sizePolicy().hasHeightForWidth())
self.label_setRangeXMin.setSizePolicy(sizePolicy)
self.label_setRangeXMin.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeXMin.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeXMin.setFont(font)
self.label_setRangeXMin.setObjectName('label_setRangeXMin')
self.gridLayout_6.addWidget(self.label_setRangeXMin, 3, 3, 1, 1)
self.horizontalSlider_xAxis = QtWidgets.QSlider(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.horizontalSlider_xAxis.sizePolicy().hasHeightForWidth())
self.horizontalSlider_xAxis.setSizePolicy(sizePolicy)
self.horizontalSlider_xAxis.setMaximum(450)
self.horizontalSlider_xAxis.setOrientation(QtCore.Qt.Horizontal)
self.horizontalSlider_xAxis.setObjectName('horizontalSlider_xAxis')
self.gridLayout_6.addWidget(self.horizontalSlider_xAxis, 4, 0, 1, 2)
self.horizontalSlider_zAxis = QtWidgets.QSlider(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.horizontalSlider_zAxis.sizePolicy().hasHeightForWidth())
self.horizontalSlider_zAxis.setSizePolicy(sizePolicy)
self.horizontalSlider_zAxis.setMinimum((- 45000))
self.horizontalSlider_zAxis.setMaximum(0)
self.horizontalSlider_zAxis.setOrientation(QtCore.Qt.Horizontal)
self.horizontalSlider_zAxis.setObjectName('horizontalSlider_zAxis')
self.gridLayout_6.addWidget(self.horizontalSlider_zAxis, 10, 0, 1, 2)
self.pushButton_xHome = QtWidgets.QPushButton(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_xHome.sizePolicy().hasHeightForWidth())
self.pushButton_xHome.setSizePolicy(sizePolicy)
self.pushButton_xHome.setMinimumSize(QtCore.QSize(120, 30))
self.pushButton_xHome.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_xHome.setFont(font)
self.pushButton_xHome.setObjectName('pushButton_xHome')
self.gridLayout_6.addWidget(self.pushButton_xHome, 3, 2, 1, 1)
self.label_zAxis = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_zAxis.setFont(font)
self.label_zAxis.setObjectName('label_zAxis')
self.gridLayout_6.addWidget(self.label_zAxis, 8, 0, 1, 1)
self.label_xAxis = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_xAxis.setFont(font)
self.label_xAxis.setObjectName('label_xAxis')
self.gridLayout_6.addWidget(self.label_xAxis, 1, 0, 1, 1)
self.doubleSpinBox_zMin = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_zMin.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_zMin.setSizePolicy(sizePolicy)
self.doubleSpinBox_zMin.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_zMin.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_zMin.setFont(font)
self.doubleSpinBox_zMin.setDecimals(0)
self.doubleSpinBox_zMin.setMinimum((- 45000.0))
self.doubleSpinBox_zMin.setMaximum(0.0)
self.doubleSpinBox_zMin.setSingleStep(1000.0)
self.doubleSpinBox_zMin.setProperty('value', (- 20000.0))
self.doubleSpinBox_zMin.setObjectName('doubleSpinBox_zMin')
self.gridLayout_6.addWidget(self.doubleSpinBox_zMin, 10, 3, 1, 1)
self.lcdNumber_zAxis = QtWidgets.QLCDNumber(self.frame_stepperControl)
self.lcdNumber_zAxis.setEnabled(True)
self.lcdNumber_zAxis.setMinimumSize(QtCore.QSize(120, 0))
self.lcdNumber_zAxis.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.lcdNumber_zAxis.setFont(font)
self.lcdNumber_zAxis.setFrameShadow(QtWidgets.QFrame.Plain)
self.lcdNumber_zAxis.setSmallDecimalPoint(True)
self.lcdNumber_zAxis.setDigitCount(6)
self.lcdNumber_zAxis.setSegmentStyle(QtWidgets.QLCDNumber.Flat)
self.lcdNumber_zAxis.setProperty('intValue', 0)
self.lcdNumber_zAxis.setObjectName('lcdNumber_zAxis')
self.gridLayout_6.addWidget(self.lcdNumber_zAxis, 10, 2, 1, 1)
self.doubleSpinBox_yMin = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_yMin.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_yMin.setSizePolicy(sizePolicy)
self.doubleSpinBox_yMin.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_yMin.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_yMin.setFont(font)
self.doubleSpinBox_yMin.setDecimals(0)
self.doubleSpinBox_yMin.setMinimum(0.0)
self.doubleSpinBox_yMin.setMaximum(1599.0)
self.doubleSpinBox_yMin.setSingleStep(5.0)
self.doubleSpinBox_yMin.setProperty('value', 0.0)
self.doubleSpinBox_yMin.setObjectName('doubleSpinBox_yMin')
self.gridLayout_6.addWidget(self.doubleSpinBox_yMin, 7, 3, 1, 1)
self.label_xAxisSliderMax = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.label_xAxisSliderMax.setFont(font)
self.label_xAxisSliderMax.setAutoFillBackground(False)
self.label_xAxisSliderMax.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.label_xAxisSliderMax.setObjectName('label_xAxisSliderMax')
self.gridLayout_6.addWidget(self.label_xAxisSliderMax, 3, 1, 1, 1)
self.lcdNumber_yAxis = QtWidgets.QLCDNumber(self.frame_stepperControl)
self.lcdNumber_yAxis.setMinimumSize(QtCore.QSize(120, 0))
self.lcdNumber_yAxis.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.lcdNumber_yAxis.setFont(font)
self.lcdNumber_yAxis.setFrameShadow(QtWidgets.QFrame.Plain)
self.lcdNumber_yAxis.setDigitCount(6)
self.lcdNumber_yAxis.setSegmentStyle(QtWidgets.QLCDNumber.Flat)
self.lcdNumber_yAxis.setObjectName('lcdNumber_yAxis')
self.gridLayout_6.addWidget(self.lcdNumber_yAxis, 7, 2, 1, 1)
self.label_setRangeYMin = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeYMin.sizePolicy().hasHeightForWidth())
self.label_setRangeYMin.setSizePolicy(sizePolicy)
self.label_setRangeYMin.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeYMin.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeYMin.setFont(font)
self.label_setRangeYMin.setObjectName('label_setRangeYMin')
self.gridLayout_6.addWidget(self.label_setRangeYMin, 6, 3, 1, 1)
self.pushButton_zHome = QtWidgets.QPushButton(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_zHome.sizePolicy().hasHeightForWidth())
self.pushButton_zHome.setSizePolicy(sizePolicy)
self.pushButton_zHome.setMinimumSize(QtCore.QSize(120, 30))
self.pushButton_zHome.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_zHome.setFont(font)
self.pushButton_zHome.setObjectName('pushButton_zHome')
self.gridLayout_6.addWidget(self.pushButton_zHome, 9, 2, 1, 1)
self.label_yAxisSliderMax = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.label_yAxisSliderMax.setFont(font)
self.label_yAxisSliderMax.setAlignment(((QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing) | QtCore.Qt.AlignVCenter))
self.label_yAxisSliderMax.setObjectName('label_yAxisSliderMax')
self.gridLayout_6.addWidget(self.label_yAxisSliderMax, 6, 1, 1, 1)
self.lcdNumber_xAxis = QtWidgets.QLCDNumber(self.frame_stepperControl)
self.lcdNumber_xAxis.setMinimumSize(QtCore.QSize(120, 0))
self.lcdNumber_xAxis.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.lcdNumber_xAxis.setFont(font)
self.lcdNumber_xAxis.setFrameShadow(QtWidgets.QFrame.Plain)
self.lcdNumber_xAxis.setDigitCount(6)
self.lcdNumber_xAxis.setSegmentStyle(QtWidgets.QLCDNumber.Flat)
self.lcdNumber_xAxis.setObjectName('lcdNumber_xAxis')
self.gridLayout_6.addWidget(self.lcdNumber_xAxis, 4, 2, 1, 1)
self.pushButton_yReset = QtWidgets.QPushButton(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_yReset.sizePolicy().hasHeightForWidth())
self.pushButton_yReset.setSizePolicy(sizePolicy)
self.pushButton_yReset.setMinimumSize(QtCore.QSize(120, 30))
self.pushButton_yReset.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_yReset.setFont(font)
self.pushButton_yReset.setObjectName('pushButton_yReset')
self.gridLayout_6.addWidget(self.pushButton_yReset, 6, 2, 1, 1)
self.label_yAxisSliderMin = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.label_yAxisSliderMin.setFont(font)
self.label_yAxisSliderMin.setObjectName('label_yAxisSliderMin')
self.gridLayout_6.addWidget(self.label_yAxisSliderMin, 6, 0, 1, 1)
self.horizontalSlider_yAxis = QtWidgets.QSlider(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.horizontalSlider_yAxis.sizePolicy().hasHeightForWidth())
self.horizontalSlider_yAxis.setSizePolicy(sizePolicy)
self.horizontalSlider_yAxis.setMinimum((- 1600))
self.horizontalSlider_yAxis.setMaximum(1600)
self.horizontalSlider_yAxis.setOrientation(QtCore.Qt.Horizontal)
self.horizontalSlider_yAxis.setObjectName('horizontalSlider_yAxis')
self.gridLayout_6.addWidget(self.horizontalSlider_yAxis, 7, 0, 1, 2)
self.label_stepperControl = QtWidgets.QLabel(self.frame_stepperControl)
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.label_stepperControl.setFont(font)
self.label_stepperControl.setObjectName('label_stepperControl')
self.gridLayout_6.addWidget(self.label_stepperControl, 0, 0, 1, 1)
self.label_setRangeYStep = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeYStep.sizePolicy().hasHeightForWidth())
self.label_setRangeYStep.setSizePolicy(sizePolicy)
self.label_setRangeYStep.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeYStep.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeYStep.setFont(font)
self.label_setRangeYStep.setObjectName('label_setRangeYStep')
self.gridLayout_6.addWidget(self.label_setRangeYStep, 6, 5, 1, 1)
self.doubleSpinBox_yStep = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_yStep.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_yStep.setSizePolicy(sizePolicy)
self.doubleSpinBox_yStep.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_yStep.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_yStep.setFont(font)
self.doubleSpinBox_yStep.setDecimals(0)
self.doubleSpinBox_yStep.setMinimum(0.0)
self.doubleSpinBox_yStep.setMaximum(1600.0)
self.doubleSpinBox_yStep.setSingleStep(5.0)
self.doubleSpinBox_yStep.setProperty('value', 80.0)
self.doubleSpinBox_yStep.setObjectName('doubleSpinBox_yStep')
self.gridLayout_6.addWidget(self.doubleSpinBox_yStep, 7, 5, 1, 1)
self.label_setRangeXMax = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeXMax.sizePolicy().hasHeightForWidth())
self.label_setRangeXMax.setSizePolicy(sizePolicy)
self.label_setRangeXMax.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeXMax.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeXMax.setFont(font)
self.label_setRangeXMax.setObjectName('label_setRangeXMax')
self.gridLayout_6.addWidget(self.label_setRangeXMax, 3, 6, 1, 1)
self.doubleSpinBox_xMin = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_xMin.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_xMin.setSizePolicy(sizePolicy)
self.doubleSpinBox_xMin.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_xMin.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_xMin.setFont(font)
self.doubleSpinBox_xMin.setDecimals(0)
self.doubleSpinBox_xMin.setMinimum(0.0)
self.doubleSpinBox_xMin.setMaximum(450.0)
self.doubleSpinBox_xMin.setSingleStep(5.0)
self.doubleSpinBox_xMin.setProperty('value', 0.0)
self.doubleSpinBox_xMin.setObjectName('doubleSpinBox_xMin')
self.gridLayout_6.addWidget(self.doubleSpinBox_xMin, 4, 3, 1, 1)
self.pushButton_Energise = QtWidgets.QPushButton(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_Energise.sizePolicy().hasHeightForWidth())
self.pushButton_Energise.setSizePolicy(sizePolicy)
self.pushButton_Energise.setMinimumSize(QtCore.QSize(120, 30))
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(True)
font.setWeight(75)
self.pushButton_Energise.setFont(font)
self.pushButton_Energise.setAutoFillBackground(False)
self.pushButton_Energise.setStyleSheet('background-color: rgb(85, 255, 20)')
self.pushButton_Energise.setObjectName('pushButton_Energise')
self.gridLayout_6.addWidget(self.pushButton_Energise, 0, 2, 1, 1)
self.pushButton_stepperDeEnergise = QtWidgets.QPushButton(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.pushButton_stepperDeEnergise.sizePolicy().hasHeightForWidth())
self.pushButton_stepperDeEnergise.setSizePolicy(sizePolicy)
self.pushButton_stepperDeEnergise.setMinimumSize(QtCore.QSize(120, 30))
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(True)
font.setWeight(75)
self.pushButton_stepperDeEnergise.setFont(font)
self.pushButton_stepperDeEnergise.setStyleSheet('background-color: rgb(255, 76, 79)')
self.pushButton_stepperDeEnergise.setAutoDefault(False)
self.pushButton_stepperDeEnergise.setObjectName('pushButton_stepperDeEnergise')
self.gridLayout_6.addWidget(self.pushButton_stepperDeEnergise, 0, 3, 1, 1)
self.doubleSpinBox_xStep = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_xStep.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_xStep.setSizePolicy(sizePolicy)
self.doubleSpinBox_xStep.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_xStep.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_xStep.setFont(font)
self.doubleSpinBox_xStep.setDecimals(0)
self.doubleSpinBox_xStep.setMinimum(0.0)
self.doubleSpinBox_xStep.setMaximum(450.0)
self.doubleSpinBox_xStep.setSingleStep(5.0)
self.doubleSpinBox_xStep.setProperty('value', 50.0)
self.doubleSpinBox_xStep.setObjectName('doubleSpinBox_xStep')
self.gridLayout_6.addWidget(self.doubleSpinBox_xStep, 4, 5, 1, 1)
self.label_setRangeZStep = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeZStep.sizePolicy().hasHeightForWidth())
self.label_setRangeZStep.setSizePolicy(sizePolicy)
self.label_setRangeZStep.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeZStep.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeZStep.setFont(font)
self.label_setRangeZStep.setObjectName('label_setRangeZStep')
self.gridLayout_6.addWidget(self.label_setRangeZStep, 9, 5, 1, 1)
self.doubleSpinBox_yMax = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_yMax.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_yMax.setSizePolicy(sizePolicy)
self.doubleSpinBox_yMax.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_yMax.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_yMax.setFont(font)
self.doubleSpinBox_yMax.setDecimals(0)
self.doubleSpinBox_yMax.setMinimum(0.0)
self.doubleSpinBox_yMax.setMaximum(1600.0)
self.doubleSpinBox_yMax.setSingleStep(5.0)
self.doubleSpinBox_yMax.setProperty('value', 1600.0)
self.doubleSpinBox_yMax.setObjectName('doubleSpinBox_yMax')
self.gridLayout_6.addWidget(self.doubleSpinBox_yMax, 7, 6, 1, 1)
self.label_setRangeXStep = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeXStep.sizePolicy().hasHeightForWidth())
self.label_setRangeXStep.setSizePolicy(sizePolicy)
self.label_setRangeXStep.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeXStep.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeXStep.setFont(font)
self.label_setRangeXStep.setObjectName('label_setRangeXStep')
self.gridLayout_6.addWidget(self.label_setRangeXStep, 3, 5, 1, 1)
self.doubleSpinBox_xMax = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_xMax.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_xMax.setSizePolicy(sizePolicy)
self.doubleSpinBox_xMax.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_xMax.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_xMax.setFont(font)
self.doubleSpinBox_xMax.setDecimals(0)
self.doubleSpinBox_xMax.setMinimum(0.0)
self.doubleSpinBox_xMax.setMaximum(450.0)
self.doubleSpinBox_xMax.setSingleStep(5.0)
self.doubleSpinBox_xMax.setProperty('value', 450.0)
self.doubleSpinBox_xMax.setObjectName('doubleSpinBox_xMax')
self.gridLayout_6.addWidget(self.doubleSpinBox_xMax, 4, 6, 1, 1)
self.doubleSpinBox_zStep = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_zStep.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_zStep.setSizePolicy(sizePolicy)
self.doubleSpinBox_zStep.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_zStep.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_zStep.setFont(font)
self.doubleSpinBox_zStep.setDecimals(0)
self.doubleSpinBox_zStep.setMinimum(50.0)
self.doubleSpinBox_zStep.setMaximum(10000.0)
self.doubleSpinBox_zStep.setSingleStep(50.0)
self.doubleSpinBox_zStep.setProperty('value', 500.0)
self.doubleSpinBox_zStep.setObjectName('doubleSpinBox_zStep')
self.gridLayout_6.addWidget(self.doubleSpinBox_zStep, 10, 5, 1, 1)
self.label_setRangeYMax = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeYMax.sizePolicy().hasHeightForWidth())
self.label_setRangeYMax.setSizePolicy(sizePolicy)
self.label_setRangeYMax.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeYMax.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeYMax.setFont(font)
self.label_setRangeYMax.setObjectName('label_setRangeYMax')
self.gridLayout_6.addWidget(self.label_setRangeYMax, 6, 6, 1, 1)
self.doubleSpinBox_zMax = QtWidgets.QDoubleSpinBox(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.doubleSpinBox_zMax.sizePolicy().hasHeightForWidth())
self.doubleSpinBox_zMax.setSizePolicy(sizePolicy)
self.doubleSpinBox_zMax.setMinimumSize(QtCore.QSize(120, 0))
self.doubleSpinBox_zMax.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_zMax.setFont(font)
self.doubleSpinBox_zMax.setDecimals(0)
self.doubleSpinBox_zMax.setMinimum((- 35000.0))
self.doubleSpinBox_zMax.setMaximum(0.0)
self.doubleSpinBox_zMax.setSingleStep(1000.0)
self.doubleSpinBox_zMax.setProperty('value', (- 8000.0))
self.doubleSpinBox_zMax.setObjectName('doubleSpinBox_zMax')
self.gridLayout_6.addWidget(self.doubleSpinBox_zMax, 10, 6, 1, 1)
self.label_setRangeZMax = QtWidgets.QLabel(self.frame_stepperControl)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_setRangeZMax.sizePolicy().hasHeightForWidth())
self.label_setRangeZMax.setSizePolicy(sizePolicy)
self.label_setRangeZMax.setMinimumSize(QtCore.QSize(120, 0))
self.label_setRangeZMax.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_setRangeZMax.setFont(font)
self.label_setRangeZMax.setObjectName('label_setRangeZMax')
self.gridLayout_6.addWidget(self.label_setRangeZMax, 9, 6, 1, 1)
self.label_setRange = QtWidgets.QLabel(self.frame_stepperControl)
self.label_setRange.setMinimumSize(QtCore.QSize(120, 0))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_setRange.setFont(font)
self.label_setRange.setAlignment(QtCore.Qt.AlignCenter)
self.label_setRange.setObjectName('label_setRange')
self.gridLayout_6.addWidget(self.label_setRange, 1, 3, 1, 1)
self.gridLayout_14.addWidget(self.frame_stepperControl, 1, 0, 1, 2)
self.tabWidget.addTab(self.tab_scan_parameters, '')
self.tab_post_processing = QtWidgets.QWidget()
self.tab_post_processing.setMinimumSize(QtCore.QSize(1405, 840))
self.tab_post_processing.setObjectName('tab_post_processing')
self.gridLayout_5 = QtWidgets.QGridLayout(self.tab_post_processing)
self.gridLayout_5.setObjectName('gridLayout_5')
self.frame_live_view = QtWidgets.QFrame(self.tab_post_processing)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_live_view.sizePolicy().hasHeightForWidth())
self.frame_live_view.setSizePolicy(sizePolicy)
self.frame_live_view.setFrameShape(QtWidgets.QFrame.Box)
self.frame_live_view.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_live_view.setObjectName('frame_live_view')
self.gridLayout = QtWidgets.QGridLayout(self.frame_live_view)
self.gridLayout.setObjectName('gridLayout')
self.label_liveViewPost = QtWidgets.QLabel(self.frame_live_view)
self.label_liveViewPost.setEnabled(True)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_liveViewPost.sizePolicy().hasHeightForWidth())
self.label_liveViewPost.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setItalic(False)
font.setWeight(75)
self.label_liveViewPost.setFont(font)
self.label_liveViewPost.setAlignment(QtCore.Qt.AlignCenter)
self.label_liveViewPost.setObjectName('label_liveViewPost')
self.gridLayout.addWidget(self.label_liveViewPost, 1, 0, 1, 1)
self.gridLayout_5.addWidget(self.frame_live_view, 0, 0, 1, 1)
self.frame_exinf = QtWidgets.QFrame(self.tab_post_processing)
self.frame_exinf.setMaximumSize(QtCore.QSize(, ))
self.frame_exinf.setAcceptDrops(False)
self.frame_exinf.setFrameShape(QtWidgets.QFrame.Box)
self.frame_exinf.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_exinf.setObjectName('frame_exinf')
self.gridLayout_13 = QtWidgets.QGridLayout(self.frame_exinf)
self.gridLayout_13.setObjectName('gridLayout_13')
self.lineEdit_lensModel = QtWidgets.QLineEdit(self.frame_exinf)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_lensModel.sizePolicy().hasHeightForWidth())
self.lineEdit_lensModel.setSizePolicy(sizePolicy)
self.lineEdit_lensModel.setObjectName('lineEdit_lensModel')
self.gridLayout_13.addWidget(self.lineEdit_lensModel, 6, 1, 1, 1)
self.lineEdit_lensManufacturer = QtWidgets.QLineEdit(self.frame_exinf)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_lensManufacturer.sizePolicy().hasHeightForWidth())
self.lineEdit_lensManufacturer.setSizePolicy(sizePolicy)
self.lineEdit_lensManufacturer.setObjectName('lineEdit_lensManufacturer')
self.gridLayout_13.addWidget(self.lineEdit_lensManufacturer, 5, 1, 1, 1)
self.label_focalLength = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_focalLength.setFont(font)
self.label_focalLength.setObjectName('label_focalLength')
self.gridLayout_13.addWidget(self.label_focalLength, 7, 0, 1, 1)
self.label_lens = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_lens.setFont(font)
self.label_lens.setObjectName('label_lens')
self.gridLayout_13.addWidget(self.label_lens, 4, 0, 1, 1)
self.lineEdit_focalLengthIn35mmFormat = QtWidgets.QLineEdit(self.frame_exinf)
self.lineEdit_focalLengthIn35mmFormat.setEnabled(True)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_focalLengthIn35mmFormat.sizePolicy().hasHeightForWidth())
self.lineEdit_focalLengthIn35mmFormat.setSizePolicy(sizePolicy)
self.lineEdit_focalLengthIn35mmFormat.setObjectName('lineEdit_focalLengthIn35mmFormat')
self.gridLayout_13.addWidget(self.lineEdit_focalLengthIn35mmFormat, 9, 1, 1, 1)
self.label_model = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_model.setFont(font)
self.label_model.setObjectName('label_model')
self.gridLayout_13.addWidget(self.label_model, 2, 0, 1, 1)
self.label_serialNumber = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_serialNumber.setFont(font)
self.label_serialNumber.setObjectName('label_serialNumber')
self.gridLayout_13.addWidget(self.label_serialNumber, 3, 0, 1, 1)
self.lineEdit_focalLength = QtWidgets.QLineEdit(self.frame_exinf)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_focalLength.sizePolicy().hasHeightForWidth())
self.lineEdit_focalLength.setSizePolicy(sizePolicy)
self.lineEdit_focalLength.setObjectName('lineEdit_focalLength')
self.gridLayout_13.addWidget(self.lineEdit_focalLength, 7, 1, 1, 1)
self.lineEdit_sensorWidth = QtWidgets.QLineEdit(self.frame_exinf)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_sensorWidth.sizePolicy().hasHeightForWidth())
self.lineEdit_sensorWidth.setSizePolicy(sizePolicy)
self.lineEdit_sensorWidth.setClearButtonEnabled(False)
self.lineEdit_sensorWidth.setObjectName('lineEdit_sensorWidth')
self.gridLayout_13.addWidget(self.lineEdit_sensorWidth, 8, 1, 1, 1)
self.label_make = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_make.setFont(font)
self.label_make.setObjectName('label_make')
self.gridLayout_13.addWidget(self.label_make, 1, 0, 1, 1)
self.comboBox_make = QtWidgets.QComboBox(self.frame_exinf)
self.comboBox_make.setEditable(False)
self.comboBox_make.setObjectName('comboBox_make')
self.gridLayout_13.addWidget(self.comboBox_make, 1, 1, 1, 1)
self.label_lensManufacturer = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_lensManufacturer.setFont(font)
self.label_lensManufacturer.setObjectName('label_lensManufacturer')
self.gridLayout_13.addWidget(self.label_lensManufacturer, 5, 0, 1, 1)
self.label_sensorWidth = QtWidgets.QLabel(self.frame_exinf)
self.label_sensorWidth.setMaximumSize(QtCore.QSize(, 20))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_sensorWidth.setFont(font)
self.label_sensorWidth.setObjectName('label_sensorWidth')
self.gridLayout_13.addWidget(self.label_sensorWidth, 8, 0, 1, 1)
self.label_lensModel = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_lensModel.setFont(font)
self.label_lensModel.setObjectName('label_lensModel')
self.gridLayout_13.addWidget(self.label_lensModel, 6, 0, 1, 1)
self.comboBox_model = QtWidgets.QComboBox(self.frame_exinf)
self.comboBox_model.setEditable(False)
self.comboBox_model.setObjectName('comboBox_model')
self.gridLayout_13.addWidget(self.comboBox_model, 2, 1, 1, 1)
self.lineEdit_lens = QtWidgets.QLineEdit(self.frame_exinf)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_lens.sizePolicy().hasHeightForWidth())
self.lineEdit_lens.setSizePolicy(sizePolicy)
self.lineEdit_lens.setObjectName('lineEdit_lens')
self.gridLayout_13.addWidget(self.lineEdit_lens, 4, 1, 1, 1)
self.lineEdit_serialNumber = QtWidgets.QLineEdit(self.frame_exinf)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lineEdit_serialNumber.sizePolicy().hasHeightForWidth())
self.lineEdit_serialNumber.setSizePolicy(sizePolicy)
self.lineEdit_serialNumber.setObjectName('lineEdit_serialNumber')
self.gridLayout_13.addWidget(self.lineEdit_serialNumber, 3, 1, 1, 1)
self.label_focalLengthIn35mmFormat = QtWidgets.QLabel(self.frame_exinf)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_focalLengthIn35mmFormat.setFont(font)
self.label_focalLengthIn35mmFormat.setObjectName('label_focalLengthIn35mmFormat')
self.gridLayout_13.addWidget(self.label_focalLengthIn35mmFormat, 9, 0, 1, 1)
self.label = QtWidgets.QLabel(self.frame_exinf)
self.label.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setObjectName('label')
self.gridLayout_13.addWidget(self.label, 0, 0, 1, 1)
self.gridLayout_5.addWidget(self.frame_exinf, 0, 3, 1, 1)
self.frame_infoPost = QtWidgets.QFrame(self.tab_post_processing)
self.frame_infoPost.setFrameShape(QtWidgets.QFrame.Box)
self.frame_infoPost.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_infoPost.setObjectName('frame_infoPost')
self.gridLayout_8 = QtWidgets.QGridLayout(self.frame_infoPost)
self.gridLayout_8.setObjectName('gridLayout_8')
self.label_infoPost = QtWidgets.QLabel(self.frame_infoPost)
self.label_infoPost.setMinimumSize(QtCore.QSize(1039, 18))
self.label_infoPost.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.label_infoPost.setFont(font)
self.label_infoPost.setObjectName('label_infoPost')
self.gridLayout_8.addWidget(self.label_infoPost, 0, 0, 1, 1)
self.label_progressTotalPost = QtWidgets.QLabel(self.frame_infoPost)
self.label_progressTotalPost.setEnabled(False)
self.label_progressTotalPost.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_progressTotalPost.setFont(font)
self.label_progressTotalPost.setObjectName('label_progressTotalPost')
self.gridLayout_8.addWidget(self.label_progressTotalPost, 1, 0, 1, 1)
self.label_logPost = QtWidgets.QLabel(self.frame_infoPost)
self.label_logPost.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(False)
font.setWeight(50)
self.label_logPost.setFont(font)
self.label_logPost.setObjectName('label_logPost')
self.gridLayout_8.addWidget(self.label_logPost, 3, 0, 1, 1)
self.listWidget_logPost = QtWidgets.QListWidget(self.frame_infoPost)
self.listWidget_logPost.setMaximumSize(QtCore.QSize(1400, 600))
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(False)
font.setWeight(50)
self.listWidget_logPost.setFont(font)
self.listWidget_logPost.setFlow(QtWidgets.QListView.TopToBottom)
self.listWidget_logPost.setObjectName('listWidget_logPost')
self.gridLayout_8.addWidget(self.listWidget_logPost, 4, 0, 1, 1)
self.progressBar_totalPost = QtWidgets.QProgressBar(self.frame_infoPost)
self.progressBar_totalPost.setEnabled(False)
self.progressBar_totalPost.setMaximumSize(QtCore.QSize(, 40))
self.progressBar_totalPost.setProperty('value', 0)
self.progressBar_totalPost.setObjectName('progressBar_totalPost')
self.gridLayout_8.addWidget(self.progressBar_totalPost, 2, 0, 1, 1)
self.gridLayout_5.addWidget(self.frame_infoPost, 1, 0, 2, 2)
self.frame_startScan = QtWidgets.QFrame(self.tab_post_processing)
self.frame_startScan.setEnabled(True)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_startScan.sizePolicy().hasHeightForWidth())
self.frame_startScan.setSizePolicy(sizePolicy)
self.frame_startScan.setFrameShape(QtWidgets.QFrame.Box)
self.frame_startScan.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_startScan.setObjectName('frame_startScan')
self.gridLayout_11 = QtWidgets.QGridLayout(self.frame_startScan)
self.gridLayout_11.setObjectName('gridLayout_11')
self.pushButton_startScan = QtWidgets.QPushButton(self.frame_startScan)
self.pushButton_startScan.setMinimumSize(QtCore.QSize(0, 30))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(True)
font.setWeight(75)
self.pushButton_startScan.setFont(font)
self.pushButton_startScan.setStyleSheet('background-color: rgb(85, 255, 20)')
self.pushButton_startScan.setObjectName('pushButton_startScan')
self.gridLayout_11.addWidget(self.pushButton_startScan, 0, 0, 1, 1)
self.gridLayout_5.addWidget(self.frame_startScan, 2, 2, 1, 2)
self.frame_solePostProcess = QtWidgets.QFrame(self.tab_post_processing)
self.frame_solePostProcess.setFrameShape(QtWidgets.QFrame.Box)
self.frame_solePostProcess.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_solePostProcess.setObjectName('frame_solePostProcess')
self.gridLayout_16 = QtWidgets.QGridLayout(self.frame_solePostProcess)
self.gridLayout_16.setObjectName('gridLayout_16')
self.lineEdit_processingFolder = QtWidgets.QLineEdit(self.frame_solePostProcess)
self.lineEdit_processingFolder.setEnabled(True)
self.lineEdit_processingFolder.setObjectName('lineEdit_processingFolder')
self.gridLayout_16.addWidget(self.lineEdit_processingFolder, 0, 1, 1, 1)
self.pushButton_processingOutput = QtWidgets.QPushButton(self.frame_solePostProcess)
self.pushButton_processingOutput.setEnabled(True)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_processingOutput.setFont(font)
self.pushButton_processingOutput.setObjectName('pushButton_processingOutput')
self.gridLayout_16.addWidget(self.pushButton_processingOutput, 0, 0, 1, 1)
self.pushButton_runPostProcessing = QtWidgets.QPushButton(self.frame_solePostProcess)
self.pushButton_runPostProcessing.setEnabled(True)
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.pushButton_runPostProcessing.setFont(font)
self.pushButton_runPostProcessing.setObjectName('pushButton_runPostProcessing')
self.gridLayout_16.addWidget(self.pushButton_runPostProcessing, 3, 0, 1, 2)
self.gridLayout_5.addWidget(self.frame_solePostProcess, 1, 2, 1, 2)
self.frame_post_processing_2 = QtWidgets.QFrame(self.tab_post_processing)
self.frame_post_processing_2.setFrameShape(QtWidgets.QFrame.Box)
self.frame_post_processing_2.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_post_processing_2.setObjectName('frame_post_processing_2')
self.gridLayout_10 = QtWidgets.QGridLayout(self.frame_post_processing_2)
self.gridLayout_10.setObjectName('gridLayout_10')
self.checkBox_threshold = QtWidgets.QCheckBox(self.frame_post_processing_2)
self.checkBox_threshold.setEnabled(False)
self.checkBox_threshold.setText('')
self.checkBox_threshold.setObjectName('checkBox_threshold')
self.gridLayout_10.addWidget(self.checkBox_threshold, 2, 4, 1, 1)
self.label_maskImages = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_maskImages.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_maskImages.setFont(font)
self.label_maskImages.setObjectName('label_maskImages')
self.gridLayout_10.addWidget(self.label_maskImages, 5, 0, 1, 2)
self.label_thresholdFocus = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_thresholdFocus.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_thresholdFocus.setFont(font)
self.label_thresholdFocus.setObjectName('label_thresholdFocus')
self.gridLayout_10.addWidget(self.label_thresholdFocus, 4, 0, 1, 2)
self.label_2 = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_2.setMaximumSize(QtCore.QSize(, 30))
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.label_2.setFont(font)
self.label_2.setObjectName('label_2')
self.gridLayout_10.addWidget(self.label_2, 0, 0, 1, 5)
self.checkBox_focusOverlay = QtWidgets.QCheckBox(self.frame_post_processing_2)
self.checkBox_focusOverlay.setEnabled(False)
self.checkBox_focusOverlay.setText('')
self.checkBox_focusOverlay.setObjectName('checkBox_focusOverlay')
self.gridLayout_10.addWidget(self.checkBox_focusOverlay, 3, 4, 1, 1)
self.checkBox_maskImages = QtWidgets.QCheckBox(self.frame_post_processing_2)
self.checkBox_maskImages.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.checkBox_maskImages.setFont(font)
self.checkBox_maskImages.setText('')
self.checkBox_maskImages.setObjectName('checkBox_maskImages')
self.gridLayout_10.addWidget(self.checkBox_maskImages, 5, 5, 1, 1)
self.label_thresholdMasking = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_thresholdMasking.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_thresholdMasking.setFont(font)
self.label_thresholdMasking.setObjectName('label_thresholdMasking')
self.gridLayout_10.addWidget(self.label_thresholdMasking, 6, 0, 1, 2)
self.pushButton_captureImagePost = QtWidgets.QPushButton(self.frame_post_processing_2)
self.pushButton_captureImagePost.setMinimumSize(QtCore.QSize(0, 30))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_captureImagePost.setFont(font)
self.pushButton_captureImagePost.setObjectName('pushButton_captureImagePost')
self.gridLayout_10.addWidget(self.pushButton_captureImagePost, 9, 2, 1, 4)
self.label_stackImages = QtWidgets.QLabel(self.frame_post_processing_2)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_stackImages.setFont(font)
self.label_stackImages.setObjectName('label_stackImages')
self.gridLayout_10.addWidget(self.label_stackImages, 1, 0, 1, 1)
self.label_suggestedValues = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_suggestedValues.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_suggestedValues.setFont(font)
self.label_suggestedValues.setObjectName('label_suggestedValues')
self.gridLayout_10.addWidget(self.label_suggestedValues, 7, 0, 1, 2)
self.checkBox_suggestedValues = QtWidgets.QCheckBox(self.frame_post_processing_2)
self.checkBox_suggestedValues.setEnabled(False)
self.checkBox_suggestedValues.setText('')
self.checkBox_suggestedValues.setObjectName('checkBox_suggestedValues')
self.gridLayout_10.addWidget(self.checkBox_suggestedValues, 7, 2, 1, 1)
self.checkBox_stackImages = QtWidgets.QCheckBox(self.frame_post_processing_2)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.checkBox_stackImages.setFont(font)
self.checkBox_stackImages.setText('')
self.checkBox_stackImages.setObjectName('checkBox_stackImages')
self.gridLayout_10.addWidget(self.checkBox_stackImages, 1, 4, 1, 1)
self.label_threshold = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_threshold.setEnabled(False)
self.label_threshold.setMaximumSize(QtCore.QSize(, ))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_threshold.setFont(font)
self.label_threshold.setObjectName('label_threshold')
self.gridLayout_10.addWidget(self.label_threshold, 2, 0, 1, 2)
self.label_thresholdMaskingMin = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_thresholdMaskingMin.setEnabled(False)
self.label_thresholdMaskingMin.setMaximumSize(QtCore.QSize(, 20))
self.label_thresholdMaskingMin.setObjectName('label_thresholdMaskingMin')
self.gridLayout_10.addWidget(self.label_thresholdMaskingMin, 6, 4, 1, 1)
self.spinBox_thresholdMin = QtWidgets.QSpinBox(self.frame_post_processing_2)
self.spinBox_thresholdMin.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.spinBox_thresholdMin.setFont(font)
self.spinBox_thresholdMin.setMaximum(254)
self.spinBox_thresholdMin.setProperty('value', 175)
self.spinBox_thresholdMin.setObjectName('spinBox_thresholdMin')
self.gridLayout_10.addWidget(self.spinBox_thresholdMin, 6, 5, 1, 1)
self.label_focusOverlay = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_focusOverlay.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.label_focusOverlay.setFont(font)
self.label_focusOverlay.setObjectName('label_focusOverlay')
self.gridLayout_10.addWidget(self.label_focusOverlay, 3, 0, 1, 1)
self.pushButton_startLiveViewPost = QtWidgets.QPushButton(self.frame_post_processing_2)
self.pushButton_startLiveViewPost.setMinimumSize(QtCore.QSize(0, 30))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(False)
font.setWeight(50)
self.pushButton_startLiveViewPost.setFont(font)
self.pushButton_startLiveViewPost.setObjectName('pushButton_startLiveViewPost')
self.gridLayout_10.addWidget(self.pushButton_startLiveViewPost, 9, 0, 1, 2)
self.label_thresholdMaskingMax = QtWidgets.QLabel(self.frame_post_processing_2)
self.label_thresholdMaskingMax.setEnabled(False)
self.label_thresholdMaskingMax.setMaximumSize(QtCore.QSize(, 20))
self.label_thresholdMaskingMax.setObjectName('label_thresholdMaskingMax')
self.gridLayout_10.addWidget(self.label_thresholdMaskingMax, 7, 4, 1, 1)
self.spinBox_thresholdMax = QtWidgets.QSpinBox(self.frame_post_processing_2)
self.spinBox_thresholdMax.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.spinBox_thresholdMax.setFont(font)
self.spinBox_thresholdMax.setMaximum(254)
self.spinBox_thresholdMax.setProperty('value', 215)
self.spinBox_thresholdMax.setObjectName('spinBox_thresholdMax')
self.gridLayout_10.addWidget(self.spinBox_thresholdMax, 7, 5, 1, 1)
self.doubleSpinBox_threshold = QtWidgets.QDoubleSpinBox(self.frame_post_processing_2)
self.doubleSpinBox_threshold.setEnabled(False)
font = QtGui.QFont()
font.setPointSize(9)
font.setBold(False)
font.setWeight(50)
self.doubleSpinBox_threshold.setFont(font)
self.doubleSpinBox_threshold.setDecimals(1)
self.doubleSpinBox_threshold.setMaximum(500.0)
self.doubleSpinBox_threshold.setProperty('value', 1.0)
self.doubleSpinBox_threshold.setObjectName('doubleSpinBox_threshold')
self.gridLayout_10.addWidget(self.doubleSpinBox_threshold, 4, 5, 1, 1)
self.gridLayout_5.addWidget(self.frame_post_processing_2, 0, 1, 1, 2)
self.tabWidget.addTab(self.tab_post_processing, '')
self.gridLayout_15.addWidget(self.tabWidget, 0, 0, 1, 1)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1434, 26))
self.menubar.setObjectName('menubar')
self.menuScanner = QtWidgets.QMenu(self.menubar)
self.menuScanner.setObjectName('menuScanner')
self.menuTheme = QtWidgets.QMenu(self.menubar)
self.menuTheme.setObjectName('menuTheme')
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName('statusbar')
MainWindow.setStatusBar(self.statusbar)
self.action_openProject = QtWidgets.QAction(MainWindow)
self.action_openProject.setObjectName('action_openProject')
self.actionNew_Project = QtWidgets.QAction(MainWindow)
self.actionNew_Project.setObjectName('actionNew_Project')
self.action_save = QtWidgets.QAction(MainWindow)
self.action_save.setWhatsThis('')
self.action_save.setObjectName('action_save')
self.action_loadConfig = QtWidgets.QAction(MainWindow)
self.action_loadConfig.setObjectName('action_loadConfig')
self.action_lightMode = QtWidgets.QAction(MainWindow)
self.action_lightMode.setObjectName('action_lightMode')
self.action_darkMode = QtWidgets.QAction(MainWindow)
self.action_darkMode.setObjectName('action_darkMode')
self.menuScanner.addAction(self.action_openProject)
self.menuScanner.addAction(self.action_loadConfig)
self.menuScanner.addAction(self.action_save)
self.menuTheme.addAction(self.action_lightMode)
self.menuTheme.addAction(self.action_darkMode)
self.menubar.addAction(self.menuScanner.menuAction())
self.menubar.addAction(self.menuTheme.menuAction())
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
self.stacked_camera_settings.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
self.label_liveView.setText(_translate('MainWindow', 'Live view disabled.'))
self.label_selectCamera.setText(_translate('MainWindow', ' Select Camera'))
self.pushButton_startLiveView.setText(_translate('MainWindow', 'Start Live View'))
self.pushButton_captureImage.setText(_translate('MainWindow', 'Capture Image'))
self.label_highlightExposure.setText(_translate('MainWindow', 'Highlight Exposure'))
self.label_gamma.setText(_translate('MainWindow', 'Gamma'))
self.label_gainAuto.setText(_translate('MainWindow', 'Gain Auto'))
self.label_gainLevel.setText(_translate('MainWindow', 'Gain Level [dB]'))
self.label_balanceRatioRed.setText(_translate('MainWindow', 'Balance Ratio (red)'))
self.label_balanceRatioBlue.setText(_translate('MainWindow', 'Balance Ratio (blue)'))
self.label_exposureTime.setText(_translate('MainWindow', 'Exposure time [us]'))
self.label_exposureAuto.setText(_translate('MainWindow', 'Exposure Auto'))
self.label_shutterSpeed.setText(_translate('MainWindow', 'Shutter speed [s]'))
self.label_aperture.setText(_translate('MainWindow', 'Aperture (F Stop)'))
self.label_iso.setText(_translate('MainWindow', 'ISO'))
self.label_whiteBalance.setText(_translate('MainWindow', 'White Balance'))
self.label_compression.setText(_translate('MainWindow', 'Compression'))
self.label_cameraSettings.setText(_translate('MainWindow', 'Camera Settings'))
self.label_folderName.setText(_translate('MainWindow', 'Folder Name'))
self.pushButton_browseOutput.setText(_translate('MainWindow', 'Choose Output Folder'))
self.label_outputSettings.setText(_translate('MainWindow', 'Output Settings'))
self.lineEdit_projectName.setText(_translate('MainWindow', 'test_project'))
self.label_projectName.setText(_translate('MainWindow', 'Project name'))
self.lineEdit_outputLocation.setText(_translate('MainWindow', 'current_folder'))
self.label_outputFolder.setText(_translate('MainWindow', 'Output folder'))
self.label_log.setText(_translate('MainWindow', 'Log'))
self.label_progressTotal.setText(_translate('MainWindow', 'Progress'))
self.label_info.setText(_translate('MainWindow', 'Info'))
self.label_yAxis.setText(_translate('MainWindow', 'Rotation [Y Axis]'))
self.label_setRangeZMin.setText(_translate('MainWindow', 'Min [Z Axis]'))
self.label_xAxisSliderMin.setText(_translate('MainWindow', 'towards camera'))
self.label_zAxisSliderMin.setText(_translate('MainWindow', 'back position'))
self.label_zAxisSliderMax.setText(_translate('MainWindow', 'front position'))
self.label_setRangeXMin.setText(_translate('MainWindow', 'Min [X Axis]'))
self.pushButton_xHome.setText(_translate('MainWindow', 'Home X Axis'))
self.label_zAxis.setText(_translate('MainWindow', 'Focus [Z Axis]'))
self.label_xAxis.setText(_translate('MainWindow', 'Pitch [X Axis]'))
self.label_xAxisSliderMax.setText(_translate('MainWindow', 'away from camera'))
self.label_setRangeYMin.setText(_translate('MainWindow', 'Min [Y Axis]'))
self.pushButton_zHome.setText(_translate('MainWindow', 'Home Focus'))
self.label_yAxisSliderMax.setText(_translate('MainWindow', 'turn right'))
self.pushButton_yReset.setText(_translate('MainWindow', 'Reset Y axis'))
self.label_yAxisSliderMin.setText(_translate('MainWindow', 'turn left'))
self.label_stepperControl.setText(_translate('MainWindow', 'Stepper Control'))
self.label_setRangeYStep.setText(_translate('MainWindow', 'Step [Y Axis]'))
self.label_setRangeXMax.setText(_translate('MainWindow', 'Max [X Axis]'))
self.pushButton_Energise.setText(_translate('MainWindow', 'Resume'))
self.pushButton_stepperDeEnergise.setText(_translate('MainWindow', 'De-Energise'))
self.label_setRangeZStep.setText(_translate('MainWindow', 'Step [Z Axis]'))
self.label_setRangeXStep.setText(_translate('MainWindow', 'Step [X Axis]'))
self.label_setRangeYMax.setText(_translate('MainWindow', 'Max [Y Axis]'))
self.label_setRangeZMax.setText(_translate('MainWindow', 'Max [Z Axis]'))
self.label_setRange.setText(_translate('MainWindow', 'Scan Range'))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_scan_parameters), _translate('MainWindow', 'Scan Parameters'))
self.label_liveViewPost.setText(_translate('MainWindow', 'Live view disabled.'))
self.label_focalLength.setText(_translate('MainWindow', 'Focal Length (mm)'))
self.label_lens.setText(_translate('MainWindow', 'Lens'))
self.label_model.setText(_translate('MainWindow', 'Model'))
self.label_serialNumber.setText(_translate('MainWindow', 'Serial Number'))
self.label_make.setText(_translate('MainWindow', 'Make'))
self.label_lensManufacturer.setText(_translate('MainWindow', 'Lens Manufacturer'))
self.label_sensorWidth.setText(_translate('MainWindow', 'Sensor Width (mm)'))
self.label_lensModel.setText(_translate('MainWindow', 'Lens Model'))
self.label_focalLengthIn35mmFormat.setText(_translate('MainWindow', 'Focal Length in 35mm Format'))
self.label.setText(_translate('MainWindow', 'Camera and Lens Info'))
self.label_infoPost.setText(_translate('MainWindow', 'Info'))
self.label_progressTotalPost.setText(_translate('MainWindow', 'Progress'))
self.label_logPost.setText(_translate('MainWindow', 'Log'))
self.pushButton_startScan.setText(_translate('MainWindow', 'Start Scan'))
self.pushButton_processingOutput.setText(_translate('MainWindow', 'Processing Output'))
self.pushButton_runPostProcessing.setText(_translate('MainWindow', 'Run Post Processing'))
self.label_maskImages.setText(_translate('MainWindow', 'Mask images'))
self.label_thresholdFocus.setText(_translate('MainWindow', 'Threshold (focus)'))
self.label_2.setText(_translate('MainWindow', 'Post Processing Parameters'))
self.label_thresholdMasking.setText(_translate('MainWindow', 'Threshold (masking)'))
self.pushButton_captureImagePost.setText(_translate('MainWindow', 'Capture Image'))
self.label_stackImages.setText(_translate('MainWindow', 'Stack images'))
self.label_suggestedValues.setText(_translate('MainWindow', 'Suggested Values'))
self.label_threshold.setText(_translate('MainWindow', 'Threshold images'))
self.label_thresholdMaskingMin.setText(_translate('MainWindow', 'min'))
self.label_focusOverlay.setText(_translate('MainWindow', 'Focus Overlay'))
self.pushButton_startLiveViewPost.setText(_translate('MainWindow', 'Start Live View'))
self.label_thresholdMaskingMax.setText(_translate('MainWindow', 'max'))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_post_processing), _translate('MainWindow', 'Post Processing'))
self.menuScanner.setTitle(_translate('MainWindow', 'File'))
self.menuTheme.setTitle(_translate('MainWindow', 'Theme'))
self.action_openProject.setText(_translate('MainWindow', 'Open Project'))
self.action_openProject.setToolTip(_translate('MainWindow', 'Open Project'))
self.action_openProject.setStatusTip(_translate('MainWindow', 'Open existing scAnt project and load presets'))
self.action_openProject.setShortcut(_translate('MainWindow', 'Ctrl+O'))
self.actionNew_Project.setText(_translate('MainWindow', 'New Project'))
self.actionNew_Project.setToolTip(_translate('MainWindow', 'Create a new scAnt project'))
self.actionNew_Project.setShortcut(_translate('MainWindow', 'Ctrl+N'))
self.action_save.setText(_translate('MainWindow', 'Save Config'))
self.action_save.setToolTip(_translate('MainWindow', 'Save'))
self.action_save.setStatusTip(_translate('MainWindow', 'Save current scan parameters in config'))
self.action_save.setShortcut(_translate('MainWindow', 'Ctrl+S'))
self.action_loadConfig.setText(_translate('MainWindow', 'Load Config'))
self.action_loadConfig.setStatusTip(_translate('MainWindow', 'Load presets from existing project'))
self.action_loadConfig.setShortcut(_translate('MainWindow', 'Ctrl+L'))
self.action_lightMode.setText(_translate('MainWindow', 'Light Mode'))
self.action_darkMode.setText(_translate('MainWindow', 'Dark Mode')) |
def get_config():
config = base_config.get_base_config()
config.task_horizon = 200
config.hidden_sizes = (200, 200, 200)
config.population_size = 500
config.activation = jax.nn.silu
config.planning_horizon = 15
config.cem_alpha = 0.1
config.cem_elite_frac = 0.1
config.cem_return_mean_elites = True
config.weight_decay = 5e-05
config.lr = 0.001
config.min_delta = 0.01
config.num_ensembles = 5
config.num_particles = 20
config.num_epochs = 50
config.patience = 50
def obs_preproc(obs):
return obs
def obs_postproc(obs, pred):
return (obs + pred)
def targ_proc(obs, next_obs):
return (next_obs - obs)
def reward_fn(x, a, goal):
del goal
return reward_fns.cartpole(a, x)
def termination_fn(x, a, goal):
del goal
return termination_fns.cartpole(a, x)
config.obs_preproc = obs_preproc
config.obs_postproc = obs_postproc
config.targ_proc = targ_proc
config.reward_fn = reward_fn
config.termination_fn = termination_fn
return config |
class TestMultiplexerDisconnectsOnTermination():
def setup(self):
self.proc = None
self.runner = CliRunner()
self.agent_name = 'myagent'
self.cwd = os.getcwd()
self.t = tempfile.mkdtemp()
shutil.copytree(Path(ROOT_DIR, 'packages'), Path(self.t, 'packages'))
os.chdir(self.t)
self.key_path = os.path.join(self.t, 'fetchai_private_key.txt')
self.conn_key_path = os.path.join(self.t, 'conn_private_key.txt')
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'init', '--author', AUTHOR])
assert (result.exit_code == 0)
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'create', '--local', self.agent_name])
assert (result.exit_code == 0)
os.chdir(Path(self.t, self.agent_name))
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'generate-key', DEFAULT_LEDGER, self.key_path])
assert (result.exit_code == 0), result.stdout_bytes
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'add-key', DEFAULT_LEDGER, self.key_path])
assert (result.exit_code == 0), result.stdout_bytes
def test_multiplexer_disconnected_on_early_interruption(self):
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'add', '--local', 'connection', str(P2P_PUBLIC_ID)])
assert (result.exit_code == 0), result.stdout_bytes
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'build'])
assert (result.exit_code == 0), result.stdout_bytes
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'generate-key', DEFAULT_LEDGER, self.conn_key_path])
assert (result.exit_code == 0), result.stdout_bytes
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'add-key', DEFAULT_LEDGER, self.conn_key_path, '--connection'])
assert (result.exit_code == 0), result.stdout_bytes
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'issue-certificates'])
assert (result.exit_code == 0), result.stdout_bytes
self.proc = PexpectWrapper([sys.executable, '-m', 'aea.cli', '-v', 'DEBUG', 'run'], env=os.environ, maxread=10000, encoding='utf-8', logfile=sys.stdout)
self.proc.expect_all(['Starting libp2p node...'], timeout=50)
self.proc.control_c()
self.proc.expect_all(['Multiplexer .*disconnected.'], timeout=20, strict=False)
self.proc.expect_all([EOF], timeout=20)
def test_multiplexer_disconnected_on_termination_after_connected_no_connection(self):
self.proc = PexpectWrapper([sys.executable, '-m', 'aea.cli', '-v', 'DEBUG', 'run'], env=os.environ, maxread=10000, encoding='utf-8', logfile=sys.stdout)
self.proc.expect_all(['Start processing messages...'], timeout=20)
self.proc.control_c()
self.proc.expect_all(['Multiplexer disconnecting...', 'Multiplexer disconnected.', EOF], timeout=20)
def test_multiplexer_disconnected_on_termination_after_connected_one_connection(self):
result = self.runner.invoke(cli, [*CLI_LOG_OPTION, 'add', '--local', 'connection', str(STUB_CONNECTION_ID)])
assert (result.exit_code == 0), result.stdout_bytes
self.proc = PexpectWrapper([sys.executable, '-m', 'aea.cli', '-v', 'DEBUG', 'run'], env=os.environ, maxread=10000, encoding='utf-8', logfile=sys.stdout)
self.proc.expect_all(['Start processing messages...'], timeout=20)
self.proc.control_c()
self.proc.expect_all(['Multiplexer disconnecting...', 'Multiplexer disconnected.', EOF], timeout=20)
def teardown(self):
if self.proc:
self.proc.wait_to_complete(10)
os.chdir(self.cwd)
try:
shutil.rmtree(self.t)
except (OSError, IOError):
pass |
class OptionPlotoptionsVennOnpointPosition(Options):
def offsetX(self):
return self._config_get(None)
def offsetX(self, num: float):
self._config(num, js_type=False)
def offsetY(self):
return self._config_get(None)
def offsetY(self, num: float):
self._config(num, js_type=False)
def x(self):
return self._config_get(None)
def x(self, num: float):
self._config(num, js_type=False)
def y(self):
return self._config_get(None)
def y(self, num: float):
self._config(num, js_type=False) |
def downgrade():
op.execute('COMMIT')
try:
op.execute('SHOW bdr.permit_ddl_locking')
op.execute('SET LOCAL bdr.permit_ddl_locking = true')
except exc.ProgrammingError:
pass
op.execute("UPDATE updates SET test_gating_status = 'failed' WHERE test_gating_status = 'greenwave_failed'")
op.execute('ALTER TYPE ck_test_gating_status RENAME TO ck_test_gating_status_old')
op.execute("CREATE TYPE ck_test_gating_status AS ENUM('ignored', 'queued', 'running', 'passed', 'failed', 'waiting')")
op.execute('ALTER TABLE updates ALTER COLUMN test_gating_status TYPE ck_test_gating_status USING test_gating_status::text::ck_test_gating_status')
op.execute('DROP TYPE ck_test_gating_status_old') |
def convert_mxnet_default_inputs(model: Model, X: Any, is_train: bool) -> Tuple[(ArgsKwargs, Callable[([ArgsKwargs], Any)])]:
xp2mxnet_ = (lambda x: xp2mxnet(x, requires_grad=is_train))
converted = convert_recursive(is_xp_array, xp2mxnet_, X)
if isinstance(converted, ArgsKwargs):
def reverse_conversion(dXmxnet):
return convert_recursive(is_mxnet_array, mxnet2xp, dXmxnet)
return (converted, reverse_conversion)
elif isinstance(converted, dict):
def reverse_conversion(dXmxnet):
dX = convert_recursive(is_mxnet_array, mxnet2xp, dXmxnet)
return dX.kwargs
return (ArgsKwargs(args=tuple(), kwargs=converted), reverse_conversion)
elif isinstance(converted, (tuple, list)):
def reverse_conversion(dXmxnet):
dX = convert_recursive(is_mxnet_array, mxnet2xp, dXmxnet)
return dX.args
return (ArgsKwargs(args=tuple(converted), kwargs={}), reverse_conversion)
else:
def reverse_conversion(dXmxnet):
dX = convert_recursive(is_mxnet_array, mxnet2xp, dXmxnet)
return dX.args[0]
return (ArgsKwargs(args=(converted,), kwargs={}), reverse_conversion) |
def connect_wires(tiles, tileconn, wire_map):
wire_nodes = {}
for wire in wire_map:
wire_nodes[wire] = set([wire])
wire_connection_map = {}
for conn in tileconn:
for (idx, (wire1, wire2)) in enumerate(conn['wire_pairs']):
key1 = (conn['tile_types'][0], wire1)
if (key1 not in wire_connection_map):
wire_connection_map[key1] = []
wire_connection_map[key1].append((conn, idx))
key2 = (conn['tile_types'][1], wire2)
if (key2 not in wire_connection_map):
wire_connection_map[key2] = []
wire_connection_map[key2].append((conn, idx))
coord_to_tile = create_coord_to_tile(tiles)
for (wire, wire_info) in progressbar.progressbar(wire_map.items()):
key = (wire_info['type'], wire_info['shortname'])
if (key not in wire_connection_map):
continue
for (conn, idx) in wire_connection_map[key]:
for (target_tile, target_wire) in get_connections(wire, wire_info, conn, idx, coord_to_tile, tiles):
full_wire_name = ((coord_to_tile[target_tile] + '/') + target_wire)
assert (wire_map[full_wire_name]['shortname'] == target_wire), (target_tile, target_wire, wire, conn)
assert (wire_map[full_wire_name]['tile'] == coord_to_tile[target_tile]), (wire_map[full_wire_name]['tile'], coord_to_tile[target_tile])
make_connection(wire_nodes, wire, full_wire_name)
nodes = {}
for node in wire_nodes.values():
nodes[id(node)] = node
return tuple((tuple(node) for node in nodes.values())) |
def extractSecondstringheroesBlogspotCom(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 start_agent_service(system):
parser = options.general_parser()
options.add_evaluator_args(parser)
(args, _) = parser.parse_known_args()
app = web.Application([('/reset', ResetHandle, {'system': system}), ('/input', InputHandler, {'system': system}), ('/output', OutputHandler, {'system': system}), ('/', SystemHandler, {'system': system})], debug=False)
app.listen(args.remote_port, max_buffer_size=(1024 ** 3))
logger.info(f'Simultaneous Translation Server Started (process id {os.getpid()}). Listening to port {args.remote_port} ')
ioloop.IOLoop.current().start() |
.asyncio
.workspace_host
class TestDeleteUserField():
async def test_unauthorized(self, unauthorized_api_assertions: HTTPXResponseAssertion, test_client_api: test_data: TestData):
user_field = test_data['user_fields']['given_name']
response = (await test_client_api.delete(f'/user-fields/{user_field.id}'))
unauthorized_api_assertions(response)
.authenticated_admin
async def test_not_existing(self, test_client_api: not_existing_uuid: uuid.UUID):
response = (await test_client_api.delete(f'/user-fields/{not_existing_uuid}'))
assert (response.status_code == status.HTTP_404_NOT_FOUND)
.authenticated_admin
async def test_valid(self, test_client_api: test_data: TestData):
user_field = test_data['user_fields']['given_name']
response = (await test_client_api.delete(f'/user-fields/{user_field.id}'))
assert (response.status_code == status.HTTP_204_NO_CONTENT) |
def collectFiles():
matches = []
path_parts = os.getcwd().split('/')
dirname = '.'
if (path_parts[(- 1)] == 'tools'):
dirname = '/'.join(path_parts[:(- 1)])
for (root, dirnames, filenames) in os.walk(dirname):
dirnames[:] = [d for d in dirnames if (d not in EXCLUDE_LIST)]
for filename in fnmatch.filter(filenames, '*.py'):
matches.append(os.path.join(root, filename))
return matches |
def tex_Or(head, args, **kwargs):
for arg in args:
if (arg.head() == Step):
return latex_infix(head, args, opsymbol=' \\lor ')
argstr = [arg.latex(**kwargs) for arg in args]
for i in range(len(args)):
if (args[i].head() in (And, Or, Not)):
argstr[i] = ('\\left(%s\\right)' % argstr[i])
if kwargs.get('in_logic'):
return ' \\,\\lor\\, '.join(argstr)
else:
return ' \\;\\mathbin{\\operatorname{or}}\\; '.join(argstr) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.