def _store_imported_datatypes_in_db(self, project, all_datatypes):
# type: (Project, dict) -> int
sorted_dts = sorted(
all_datatypes.items(),
key=lambda dt_item: dt_item[1].create_date or datetime.now())
count = 0
for dt_path, datatype in sorted_dts:
datatype_already_in_tvb = dao.get_datatype_by_gid(datatype.gid)
if not datatype_already_in_tvb:
self.store_datatype(datatype, dt_path)
count += 1
else:
AlgorithmService.create_link([datatype_already_in_tvb.id],
project.id)
file_path = h5.h5_file_for_index(datatype).path
h5_class = H5File.h5_class_from_file(file_path)
reference_list = h5_class(file_path).gather_references()
for _, reference_gid in reference_list:
if not reference_gid:
continue
ref_index = dao.get_datatype_by_gid(reference_gid.hex)
if ref_index is None:
os.remove(file_path)
dao.remove_entity(datatype.__class__, datatype.id)
raise MissingReferenceException(
'Imported file depends on datatypes that do not exist. Please upload '
'those first!')
return count
def handle_next_fragment_for_monitors(self, context, rendering_rules,
current_monitor, next_monitor,
is_noise_form, form_action_url,
if_bold_url):
simulator, _, _, is_branch = context.get_common_params()
if isinstance(current_monitor,
BoldViewModel) and is_noise_form is False:
return self._prepare_next_fragment_if_bold(current_monitor,
rendering_rules,
if_bold_url)
if not next_monitor:
rendering_rules.is_branch = is_branch
return SimulatorFinalFragment.prepare_final_fragment(
simulator, context.burst_config, context.project.id,
rendering_rules, SimulatorWizzardURLs.SETUP_PSE_URL)
next_form = get_form_for_monitor(type(next_monitor))(simulator,
is_branch)
next_form = AlgorithmService().prepare_adapter_form(
form_instance=next_form, project_id=context.project.id)
next_form.fill_from_trait(next_monitor)
monitor_name = self.prepare_monitor_legend(
simulator.is_surface_simulation, next_monitor)
rendering_rules.form = next_form
rendering_rules.form_action_url = form_action_url
rendering_rules.monitor_name = monitor_name
return rendering_rules.to_dict()
def transactional_setup_method(self):
""" Prepare some entities to work with during tests:"""
self.algorithm_service = AlgorithmService()
category = dao.get_uploader_categories()[0]
self.algorithm = dao.store_entity(model_operation.Algorithm(TEST_ADAPTER_VALID_MODULE,
TEST_ADAPTER_VALID_CLASS, category.id))
def _store_imported_datatypes_in_db(self, project, all_datatypes,
dt_burst_mappings, burst_ids_mapping):
def by_time(dt):
return dt.create_date or datetime.now()
if burst_ids_mapping is None:
burst_ids_mapping = {}
if dt_burst_mappings is None:
dt_burst_mappings = {}
all_datatypes.sort(key=by_time)
for datatype in all_datatypes:
old_burst_id = dt_burst_mappings.get(datatype.gid)
if old_burst_id is not None:
datatype.fk_parent_burst = burst_ids_mapping[old_burst_id]
datatype_allready_in_tvb = dao.get_datatype_by_gid(datatype.gid)
if not datatype_allready_in_tvb:
self.store_datatype(datatype)
else:
AlgorithmService.create_link([datatype_allready_in_tvb.id],
project.id)
def __init__(self):
self.logger = get_logger(self.__class__.__module__)
self.user_service = UserService()
self.project_service = ProjectService()
self.algorithm_service = AlgorithmService()
self.analyze_category_link = '/flow/step_analyzers'
self.analyze_adapters = None
self.connectivity_tab_link = '/flow/step_connectivity'
view_category = self.algorithm_service.get_visualisers_category()
conn_id = self.algorithm_service.get_algorithm_by_module_and_class(
IntrospectionRegistry.CONNECTIVITY_MODULE,
IntrospectionRegistry.CONNECTIVITY_CLASS).id
connectivity_link = self.get_url_adapter(view_category.id, conn_id)
self.connectivity_submenu = [
dict(title="Large Scale Connectivity",
link=connectivity_link,
subsection=WebStructure.SUB_SECTION_CONNECTIVITY,
description=
"View Connectivity Regions. Perform Connectivity lesions"),
dict(title="Local Connectivity",
link='/spatial/localconnectivity/step_1/1',
subsection=WebStructure.SUB_SECTION_LOCAL_CONNECTIVITY,
description=
"Create or view existent Local Connectivity entities.")
]
allen_algo = self.algorithm_service.get_algorithm_by_module_and_class(
IntrospectionRegistry.ALLEN_CREATOR_MODULE,
IntrospectionRegistry.ALLEN_CREATOR_CLASS)
if allen_algo and not allen_algo.removed:
# Only add the Allen Creator if AllenSDK is installed
allen_link = self.get_url_adapter(allen_algo.fk_category,
allen_algo.id)
self.connectivity_submenu.append(
dict(
title="Allen Connectome Builder",
link=allen_link,
subsection=WebStructure.SUB_SECTION_ALLEN,
description=
"Download data from Allen dataset and create a mouse connectome"
))
self.burst_submenu = [
dict(link='/burst',
subsection=WebStructure.SUB_SECTION_BURST,
title='Simulation Cockpit',
description='Manage simulations'),
dict(link='/burst/dynamic',
subsection='dynamic',
title='Phase plane',
description='Configure model dynamics')
]
def prepare_stimulus_fragment(simulator, rendering_rules,
is_surface_simulation, form_action_url,
project_id):
form = SimulatorStimulusFragment(is_surface_simulation)
stimuli_fragment = AlgorithmService().prepare_adapter_form(
form_instance=form, project_id=project_id)
stimuli_fragment.fill_from_trait(simulator)
rendering_rules.form = stimuli_fragment
rendering_rules.form_action_url = form_action_url
return rendering_rules.to_dict()
def prepare_cortex_fragment(simulator, rendering_rules, form_action_url,
project_id):
surface_index = load_entity_by_gid(simulator.surface.surface_gid)
form = SimulatorRMFragment(surface_index, simulator.connectivity)
rm_fragment = AlgorithmService().prepare_adapter_form(
form_instance=form, project_id=project_id)
rm_fragment.fill_from_trait(simulator.surface)
rendering_rules.form = rm_fragment
rendering_rules.form_action_url = form_action_url
return rendering_rules.to_dict()
def store_or_link_datatype(self, datatype, dt_path, project_id):
self.check_import_references(dt_path, datatype)
stored_dt_count = 0
datatype_already_in_tvb = load.load_entity_by_gid(datatype.gid)
if not datatype_already_in_tvb:
self.store_datatype(datatype, dt_path)
stored_dt_count = 1
elif datatype_already_in_tvb.parent_operation.project.id != project_id:
AlgorithmService.create_link([datatype_already_in_tvb.id], project_id)
if datatype_already_in_tvb.fk_datatype_group:
AlgorithmService.create_link([datatype_already_in_tvb.fk_datatype_group], project_id)
return stored_dt_count
def _store_imported_datatypes_in_db(self, project, all_datatypes):
# type: (Project, dict) -> int
sorted_dts = sorted(
all_datatypes.items(),
key=lambda dt_item: dt_item[1].create_date or datetime.now())
count = 0
for dt_path, datatype in sorted_dts:
datatype_already_in_tvb = dao.get_datatype_by_gid(datatype.gid)
if not datatype_already_in_tvb:
self.store_datatype(datatype, dt_path)
count += 1
else:
AlgorithmService.create_link([datatype_already_in_tvb.id],
project.id)
return count
def launch_simulation(self, current_user_id, zip_directory, project_gid):
try:
project = self.project_service.find_project_lazy_by_gid(
project_gid)
except ProjectServiceException:
raise InvalidIdentifierException()
try:
simulator_h5_name = DirLoader(
zip_directory, None).find_file_for_has_traits_type(Simulator)
simulator_file = os.path.join(zip_directory, simulator_h5_name)
except IOError:
raise InvalidInputException(
'No Simulator h5 file found in the archive')
try:
simulator_algorithm = AlgorithmService(
).get_algorithm_by_module_and_class(SimulatorAdapter.__module__,
SimulatorAdapter.__name__)
simulation = self.simulator_service.prepare_simulation_on_server(
user_id=current_user_id,
project=project,
algorithm=simulator_algorithm,
zip_folder_path=zip_directory,
simulator_file=simulator_file)
return simulation.gid
except Exception as excep:
self.logger.error(excep, exc_info=True)
raise ServiceException(str(excep))
def initialize_two_projects(self, dummy_datatype_index_factory,
project_factory, user_factory):
"""
Creates a user, an algorithm and 2 projects
Project src_project will have an operation and 2 datatypes
Project dest_project will be empty.
Initializes a flow and a project service
"""
self.clean_database(delete_folders=True)
self.algorithm_service = AlgorithmService()
self.project_service = ProjectService()
# Create the source project with 2 datatypes in it
src_user = user_factory(username="******")
self.src_usr_id = src_user.id
self.src_project = project_factory(src_user, "Src_Project")
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'paupau.zip')
self.red_datatype = TestFactory.import_zip_connectivity(
src_user, self.src_project, zip_path, "John")
zip_path = os.path.join(os.path.dirname(tvb_data.__file__), 'sensors',
'eeg_unitvector_62.txt.bz2')
self.blue_datatype = TestFactory.import_sensors(
src_user, self.src_project, zip_path, SensorTypes.TYPE_EEG.value)
assert 1 == self.red_datatypes_in(self.src_project.id)
assert 1 == self.blue_datatypes_in(self.src_project.id)
# create the destination project empty
self.dst_user = user_factory(username='******')
self.dst_usr_id = self.dst_user.id
self.dest_project = project_factory(self.dst_user,
"Destination_Project")
assert 0 == self.red_datatypes_in(self.dest_project.id)
assert 0 == self.blue_datatypes_in(self.dest_project.id)
def test_get_project_structure(self, datatype_group_factory,
dummy_datatype_index_factory,
project_factory, user_factory):
"""
Tests project structure is as expected and contains all datatypes and created links
"""
user = user_factory()
project1 = project_factory(user, name="TestPS1")
project2 = project_factory(user, name="TestPS2")
dt_group = datatype_group_factory(project=project1)
dt_simple = dummy_datatype_index_factory(state="RAW_DATA",
project=project1)
# Create 3 DTs directly in Project 2
dummy_datatype_index_factory(state="RAW_DATA", project=project2)
dummy_datatype_index_factory(state="RAW_DATA", project=project2)
dummy_datatype_index_factory(state="RAW_DATA", project=project2)
# Create Links from Project 1 into Project 2
link_ids, expected_links = [], []
link_ids.append(dt_simple.id)
expected_links.append(dt_simple.gid)
# Prepare links towards a full DT Group, but expecting only the DT_Group in the final tree
dts = dao.get_datatype_in_group(datatype_group_id=dt_group.id)
link_ids.extend([dt_to_link.id for dt_to_link in dts])
link_ids.append(dt_group.id)
expected_links.append(dt_group.gid)
# Actually create the links from Prj1 into Prj2
AlgorithmService().create_link(link_ids, project2.id)
# Retrieve the raw data used to compose the tree (for easy parsing)
dts_in_tree = dao.get_data_in_project(project2.id)
dts_in_tree = [dt.gid for dt in dts_in_tree]
# Retrieve the tree json (for trivial validations only, as we can not decode)
node_json = self.project_service.get_project_structure(
project2, None, DataTypeMetaData.KEY_STATE,
DataTypeMetaData.KEY_SUBJECT, None)
assert len(expected_links) + 3 == len(
dts_in_tree), "invalid number of nodes in tree"
assert dt_group.gid in dts_in_tree, "DT_Group should be in the Project Tree!"
assert dt_group.gid in node_json, "DT_Group should be in the Project Tree JSON!"
project_dts = dao.get_datatypes_in_project(project2.id)
for dt in project_dts:
if dt.fk_datatype_group is not None:
assert not dt.gid in node_json, "DTs part of a group should not be"
assert not dt.gid in dts_in_tree, "DTs part of a group should not be"
else:
assert dt.gid in node_json, "Simple DTs and DT_Groups should be"
assert dt.gid in dts_in_tree, "Simple DTs and DT_Groups should be"
for link_gid in expected_links:
assert link_gid in node_json, "Expected Link not present"
assert link_gid in dts_in_tree, "Expected Link not present"
def test_get_group_by_identifier(self):
"""
Test for the get_algorithm_by_identifier.
"""
algo_ret = AlgorithmService.get_algorithm_by_identifier(self.algorithm.id)
assert algo_ret.id == self.algorithm.id, "ID-s are different!"
assert algo_ret.module == self.algorithm.module, "Modules are different!"
assert algo_ret.fk_category == self.algorithm.fk_category, "Categories are different!"
assert algo_ret.classname == self.algorithm.classname, "Class names are different!"
def get_fragment_after_monitors(simulator, burst_config, project_id,
is_branch, rendering_rules, setup_pse_url):
first_monitor = simulator.first_monitor
if first_monitor is None:
rendering_rules.is_branch = is_branch
return SimulatorFinalFragment.prepare_final_fragment(
simulator, burst_config, project_id, rendering_rules,
setup_pse_url)
form = get_form_for_monitor(type(first_monitor))(simulator, is_branch)
form = AlgorithmService().prepare_adapter_form(form_instance=form)
form.fill_from_trait(first_monitor)
monitor_name = MonitorsWizardHandler.prepare_monitor_legend(
simulator.is_surface_simulation, first_monitor)
rendering_rules.monitor_name = monitor_name
rendering_rules.form = form
return rendering_rules.to_dict()
def test_get_uploaders(self):
result = AlgorithmService.get_upload_algorithms()
assert 20 == len(result)
found = False
for algo in result:
if algo.classname == self.algorithm.classname and algo.module == self.algorithm.module:
found = True
break
assert found, "Uploader incorrectly returned"
def test_get_uploaders(self):
result = AlgorithmService.get_upload_algorithms()
# Not sure if it is correct but I think there are not 29 algorithms anymore here
assert 19 == len(result)
found = False
for algo in result:
if algo.classname == self.algorithm.classname and algo.module == self.algorithm.module:
found = True
break
assert found, "Uploader incorrectly returned"
def launch_operation(self, current_user_id, model_file, project_gid,
algorithm_module, algorithm_classname, fetch_file):
temp_folder = FilesHelper.create_temp_folder()
model_h5_path = FilesHelper.save_temporary_file(
model_file, temp_folder)
try:
project = self.project_service.find_project_lazy_by_gid(
project_gid)
except ProjectServiceException:
raise InvalidIdentifierException()
algorithm = AlgorithmService.get_algorithm_by_module_and_class(
algorithm_module, algorithm_classname)
if algorithm is None:
raise InvalidIdentifierException(
'No algorithm found for: %s.%s' %
(algorithm_module, algorithm_classname))
try:
adapter_instance = ABCAdapter.build_adapter(algorithm)
view_model = adapter_instance.get_view_model_class()()
view_model_h5 = ViewModelH5(model_h5_path, view_model)
view_model_gid = view_model_h5.gid.load()
operation = self.operation_service.prepare_operation(
current_user_id, project.id, algorithm.id,
algorithm.algorithm_category, view_model_gid.hex, None, {})
storage_path = self.files_helper.get_project_folder(
project, str(operation.id))
if isinstance(adapter_instance, ABCUploader):
for key, value in adapter_instance.get_form_class(
).get_upload_information().items():
data_file = fetch_file(request_file_key=key,
file_extension=value)
data_file_path = FilesHelper.save_temporary_file(
data_file, temp_folder)
file_name = os.path.basename(data_file_path)
upload_field = getattr(view_model_h5, key)
upload_field.store(os.path.join(storage_path, file_name))
shutil.move(data_file_path, storage_path)
shutil.move(model_h5_path, storage_path)
os.rmdir(temp_folder)
view_model_h5.close()
OperationService().launch_operation(operation.id, True)
return operation.gid
except Exception as excep:
self.logger.error(excep, exc_info=True)
raise ServiceException(str(excep))
def _compute_connectivity_global_params(self, connectivity):
"""
Returns a dictionary which contains the data needed for drawing a connectivity.
:param connectivity: the `Connectivity(HasTraits)` object
"""
conn_gid = connectivity.gid.hex
path_weights = SurfaceURLGenerator.paths2url(conn_gid,
'ordered_weights')
path_pos = SurfaceURLGenerator.paths2url(conn_gid, 'ordered_centres')
path_tracts = SurfaceURLGenerator.paths2url(conn_gid, 'ordered_tracts')
path_labels = SurfaceURLGenerator.paths2url(conn_gid, 'ordered_labels')
path_hemisphere_order_indices = SurfaceURLGenerator.paths2url(
conn_gid, 'hemisphere_order_indices')
algo = AlgorithmService().get_algorithm_by_module_and_class(
CONNECTIVITY_CREATOR_MODULE, CONNECTIVITY_CREATOR_CLASS)
submit_url = '/{}/{}/{}'.format(SurfaceURLGenerator.FLOW,
algo.fk_category, algo.id)
global_pages = dict(controlPage="connectivity/top_right_controls")
minimum, maximum, minimum_non_zero = self._compute_matrix_extrema(
connectivity.ordered_weights)
minimum_t, maximum_t, minimum_non_zero_t = self._compute_matrix_extrema(
connectivity.ordered_tracts)
global_params = dict(
urlWeights=path_weights,
urlPositions=path_pos,
urlTracts=path_tracts,
urlLabels=path_labels,
originalConnectivity=conn_gid,
title="Connectivity Control",
submitURL=submit_url,
positions=connectivity.ordered_centres,
tractsMin=minimum_t,
tractsMax=maximum_t,
weightsMin=minimum,
weightsMax=maximum,
tractsNonZeroMin=minimum_non_zero_t,
weightsNonZeroMin=minimum_non_zero,
pointsLabels=connectivity.ordered_labels,
conductionSpeed=1,
connectivity_entity=connectivity,
base_selection=connectivity.saved_selection_labels,
hemisphereOrderUrl=path_hemisphere_order_indices,
leftHemisphereCount=(connectivity.hemispheres == 0).sum())
global_params.update(
self.build_params_for_selectable_connectivity(connectivity))
return global_params, global_pages
class DatatypeFacade:
def __init__(self):
self.algorithm_service = AlgorithmService()
@staticmethod
def get_dt_h5_path(datatype_gid):
index = ABCAdapter.load_entity_by_gid(datatype_gid)
return h5_file_for_index(index).path
def get_datatype_operations(self, datatype_gid):
categories = dao.get_launchable_categories(elimin_viewers=True)
datatype = dao.get_datatype_by_gid(datatype_gid)
_, filtered_adapters, _ = self.algorithm_service.get_launchable_algorithms_for_datatype(
datatype, categories)
return [AlgorithmDto(algorithm) for algorithm in filtered_adapters]
def run_simulation():
log = get_logger(__name__)
# This ID of a project needs to exists in DB, and it can be taken from the WebInterface:
project = dao.get_project_by_id(1)
# Find a structural Connectivity and load it in memory
connectivity_index = dao.get_generic_entity(
ConnectivityIndex, DataTypeMetaData.DEFAULT_SUBJECT, "subject")[0]
connectivity = h5.load_from_index(connectivity_index)
# Load the SimulatorAdapter algorithm from DB
cached_simulator_algorithm = AlgorithmService(
).get_algorithm_by_module_and_class(IntrospectionRegistry.SIMULATOR_MODULE,
IntrospectionRegistry.SIMULATOR_CLASS)
# Instantiate a SimulatorService and launch the configured simulation
simulator_model = SimulatorAdapterModel()
simulator_model.connectivity = connectivity.gid
simulator_model.simulation_length = 100
simulator_model.coupling = Scaling()
simulator_service = SimulatorService()
burst = BurstConfiguration(project.id, name="Simulation")
dao.store_entity(burst)
launched_operation = simulator_service.async_launch_and_prepare_simulation(
burst, project.administrator, project, cached_simulator_algorithm,
simulator_model)
# wait for the operation to finish
while not launched_operation.has_finished:
sleep(5)
launched_operation = dao.get_operation_by_id(launched_operation.id)
if launched_operation.status == STATUS_FINISHED:
ts = dao.get_generic_entity(TimeSeriesRegionIndex,
launched_operation.id,
"fk_from_operation")[0]
log.info("TimeSeries result is: %s " % ts)
else:
log.warning(
"Operation ended with problems [%s]: [%s]" %
(launched_operation.status, launched_operation.additional_info))
def launch_operation(self, current_user_id, model_file, project_gid,
algorithm_module, algorithm_classname, fetch_file):
temp_folder = create_temp_folder()
model_h5_path = save_temporary_file(model_file, temp_folder)
try:
project = self.project_service.find_project_lazy_by_gid(
project_gid)
except ProjectServiceException:
raise InvalidIdentifierException()
try:
algorithm = AlgorithmService.get_algorithm_by_module_and_class(
algorithm_module, algorithm_classname)
if algorithm is None:
raise InvalidIdentifierException(
'No algorithm found for: %s.%s' %
(algorithm_module, algorithm_classname))
adapter_instance = ABCAdapter.build_adapter(algorithm)
view_model = h5.load_view_model_from_file(model_h5_path)
if isinstance(adapter_instance, ABCUploader):
with ViewModelH5(model_h5_path, view_model) as view_model_h5:
for key, value in adapter_instance.get_form_class(
).get_upload_information().items():
data_file = fetch_file(request_file_key=key,
file_extension=value)
data_file_path = save_temporary_file(
data_file, temp_folder)
view_model_h5.store_metadata_param(key, data_file_path)
view_model = h5.load_view_model_from_file(model_h5_path)
operation = self.operation_service.prepare_operation(
current_user_id, project, algorithm, view_model=view_model)
if os.path.exists(model_h5_path):
os.remove(model_h5_path)
OperationService().launch_operation(operation.id, True)
return operation.gid
except Exception as excep:
self.logger.error(excep, exc_info=True)
raise ServiceException(str(excep))
def fire_simulation(project_id, simulator):
project = dao.get_project_by_id(project_id)
assert isinstance(simulator, Simulator)
# Load the SimulatorAdapter algorithm from DB
cached_simulator_algorithm = AlgorithmService(
).get_algorithm_by_module_and_class(IntrospectionRegistry.SIMULATOR_MODULE,
IntrospectionRegistry.SIMULATOR_CLASS)
# Instantiate a SimulatorService and launch the configured simulation
simulator_service = SimulatorService()
burst = BurstConfiguration(project.id)
burst.name = "Sim " + str(datetime.now())
burst.start_time = datetime.now()
dao.store_entity(burst)
launched_operation = simulator_service.async_launch_and_prepare_simulation(
burst, project.administrator, project, cached_simulator_algorithm,
simulator)
LOG.info("Operation launched ....")
return launched_operation
def test_datatype_select_field(self, connectivity_index_factory):
trait_attribute = SimulatorAdapterModel.connectivity
connectivity_1 = connectivity_index_factory(2)
connectivity_2 = connectivity_index_factory(2)
connectivity_3 = connectivity_index_factory(2)
op_1 = dao.get_operation_by_id(connectivity_1.fk_from_operation)
op_1.fk_launched_in = self.test_project.id
dao.store_entity(op_1)
op_2 = dao.get_operation_by_id(connectivity_2.fk_from_operation)
op_2.fk_launched_in = self.test_project.id
dao.store_entity(op_2)
op_3 = dao.get_operation_by_id(connectivity_3.fk_from_operation)
op_3.fk_launched_in = self.test_project.id
dao.store_entity(op_3)
datatype_select_field = TraitDataTypeSelectField(trait_attribute,
self.name,
None,
has_all_option=True)
AlgorithmService().fill_selectfield_with_datatypes(
datatype_select_field, self.test_project.id)
post_data = {self.name: connectivity_1.gid}
datatype_select_field.fill_from_post(post_data)
options = datatype_select_field.options()
conn_1 = next(options)
conn_2 = next(options)
conn_3 = next(options)
next(options)
with pytest.raises(StopIteration):
next(options)
assert conn_1.value == connectivity_3.gid
assert conn_2.value == connectivity_2.gid
assert conn_3.value == connectivity_1.gid
assert uuid.UUID(post_data[self.name]) == datatype_select_field.data, "UUID data was not set correctly on" \
" TraitDataTypeSelectField"
def __init__(self):
self.logger = get_logger(self.__class__.__module__)
self.burst_service = BurstService()
self.operation_service = OperationService()
self.algorithm_service = AlgorithmService()
self.storage_interface = StorageInterface()
class TestBurstService(BaseTestCase):
"""
Test the service layer for BURST PAGE. We can't have this transactional since
we launch operations in different threads and the transactional operator only rolls back
sessions bounded to the current thread transaction.
"""
burst_service = BurstService()
sim_algorithm = AlgorithmService().get_algorithm_by_module_and_class(IntrospectionRegistry.SIMULATOR_MODULE,
IntrospectionRegistry.SIMULATOR_CLASS)
def setup_method(self):
"""
Sets up the environment for running the tests;
cleans the database before testing and saves config file;
creates a test user, a test project;
creates burst, flow, operation and workflow services
"""
self.clean_database()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
def teardown_method(self):
"""
Clean up database.
"""
self.clean_database()
def test_clone_burst_configuration(self):
"""
Test that all the major attributes are the same after a clone burst but the
id of the cloned one is None.
"""
first_burst = TestFactory.store_burst(self.test_project.id)
cloned_burst = first_burst.clone()
self._compare_bursts(first_burst, cloned_burst)
assert cloned_burst.name == first_burst.name, 'Cloned burst should have the same name'
assert cloned_burst.id is None, 'id should be none for cloned entry.'
def test_store_burst_config(self):
"""
Test that a burst entity is properly stored in db.
"""
burst_config = TestFactory.store_burst(self.test_project.id)
assert burst_config.id is not None, 'Burst was not stored properly.'
stored_entity = dao.get_burst_by_id(burst_config.id)
assert stored_entity is not None, 'Burst was not stored properly.'
self._compare_bursts(burst_config, stored_entity)
def _compare_bursts(self, first_burst, second_burst):
"""
Compare that all important attributes are the same between two bursts. (name, project id and status)
"""
assert first_burst.name == second_burst.name, "Names not equal for bursts."
assert first_burst.fk_project == second_burst.fk_project, "Projects not equal for bursts."
assert first_burst.status == second_burst.status, "Statuses not equal for bursts."
assert first_burst.range1 == second_burst.range1, "Statuses not equal for bursts."
assert first_burst.range2 == second_burst.range2, "Statuses not equal for bursts."
def test_getavailablebursts_none(self):
"""
Test that an empty list is returned if no data is available in db.
"""
bursts = self.burst_service.get_available_bursts(self.test_project.id)
assert bursts == [], "Unexpected result returned : %s" % (bursts,)
def test_get_available_bursts_happy(self):
"""
Test that all the correct burst are returned for the given project.
"""
project = Project("second_test_proj", self.test_user.id, "description")
second_project = dao.store_entity(project)
test_project_bursts = [TestFactory.store_burst(self.test_project.id).id for _ in range(4)]
second_project_bursts = [TestFactory.store_burst(second_project.id).id for _ in range(3)]
returned_test_project_bursts = [burst.id for burst in
self.burst_service.get_available_bursts(self.test_project.id)]
returned_second_project_bursts = [burst.id for burst in
self.burst_service.get_available_bursts(second_project.id)]
assert len(test_project_bursts) == len(returned_test_project_bursts), \
"Incorrect bursts retrieved for project %s." % self.test_project
assert len(second_project_bursts) == len(returned_second_project_bursts), \
"Incorrect bursts retrieved for project %s." % second_project
assert set(second_project_bursts) == set(returned_second_project_bursts), \
"Incorrect bursts retrieved for project %s." % second_project
assert set(test_project_bursts) == set(returned_test_project_bursts), \
"Incorrect bursts retrieved for project %s." % self.test_project
def test_rename_burst(self, operation_factory):
"""
Test that renaming of a burst functions properly.
"""
operation = operation_factory()
burst_config = TestFactory.store_burst(self.test_project.id, operation)
self.burst_service.rename_burst(burst_config.id, "new_burst_name")
loaded_burst = dao.get_burst_by_id(burst_config.id)
assert loaded_burst.name == "new_burst_name", "Burst was not renamed properly."
def test_burst_delete_with_project(self):
"""
Test that on removal of a project all burst related data is cleared.
"""
TestFactory.store_burst(self.test_project.id)
ProjectService().remove_project(self.test_project.id)
self._check_burst_removed()
def test_load_burst_configuration(self):
"""
Test that loads the burst configuration based non the stored config id
"""
stored_burst = TestFactory.store_burst(self.test_project.id)
burst_config = self.burst_service.load_burst_configuration(stored_burst.id)
assert burst_config.id == stored_burst.id, "The loaded burst does not have the same ID"
def test_update_simulation_fields(self, tmph5factory):
"""
Test that updates the simulation fields of the burst
"""
stored_burst = TestFactory.store_burst(self.test_project.id)
connectivity = TestFactory.import_zip_connectivity(self.test_user, self.test_project)
op = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project)
simulation = SimulatorAdapterModel()
simulation.connectivity = UUID(connectivity.gid)
burst_config = self.burst_service.update_simulation_fields(stored_burst, op.id, simulation.gid)
assert burst_config.id == stored_burst.id, "The loaded burst does not have the same ID"
assert burst_config.fk_simulation == op.id, "The loaded burst does not have the fk simulation that it was given"
assert burst_config.simulator_gid == simulation.gid.hex, "The loaded burst does not have the simulation gid that it was given"
def test_prepare_name(self):
"""
Test prepare burst name
"""
stored_burst = TestFactory.store_burst(self.test_project.id)
simulation_tuple = self.burst_service.prepare_simulation_name(stored_burst, self.test_project.id)
assert simulation_tuple[0] == 'simulation_' + str(dao.get_number_of_bursts(self.test_project.id) + 1), \
"The default simulation name is not the defined one"
busrt_test_name = "Burst Test Name"
stored_burst.name = busrt_test_name
stored_burst = dao.store_entity(stored_burst)
simulation_tuple = self.burst_service.prepare_simulation_name(stored_burst, self.test_project.id)
assert simulation_tuple[0] == busrt_test_name, "The burst name is not the given one"
def test_prepare_burst_for_pse(self):
"""
Test prepare burst for pse
"""
burst = BurstConfiguration(self.test_project.id)
assert burst.fk_metric_operation_group == None, "The fk for the metric operation group is not None"
assert burst.fk_operation_group == None, "The fk for the operation group is not None"
assert burst.operation_group == None, "The operation group is not None"
pse_burst = self.burst_service.prepare_burst_for_pse(burst)
assert pse_burst.metric_operation_group != None, "The fk for the operation group is None"
assert pse_burst.operation_group != None, "The operation group is None"
def _check_burst_removed(self):
"""
Test that a burst was properly removed. This means checking that the burst entity,
any workflow steps and any datatypes resulted from the burst are also removed.
"""
remaining_bursts = dao.get_bursts_for_project(self.test_project.id)
assert 0 == len(remaining_bursts), "Burst was not deleted"
ops_number = dao.get_operation_numbers(self.test_project.id)[0]
assert 0 == ops_number, "Operations were not deleted."
datatypes = dao.get_datatypes_in_project(self.test_project.id)
assert 0 == len(datatypes)
datatype1_stored = self.count_all_entities(Datatype1)
datatype2_stored = self.count_all_entities(Datatype2)
assert 0 == datatype1_stored, "Specific datatype entries for DataType1 were not deleted."
assert 0 == datatype2_stored, "Specific datatype entries for DataType2 were not deleted."
def test_prepare_indexes_for_simulation_results(self, time_series_factory, operation_factory, simulator_factory):
ts_1 = time_series_factory()
ts_2 = time_series_factory()
ts_3 = time_series_factory()
operation = operation_factory(test_user=self.test_user, test_project=self.test_project)
sim_folder, sim_gid = simulator_factory(op=operation)
path_1 = os.path.join(sim_folder, "Time_Series_{}.h5".format(ts_1.gid.hex))
path_2 = os.path.join(sim_folder, "Time_Series_{}.h5".format(ts_2.gid.hex))
path_3 = os.path.join(sim_folder, "Time_Series_{}.h5".format(ts_3.gid.hex))
with TimeSeriesH5(path_1) as f:
f.store(ts_1)
f.sample_rate.store(ts_1.sample_rate)
f.store_generic_attributes(GenericAttributes())
with TimeSeriesH5(path_2) as f:
f.store(ts_2)
f.sample_rate.store(ts_2.sample_rate)
f.store_generic_attributes(GenericAttributes())
with TimeSeriesH5(path_3) as f:
f.store(ts_3)
f.sample_rate.store(ts_3.sample_rate)
f.store_generic_attributes(GenericAttributes())
burst_configuration = BurstConfiguration(self.test_project.id)
burst_configuration.fk_simulation = operation.id
burst_configuration.simulator_gid = operation.view_model_gid
burst_configuration = dao.store_entity(burst_configuration)
file_names = [path_1, path_2, path_3]
ts_datatypes = [ts_1, ts_2, ts_3]
indexes = self.burst_service.prepare_indexes_for_simulation_results(operation, file_names, burst_configuration)
for i in range(len(indexes)):
assert indexes[i].gid == ts_datatypes[i].gid.hex, "Gid was not set correctly on index."
assert indexes[i].sample_period == ts_datatypes[i].sample_period
assert indexes[i].sample_period_unit == ts_datatypes[i].sample_period_unit
assert indexes[i].sample_rate == ts_datatypes[i].sample_rate
def retrieve_project_full(self, project_id, applied_filters=None, current_page=1):
"""
Return a Tuple with Project entity and Operations for current Project.
:param project_id: Current Project Identifier
:param applied_filters: Filters to apply on Operations
:param current_page: Number for current page in operations
"""
selected_project = self.find_project(project_id)
total_filtered = self.count_filtered_operations(project_id, applied_filters)
pages_no = total_filtered // OPERATIONS_PAGE_SIZE + (1 if total_filtered % OPERATIONS_PAGE_SIZE else 0)
total_ops_nr = self.count_filtered_operations(project_id)
start_idx = OPERATIONS_PAGE_SIZE * (current_page - 1)
current_ops = dao.get_filtered_operations(project_id, applied_filters, start_idx, OPERATIONS_PAGE_SIZE)
if current_ops is None:
return selected_project, 0, [], 0
operations = []
for one_op in current_ops:
try:
result = {}
if one_op[0] != one_op[1]:
result["id"] = str(one_op[0]) + "-" + str(one_op[1])
else:
result["id"] = str(one_op[0])
burst = dao.get_burst_for_operation_id(one_op[0])
result["burst_name"] = burst.name if burst else '-'
result["count"] = one_op[2]
result["gid"] = one_op[13]
if one_op[3] is not None and one_op[3]:
try:
operation_group = dao.get_generic_entity(OperationGroup, one_op[3])[0]
result["group"] = operation_group.name
result["group"] = result["group"].replace("_", " ")
result["operation_group_id"] = operation_group.id
datatype_group = dao.get_datatypegroup_by_op_group_id(one_op[3])
result["datatype_group_gid"] = datatype_group.gid if datatype_group is not None else None
result["gid"] = operation_group.gid
# Filter only viewers for current DataTypeGroup entity:
result["view_groups"] = AlgorithmService().get_visualizers_for_group(datatype_group.gid) \
if datatype_group is not None else None
except Exception:
self.logger.exception("We will ignore group on entity:" + str(one_op))
result["datatype_group_gid"] = None
else:
result['group'] = None
result['datatype_group_gid'] = None
result["algorithm"] = dao.get_algorithm_by_id(one_op[4])
result["user"] = dao.get_user_by_id(one_op[5])
if type(one_op[6]) is str:
result["create"] = string2date(str(one_op[6]))
else:
result["create"] = one_op[6]
if type(one_op[7]) is str:
result["start"] = string2date(str(one_op[7]))
else:
result["start"] = one_op[7]
if type(one_op[8]) is str:
result["complete"] = string2date(str(one_op[8]))
else:
result["complete"] = one_op[8]
if result["complete"] is not None and result["start"] is not None:
result["duration"] = format_timedelta(result["complete"] - result["start"])
result["status"] = one_op[9]
result["additional"] = one_op[10]
result["visible"] = True if one_op[11] > 0 else False
result['operation_tag'] = one_op[12]
if not result['group']:
datatype_results = dao.get_results_for_operation(result['id'])
result['results'] = []
for dt in datatype_results:
dt_loaded = load_entity_by_gid(dt.gid)
if dt_loaded:
result['results'].append(dt_loaded)
else:
self.logger.warning("Could not retrieve datatype %s" % str(dt))
else:
result['results'] = None
operations.append(result)
except Exception:
# We got an exception when processing one Operation Row. We will continue with the rest of the rows.
self.logger.exception("Could not prepare operation for display:" + str(one_op))
return selected_project, total_ops_nr, operations, pages_no
def test_get_analyze_groups(self):
category, groups = AlgorithmService.get_analyze_groups()
assert category.displayname == 'Analyze'
assert len(groups) > 1
assert isinstance(groups[0], model_operation.AlgorithmTransientGroup)
class TestAlgorithmService(TransactionalTestCase):
"""
This class contains tests for the tvb.core.services.algorithm_service module.
"""
def transactional_setup_method(self):
""" Prepare some entities to work with during tests:"""
self.algorithm_service = AlgorithmService()
category = dao.get_uploader_categories()[0]
self.algorithm = dao.store_entity(
model_operation.Algorithm(TEST_ADAPTER_VALID_MODULE,
TEST_ADAPTER_VALID_CLASS, category.id))
def transactional_teardown_method(self):
dao.remove_entity(model_operation.Algorithm, self.algorithm.id)
def test_get_uploaders(self):
result = AlgorithmService.get_upload_algorithms()
assert 20 == len(result)
found = False
for algo in result:
if algo.classname == self.algorithm.classname and algo.module == self.algorithm.module:
found = True
break
assert found, "Uploader incorrectly returned"
def test_get_analyze_groups(self):
category, groups = AlgorithmService.get_analyze_groups()
assert category.displayname == 'Analyze'
assert len(groups) > 1
assert isinstance(groups[0], model_operation.AlgorithmTransientGroup)
def test_get_visualizers_for_group(self, datatype_group_factory):
group = datatype_group_factory()
dt_group = dao.get_datatypegroup_by_op_group_id(
group.fk_from_operation)
result = self.algorithm_service.get_visualizers_for_group(dt_group.gid)
# Both discrete and isocline are expected due to the 2 ranges set in the factory
assert 2 == len(result)
result_classnames = [res.classname for res in result]
assert IntrospectionRegistry.ISOCLINE_PSE_ADAPTER_CLASS in result_classnames
assert IntrospectionRegistry.DISCRETE_PSE_ADAPTER_CLASS in result_classnames
def test_get_launchable_algorithms(self, time_series_region_index_factory,
connectivity_factory,
region_mapping_factory):
conn = connectivity_factory()
rm = region_mapping_factory()
ts = time_series_region_index_factory(connectivity=conn,
region_mapping=rm)
result, has_operations_warning = self.algorithm_service.get_launchable_algorithms(
ts.gid)
assert 'Analyze' in result
assert 'View' in result
assert has_operations_warning is False
def test_get_group_by_identifier(self):
"""
Test for the get_algorithm_by_identifier.
"""
algo_ret = AlgorithmService.get_algorithm_by_identifier(
self.algorithm.id)
assert algo_ret.id == self.algorithm.id, "ID-s are different!"
assert algo_ret.module == self.algorithm.module, "Modules are different!"
assert algo_ret.fk_category == self.algorithm.fk_category, "Categories are different!"
assert algo_ret.classname == self.algorithm.classname, "Class names are different!"
def test_build_adapter_invalid(self):
"""
Test flow for trying to build an adapter that does not inherit from ABCAdapter.
"""
group = dao.get_algorithm_by_module(TEST_ADAPTER_VALID_MODULE,
TEST_ADAPTER_INVALID_CLASS)
with pytest.raises(IntrospectionException):
ABCAdapter.build_adapter(group)
def test_prepare_adapter(self):
"""
Test preparation of an adapter.
"""
assert isinstance(self.algorithm,
model_operation.Algorithm), "Can not find Adapter!"
adapter = self.algorithm_service.prepare_adapter(self.algorithm)
assert isinstance(adapter, TestAdapter1), "Adapter incorrectly built"
assert adapter.get_form_class() == TestAdapter1Form
assert adapter.get_view_model() == TestModel
class BaseController(object):
"""
This class contains the methods served at the root of the Web site.
"""
def __init__(self):
self.logger = get_logger(self.__class__.__module__)
self.user_service = UserService()
self.algorithm_service = AlgorithmService()
self.analyze_category_link = '/flow/step_analyzers'
self.analyze_adapters = None
self.connectivity_tab_link = '/flow/step_connectivity'
view_category = self.algorithm_service.get_visualisers_category()
conn_id = self.algorithm_service.get_algorithm_by_module_and_class(IntrospectionRegistry.CONNECTIVITY_MODULE,
IntrospectionRegistry.CONNECTIVITY_CLASS).id
connectivity_link = self.get_url_adapter(view_category.id, conn_id)
self.connectivity_submenu = [dict(title="Large Scale Connectivity", link=connectivity_link,
subsection=WebStructure.SUB_SECTION_CONNECTIVITY,
description="View Connectivity Regions. Perform Connectivity lesions"),
dict(title="Local Connectivity", link='/spatial/localconnectivity/step_1/1',
subsection=WebStructure.SUB_SECTION_LOCAL_CONNECTIVITY,
description="Create or view existent Local Connectivity entities.")]
allen_algo = self.algorithm_service.get_algorithm_by_module_and_class(
IntrospectionRegistry.ALLEN_CREATOR_MODULE,
IntrospectionRegistry.ALLEN_CREATOR_CLASS)
if allen_algo and not allen_algo.removed:
# Only add the Allen Creator if AllenSDK is installed
allen_link = self.get_url_adapter(allen_algo.fk_category, allen_algo.id)
self.connectivity_submenu.append(dict(title="Allen Connectome Builder", link=allen_link,
subsection=WebStructure.SUB_SECTION_ALLEN,
description="Download data from Allen dataset and create a mouse connectome"))
self.burst_submenu = [dict(link='/burst', subsection=WebStructure.SUB_SECTION_BURST,
title='Simulation Cockpit', description='Manage simulations'),
dict(link='/burst/dynamic', subsection='dynamic',
title='Phase plane', description='Configure model dynamics')]
@staticmethod
def mark_file_for_delete(file_name, delete_parent_folder=False):
"""
This method stores provided file name in session,
and later on when request is done, all these files/folders
are deleted
:param file_name: name of the file or folder to be deleted
:param delete_parent_folder: specify if the parent folder of the file should be removed too.
"""
# No processing if no file specified
if file_name is None:
return
files_list = common.get_from_session(FILES_TO_DELETE_ATTR)
if files_list is None:
files_list = []
common.add2session(FILES_TO_DELETE_ATTR, files_list)
# Now add file/folder to list
if delete_parent_folder:
folder_name = os.path.split(file_name)[0]
files_list.append(folder_name)
else:
files_list.append(file_name)
def _mark_selected(self, project):
"""
Set the project passed as parameter as the selected project.
"""
previous_project = common.get_current_project()
# Update project stored in selection, with latest Project entity from DB.
members = self.user_service.get_users_for_project("", project.id)[1]
project.members = members
if previous_project is None or previous_project.id != project.id:
# Clean Burst selection from session in case of a different project.
common.clean_project_data_from_session()
# Store in DB new project selection
user = common.get_from_session(common.KEY_USER)
if user is not None:
self.user_service.save_project_to_user(user.id, project.id)
# Display info message about project change
self.logger.debug("Selected project is now " + project.name)
common.set_info_message("Your current working project is: " + str(project.name))
# Add the project entity to session every time, as it might be changed (e.g. after edit)
common.add2session(common.KEY_PROJECT, project)
@staticmethod
def get_url_adapter(step_key, adapter_id, back_page=None):
"""
Compute the URLs for a given adapter.
Same URL is used both for GET and POST.
"""
result_url = '/flow/' + str(step_key) + '/' + str(adapter_id)
if back_page is not None:
result_url = result_url + "?back_page=" + str(back_page)
return result_url
@cherrypy.expose
def index(self):
"""
/ Path response
Redirects to /tvb
"""
raise cherrypy.HTTPRedirect('/user')
@cherrypy.expose()
@using_template('user/base_user')
def tvb(self, error=False, **data):
"""
/tvb URL
Returns the home page with the messages stored in the user's session.
"""
self.logger.debug("Unused submit attributes:" + str(data))
template_dictionary = dict(mainContent="index", title="The Virtual Brain Project")
template_dictionary = self._fill_user_specific_attributes(template_dictionary)
if common.get_from_session(common.KEY_IS_RESTART):
template_dictionary[common.KEY_IS_RESTART] = True
common.remove_from_session(common.KEY_IS_RESTART)
return self.fill_default_attributes(template_dictionary, error)
@cherrypy.expose
@using_template('user/base_user')
def error(self, **data):
"""Error page to redirect when something extremely bad happened"""
template_specification = dict(mainContent="error", title="Error page", data=data)
template_specification = self._fill_user_specific_attributes(template_specification)
return self.fill_default_attributes(template_specification)
def _populate_user_and_project(self, template_dictionary, escape_db_operations=False):
"""
Populate the template dictionary with current logged user (from session).
"""
logged_user = common.get_logged_user()
template_dictionary[common.KEY_USER] = logged_user
show_help = logged_user is not None and logged_user.is_online_help_active()
template_dictionary[common.KEY_SHOW_ONLINE_HELP] = show_help
project = common.get_current_project()
template_dictionary[common.KEY_PROJECT] = project
if project is not None and not escape_db_operations:
self.update_operations_count()
return template_dictionary
@staticmethod
def _populate_message(template_dictionary):
"""
Populate the template dictionary with current message stored in session.
Also specify the message type (default INFO).
Clear from session current message (to avoid displaying it twice).
"""
msg = common.pop_message_from_session()
template_dictionary.update(msg)
return template_dictionary
@staticmethod
def _populate_web_keycloak_config(template_dictionary):
if common.KEY_KEYCLOAK_WEB not in template_dictionary and TvbProfile.current.KEYCLOAK_LOGIN_ENABLED \
and TvbProfile.current.KEYCLOAK_WEB_CONFIG:
template_dictionary[common.KEY_KEYCLOAK_WEB] = TvbProfile.current.KEYCLOAK_WEB_CONFIG
return template_dictionary
def _populate_menu(self, template_dictionary):
"""
Populate current template with information for the Left Menu.
"""
if common.KEY_FIRST_RUN not in template_dictionary:
template_dictionary[common.KEY_FIRST_RUN] = False
template_dictionary[common.KEY_LINK_ANALYZE] = self.analyze_category_link
template_dictionary[common.KEY_LINK_CONNECTIVITY_TAB] = self.connectivity_tab_link
if common.KEY_BACK_PAGE not in template_dictionary:
template_dictionary[common.KEY_BACK_PAGE] = False
template_dictionary[common.KEY_SECTION_TITLES] = WebStructure.WEB_SECTION_TITLES
template_dictionary[common.KEY_SUBSECTION_TITLES] = WebStructure.WEB_SUBSECTION_TITLES
return template_dictionary
def _populate_section(self, algorithm, result_template, is_burst=True):
"""
Populate Section and Sub-Section fields from current Algorithm-Group.
"""
if algorithm.module == IntrospectionRegistry.CONNECTIVITY_MODULE:
result_template[common.KEY_SECTION] = WebStructure.SECTION_CONNECTIVITY
result_template[common.KEY_SUB_SECTION] = WebStructure.SUB_SECTION_CONNECTIVITY
result_template[common.KEY_SUBMENU_LIST] = self.connectivity_submenu
elif algorithm.module == IntrospectionRegistry.ALLEN_CREATOR_MODULE:
result_template[common.KEY_SECTION] = WebStructure.SECTION_CONNECTIVITY
result_template[common.KEY_SUB_SECTION] = WebStructure.SUB_SECTION_ALLEN
result_template[common.KEY_SUBMENU_LIST] = self.connectivity_submenu
elif algorithm.algorithm_category.display:
## We are having a visualizer:
if is_burst:
result_template[common.KEY_SECTION] = WebStructure.SECTION_BURST
result_template[common.KEY_SUBMENU_LIST] = self.burst_submenu
else:
result_template[common.KEY_SECTION] = WebStructure.SECTION_PROJECT
result_template[common.KEY_SUB_SECTION] = 'view_' + algorithm.subsection_name
elif algorithm.algorithm_category.rawinput:
### Upload algorithms
result_template[common.KEY_SECTION] = WebStructure.SECTION_PROJECT
result_template[common.KEY_SUB_SECTION] = WebStructure.SUB_SECTION_DATA_STRUCTURE
elif 'RAW_DATA' in algorithm.algorithm_category.defaultdatastate:
### Creators
result_template[common.KEY_SECTION] = WebStructure.SECTION_STIMULUS
result_template[common.KEY_SUB_SECTION] = WebStructure.SUB_SECTION_STIMULUS_MENU
else:
### Analyzers
result_template[common.KEY_SECTION] = algorithm.algorithm_category.displayname.lower()
result_template[common.KEY_SUB_SECTION] = algorithm.subsection_name
result_template[common.KEY_SUBMENU_LIST] = self.analyze_adapters
def _fill_user_specific_attributes(self, template_dictionary):
"""
Attributes needed for base_user template.
"""
template_dictionary[common.KEY_INCLUDE_TOOLTIP] = False
template_dictionary[common.KEY_WRAP_CONTENT_IN_MAIN_DIV] = True
template_dictionary[common.KEY_CURRENT_TAB] = 'none'
return template_dictionary
def fill_default_attributes(self, template_dictionary, escape_db_operations=False):
"""
Fill into 'template_dictionary' data that we want to have ready in UI.
"""
template_dictionary = self._populate_user_and_project(template_dictionary, escape_db_operations)
template_dictionary = self._populate_message(template_dictionary)
template_dictionary = self._populate_menu(template_dictionary)
template_dictionary = self._populate_web_keycloak_config(template_dictionary)
if common.KEY_ERRORS not in template_dictionary:
template_dictionary[common.KEY_ERRORS] = {}
if common.KEY_FORM_DATA not in template_dictionary:
template_dictionary[common.KEY_FORM_DATA] = {}
if common.KEY_SUB_SECTION not in template_dictionary and common.KEY_SECTION in template_dictionary:
template_dictionary[common.KEY_SUB_SECTION] = template_dictionary[common.KEY_SECTION]
if common.KEY_SUBMENU_LIST not in template_dictionary:
template_dictionary[common.KEY_SUBMENU_LIST] = None
js_suffix = TvbProfile.current.version.CURRENT_VERSION.replace(".", "").replace("-", "")
template_dictionary[common.KEY_CURRENT_VERSION] = TvbProfile.current.version.BASE_VERSION
template_dictionary[common.KEY_CURRENT_JS_VERSION] = js_suffix
return template_dictionary
def fill_overlay_attributes(self, template_dictionary, title, description, content_template,
css_class, tabs_horizontal=None, overlay_indexes=None, tabs_vertical=None):
"""
This method prepares parameters for rendering overlay (overlay.html)
:param title: overlay title
:param description: overlay description
:param content_template: path&name of the template file which will fill overlay content (without .html)
:param css_class: CSS class to be applied on overlay
:param tabs_horizontal: list of strings containing names of the tabs spread horizontally
:param tabs_vertical: list of strings containing names of the tabs spread vertically
"""
if template_dictionary is None:
template_dictionary = dict()
template_dictionary[common.KEY_OVERLAY_TITLE] = title
template_dictionary[common.KEY_OVERLAY_DESCRIPTION] = description
template_dictionary[common.KEY_OVERLAY_CONTENT_TEMPLATE] = content_template
template_dictionary[common.KEY_OVERLAY_CLASS] = css_class
template_dictionary[common.KEY_OVERLAY_TABS_HORIZONTAL] = tabs_horizontal if tabs_horizontal is not None else []
template_dictionary[common.KEY_OVERLAY_TABS_VERTICAL] = tabs_vertical if tabs_vertical is not None else []
if overlay_indexes is not None:
template_dictionary[common.KEY_OVERLAY_INDEXES] = overlay_indexes
else:
template_dictionary[common.KEY_OVERLAY_INDEXES] = list(range(len(tabs_horizontal))) \
if tabs_horizontal is not None else []
template_dictionary[common.KEY_OVERLAY_PAGINATION] = False
return template_dictionary
@cherrypy.expose
@using_template('overlay_blocker')
def showBlockerOverlay(self, **data):
"""
Returns the content of the blocking overlay (covers entire page and do not allow any action)
"""
return self.fill_default_attributes(dict(data))
def update_operations_count(self):
"""
If a project is selected, update Operation Numbers in call-out.
"""
project = common.get_current_project()
if project is not None:
fns, sta, err, canceled, pending = self.algorithm_service.get_operation_numbers(project.id)
project.operations_finished = fns
project.operations_started = sta
project.operations_error = err
project.operations_canceled = canceled
project.operations_pending = pending
common.add2session(common.KEY_PROJECT, project)
@using_template('form_fields/form')
def render_adapter_form(self, adapter_form, is_callout=False):
show_online_help = common.get_logged_user().is_online_help_active()
return {'adapter_form': adapter_form, 'showOnlineHelp': show_online_help, 'isCallout': is_callout}
ConnectivityIndex, DataTypeMetaData.DEFAULT_SUBJECT, "subject")[0]
connectivity = h5.load_from_index(connectivity_index)
# Prepare a Simulator instance with defaults and configure it to use the previously loaded Connectivity
simulator = Simulator()
simulator.connectivity = connectivity
# Configure the Simulator to use a Scaling type coupling
simulator.coupling = Scaling()
# Choose a higher value for the 'tau' parameter of the Generic2dOscillator model
simulator.model.tau = numpy.array([2.0])
# Configure the simulation length
simulator.simulation_length = 100
# Load the SimulatorAdapter algorithm from DB
cached_simulator_algorithm = AlgorithmService(
).get_algorithm_by_module_and_class(IntrospectionRegistry.SIMULATOR_MODULE,
IntrospectionRegistry.SIMULATOR_CLASS)
# Instantiate a SimulatorService and launch the configured simulation
simulator_service = SimulatorService()
launched_operation = simulator_service.async_launch_and_prepare_simulation(
BurstConfiguration(project.id), project.administrator, project,
cached_simulator_algorithm, simulator)
# wait for the operation to finish
while not launched_operation.has_finished:
sleep(5)
launched_operation = dao.get_operation_by_id(launched_operation.id)
if launched_operation.status == STATUS_FINISHED:
ts = dao.get_generic_entity(TimeSeriesRegionIndex,
