body_hash
stringlengths
64
64
body
stringlengths
23
109k
docstring
stringlengths
1
57k
path
stringlengths
4
198
name
stringlengths
1
115
repository_name
stringlengths
7
111
repository_stars
float64
0
191k
lang
stringclasses
1 value
body_without_docstring
stringlengths
14
108k
unified
stringlengths
45
133k
0b42b0e45c78481f0c54577a737b3f96f2c93a9eaa6d829f8d2a0df88add870b
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_not_enrolled_not_passed_not_offered(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): 'test for get_info_for_course for course with run not passed and nothing offered' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)), patch('courses.models.Course.first_unexpired_run', return_value=None): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course for course with run not passed and nothing offered
dashboard/api_test.py
test_info_not_enrolled_not_passed_not_offered
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_not_enrolled_not_passed_not_offered(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)), patch('courses.models.Course.first_unexpired_run', return_value=None): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_not_enrolled_not_passed_not_offered(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)), patch('courses.models.Course.first_unexpired_run', return_value=None): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course for course with run not passed and nothing offered<|endoftext|>
f1278de8995a5a76a747d04e7cb52d8074ba02cc72820d28e605e14aae27e83a
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_grade(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): 'test for get_info_for_course for course with a course current and another not passed' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CURRENTLY_ENROLLED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.CURRENTLY_ENROLLED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course for course with a course current and another not passed
dashboard/api_test.py
test_info_grade
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_grade(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CURRENTLY_ENROLLED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.CURRENTLY_ENROLLED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_grade(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CURRENTLY_ENROLLED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.CURRENTLY_ENROLLED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course for course with a course current and another not passed<|endoftext|>
30baae301d9e9e54577ae0bc89db5416a112a514359df31da23996e783a891d1
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_but_not_passed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case a check if the course has been passed is required\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_ENROLLED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run, api.CourseStatus.OFFERED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course in case a check if the course has been passed is required
dashboard/api_test.py
test_info_check_but_not_passed
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_but_not_passed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_ENROLLED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run, api.CourseStatus.OFFERED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_but_not_passed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_ENROLLED, self.course_run, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run, api.CourseStatus.OFFERED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course in case a check if the course has been passed is required<|endoftext|>
f2fe41ee6c1354e52b39a83108a3d4ba6c4d6355b8d05adc003fa319b772b579
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_missed_deadline(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course with a missed upgrade deadline\n ' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_ENROLLED, self.course_run, api.CourseRunStatus.MISSED_DEADLINE)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.MISSED_DEADLINE, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run, api.CourseStatus.OFFERED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course with a missed upgrade deadline
dashboard/api_test.py
test_info_missed_deadline
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_missed_deadline(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_ENROLLED, self.course_run, api.CourseRunStatus.MISSED_DEADLINE)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.MISSED_DEADLINE, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run, api.CourseStatus.OFFERED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_missed_deadline(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_ENROLLED, self.course_run, api.CourseRunStatus.MISSED_DEADLINE)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.MISSED_DEADLINE, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run, api.CourseStatus.OFFERED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course with a missed upgrade deadline<|endoftext|>
4050171ccd4a07c7d891dbaed7e8d74883dfa8278a53950cdd0a1057a3dd2f09
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_but_not_passed_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case a check if the course has been passed\n is required for the course, the course has not been passed and there is no next run\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run_past, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) mock_format.assert_called_once_with(self.course_run_past, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course in case a check if the course has been passed is required for the course, the course has not been passed and there is no next run
dashboard/api_test.py
test_info_check_but_not_passed_no_next
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_but_not_passed_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case a check if the course has been passed\n is required for the course, the course has not been passed and there is no next run\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run_past, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) mock_format.assert_called_once_with(self.course_run_past, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_but_not_passed_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case a check if the course has been passed\n is required for the course, the course has not been passed and there is no next run\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': False}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run_past, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) mock_format.assert_called_once_with(self.course_run_past, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course in case a check if the course has been passed is required for the course, the course has not been passed and there is no next run<|endoftext|>
db71ad2ca63a2cf034e6aec8aaf659bc0f2f6616aa1c303aba9f98ea3abe5f8c
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_passed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case a check if the course has been passed\n is required for the course and the course has been passed\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': True, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run_ver, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) assert (mock_format.call_count == 2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course in case a check if the course has been passed is required for the course and the course has been passed
dashboard/api_test.py
test_info_check_passed
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_passed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case a check if the course has been passed\n is required for the course and the course has been passed\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': True, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run_ver, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) assert (mock_format.call_count == 2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_check_passed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case a check if the course has been passed\n is required for the course and the course has been passed\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': True, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CHECK_IF_PASSED, self.course_run_ver, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) assert (mock_format.call_count == 2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course in case a check if the course has been passed is required for the course and the course has been passed<|endoftext|>
b184c01cd26a39345f70477590a871bd9ed14cb0a3191e856286279403e608c4
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_will_attend(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): 'test for get_info_for_course for course with enrolled run that will happen in the future' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.WILL_ATTEND, self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_called_once_with(self.course_run, api.CourseStatus.WILL_ATTEND, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course for course with enrolled run that will happen in the future
dashboard/api_test.py
test_info_will_attend
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_will_attend(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.WILL_ATTEND, self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_called_once_with(self.course_run, api.CourseStatus.WILL_ATTEND, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_will_attend(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.WILL_ATTEND, self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_called_once_with(self.course_run, api.CourseStatus.WILL_ATTEND, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course for course with enrolled run that will happen in the future<|endoftext|>
eb48aae166110f87b924d880a00dc5b5c6883f5985f4e8c7caae1ec4d39c2f46
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_upgrade(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): 'test for get_info_for_course for course with a run that needs to be upgraded' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CAN_UPGRADE, self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_called_once_with(self.course_run, api.CourseStatus.CAN_UPGRADE, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course for course with a run that needs to be upgraded
dashboard/api_test.py
test_info_upgrade
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_upgrade(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CAN_UPGRADE, self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_called_once_with(self.course_run, api.CourseStatus.CAN_UPGRADE, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_upgrade(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CAN_UPGRADE, self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_called_once_with(self.course_run, api.CourseStatus.CAN_UPGRADE, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course for course with a run that needs to be upgraded<|endoftext|>
919e7c78562f9097d4863e992653ea81d4037231486be9963a82341b5fefcff5
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_upgrade_in_past(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course for course with a run\n that needs to be upgraded but before a current enrolled one\n ' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CURRENTLY_ENROLLED, self.course_run, api.CourseRunStatus.CAN_UPGRADE)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.CURRENTLY_ENROLLED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.CAN_UPGRADE, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course for course with a run that needs to be upgraded but before a current enrolled one
dashboard/api_test.py
test_info_upgrade_in_past
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_upgrade_in_past(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course for course with a run\n that needs to be upgraded but before a current enrolled one\n ' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CURRENTLY_ENROLLED, self.course_run, api.CourseRunStatus.CAN_UPGRADE)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.CURRENTLY_ENROLLED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.CAN_UPGRADE, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_upgrade_in_past(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course for course with a run\n that needs to be upgraded but before a current enrolled one\n ' self.mmtrack.configure_mock(**{'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.CURRENTLY_ENROLLED, self.course_run, api.CourseRunStatus.CAN_UPGRADE)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) mock_format.assert_any_call(self.course_run, api.CourseStatus.CURRENTLY_ENROLLED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_ver, api.CourseStatus.CAN_UPGRADE, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course for course with a run that needs to be upgraded but before a current enrolled one<|endoftext|>
1ff7c11d169b0f82c38d9ad09f256a4d789a1d886cdc361e177c602c33756e38
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_default_should_not_happen(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course for course with a run with an\n unexpected state but that can be offered\n ' with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func('status-that-we-should-never-have', self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) assert (mock_format.call_count == 0) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course for course with a run with an unexpected state but that can be offered
dashboard/api_test.py
test_info_default_should_not_happen
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_default_should_not_happen(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course for course with a run with an\n unexpected state but that can be offered\n ' with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func('status-that-we-should-never-have', self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) assert (mock_format.call_count == 0) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_default_should_not_happen(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course for course with a run with an\n unexpected state but that can be offered\n ' with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func('status-that-we-should-never-have', self.course_run, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course, api.get_info_for_course(self.course, self.mmtrack)) assert (mock_format.call_count == 0) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course for course with a run with an unexpected state but that can be offered<|endoftext|>
19352cae084dfb3c83b1bd2ee4d828866df1a11695abdf0e7db6f8f959c33def
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_default_should_not_happen_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): 'test for get_info_for_course with no next and weird status' with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func('status-that-we-should-never-have', self.course_run_past, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) assert (mock_format.call_count == 0) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course with no next and weird status
dashboard/api_test.py
test_info_default_should_not_happen_no_next
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_default_should_not_happen_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func('status-that-we-should-never-have', self.course_run_past, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) assert (mock_format.call_count == 0) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_default_should_not_happen_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func('status-that-we-should-never-have', self.course_run_past, api.CourseRunStatus.NOT_ENROLLED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) assert (mock_format.call_count == 0) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course with no next and weird status<|endoftext|>
b9160d01208b159dff6239ccb8ea0e29ca41545ffa8479e3014f005ed85a4b65
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_read_cert_for_all_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n test for get_info_for_course in case the less recent course is flagged to be checked if passed\n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': True, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_PASSED, self.course_run_past, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) mock_format.assert_any_call(self.course_run_past, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_past_ver, api.CourseStatus.PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
test for get_info_for_course in case the less recent course is flagged to be checked if passed
dashboard/api_test.py
test_info_read_cert_for_all_no_next
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_read_cert_for_all_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': True, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_PASSED, self.course_run_past, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) mock_format.assert_any_call(self.course_run_past, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_past_ver, api.CourseStatus.PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_info_read_cert_for_all_no_next(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' self.mmtrack.configure_mock(**{'has_passed_course.return_value': True, 'is_enrolled_mmtrack.return_value': True}) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=self.get_mock_run_status_func(api.CourseRunStatus.NOT_PASSED, self.course_run_past, api.CourseRunStatus.CHECK_IF_PASSED)): self.assert_course_equal(self.course_no_next_run, api.get_info_for_course(self.course_no_next_run, self.mmtrack)) mock_format.assert_any_call(self.course_run_past, api.CourseStatus.NOT_PASSED, self.mmtrack, position=1) mock_format.assert_any_call(self.course_run_past_ver, api.CourseStatus.PASSED, self.mmtrack, position=2) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>test for get_info_for_course in case the less recent course is flagged to be checked if passed<|endoftext|>
0dba9b99732221bcf27b2a02ac6148decb323da23512d1540bd249df216920dc
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_course_run_end_date_mixed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n Test with a mix of end_date being None and also a valid date\n ' def mocked_get_status_for_courserun(run, enrollments): 'Mock get_status_for_courserun with different values for each run' return api.CourseRunUserStatus(status=api.CourseRunStatus.NOT_ENROLLED, course_run=run) self.mmtrack.configure_mock(**{'user': self.user, 'is_enrolled_mmtrack.return_value': True}) run1 = CourseRunFactory.create(start_date=now_in_utc(), end_date=None, enrollment_start=None, enrollment_end=None) CourseRunFactory.create(start_date=now_in_utc(), end_date=now_in_utc(), enrollment_start=None, enrollment_end=None, course=run1.course) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=mocked_get_status_for_courserun): self.assert_course_equal(run1.course, api.get_info_for_course(run1.course, self.mmtrack)) mock_format.assert_called_once_with(run1, api.CourseStatus.OFFERED, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
Test with a mix of end_date being None and also a valid date
dashboard/api_test.py
test_course_run_end_date_mixed
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_course_run_end_date_mixed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' def mocked_get_status_for_courserun(run, enrollments): 'Mock get_status_for_courserun with different values for each run' return api.CourseRunUserStatus(status=api.CourseRunStatus.NOT_ENROLLED, course_run=run) self.mmtrack.configure_mock(**{'user': self.user, 'is_enrolled_mmtrack.return_value': True}) run1 = CourseRunFactory.create(start_date=now_in_utc(), end_date=None, enrollment_start=None, enrollment_end=None) CourseRunFactory.create(start_date=now_in_utc(), end_date=now_in_utc(), enrollment_start=None, enrollment_end=None, course=run1.course) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=mocked_get_status_for_courserun): self.assert_course_equal(run1.course, api.get_info_for_course(run1.course, self.mmtrack)) mock_format.assert_called_once_with(run1, api.CourseStatus.OFFERED, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_course_run_end_date_mixed(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' def mocked_get_status_for_courserun(run, enrollments): 'Mock get_status_for_courserun with different values for each run' return api.CourseRunUserStatus(status=api.CourseRunStatus.NOT_ENROLLED, course_run=run) self.mmtrack.configure_mock(**{'user': self.user, 'is_enrolled_mmtrack.return_value': True}) run1 = CourseRunFactory.create(start_date=now_in_utc(), end_date=None, enrollment_start=None, enrollment_end=None) CourseRunFactory.create(start_date=now_in_utc(), end_date=now_in_utc(), enrollment_start=None, enrollment_end=None, course=run1.course) with patch('dashboard.api.get_status_for_courserun', autospec=True, side_effect=mocked_get_status_for_courserun): self.assert_course_equal(run1.course, api.get_info_for_course(run1.course, self.mmtrack)) mock_format.assert_called_once_with(run1, api.CourseStatus.OFFERED, self.mmtrack, position=1) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1)<|docstring|>Test with a mix of end_date being None and also a valid date<|endoftext|>
8dd888722e9eee59c5ef4da85a11e013c73ac791531b00144f7f4bab8d4d7a0a
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_course_with_proctorate_exam(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n Test with proctorate exam results\n ' for _ in range(3): ProctoredExamGradeFactory.create(user=self.user, course=self.course_noruns) proct_exam_qset = ProctoredExamGrade.for_user_course(user=self.user, course=self.course_noruns) serialized_proct_exams = ProctoredExamGradeSerializer(proct_exam_qset, many=True).data self.mmtrack.get_course_proctorate_exam_results.return_value = serialized_proct_exams self.assert_course_equal(self.course_noruns, api.get_info_for_course(self.course_noruns, self.mmtrack), proct_exams=serialized_proct_exams) assert (mock_format.called is False) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1) self.mmtrack.get_course_proctorate_exam_results.assert_called_once_with(self.course_noruns)
Test with proctorate exam results
dashboard/api_test.py
test_course_with_proctorate_exam
mitodl/micromasters
32
python
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_course_with_proctorate_exam(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' for _ in range(3): ProctoredExamGradeFactory.create(user=self.user, course=self.course_noruns) proct_exam_qset = ProctoredExamGrade.for_user_course(user=self.user, course=self.course_noruns) serialized_proct_exams = ProctoredExamGradeSerializer(proct_exam_qset, many=True).data self.mmtrack.get_course_proctorate_exam_results.return_value = serialized_proct_exams self.assert_course_equal(self.course_noruns, api.get_info_for_course(self.course_noruns, self.mmtrack), proct_exams=serialized_proct_exams) assert (mock_format.called is False) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1) self.mmtrack.get_course_proctorate_exam_results.assert_called_once_with(self.course_noruns)
@patch('dashboard.api.format_courserun_for_dashboard', autospec=True) @patch('dashboard.api.is_exam_schedulable', return_value=False) def test_course_with_proctorate_exam(self, mock_schedulable, mock_format, mock_get_cert, mock_future_exams, mock_has_to_pay, mock_exam_url): '\n \n ' for _ in range(3): ProctoredExamGradeFactory.create(user=self.user, course=self.course_noruns) proct_exam_qset = ProctoredExamGrade.for_user_course(user=self.user, course=self.course_noruns) serialized_proct_exams = ProctoredExamGradeSerializer(proct_exam_qset, many=True).data self.mmtrack.get_course_proctorate_exam_results.return_value = serialized_proct_exams self.assert_course_equal(self.course_noruns, api.get_info_for_course(self.course_noruns, self.mmtrack), proct_exams=serialized_proct_exams) assert (mock_format.called is False) assert (mock_schedulable.call_count == 1) assert (mock_has_to_pay.call_count == 1) assert (mock_future_exams.call_count == 1) assert (mock_get_cert.call_count == 1) assert (mock_exam_url.call_count == 1) self.mmtrack.get_course_proctorate_exam_results.assert_called_once_with(self.course_noruns)<|docstring|>Test with proctorate exam results<|endoftext|>
acb420db35e9f8dd578efd2e020f9cb46339c932aed4f60b540002f62e1598a8
@ddt.data([[True], [False]]) @patch('backends.edxorg.EdxOrgOAuth2.refresh_token', return_value=social_extra_data, autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_format(self, update_cache, mock_cache_refresh, mock_refresh_token): 'Test that get_user_program_info fetches edx data and returns a list of Program data' result = api.get_user_program_info(self.user) assert (mock_refresh_token.call_count == (1 if update_cache else 0)) assert (mock_cache_refresh.call_count == (len(CachedEdxDataApi.EDX_SUPPORTED_CACHES) if update_cache else 0)) assert isinstance(result, dict) assert ('is_edx_data_fresh' in result) assert (result['is_edx_data_fresh'] is False) assert ('programs' in result) assert (len(result['programs']) == 2) for i in range(2): expected = {'id': self.expected_programs[i].id, 'description': self.expected_programs[i].description, 'title': self.expected_programs[i].title, 'financial_aid_availability': self.expected_programs[i].financial_aid_availability} assert is_subset_dict(expected, result['programs'][i])
Test that get_user_program_info fetches edx data and returns a list of Program data
dashboard/api_test.py
test_format
mitodl/micromasters
32
python
@ddt.data([[True], [False]]) @patch('backends.edxorg.EdxOrgOAuth2.refresh_token', return_value=social_extra_data, autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_format(self, update_cache, mock_cache_refresh, mock_refresh_token): result = api.get_user_program_info(self.user) assert (mock_refresh_token.call_count == (1 if update_cache else 0)) assert (mock_cache_refresh.call_count == (len(CachedEdxDataApi.EDX_SUPPORTED_CACHES) if update_cache else 0)) assert isinstance(result, dict) assert ('is_edx_data_fresh' in result) assert (result['is_edx_data_fresh'] is False) assert ('programs' in result) assert (len(result['programs']) == 2) for i in range(2): expected = {'id': self.expected_programs[i].id, 'description': self.expected_programs[i].description, 'title': self.expected_programs[i].title, 'financial_aid_availability': self.expected_programs[i].financial_aid_availability} assert is_subset_dict(expected, result['programs'][i])
@ddt.data([[True], [False]]) @patch('backends.edxorg.EdxOrgOAuth2.refresh_token', return_value=social_extra_data, autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_format(self, update_cache, mock_cache_refresh, mock_refresh_token): result = api.get_user_program_info(self.user) assert (mock_refresh_token.call_count == (1 if update_cache else 0)) assert (mock_cache_refresh.call_count == (len(CachedEdxDataApi.EDX_SUPPORTED_CACHES) if update_cache else 0)) assert isinstance(result, dict) assert ('is_edx_data_fresh' in result) assert (result['is_edx_data_fresh'] is False) assert ('programs' in result) assert (len(result['programs']) == 2) for i in range(2): expected = {'id': self.expected_programs[i].id, 'description': self.expected_programs[i].description, 'title': self.expected_programs[i].title, 'financial_aid_availability': self.expected_programs[i].financial_aid_availability} assert is_subset_dict(expected, result['programs'][i])<|docstring|>Test that get_user_program_info fetches edx data and returns a list of Program data<|endoftext|>
b31345c80724905adf389f58dbbca66e366ab6580039bacf5d5b7f35f35097a7
@patch('backends.utils.refresh_user_token', autospec=True) def test_past_course_runs(self, mock_refresh): 'Test that past course runs are returned in the API results' now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() failed_course_run = course.courserun_set.first() failed_course_run.end_date = (now - timedelta(days=1)) failed_course_run.upgrade_deadline = (now - timedelta(days=1)) failed_course_run.save() CachedEnrollmentFactory.create(user=self.user, course_run=failed_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=failed_course_run) FinalGrade.objects.create(user=self.user, course_run=failed_course_run, grade=0.1, passed=False, status=FinalGradeStatus.COMPLETE, course_run_paid_on_edx=True) CourseRunGradingStatus.objects.create(course_run=failed_course_run, status=FinalGradeStatus.COMPLETE) previous_failed_course_run = CourseRunFactory.create(course=course, end_date=(failed_course_run.end_date - timedelta(days=30)), upgrade_deadline=(failed_course_run.upgrade_deadline - timedelta(days=30))) CachedEnrollmentFactory.create(user=self.user, course_run=previous_failed_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=previous_failed_course_run) FinalGrade.objects.create(user=self.user, course_run=previous_failed_course_run, grade=0.1, passed=False, status=FinalGradeStatus.COMPLETE, course_run_paid_on_edx=True) CourseRunGradingStatus.objects.create(course_run=previous_failed_course_run, status=FinalGradeStatus.COMPLETE) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 2) assert all([(run['status'] == api.CourseStatus.NOT_PASSED) for run in result['programs'][0]['courses'][0]['runs']])
Test that past course runs are returned in the API results
dashboard/api_test.py
test_past_course_runs
mitodl/micromasters
32
python
@patch('backends.utils.refresh_user_token', autospec=True) def test_past_course_runs(self, mock_refresh): now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() failed_course_run = course.courserun_set.first() failed_course_run.end_date = (now - timedelta(days=1)) failed_course_run.upgrade_deadline = (now - timedelta(days=1)) failed_course_run.save() CachedEnrollmentFactory.create(user=self.user, course_run=failed_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=failed_course_run) FinalGrade.objects.create(user=self.user, course_run=failed_course_run, grade=0.1, passed=False, status=FinalGradeStatus.COMPLETE, course_run_paid_on_edx=True) CourseRunGradingStatus.objects.create(course_run=failed_course_run, status=FinalGradeStatus.COMPLETE) previous_failed_course_run = CourseRunFactory.create(course=course, end_date=(failed_course_run.end_date - timedelta(days=30)), upgrade_deadline=(failed_course_run.upgrade_deadline - timedelta(days=30))) CachedEnrollmentFactory.create(user=self.user, course_run=previous_failed_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=previous_failed_course_run) FinalGrade.objects.create(user=self.user, course_run=previous_failed_course_run, grade=0.1, passed=False, status=FinalGradeStatus.COMPLETE, course_run_paid_on_edx=True) CourseRunGradingStatus.objects.create(course_run=previous_failed_course_run, status=FinalGradeStatus.COMPLETE) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 2) assert all([(run['status'] == api.CourseStatus.NOT_PASSED) for run in result['programs'][0]['courses'][0]['runs']])
@patch('backends.utils.refresh_user_token', autospec=True) def test_past_course_runs(self, mock_refresh): now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() failed_course_run = course.courserun_set.first() failed_course_run.end_date = (now - timedelta(days=1)) failed_course_run.upgrade_deadline = (now - timedelta(days=1)) failed_course_run.save() CachedEnrollmentFactory.create(user=self.user, course_run=failed_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=failed_course_run) FinalGrade.objects.create(user=self.user, course_run=failed_course_run, grade=0.1, passed=False, status=FinalGradeStatus.COMPLETE, course_run_paid_on_edx=True) CourseRunGradingStatus.objects.create(course_run=failed_course_run, status=FinalGradeStatus.COMPLETE) previous_failed_course_run = CourseRunFactory.create(course=course, end_date=(failed_course_run.end_date - timedelta(days=30)), upgrade_deadline=(failed_course_run.upgrade_deadline - timedelta(days=30))) CachedEnrollmentFactory.create(user=self.user, course_run=previous_failed_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=previous_failed_course_run) FinalGrade.objects.create(user=self.user, course_run=previous_failed_course_run, grade=0.1, passed=False, status=FinalGradeStatus.COMPLETE, course_run_paid_on_edx=True) CourseRunGradingStatus.objects.create(course_run=previous_failed_course_run, status=FinalGradeStatus.COMPLETE) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 2) assert all([(run['status'] == api.CourseStatus.NOT_PASSED) for run in result['programs'][0]['courses'][0]['runs']])<|docstring|>Test that past course runs are returned in the API results<|endoftext|>
ae46c053528a07b111834baf1c753c58b5172a18881188b7d28b9277f9b877b2
@patch('backends.utils.refresh_user_token', autospec=True) def test_current_run_first(self, mock_refresh): 'Test that current course runs is on top of returned in the API results' now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() current_run.end_date = (now + timedelta(weeks=1)) current_run.upgrade_deadline = (now + timedelta(days=1)) current_run.save() CachedEnrollmentFactory.create(user=self.user, course_run=current_run) CachedCurrentGradeFactory.create(user=self.user, course_run=current_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=current_run.edx_course_key) future_course_run = CourseRunFactory.create(course=course, start_date=(now + timedelta(weeks=2)), end_date=(now + timedelta(weeks=20)), upgrade_deadline=(current_run.upgrade_deadline + timedelta(weeks=6))) CachedEnrollmentFactory.create(user=self.user, course_run=future_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=future_course_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=future_course_run.edx_course_key) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 2) assert (result['programs'][0]['courses'][0]['runs'][0]['status'] == api.CourseRunStatus.CURRENTLY_ENROLLED)
Test that current course runs is on top of returned in the API results
dashboard/api_test.py
test_current_run_first
mitodl/micromasters
32
python
@patch('backends.utils.refresh_user_token', autospec=True) def test_current_run_first(self, mock_refresh): now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() current_run.end_date = (now + timedelta(weeks=1)) current_run.upgrade_deadline = (now + timedelta(days=1)) current_run.save() CachedEnrollmentFactory.create(user=self.user, course_run=current_run) CachedCurrentGradeFactory.create(user=self.user, course_run=current_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=current_run.edx_course_key) future_course_run = CourseRunFactory.create(course=course, start_date=(now + timedelta(weeks=2)), end_date=(now + timedelta(weeks=20)), upgrade_deadline=(current_run.upgrade_deadline + timedelta(weeks=6))) CachedEnrollmentFactory.create(user=self.user, course_run=future_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=future_course_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=future_course_run.edx_course_key) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 2) assert (result['programs'][0]['courses'][0]['runs'][0]['status'] == api.CourseRunStatus.CURRENTLY_ENROLLED)
@patch('backends.utils.refresh_user_token', autospec=True) def test_current_run_first(self, mock_refresh): now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() current_run.end_date = (now + timedelta(weeks=1)) current_run.upgrade_deadline = (now + timedelta(days=1)) current_run.save() CachedEnrollmentFactory.create(user=self.user, course_run=current_run) CachedCurrentGradeFactory.create(user=self.user, course_run=current_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=current_run.edx_course_key) future_course_run = CourseRunFactory.create(course=course, start_date=(now + timedelta(weeks=2)), end_date=(now + timedelta(weeks=20)), upgrade_deadline=(current_run.upgrade_deadline + timedelta(weeks=6))) CachedEnrollmentFactory.create(user=self.user, course_run=future_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=future_course_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=future_course_run.edx_course_key) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 2) assert (result['programs'][0]['courses'][0]['runs'][0]['status'] == api.CourseRunStatus.CURRENTLY_ENROLLED)<|docstring|>Test that current course runs is on top of returned in the API results<|endoftext|>
d145f07ee27929e0bc6da51fae2cf9e84daac5d50674a40d87a828344ba70526
@patch('backends.utils.refresh_user_token', autospec=True) def test_when_enroll_in_only_future_run(self, mock_refresh): 'Test that user in enrolled in future run but not enrolled in current course runs' now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() current_run.end_date = (now + timedelta(weeks=1)) current_run.upgrade_deadline = (now + timedelta(days=1)) current_run.save() future_course_run = CourseRunFactory.create(course=course, start_date=(now + timedelta(weeks=2)), end_date=(now + timedelta(weeks=20)), upgrade_deadline=(current_run.upgrade_deadline + timedelta(weeks=6))) CachedEnrollmentFactory.create(user=self.user, course_run=future_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=future_course_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=future_course_run.edx_course_key) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 1) assert (result['programs'][0]['courses'][0]['runs'][0]['status'] == api.CourseRunStatus.WILL_ATTEND)
Test that user in enrolled in future run but not enrolled in current course runs
dashboard/api_test.py
test_when_enroll_in_only_future_run
mitodl/micromasters
32
python
@patch('backends.utils.refresh_user_token', autospec=True) def test_when_enroll_in_only_future_run(self, mock_refresh): now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() current_run.end_date = (now + timedelta(weeks=1)) current_run.upgrade_deadline = (now + timedelta(days=1)) current_run.save() future_course_run = CourseRunFactory.create(course=course, start_date=(now + timedelta(weeks=2)), end_date=(now + timedelta(weeks=20)), upgrade_deadline=(current_run.upgrade_deadline + timedelta(weeks=6))) CachedEnrollmentFactory.create(user=self.user, course_run=future_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=future_course_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=future_course_run.edx_course_key) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 1) assert (result['programs'][0]['courses'][0]['runs'][0]['status'] == api.CourseRunStatus.WILL_ATTEND)
@patch('backends.utils.refresh_user_token', autospec=True) def test_when_enroll_in_only_future_run(self, mock_refresh): now = now_in_utc() program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() current_run.end_date = (now + timedelta(weeks=1)) current_run.upgrade_deadline = (now + timedelta(days=1)) current_run.save() future_course_run = CourseRunFactory.create(course=course, start_date=(now + timedelta(weeks=2)), end_date=(now + timedelta(weeks=20)), upgrade_deadline=(current_run.upgrade_deadline + timedelta(weeks=6))) CachedEnrollmentFactory.create(user=self.user, course_run=future_course_run) CachedCurrentGradeFactory.create(user=self.user, course_run=future_course_run) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=future_course_run.edx_course_key) UserCacheRefreshTimeFactory.create(user=self.user, unexpired=True) result = api.get_user_program_info(self.user) program_result = None for res in result['programs']: if (res['id'] == program.pk): program_result = res break assert (program_result is not None) assert (len(result['programs']) > 0) assert (len(result['programs'][0]['courses']) > 0) assert (len(result['programs'][0]['courses'][0]['runs']) == 1) assert (result['programs'][0]['courses'][0]['runs'][0]['status'] == api.CourseRunStatus.WILL_ATTEND)<|docstring|>Test that user in enrolled in future run but not enrolled in current course runs<|endoftext|>
8b674e23b4b4fa1891b47136f68af0a7fa341f23e00349b449cbc05683cb30f9
@patch('backends.utils.refresh_user_token', autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_exception_in_refresh_cache_2(self, mock_cache_refresh, mock_token_refresh): 'Test in case the backend refresh cache raises any other exception' mock_cache_refresh.side_effect = ZeroDivisionError result = api.get_user_program_info(self.user) assert (mock_token_refresh.call_count == 1) assert isinstance(result, dict) assert ('is_edx_data_fresh' in result) assert (result['is_edx_data_fresh'] is False) assert ('programs' in result) assert (len(result['programs']) == 2)
Test in case the backend refresh cache raises any other exception
dashboard/api_test.py
test_exception_in_refresh_cache_2
mitodl/micromasters
32
python
@patch('backends.utils.refresh_user_token', autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_exception_in_refresh_cache_2(self, mock_cache_refresh, mock_token_refresh): mock_cache_refresh.side_effect = ZeroDivisionError result = api.get_user_program_info(self.user) assert (mock_token_refresh.call_count == 1) assert isinstance(result, dict) assert ('is_edx_data_fresh' in result) assert (result['is_edx_data_fresh'] is False) assert ('programs' in result) assert (len(result['programs']) == 2)
@patch('backends.utils.refresh_user_token', autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_exception_in_refresh_cache_2(self, mock_cache_refresh, mock_token_refresh): mock_cache_refresh.side_effect = ZeroDivisionError result = api.get_user_program_info(self.user) assert (mock_token_refresh.call_count == 1) assert isinstance(result, dict) assert ('is_edx_data_fresh' in result) assert (result['is_edx_data_fresh'] is False) assert ('programs' in result) assert (len(result['programs']) == 2)<|docstring|>Test in case the backend refresh cache raises any other exception<|endoftext|>
1ee26cbd5d1c13b7d0a0085ef8a4d0df653193d30ae6e9031d64bdefc10e31a7
@patch('backends.utils.refresh_user_token', autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_returns_courseruns_for_different_backends(self, mock_cache_refresh, mock_token_refresh): 'Test that user in enrolled in future run but not enrolled in current course runs' UserSocialAuthFactory.create(user=self.user, provider=BACKEND_MITX_ONLINE) course_run_mitxonline = CourseRunFactory.create(course__program=self.program_fin_aid) set_course_run_current(course_run_mitxonline) program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() set_course_run_current(current_run) CachedEnrollmentFactory.create(user=self.user, course_run=current_run) CachedCurrentGradeFactory.create(user=self.user, course_run=current_run) add_paid_order_for_course(self.user, current_run) result = api.get_user_program_info(self.user) assert (mock_token_refresh.call_count == 2) assert (mock_cache_refresh.call_count == len(CachedEdxDataApi.ALL_CACHE_TYPES)) assert (len(result['programs']) == 2) for program_result in result['programs']: assert (program_result is not None) assert (len(program_result['courses'][0]['runs']) == 1)
Test that user in enrolled in future run but not enrolled in current course runs
dashboard/api_test.py
test_returns_courseruns_for_different_backends
mitodl/micromasters
32
python
@patch('backends.utils.refresh_user_token', autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_returns_courseruns_for_different_backends(self, mock_cache_refresh, mock_token_refresh): UserSocialAuthFactory.create(user=self.user, provider=BACKEND_MITX_ONLINE) course_run_mitxonline = CourseRunFactory.create(course__program=self.program_fin_aid) set_course_run_current(course_run_mitxonline) program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() set_course_run_current(current_run) CachedEnrollmentFactory.create(user=self.user, course_run=current_run) CachedCurrentGradeFactory.create(user=self.user, course_run=current_run) add_paid_order_for_course(self.user, current_run) result = api.get_user_program_info(self.user) assert (mock_token_refresh.call_count == 2) assert (mock_cache_refresh.call_count == len(CachedEdxDataApi.ALL_CACHE_TYPES)) assert (len(result['programs']) == 2) for program_result in result['programs']: assert (program_result is not None) assert (len(program_result['courses'][0]['runs']) == 1)
@patch('backends.utils.refresh_user_token', autospec=True) @patch('dashboard.api_edx_cache.CachedEdxDataApi.update_cache_if_expired', new_callable=MagicMock) def test_returns_courseruns_for_different_backends(self, mock_cache_refresh, mock_token_refresh): UserSocialAuthFactory.create(user=self.user, provider=BACKEND_MITX_ONLINE) course_run_mitxonline = CourseRunFactory.create(course__program=self.program_fin_aid) set_course_run_current(course_run_mitxonline) program = self.program_non_fin_aid course = program.course_set.first() current_run = course.courserun_set.first() set_course_run_current(current_run) CachedEnrollmentFactory.create(user=self.user, course_run=current_run) CachedCurrentGradeFactory.create(user=self.user, course_run=current_run) add_paid_order_for_course(self.user, current_run) result = api.get_user_program_info(self.user) assert (mock_token_refresh.call_count == 2) assert (mock_cache_refresh.call_count == len(CachedEdxDataApi.ALL_CACHE_TYPES)) assert (len(result['programs']) == 2) for program_result in result['programs']: assert (program_result is not None) assert (len(program_result['courses'][0]['runs']) == 1)<|docstring|>Test that user in enrolled in future run but not enrolled in current course runs<|endoftext|>
b113a53896ba90df377263b8e861dc52b859f4ac5a719bccc8c8b34d2363f64b
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program(self, mock_info_course): 'Test happy path' self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': '', 'get_program_letter_url.return_value': '', 'get_number_of_passed_courses_for_completion.return_value': 0}) mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': 3, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': ''} self.assertEqual(res, expected_data)
Test happy path
dashboard/api_test.py
test_program
mitodl/micromasters
32
python
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program(self, mock_info_course): self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': 3, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': } self.assertEqual(res, expected_data)
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program(self, mock_info_course): self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': 3, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': } self.assertEqual(res, expected_data)<|docstring|>Test happy path<|endoftext|>
64bbe5c2f06e34eab3f65a7058b472c73ef511fd2d4906b80cc948772b5af0f8
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_with_electives(self, mock_info_course): 'Test happy path' self.program.num_required_courses = 5 self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': '', 'get_program_letter_url.return_value': '', 'get_number_of_passed_courses_for_completion.return_value': 0}) mock_info_course.return_value = {'position_in_program': 1} electives_set = ElectivesSet.objects.create(program=self.program, required_number=2) for num in range(3): course = CourseFactory.create(title='title course prog1 {}'.format(num), program=self.program) ElectiveCourse.objects.create(course=course, electives_set=electives_set) res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': 5, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': ''} self.assertEqual(res, expected_data)
Test happy path
dashboard/api_test.py
test_program_with_electives
mitodl/micromasters
32
python
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_with_electives(self, mock_info_course): self.program.num_required_courses = 5 self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) mock_info_course.return_value = {'position_in_program': 1} electives_set = ElectivesSet.objects.create(program=self.program, required_number=2) for num in range(3): course = CourseFactory.create(title='title course prog1 {}'.format(num), program=self.program) ElectiveCourse.objects.create(course=course, electives_set=electives_set) res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': 5, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': } self.assertEqual(res, expected_data)
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_with_electives(self, mock_info_course): self.program.num_required_courses = 5 self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) mock_info_course.return_value = {'position_in_program': 1} electives_set = ElectivesSet.objects.create(program=self.program, required_number=2) for num in range(3): course = CourseFactory.create(title='title course prog1 {}'.format(num), program=self.program) ElectiveCourse.objects.create(course=course, electives_set=electives_set) res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': 5, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': } self.assertEqual(res, expected_data)<|docstring|>Test happy path<|endoftext|>
7734e13572d859d42c994cd27a094bb96b5a963d7aaed911ae8f5dcd56df0a5a
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_no_courses(self, mock_info_course): 'Test program with no courses' self.mmtrack.configure_mock(**{'program': self.program_no_courses, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_INVALID, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': '', 'get_program_letter_url.return_value': '', 'get_number_of_passed_courses_for_completion.return_value': 0}) res = api.get_info_for_program(self.mmtrack) assert (mock_info_course.called is False) expected_data = {'id': self.program_no_courses.pk, 'description': self.program_no_courses.description, 'title': self.program_no_courses.title, 'courses': [], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_INVALID, 'number_courses_required': 0, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': ''} self.assertEqual(res, expected_data)
Test program with no courses
dashboard/api_test.py
test_program_no_courses
mitodl/micromasters
32
python
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_no_courses(self, mock_info_course): self.mmtrack.configure_mock(**{'program': self.program_no_courses, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_INVALID, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) res = api.get_info_for_program(self.mmtrack) assert (mock_info_course.called is False) expected_data = {'id': self.program_no_courses.pk, 'description': self.program_no_courses.description, 'title': self.program_no_courses.title, 'courses': [], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_INVALID, 'number_courses_required': 0, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': } self.assertEqual(res, expected_data)
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_no_courses(self, mock_info_course): self.mmtrack.configure_mock(**{'program': self.program_no_courses, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_INVALID, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) res = api.get_info_for_program(self.mmtrack) assert (mock_info_course.called is False) expected_data = {'id': self.program_no_courses.pk, 'description': self.program_no_courses.description, 'title': self.program_no_courses.title, 'courses': [], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_INVALID, 'number_courses_required': 0, 'number_courses_passed': 0, 'grade_average': 91, 'certificate': } self.assertEqual(res, expected_data)<|docstring|>Test program with no courses<|endoftext|>
fc003d691cf8df32272b89dc0aa71f76fa8405b7de45dd7807fc716cb824b539
@patch('dashboard.api.get_info_for_course', autospec=True) @patch('financialaid.serializers.FinancialAidDashboardSerializer.serialize', new_callable=MagicMock) def test_program_financial_aid(self, mock_fin_aid_serialize, mock_info_course): 'Test happy path' self.mmtrack.configure_mock(**{'program': self.program, 'get_exam_card_status.return_value': ExamProfile.PROFILE_IN_PROGRESS, 'calculate_final_grade_average.return_value': 91, 'financial_aid_available': True, 'get_program_certificate_url.return_value': '', 'get_program_enrollment.return_value': self.program_enrollment, 'get_program_letter_url.return_value': '', 'get_number_of_passed_courses_for_completion.return_value': 0}) serialized_fin_aid = {'id': 123, 'has_user_applied': True, 'application_status': 'WHO-KNOWS', 'min_possible_cost': 100, 'max_possible_cost': 200, 'date_documents_sent': (now_in_utc() - timedelta(hours=12))} mock_fin_aid_serialize.return_value = serialized_fin_aid mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': True, 'financial_aid_user_info': serialized_fin_aid, 'exam_card_status': ExamProfile.PROFILE_IN_PROGRESS, 'number_courses_required': self.program.course_set.count(), 'number_courses_passed': 0, 'grade_average': 91, 'certificate': '', 'grade_records_url': reverse('grade_records', args=[self.program_enrollment.id])} self.assertEqual(res, expected_data)
Test happy path
dashboard/api_test.py
test_program_financial_aid
mitodl/micromasters
32
python
@patch('dashboard.api.get_info_for_course', autospec=True) @patch('financialaid.serializers.FinancialAidDashboardSerializer.serialize', new_callable=MagicMock) def test_program_financial_aid(self, mock_fin_aid_serialize, mock_info_course): self.mmtrack.configure_mock(**{'program': self.program, 'get_exam_card_status.return_value': ExamProfile.PROFILE_IN_PROGRESS, 'calculate_final_grade_average.return_value': 91, 'financial_aid_available': True, 'get_program_certificate_url.return_value': , 'get_program_enrollment.return_value': self.program_enrollment, 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) serialized_fin_aid = {'id': 123, 'has_user_applied': True, 'application_status': 'WHO-KNOWS', 'min_possible_cost': 100, 'max_possible_cost': 200, 'date_documents_sent': (now_in_utc() - timedelta(hours=12))} mock_fin_aid_serialize.return_value = serialized_fin_aid mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': True, 'financial_aid_user_info': serialized_fin_aid, 'exam_card_status': ExamProfile.PROFILE_IN_PROGRESS, 'number_courses_required': self.program.course_set.count(), 'number_courses_passed': 0, 'grade_average': 91, 'certificate': , 'grade_records_url': reverse('grade_records', args=[self.program_enrollment.id])} self.assertEqual(res, expected_data)
@patch('dashboard.api.get_info_for_course', autospec=True) @patch('financialaid.serializers.FinancialAidDashboardSerializer.serialize', new_callable=MagicMock) def test_program_financial_aid(self, mock_fin_aid_serialize, mock_info_course): self.mmtrack.configure_mock(**{'program': self.program, 'get_exam_card_status.return_value': ExamProfile.PROFILE_IN_PROGRESS, 'calculate_final_grade_average.return_value': 91, 'financial_aid_available': True, 'get_program_certificate_url.return_value': , 'get_program_enrollment.return_value': self.program_enrollment, 'get_program_letter_url.return_value': , 'get_number_of_passed_courses_for_completion.return_value': 0}) serialized_fin_aid = {'id': 123, 'has_user_applied': True, 'application_status': 'WHO-KNOWS', 'min_possible_cost': 100, 'max_possible_cost': 200, 'date_documents_sent': (now_in_utc() - timedelta(hours=12))} mock_fin_aid_serialize.return_value = serialized_fin_aid mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': True, 'financial_aid_user_info': serialized_fin_aid, 'exam_card_status': ExamProfile.PROFILE_IN_PROGRESS, 'number_courses_required': self.program.course_set.count(), 'number_courses_passed': 0, 'grade_average': 91, 'certificate': , 'grade_records_url': reverse('grade_records', args=[self.program_enrollment.id])} self.assertEqual(res, expected_data)<|docstring|>Test happy path<|endoftext|>
9455477bb436b5b64dd4029912ec0f2b8110453147aa16ec93bdbf2282186012
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_for_program_letter(self, mock_info_course): ' Verify that api returns program_letter_url if exists.' self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': '', 'get_program_letter_url.return_value': reverse('program_letter', args=[self.program_letter.uuid]), 'get_number_of_passed_courses_for_completion.return_value': 3}) mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': self.program.course_set.count(), 'number_courses_passed': 3, 'grade_average': 91, 'certificate': '', 'program_letter_url': reverse('program_letter', args=[self.program_letter.uuid])} self.assertEqual(res, expected_data)
Verify that api returns program_letter_url if exists.
dashboard/api_test.py
test_program_for_program_letter
mitodl/micromasters
32
python
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_for_program_letter(self, mock_info_course): ' ' self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': reverse('program_letter', args=[self.program_letter.uuid]), 'get_number_of_passed_courses_for_completion.return_value': 3}) mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': self.program.course_set.count(), 'number_courses_passed': 3, 'grade_average': 91, 'certificate': , 'program_letter_url': reverse('program_letter', args=[self.program_letter.uuid])} self.assertEqual(res, expected_data)
@patch('dashboard.api.get_info_for_course', autospec=True) def test_program_for_program_letter(self, mock_info_course): ' ' self.mmtrack.configure_mock(**{'program': self.program, 'financial_aid_available': False, 'get_exam_card_status.return_value': ExamProfile.PROFILE_SUCCESS, 'calculate_final_grade_average.return_value': 91, 'get_program_certificate_url.return_value': , 'get_program_letter_url.return_value': reverse('program_letter', args=[self.program_letter.uuid]), 'get_number_of_passed_courses_for_completion.return_value': 3}) mock_info_course.return_value = {'position_in_program': 1} res = api.get_info_for_program(self.mmtrack) for course in self.courses: mock_info_course.assert_any_call(course, self.mmtrack) expected_data = {'id': self.program.pk, 'description': self.program.description, 'title': self.program.title, 'courses': [{'position_in_program': 1}, {'position_in_program': 1}, {'position_in_program': 1}], 'financial_aid_availability': False, 'exam_card_status': ExamProfile.PROFILE_SUCCESS, 'number_courses_required': self.program.course_set.count(), 'number_courses_passed': 3, 'grade_average': 91, 'certificate': , 'program_letter_url': reverse('program_letter', args=[self.program_letter.uuid])} self.assertEqual(res, expected_data)<|docstring|>Verify that api returns program_letter_url if exists.<|endoftext|>
c50b4436618c9fe049a3b10e393d742efdcc366156a085dff1602f034a189566
@ddt.data((False, False, False, False, True, False), (False, True, False, False, True, False), (True, False, False, False, True, False), (True, True, False, False, True, False), (False, False, True, False, True, True), (False, False, True, False, False, True), (False, True, True, False, True, True), (True, False, True, False, True, True), (True, True, True, False, True, True), (True, True, True, True, True, False)) @ddt.unpack @pytest.mark.flaky(max_runs=3, min_passes=1) def test_is_exam_schedulable(self, is_past, is_future, has_eligibility_future, is_operation_delete, has_coupon, can_schedule_exam): 'Test that is_exam_schedulable is correct' exam_run = ExamRunFactory.create(scheduling_past=is_past, scheduling_future=is_future, eligibility_past=(not has_eligibility_future), eligibility_future=has_eligibility_future) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=ExamAuthorization.STATUS_SUCCESS, operation=(ExamAuthorization.OPERATION_DELETE if is_operation_delete else ExamAuthorization.OPERATION_ADD)) if has_coupon: coupon = ExamRunCouponFactory.create(course=exam_run.course, coupon_url='http://example.com', is_taken=False) exam_auth.exam_coupon = coupon exam_auth.save() assert (api.is_exam_schedulable(exam_auth.user, exam_auth.course) is can_schedule_exam)
Test that is_exam_schedulable is correct
dashboard/api_test.py
test_is_exam_schedulable
mitodl/micromasters
32
python
@ddt.data((False, False, False, False, True, False), (False, True, False, False, True, False), (True, False, False, False, True, False), (True, True, False, False, True, False), (False, False, True, False, True, True), (False, False, True, False, False, True), (False, True, True, False, True, True), (True, False, True, False, True, True), (True, True, True, False, True, True), (True, True, True, True, True, False)) @ddt.unpack @pytest.mark.flaky(max_runs=3, min_passes=1) def test_is_exam_schedulable(self, is_past, is_future, has_eligibility_future, is_operation_delete, has_coupon, can_schedule_exam): exam_run = ExamRunFactory.create(scheduling_past=is_past, scheduling_future=is_future, eligibility_past=(not has_eligibility_future), eligibility_future=has_eligibility_future) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=ExamAuthorization.STATUS_SUCCESS, operation=(ExamAuthorization.OPERATION_DELETE if is_operation_delete else ExamAuthorization.OPERATION_ADD)) if has_coupon: coupon = ExamRunCouponFactory.create(course=exam_run.course, coupon_url='http://example.com', is_taken=False) exam_auth.exam_coupon = coupon exam_auth.save() assert (api.is_exam_schedulable(exam_auth.user, exam_auth.course) is can_schedule_exam)
@ddt.data((False, False, False, False, True, False), (False, True, False, False, True, False), (True, False, False, False, True, False), (True, True, False, False, True, False), (False, False, True, False, True, True), (False, False, True, False, False, True), (False, True, True, False, True, True), (True, False, True, False, True, True), (True, True, True, False, True, True), (True, True, True, True, True, False)) @ddt.unpack @pytest.mark.flaky(max_runs=3, min_passes=1) def test_is_exam_schedulable(self, is_past, is_future, has_eligibility_future, is_operation_delete, has_coupon, can_schedule_exam): exam_run = ExamRunFactory.create(scheduling_past=is_past, scheduling_future=is_future, eligibility_past=(not has_eligibility_future), eligibility_future=has_eligibility_future) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=ExamAuthorization.STATUS_SUCCESS, operation=(ExamAuthorization.OPERATION_DELETE if is_operation_delete else ExamAuthorization.OPERATION_ADD)) if has_coupon: coupon = ExamRunCouponFactory.create(course=exam_run.course, coupon_url='http://example.com', is_taken=False) exam_auth.exam_coupon = coupon exam_auth.save() assert (api.is_exam_schedulable(exam_auth.user, exam_auth.course) is can_schedule_exam)<|docstring|>Test that is_exam_schedulable is correct<|endoftext|>
be10d7a0a5cbd582e936d1e1f60de6d6ef1090e9c6c38bd239b9a0d1a59f3615
@ddt.data((ExamAuthorization.STATUS_SUCCESS, True, True), (ExamAuthorization.STATUS_FAILED, True, False), (ExamAuthorization.STATUS_SUCCESS, False, False)) @ddt.unpack def test_get_edx_exam_coupon_url(self, auth_status, has_coupon, returned_coupon): '\n Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run\n and their is an available coupon\n ' coupon_url = 'http://example.com' exam_run = ExamRunFactory.create(scheduling_past=False, scheduling_future=False, eligibility_past=False) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=auth_status) if has_coupon: ExamRunCouponFactory.create(course=exam_run.course, coupon_url=coupon_url, is_taken=False) expected = (coupon_url if returned_coupon else '') assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == expected)
Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run and their is an available coupon
dashboard/api_test.py
test_get_edx_exam_coupon_url
mitodl/micromasters
32
python
@ddt.data((ExamAuthorization.STATUS_SUCCESS, True, True), (ExamAuthorization.STATUS_FAILED, True, False), (ExamAuthorization.STATUS_SUCCESS, False, False)) @ddt.unpack def test_get_edx_exam_coupon_url(self, auth_status, has_coupon, returned_coupon): '\n Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run\n and their is an available coupon\n ' coupon_url = 'http://example.com' exam_run = ExamRunFactory.create(scheduling_past=False, scheduling_future=False, eligibility_past=False) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=auth_status) if has_coupon: ExamRunCouponFactory.create(course=exam_run.course, coupon_url=coupon_url, is_taken=False) expected = (coupon_url if returned_coupon else ) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == expected)
@ddt.data((ExamAuthorization.STATUS_SUCCESS, True, True), (ExamAuthorization.STATUS_FAILED, True, False), (ExamAuthorization.STATUS_SUCCESS, False, False)) @ddt.unpack def test_get_edx_exam_coupon_url(self, auth_status, has_coupon, returned_coupon): '\n Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run\n and their is an available coupon\n ' coupon_url = 'http://example.com' exam_run = ExamRunFactory.create(scheduling_past=False, scheduling_future=False, eligibility_past=False) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=auth_status) if has_coupon: ExamRunCouponFactory.create(course=exam_run.course, coupon_url=coupon_url, is_taken=False) expected = (coupon_url if returned_coupon else ) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == expected)<|docstring|>Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run and their is an available coupon<|endoftext|>
0e7e8d4eb02d1a80b220ed1523eb86439a0dc6ec39d3589db68a30f4a30df05c
def test_get_edx_exam_coupon_url_returns_taken_coupon(self): '\n Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run\n and their is an available coupon\n ' coupon_url = 'http://example.com' exam_run = ExamRunFactory.create(scheduling_past=False, scheduling_future=False, eligibility_past=False) ExamRunCouponFactory.create(course=exam_run.course, coupon_url=coupon_url, is_taken=False) ExamRunCouponFactory.create(course=exam_run.course, coupon_url='coupon_2', is_taken=False) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=ExamAuthorization.STATUS_SUCCESS) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == coupon_url) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == coupon_url)
Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run and their is an available coupon
dashboard/api_test.py
test_get_edx_exam_coupon_url_returns_taken_coupon
mitodl/micromasters
32
python
def test_get_edx_exam_coupon_url_returns_taken_coupon(self): '\n Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run\n and their is an available coupon\n ' coupon_url = 'http://example.com' exam_run = ExamRunFactory.create(scheduling_past=False, scheduling_future=False, eligibility_past=False) ExamRunCouponFactory.create(course=exam_run.course, coupon_url=coupon_url, is_taken=False) ExamRunCouponFactory.create(course=exam_run.course, coupon_url='coupon_2', is_taken=False) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=ExamAuthorization.STATUS_SUCCESS) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == coupon_url) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == coupon_url)
def test_get_edx_exam_coupon_url_returns_taken_coupon(self): '\n Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run\n and their is an available coupon\n ' coupon_url = 'http://example.com' exam_run = ExamRunFactory.create(scheduling_past=False, scheduling_future=False, eligibility_past=False) ExamRunCouponFactory.create(course=exam_run.course, coupon_url=coupon_url, is_taken=False) ExamRunCouponFactory.create(course=exam_run.course, coupon_url='coupon_2', is_taken=False) exam_auth = ExamAuthorizationFactory.create(exam_run=exam_run, course=exam_run.course, status=ExamAuthorization.STATUS_SUCCESS) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == coupon_url) assert (api.get_edx_exam_coupon_url(exam_auth.user, exam_auth.course) == coupon_url)<|docstring|>Test that get_edx_exam_coupon_url returns a url only if student is authorized for an current exam run and their is an available coupon<|endoftext|>
b24fd92c00ee72506bf67fbf9261eb7ccb3644c74587a9c2a0052b46a4f5a260
@ddt.data((False, True, 1), (True, False, 0), (False, False, 0)) @ddt.unpack def test_get_future_exam_runs(self, is_past, is_future, result): 'test get_future_exam_runs' exam_run = ExamRunFactory.create(scheduling_past=is_past, scheduling_future=is_future) assert (len(api.get_future_exam_runs(exam_run.course)) == result)
test get_future_exam_runs
dashboard/api_test.py
test_get_future_exam_runs
mitodl/micromasters
32
python
@ddt.data((False, True, 1), (True, False, 0), (False, False, 0)) @ddt.unpack def test_get_future_exam_runs(self, is_past, is_future, result): exam_run = ExamRunFactory.create(scheduling_past=is_past, scheduling_future=is_future) assert (len(api.get_future_exam_runs(exam_run.course)) == result)
@ddt.data((False, True, 1), (True, False, 0), (False, False, 0)) @ddt.unpack def test_get_future_exam_runs(self, is_past, is_future, result): exam_run = ExamRunFactory.create(scheduling_past=is_past, scheduling_future=is_future) assert (len(api.get_future_exam_runs(exam_run.course)) == result)<|docstring|>test get_future_exam_runs<|endoftext|>
e3d8850976ad9867aee57939b48902e00ed65462a1f16505b42b33a81b64bebf
@ddt.data((False, True), (True, True), (False, False)) @ddt.unpack def test_get_current_exam_run_dates(self, eligibility, has_current_exam): 'test get_past_recent_exam_run' exam_run = ExamRunFactory.create(scheduling_past=(not has_current_exam), scheduling_future=False, eligibility_past=False, eligibility_future=eligibility) expected = '' if has_current_exam: expected = '{} and {}'.format(exam_run.date_first_eligible.strftime('%b %-d'), exam_run.date_last_eligible.strftime('%b %-d, %Y')) self.assertEqual(api.get_current_exam_run_dates(exam_run.course), expected)
test get_past_recent_exam_run
dashboard/api_test.py
test_get_current_exam_run_dates
mitodl/micromasters
32
python
@ddt.data((False, True), (True, True), (False, False)) @ddt.unpack def test_get_current_exam_run_dates(self, eligibility, has_current_exam): exam_run = ExamRunFactory.create(scheduling_past=(not has_current_exam), scheduling_future=False, eligibility_past=False, eligibility_future=eligibility) expected = if has_current_exam: expected = '{} and {}'.format(exam_run.date_first_eligible.strftime('%b %-d'), exam_run.date_last_eligible.strftime('%b %-d, %Y')) self.assertEqual(api.get_current_exam_run_dates(exam_run.course), expected)
@ddt.data((False, True), (True, True), (False, False)) @ddt.unpack def test_get_current_exam_run_dates(self, eligibility, has_current_exam): exam_run = ExamRunFactory.create(scheduling_past=(not has_current_exam), scheduling_future=False, eligibility_past=False, eligibility_future=eligibility) expected = if has_current_exam: expected = '{} and {}'.format(exam_run.date_first_eligible.strftime('%b %-d'), exam_run.date_last_eligible.strftime('%b %-d, %Y')) self.assertEqual(api.get_current_exam_run_dates(exam_run.course), expected)<|docstring|>test get_past_recent_exam_run<|endoftext|>
8b6610ec89d14775f4d792592dc7499075ab6ab8af41fad120c420e41ed32d97
@ddt.data((1, 1, False, False), (2, 1, False, True), (3, 1, False, True), (3, 2, False, False), (1, 1, True, False), (2, 1, True, True), (3, 1, True, True), (3, 2, True, False)) @ddt.unpack def test_has_to_pay(self, num_of_taken_exams, num_of_payments, first_date, result): 'Test has_to_pay_for_exam' if first_date: self.mmtrack.program.exam_attempts_first_date = (self.now + timedelta(weeks=2)) self.mmtrack.get_payments_count_for_course.return_value = num_of_payments for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)
Test has_to_pay_for_exam
dashboard/api_test.py
test_has_to_pay
mitodl/micromasters
32
python
@ddt.data((1, 1, False, False), (2, 1, False, True), (3, 1, False, True), (3, 2, False, False), (1, 1, True, False), (2, 1, True, True), (3, 1, True, True), (3, 2, True, False)) @ddt.unpack def test_has_to_pay(self, num_of_taken_exams, num_of_payments, first_date, result): if first_date: self.mmtrack.program.exam_attempts_first_date = (self.now + timedelta(weeks=2)) self.mmtrack.get_payments_count_for_course.return_value = num_of_payments for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)
@ddt.data((1, 1, False, False), (2, 1, False, True), (3, 1, False, True), (3, 2, False, False), (1, 1, True, False), (2, 1, True, True), (3, 1, True, True), (3, 2, True, False)) @ddt.unpack def test_has_to_pay(self, num_of_taken_exams, num_of_payments, first_date, result): if first_date: self.mmtrack.program.exam_attempts_first_date = (self.now + timedelta(weeks=2)) self.mmtrack.get_payments_count_for_course.return_value = num_of_payments for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)<|docstring|>Test has_to_pay_for_exam<|endoftext|>
acfe8962ab5c717aa16b7079f7f9dd62025f2494390bf3631f93199bf0197731
@ddt.data((0, 1, False, False), (1, 1, False, True), (0, 1, True, False), (1, 1, True, True)) @ddt.unpack def test_has_to_pay_after_first_date(self, num_of_taken_exams, num_of_payments, before_second_date, result): 'Test has_to_pay_for_exam after attempt dates have been set' second_date = ((self.now + timedelta(weeks=1)) if before_second_date else (self.now - timedelta(weeks=1))) self.mmtrack.program.exam_attempts_first_date = (self.now - timedelta(weeks=2)) self.mmtrack.program.exam_attempts_second_date = second_date self.mmtrack.get_payments_count_for_course.return_value = num_of_payments run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) self.mmtrack.get_custom_number_of_attempts_for_course.return_value = num_of_payments for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)
Test has_to_pay_for_exam after attempt dates have been set
dashboard/api_test.py
test_has_to_pay_after_first_date
mitodl/micromasters
32
python
@ddt.data((0, 1, False, False), (1, 1, False, True), (0, 1, True, False), (1, 1, True, True)) @ddt.unpack def test_has_to_pay_after_first_date(self, num_of_taken_exams, num_of_payments, before_second_date, result): second_date = ((self.now + timedelta(weeks=1)) if before_second_date else (self.now - timedelta(weeks=1))) self.mmtrack.program.exam_attempts_first_date = (self.now - timedelta(weeks=2)) self.mmtrack.program.exam_attempts_second_date = second_date self.mmtrack.get_payments_count_for_course.return_value = num_of_payments run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) self.mmtrack.get_custom_number_of_attempts_for_course.return_value = num_of_payments for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)
@ddt.data((0, 1, False, False), (1, 1, False, True), (0, 1, True, False), (1, 1, True, True)) @ddt.unpack def test_has_to_pay_after_first_date(self, num_of_taken_exams, num_of_payments, before_second_date, result): second_date = ((self.now + timedelta(weeks=1)) if before_second_date else (self.now - timedelta(weeks=1))) self.mmtrack.program.exam_attempts_first_date = (self.now - timedelta(weeks=2)) self.mmtrack.program.exam_attempts_second_date = second_date self.mmtrack.get_payments_count_for_course.return_value = num_of_payments run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) self.mmtrack.get_custom_number_of_attempts_for_course.return_value = num_of_payments for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)<|docstring|>Test has_to_pay_for_exam after attempt dates have been set<|endoftext|>
1e5988b1d7894fca01a87e29a6a41cbded002f9b700846d2531aab466a6b242a
@ddt.data((0, 1, 1, False, False), (1, 1, 1, False, True), (1, 2, 2, False, False), (2, 2, 2, False, True), (0, 1, 2, True, False), (1, 1, 2, True, False), (1, 2, 3, True, False), (2, 2, 3, True, False), (3, 2, 3, True, True)) @ddt.unpack def test_has_to_pay_after_first_date_old_payment(self, num_of_taken_exams, num_of_payments, total_attempts, older_purchase, result): 'Test has_to_pay_for_exam after attempt dates have been set' second_date = (self.now + timedelta(weeks=1)) self.mmtrack.program.exam_attempts_first_date = (self.now - timedelta(weeks=2)) self.mmtrack.program.exam_attempts_second_date = second_date self.mmtrack.get_payments_count_for_course.return_value = num_of_payments run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) if older_purchase: run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) ten_days_ago = (self.now - timedelta(weeks=3)) Line.objects.filter(order=order).update(modified_at=ten_days_ago) self.mmtrack.get_custom_number_of_attempts_for_course.return_value = total_attempts for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)
Test has_to_pay_for_exam after attempt dates have been set
dashboard/api_test.py
test_has_to_pay_after_first_date_old_payment
mitodl/micromasters
32
python
@ddt.data((0, 1, 1, False, False), (1, 1, 1, False, True), (1, 2, 2, False, False), (2, 2, 2, False, True), (0, 1, 2, True, False), (1, 1, 2, True, False), (1, 2, 3, True, False), (2, 2, 3, True, False), (3, 2, 3, True, True)) @ddt.unpack def test_has_to_pay_after_first_date_old_payment(self, num_of_taken_exams, num_of_payments, total_attempts, older_purchase, result): second_date = (self.now + timedelta(weeks=1)) self.mmtrack.program.exam_attempts_first_date = (self.now - timedelta(weeks=2)) self.mmtrack.program.exam_attempts_second_date = second_date self.mmtrack.get_payments_count_for_course.return_value = num_of_payments run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) if older_purchase: run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) ten_days_ago = (self.now - timedelta(weeks=3)) Line.objects.filter(order=order).update(modified_at=ten_days_ago) self.mmtrack.get_custom_number_of_attempts_for_course.return_value = total_attempts for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)
@ddt.data((0, 1, 1, False, False), (1, 1, 1, False, True), (1, 2, 2, False, False), (2, 2, 2, False, True), (0, 1, 2, True, False), (1, 1, 2, True, False), (1, 2, 3, True, False), (2, 2, 3, True, False), (3, 2, 3, True, True)) @ddt.unpack def test_has_to_pay_after_first_date_old_payment(self, num_of_taken_exams, num_of_payments, total_attempts, older_purchase, result): second_date = (self.now + timedelta(weeks=1)) self.mmtrack.program.exam_attempts_first_date = (self.now - timedelta(weeks=2)) self.mmtrack.program.exam_attempts_second_date = second_date self.mmtrack.get_payments_count_for_course.return_value = num_of_payments run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) if older_purchase: run = CourseRunFactory.create(course=self.course) order = OrderFactory.create(user=self.user, status=Order.FULFILLED) LineFactory.create(order=order, course_key=run.edx_course_key) ten_days_ago = (self.now - timedelta(weeks=3)) Line.objects.filter(order=order).update(modified_at=ten_days_ago) self.mmtrack.get_custom_number_of_attempts_for_course.return_value = total_attempts for _ in range(num_of_taken_exams): ExamAuthorizationFactory.create(user=self.user, course=self.course, exam_taken=True) assert (api.has_to_pay_for_exam(self.mmtrack, self.course) is result)<|docstring|>Test has_to_pay_for_exam after attempt dates have been set<|endoftext|>
4833a011b3f35367a0958447e714d77fe5e7787706991e0cf8d1ab8121dbb61a
def test_get_certificate_url(self): 'Test get_certificate_url for course with certificate' self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade cert = MicromastersCourseCertificateFactory.create(course=self.course, user=self.user) self.mmtrack.get_course_certificate.return_value = cert CourseCertificateSignatoriesFactory.create(course=self.course) assert (api.get_certificate_url(self.mmtrack, self.course) == '/certificate/course/{}'.format(cert.hash))
Test get_certificate_url for course with certificate
dashboard/api_test.py
test_get_certificate_url
mitodl/micromasters
32
python
def test_get_certificate_url(self): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade cert = MicromastersCourseCertificateFactory.create(course=self.course, user=self.user) self.mmtrack.get_course_certificate.return_value = cert CourseCertificateSignatoriesFactory.create(course=self.course) assert (api.get_certificate_url(self.mmtrack, self.course) == '/certificate/course/{}'.format(cert.hash))
def test_get_certificate_url(self): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade cert = MicromastersCourseCertificateFactory.create(course=self.course, user=self.user) self.mmtrack.get_course_certificate.return_value = cert CourseCertificateSignatoriesFactory.create(course=self.course) assert (api.get_certificate_url(self.mmtrack, self.course) == '/certificate/course/{}'.format(cert.hash))<|docstring|>Test get_certificate_url for course with certificate<|endoftext|>
15072b77b5cb7b237b637aa4f272926026ec80ccedea4fb412237ed127006f1e
def test_no_signatories(self): 'Test get_certificate_url for course with no signatories' self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade MicromastersCourseCertificateFactory.create(course=self.course, user=self.user) self.mmtrack.get_course_certificate.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == '')
Test get_certificate_url for course with no signatories
dashboard/api_test.py
test_no_signatories
mitodl/micromasters
32
python
def test_no_signatories(self): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade MicromastersCourseCertificateFactory.create(course=self.course, user=self.user) self.mmtrack.get_course_certificate.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == )
def test_no_signatories(self): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade MicromastersCourseCertificateFactory.create(course=self.course, user=self.user) self.mmtrack.get_course_certificate.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == )<|docstring|>Test get_certificate_url for course with no signatories<|endoftext|>
558fd0e8ef3aa538bf16353caa766a23d3662717149a6ee9850d1453c04325e9
def test_has_no_final_grade(self): 'Test no final grade for a course' self.mmtrack.get_best_final_grade_for_course.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == '')
Test no final grade for a course
dashboard/api_test.py
test_has_no_final_grade
mitodl/micromasters
32
python
def test_has_no_final_grade(self): self.mmtrack.get_best_final_grade_for_course.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == )
def test_has_no_final_grade(self): self.mmtrack.get_best_final_grade_for_course.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == )<|docstring|>Test no final grade for a course<|endoftext|>
e74865b58c3660f4ce63edce7c7da9fe3709ec6d10615672c92a8246c682a19b
def test_has_passing_grade_no_certificate(self): 'Test has passing grade but no certificate' self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade self.mmtrack.get_course_certificate.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == '')
Test has passing grade but no certificate
dashboard/api_test.py
test_has_passing_grade_no_certificate
mitodl/micromasters
32
python
def test_has_passing_grade_no_certificate(self): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade self.mmtrack.get_course_certificate.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == )
def test_has_passing_grade_no_certificate(self): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade self.mmtrack.get_course_certificate.return_value = None assert (api.get_certificate_url(self.mmtrack, self.course) == )<|docstring|>Test has passing grade but no certificate<|endoftext|>
00aeebeca458543e7ee370557cd714f0759daa81e71d14705b39bf1c584c2eaf
@ddt.data(('verified', True, True), ('audit', False, False), ('verified', False, False), ('audit', True, False)) @ddt.unpack def test_edx_course_certificate(self, certificate_type, is_passing, has_url): 'Test edx certificate url for non FA courses' self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade self.mmtrack.financial_aid_available = False self.mmtrack.has_passing_certificate.return_value = ((certificate_type == 'verified') and is_passing) cert_json = {'username': 'staff', 'course_id': self.course_run.edx_course_key, 'certificate_type': certificate_type, 'is_passing': is_passing, 'status': 'downloadable', 'download_url': '/certificates/user/course_key', 'grade': '0.98'} self.mmtrack.certificates = CachedCertificate.deserialize_edx_data([cert_json]) certificate_url = (urljoin(settings.EDXORG_BASE_URL, 'certificates/user/course_key') if has_url else '') assert (api.get_certificate_url(self.mmtrack, self.course) == certificate_url)
Test edx certificate url for non FA courses
dashboard/api_test.py
test_edx_course_certificate
mitodl/micromasters
32
python
@ddt.data(('verified', True, True), ('audit', False, False), ('verified', False, False), ('audit', True, False)) @ddt.unpack def test_edx_course_certificate(self, certificate_type, is_passing, has_url): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade self.mmtrack.financial_aid_available = False self.mmtrack.has_passing_certificate.return_value = ((certificate_type == 'verified') and is_passing) cert_json = {'username': 'staff', 'course_id': self.course_run.edx_course_key, 'certificate_type': certificate_type, 'is_passing': is_passing, 'status': 'downloadable', 'download_url': '/certificates/user/course_key', 'grade': '0.98'} self.mmtrack.certificates = CachedCertificate.deserialize_edx_data([cert_json]) certificate_url = (urljoin(settings.EDXORG_BASE_URL, 'certificates/user/course_key') if has_url else ) assert (api.get_certificate_url(self.mmtrack, self.course) == certificate_url)
@ddt.data(('verified', True, True), ('audit', False, False), ('verified', False, False), ('audit', True, False)) @ddt.unpack def test_edx_course_certificate(self, certificate_type, is_passing, has_url): self.mmtrack.get_best_final_grade_for_course.return_value = self.final_grade self.mmtrack.financial_aid_available = False self.mmtrack.has_passing_certificate.return_value = ((certificate_type == 'verified') and is_passing) cert_json = {'username': 'staff', 'course_id': self.course_run.edx_course_key, 'certificate_type': certificate_type, 'is_passing': is_passing, 'status': 'downloadable', 'download_url': '/certificates/user/course_key', 'grade': '0.98'} self.mmtrack.certificates = CachedCertificate.deserialize_edx_data([cert_json]) certificate_url = (urljoin(settings.EDXORG_BASE_URL, 'certificates/user/course_key') if has_url else ) assert (api.get_certificate_url(self.mmtrack, self.course) == certificate_url)<|docstring|>Test edx certificate url for non FA courses<|endoftext|>
10b8954c9ba3915f419499cc076f2face6b02b6fdc808791b79f7d944f080af0
def _update_cache(user, edx_client, cache_type, provider): 'Fail updating the cache for only the given cache type' if (cache_type == failed_cache_type): raise KeyError()
Fail updating the cache for only the given cache type
dashboard/api_test.py
_update_cache
mitodl/micromasters
32
python
def _update_cache(user, edx_client, cache_type, provider): if (cache_type == failed_cache_type): raise KeyError()
def _update_cache(user, edx_client, cache_type, provider): if (cache_type == failed_cache_type): raise KeyError()<|docstring|>Fail updating the cache for only the given cache type<|endoftext|>
4bb3a220208c3139b89c6ba4045ae4878d7b7eb8abe700ed5e00b109abb66fe6
def mock_return_status(actual_course_run, *args, **kargs): 'Mock function for get_status_for_courserun' if (actual_course_run == specific_run): return api.CourseRunUserStatus(status=status, course_run=actual_course_run) return api.CourseRunUserStatus(status=other_run_status, course_run=actual_course_run)
Mock function for get_status_for_courserun
dashboard/api_test.py
mock_return_status
mitodl/micromasters
32
python
def mock_return_status(actual_course_run, *args, **kargs): if (actual_course_run == specific_run): return api.CourseRunUserStatus(status=status, course_run=actual_course_run) return api.CourseRunUserStatus(status=other_run_status, course_run=actual_course_run)
def mock_return_status(actual_course_run, *args, **kargs): if (actual_course_run == specific_run): return api.CourseRunUserStatus(status=status, course_run=actual_course_run) return api.CourseRunUserStatus(status=other_run_status, course_run=actual_course_run)<|docstring|>Mock function for get_status_for_courserun<|endoftext|>
cfdbfe9dc747b93a887834ce31a904a3566a88c64bffd5b0ea20032d8bf43b55
def mocked_get_status_for_courserun(run, enrollments): 'Mock get_status_for_courserun with different values for each run' return api.CourseRunUserStatus(status=api.CourseRunStatus.NOT_ENROLLED, course_run=run)
Mock get_status_for_courserun with different values for each run
dashboard/api_test.py
mocked_get_status_for_courserun
mitodl/micromasters
32
python
def mocked_get_status_for_courserun(run, enrollments): return api.CourseRunUserStatus(status=api.CourseRunStatus.NOT_ENROLLED, course_run=run)
def mocked_get_status_for_courserun(run, enrollments): return api.CourseRunUserStatus(status=api.CourseRunStatus.NOT_ENROLLED, course_run=run)<|docstring|>Mock get_status_for_courserun with different values for each run<|endoftext|>
e4552a58f26c2193002a5459f8cc67a5090337cdebad2261fa215630358776dc
def getSerialPorts(): ' Lists serial port names\n\n :raises EnvironmentError:\n On unsupported or unknown platforms\n :returns:\n A list of the serial ports available on the system\n ' if sys.platform.startswith('win'): ports = [('COM%s' % (i + 1)) for i in range(256)] elif (sys.platform.startswith('linux') or sys.platform.startswith('cygwin')): ports = glob.glob('/dev/tty[A-Za-z]*') elif sys.platform.startswith('darwin'): ports = glob.glob('/dev/tty.*') else: raise EnvironmentError('Unsupported platform') result = [] for port in ports: try: s = serial.Serial(port) s.close() result.append(port) except (OSError, serial.SerialException): pass return result
Lists serial port names :raises EnvironmentError: On unsupported or unknown platforms :returns: A list of the serial ports available on the system
projects/util/term/startTerms.py
getSerialPorts
adriansaridache/demo_fruity
0
python
def getSerialPorts(): ' Lists serial port names\n\n :raises EnvironmentError:\n On unsupported or unknown platforms\n :returns:\n A list of the serial ports available on the system\n ' if sys.platform.startswith('win'): ports = [('COM%s' % (i + 1)) for i in range(256)] elif (sys.platform.startswith('linux') or sys.platform.startswith('cygwin')): ports = glob.glob('/dev/tty[A-Za-z]*') elif sys.platform.startswith('darwin'): ports = glob.glob('/dev/tty.*') else: raise EnvironmentError('Unsupported platform') result = [] for port in ports: try: s = serial.Serial(port) s.close() result.append(port) except (OSError, serial.SerialException): pass return result
def getSerialPorts(): ' Lists serial port names\n\n :raises EnvironmentError:\n On unsupported or unknown platforms\n :returns:\n A list of the serial ports available on the system\n ' if sys.platform.startswith('win'): ports = [('COM%s' % (i + 1)) for i in range(256)] elif (sys.platform.startswith('linux') or sys.platform.startswith('cygwin')): ports = glob.glob('/dev/tty[A-Za-z]*') elif sys.platform.startswith('darwin'): ports = glob.glob('/dev/tty.*') else: raise EnvironmentError('Unsupported platform') result = [] for port in ports: try: s = serial.Serial(port) s.close() result.append(port) except (OSError, serial.SerialException): pass return result<|docstring|>Lists serial port names :raises EnvironmentError: On unsupported or unknown platforms :returns: A list of the serial ports available on the system<|endoftext|>
bf4df05f961eb8aceb450bc6054329303711595a18ec434d62cead6b9e3f1741
def np_put(p): '\n a[order][np_put(order)] = a\n\n ' n = p.size s = np.zeros(n, dtype=np.int32) i = np.arange(n, dtype=np.int32) return np.put(s, p, i)
a[order][np_put(order)] = a
pypcurve.py
np_put
c235gsy/scTrack
0
python
def np_put(p): '\n \n\n ' n = p.size s = np.zeros(n, dtype=np.int32) i = np.arange(n, dtype=np.int32) return np.put(s, p, i)
def np_put(p): '\n \n\n ' n = p.size s = np.zeros(n, dtype=np.int32) i = np.arange(n, dtype=np.int32) return np.put(s, p, i)<|docstring|>a[order][np_put(order)] = a<|endoftext|>
94b0909df8a7b736a28f9f274cfa3f784cd9ba307eeada437d5e550463ac0552
def project_points(points, curve, init_lambda=None, inter_dimension=3, extend=2, n_curve_seq=int(10000.0), return_curve_seq=False, lambda_model='pseudotime', smoothness=1.0): '\n points : the points used to project\n curve : the curve points project to\n inter_dimension : the interpolation dimension of the interpolation functions\n extend : the rate of the extension of the interpolation prediction\n n_curve_seq : the number of point used to general the curve sequences\n return_curve_seq : default False, if True, the dictionary returned contains a key "curve_seq"\n\n return:\n a dictionary:\n "projection" : the projections of the points\n "order" : the order array of the points in the curve\n "lambda_points" : the lambda of the points\n "extend" : the rate of the extension of the interpolation prediction\n "n_curve_seq" : the number of point used to general the curve sequences\n "curve_seq" : the whole curve sequences\n ' n_points = len(points) n_curves = len(curve) n_features = len(points[0]) n_curve_seq_all = int(((n_curve_seq * (100 + (extend * 2))) / 100)) if (init_lambda is None): lambda_curve = np.linspace(0, 100, n_curves) else: lambda_curve = ((100 * (init_lambda - init_lambda.min())) / (init_lambda.max() - init_lambda.min())) lambda_seq = np.linspace((0 - extend), (100 + extend), n_curve_seq_all) (sorted_lambda_curve, lambda_curve_idx) = np.unique(lambda_curve, return_index=True) interpolation_functions = [UnivariateSpline(x=sorted_lambda_curve, y=curve[(lambda_curve_idx, n_f)], k=inter_dimension, s=(smoothness * len(sorted_lambda_curve))) for n_f in range(n_features)] curve_seq = np.array([function(lambda_seq) for function in interpolation_functions]).T min_dist_idx_ = np.array([np.argmin(np.sum(((p - curve_seq) ** 2), axis=1), axis=0) for p in points]) projection = curve_seq[min_dist_idx_] order = np.argsort(lambda_seq[min_dist_idx_]) if (lambda_model == 'arc'): ord_projection = projection[order] lambda_points = [0] arc = 0 for i in range((len(ord_projection) - 1)): arc += np.sqrt(np.sum(((ord_projection[i] - ord_projection[(i + 1)]) ** 2))) lambda_points.append(arc) lambda_points = np.array(lambda_points)[np_put(order)] elif (lambda_model == 'pseudotime'): lambda_points = lambda_seq[min_dist_idx_] lambda_points = ((100 * (lambda_points - lambda_points.min())) / (lambda_points.max() - lambda_points.min())) else: print('The lambda_model must be chosen from "arc" and "pseudotime" ') sys.exit() output = {'projection': projection, 'order': order, 'lambda_points': lambda_points, 'extend': extend, 'n_curve_seq': n_curve_seq} if return_curve_seq: output['curve_seq'] = curve_seq return output
points : the points used to project curve : the curve points project to inter_dimension : the interpolation dimension of the interpolation functions extend : the rate of the extension of the interpolation prediction n_curve_seq : the number of point used to general the curve sequences return_curve_seq : default False, if True, the dictionary returned contains a key "curve_seq" return: a dictionary: "projection" : the projections of the points "order" : the order array of the points in the curve "lambda_points" : the lambda of the points "extend" : the rate of the extension of the interpolation prediction "n_curve_seq" : the number of point used to general the curve sequences "curve_seq" : the whole curve sequences
pypcurve.py
project_points
c235gsy/scTrack
0
python
def project_points(points, curve, init_lambda=None, inter_dimension=3, extend=2, n_curve_seq=int(10000.0), return_curve_seq=False, lambda_model='pseudotime', smoothness=1.0): '\n points : the points used to project\n curve : the curve points project to\n inter_dimension : the interpolation dimension of the interpolation functions\n extend : the rate of the extension of the interpolation prediction\n n_curve_seq : the number of point used to general the curve sequences\n return_curve_seq : default False, if True, the dictionary returned contains a key "curve_seq"\n\n return:\n a dictionary:\n "projection" : the projections of the points\n "order" : the order array of the points in the curve\n "lambda_points" : the lambda of the points\n "extend" : the rate of the extension of the interpolation prediction\n "n_curve_seq" : the number of point used to general the curve sequences\n "curve_seq" : the whole curve sequences\n ' n_points = len(points) n_curves = len(curve) n_features = len(points[0]) n_curve_seq_all = int(((n_curve_seq * (100 + (extend * 2))) / 100)) if (init_lambda is None): lambda_curve = np.linspace(0, 100, n_curves) else: lambda_curve = ((100 * (init_lambda - init_lambda.min())) / (init_lambda.max() - init_lambda.min())) lambda_seq = np.linspace((0 - extend), (100 + extend), n_curve_seq_all) (sorted_lambda_curve, lambda_curve_idx) = np.unique(lambda_curve, return_index=True) interpolation_functions = [UnivariateSpline(x=sorted_lambda_curve, y=curve[(lambda_curve_idx, n_f)], k=inter_dimension, s=(smoothness * len(sorted_lambda_curve))) for n_f in range(n_features)] curve_seq = np.array([function(lambda_seq) for function in interpolation_functions]).T min_dist_idx_ = np.array([np.argmin(np.sum(((p - curve_seq) ** 2), axis=1), axis=0) for p in points]) projection = curve_seq[min_dist_idx_] order = np.argsort(lambda_seq[min_dist_idx_]) if (lambda_model == 'arc'): ord_projection = projection[order] lambda_points = [0] arc = 0 for i in range((len(ord_projection) - 1)): arc += np.sqrt(np.sum(((ord_projection[i] - ord_projection[(i + 1)]) ** 2))) lambda_points.append(arc) lambda_points = np.array(lambda_points)[np_put(order)] elif (lambda_model == 'pseudotime'): lambda_points = lambda_seq[min_dist_idx_] lambda_points = ((100 * (lambda_points - lambda_points.min())) / (lambda_points.max() - lambda_points.min())) else: print('The lambda_model must be chosen from "arc" and "pseudotime" ') sys.exit() output = {'projection': projection, 'order': order, 'lambda_points': lambda_points, 'extend': extend, 'n_curve_seq': n_curve_seq} if return_curve_seq: output['curve_seq'] = curve_seq return output
def project_points(points, curve, init_lambda=None, inter_dimension=3, extend=2, n_curve_seq=int(10000.0), return_curve_seq=False, lambda_model='pseudotime', smoothness=1.0): '\n points : the points used to project\n curve : the curve points project to\n inter_dimension : the interpolation dimension of the interpolation functions\n extend : the rate of the extension of the interpolation prediction\n n_curve_seq : the number of point used to general the curve sequences\n return_curve_seq : default False, if True, the dictionary returned contains a key "curve_seq"\n\n return:\n a dictionary:\n "projection" : the projections of the points\n "order" : the order array of the points in the curve\n "lambda_points" : the lambda of the points\n "extend" : the rate of the extension of the interpolation prediction\n "n_curve_seq" : the number of point used to general the curve sequences\n "curve_seq" : the whole curve sequences\n ' n_points = len(points) n_curves = len(curve) n_features = len(points[0]) n_curve_seq_all = int(((n_curve_seq * (100 + (extend * 2))) / 100)) if (init_lambda is None): lambda_curve = np.linspace(0, 100, n_curves) else: lambda_curve = ((100 * (init_lambda - init_lambda.min())) / (init_lambda.max() - init_lambda.min())) lambda_seq = np.linspace((0 - extend), (100 + extend), n_curve_seq_all) (sorted_lambda_curve, lambda_curve_idx) = np.unique(lambda_curve, return_index=True) interpolation_functions = [UnivariateSpline(x=sorted_lambda_curve, y=curve[(lambda_curve_idx, n_f)], k=inter_dimension, s=(smoothness * len(sorted_lambda_curve))) for n_f in range(n_features)] curve_seq = np.array([function(lambda_seq) for function in interpolation_functions]).T min_dist_idx_ = np.array([np.argmin(np.sum(((p - curve_seq) ** 2), axis=1), axis=0) for p in points]) projection = curve_seq[min_dist_idx_] order = np.argsort(lambda_seq[min_dist_idx_]) if (lambda_model == 'arc'): ord_projection = projection[order] lambda_points = [0] arc = 0 for i in range((len(ord_projection) - 1)): arc += np.sqrt(np.sum(((ord_projection[i] - ord_projection[(i + 1)]) ** 2))) lambda_points.append(arc) lambda_points = np.array(lambda_points)[np_put(order)] elif (lambda_model == 'pseudotime'): lambda_points = lambda_seq[min_dist_idx_] lambda_points = ((100 * (lambda_points - lambda_points.min())) / (lambda_points.max() - lambda_points.min())) else: print('The lambda_model must be chosen from "arc" and "pseudotime" ') sys.exit() output = {'projection': projection, 'order': order, 'lambda_points': lambda_points, 'extend': extend, 'n_curve_seq': n_curve_seq} if return_curve_seq: output['curve_seq'] = curve_seq return output<|docstring|>points : the points used to project curve : the curve points project to inter_dimension : the interpolation dimension of the interpolation functions extend : the rate of the extension of the interpolation prediction n_curve_seq : the number of point used to general the curve sequences return_curve_seq : default False, if True, the dictionary returned contains a key "curve_seq" return: a dictionary: "projection" : the projections of the points "order" : the order array of the points in the curve "lambda_points" : the lambda of the points "extend" : the rate of the extension of the interpolation prediction "n_curve_seq" : the number of point used to general the curve sequences "curve_seq" : the whole curve sequences<|endoftext|>
ffb065e9ab3e76b15e99369b086db23a136fcfaa946ce7ba4712c2edbd3682a4
def clear_old_snapshots(): ' Remove any old snapshots to minimize disk space usage locally. ' logging.info('Removing old Cassandra snapshots...') try: subprocess.check_call([NODE_TOOL, 'clearsnapshot']) except CalledProcessError as error: logging.error('Error while deleting old Cassandra snapshots. Error: {0}'.format(str(error)))
Remove any old snapshots to minimize disk space usage locally.
AppDB/appscale/datastore/backup/cassandra_backup.py
clear_old_snapshots
HafeezRai/appscale
1
python
def clear_old_snapshots(): ' ' logging.info('Removing old Cassandra snapshots...') try: subprocess.check_call([NODE_TOOL, 'clearsnapshot']) except CalledProcessError as error: logging.error('Error while deleting old Cassandra snapshots. Error: {0}'.format(str(error)))
def clear_old_snapshots(): ' ' logging.info('Removing old Cassandra snapshots...') try: subprocess.check_call([NODE_TOOL, 'clearsnapshot']) except CalledProcessError as error: logging.error('Error while deleting old Cassandra snapshots. Error: {0}'.format(str(error)))<|docstring|>Remove any old snapshots to minimize disk space usage locally.<|endoftext|>
8864771b4338502cc52db24f185d14500c8af79ace02dc4c54f75b26d9946ea8
def create_snapshot(snapshot_name=''): ' Perform local Cassandra backup by taking a new snapshot.\n\n Args:\n snapshot_name: A str, optional. A fixed name for the snapshot to create.\n Returns:\n True on success, False otherwise.\n ' logging.info('Creating new Cassandra snapshots...') try: subprocess.check_call([NODE_TOOL, 'snapshot']) except CalledProcessError as error: logging.error('Error while creating new Cassandra snapshots. Error: {0}'.format(str(error))) return False return True
Perform local Cassandra backup by taking a new snapshot. Args: snapshot_name: A str, optional. A fixed name for the snapshot to create. Returns: True on success, False otherwise.
AppDB/appscale/datastore/backup/cassandra_backup.py
create_snapshot
HafeezRai/appscale
1
python
def create_snapshot(snapshot_name=): ' Perform local Cassandra backup by taking a new snapshot.\n\n Args:\n snapshot_name: A str, optional. A fixed name for the snapshot to create.\n Returns:\n True on success, False otherwise.\n ' logging.info('Creating new Cassandra snapshots...') try: subprocess.check_call([NODE_TOOL, 'snapshot']) except CalledProcessError as error: logging.error('Error while creating new Cassandra snapshots. Error: {0}'.format(str(error))) return False return True
def create_snapshot(snapshot_name=): ' Perform local Cassandra backup by taking a new snapshot.\n\n Args:\n snapshot_name: A str, optional. A fixed name for the snapshot to create.\n Returns:\n True on success, False otherwise.\n ' logging.info('Creating new Cassandra snapshots...') try: subprocess.check_call([NODE_TOOL, 'snapshot']) except CalledProcessError as error: logging.error('Error while creating new Cassandra snapshots. Error: {0}'.format(str(error))) return False return True<|docstring|>Perform local Cassandra backup by taking a new snapshot. Args: snapshot_name: A str, optional. A fixed name for the snapshot to create. Returns: True on success, False otherwise.<|endoftext|>
0147949e4ddc9ae6072403adbb1cd5ca8935498b46c49cd27fb0e6d62c4e1fa3
def remove_old_data(): ' Removes previous node data from the Cassandra store. ' for directory in CASSANDRA_DATA_SUBDIRS: data_dir = '{0}/{1}/{2}'.format(APPSCALE_DATA_DIR, 'cassandra', directory) logging.warning('Removing data from {0}'.format(data_dir)) try: subprocess.Popen('find /opt/appscale/cassandra -name "*" | grep ".db\\|.txt\\|.log" | grep -v snapshot | xargs rm', shell=True) logging.info('Done removing data!') except CalledProcessError as error: logging.error('Error while removing old data from db. Overwriting... Error: {0}'.format(str(error)))
Removes previous node data from the Cassandra store.
AppDB/appscale/datastore/backup/cassandra_backup.py
remove_old_data
HafeezRai/appscale
1
python
def remove_old_data(): ' ' for directory in CASSANDRA_DATA_SUBDIRS: data_dir = '{0}/{1}/{2}'.format(APPSCALE_DATA_DIR, 'cassandra', directory) logging.warning('Removing data from {0}'.format(data_dir)) try: subprocess.Popen('find /opt/appscale/cassandra -name "*" | grep ".db\\|.txt\\|.log" | grep -v snapshot | xargs rm', shell=True) logging.info('Done removing data!') except CalledProcessError as error: logging.error('Error while removing old data from db. Overwriting... Error: {0}'.format(str(error)))
def remove_old_data(): ' ' for directory in CASSANDRA_DATA_SUBDIRS: data_dir = '{0}/{1}/{2}'.format(APPSCALE_DATA_DIR, 'cassandra', directory) logging.warning('Removing data from {0}'.format(data_dir)) try: subprocess.Popen('find /opt/appscale/cassandra -name "*" | grep ".db\\|.txt\\|.log" | grep -v snapshot | xargs rm', shell=True) logging.info('Done removing data!') except CalledProcessError as error: logging.error('Error while removing old data from db. Overwriting... Error: {0}'.format(str(error)))<|docstring|>Removes previous node data from the Cassandra store.<|endoftext|>
fd4c174473bf20705a58513cfda4fa92abe9c560206baac577ceb4abc71207ed
def restore_snapshots(): ' Restore snapshot into correct directories.\n\n Returns:\n True on success, False otherwise.\n ' logging.info('Restoring Cassandra snapshots.') for directory in CASSANDRA_DATA_SUBDIRS: data_dir = '{0}/{1}/{2}/'.format(APPSCALE_DATA_DIR, 'cassandra', directory) logging.debug('Restoring in dir {0}'.format(data_dir)) for (path, _, filenames) in os.walk(data_dir): for filename in filenames: logging.debug('Restoring: {0}'.format(filename)) if (not filename): logging.warn('skipping...') continue full_path = '{0}/{1}'.format(path, filename) new_full_path = '{0}/../../{1}'.format(path, filename) logging.debug('{0} -> {1}'.format(full_path, new_full_path)) if (not backup_recovery_helper.rename(full_path, new_full_path)): logging.error('Error while moving Cassandra snapshot in place. Aborting restore...') return False logging.info('Done restoring Cassandra snapshots.') return True
Restore snapshot into correct directories. Returns: True on success, False otherwise.
AppDB/appscale/datastore/backup/cassandra_backup.py
restore_snapshots
HafeezRai/appscale
1
python
def restore_snapshots(): ' Restore snapshot into correct directories.\n\n Returns:\n True on success, False otherwise.\n ' logging.info('Restoring Cassandra snapshots.') for directory in CASSANDRA_DATA_SUBDIRS: data_dir = '{0}/{1}/{2}/'.format(APPSCALE_DATA_DIR, 'cassandra', directory) logging.debug('Restoring in dir {0}'.format(data_dir)) for (path, _, filenames) in os.walk(data_dir): for filename in filenames: logging.debug('Restoring: {0}'.format(filename)) if (not filename): logging.warn('skipping...') continue full_path = '{0}/{1}'.format(path, filename) new_full_path = '{0}/../../{1}'.format(path, filename) logging.debug('{0} -> {1}'.format(full_path, new_full_path)) if (not backup_recovery_helper.rename(full_path, new_full_path)): logging.error('Error while moving Cassandra snapshot in place. Aborting restore...') return False logging.info('Done restoring Cassandra snapshots.') return True
def restore_snapshots(): ' Restore snapshot into correct directories.\n\n Returns:\n True on success, False otherwise.\n ' logging.info('Restoring Cassandra snapshots.') for directory in CASSANDRA_DATA_SUBDIRS: data_dir = '{0}/{1}/{2}/'.format(APPSCALE_DATA_DIR, 'cassandra', directory) logging.debug('Restoring in dir {0}'.format(data_dir)) for (path, _, filenames) in os.walk(data_dir): for filename in filenames: logging.debug('Restoring: {0}'.format(filename)) if (not filename): logging.warn('skipping...') continue full_path = '{0}/{1}'.format(path, filename) new_full_path = '{0}/../../{1}'.format(path, filename) logging.debug('{0} -> {1}'.format(full_path, new_full_path)) if (not backup_recovery_helper.rename(full_path, new_full_path)): logging.error('Error while moving Cassandra snapshot in place. Aborting restore...') return False logging.info('Done restoring Cassandra snapshots.') return True<|docstring|>Restore snapshot into correct directories. Returns: True on success, False otherwise.<|endoftext|>
d96564eb3fb3a7fb4d6662fbcc61a36a0e0b328e5a04dd4ec3f392b3a0c7a589
def shutdown_datastore(): ' Top level function for bringing down Cassandra.\n\n Returns:\n True on success, False otherwise.\n ' logging.info('Shutting down Cassandra.') monit_interface.stop(cassandra_interface.CASSANDRA_MONIT_WATCH_NAME, is_group=False) logging.warning('Done!') return True
Top level function for bringing down Cassandra. Returns: True on success, False otherwise.
AppDB/appscale/datastore/backup/cassandra_backup.py
shutdown_datastore
HafeezRai/appscale
1
python
def shutdown_datastore(): ' Top level function for bringing down Cassandra.\n\n Returns:\n True on success, False otherwise.\n ' logging.info('Shutting down Cassandra.') monit_interface.stop(cassandra_interface.CASSANDRA_MONIT_WATCH_NAME, is_group=False) logging.warning('Done!') return True
def shutdown_datastore(): ' Top level function for bringing down Cassandra.\n\n Returns:\n True on success, False otherwise.\n ' logging.info('Shutting down Cassandra.') monit_interface.stop(cassandra_interface.CASSANDRA_MONIT_WATCH_NAME, is_group=False) logging.warning('Done!') return True<|docstring|>Top level function for bringing down Cassandra. Returns: True on success, False otherwise.<|endoftext|>
06a498e8357c0fdd732b996adb3c99d82f10de0a542f1604674cb1a0c1b10add
def backup_data(path, keyname): " Backup Cassandra snapshot data directories/files.\n\n Args:\n path: A string containing the location to store the backup on each of the\n DB machines.\n keyname: A string containing the deployment's keyname.\n Raises:\n BRException if unable to find any Cassandra machines or if DB machine has\n insufficient space.\n " logging.info('Starting new db backup.') db_ips = appscale_info.get_db_ips() if (not db_ips): raise BRException('Unable to find any Cassandra machines.') for db_ip in db_ips: appscale_utils.ssh(db_ip, keyname, '{} clearsnapshot'.format(NODE_TOOL)) appscale_utils.ssh(db_ip, keyname, '{} snapshot'.format(NODE_TOOL)) get_snapshot_size = 'find {0} -name "snapshots" -exec du -s {{}} \\;'.format(APPSCALE_DATA_DIR) du_output = appscale_utils.ssh(db_ip, keyname, get_snapshot_size, method=subprocess.check_output) backup_size = sum((int(line.split()[0]) for line in du_output.split('\n') if line)) output_dir = ('/'.join(path.split('/')[:(- 1)]) + '/') df_output = appscale_utils.ssh(db_ip, keyname, 'df {}'.format(output_dir), method=subprocess.check_output) available = int(df_output.split('\n')[1].split()[3]) if (backup_size > (available * PADDING_PERCENTAGE)): raise BRException('{} has insufficient space: {}/{}'.format(db_ip, (available * PADDING_PERCENTAGE), backup_size)) cassandra_dir = '{}/cassandra'.format(APPSCALE_DATA_DIR) for db_ip in db_ips: create_tar = 'find . -regex ".*/snapshots/[0-9]*/.*" -exec tar --transform="s/snapshots\\/[0-9]*\\///" -cf {0} {{}} +'.format(path) appscale_utils.ssh(db_ip, keyname, 'cd {} && {}'.format(cassandra_dir, create_tar)) logging.info('Done with db backup.')
Backup Cassandra snapshot data directories/files. Args: path: A string containing the location to store the backup on each of the DB machines. keyname: A string containing the deployment's keyname. Raises: BRException if unable to find any Cassandra machines or if DB machine has insufficient space.
AppDB/appscale/datastore/backup/cassandra_backup.py
backup_data
HafeezRai/appscale
1
python
def backup_data(path, keyname): " Backup Cassandra snapshot data directories/files.\n\n Args:\n path: A string containing the location to store the backup on each of the\n DB machines.\n keyname: A string containing the deployment's keyname.\n Raises:\n BRException if unable to find any Cassandra machines or if DB machine has\n insufficient space.\n " logging.info('Starting new db backup.') db_ips = appscale_info.get_db_ips() if (not db_ips): raise BRException('Unable to find any Cassandra machines.') for db_ip in db_ips: appscale_utils.ssh(db_ip, keyname, '{} clearsnapshot'.format(NODE_TOOL)) appscale_utils.ssh(db_ip, keyname, '{} snapshot'.format(NODE_TOOL)) get_snapshot_size = 'find {0} -name "snapshots" -exec du -s {{}} \\;'.format(APPSCALE_DATA_DIR) du_output = appscale_utils.ssh(db_ip, keyname, get_snapshot_size, method=subprocess.check_output) backup_size = sum((int(line.split()[0]) for line in du_output.split('\n') if line)) output_dir = ('/'.join(path.split('/')[:(- 1)]) + '/') df_output = appscale_utils.ssh(db_ip, keyname, 'df {}'.format(output_dir), method=subprocess.check_output) available = int(df_output.split('\n')[1].split()[3]) if (backup_size > (available * PADDING_PERCENTAGE)): raise BRException('{} has insufficient space: {}/{}'.format(db_ip, (available * PADDING_PERCENTAGE), backup_size)) cassandra_dir = '{}/cassandra'.format(APPSCALE_DATA_DIR) for db_ip in db_ips: create_tar = 'find . -regex ".*/snapshots/[0-9]*/.*" -exec tar --transform="s/snapshots\\/[0-9]*\\///" -cf {0} {{}} +'.format(path) appscale_utils.ssh(db_ip, keyname, 'cd {} && {}'.format(cassandra_dir, create_tar)) logging.info('Done with db backup.')
def backup_data(path, keyname): " Backup Cassandra snapshot data directories/files.\n\n Args:\n path: A string containing the location to store the backup on each of the\n DB machines.\n keyname: A string containing the deployment's keyname.\n Raises:\n BRException if unable to find any Cassandra machines or if DB machine has\n insufficient space.\n " logging.info('Starting new db backup.') db_ips = appscale_info.get_db_ips() if (not db_ips): raise BRException('Unable to find any Cassandra machines.') for db_ip in db_ips: appscale_utils.ssh(db_ip, keyname, '{} clearsnapshot'.format(NODE_TOOL)) appscale_utils.ssh(db_ip, keyname, '{} snapshot'.format(NODE_TOOL)) get_snapshot_size = 'find {0} -name "snapshots" -exec du -s {{}} \\;'.format(APPSCALE_DATA_DIR) du_output = appscale_utils.ssh(db_ip, keyname, get_snapshot_size, method=subprocess.check_output) backup_size = sum((int(line.split()[0]) for line in du_output.split('\n') if line)) output_dir = ('/'.join(path.split('/')[:(- 1)]) + '/') df_output = appscale_utils.ssh(db_ip, keyname, 'df {}'.format(output_dir), method=subprocess.check_output) available = int(df_output.split('\n')[1].split()[3]) if (backup_size > (available * PADDING_PERCENTAGE)): raise BRException('{} has insufficient space: {}/{}'.format(db_ip, (available * PADDING_PERCENTAGE), backup_size)) cassandra_dir = '{}/cassandra'.format(APPSCALE_DATA_DIR) for db_ip in db_ips: create_tar = 'find . -regex ".*/snapshots/[0-9]*/.*" -exec tar --transform="s/snapshots\\/[0-9]*\\///" -cf {0} {{}} +'.format(path) appscale_utils.ssh(db_ip, keyname, 'cd {} && {}'.format(cassandra_dir, create_tar)) logging.info('Done with db backup.')<|docstring|>Backup Cassandra snapshot data directories/files. Args: path: A string containing the location to store the backup on each of the DB machines. keyname: A string containing the deployment's keyname. Raises: BRException if unable to find any Cassandra machines or if DB machine has insufficient space.<|endoftext|>
fdea63ee4a2bb63495379abb18c68a14e69557ea27124d9f90fb1c7398ef4a60
def restore_data(path, keyname, force=False): " Restores the Cassandra backup.\n\n Args:\n path: A string containing the location on each of the DB machines to use\n for restoring data.\n keyname: A string containing the deployment's keyname.\n Raises:\n BRException if unable to find any Cassandra machines or if DB machine has\n insufficient space.\n " logging.info('Starting new db restore.') db_ips = appscale_info.get_db_ips() if (not db_ips): raise BRException('Unable to find any Cassandra machines.') machines_without_restore = [] for db_ip in db_ips: exit_code = appscale_utils.ssh(db_ip, keyname, 'ls {}'.format(path), method=subprocess.call) if (exit_code != ExitCodes.SUCCESS): machines_without_restore.append(db_ip) if (machines_without_restore and (not force)): logging.info('The following machines do not have a restore file: {}'.format(machines_without_restore)) response = raw_input('Would you like to continue? [y/N] ') if (response not in ['Y', 'y']): return for db_ip in db_ips: logging.info('Stopping Cassandra on {}'.format(db_ip)) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries = SERVICE_RETRIES while (status != MonitStates.UNMONITORED): appscale_utils.ssh(db_ip, keyname, 'monit stop {}'.format(CASSANDRA_MONIT_WATCH_NAME), method=subprocess.call) time.sleep(3) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries -= 1 if (retries < 0): raise BRException('Unable to stop Cassandra') cassandra_dir = '{}/cassandra'.format(APPSCALE_DATA_DIR) for db_ip in db_ips: logging.info('Restoring Cassandra data on {}'.format(db_ip)) clear_db = 'find {0} -regex ".*\\.\\(db\\|txt\\|log\\)$" -exec rm {{}} \\;'.format(cassandra_dir) appscale_utils.ssh(db_ip, keyname, clear_db) if (db_ip not in machines_without_restore): appscale_utils.ssh(db_ip, keyname, 'tar xf {} -C {}'.format(path, cassandra_dir)) appscale_utils.ssh(db_ip, keyname, 'chown -R cassandra {}'.format(cassandra_dir)) logging.info('Starting Cassandra on {}'.format(db_ip)) retries = SERVICE_RETRIES status = MonitStates.UNMONITORED while (status != MonitStates.RUNNING): appscale_utils.ssh(db_ip, keyname, 'monit start {}'.format(CASSANDRA_MONIT_WATCH_NAME), method=subprocess.call) time.sleep(3) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries -= 1 if (retries < 0): raise BRException('Unable to start Cassandra') appscale_utils.ssh(db_ip, keyname, 'monit start {}'.format(CASSANDRA_MONIT_WATCH_NAME)) logging.info('Waiting for Cassandra cluster to be ready') db_ip = db_ips[0] deadline = (time.time() + SCHEMA_CHANGE_TIMEOUT) while True: ready = True try: output = appscale_utils.ssh(db_ip, keyname, '{} status'.format(NODE_TOOL), method=subprocess.check_output) nodes_ready = len([line for line in output.split('\n') if line.startswith('UN')]) if (nodes_ready < len(db_ips)): ready = False except CalledProcessError: ready = False if ready: break if (time.time() > deadline): logging.warning('Cassandra cluster still not ready.') break time.sleep(3) logging.info('Done with db restore.')
Restores the Cassandra backup. Args: path: A string containing the location on each of the DB machines to use for restoring data. keyname: A string containing the deployment's keyname. Raises: BRException if unable to find any Cassandra machines or if DB machine has insufficient space.
AppDB/appscale/datastore/backup/cassandra_backup.py
restore_data
HafeezRai/appscale
1
python
def restore_data(path, keyname, force=False): " Restores the Cassandra backup.\n\n Args:\n path: A string containing the location on each of the DB machines to use\n for restoring data.\n keyname: A string containing the deployment's keyname.\n Raises:\n BRException if unable to find any Cassandra machines or if DB machine has\n insufficient space.\n " logging.info('Starting new db restore.') db_ips = appscale_info.get_db_ips() if (not db_ips): raise BRException('Unable to find any Cassandra machines.') machines_without_restore = [] for db_ip in db_ips: exit_code = appscale_utils.ssh(db_ip, keyname, 'ls {}'.format(path), method=subprocess.call) if (exit_code != ExitCodes.SUCCESS): machines_without_restore.append(db_ip) if (machines_without_restore and (not force)): logging.info('The following machines do not have a restore file: {}'.format(machines_without_restore)) response = raw_input('Would you like to continue? [y/N] ') if (response not in ['Y', 'y']): return for db_ip in db_ips: logging.info('Stopping Cassandra on {}'.format(db_ip)) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries = SERVICE_RETRIES while (status != MonitStates.UNMONITORED): appscale_utils.ssh(db_ip, keyname, 'monit stop {}'.format(CASSANDRA_MONIT_WATCH_NAME), method=subprocess.call) time.sleep(3) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries -= 1 if (retries < 0): raise BRException('Unable to stop Cassandra') cassandra_dir = '{}/cassandra'.format(APPSCALE_DATA_DIR) for db_ip in db_ips: logging.info('Restoring Cassandra data on {}'.format(db_ip)) clear_db = 'find {0} -regex ".*\\.\\(db\\|txt\\|log\\)$" -exec rm {{}} \\;'.format(cassandra_dir) appscale_utils.ssh(db_ip, keyname, clear_db) if (db_ip not in machines_without_restore): appscale_utils.ssh(db_ip, keyname, 'tar xf {} -C {}'.format(path, cassandra_dir)) appscale_utils.ssh(db_ip, keyname, 'chown -R cassandra {}'.format(cassandra_dir)) logging.info('Starting Cassandra on {}'.format(db_ip)) retries = SERVICE_RETRIES status = MonitStates.UNMONITORED while (status != MonitStates.RUNNING): appscale_utils.ssh(db_ip, keyname, 'monit start {}'.format(CASSANDRA_MONIT_WATCH_NAME), method=subprocess.call) time.sleep(3) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries -= 1 if (retries < 0): raise BRException('Unable to start Cassandra') appscale_utils.ssh(db_ip, keyname, 'monit start {}'.format(CASSANDRA_MONIT_WATCH_NAME)) logging.info('Waiting for Cassandra cluster to be ready') db_ip = db_ips[0] deadline = (time.time() + SCHEMA_CHANGE_TIMEOUT) while True: ready = True try: output = appscale_utils.ssh(db_ip, keyname, '{} status'.format(NODE_TOOL), method=subprocess.check_output) nodes_ready = len([line for line in output.split('\n') if line.startswith('UN')]) if (nodes_ready < len(db_ips)): ready = False except CalledProcessError: ready = False if ready: break if (time.time() > deadline): logging.warning('Cassandra cluster still not ready.') break time.sleep(3) logging.info('Done with db restore.')
def restore_data(path, keyname, force=False): " Restores the Cassandra backup.\n\n Args:\n path: A string containing the location on each of the DB machines to use\n for restoring data.\n keyname: A string containing the deployment's keyname.\n Raises:\n BRException if unable to find any Cassandra machines or if DB machine has\n insufficient space.\n " logging.info('Starting new db restore.') db_ips = appscale_info.get_db_ips() if (not db_ips): raise BRException('Unable to find any Cassandra machines.') machines_without_restore = [] for db_ip in db_ips: exit_code = appscale_utils.ssh(db_ip, keyname, 'ls {}'.format(path), method=subprocess.call) if (exit_code != ExitCodes.SUCCESS): machines_without_restore.append(db_ip) if (machines_without_restore and (not force)): logging.info('The following machines do not have a restore file: {}'.format(machines_without_restore)) response = raw_input('Would you like to continue? [y/N] ') if (response not in ['Y', 'y']): return for db_ip in db_ips: logging.info('Stopping Cassandra on {}'.format(db_ip)) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries = SERVICE_RETRIES while (status != MonitStates.UNMONITORED): appscale_utils.ssh(db_ip, keyname, 'monit stop {}'.format(CASSANDRA_MONIT_WATCH_NAME), method=subprocess.call) time.sleep(3) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries -= 1 if (retries < 0): raise BRException('Unable to stop Cassandra') cassandra_dir = '{}/cassandra'.format(APPSCALE_DATA_DIR) for db_ip in db_ips: logging.info('Restoring Cassandra data on {}'.format(db_ip)) clear_db = 'find {0} -regex ".*\\.\\(db\\|txt\\|log\\)$" -exec rm {{}} \\;'.format(cassandra_dir) appscale_utils.ssh(db_ip, keyname, clear_db) if (db_ip not in machines_without_restore): appscale_utils.ssh(db_ip, keyname, 'tar xf {} -C {}'.format(path, cassandra_dir)) appscale_utils.ssh(db_ip, keyname, 'chown -R cassandra {}'.format(cassandra_dir)) logging.info('Starting Cassandra on {}'.format(db_ip)) retries = SERVICE_RETRIES status = MonitStates.UNMONITORED while (status != MonitStates.RUNNING): appscale_utils.ssh(db_ip, keyname, 'monit start {}'.format(CASSANDRA_MONIT_WATCH_NAME), method=subprocess.call) time.sleep(3) summary = appscale_utils.ssh(db_ip, keyname, 'monit summary', method=subprocess.check_output) status = utils.monit_status(summary, CASSANDRA_MONIT_WATCH_NAME) retries -= 1 if (retries < 0): raise BRException('Unable to start Cassandra') appscale_utils.ssh(db_ip, keyname, 'monit start {}'.format(CASSANDRA_MONIT_WATCH_NAME)) logging.info('Waiting for Cassandra cluster to be ready') db_ip = db_ips[0] deadline = (time.time() + SCHEMA_CHANGE_TIMEOUT) while True: ready = True try: output = appscale_utils.ssh(db_ip, keyname, '{} status'.format(NODE_TOOL), method=subprocess.check_output) nodes_ready = len([line for line in output.split('\n') if line.startswith('UN')]) if (nodes_ready < len(db_ips)): ready = False except CalledProcessError: ready = False if ready: break if (time.time() > deadline): logging.warning('Cassandra cluster still not ready.') break time.sleep(3) logging.info('Done with db restore.')<|docstring|>Restores the Cassandra backup. Args: path: A string containing the location on each of the DB machines to use for restoring data. keyname: A string containing the deployment's keyname. Raises: BRException if unable to find any Cassandra machines or if DB machine has insufficient space.<|endoftext|>
0ad9e745a629a3ed6335f4b188b8e5f8a4d97f48fe0850d40835c244ff13c064
def save_figure_array(figarr, f): 'save array representing colored figure (produced by figure2array) to file' Image.fromarray(figarr[0]).save(f)
save array representing colored figure (produced by figure2array) to file
MC simulation/mcdose/mcdose/visualize.py
save_figure_array
qihuilyu/P2T
0
python
def save_figure_array(figarr, f): Image.fromarray(figarr[0]).save(f)
def save_figure_array(figarr, f): Image.fromarray(figarr[0]).save(f)<|docstring|>save array representing colored figure (produced by figure2array) to file<|endoftext|>
ac7e228af34dd9e420f3153e85378d44bc0a0ae14fa9de7bf1eac1c74be94c4e
def create_volume_dose_figure(arr, col_labels=[], dpi=FIG_DPI, cmap='viridis', own_scale=False, return_fig=False, ndiff_cols=1): 'create figure of axes rows mapped to each slice in numpy array [Rows, Cols, H, W]\n with each row containing imshow() instances with matched value limits (vmin, vmax) according\n to data (min, max)\n ' (nrows, ncols, H, W) = arr.shape axwidth_inches = 1.25 width_ratios = (([1.0] * ncols) + ([0.25] * 2)) figwidth = (axwidth_inches * np.sum(width_ratios)) figheight = ((((axwidth_inches / W) * H) * nrows) / 0.98) fig = plt.figure(figsize=(figwidth, figheight), dpi=dpi) spec = gridspec.GridSpec(nrows=nrows, ncols=(ncols + 2), width_ratios=width_ratios, wspace=0, hspace=0, left=0.0, right=1.0, bottom=0.0, top=0.98, figure=fig) annotate_fontsize = 5 annotate_margin = 0.03 row_minmax = [] row_diff_absmax = [] for row in range(nrows): rowarr = arr[row] if (ndiff_cols > 0): (vmin, vmax) = (np.amin(rowarr[:(- ndiff_cols)]), np.amax(rowarr[:(- ndiff_cols)])) (diffmin, diffmax) = (np.amin(rowarr[(- ndiff_cols):]), np.amax(rowarr[(- ndiff_cols):])) diffabsmax = max(abs(diffmin), abs(diffmax)) row_diff_absmax.append(diffabsmax) else: (vmin, vmax) = (np.amin(rowarr), np.amax(rowarr)) row_minmax.append((vmin, vmax)) for col in range(ncols): if (col >= (ncols - ndiff_cols)): this_norm = colors.Normalize(vmin=(- diffabsmax), vmax=diffabsmax) this_cmap = 'RdBu_r' this_fontcolor = 'black' else: this_norm = colors.Normalize(vmin=vmin, vmax=vmax) this_cmap = cmap this_fontcolor = 'white' cellarr = rowarr[col] ax = fig.add_subplot(spec[(row, col)]) ax.set_xticks([]) ax.set_yticks([]) ax.imshow(cellarr, interpolation='none', aspect='equal', cmap=this_cmap, norm=(this_norm if (not own_scale) else None)) margin = 0.03 fmt = '{:0.2f}' (cellmin, cellmax) = (np.amin(cellarr), np.amax(cellarr)) ax.text(margin, (1.0 - margin), fmt.format(cellmax), fontsize=annotate_fontsize, color=this_fontcolor, horizontalalignment='left', verticalalignment='top', transform=ax.transAxes) ax.text(margin, margin, fmt.format(cellmin), fontsize=annotate_fontsize, color=this_fontcolor, horizontalalignment='left', verticalalignment='bottom', transform=ax.transAxes) if ((row == 0) and (col < len(col_labels))): ax.text(0.5, 1.01, col_labels[col], horizontalalignment='center', verticalalignment='bottom', transform=ax.transAxes) cbar_ax = fig.add_subplot(spec[(:, (- 2))]) fig.colorbar(cm.ScalarMappable(norm=colors.Normalize(vmin=0, vmax=1), cmap='viridis'), cax=cbar_ax, ticks=[]) if (ndiff_cols > 0): cbar_ax2 = fig.add_subplot(spec[(:, (- 1))]) fig.colorbar(cm.ScalarMappable(norm=colors.Normalize(vmin=(- 1), vmax=1), cmap='RdBu_r'), cax=cbar_ax2, ticks=[]) for row in range(nrows): ypos_high = (1.0 - (float((row + margin)) / nrows)) ypos_low = (1.0 - (float(((row + 1) - margin)) / nrows)) (row_min, row_max) = row_minmax[row] cbar_ax.text(0.5, ypos_high, '{:0.2f}'.format(row_max), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='top', transform=cbar_ax.transAxes) cbar_ax.text(0.5, ypos_low, '{:0.2f}'.format(row_min), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='bottom', transform=cbar_ax.transAxes) if (ndiff_cols > 0): row_diffabsmax = row_diff_absmax[row] cbar_ax2.text(0.5, ypos_high, '{:0.2f}'.format(row_diffabsmax), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='top', transform=cbar_ax2.transAxes) cbar_ax2.text(0.5, ypos_low, '{:0.2f}'.format((- row_diffabsmax)), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='bottom', transform=cbar_ax2.transAxes) if return_fig: return fig else: return figure2array(fig)
create figure of axes rows mapped to each slice in numpy array [Rows, Cols, H, W] with each row containing imshow() instances with matched value limits (vmin, vmax) according to data (min, max)
MC simulation/mcdose/mcdose/visualize.py
create_volume_dose_figure
qihuilyu/P2T
0
python
def create_volume_dose_figure(arr, col_labels=[], dpi=FIG_DPI, cmap='viridis', own_scale=False, return_fig=False, ndiff_cols=1): 'create figure of axes rows mapped to each slice in numpy array [Rows, Cols, H, W]\n with each row containing imshow() instances with matched value limits (vmin, vmax) according\n to data (min, max)\n ' (nrows, ncols, H, W) = arr.shape axwidth_inches = 1.25 width_ratios = (([1.0] * ncols) + ([0.25] * 2)) figwidth = (axwidth_inches * np.sum(width_ratios)) figheight = ((((axwidth_inches / W) * H) * nrows) / 0.98) fig = plt.figure(figsize=(figwidth, figheight), dpi=dpi) spec = gridspec.GridSpec(nrows=nrows, ncols=(ncols + 2), width_ratios=width_ratios, wspace=0, hspace=0, left=0.0, right=1.0, bottom=0.0, top=0.98, figure=fig) annotate_fontsize = 5 annotate_margin = 0.03 row_minmax = [] row_diff_absmax = [] for row in range(nrows): rowarr = arr[row] if (ndiff_cols > 0): (vmin, vmax) = (np.amin(rowarr[:(- ndiff_cols)]), np.amax(rowarr[:(- ndiff_cols)])) (diffmin, diffmax) = (np.amin(rowarr[(- ndiff_cols):]), np.amax(rowarr[(- ndiff_cols):])) diffabsmax = max(abs(diffmin), abs(diffmax)) row_diff_absmax.append(diffabsmax) else: (vmin, vmax) = (np.amin(rowarr), np.amax(rowarr)) row_minmax.append((vmin, vmax)) for col in range(ncols): if (col >= (ncols - ndiff_cols)): this_norm = colors.Normalize(vmin=(- diffabsmax), vmax=diffabsmax) this_cmap = 'RdBu_r' this_fontcolor = 'black' else: this_norm = colors.Normalize(vmin=vmin, vmax=vmax) this_cmap = cmap this_fontcolor = 'white' cellarr = rowarr[col] ax = fig.add_subplot(spec[(row, col)]) ax.set_xticks([]) ax.set_yticks([]) ax.imshow(cellarr, interpolation='none', aspect='equal', cmap=this_cmap, norm=(this_norm if (not own_scale) else None)) margin = 0.03 fmt = '{:0.2f}' (cellmin, cellmax) = (np.amin(cellarr), np.amax(cellarr)) ax.text(margin, (1.0 - margin), fmt.format(cellmax), fontsize=annotate_fontsize, color=this_fontcolor, horizontalalignment='left', verticalalignment='top', transform=ax.transAxes) ax.text(margin, margin, fmt.format(cellmin), fontsize=annotate_fontsize, color=this_fontcolor, horizontalalignment='left', verticalalignment='bottom', transform=ax.transAxes) if ((row == 0) and (col < len(col_labels))): ax.text(0.5, 1.01, col_labels[col], horizontalalignment='center', verticalalignment='bottom', transform=ax.transAxes) cbar_ax = fig.add_subplot(spec[(:, (- 2))]) fig.colorbar(cm.ScalarMappable(norm=colors.Normalize(vmin=0, vmax=1), cmap='viridis'), cax=cbar_ax, ticks=[]) if (ndiff_cols > 0): cbar_ax2 = fig.add_subplot(spec[(:, (- 1))]) fig.colorbar(cm.ScalarMappable(norm=colors.Normalize(vmin=(- 1), vmax=1), cmap='RdBu_r'), cax=cbar_ax2, ticks=[]) for row in range(nrows): ypos_high = (1.0 - (float((row + margin)) / nrows)) ypos_low = (1.0 - (float(((row + 1) - margin)) / nrows)) (row_min, row_max) = row_minmax[row] cbar_ax.text(0.5, ypos_high, '{:0.2f}'.format(row_max), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='top', transform=cbar_ax.transAxes) cbar_ax.text(0.5, ypos_low, '{:0.2f}'.format(row_min), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='bottom', transform=cbar_ax.transAxes) if (ndiff_cols > 0): row_diffabsmax = row_diff_absmax[row] cbar_ax2.text(0.5, ypos_high, '{:0.2f}'.format(row_diffabsmax), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='top', transform=cbar_ax2.transAxes) cbar_ax2.text(0.5, ypos_low, '{:0.2f}'.format((- row_diffabsmax)), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='bottom', transform=cbar_ax2.transAxes) if return_fig: return fig else: return figure2array(fig)
def create_volume_dose_figure(arr, col_labels=[], dpi=FIG_DPI, cmap='viridis', own_scale=False, return_fig=False, ndiff_cols=1): 'create figure of axes rows mapped to each slice in numpy array [Rows, Cols, H, W]\n with each row containing imshow() instances with matched value limits (vmin, vmax) according\n to data (min, max)\n ' (nrows, ncols, H, W) = arr.shape axwidth_inches = 1.25 width_ratios = (([1.0] * ncols) + ([0.25] * 2)) figwidth = (axwidth_inches * np.sum(width_ratios)) figheight = ((((axwidth_inches / W) * H) * nrows) / 0.98) fig = plt.figure(figsize=(figwidth, figheight), dpi=dpi) spec = gridspec.GridSpec(nrows=nrows, ncols=(ncols + 2), width_ratios=width_ratios, wspace=0, hspace=0, left=0.0, right=1.0, bottom=0.0, top=0.98, figure=fig) annotate_fontsize = 5 annotate_margin = 0.03 row_minmax = [] row_diff_absmax = [] for row in range(nrows): rowarr = arr[row] if (ndiff_cols > 0): (vmin, vmax) = (np.amin(rowarr[:(- ndiff_cols)]), np.amax(rowarr[:(- ndiff_cols)])) (diffmin, diffmax) = (np.amin(rowarr[(- ndiff_cols):]), np.amax(rowarr[(- ndiff_cols):])) diffabsmax = max(abs(diffmin), abs(diffmax)) row_diff_absmax.append(diffabsmax) else: (vmin, vmax) = (np.amin(rowarr), np.amax(rowarr)) row_minmax.append((vmin, vmax)) for col in range(ncols): if (col >= (ncols - ndiff_cols)): this_norm = colors.Normalize(vmin=(- diffabsmax), vmax=diffabsmax) this_cmap = 'RdBu_r' this_fontcolor = 'black' else: this_norm = colors.Normalize(vmin=vmin, vmax=vmax) this_cmap = cmap this_fontcolor = 'white' cellarr = rowarr[col] ax = fig.add_subplot(spec[(row, col)]) ax.set_xticks([]) ax.set_yticks([]) ax.imshow(cellarr, interpolation='none', aspect='equal', cmap=this_cmap, norm=(this_norm if (not own_scale) else None)) margin = 0.03 fmt = '{:0.2f}' (cellmin, cellmax) = (np.amin(cellarr), np.amax(cellarr)) ax.text(margin, (1.0 - margin), fmt.format(cellmax), fontsize=annotate_fontsize, color=this_fontcolor, horizontalalignment='left', verticalalignment='top', transform=ax.transAxes) ax.text(margin, margin, fmt.format(cellmin), fontsize=annotate_fontsize, color=this_fontcolor, horizontalalignment='left', verticalalignment='bottom', transform=ax.transAxes) if ((row == 0) and (col < len(col_labels))): ax.text(0.5, 1.01, col_labels[col], horizontalalignment='center', verticalalignment='bottom', transform=ax.transAxes) cbar_ax = fig.add_subplot(spec[(:, (- 2))]) fig.colorbar(cm.ScalarMappable(norm=colors.Normalize(vmin=0, vmax=1), cmap='viridis'), cax=cbar_ax, ticks=[]) if (ndiff_cols > 0): cbar_ax2 = fig.add_subplot(spec[(:, (- 1))]) fig.colorbar(cm.ScalarMappable(norm=colors.Normalize(vmin=(- 1), vmax=1), cmap='RdBu_r'), cax=cbar_ax2, ticks=[]) for row in range(nrows): ypos_high = (1.0 - (float((row + margin)) / nrows)) ypos_low = (1.0 - (float(((row + 1) - margin)) / nrows)) (row_min, row_max) = row_minmax[row] cbar_ax.text(0.5, ypos_high, '{:0.2f}'.format(row_max), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='top', transform=cbar_ax.transAxes) cbar_ax.text(0.5, ypos_low, '{:0.2f}'.format(row_min), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='bottom', transform=cbar_ax.transAxes) if (ndiff_cols > 0): row_diffabsmax = row_diff_absmax[row] cbar_ax2.text(0.5, ypos_high, '{:0.2f}'.format(row_diffabsmax), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='top', transform=cbar_ax2.transAxes) cbar_ax2.text(0.5, ypos_low, '{:0.2f}'.format((- row_diffabsmax)), fontsize=annotate_fontsize, horizontalalignment='center', verticalalignment='bottom', transform=cbar_ax2.transAxes) if return_fig: return fig else: return figure2array(fig)<|docstring|>create figure of axes rows mapped to each slice in numpy array [Rows, Cols, H, W] with each row containing imshow() instances with matched value limits (vmin, vmax) according to data (min, max)<|endoftext|>
d171085426402c5b89bdce4b65eeb79d5c7d6e31a2748d97506464d92e73ac2a
def make_image_figure(colorbar=True, dpi=FIG_DPI): 'makes standard figure with large imshow axes and colorbar to right' fig = plt.figure(dpi=dpi) if colorbar: ax_im = fig.add_axes([0, 0, 0.87, 1.0]) ax_cbar = fig.add_axes([0.89, 0.05, 0.04, 0.9]) else: ax_im = fig.add_axes([0, 0, 1.0, 1.0]) ax_cbar = None return (fig, ax_im, ax_cbar)
makes standard figure with large imshow axes and colorbar to right
MC simulation/mcdose/mcdose/visualize.py
make_image_figure
qihuilyu/P2T
0
python
def make_image_figure(colorbar=True, dpi=FIG_DPI): fig = plt.figure(dpi=dpi) if colorbar: ax_im = fig.add_axes([0, 0, 0.87, 1.0]) ax_cbar = fig.add_axes([0.89, 0.05, 0.04, 0.9]) else: ax_im = fig.add_axes([0, 0, 1.0, 1.0]) ax_cbar = None return (fig, ax_im, ax_cbar)
def make_image_figure(colorbar=True, dpi=FIG_DPI): fig = plt.figure(dpi=dpi) if colorbar: ax_im = fig.add_axes([0, 0, 0.87, 1.0]) ax_cbar = fig.add_axes([0.89, 0.05, 0.04, 0.9]) else: ax_im = fig.add_axes([0, 0, 1.0, 1.0]) ax_cbar = None return (fig, ax_im, ax_cbar)<|docstring|>makes standard figure with large imshow axes and colorbar to right<|endoftext|>
5120693bc549135756e069bb3d51d7409995847d42fd6e3e285573333982d809
def plot_dose(*args, colorbar=True, dpi=FIG_DPI, **kwargs): 'See _plot_gamma_components for function signature' (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_dose(ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)
See _plot_gamma_components for function signature
MC simulation/mcdose/mcdose/visualize.py
plot_dose
qihuilyu/P2T
0
python
def plot_dose(*args, colorbar=True, dpi=FIG_DPI, **kwargs): (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_dose(ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)
def plot_dose(*args, colorbar=True, dpi=FIG_DPI, **kwargs): (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_dose(ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)<|docstring|>See _plot_gamma_components for function signature<|endoftext|>
3533a0b49e5bf5453e1e251aeb8695a80604c6f7c841803a6ec3a2e1447e27cc
def _plot_dose(ax_im, ax_cbar, arr, **kwargs): 'plots array using imshow with colorbar then converts back to png compatible rgb array' kwargs['cmap'] = kwargs.get('cmap', 'viridis') im = ax_im.imshow(arr, interpolation='nearest', **kwargs) ax_im.set_axis_off() if (ax_cbar is not None): plt.colorbar(im, ax_cbar) return (ax_im, ax_cbar)
plots array using imshow with colorbar then converts back to png compatible rgb array
MC simulation/mcdose/mcdose/visualize.py
_plot_dose
qihuilyu/P2T
0
python
def _plot_dose(ax_im, ax_cbar, arr, **kwargs): kwargs['cmap'] = kwargs.get('cmap', 'viridis') im = ax_im.imshow(arr, interpolation='nearest', **kwargs) ax_im.set_axis_off() if (ax_cbar is not None): plt.colorbar(im, ax_cbar) return (ax_im, ax_cbar)
def _plot_dose(ax_im, ax_cbar, arr, **kwargs): kwargs['cmap'] = kwargs.get('cmap', 'viridis') im = ax_im.imshow(arr, interpolation='nearest', **kwargs) ax_im.set_axis_off() if (ax_cbar is not None): plt.colorbar(im, ax_cbar) return (ax_im, ax_cbar)<|docstring|>plots array using imshow with colorbar then converts back to png compatible rgb array<|endoftext|>
7fdc80fc34baeba640820792787b32e00fe64bad154244b3feb1458274948c8c
def plot_gamma(*args, colorbar=True, dpi=FIG_DPI, **kwargs): 'See _plot_gamma_components for function signature' (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_gamma(fig, ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)
See _plot_gamma_components for function signature
MC simulation/mcdose/mcdose/visualize.py
plot_gamma
qihuilyu/P2T
0
python
def plot_gamma(*args, colorbar=True, dpi=FIG_DPI, **kwargs): (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_gamma(fig, ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)
def plot_gamma(*args, colorbar=True, dpi=FIG_DPI, **kwargs): (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_gamma(fig, ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)<|docstring|>See _plot_gamma_components for function signature<|endoftext|>
28a3d986a731d3a604b82efb40aa58ac3224cb27f72d182ec8eb67d97e64af59
def _plot_gamma(fig, ax_im, ax_cbar, arr, annotate=None, **kwargs): 'plots array using imshow with colorbar then converts back to png compatible rgb array' ignored_cmap = get_ignored_cmap() im = ax_im.imshow(arr, cmap='RdBu_r', interpolation='nearest', norm=MidpointNormalize(0, 10, 1), **kwargs) im1 = masked_array(arr, (arr >= 0)) ax_im.imshow(im1, cmap=ignored_cmap, interpolation='nearest') ax_im.set_axis_off() if (ax_cbar is not None): plt.colorbar(im, ax_cbar) if annotate: ax_im.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return (ax_im, ax_cbar)
plots array using imshow with colorbar then converts back to png compatible rgb array
MC simulation/mcdose/mcdose/visualize.py
_plot_gamma
qihuilyu/P2T
0
python
def _plot_gamma(fig, ax_im, ax_cbar, arr, annotate=None, **kwargs): ignored_cmap = get_ignored_cmap() im = ax_im.imshow(arr, cmap='RdBu_r', interpolation='nearest', norm=MidpointNormalize(0, 10, 1), **kwargs) im1 = masked_array(arr, (arr >= 0)) ax_im.imshow(im1, cmap=ignored_cmap, interpolation='nearest') ax_im.set_axis_off() if (ax_cbar is not None): plt.colorbar(im, ax_cbar) if annotate: ax_im.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return (ax_im, ax_cbar)
def _plot_gamma(fig, ax_im, ax_cbar, arr, annotate=None, **kwargs): ignored_cmap = get_ignored_cmap() im = ax_im.imshow(arr, cmap='RdBu_r', interpolation='nearest', norm=MidpointNormalize(0, 10, 1), **kwargs) im1 = masked_array(arr, (arr >= 0)) ax_im.imshow(im1, cmap=ignored_cmap, interpolation='nearest') ax_im.set_axis_off() if (ax_cbar is not None): plt.colorbar(im, ax_cbar) if annotate: ax_im.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return (ax_im, ax_cbar)<|docstring|>plots array using imshow with colorbar then converts back to png compatible rgb array<|endoftext|>
82d495d4b94ba5e0b5148f5722fcbc469f5c180cbd5f60ca8f6fe7c296430b2d
def plot_gamma_components(*args, colorbar=True, dpi=FIG_DPI, **kwargs): 'See _plot_gamma_components for function signature' (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_gamma_components(fig, ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)
See _plot_gamma_components for function signature
MC simulation/mcdose/mcdose/visualize.py
plot_gamma_components
qihuilyu/P2T
0
python
def plot_gamma_components(*args, colorbar=True, dpi=FIG_DPI, **kwargs): (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_gamma_components(fig, ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)
def plot_gamma_components(*args, colorbar=True, dpi=FIG_DPI, **kwargs): (fig, ax_im, ax_cbar) = make_image_figure(colorbar, dpi) _plot_gamma_components(fig, ax_im, ax_cbar, *args, **kwargs) return figure2array(fig)<|docstring|>See _plot_gamma_components for function signature<|endoftext|>
62c6f0171e87aa63569dd2bce3ff0a70e4aeedd4e6ec8d0108cd0ee779b2b3f1
def _plot_gamma_components(fig, ax_im, ax_cbar, arr_dd, arr_dta, annotate=None, array_spacing=2, **kwargs): 'plots array using imshow with colorbar then converts back to png compatible rgb array' ignored_cmap = get_ignored_cmap() arr = np.concatenate([arr_dd, ((- 1) * np.ones((arr_dd.shape[0], array_spacing))), arr_dta], axis=1) im = ax_im.imshow(arr, cmap='RdBu_r', interpolation='nearest', norm=MidpointNormalize(0, 10, 1), **kwargs) im1 = masked_array(arr, (arr >= 0)) ax_im.imshow(im1, cmap=ignored_cmap, interpolation='nearest') ax_im.set_axis_off() try: dd_passing = ((np.count_nonzero((arr_dd <= 1)) - np.count_nonzero((arr_dd < 0))) / np.count_nonzero((arr_dd >= 0))) except: dd_passing = np.nan ax_im.text(0.02, 0.02, 'dd: {:0.2f}%'.format((dd_passing * 100)), fontsize=9, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=ax_im.transAxes) try: dta_passing = ((np.count_nonzero((arr_dta <= 1)) - np.count_nonzero((arr_dta < 0))) / np.count_nonzero((arr_dta >= 0))) except: dta_passing = np.nan ax_im.text(0.52, 0.02, 'dta: {:0.2f}%'.format((dta_passing * 100)), fontsize=9, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=ax_im.transAxes) if (ax_cbar is not None): plt.colorbar(im, ax_cbar) if annotate: ax_im.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return (ax_im, ax_cbar)
plots array using imshow with colorbar then converts back to png compatible rgb array
MC simulation/mcdose/mcdose/visualize.py
_plot_gamma_components
qihuilyu/P2T
0
python
def _plot_gamma_components(fig, ax_im, ax_cbar, arr_dd, arr_dta, annotate=None, array_spacing=2, **kwargs): ignored_cmap = get_ignored_cmap() arr = np.concatenate([arr_dd, ((- 1) * np.ones((arr_dd.shape[0], array_spacing))), arr_dta], axis=1) im = ax_im.imshow(arr, cmap='RdBu_r', interpolation='nearest', norm=MidpointNormalize(0, 10, 1), **kwargs) im1 = masked_array(arr, (arr >= 0)) ax_im.imshow(im1, cmap=ignored_cmap, interpolation='nearest') ax_im.set_axis_off() try: dd_passing = ((np.count_nonzero((arr_dd <= 1)) - np.count_nonzero((arr_dd < 0))) / np.count_nonzero((arr_dd >= 0))) except: dd_passing = np.nan ax_im.text(0.02, 0.02, 'dd: {:0.2f}%'.format((dd_passing * 100)), fontsize=9, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=ax_im.transAxes) try: dta_passing = ((np.count_nonzero((arr_dta <= 1)) - np.count_nonzero((arr_dta < 0))) / np.count_nonzero((arr_dta >= 0))) except: dta_passing = np.nan ax_im.text(0.52, 0.02, 'dta: {:0.2f}%'.format((dta_passing * 100)), fontsize=9, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=ax_im.transAxes) if (ax_cbar is not None): plt.colorbar(im, ax_cbar) if annotate: ax_im.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return (ax_im, ax_cbar)
def _plot_gamma_components(fig, ax_im, ax_cbar, arr_dd, arr_dta, annotate=None, array_spacing=2, **kwargs): ignored_cmap = get_ignored_cmap() arr = np.concatenate([arr_dd, ((- 1) * np.ones((arr_dd.shape[0], array_spacing))), arr_dta], axis=1) im = ax_im.imshow(arr, cmap='RdBu_r', interpolation='nearest', norm=MidpointNormalize(0, 10, 1), **kwargs) im1 = masked_array(arr, (arr >= 0)) ax_im.imshow(im1, cmap=ignored_cmap, interpolation='nearest') ax_im.set_axis_off() try: dd_passing = ((np.count_nonzero((arr_dd <= 1)) - np.count_nonzero((arr_dd < 0))) / np.count_nonzero((arr_dd >= 0))) except: dd_passing = np.nan ax_im.text(0.02, 0.02, 'dd: {:0.2f}%'.format((dd_passing * 100)), fontsize=9, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=ax_im.transAxes) try: dta_passing = ((np.count_nonzero((arr_dta <= 1)) - np.count_nonzero((arr_dta < 0))) / np.count_nonzero((arr_dta >= 0))) except: dta_passing = np.nan ax_im.text(0.52, 0.02, 'dta: {:0.2f}%'.format((dta_passing * 100)), fontsize=9, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=ax_im.transAxes) if (ax_cbar is not None): plt.colorbar(im, ax_cbar) if annotate: ax_im.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return (ax_im, ax_cbar)<|docstring|>plots array using imshow with colorbar then converts back to png compatible rgb array<|endoftext|>
9669ad04f44b5f800d4da52351263284a1f4f01f193ef823533048a8ba51ecfd
def plot_profile(arr_pred, arr_true=None, annotate=None, dpi=FIG_DPI, **kwargs): 'plots line profiles at various depths then converts back to png compatible rgb array' idx = [0.1, 0.3, 0.5, 0.7, 0.9] color = ['green', 'red', 'yellow', 'skyblue', 'blue'] fig = plt.figure(dpi=dpi) ax = fig.add_subplot(1, 1, 1) x_axis = [i for i in range(arr_pred.shape[1])] for j in range(len(idx)): sliceidx = int((idx[j] * arr_pred.shape[0])) dose_pred = arr_pred[(sliceidx, :)].tolist() ax.plot(x_axis, dose_pred, color[j], label=('profile_at_%d_pixel' % sliceidx), **kwargs) if (arr_true is not None): dose_true = arr_true[(sliceidx, :)].tolist() ax.plot(x_axis, dose_true, color[j], linestyle=':', label=None, **kwargs) plt.legend() ax.set_ylabel('dose') if annotate: ax.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return figure2array(fig)
plots line profiles at various depths then converts back to png compatible rgb array
MC simulation/mcdose/mcdose/visualize.py
plot_profile
qihuilyu/P2T
0
python
def plot_profile(arr_pred, arr_true=None, annotate=None, dpi=FIG_DPI, **kwargs): idx = [0.1, 0.3, 0.5, 0.7, 0.9] color = ['green', 'red', 'yellow', 'skyblue', 'blue'] fig = plt.figure(dpi=dpi) ax = fig.add_subplot(1, 1, 1) x_axis = [i for i in range(arr_pred.shape[1])] for j in range(len(idx)): sliceidx = int((idx[j] * arr_pred.shape[0])) dose_pred = arr_pred[(sliceidx, :)].tolist() ax.plot(x_axis, dose_pred, color[j], label=('profile_at_%d_pixel' % sliceidx), **kwargs) if (arr_true is not None): dose_true = arr_true[(sliceidx, :)].tolist() ax.plot(x_axis, dose_true, color[j], linestyle=':', label=None, **kwargs) plt.legend() ax.set_ylabel('dose') if annotate: ax.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return figure2array(fig)
def plot_profile(arr_pred, arr_true=None, annotate=None, dpi=FIG_DPI, **kwargs): idx = [0.1, 0.3, 0.5, 0.7, 0.9] color = ['green', 'red', 'yellow', 'skyblue', 'blue'] fig = plt.figure(dpi=dpi) ax = fig.add_subplot(1, 1, 1) x_axis = [i for i in range(arr_pred.shape[1])] for j in range(len(idx)): sliceidx = int((idx[j] * arr_pred.shape[0])) dose_pred = arr_pred[(sliceidx, :)].tolist() ax.plot(x_axis, dose_pred, color[j], label=('profile_at_%d_pixel' % sliceidx), **kwargs) if (arr_true is not None): dose_true = arr_true[(sliceidx, :)].tolist() ax.plot(x_axis, dose_true, color[j], linestyle=':', label=None, **kwargs) plt.legend() ax.set_ylabel('dose') if annotate: ax.text(0.02, 0.02, str(annotate), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='left', verticalalignment='bottom', transform=fig.transFigure) return figure2array(fig)<|docstring|>plots line profiles at various depths then converts back to png compatible rgb array<|endoftext|>
911d0591f331cf5c3c1f2f08adc94e0f00496c218769ffd09ce50bb275a1620d
def _plot_gamma_scatter(fig, ax, arr_dd, arr_dta, arr_gamma, dd_thresh, dta_thresh, **kwargs): 'place voxels on scatter-plot based on coordinates in dd-dta space' select = np.logical_and((arr_gamma >= 0), np.isfinite(arr_gamma)) dd_flat = ((np.ravel(arr_dd[select]) * dd_thresh) * 100) dta_flat = (np.ravel(arr_dta[select]) * dta_thresh) gamma_flat = np.ravel(arr_gamma[select]) scat = ax.scatter(dd_flat, dta_flat, s=4, marker='o', color='black') dd_max = np.max(dd_flat) dta_max = np.max(dta_flat) axis_buffer = 0.01 ax.set_xlim([((- axis_buffer) * dd_max), (dd_max + (axis_buffer * dd_max))]) ax.set_ylim([((- axis_buffer) * dta_max), (dta_max + (axis_buffer * dta_max))]) ax.set_xlabel('Percent dose difference') ax.set_ylabel('Distance to agreement (mm)') lineargs = {'linewidth': 1, 'linestyle': '-', 'color': 'black'} if (dd_max > (dd_thresh * 100)): ax.add_line(Line2D(ax.get_xlim(), [dta_thresh, dta_thresh], **lineargs)) if (dta_max > dta_thresh): ax.add_line(Line2D([(dd_thresh * 100), (dd_thresh * 100)], ax.get_ylim(), **lineargs)) try: gamma_passing = ((np.count_nonzero((arr_gamma <= 1)) - np.count_nonzero((arr_gamma < 0))) / np.count_nonzero((arr_gamma >= 0))) except: gamma_passing = np.nan try: dd_passing = ((np.count_nonzero((arr_dd <= 1)) - np.count_nonzero((arr_dd < 0))) / np.count_nonzero((arr_dd >= 0))) except: dd_passing = np.nan try: dta_passing = ((np.count_nonzero((arr_dta <= 1)) - np.count_nonzero((arr_dta < 0))) / np.count_nonzero((arr_dta >= 0))) except: dta_passing = np.nan nautofail = (np.count_nonzero(np.isinf(arr_gamma)) / np.count_nonzero((arr_gamma >= 0))) ax.text(1.0, 1.0, 'gamma: {:0.2f}%\ndd: {:0.2f}%\ndta: {:0.2f}%\ninf: {:0.2f}%'.format((gamma_passing * 100), (dd_passing * 100), (dta_passing * 100), (nautofail * 100)), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='right', verticalalignment='top', transform=ax.transAxes) return ax
place voxels on scatter-plot based on coordinates in dd-dta space
MC simulation/mcdose/mcdose/visualize.py
_plot_gamma_scatter
qihuilyu/P2T
0
python
def _plot_gamma_scatter(fig, ax, arr_dd, arr_dta, arr_gamma, dd_thresh, dta_thresh, **kwargs): select = np.logical_and((arr_gamma >= 0), np.isfinite(arr_gamma)) dd_flat = ((np.ravel(arr_dd[select]) * dd_thresh) * 100) dta_flat = (np.ravel(arr_dta[select]) * dta_thresh) gamma_flat = np.ravel(arr_gamma[select]) scat = ax.scatter(dd_flat, dta_flat, s=4, marker='o', color='black') dd_max = np.max(dd_flat) dta_max = np.max(dta_flat) axis_buffer = 0.01 ax.set_xlim([((- axis_buffer) * dd_max), (dd_max + (axis_buffer * dd_max))]) ax.set_ylim([((- axis_buffer) * dta_max), (dta_max + (axis_buffer * dta_max))]) ax.set_xlabel('Percent dose difference') ax.set_ylabel('Distance to agreement (mm)') lineargs = {'linewidth': 1, 'linestyle': '-', 'color': 'black'} if (dd_max > (dd_thresh * 100)): ax.add_line(Line2D(ax.get_xlim(), [dta_thresh, dta_thresh], **lineargs)) if (dta_max > dta_thresh): ax.add_line(Line2D([(dd_thresh * 100), (dd_thresh * 100)], ax.get_ylim(), **lineargs)) try: gamma_passing = ((np.count_nonzero((arr_gamma <= 1)) - np.count_nonzero((arr_gamma < 0))) / np.count_nonzero((arr_gamma >= 0))) except: gamma_passing = np.nan try: dd_passing = ((np.count_nonzero((arr_dd <= 1)) - np.count_nonzero((arr_dd < 0))) / np.count_nonzero((arr_dd >= 0))) except: dd_passing = np.nan try: dta_passing = ((np.count_nonzero((arr_dta <= 1)) - np.count_nonzero((arr_dta < 0))) / np.count_nonzero((arr_dta >= 0))) except: dta_passing = np.nan nautofail = (np.count_nonzero(np.isinf(arr_gamma)) / np.count_nonzero((arr_gamma >= 0))) ax.text(1.0, 1.0, 'gamma: {:0.2f}%\ndd: {:0.2f}%\ndta: {:0.2f}%\ninf: {:0.2f}%'.format((gamma_passing * 100), (dd_passing * 100), (dta_passing * 100), (nautofail * 100)), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='right', verticalalignment='top', transform=ax.transAxes) return ax
def _plot_gamma_scatter(fig, ax, arr_dd, arr_dta, arr_gamma, dd_thresh, dta_thresh, **kwargs): select = np.logical_and((arr_gamma >= 0), np.isfinite(arr_gamma)) dd_flat = ((np.ravel(arr_dd[select]) * dd_thresh) * 100) dta_flat = (np.ravel(arr_dta[select]) * dta_thresh) gamma_flat = np.ravel(arr_gamma[select]) scat = ax.scatter(dd_flat, dta_flat, s=4, marker='o', color='black') dd_max = np.max(dd_flat) dta_max = np.max(dta_flat) axis_buffer = 0.01 ax.set_xlim([((- axis_buffer) * dd_max), (dd_max + (axis_buffer * dd_max))]) ax.set_ylim([((- axis_buffer) * dta_max), (dta_max + (axis_buffer * dta_max))]) ax.set_xlabel('Percent dose difference') ax.set_ylabel('Distance to agreement (mm)') lineargs = {'linewidth': 1, 'linestyle': '-', 'color': 'black'} if (dd_max > (dd_thresh * 100)): ax.add_line(Line2D(ax.get_xlim(), [dta_thresh, dta_thresh], **lineargs)) if (dta_max > dta_thresh): ax.add_line(Line2D([(dd_thresh * 100), (dd_thresh * 100)], ax.get_ylim(), **lineargs)) try: gamma_passing = ((np.count_nonzero((arr_gamma <= 1)) - np.count_nonzero((arr_gamma < 0))) / np.count_nonzero((arr_gamma >= 0))) except: gamma_passing = np.nan try: dd_passing = ((np.count_nonzero((arr_dd <= 1)) - np.count_nonzero((arr_dd < 0))) / np.count_nonzero((arr_dd >= 0))) except: dd_passing = np.nan try: dta_passing = ((np.count_nonzero((arr_dta <= 1)) - np.count_nonzero((arr_dta < 0))) / np.count_nonzero((arr_dta >= 0))) except: dta_passing = np.nan nautofail = (np.count_nonzero(np.isinf(arr_gamma)) / np.count_nonzero((arr_gamma >= 0))) ax.text(1.0, 1.0, 'gamma: {:0.2f}%\ndd: {:0.2f}%\ndta: {:0.2f}%\ninf: {:0.2f}%'.format((gamma_passing * 100), (dd_passing * 100), (dta_passing * 100), (nautofail * 100)), fontsize=11, bbox={'facecolor': 'white', 'alpha': 1.0}, horizontalalignment='right', verticalalignment='top', transform=ax.transAxes) return ax<|docstring|>place voxels on scatter-plot based on coordinates in dd-dta space<|endoftext|>
3717d9429a5969b08ba50eea4b31efb3bb940aa62045ab757b4010fc0633535f
def register_custom_scalars_layout(writer): "define custom plotting in 'Custom Scalars' tab of TensorBoard" layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(category=[layout_pb2.Category(title='all', chart=[layout_pb2.Chart(title='loss', multiline=layout_pb2.MultilineChartContent(tag=['train/loss', 'eval/loss/test', 'eval/loss/train'])), layout_pb2.Chart(title='eval-avg_gammapass/0.1mm_0.1%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.1mm_0.1%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/0.2mm_0.2%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.2mm_0.2%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/0.5mm_0.5%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.5mm_0.5%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/1.0mm_1.0%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/1.0mm_1.0%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/2.0mm_2.0%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/2.0mm_2.0%/.*'])), layout_pb2.Chart(title='MSE', multiline=layout_pb2.MultilineChartContent(tag=['.*mse.*']))])])) writer.add_summary(layout_summary)
define custom plotting in 'Custom Scalars' tab of TensorBoard
MC simulation/mcdose/mcdose/visualize.py
register_custom_scalars_layout
qihuilyu/P2T
0
python
def register_custom_scalars_layout(writer): layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(category=[layout_pb2.Category(title='all', chart=[layout_pb2.Chart(title='loss', multiline=layout_pb2.MultilineChartContent(tag=['train/loss', 'eval/loss/test', 'eval/loss/train'])), layout_pb2.Chart(title='eval-avg_gammapass/0.1mm_0.1%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.1mm_0.1%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/0.2mm_0.2%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.2mm_0.2%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/0.5mm_0.5%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.5mm_0.5%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/1.0mm_1.0%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/1.0mm_1.0%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/2.0mm_2.0%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/2.0mm_2.0%/.*'])), layout_pb2.Chart(title='MSE', multiline=layout_pb2.MultilineChartContent(tag=['.*mse.*']))])])) writer.add_summary(layout_summary)
def register_custom_scalars_layout(writer): layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(category=[layout_pb2.Category(title='all', chart=[layout_pb2.Chart(title='loss', multiline=layout_pb2.MultilineChartContent(tag=['train/loss', 'eval/loss/test', 'eval/loss/train'])), layout_pb2.Chart(title='eval-avg_gammapass/0.1mm_0.1%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.1mm_0.1%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/0.2mm_0.2%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.2mm_0.2%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/0.5mm_0.5%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/0.5mm_0.5%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/1.0mm_1.0%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/1.0mm_1.0%/.*'])), layout_pb2.Chart(title='eval-avg_gammapass/2.0mm_2.0%', multiline=layout_pb2.MultilineChartContent(tag=['eval-avg_gammapass/2.0mm_2.0%/.*'])), layout_pb2.Chart(title='MSE', multiline=layout_pb2.MultilineChartContent(tag=['.*mse.*']))])])) writer.add_summary(layout_summary)<|docstring|>define custom plotting in 'Custom Scalars' tab of TensorBoard<|endoftext|>
ec7c09253b91e542651ea06cf80fa12afd4e979218d4d6666523d0fdfa449106
def tile(array_list, perrow, square=False, pad_width=5, pad_intensity=1000): 'Takes a list of arrays and number of images per row and constructs a tiled array for margin-less\n visualization\n\n Args:\n array_list -- list of np.ndarrays to be tiled in row-major order\n perrow -- integer specifying number of images per row\n\n Optional Args:\n square -- Try to make length and width equal by tiling vertical columns side-by-side\n pad_width -- # columns between vertical tiling columns\n pad_intensity -- # intensity value of padding cells\n\n Returns:\n numpy matrix/2dArray\n ' if (not isinstance(array_list, list)): array_list_old = array_list ndims = len(array_list_old.shape) if (ndims == 3): array_list = [] array_list_old_2dshape = (array_list_old.shape[1], array_list_old.shape[2]) for i in range(array_list_old.shape[0]): array_list.append(array_list_old[(i, :, :)].reshape(array_list_old_2dshape)) elif (ndims == 2): array_list = [array_list_old] nimages = len(array_list) expect_row_shape = (array_list[0].shape[0], (perrow * array_list[0].shape[1])) rows_list = [] this_row_array = None for i in range((nimages + 1)): if ((i % perrow) == 0): if (i > 0): rows_list.append(this_row_array) this_row_array = None if (i < nimages): this_row_array = array_list[i] else: this_row_array = np.concatenate((this_row_array, array_list[i]), axis=1) for (i, row) in enumerate(rows_list): if (row.shape != expect_row_shape): extra = np.zeros((expect_row_shape[0], (expect_row_shape[1] - row.shape[1]))) row = np.concatenate((row, extra), axis=1) rows_list[i] = row if square: if (pad_width >= 0): pad = pad_width else: pad = 0 if (pad_intensity <= 0): pad_intensity = 0 rows = (len(rows_list) * expect_row_shape[0]) cols = expect_row_shape[1] area = (rows * cols) pref_rows = math.ceil((math.sqrt(area) / expect_row_shape[0])) cols_list = [] this_col_array = [] for i in range((len(rows_list) + 1)): if (((i % pref_rows) == 0) or (i >= len(rows_list))): if (i > 0): cols_list.append(this_col_array) if (i >= len(rows_list)): break if ((pad > 0) and (i < (len(rows_list) - 1))): cols_list.append((pad_intensity * np.ones(((pref_rows * expect_row_shape[0]), pad)))) this_col_array = rows_list[i] else: this_col_array = np.concatenate((this_col_array, rows_list[i]), axis=0) for (i, col) in enumerate(cols_list): if (col.shape[0] != (pref_rows * expect_row_shape[0])): extra = np.zeros((((expect_row_shape[0] * pref_rows) - col.shape[0]), expect_row_shape[1])) row = np.concatenate((col, extra), axis=0) cols_list[i] = row tiled_array = np.concatenate(cols_list, axis=1) else: tiled_array = np.concatenate(rows_list, axis=0) return tiled_array
Takes a list of arrays and number of images per row and constructs a tiled array for margin-less visualization Args: array_list -- list of np.ndarrays to be tiled in row-major order perrow -- integer specifying number of images per row Optional Args: square -- Try to make length and width equal by tiling vertical columns side-by-side pad_width -- # columns between vertical tiling columns pad_intensity -- # intensity value of padding cells Returns: numpy matrix/2dArray
MC simulation/mcdose/mcdose/visualize.py
tile
qihuilyu/P2T
0
python
def tile(array_list, perrow, square=False, pad_width=5, pad_intensity=1000): 'Takes a list of arrays and number of images per row and constructs a tiled array for margin-less\n visualization\n\n Args:\n array_list -- list of np.ndarrays to be tiled in row-major order\n perrow -- integer specifying number of images per row\n\n Optional Args:\n square -- Try to make length and width equal by tiling vertical columns side-by-side\n pad_width -- # columns between vertical tiling columns\n pad_intensity -- # intensity value of padding cells\n\n Returns:\n numpy matrix/2dArray\n ' if (not isinstance(array_list, list)): array_list_old = array_list ndims = len(array_list_old.shape) if (ndims == 3): array_list = [] array_list_old_2dshape = (array_list_old.shape[1], array_list_old.shape[2]) for i in range(array_list_old.shape[0]): array_list.append(array_list_old[(i, :, :)].reshape(array_list_old_2dshape)) elif (ndims == 2): array_list = [array_list_old] nimages = len(array_list) expect_row_shape = (array_list[0].shape[0], (perrow * array_list[0].shape[1])) rows_list = [] this_row_array = None for i in range((nimages + 1)): if ((i % perrow) == 0): if (i > 0): rows_list.append(this_row_array) this_row_array = None if (i < nimages): this_row_array = array_list[i] else: this_row_array = np.concatenate((this_row_array, array_list[i]), axis=1) for (i, row) in enumerate(rows_list): if (row.shape != expect_row_shape): extra = np.zeros((expect_row_shape[0], (expect_row_shape[1] - row.shape[1]))) row = np.concatenate((row, extra), axis=1) rows_list[i] = row if square: if (pad_width >= 0): pad = pad_width else: pad = 0 if (pad_intensity <= 0): pad_intensity = 0 rows = (len(rows_list) * expect_row_shape[0]) cols = expect_row_shape[1] area = (rows * cols) pref_rows = math.ceil((math.sqrt(area) / expect_row_shape[0])) cols_list = [] this_col_array = [] for i in range((len(rows_list) + 1)): if (((i % pref_rows) == 0) or (i >= len(rows_list))): if (i > 0): cols_list.append(this_col_array) if (i >= len(rows_list)): break if ((pad > 0) and (i < (len(rows_list) - 1))): cols_list.append((pad_intensity * np.ones(((pref_rows * expect_row_shape[0]), pad)))) this_col_array = rows_list[i] else: this_col_array = np.concatenate((this_col_array, rows_list[i]), axis=0) for (i, col) in enumerate(cols_list): if (col.shape[0] != (pref_rows * expect_row_shape[0])): extra = np.zeros((((expect_row_shape[0] * pref_rows) - col.shape[0]), expect_row_shape[1])) row = np.concatenate((col, extra), axis=0) cols_list[i] = row tiled_array = np.concatenate(cols_list, axis=1) else: tiled_array = np.concatenate(rows_list, axis=0) return tiled_array
def tile(array_list, perrow, square=False, pad_width=5, pad_intensity=1000): 'Takes a list of arrays and number of images per row and constructs a tiled array for margin-less\n visualization\n\n Args:\n array_list -- list of np.ndarrays to be tiled in row-major order\n perrow -- integer specifying number of images per row\n\n Optional Args:\n square -- Try to make length and width equal by tiling vertical columns side-by-side\n pad_width -- # columns between vertical tiling columns\n pad_intensity -- # intensity value of padding cells\n\n Returns:\n numpy matrix/2dArray\n ' if (not isinstance(array_list, list)): array_list_old = array_list ndims = len(array_list_old.shape) if (ndims == 3): array_list = [] array_list_old_2dshape = (array_list_old.shape[1], array_list_old.shape[2]) for i in range(array_list_old.shape[0]): array_list.append(array_list_old[(i, :, :)].reshape(array_list_old_2dshape)) elif (ndims == 2): array_list = [array_list_old] nimages = len(array_list) expect_row_shape = (array_list[0].shape[0], (perrow * array_list[0].shape[1])) rows_list = [] this_row_array = None for i in range((nimages + 1)): if ((i % perrow) == 0): if (i > 0): rows_list.append(this_row_array) this_row_array = None if (i < nimages): this_row_array = array_list[i] else: this_row_array = np.concatenate((this_row_array, array_list[i]), axis=1) for (i, row) in enumerate(rows_list): if (row.shape != expect_row_shape): extra = np.zeros((expect_row_shape[0], (expect_row_shape[1] - row.shape[1]))) row = np.concatenate((row, extra), axis=1) rows_list[i] = row if square: if (pad_width >= 0): pad = pad_width else: pad = 0 if (pad_intensity <= 0): pad_intensity = 0 rows = (len(rows_list) * expect_row_shape[0]) cols = expect_row_shape[1] area = (rows * cols) pref_rows = math.ceil((math.sqrt(area) / expect_row_shape[0])) cols_list = [] this_col_array = [] for i in range((len(rows_list) + 1)): if (((i % pref_rows) == 0) or (i >= len(rows_list))): if (i > 0): cols_list.append(this_col_array) if (i >= len(rows_list)): break if ((pad > 0) and (i < (len(rows_list) - 1))): cols_list.append((pad_intensity * np.ones(((pref_rows * expect_row_shape[0]), pad)))) this_col_array = rows_list[i] else: this_col_array = np.concatenate((this_col_array, rows_list[i]), axis=0) for (i, col) in enumerate(cols_list): if (col.shape[0] != (pref_rows * expect_row_shape[0])): extra = np.zeros((((expect_row_shape[0] * pref_rows) - col.shape[0]), expect_row_shape[1])) row = np.concatenate((col, extra), axis=0) cols_list[i] = row tiled_array = np.concatenate(cols_list, axis=1) else: tiled_array = np.concatenate(rows_list, axis=0) return tiled_array<|docstring|>Takes a list of arrays and number of images per row and constructs a tiled array for margin-less visualization Args: array_list -- list of np.ndarrays to be tiled in row-major order perrow -- integer specifying number of images per row Optional Args: square -- Try to make length and width equal by tiling vertical columns side-by-side pad_width -- # columns between vertical tiling columns pad_intensity -- # intensity value of padding cells Returns: numpy matrix/2dArray<|endoftext|>
b1750c72d6d47246a130e6ea159f6719f41358b881be9aabde85dc5dd0f4682e
@abstractmethod def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by current reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')
Verify whether the specified file or files format is supported by current reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.
monai/data/image_reader.py
verify_suffix
lyndonboone/MONAI
1
python
@abstractmethod def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by current reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')
@abstractmethod def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by current reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')<|docstring|>Verify whether the specified file or files format is supported by current reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.<|endoftext|>
ac95ef0278076f08a22d2cdd709393329466a87bc71e92cd814d4cc9af585810
@abstractmethod def read(self, data: Union[(Sequence[str], str)], **kwargs) -> Union[(Sequence[Any], Any)]: '\n Read image data from specified file or files.\n Note that it returns the raw data, so different readers return different image data type.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for actual `read` API of 3rd party libs.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')
Read image data from specified file or files. Note that it returns the raw data, so different readers return different image data type. Args: data: file name or a list of file names to read. kwargs: additional args for actual `read` API of 3rd party libs.
monai/data/image_reader.py
read
lyndonboone/MONAI
1
python
@abstractmethod def read(self, data: Union[(Sequence[str], str)], **kwargs) -> Union[(Sequence[Any], Any)]: '\n Read image data from specified file or files.\n Note that it returns the raw data, so different readers return different image data type.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for actual `read` API of 3rd party libs.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')
@abstractmethod def read(self, data: Union[(Sequence[str], str)], **kwargs) -> Union[(Sequence[Any], Any)]: '\n Read image data from specified file or files.\n Note that it returns the raw data, so different readers return different image data type.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for actual `read` API of 3rd party libs.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')<|docstring|>Read image data from specified file or files. Note that it returns the raw data, so different readers return different image data type. Args: data: file name or a list of file names to read. kwargs: additional args for actual `read` API of 3rd party libs.<|endoftext|>
fe4a4c6a69aef5328b549e732a600a325292d27365122d49ffd81870b23165bc
@abstractmethod def get_data(self, img) -> Tuple[(np.ndarray, Dict)]: '\n Extract data array and meta data from loaded image and return them.\n This function must return 2 objects, first is numpy array of image data, second is dict of meta data.\n\n Args:\n img: an image object loaded from a image file or a list of image objects.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')
Extract data array and meta data from loaded image and return them. This function must return 2 objects, first is numpy array of image data, second is dict of meta data. Args: img: an image object loaded from a image file or a list of image objects.
monai/data/image_reader.py
get_data
lyndonboone/MONAI
1
python
@abstractmethod def get_data(self, img) -> Tuple[(np.ndarray, Dict)]: '\n Extract data array and meta data from loaded image and return them.\n This function must return 2 objects, first is numpy array of image data, second is dict of meta data.\n\n Args:\n img: an image object loaded from a image file or a list of image objects.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')
@abstractmethod def get_data(self, img) -> Tuple[(np.ndarray, Dict)]: '\n Extract data array and meta data from loaded image and return them.\n This function must return 2 objects, first is numpy array of image data, second is dict of meta data.\n\n Args:\n img: an image object loaded from a image file or a list of image objects.\n\n ' raise NotImplementedError(f'Subclass {self.__class__.__name__} must implement this method.')<|docstring|>Extract data array and meta data from loaded image and return them. This function must return 2 objects, first is numpy array of image data, second is dict of meta data. Args: img: an image object loaded from a image file or a list of image objects.<|endoftext|>
4843a33ad6a10a120d58e39192f207a08aa73fcec0c10be064c6b13d7c1a0353
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by ITK reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' return has_itk
Verify whether the specified file or files format is supported by ITK reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.
monai/data/image_reader.py
verify_suffix
lyndonboone/MONAI
1
python
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by ITK reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' return has_itk
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by ITK reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' return has_itk<|docstring|>Verify whether the specified file or files format is supported by ITK reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.<|endoftext|>
00f400ede9f0cc142e4577d2a333ac4b2b8764915c4272b63c0445c6e7b4ad90
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is ITK image object or list of ITK image objects.\n\n Args:\n data: file name or a list of file names to read,\n kwargs: additional args for `itk.imread` API, will override `self.kwargs` for existing keys.\n More details about available args:\n https://github.com/InsightSoftwareConsortium/ITK/blob/master/Wrapping/Generators/Python/itkExtras.py\n\n ' img_: List[Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: if os.path.isdir(name): names_generator = itk.GDCMSeriesFileNames.New() names_generator.SetUseSeriesDetails(True) names_generator.AddSeriesRestriction('0008|0021') names_generator.SetDirectory(name) series_uid = names_generator.GetSeriesUIDs() if (len(series_uid) == 0): raise FileNotFoundError(f'no DICOMs in: {name}.') if (len(series_uid) > 1): raise OSError(f'the directory: {name} contains more than one DICOM series.') series_identifier = series_uid[0] name = names_generator.GetFileNames(series_identifier) img_.append(itk.imread(name, **kwargs_)) return (img_ if (len(filenames) > 1) else img_[0])
Read image data from specified file or files. Note that the returned object is ITK image object or list of ITK image objects. Args: data: file name or a list of file names to read, kwargs: additional args for `itk.imread` API, will override `self.kwargs` for existing keys. More details about available args: https://github.com/InsightSoftwareConsortium/ITK/blob/master/Wrapping/Generators/Python/itkExtras.py
monai/data/image_reader.py
read
lyndonboone/MONAI
1
python
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is ITK image object or list of ITK image objects.\n\n Args:\n data: file name or a list of file names to read,\n kwargs: additional args for `itk.imread` API, will override `self.kwargs` for existing keys.\n More details about available args:\n https://github.com/InsightSoftwareConsortium/ITK/blob/master/Wrapping/Generators/Python/itkExtras.py\n\n ' img_: List[Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: if os.path.isdir(name): names_generator = itk.GDCMSeriesFileNames.New() names_generator.SetUseSeriesDetails(True) names_generator.AddSeriesRestriction('0008|0021') names_generator.SetDirectory(name) series_uid = names_generator.GetSeriesUIDs() if (len(series_uid) == 0): raise FileNotFoundError(f'no DICOMs in: {name}.') if (len(series_uid) > 1): raise OSError(f'the directory: {name} contains more than one DICOM series.') series_identifier = series_uid[0] name = names_generator.GetFileNames(series_identifier) img_.append(itk.imread(name, **kwargs_)) return (img_ if (len(filenames) > 1) else img_[0])
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is ITK image object or list of ITK image objects.\n\n Args:\n data: file name or a list of file names to read,\n kwargs: additional args for `itk.imread` API, will override `self.kwargs` for existing keys.\n More details about available args:\n https://github.com/InsightSoftwareConsortium/ITK/blob/master/Wrapping/Generators/Python/itkExtras.py\n\n ' img_: List[Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: if os.path.isdir(name): names_generator = itk.GDCMSeriesFileNames.New() names_generator.SetUseSeriesDetails(True) names_generator.AddSeriesRestriction('0008|0021') names_generator.SetDirectory(name) series_uid = names_generator.GetSeriesUIDs() if (len(series_uid) == 0): raise FileNotFoundError(f'no DICOMs in: {name}.') if (len(series_uid) > 1): raise OSError(f'the directory: {name} contains more than one DICOM series.') series_identifier = series_uid[0] name = names_generator.GetFileNames(series_identifier) img_.append(itk.imread(name, **kwargs_)) return (img_ if (len(filenames) > 1) else img_[0])<|docstring|>Read image data from specified file or files. Note that the returned object is ITK image object or list of ITK image objects. Args: data: file name or a list of file names to read, kwargs: additional args for `itk.imread` API, will override `self.kwargs` for existing keys. More details about available args: https://github.com/InsightSoftwareConsortium/ITK/blob/master/Wrapping/Generators/Python/itkExtras.py<|endoftext|>
cb1ccc80b743fa3d2ca079302e9b2c315966e56bec9c4f8c136cf0209e9d9d3b
def get_data(self, img): '\n Extract data array and meta data from loaded image and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a ITK image object loaded from a image file or a list of ITK image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['original_affine'] = self._get_affine(i) header['affine'] = header['original_affine'].copy() header['spatial_shape'] = self._get_spatial_shape(i) data = self._get_array_data(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
Extract data array and meta data from loaded image and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a ITK image object loaded from a image file or a list of ITK image objects.
monai/data/image_reader.py
get_data
lyndonboone/MONAI
1
python
def get_data(self, img): '\n Extract data array and meta data from loaded image and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a ITK image object loaded from a image file or a list of ITK image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['original_affine'] = self._get_affine(i) header['affine'] = header['original_affine'].copy() header['spatial_shape'] = self._get_spatial_shape(i) data = self._get_array_data(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
def get_data(self, img): '\n Extract data array and meta data from loaded image and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a ITK image object loaded from a image file or a list of ITK image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['original_affine'] = self._get_affine(i) header['affine'] = header['original_affine'].copy() header['spatial_shape'] = self._get_spatial_shape(i) data = self._get_array_data(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)<|docstring|>Extract data array and meta data from loaded image and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a ITK image object loaded from a image file or a list of ITK image objects.<|endoftext|>
74f469defaa4fcd707c2e29d2a00d7abe5ef41f2c8aa7164ad9adff1e98e7258
def _get_meta_dict(self, img) -> Dict: '\n Get all the meta data of the image and convert to dict type.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' img_meta_dict = img.GetMetaDataDictionary() meta_dict = {} for key in img_meta_dict.GetKeys(): if key.startswith('ITK_original_'): continue if ((key == 'NRRD_measurement frame') and (int(itk.Version.GetITKMajorVersion()) == 5) and (int(itk.Version.GetITKMinorVersion()) < 2)): warnings.warn("Ignoring 'measurement frame' field. Correct reading of NRRD05 files requires ITK >= 5.2: `pip install --upgrade --pre itk`") continue meta_dict[key] = img_meta_dict[key] meta_dict['origin'] = np.asarray(img.GetOrigin()) meta_dict['spacing'] = np.asarray(img.GetSpacing()) meta_dict['direction'] = itk.array_from_matrix(img.GetDirection()) return meta_dict
Get all the meta data of the image and convert to dict type. Args: img: a ITK image object loaded from a image file.
monai/data/image_reader.py
_get_meta_dict
lyndonboone/MONAI
1
python
def _get_meta_dict(self, img) -> Dict: '\n Get all the meta data of the image and convert to dict type.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' img_meta_dict = img.GetMetaDataDictionary() meta_dict = {} for key in img_meta_dict.GetKeys(): if key.startswith('ITK_original_'): continue if ((key == 'NRRD_measurement frame') and (int(itk.Version.GetITKMajorVersion()) == 5) and (int(itk.Version.GetITKMinorVersion()) < 2)): warnings.warn("Ignoring 'measurement frame' field. Correct reading of NRRD05 files requires ITK >= 5.2: `pip install --upgrade --pre itk`") continue meta_dict[key] = img_meta_dict[key] meta_dict['origin'] = np.asarray(img.GetOrigin()) meta_dict['spacing'] = np.asarray(img.GetSpacing()) meta_dict['direction'] = itk.array_from_matrix(img.GetDirection()) return meta_dict
def _get_meta_dict(self, img) -> Dict: '\n Get all the meta data of the image and convert to dict type.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' img_meta_dict = img.GetMetaDataDictionary() meta_dict = {} for key in img_meta_dict.GetKeys(): if key.startswith('ITK_original_'): continue if ((key == 'NRRD_measurement frame') and (int(itk.Version.GetITKMajorVersion()) == 5) and (int(itk.Version.GetITKMinorVersion()) < 2)): warnings.warn("Ignoring 'measurement frame' field. Correct reading of NRRD05 files requires ITK >= 5.2: `pip install --upgrade --pre itk`") continue meta_dict[key] = img_meta_dict[key] meta_dict['origin'] = np.asarray(img.GetOrigin()) meta_dict['spacing'] = np.asarray(img.GetSpacing()) meta_dict['direction'] = itk.array_from_matrix(img.GetDirection()) return meta_dict<|docstring|>Get all the meta data of the image and convert to dict type. Args: img: a ITK image object loaded from a image file.<|endoftext|>
b5974427049978a727064d0e7a583727f2a121b1fc29dc42a92520ecf08a699f
def _get_affine(self, img): '\n Get or construct the affine matrix of the image, it can be used to correct\n spacing, orientation or execute spatial transforms.\n Construct Affine matrix based on direction, spacing, origin information.\n Refer to: https://github.com/RSIP-Vision/medio\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' direction = itk.array_from_matrix(img.GetDirection()) spacing = np.asarray(img.GetSpacing()) origin = np.asarray(img.GetOrigin()) direction = np.asarray(direction) affine: np.ndarray = np.eye((direction.shape[0] + 1)) affine[(slice((- 1)), slice((- 1)))] = (direction @ np.diag(spacing)) affine[(slice((- 1)), (- 1))] = origin return affine
Get or construct the affine matrix of the image, it can be used to correct spacing, orientation or execute spatial transforms. Construct Affine matrix based on direction, spacing, origin information. Refer to: https://github.com/RSIP-Vision/medio Args: img: a ITK image object loaded from a image file.
monai/data/image_reader.py
_get_affine
lyndonboone/MONAI
1
python
def _get_affine(self, img): '\n Get or construct the affine matrix of the image, it can be used to correct\n spacing, orientation or execute spatial transforms.\n Construct Affine matrix based on direction, spacing, origin information.\n Refer to: https://github.com/RSIP-Vision/medio\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' direction = itk.array_from_matrix(img.GetDirection()) spacing = np.asarray(img.GetSpacing()) origin = np.asarray(img.GetOrigin()) direction = np.asarray(direction) affine: np.ndarray = np.eye((direction.shape[0] + 1)) affine[(slice((- 1)), slice((- 1)))] = (direction @ np.diag(spacing)) affine[(slice((- 1)), (- 1))] = origin return affine
def _get_affine(self, img): '\n Get or construct the affine matrix of the image, it can be used to correct\n spacing, orientation or execute spatial transforms.\n Construct Affine matrix based on direction, spacing, origin information.\n Refer to: https://github.com/RSIP-Vision/medio\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' direction = itk.array_from_matrix(img.GetDirection()) spacing = np.asarray(img.GetSpacing()) origin = np.asarray(img.GetOrigin()) direction = np.asarray(direction) affine: np.ndarray = np.eye((direction.shape[0] + 1)) affine[(slice((- 1)), slice((- 1)))] = (direction @ np.diag(spacing)) affine[(slice((- 1)), (- 1))] = origin return affine<|docstring|>Get or construct the affine matrix of the image, it can be used to correct spacing, orientation or execute spatial transforms. Construct Affine matrix based on direction, spacing, origin information. Refer to: https://github.com/RSIP-Vision/medio Args: img: a ITK image object loaded from a image file.<|endoftext|>
e5393307964b8d85f0ce04173cc19e4989680bdc11760edaa54e00669d3b0256
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n " shape = list(itk.size(img)) shape.reverse() return np.asarray(shape)
Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a ITK image object loaded from a image file.
monai/data/image_reader.py
_get_spatial_shape
lyndonboone/MONAI
1
python
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n " shape = list(itk.size(img)) shape.reverse() return np.asarray(shape)
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n " shape = list(itk.size(img)) shape.reverse() return np.asarray(shape)<|docstring|>Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a ITK image object loaded from a image file.<|endoftext|>
592ba53f9bfb591d61381873c9bbe75031ae4bcd7b9c1b5224f2de163225925d
def _get_array_data(self, img): '\n Get the raw array data of the image, converted to Numpy array.\n\n Following PyTorch conventions, the returned array data has contiguous channels,\n e.g. for an RGB image, all red channel image pixels are contiguous in memory.\n The first axis of the returned array is the channel axis.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' channels = img.GetNumberOfComponentsPerPixel() if (channels == 1): return itk.array_view_from_image(img, keep_axes=False) arr = itk.array_view_from_image(img, keep_axes=False) dest = list(range(img.ndim)) source = dest.copy() end = source.pop() source.insert(0, end) return np.moveaxis(arr, source, dest)
Get the raw array data of the image, converted to Numpy array. Following PyTorch conventions, the returned array data has contiguous channels, e.g. for an RGB image, all red channel image pixels are contiguous in memory. The first axis of the returned array is the channel axis. Args: img: a ITK image object loaded from a image file.
monai/data/image_reader.py
_get_array_data
lyndonboone/MONAI
1
python
def _get_array_data(self, img): '\n Get the raw array data of the image, converted to Numpy array.\n\n Following PyTorch conventions, the returned array data has contiguous channels,\n e.g. for an RGB image, all red channel image pixels are contiguous in memory.\n The first axis of the returned array is the channel axis.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' channels = img.GetNumberOfComponentsPerPixel() if (channels == 1): return itk.array_view_from_image(img, keep_axes=False) arr = itk.array_view_from_image(img, keep_axes=False) dest = list(range(img.ndim)) source = dest.copy() end = source.pop() source.insert(0, end) return np.moveaxis(arr, source, dest)
def _get_array_data(self, img): '\n Get the raw array data of the image, converted to Numpy array.\n\n Following PyTorch conventions, the returned array data has contiguous channels,\n e.g. for an RGB image, all red channel image pixels are contiguous in memory.\n The first axis of the returned array is the channel axis.\n\n Args:\n img: a ITK image object loaded from a image file.\n\n ' channels = img.GetNumberOfComponentsPerPixel() if (channels == 1): return itk.array_view_from_image(img, keep_axes=False) arr = itk.array_view_from_image(img, keep_axes=False) dest = list(range(img.ndim)) source = dest.copy() end = source.pop() source.insert(0, end) return np.moveaxis(arr, source, dest)<|docstring|>Get the raw array data of the image, converted to Numpy array. Following PyTorch conventions, the returned array data has contiguous channels, e.g. for an RGB image, all red channel image pixels are contiguous in memory. The first axis of the returned array is the channel axis. Args: img: a ITK image object loaded from a image file.<|endoftext|>
d599d4a8b0b22a702603d5d7ef8fa49bd197f9d1a09d570665bc12cc6a41410c
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by Nibabel reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' suffixes: Sequence[str] = ['nii', 'nii.gz'] return (has_nib and is_supported_format(filename, suffixes))
Verify whether the specified file or files format is supported by Nibabel reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.
monai/data/image_reader.py
verify_suffix
lyndonboone/MONAI
1
python
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by Nibabel reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' suffixes: Sequence[str] = ['nii', 'nii.gz'] return (has_nib and is_supported_format(filename, suffixes))
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by Nibabel reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n\n ' suffixes: Sequence[str] = ['nii', 'nii.gz'] return (has_nib and is_supported_format(filename, suffixes))<|docstring|>Verify whether the specified file or files format is supported by Nibabel reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.<|endoftext|>
7ca6f46f332119a631912f9d7dc5b1c389e48558cc703ed2b031c9eec5b06687
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is Nibabel image object or list of Nibabel image objects.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `nibabel.load` API, will override `self.kwargs` for existing keys.\n More details about available args:\n https://github.com/nipy/nibabel/blob/master/nibabel/loadsave.py\n\n ' img_: List[Nifti1Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = nib.load(name, **kwargs_) img = correct_nifti_header_if_necessary(img) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])
Read image data from specified file or files. Note that the returned object is Nibabel image object or list of Nibabel image objects. Args: data: file name or a list of file names to read. kwargs: additional args for `nibabel.load` API, will override `self.kwargs` for existing keys. More details about available args: https://github.com/nipy/nibabel/blob/master/nibabel/loadsave.py
monai/data/image_reader.py
read
lyndonboone/MONAI
1
python
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is Nibabel image object or list of Nibabel image objects.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `nibabel.load` API, will override `self.kwargs` for existing keys.\n More details about available args:\n https://github.com/nipy/nibabel/blob/master/nibabel/loadsave.py\n\n ' img_: List[Nifti1Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = nib.load(name, **kwargs_) img = correct_nifti_header_if_necessary(img) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is Nibabel image object or list of Nibabel image objects.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `nibabel.load` API, will override `self.kwargs` for existing keys.\n More details about available args:\n https://github.com/nipy/nibabel/blob/master/nibabel/loadsave.py\n\n ' img_: List[Nifti1Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = nib.load(name, **kwargs_) img = correct_nifti_header_if_necessary(img) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])<|docstring|>Read image data from specified file or files. Note that the returned object is Nibabel image object or list of Nibabel image objects. Args: data: file name or a list of file names to read. kwargs: additional args for `nibabel.load` API, will override `self.kwargs` for existing keys. More details about available args: https://github.com/nipy/nibabel/blob/master/nibabel/loadsave.py<|endoftext|>
c799b00d08b9a9764b0739495a11ea7b6ed1539a249518f306f14954aff8fc0f
def get_data(self, img): '\n Extract data array and meta data from loaded image and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a Nibabel image object loaded from a image file or a list of Nibabel image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['affine'] = self._get_affine(i) header['original_affine'] = self._get_affine(i) header['as_closest_canonical'] = self.as_closest_canonical if self.as_closest_canonical: i = nib.as_closest_canonical(i) header['affine'] = self._get_affine(i) header['spatial_shape'] = self._get_spatial_shape(i) data = self._get_array_data(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
Extract data array and meta data from loaded image and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a Nibabel image object loaded from a image file or a list of Nibabel image objects.
monai/data/image_reader.py
get_data
lyndonboone/MONAI
1
python
def get_data(self, img): '\n Extract data array and meta data from loaded image and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a Nibabel image object loaded from a image file or a list of Nibabel image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['affine'] = self._get_affine(i) header['original_affine'] = self._get_affine(i) header['as_closest_canonical'] = self.as_closest_canonical if self.as_closest_canonical: i = nib.as_closest_canonical(i) header['affine'] = self._get_affine(i) header['spatial_shape'] = self._get_spatial_shape(i) data = self._get_array_data(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
def get_data(self, img): '\n Extract data array and meta data from loaded image and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a Nibabel image object loaded from a image file or a list of Nibabel image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['affine'] = self._get_affine(i) header['original_affine'] = self._get_affine(i) header['as_closest_canonical'] = self.as_closest_canonical if self.as_closest_canonical: i = nib.as_closest_canonical(i) header['affine'] = self._get_affine(i) header['spatial_shape'] = self._get_spatial_shape(i) data = self._get_array_data(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)<|docstring|>Extract data array and meta data from loaded image and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `affine`, `original_affine`, and `spatial_shape` and stores in meta dict. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a Nibabel image object loaded from a image file or a list of Nibabel image objects.<|endoftext|>
8a8267ee03fe933b4a236e42c7e3dd575289e8d550ae9b68f703ee9dbade73e7
def _get_meta_dict(self, img) -> Dict: '\n Get the all the meta data of the image and convert to dict type.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' header = img.header.as_byteswapped('<') return dict(header)
Get the all the meta data of the image and convert to dict type. Args: img: a Nibabel image object loaded from a image file.
monai/data/image_reader.py
_get_meta_dict
lyndonboone/MONAI
1
python
def _get_meta_dict(self, img) -> Dict: '\n Get the all the meta data of the image and convert to dict type.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' header = img.header.as_byteswapped('<') return dict(header)
def _get_meta_dict(self, img) -> Dict: '\n Get the all the meta data of the image and convert to dict type.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' header = img.header.as_byteswapped('<') return dict(header)<|docstring|>Get the all the meta data of the image and convert to dict type. Args: img: a Nibabel image object loaded from a image file.<|endoftext|>
43f1acdc99b2b7283de62797c830422172fc87c3190bc9d9c4d92701cc8747f2
def _get_affine(self, img): '\n Get the affine matrix of the image, it can be used to correct\n spacing, orientation or execute spatial transforms.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' return np.array(img.affine, copy=True)
Get the affine matrix of the image, it can be used to correct spacing, orientation or execute spatial transforms. Args: img: a Nibabel image object loaded from a image file.
monai/data/image_reader.py
_get_affine
lyndonboone/MONAI
1
python
def _get_affine(self, img): '\n Get the affine matrix of the image, it can be used to correct\n spacing, orientation or execute spatial transforms.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' return np.array(img.affine, copy=True)
def _get_affine(self, img): '\n Get the affine matrix of the image, it can be used to correct\n spacing, orientation or execute spatial transforms.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' return np.array(img.affine, copy=True)<|docstring|>Get the affine matrix of the image, it can be used to correct spacing, orientation or execute spatial transforms. Args: img: a Nibabel image object loaded from a image file.<|endoftext|>
b097c8a758fa6b8dfc7320c242e85c3889e32d65e7a3afe898c43a10c26183db
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n " header = img.header.as_byteswapped('<') ndim = header['dim'][0] spatial_rank = min(ndim, 3) return np.asarray(header['dim'][1:(spatial_rank + 1)])
Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a Nibabel image object loaded from a image file.
monai/data/image_reader.py
_get_spatial_shape
lyndonboone/MONAI
1
python
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n " header = img.header.as_byteswapped('<') ndim = header['dim'][0] spatial_rank = min(ndim, 3) return np.asarray(header['dim'][1:(spatial_rank + 1)])
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n " header = img.header.as_byteswapped('<') ndim = header['dim'][0] spatial_rank = min(ndim, 3) return np.asarray(header['dim'][1:(spatial_rank + 1)])<|docstring|>Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a Nibabel image object loaded from a image file.<|endoftext|>
4da40f70df7063d8badc8ab652f6f0cf65332281ac006e8a1cebff524ebf34e8
def _get_array_data(self, img): '\n Get the raw array data of the image, converted to Numpy array.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' _array = np.array(img.get_fdata(dtype=self.dtype)) img.uncache() return _array
Get the raw array data of the image, converted to Numpy array. Args: img: a Nibabel image object loaded from a image file.
monai/data/image_reader.py
_get_array_data
lyndonboone/MONAI
1
python
def _get_array_data(self, img): '\n Get the raw array data of the image, converted to Numpy array.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' _array = np.array(img.get_fdata(dtype=self.dtype)) img.uncache() return _array
def _get_array_data(self, img): '\n Get the raw array data of the image, converted to Numpy array.\n\n Args:\n img: a Nibabel image object loaded from a image file.\n\n ' _array = np.array(img.get_fdata(dtype=self.dtype)) img.uncache() return _array<|docstring|>Get the raw array data of the image, converted to Numpy array. Args: img: a Nibabel image object loaded from a image file.<|endoftext|>
da8a63bc8578858f173e53b338610103bade555e1368e1a412b24b38ce214bf3
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by Numpy reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' suffixes: Sequence[str] = ['npz', 'npy'] return is_supported_format(filename, suffixes)
Verify whether the specified file or files format is supported by Numpy reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.
monai/data/image_reader.py
verify_suffix
lyndonboone/MONAI
1
python
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by Numpy reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' suffixes: Sequence[str] = ['npz', 'npy'] return is_supported_format(filename, suffixes)
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by Numpy reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' suffixes: Sequence[str] = ['npz', 'npy'] return is_supported_format(filename, suffixes)<|docstring|>Verify whether the specified file or files format is supported by Numpy reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.<|endoftext|>
52cbe998b05b934bd2013c008e67e3a548588274fc0484d5a4652583be10d2ff
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is Numpy array or list of Numpy arrays.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `numpy.load` API except `allow_pickle`, will override `self.kwargs` for existing keys.\n More details about available args:\n https://numpy.org/doc/stable/reference/generated/numpy.load.html\n\n ' img_: List[Nifti1Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = np.load(name, allow_pickle=True, **kwargs_) if name.endswith('.npz'): npz_keys = ([f'arr_{i}' for i in range(len(img))] if (self.npz_keys is None) else self.npz_keys) for k in npz_keys: img_.append(img[k]) else: img_.append(img) return (img_ if (len(img_) > 1) else img_[0])
Read image data from specified file or files. Note that the returned object is Numpy array or list of Numpy arrays. Args: data: file name or a list of file names to read. kwargs: additional args for `numpy.load` API except `allow_pickle`, will override `self.kwargs` for existing keys. More details about available args: https://numpy.org/doc/stable/reference/generated/numpy.load.html
monai/data/image_reader.py
read
lyndonboone/MONAI
1
python
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is Numpy array or list of Numpy arrays.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `numpy.load` API except `allow_pickle`, will override `self.kwargs` for existing keys.\n More details about available args:\n https://numpy.org/doc/stable/reference/generated/numpy.load.html\n\n ' img_: List[Nifti1Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = np.load(name, allow_pickle=True, **kwargs_) if name.endswith('.npz'): npz_keys = ([f'arr_{i}' for i in range(len(img))] if (self.npz_keys is None) else self.npz_keys) for k in npz_keys: img_.append(img[k]) else: img_.append(img) return (img_ if (len(img_) > 1) else img_[0])
def read(self, data: Union[(Sequence[str], str)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is Numpy array or list of Numpy arrays.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `numpy.load` API except `allow_pickle`, will override `self.kwargs` for existing keys.\n More details about available args:\n https://numpy.org/doc/stable/reference/generated/numpy.load.html\n\n ' img_: List[Nifti1Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = np.load(name, allow_pickle=True, **kwargs_) if name.endswith('.npz'): npz_keys = ([f'arr_{i}' for i in range(len(img))] if (self.npz_keys is None) else self.npz_keys) for k in npz_keys: img_.append(img[k]) else: img_.append(img) return (img_ if (len(img_) > 1) else img_[0])<|docstring|>Read image data from specified file or files. Note that the returned object is Numpy array or list of Numpy arrays. Args: data: file name or a list of file names to read. kwargs: additional args for `numpy.load` API except `allow_pickle`, will override `self.kwargs` for existing keys. More details about available args: https://numpy.org/doc/stable/reference/generated/numpy.load.html<|endoftext|>
be666806596a8aa342c0986a29d967c64e7cdce5de9907a0340e7f1c70b51016
def get_data(self, img): '\n Extract data array and meta data from loaded data and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `spatial_shape=data.shape` and stores in meta dict if the data is numpy array.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a Numpy array loaded from a file or a list of Numpy arrays.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} if isinstance(img, np.ndarray): img = (img,) for i in ensure_tuple(img): header = {} if isinstance(i, np.ndarray): header['spatial_shape'] = i.shape img_array.append(i) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
Extract data array and meta data from loaded data and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `spatial_shape=data.shape` and stores in meta dict if the data is numpy array. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a Numpy array loaded from a file or a list of Numpy arrays.
monai/data/image_reader.py
get_data
lyndonboone/MONAI
1
python
def get_data(self, img): '\n Extract data array and meta data from loaded data and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `spatial_shape=data.shape` and stores in meta dict if the data is numpy array.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a Numpy array loaded from a file or a list of Numpy arrays.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} if isinstance(img, np.ndarray): img = (img,) for i in ensure_tuple(img): header = {} if isinstance(i, np.ndarray): header['spatial_shape'] = i.shape img_array.append(i) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
def get_data(self, img): '\n Extract data array and meta data from loaded data and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `spatial_shape=data.shape` and stores in meta dict if the data is numpy array.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a Numpy array loaded from a file or a list of Numpy arrays.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} if isinstance(img, np.ndarray): img = (img,) for i in ensure_tuple(img): header = {} if isinstance(i, np.ndarray): header['spatial_shape'] = i.shape img_array.append(i) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)<|docstring|>Extract data array and meta data from loaded data and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `spatial_shape=data.shape` and stores in meta dict if the data is numpy array. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a Numpy array loaded from a file or a list of Numpy arrays.<|endoftext|>
bbd4e8cabe313a8d1c797e9ef93fdc459f4261972e1a330459d91ef6701fe77d
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by PIL reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' suffixes: Sequence[str] = ['png', 'jpg', 'jpeg', 'bmp'] return (has_pil and is_supported_format(filename, suffixes))
Verify whether the specified file or files format is supported by PIL reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.
monai/data/image_reader.py
verify_suffix
lyndonboone/MONAI
1
python
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by PIL reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' suffixes: Sequence[str] = ['png', 'jpg', 'jpeg', 'bmp'] return (has_pil and is_supported_format(filename, suffixes))
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by PIL reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' suffixes: Sequence[str] = ['png', 'jpg', 'jpeg', 'bmp'] return (has_pil and is_supported_format(filename, suffixes))<|docstring|>Verify whether the specified file or files format is supported by PIL reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.<|endoftext|>
d8993fc50489d5492cbee7e05c99ea411c64f4835999c683c5b2e6d2ab2371b0
def read(self, data: Union[(Sequence[str], str, np.ndarray)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is PIL image or list of PIL image.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `Image.open` API in `read()`, will override `self.kwargs` for existing keys.\n Mode details about available args:\n https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.open\n\n ' img_: List[PILImage.Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = PILImage.open(name, **kwargs_) if callable(self.converter): img = self.converter(img) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])
Read image data from specified file or files. Note that the returned object is PIL image or list of PIL image. Args: data: file name or a list of file names to read. kwargs: additional args for `Image.open` API in `read()`, will override `self.kwargs` for existing keys. Mode details about available args: https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.open
monai/data/image_reader.py
read
lyndonboone/MONAI
1
python
def read(self, data: Union[(Sequence[str], str, np.ndarray)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is PIL image or list of PIL image.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `Image.open` API in `read()`, will override `self.kwargs` for existing keys.\n Mode details about available args:\n https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.open\n\n ' img_: List[PILImage.Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = PILImage.open(name, **kwargs_) if callable(self.converter): img = self.converter(img) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])
def read(self, data: Union[(Sequence[str], str, np.ndarray)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is PIL image or list of PIL image.\n\n Args:\n data: file name or a list of file names to read.\n kwargs: additional args for `Image.open` API in `read()`, will override `self.kwargs` for existing keys.\n Mode details about available args:\n https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.open\n\n ' img_: List[PILImage.Image] = [] filenames: Sequence[str] = ensure_tuple(data) kwargs_ = self.kwargs.copy() kwargs_.update(kwargs) for name in filenames: img = PILImage.open(name, **kwargs_) if callable(self.converter): img = self.converter(img) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])<|docstring|>Read image data from specified file or files. Note that the returned object is PIL image or list of PIL image. Args: data: file name or a list of file names to read. kwargs: additional args for `Image.open` API in `read()`, will override `self.kwargs` for existing keys. Mode details about available args: https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.open<|endoftext|>
8bf13abf255a1fa2a99a95532eedf29fbc8d3f7f302149b7944980a8c234c5fc
def get_data(self, img): '\n Extract data array and meta data from loaded data and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a PIL Image object loaded from a file or a list of PIL Image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['spatial_shape'] = self._get_spatial_shape(i) data = np.asarray(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
Extract data array and meta data from loaded data and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `spatial_shape` and stores in meta dict. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a PIL Image object loaded from a file or a list of PIL Image objects.
monai/data/image_reader.py
get_data
lyndonboone/MONAI
1
python
def get_data(self, img): '\n Extract data array and meta data from loaded data and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a PIL Image object loaded from a file or a list of PIL Image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['spatial_shape'] = self._get_spatial_shape(i) data = np.asarray(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)
def get_data(self, img): '\n Extract data array and meta data from loaded data and return them.\n This function returns 2 objects, first is numpy array of image data, second is dict of meta data.\n It constructs `spatial_shape` and stores in meta dict.\n If loading a list of files, stack them together and add a new dimension as first dimension,\n and use the meta data of the first image to represent the stacked result.\n\n Args:\n img: a PIL Image object loaded from a file or a list of PIL Image objects.\n\n ' img_array: List[np.ndarray] = [] compatible_meta: Dict = {} for i in ensure_tuple(img): header = self._get_meta_dict(i) header['spatial_shape'] = self._get_spatial_shape(i) data = np.asarray(i) img_array.append(data) header['original_channel_dim'] = ('no_channel' if (len(data.shape) == len(header['spatial_shape'])) else (- 1)) _copy_compatible_dict(header, compatible_meta) return (_stack_images(img_array, compatible_meta), compatible_meta)<|docstring|>Extract data array and meta data from loaded data and return them. This function returns 2 objects, first is numpy array of image data, second is dict of meta data. It constructs `spatial_shape` and stores in meta dict. If loading a list of files, stack them together and add a new dimension as first dimension, and use the meta data of the first image to represent the stacked result. Args: img: a PIL Image object loaded from a file or a list of PIL Image objects.<|endoftext|>
02e164c6a7bc398cc8885b1cea6a29141b53a05ccbfd37383286273f11b34728
def _get_meta_dict(self, img) -> Dict: '\n Get the all the meta data of the image and convert to dict type.\n Args:\n img: a PIL Image object loaded from a image file.\n\n ' return {'format': img.format, 'mode': img.mode, 'width': img.width, 'height': img.height}
Get the all the meta data of the image and convert to dict type. Args: img: a PIL Image object loaded from a image file.
monai/data/image_reader.py
_get_meta_dict
lyndonboone/MONAI
1
python
def _get_meta_dict(self, img) -> Dict: '\n Get the all the meta data of the image and convert to dict type.\n Args:\n img: a PIL Image object loaded from a image file.\n\n ' return {'format': img.format, 'mode': img.mode, 'width': img.width, 'height': img.height}
def _get_meta_dict(self, img) -> Dict: '\n Get the all the meta data of the image and convert to dict type.\n Args:\n img: a PIL Image object loaded from a image file.\n\n ' return {'format': img.format, 'mode': img.mode, 'width': img.width, 'height': img.height}<|docstring|>Get the all the meta data of the image and convert to dict type. Args: img: a PIL Image object loaded from a image file.<|endoftext|>
a2f6048885700df60caf106a047a6ab957a16e372cfa3e3c7d18679e7ce871b2
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n Args:\n img: a PIL Image object loaded from a image file.\n " return np.asarray((img.width, img.height))
Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a PIL Image object loaded from a image file.
monai/data/image_reader.py
_get_spatial_shape
lyndonboone/MONAI
1
python
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n Args:\n img: a PIL Image object loaded from a image file.\n " return np.asarray((img.width, img.height))
def _get_spatial_shape(self, img): "\n Get the spatial shape of image data, it doesn't contain the channel dim.\n Args:\n img: a PIL Image object loaded from a image file.\n " return np.asarray((img.width, img.height))<|docstring|>Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a PIL Image object loaded from a image file.<|endoftext|>
aa2da00ceb29c08933646c5aac15af7eba2e632bf8b3f61b4adc8587dd4e9c85
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by WSI reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' return is_supported_format(filename, ['tif', 'tiff'])
Verify whether the specified file or files format is supported by WSI reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.
monai/data/image_reader.py
verify_suffix
lyndonboone/MONAI
1
python
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by WSI reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' return is_supported_format(filename, ['tif', 'tiff'])
def verify_suffix(self, filename: Union[(Sequence[str], str)]) -> bool: '\n Verify whether the specified file or files format is supported by WSI reader.\n\n Args:\n filename: file name or a list of file names to read.\n if a list of files, verify all the suffixes.\n ' return is_supported_format(filename, ['tif', 'tiff'])<|docstring|>Verify whether the specified file or files format is supported by WSI reader. Args: filename: file name or a list of file names to read. if a list of files, verify all the suffixes.<|endoftext|>
cff75a2d79ae7a30759d0cdfabb3d3fa0de21b2e3b52f591fc10ab01708863c5
def read(self, data: Union[(Sequence[str], str, np.ndarray)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is CuImage or list of CuImage objects.\n\n Args:\n data: file name or a list of file names to read.\n\n ' if ((self.reader_lib == 'openslide') and (not has_osl)): raise ImportError("No module named 'openslide'") if ((self.reader_lib == 'cucim') and (not has_cim)): raise ImportError("No module named 'cucim'") img_: List = [] filenames: Sequence[str] = ensure_tuple(data) for name in filenames: img = self.wsi_reader(name) if (self.reader_lib == 'openslide'): img.shape = (img.dimensions[1], img.dimensions[0], 3) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])
Read image data from specified file or files. Note that the returned object is CuImage or list of CuImage objects. Args: data: file name or a list of file names to read.
monai/data/image_reader.py
read
lyndonboone/MONAI
1
python
def read(self, data: Union[(Sequence[str], str, np.ndarray)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is CuImage or list of CuImage objects.\n\n Args:\n data: file name or a list of file names to read.\n\n ' if ((self.reader_lib == 'openslide') and (not has_osl)): raise ImportError("No module named 'openslide'") if ((self.reader_lib == 'cucim') and (not has_cim)): raise ImportError("No module named 'cucim'") img_: List = [] filenames: Sequence[str] = ensure_tuple(data) for name in filenames: img = self.wsi_reader(name) if (self.reader_lib == 'openslide'): img.shape = (img.dimensions[1], img.dimensions[0], 3) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])
def read(self, data: Union[(Sequence[str], str, np.ndarray)], **kwargs): '\n Read image data from specified file or files.\n Note that the returned object is CuImage or list of CuImage objects.\n\n Args:\n data: file name or a list of file names to read.\n\n ' if ((self.reader_lib == 'openslide') and (not has_osl)): raise ImportError("No module named 'openslide'") if ((self.reader_lib == 'cucim') and (not has_cim)): raise ImportError("No module named 'cucim'") img_: List = [] filenames: Sequence[str] = ensure_tuple(data) for name in filenames: img = self.wsi_reader(name) if (self.reader_lib == 'openslide'): img.shape = (img.dimensions[1], img.dimensions[0], 3) img_.append(img) return (img_ if (len(filenames) > 1) else img_[0])<|docstring|>Read image data from specified file or files. Note that the returned object is CuImage or list of CuImage objects. Args: data: file name or a list of file names to read.<|endoftext|>
9456476468e198906f78ba61ce197ccee9fa6e4be34903100e8b6fc99c18b4bb
def get_data(self, img, location: Tuple[(int, int)]=(0, 0), size: Optional[Tuple[(int, int)]]=None, level: int=0, dtype: DtypeLike=np.uint8, grid_shape: Tuple[(int, int)]=(1, 1), patch_size: Optional[Union[(int, Tuple[(int, int)])]]=None): '\n Extract regions as numpy array from WSI image and return them.\n\n Args:\n img: a WSIReader image object loaded from a file, or list of CuImage objects\n location: (x_min, y_min) tuple giving the top left pixel in the level 0 reference frame,\n or list of tuples (default=(0, 0))\n size: (height, width) tuple giving the region size, or list of tuples (default to full image size)\n This is the size of image at the given level (`level`)\n level: the level number, or list of level numbers (default=0)\n dtype: the data type of output image\n grid_shape: (row, columns) tuple define a grid to extract patches on that\n patch_size: (height, width) the size of extracted patches at the given level\n ' if ((self.reader_lib == 'openslide') and (size is None)): size = (((img.shape[0] // (2 ** level)) - location[0]), ((img.shape[1] // (2 ** level)) - location[1])) region = self._extract_region(img, location=location, size=size, level=level, dtype=dtype) metadata: Dict = {} metadata['spatial_shape'] = size metadata['original_channel_dim'] = (- 1) region = EnsureChannelFirst()(region, metadata) if (patch_size is None): patches = region else: tuple_patch_size = ensure_tuple_rep(patch_size, 2) patches = self._extract_patches(region, patch_size=tuple_patch_size, grid_shape=grid_shape, dtype=dtype) return (patches, metadata)
Extract regions as numpy array from WSI image and return them. Args: img: a WSIReader image object loaded from a file, or list of CuImage objects location: (x_min, y_min) tuple giving the top left pixel in the level 0 reference frame, or list of tuples (default=(0, 0)) size: (height, width) tuple giving the region size, or list of tuples (default to full image size) This is the size of image at the given level (`level`) level: the level number, or list of level numbers (default=0) dtype: the data type of output image grid_shape: (row, columns) tuple define a grid to extract patches on that patch_size: (height, width) the size of extracted patches at the given level
monai/data/image_reader.py
get_data
lyndonboone/MONAI
1
python
def get_data(self, img, location: Tuple[(int, int)]=(0, 0), size: Optional[Tuple[(int, int)]]=None, level: int=0, dtype: DtypeLike=np.uint8, grid_shape: Tuple[(int, int)]=(1, 1), patch_size: Optional[Union[(int, Tuple[(int, int)])]]=None): '\n Extract regions as numpy array from WSI image and return them.\n\n Args:\n img: a WSIReader image object loaded from a file, or list of CuImage objects\n location: (x_min, y_min) tuple giving the top left pixel in the level 0 reference frame,\n or list of tuples (default=(0, 0))\n size: (height, width) tuple giving the region size, or list of tuples (default to full image size)\n This is the size of image at the given level (`level`)\n level: the level number, or list of level numbers (default=0)\n dtype: the data type of output image\n grid_shape: (row, columns) tuple define a grid to extract patches on that\n patch_size: (height, width) the size of extracted patches at the given level\n ' if ((self.reader_lib == 'openslide') and (size is None)): size = (((img.shape[0] // (2 ** level)) - location[0]), ((img.shape[1] // (2 ** level)) - location[1])) region = self._extract_region(img, location=location, size=size, level=level, dtype=dtype) metadata: Dict = {} metadata['spatial_shape'] = size metadata['original_channel_dim'] = (- 1) region = EnsureChannelFirst()(region, metadata) if (patch_size is None): patches = region else: tuple_patch_size = ensure_tuple_rep(patch_size, 2) patches = self._extract_patches(region, patch_size=tuple_patch_size, grid_shape=grid_shape, dtype=dtype) return (patches, metadata)
def get_data(self, img, location: Tuple[(int, int)]=(0, 0), size: Optional[Tuple[(int, int)]]=None, level: int=0, dtype: DtypeLike=np.uint8, grid_shape: Tuple[(int, int)]=(1, 1), patch_size: Optional[Union[(int, Tuple[(int, int)])]]=None): '\n Extract regions as numpy array from WSI image and return them.\n\n Args:\n img: a WSIReader image object loaded from a file, or list of CuImage objects\n location: (x_min, y_min) tuple giving the top left pixel in the level 0 reference frame,\n or list of tuples (default=(0, 0))\n size: (height, width) tuple giving the region size, or list of tuples (default to full image size)\n This is the size of image at the given level (`level`)\n level: the level number, or list of level numbers (default=0)\n dtype: the data type of output image\n grid_shape: (row, columns) tuple define a grid to extract patches on that\n patch_size: (height, width) the size of extracted patches at the given level\n ' if ((self.reader_lib == 'openslide') and (size is None)): size = (((img.shape[0] // (2 ** level)) - location[0]), ((img.shape[1] // (2 ** level)) - location[1])) region = self._extract_region(img, location=location, size=size, level=level, dtype=dtype) metadata: Dict = {} metadata['spatial_shape'] = size metadata['original_channel_dim'] = (- 1) region = EnsureChannelFirst()(region, metadata) if (patch_size is None): patches = region else: tuple_patch_size = ensure_tuple_rep(patch_size, 2) patches = self._extract_patches(region, patch_size=tuple_patch_size, grid_shape=grid_shape, dtype=dtype) return (patches, metadata)<|docstring|>Extract regions as numpy array from WSI image and return them. Args: img: a WSIReader image object loaded from a file, or list of CuImage objects location: (x_min, y_min) tuple giving the top left pixel in the level 0 reference frame, or list of tuples (default=(0, 0)) size: (height, width) tuple giving the region size, or list of tuples (default to full image size) This is the size of image at the given level (`level`) level: the level number, or list of level numbers (default=0) dtype: the data type of output image grid_shape: (row, columns) tuple define a grid to extract patches on that patch_size: (height, width) the size of extracted patches at the given level<|endoftext|>
1658ff9e78748541ed2aac4ab6101a5754d75d9afb962b44428ccb8beae5c3f1
def convert_to_rgb_array(self, raw_region, dtype: DtypeLike=np.uint8): 'Convert to RGB mode and numpy array' if (self.reader_lib == 'openslide'): raw_region = raw_region.convert('RGB') raw_region = np.asarray(raw_region, dtype=dtype) else: num_channels = len(raw_region.channel_names) raw_region = np.asarray(raw_region, dtype=dtype) if (num_channels > 3): raw_region = raw_region[(:, :, :3)] return raw_region
Convert to RGB mode and numpy array
monai/data/image_reader.py
convert_to_rgb_array
lyndonboone/MONAI
1
python
def convert_to_rgb_array(self, raw_region, dtype: DtypeLike=np.uint8): if (self.reader_lib == 'openslide'): raw_region = raw_region.convert('RGB') raw_region = np.asarray(raw_region, dtype=dtype) else: num_channels = len(raw_region.channel_names) raw_region = np.asarray(raw_region, dtype=dtype) if (num_channels > 3): raw_region = raw_region[(:, :, :3)] return raw_region
def convert_to_rgb_array(self, raw_region, dtype: DtypeLike=np.uint8): if (self.reader_lib == 'openslide'): raw_region = raw_region.convert('RGB') raw_region = np.asarray(raw_region, dtype=dtype) else: num_channels = len(raw_region.channel_names) raw_region = np.asarray(raw_region, dtype=dtype) if (num_channels > 3): raw_region = raw_region[(:, :, :3)] return raw_region<|docstring|>Convert to RGB mode and numpy array<|endoftext|>
b79becc4818a1c8fe25c64350553f81f790d56939e2ec82d84d69cf52ab0cdaf
def modify_document(self, doc): ' This handler does not make any modifications to the Document.\n\n Args:\n doc (Document) : A Bokeh Document to update in-place\n\n *This handler does not modify the document*\n\n Returns:\n None\n\n ' pass
This handler does not make any modifications to the Document. Args: doc (Document) : A Bokeh Document to update in-place *This handler does not modify the document* Returns: None
bokeh/application/handlers/lifecycle.py
modify_document
jdlesage/bokeh
1
python
def modify_document(self, doc): ' This handler does not make any modifications to the Document.\n\n Args:\n doc (Document) : A Bokeh Document to update in-place\n\n *This handler does not modify the document*\n\n Returns:\n None\n\n ' pass
def modify_document(self, doc): ' This handler does not make any modifications to the Document.\n\n Args:\n doc (Document) : A Bokeh Document to update in-place\n\n *This handler does not modify the document*\n\n Returns:\n None\n\n ' pass<|docstring|>This handler does not make any modifications to the Document. Args: doc (Document) : A Bokeh Document to update in-place *This handler does not modify the document* Returns: None<|endoftext|>
3789adb3f21429fd1170e8e6249351152b2d0e9615fc2b7de23c0b304e27f137
def on_server_loaded(self, server_context): ' Execute `on_server_unloaded`` from the configured module (if\n it is defined) when the server is first started.\n\n Args:\n server_context (ServerContext) :\n\n ' return self._on_server_loaded(server_context)
Execute `on_server_unloaded`` from the configured module (if it is defined) when the server is first started. Args: server_context (ServerContext) :
bokeh/application/handlers/lifecycle.py
on_server_loaded
jdlesage/bokeh
1
python
def on_server_loaded(self, server_context): ' Execute `on_server_unloaded`` from the configured module (if\n it is defined) when the server is first started.\n\n Args:\n server_context (ServerContext) :\n\n ' return self._on_server_loaded(server_context)
def on_server_loaded(self, server_context): ' Execute `on_server_unloaded`` from the configured module (if\n it is defined) when the server is first started.\n\n Args:\n server_context (ServerContext) :\n\n ' return self._on_server_loaded(server_context)<|docstring|>Execute `on_server_unloaded`` from the configured module (if it is defined) when the server is first started. Args: server_context (ServerContext) :<|endoftext|>
c3f913d339799524e0e40b1388675007bc2d68188108c761141a7b2d37e52591
def on_server_unloaded(self, server_context): " Execute ``on_server_unloaded`` from the configured module (if\n it is defined) when the server cleanly exits. (Before stopping the\n server's ``IOLoop``.)\n\n Args:\n server_context (ServerContext) :\n\n .. warning::\n In practice this code may not run, since servers are often killed\n by a signal.\n\n " return self._on_server_unloaded(server_context)
Execute ``on_server_unloaded`` from the configured module (if it is defined) when the server cleanly exits. (Before stopping the server's ``IOLoop``.) Args: server_context (ServerContext) : .. warning:: In practice this code may not run, since servers are often killed by a signal.
bokeh/application/handlers/lifecycle.py
on_server_unloaded
jdlesage/bokeh
1
python
def on_server_unloaded(self, server_context): " Execute ``on_server_unloaded`` from the configured module (if\n it is defined) when the server cleanly exits. (Before stopping the\n server's ``IOLoop``.)\n\n Args:\n server_context (ServerContext) :\n\n .. warning::\n In practice this code may not run, since servers are often killed\n by a signal.\n\n " return self._on_server_unloaded(server_context)
def on_server_unloaded(self, server_context): " Execute ``on_server_unloaded`` from the configured module (if\n it is defined) when the server cleanly exits. (Before stopping the\n server's ``IOLoop``.)\n\n Args:\n server_context (ServerContext) :\n\n .. warning::\n In practice this code may not run, since servers are often killed\n by a signal.\n\n " return self._on_server_unloaded(server_context)<|docstring|>Execute ``on_server_unloaded`` from the configured module (if it is defined) when the server cleanly exits. (Before stopping the server's ``IOLoop``.) Args: server_context (ServerContext) : .. warning:: In practice this code may not run, since servers are often killed by a signal.<|endoftext|>
b0366169ffd59183db5e0924ed308f0249b96b0fc6fccf6598122c80f643d001
async def on_session_created(self, session_context): ' Execute ``on_session_created`` from the configured module (if\n it is defined) when a new session is created.\n\n Args:\n session_context (SessionContext) :\n\n ' return self._on_session_created(session_context)
Execute ``on_session_created`` from the configured module (if it is defined) when a new session is created. Args: session_context (SessionContext) :
bokeh/application/handlers/lifecycle.py
on_session_created
jdlesage/bokeh
1
python
async def on_session_created(self, session_context): ' Execute ``on_session_created`` from the configured module (if\n it is defined) when a new session is created.\n\n Args:\n session_context (SessionContext) :\n\n ' return self._on_session_created(session_context)
async def on_session_created(self, session_context): ' Execute ``on_session_created`` from the configured module (if\n it is defined) when a new session is created.\n\n Args:\n session_context (SessionContext) :\n\n ' return self._on_session_created(session_context)<|docstring|>Execute ``on_session_created`` from the configured module (if it is defined) when a new session is created. Args: session_context (SessionContext) :<|endoftext|>
48ffb6b3b090c20856d0337fd0577228a757a1c177942de64e4522f9af2fff66
async def on_session_destroyed(self, session_context): ' Execute ``on_session_destroyed`` from the configured module (if\n it is defined) when a new session is destroyed.\n\n Args:\n session_context (SessionContext) :\n\n ' return self._on_session_destroyed(session_context)
Execute ``on_session_destroyed`` from the configured module (if it is defined) when a new session is destroyed. Args: session_context (SessionContext) :
bokeh/application/handlers/lifecycle.py
on_session_destroyed
jdlesage/bokeh
1
python
async def on_session_destroyed(self, session_context): ' Execute ``on_session_destroyed`` from the configured module (if\n it is defined) when a new session is destroyed.\n\n Args:\n session_context (SessionContext) :\n\n ' return self._on_session_destroyed(session_context)
async def on_session_destroyed(self, session_context): ' Execute ``on_session_destroyed`` from the configured module (if\n it is defined) when a new session is destroyed.\n\n Args:\n session_context (SessionContext) :\n\n ' return self._on_session_destroyed(session_context)<|docstring|>Execute ``on_session_destroyed`` from the configured module (if it is defined) when a new session is destroyed. Args: session_context (SessionContext) :<|endoftext|>
5fe882d13586697b171c55d8b72f407b2d831877c71e89bdde888122cd235ac8
def cnn_model(input_shape, num_of_class): '\n A method to define the CNN architecture\n ' input = Input(shape=input_shape) x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='valid')(input) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='valid')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Flatten()(x) x = Dense(256, activation='relu')(x) output = Dense(num_of_class, activation='softmax')(x) model = Model(input, output) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
A method to define the CNN architecture
ml_proj_init/data/network/cnn_nn.py
cnn_model
faruk-ahmad/ml-proj-init
1
python
def cnn_model(input_shape, num_of_class): '\n \n ' input = Input(shape=input_shape) x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='valid')(input) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='valid')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Flatten()(x) x = Dense(256, activation='relu')(x) output = Dense(num_of_class, activation='softmax')(x) model = Model(input, output) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
def cnn_model(input_shape, num_of_class): '\n \n ' input = Input(shape=input_shape) x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='valid')(input) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', padding='valid')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Flatten()(x) x = Dense(256, activation='relu')(x) output = Dense(num_of_class, activation='softmax')(x) model = Model(input, output) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model<|docstring|>A method to define the CNN architecture<|endoftext|>
dffa24d757efd2e98ed4eab1638a3c5043e42bcf382364c24b446d2c69457974
def train_mnist(x_train, y_train, input_shape, num_classes): '\n a dummy method to train the built CNN model\n ' model = cnn_model(input_shape, num_classes) model.fit(x_train, y_train, epochs=1, batch_size=32, validation_split=0.2) return model
a dummy method to train the built CNN model
ml_proj_init/data/network/cnn_nn.py
train_mnist
faruk-ahmad/ml-proj-init
1
python
def train_mnist(x_train, y_train, input_shape, num_classes): '\n \n ' model = cnn_model(input_shape, num_classes) model.fit(x_train, y_train, epochs=1, batch_size=32, validation_split=0.2) return model
def train_mnist(x_train, y_train, input_shape, num_classes): '\n \n ' model = cnn_model(input_shape, num_classes) model.fit(x_train, y_train, epochs=1, batch_size=32, validation_split=0.2) return model<|docstring|>a dummy method to train the built CNN model<|endoftext|>