class VerifyStatusUI(PeachyFrame):

    def initialize(self):
        self.grid()
        
        self._elapsed_time = StringVar()
        self._current_layer = IntVar()
        self._current_height = StringVar()
        self._current_model_height = StringVar()
        self._errors = IntVar()
        self._status = StringVar()
        self._stop_button_text = StringVar()
        self._stop_button_text.set("Abort Verification")
        self._current_status = {}

        self._print_api = PrintAPI(self.kwargs['config'],status_call_back = self.status_call_back)
        if 'filename' in self.kwargs:
            file_to_print = self.kwargs['filename']
            self._print_api.verify_gcode(file_to_print)
        else:
            self._print_api.verify_gcode(self.kwargs['layer_generator'])


        Label(self, text = "Verifying Model" ).grid(column=0,row=5)
        Label(self ).grid(column=0,row=8)

        Label(self, text = "Elapsed Time" ).grid(column=0,row=10)
        Label(self, textvariable = self._elapsed_time ).grid(column=1,row=10)

        Label(self, text = "Layer" ).grid(column=0,row=20)
        Label(self, textvariable = self._current_layer ).grid(column=1,row=20)

        Label(self, text = "Model Height (mm)" ).grid(column=0,row=35)
        Label(self, textvariable = self._current_model_height ).grid(column=1,row=35)

        Label(self, text = "Status").grid(column=0,row=60)
        Label(self, textvariable = self._status).grid(column=1,row=60)

        Label(self, text = "Errors" ).grid(column=0,row=70)
        Label(self, textvariable = self._errors ).grid(column=1,row=70)

        Label(self).grid(column=0,row=70)
        
        Button(self,textvariable=self._stop_button_text, command=self._stop_button_click).grid(column=2,row=80)
        Button(self,text="Show Errors", command=self._show_errors).grid(column=3,row=80)
        
        self.update()

    def _stop_button_click(self):
        self._print_api.stop()
        self.navigate(self.kwargs['calling_class'], printer = self.kwargs['printer'])

    def _show_errors(self):
        PopUp(self,'Errors', '\n'.join([ "SubLayer %s : %s" % (err['layer'], err['message']) for err in self._current_status['errors'] ]))

    def status_call_back(self,status):
        total_seconds = int(status['elapsed_time'].total_seconds())
        hours, remainder = divmod(total_seconds,60*60)
        minutes, seconds = divmod(remainder,60)

        self._elapsed_time.set("%02d:%02d:%02d" % (hours,minutes,seconds))
        self._current_layer.set(status['current_layer'])
        self._current_model_height.set("%.2f" % status['model_height'])
        self._errors.set(len(status['errors']))
        self._current_status = status
        self._status.set(status['status'])
        if (status['status'] == "Complete"):
            self._stop_button_text.set("Finished")

    def close(self):
        self._print_api.stop()
    def test_verify_gcode_should_create_required_classes_and_start_it_and_return_errors(self,
            mock_SubLayerGenerator, 
            mock_AudioDripZAxis,
            mock_AudioModulationLaserControl,
            mock_GCodeReader,
            mock_AudioWriter,
            mock_Transformer,
            mock_PathToAudio,
            mock_Controller,
            ):
        gcode_path = "FakeFile"
        actual_samples_per_second = 7
        fake_layers = "Fake Layers"
        mock_dripbasedzaxis = mock_AudioDripZAxis.return_value
        mock_audiomodulationlasercontrol = mock_AudioModulationLaserControl.return_value
        mock_gcodereader = mock_GCodeReader.return_value
        mock_sublayergenerator = mock_SubLayerGenerator.return_value
        mock_audiowriter = mock_AudioWriter.return_value
        mock_transformer = mock_Transformer.return_value
        mock_pathtoaudio = mock_PathToAudio.return_value
        mock_controller = mock_Controller.return_value
        expected_errors = ['Some Error']
        mock_controller.get_status.return_value = {'errors':expected_errors}

        mock_audiomodulationlasercontrol.actual_samples_per_second = actual_samples_per_second
        mock_gcodereader.get_layers.return_value = fake_layers

        test_config = self.default_config
        api = PrintAPI(test_config)
        api.verify_gcode(gcode_path)


        mock_SubLayerGenerator.assert_called_with(
            fake_layers,
            test_config.options.sublayer_height_mm
            )

        self.assertEquals(0, mock_AudioDripZAxis.call_count)
        mock_AudioModulationLaserControl.assert_called_with(
            test_config.audio.output.sample_rate,
            test_config.audio.output.modulation_on_frequency,
            test_config.audio.output.modulation_off_frequency,
            test_config.options.laser_offset
            )
        mock_GCodeReader.assert_called_with(gcode_path)

        self.assertEquals(0, mock_AudioWriter.call_count)

        mock_Transformer.assert_called_with(
            test_config.calibration.max_deflection,
            test_config.calibration.height,
            test_config.calibration.lower_points,
            test_config.calibration.upper_points,
            )
        mock_PathToAudio.assert_called_with(
            actual_samples_per_second,
            mock_transformer, 
            test_config.options.laser_thickness_mm
            )
        mock_Controller.assert_called_with(
            mock_audiomodulationlasercontrol,
            mock_pathtoaudio,
            None,
            mock_sublayergenerator,
            zaxis = None,
            status_call_back = None,
            max_lead_distance = test_config.dripper.max_lead_distance_mm,
            abort_on_error = False
            )
