def build(adapter_class=DummyAdapter1):
all_categories = dao.get_algorithm_categories()
algo_category_id = all_categories[0].id
stored_adapter = Algorithm(adapter_class.__module__, adapter_class.__name__, algo_category_id,
adapter_class.get_group_name(), adapter_class.get_group_description(),
adapter_class.get_ui_name(), adapter_class.get_ui_description(),
adapter_class.get_ui_subsection(), datetime.now())
adapter_inst = adapter_class()
adapter_form = adapter_inst.get_form()
required_datatype = adapter_form.get_required_datatype()
if required_datatype is not None:
required_datatype = required_datatype.__name__
filters = adapter_form.get_filters()
if filters is not None:
filters = filters.to_json()
stored_adapter.required_datatype = required_datatype
stored_adapter.datatype_filter_filter = filters
stored_adapter.parameter_name = adapter_form.get_input_name()
stored_adapter.outputlist = str(adapter_inst.get_output())
inst_from_db = dao.get_algorithm_by_module(adapter_class.__module__, adapter_class.__name__)
if inst_from_db is not None:
stored_adapter.id = inst_from_db.id
return dao.store_entity(stored_adapter, inst_from_db is not None)
def test_introspect(self):
"""
Test that expected categories and groups are found in DB after introspection.
We also check algorithms introspected during base_testcase.init_test_env
"""
all_categories = dao.get_algorithm_categories()
category_ids = [
cat.id for cat in all_categories
if cat.displayname == "AdaptersTest"
]
adapters = dao.get_adapters_from_categories(category_ids)
self.assertEqual(8, len(adapters), "Introspection failed!")
nr_adapters_mod2 = 0
for algorithm in adapters:
self.assertTrue(
algorithm.module in [
'tvb.tests.framework.adapters.testadapter1',
'tvb.tests.framework.adapters.testadapter2',
'tvb.tests.framework.adapters.testadapter3',
'tvb.tests.framework.adapters.ndimensionarrayadapter',
'tvb.tests.framework.adapters.testgroupadapter'
], "Unknown Adapter module:" + str(algorithm.module))
self.assertTrue(
algorithm.classname in [
"TestAdapter1", "TestAdapterDatatypeInput", "TestAdapter2",
"TestAdapter22", "TestAdapterHugeMemoryRequired",
"TestAdapter3", "TestAdapterHDDRequired",
"NDimensionArrayAdapter"
], "Unknown Adapter Class:" + str(algorithm.classname))
if algorithm.module == 'tvb.tests.framework.adapters.testadapter2':
nr_adapters_mod2 += 1
self.assertEqual(nr_adapters_mod2, 2)
def test_introspect(self):
"""
Test that expected categories and groups are found in DB after introspection.
We also check algorithms introspected during base_testcase.init_test_env
"""
all_categories = dao.get_algorithm_categories()
category_ids = [cat.id for cat in all_categories if cat.displayname == "AdaptersTest"]
adapters = dao.get_adapters_from_categories(category_ids)
self.assertEqual(8, len(adapters), "Introspection failed!")
nr_adapters_mod2 = 0
for algorithm in adapters:
self.assertTrue(algorithm.module in ['tvb.tests.framework.adapters.testadapter1',
'tvb.tests.framework.adapters.testadapter2',
'tvb.tests.framework.adapters.testadapter3',
'tvb.tests.framework.adapters.ndimensionarrayadapter',
'tvb.tests.framework.adapters.testgroupadapter'],
"Unknown Adapter module:" + str(algorithm.module))
self.assertTrue(algorithm.classname in ["TestAdapter1", "TestAdapterDatatypeInput",
"TestAdapter2", "TestAdapter22", "TestAdapterHugeMemoryRequired",
"TestAdapter3", "TestAdapterHDDRequired",
"NDimensionArrayAdapter"
],
"Unknown Adapter Class:" + str(algorithm.classname))
if algorithm.module == 'tvb.tests.framework.adapters.testadapter2':
nr_adapters_mod2 += 1
self.assertEqual(nr_adapters_mod2, 2)
def test_default_cancel(self):
"""
On cancel we should get a redirect to the back page link.
"""
cherrypy.request.method = "POST"
categories = dao.get_algorithm_categories()
algo_groups = dao.get_adapters_from_categories([categories[0].id])
self._expect_redirect('/project/viewoperations/%i' % self.test_project.id, self.flow_c.default,
categories[0].id, algo_groups[0].id, cancel=True, back_page='operations')
def test_default_cancel(self):
"""
On cancel we should get a redirect to the back page link.
"""
cherrypy.request.method = "POST"
categories = dao.get_algorithm_categories()
algo_groups = dao.get_groups_by_categories([categories[0].id])
self._expect_redirect('/project/viewoperations/%i' % self.test_project.id, self.flow_c.default,
categories[0].id, algo_groups[0].id, cancel=True, back_page='operations')
def teardown_method(self):
all_categories = dao.get_algorithm_categories()
category_ids = [
cat.id for cat in all_categories
if cat.displayname == TestCategory.category_name
]
adapters = dao.get_adapters_from_categories(category_ids)
for algorithm in adapters:
dao.remove_entity(Algorithm, algorithm.id)
dao.remove_entity(AlgorithmCategory, category_ids[0])
def test_valid_step(self):
"""
For all algorithm categories check that a submenu is generated and the result
page has it's title given by category name.
"""
categories = dao.get_algorithm_categories()
for categ in categories:
result_dict = self.flow_c.step(categ.id)
self.assertTrue(common.KEY_SUBMENU_LIST in result_dict,
"Expect to have a submenu with available algorithms for category.")
self.assertEqual(result_dict["section_name"], categ.displayname.lower())
def test_valid_step(self):
"""
For all algorithm categories check that a submenu is generated and the result
page has it's title given by category name.
"""
categories = dao.get_algorithm_categories()
for categ in categories:
result_dict = self.flow_c.step(categ.id)
self.assertTrue(b_c.KEY_SUBMENU_LIST in result_dict,
"Expect to have a submenu with available algorithms for category.")
self.assertEqual(result_dict["section_name"], categ.displayname.lower())
def test_default(self):
"""
Test default method from step controllers. Check that the submit link is ok, that a mainContent
is present in result dict and that the isAdapter flag is set to true.
"""
cherrypy.request.method = "GET"
categories = dao.get_algorithm_categories()
for categ in categories:
algo_groups = dao.get_adapters_from_categories([categ.id])
for algo in algo_groups:
result_dict = self.flow_c.default(categ.id, algo.id)
assert result_dict[common.KEY_SUBMIT_LINK] == '/flow/%i/%i' % (categ.id, algo.id)
assert 'mainContent' in result_dict
assert result_dict['isAdapter']
def test_default(self):
"""
Test default method from step controllers. Check that the submit link is ok, that a mainContent
is present in result dict and that the isAdapter flag is set to true.
"""
cherrypy.request.method = "GET"
categories = dao.get_algorithm_categories()
for categ in categories:
algo_groups = dao.get_groups_by_categories([categ.id])
for algo in algo_groups:
result_dict = self.flow_c.default(categ.id, algo.id)
self.assertEqual(result_dict[common.KEY_SUBMIT_LINK], '/flow/%i/%i' % (categ.id, algo.id))
self.assertTrue('mainContent' in result_dict)
self.assertTrue(result_dict['isAdapter'])
def test_default(self):
"""
Test default method from step controllers. Check that the submit link is ok, that a mainContent
is present in result dict and that the isAdapter flag is set to true.
"""
cherrypy.request.method = "GET"
categories = dao.get_algorithm_categories()
for categ in categories:
# Ignore creators, as those won't go through this flow
if categ.displayname in [CreateAlgorithmCategoryConfig.category_name]:
continue
algo_groups = dao.get_adapters_from_categories([categ.id])
for algo in algo_groups:
result_dict = self.flow_c.default(categ.id, algo.id)
assert result_dict[common.KEY_SUBMIT_LINK] == '/flow/%i/%i' % (categ.id, algo.id)
assert 'mainContent' in result_dict
assert result_dict['isAdapter']
def test_introspect(self):
"""
Test the actual introspect module on a test structure created in:
tvb_test.dummy_adapters and tvb_test.dummy_datatypes
"""
self.introspector.introspect(True)
initialize_storage()
all_categories = dao.get_algorithm_categories()
category_ids = [
cat.id for cat in all_categories
if cat.displayname == "AdaptersTest"
]
groups = dao.get_groups_by_categories(category_ids)
self.assertEqual(len(groups), 11, "Introspection failed!")
nr_adapters_mod2 = 0
for algorithm in groups:
self.assertTrue(
algorithm.module in [
'tvb_test.adapters.testadapter1',
'tvb_test.adapters.testadapter2',
'tvb_test.adapters.testadapter3',
'tvb_test.adapters.ndimensionarrayadapter',
"tvb.adapters.analyzers.group_python_adapter",
"tvb_test.adapters.testgroupadapter"
], "Unknown Adapter:" + str(algorithm.module))
self.assertTrue(
algorithm.classname in [
"TestAdapter1", "TestAdapterDatatypeInput", "TestAdapter2",
"TestAdapter22", "TestAdapter3", "NDimensionArrayAdapter",
"PythonAdapter", "TestAdapterHDDRequired",
"TestAdapterHugeMemoryRequired",
"TestAdapterNoMemoryImplemented", "TestGroupAdapter"
], "Unknown Adapter Class:" + str(algorithm.classname))
if algorithm.module == 'tvb_test.adapters.testadapter2':
nr_adapters_mod2 = nr_adapters_mod2 + 1
self.assertEqual(
nr_adapters_mod2, 2,
"Two adapters should have been loaded from module tvb_test.adapters2!"
)
def test_introspect(self):
"""
Test that expected categories and groups are found in DB after introspection.
We also check algorithms introspected during base_testcase.init_test_env
"""
introspector = Introspector()
introspector.introspection_registry.ADAPTERS[
TestCategory] = import_adapters(tvb.tests.framework.adapters,
ALL_TEST_ADAPTERS)
introspector.introspect()
all_categories = dao.get_algorithm_categories()
category_ids = [
cat.id for cat in all_categories
if cat.displayname == TestCategory.category_name
]
adapters = dao.get_adapters_from_categories(category_ids)
assert 5 == len(adapters), "Introspection failed!"
nr_adapters_mod3 = 0
for algorithm in adapters:
assert algorithm.module in [
'tvb.tests.framework.adapters.testadapter1',
'tvb.tests.framework.adapters.testadapter2',
'tvb.tests.framework.adapters.testadapter3'
], "Unknown Adapter Module:" + str(algorithm.module)
assert algorithm.classname in [
"TestAdapter1", "TestAdapter2",
"TestAdapterHugeMemoryRequired", "TestAdapter3",
"TestAdapterHDDRequired"
], "Unknown Adapter Class:" + str(algorithm.classname)
if algorithm.module == 'tvb.tests.framework.adapters.testadapter3':
nr_adapters_mod3 += 1
assert nr_adapters_mod3 == 3
def read_algorithm_categories():
"""
Retrieve from DB all categories of adapters that were previously stored
by introspection into a Python module-given as parameter at startup.
"""
return dao.get_algorithm_categories()
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)
start_idx = OPERATIONS_PAGE_SIZE * (current_page - 1)
if total_filtered >= start_idx + OPERATIONS_PAGE_SIZE:
end_idx = OPERATIONS_PAGE_SIZE
else:
end_idx = total_filtered - start_idx
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)
current_ops = dao.get_filtered_operations(project_id, applied_filters, start_idx, end_idx)
started_ops = 0
if current_ops is None:
return selected_project, [], 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[14]
if one_op[3] is not None and one_op[3]:
try:
operation_group = dao.get_generic_entity(model.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])
datatype = dao.get_datatype_by_id(datatype_group.id)
result["datatype_group_gid"] = datatype.gid
result["gid"] = operation_group.gid
all_categs = dao.get_algorithm_categories()
view_categ = dao.get_visualisers_categories()[0]
excludes = [categ.id for categ in all_categs if categ.id != view_categ.id]
algo = self.retrieve_launchers("DataTypeGroup", datatype.gid,
exclude_categories=excludes).values()[0]
view_groups = []
for algo in algo.values():
url = '/flow/' + str(algo['category']) + '/' + str(algo['id'])
if algo['part_of_group']:
url = '/flow/prepare_group_launch/' + datatype.gid + '/' + \
str(algo['category']) + '/' + str(algo['id'])
view_groups.append(dict(name=algo["displayName"],
url=url,
param_name=algo['children'][0]['param_name'],
part_of_group=algo['part_of_group']))
result["view_groups"] = view_groups
except Exception, excep:
self.logger.error(excep)
self.logger.warning("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["method"] = one_op[5]
result["user"] = dao.get_user_by_id(one_op[6])
if type(one_op[7]) in (str, unicode):
result["create"] = string2date(str(one_op[7]))
else:
result["create"] = one_op[7]
if type(one_op[8]) in (str, unicode):
result["start"] = string2date(str(one_op[8]))
else:
result["start"] = one_op[8]
if type(one_op[9]) in (str, unicode):
result["complete"] = string2date(str(one_op[9]))
else:
result["complete"] = one_op[9]
if result["complete"] is not None and result["start"] is not None:
result["duration"] = timedelta2string(result["complete"] - result["start"])
result["status"] = one_op[10]
if result["status"] == model.STATUS_STARTED:
started_ops += 1
result["additional"] = one_op[11]
result["visible"] = True if one_op[12] > 0 else False
result['operation_tag'] = one_op[13]
result['figures'] = None
if not result['group']:
datatype_results = dao.get_results_for_operation(result['id'])
result['results'] = [dao.get_generic_entity(dt.module + '.' + dt.type,
dt.gid, 'gid')[0] for dt in datatype_results]
operation_figures = dao.get_figures_for_operation(result['id'])
# Compute the full path to the figure / image on disk
for figure in operation_figures:
figures_folder = self.structure_helper.get_images_folder(figure.project.name,
figure.operation.id)
figure_full_path = os.path.join(figures_folder, figure.file_path)
# Compute the path available from browser
figure.figure_path = utils.path2url_part(figure_full_path)
result['figures'] = operation_figures
else:
result['results'] = None
operations.append(result)
def read_algorithm_categories():
"""
Retrieve from DB all categories of adapters that were previously stored
by introspection into a Python module-given as parameter at startup.
"""
return dao.get_algorithm_categories()