예제 #3
0
class VerifyStatusUI(PeachyFrame):
    def initialize(self):
        self.grid()

        self._elapsed_time = StringVar()
        self._current_layer = IntVar()
        self._current_height = StringVar()
        self._current_model_height = StringVar()
        self._errors = IntVar()
        self._status = StringVar()
        self._stop_button_text = StringVar()
        self._stop_button_text.set("Abort Verification")
        self._current_status = {}

        self._print_api = PrintAPI(self.kwargs['config'],
                                   status_call_back=self.status_call_back)
        if 'filename' in self.kwargs:
            file_to_print = self.kwargs['filename']
            self._print_api.verify_gcode(file_to_print)
        else:
            self._print_api.verify_gcode(self.kwargs['layer_generator'])

        Label(self, text="Verifying Model").grid(column=0, row=5)
        Label(self).grid(column=0, row=8)

        Label(self, text="Elapsed Time").grid(column=0, row=10)
        Label(self, textvariable=self._elapsed_time).grid(column=1, row=10)

        Label(self, text="Layer").grid(column=0, row=20)
        Label(self, textvariable=self._current_layer).grid(column=1, row=20)

        Label(self, text="Model Height (mm)").grid(column=0, row=35)
        Label(self, textvariable=self._current_model_height).grid(column=1,
                                                                  row=35)

        Label(self, text="Status").grid(column=0, row=60)
        Label(self, textvariable=self._status).grid(column=1, row=60)

        Label(self, text="Errors").grid(column=0, row=70)
        Label(self, textvariable=self._errors).grid(column=1, row=70)

        Label(self).grid(column=0, row=70)

        Button(self,
               textvariable=self._stop_button_text,
               command=self._stop_button_click).grid(column=2, row=80)
        Button(self, text="Show Errors",
               command=self._show_errors).grid(column=3, row=80)

        self.update()

    def _stop_button_click(self):
        self._print_api.stop()
        self.navigate(self.kwargs['calling_class'],
                      printer=self.kwargs['printer'])

    def _show_errors(self):
        PopUp(
            self, 'Errors', '\n'.join([
                "SubLayer %s : %s" % (err['layer'], err['message'])
                for err in self._current_status['errors']
            ]))

    def status_call_back(self, status):
        total_seconds = int(status['elapsed_time'].total_seconds())
        hours, remainder = divmod(total_seconds, 60 * 60)
        minutes, seconds = divmod(remainder, 60)

        self._elapsed_time.set("%02d:%02d:%02d" % (hours, minutes, seconds))
        self._current_layer.set(status['current_layer'])
        self._current_model_height.set("%.2f" % status['model_height'])
        self._errors.set(len(status['errors']))
        self._current_status = status
        self._status.set(status['status'])
        if (status['status'] == "Complete"):
            self._stop_button_text.set("Finished")

    def close(self):
        self._print_api.stop()
    def test_verify_gcode_should_create_required_classes_and_start_it_and_return_errors(self,
            mock_SubLayerGenerator, 
            mock_DripBasedZAxis,
            mock_AudioModulationLaserControl,
            mock_GCodeReader,
            mock_AudioWriter,
            mock_Transformer,
            mock_PathToAudio,
            mock_Controller,
            ):
        gcode_path = "FakeFile"
        actual_samples_per_second = 7
        fake_layers = "Fake Layers"
        mock_dripbasedzaxis = mock_DripBasedZAxis.return_value
        mock_audiomodulationlasercontrol = mock_AudioModulationLaserControl.return_value
        mock_gcodereader = mock_GCodeReader.return_value
        mock_sublayergenerator = mock_SubLayerGenerator.return_value
        mock_audiowriter = mock_AudioWriter.return_value
        mock_transformer = mock_Transformer.return_value
        mock_pathtoaudio = mock_PathToAudio.return_value
        mock_controller = mock_Controller.return_value
        expected_errors = ['Some Error']
        mock_controller.get_status.return_value = {'errors':expected_errors}

        mock_audiomodulationlasercontrol.actual_samples_per_second = actual_samples_per_second
        mock_gcodereader.get_layers.return_value = fake_layers


        api = PrintAPI(self.DEFAULT_CONFIG)
        api.verify_gcode(gcode_path)


        mock_SubLayerGenerator.assert_called_with(
            fake_layers,
            self.DEFAULT_CONFIG['sublayer_height_mm']
            )

        self.assertEquals(0, mock_DripBasedZAxis.call_count)
        mock_AudioModulationLaserControl.assert_called_with(
            self.DEFAULT_CONFIG['output_sample_frequency'],
            self.DEFAULT_CONFIG['on_modulation_frequency'],
            self.DEFAULT_CONFIG['off_modulation_frequency'],
            )
        mock_GCodeReader.assert_called_with(gcode_path)

        self.assertEquals(0, mock_AudioWriter.call_count)

        mock_Transformer.assert_called_with(self.DEFAULT_CONFIG['calibration_data'], scale = self.DEFAULT_CONFIG['max_deflection'])
        mock_PathToAudio.assert_called_with(
            actual_samples_per_second,
            mock_transformer, 
            self.DEFAULT_CONFIG['laser_thickness_mm']
            )
        mock_Controller.assert_called_with(
            mock_audiomodulationlasercontrol,
            mock_pathtoaudio,
            None,
            mock_sublayergenerator,
            zaxis = None,
            zaxis_control = None,
            status_call_back = None,
            max_lead_distance = self.DEFAULT_CONFIG['max_lead_distance_mm'],
            abort_on_error = False
            )
    def test_verify_gcode_should_create_required_classes_and_start_it_and_return_errors(
        self,
        mock_SubLayerGenerator,
        mock_AudioDripZAxis,
        mock_AudioModulationLaserControl,
        mock_GCodeReader,
        mock_AudioWriter,
        mock_Transformer,
        mock_PathToAudio,
        mock_Controller,
    ):
        gcode_path = "FakeFile"
        actual_samples_per_second = 7
        fake_layers = "Fake Layers"
        mock_dripbasedzaxis = mock_AudioDripZAxis.return_value
        mock_audiomodulationlasercontrol = mock_AudioModulationLaserControl.return_value
        mock_gcodereader = mock_GCodeReader.return_value
        mock_sublayergenerator = mock_SubLayerGenerator.return_value
        mock_audiowriter = mock_AudioWriter.return_value
        mock_transformer = mock_Transformer.return_value
        mock_pathtoaudio = mock_PathToAudio.return_value
        mock_controller = mock_Controller.return_value
        expected_errors = ['Some Error']
        mock_controller.get_status.return_value = {'errors': expected_errors}

        mock_audiomodulationlasercontrol.actual_samples_per_second = actual_samples_per_second
        mock_gcodereader.get_layers.return_value = fake_layers

        test_config = self.default_config
        api = PrintAPI(test_config)
        api.verify_gcode(gcode_path)

        mock_SubLayerGenerator.assert_called_with(
            fake_layers, test_config.options.sublayer_height_mm)

        self.assertEquals(0, mock_AudioDripZAxis.call_count)
        mock_AudioModulationLaserControl.assert_called_with(
            test_config.audio.output.sample_rate,
            test_config.audio.output.modulation_on_frequency,
            test_config.audio.output.modulation_off_frequency,
            test_config.options.laser_offset)
        mock_GCodeReader.assert_called_with(gcode_path)

        self.assertEquals(0, mock_AudioWriter.call_count)

        mock_Transformer.assert_called_with(
            test_config.calibration.max_deflection,
            test_config.calibration.height,
            test_config.calibration.lower_points,
            test_config.calibration.upper_points,
        )
        mock_PathToAudio.assert_called_with(
            actual_samples_per_second, mock_transformer,
            test_config.options.laser_thickness_mm)
        mock_Controller.assert_called_with(
            mock_audiomodulationlasercontrol,
            mock_pathtoaudio,
            None,
            mock_sublayergenerator,
            zaxis=None,
            status_call_back=None,
            max_lead_distance=test_config.dripper.max_lead_distance_mm,
            abort_on_error=False)