예제 #1
0
 def _update_image_properties(self):
     """
     Actualiza los campos que muestran las propiedades de la imagen
     """
     index = self._images_list.currentRow() #obtener el índice de la imagen seleccionada
     if 0 <= index < self._images_list.count():
         id = self._images_ids[index] #obtener el id de la imagen según el índice
         img = Application.get_images()[id]
         self._images_list.currentItem().setText(img.DisplayName)
         index = self._images_list.currentRow() #obtener el índice de la imagen seleccionada
         id = self._images_ids[index] #obtener el id de la imagen según el índice
         img = Application.get_images()[id] #imagen para obtener las propiedades
         #actualizar los atributos de la imagen que se muestran
         self._properties_tree.blockSignals(True)
         self._id_prop.setText(1,str(img.Id))
         self._name_prop.setText(1,str(img.DisplayName))
         self._format_prop.setText(1,str(img.OriginalFormat))
         self._file_prop.setText(1,str(img.OriginalFile))
         self._dim_prop.setText(1,str(img.Dimension))
         self._pt_prop.setText(1,str(img.PixelType))
         self._size_prop.setText(1,str(img.Size))
         self._sizeX_prop.setText(1,str(img.Size[0]))
         self._sizeY_prop.setText(1,str(img.Size[1]))
         self._sizeZ_prop.setText(1,str(img.Size[2]))
         self._spc_prop.setText(1,str(img.Spacing))
         self._spcX_prop.setText(1,str(img.Spacing[0]))
         self._spcY_prop.setText(1,str(img.Spacing[1]))
         self._spcZ_prop.setText(1,str(img.Spacing[2]))
         self._properties_tree.blockSignals(False)
예제 #2
0
 def _load_series(self):
     img_ldr = SeriesLoader()  #crear un cargador
     res, img = img_ldr.run()  #ejecutar el cargador
     if res == ImageLoader.OK:
         Application.add_image(
             img)  #agregar la nueva imagen cargada a la aplicación
         #notificar al sincronizador de las propiedades de las imágenes que hay una nueva imagen cargada
         self._images_ui_synchronizer.add_image(img)
예제 #3
0
 def _processImage(self):
     wt = WaitProcess
     wt.run()
     wt.change_value(50)
     wt.change_info("Procesando imagen")
     Application.processImage()
     wt.change_value(80)
     wt.change_info("Visualizando datos")
     #actualizar la vista de los tres planos de la imagen procesada
     self._processed_planes.Image = Application.get_processed_image()
     self._filters_ui_synchronizer._update_filters_properties()
     wt.stop()
예제 #4
0
    def _update_filters_properties(self):
        """
        Actualiza las propiedades que se muestran de los filtros
        """
        self._properties_tree.blockSignals(True)

        smooth = Application.get_current_document()._smooth_pipe
        self._iterations_prop.setText(1,str(smooth.NumberOfIterations))
        self._time_step_prop.setText(1,str(smooth.TimeStep))
        self._conductance_prop.setText(1,str(smooth.Conductance))
        self._smoother_prop.setText(1,str([smooth.NumberOfIterations,smooth.TimeStep,
                                           smooth.Conductance]))
        state = Qt.Unchecked
        if Application.get_current_document().usingSmoother():
            state = Qt.Checked
        self._smoother_prop.setCheckState(0,state)

        segment = Application.get_current_document()._segment_pipe
        self._seed_prop.setText(1,str(segment.Seed))
        self._seedX_prop.setText(1,str(segment.Seed[0]))
        self._seedY_prop.setText(1,str(segment.Seed[1]))
        self._seedZ_prop.setText(1,str(segment.Seed[2]))
        self._min_threshold_prop.setText(1,str(segment.LowerThreshold))
        self._max_threshold_prop.setText(1,str(segment.UpperThreshold))
        self._replace_value_prop.setText(1,str(segment.ReplaceValue))
        state = Qt.Unchecked
        if Application.get_current_document().usingSegmentor():
            state = Qt.Checked
        self._segment_prop.setCheckState(0,state)


        confidence = Application.get_current_document()._confidence_connected_pipe
        self._conf_seed_prop.setText(1,str(confidence.Seed))
        self._conf_seedX_prop.setText(1,str(confidence.Seed[0]))
        self._conf_seedY_prop.setText(1,str(confidence.Seed[1]))
        self._conf_seedZ_prop.setText(1,str(confidence.Seed[2]))
        self._conf_radius_prop.setText(1,str(confidence.InitialRadius))
        self._conf_mult_value_prop.setText(1,str(confidence.Multiplier))
        self._conf_repl_value_prop.setText(1,str(confidence.ReplaceValue))
        self._conf_iter_prop.setText(1,str(confidence.NumberOfIterations))
        state = Qt.Unchecked
        if Application.get_current_document().usingConfidenceConnected():
            state = Qt.Checked
        self._confidence_prop.setCheckState(0,state)

        voting = Application.get_current_document()._voting_pipe
        self._radius_prop.setText(1,str(voting.Radius))
        self._radiusX_prop.setText(1,str(voting.Radius[0]))
        self._radiusY_prop.setText(1,str(voting.Radius[1]))
        self._radiusZ_prop.setText(1,str(voting.Radius[2]))
        self._foreground_prop.setText(1,str(voting.Foreground))
        self._background_prop.setText(1,str(voting.Background))
        self._survival_prop.setText(1,str(voting.SurvivalValue))
        self._birth_prop.setText(1,str(voting.BirthValue))
        state = Qt.Unchecked
        if Application.get_current_document().usingVoter():
            state = Qt.Checked
        self._voting_prop.setCheckState(0,state)

        self._properties_tree.blockSignals(False)
예제 #5
0
 def _update_image(self,item,col):
     """
     Actualiza las propiedades de la imagen luego de haberlas editado
     @param item: item que se editó
     @param col: columna del item que se editó
     @return: None
     """
     #cambiaron la etiqueta de la propiedad no el valor
     if col == 0:
         self._update_editable_labels() #restaurar las etiquetas
         return
     id = self.get_selected_image_id() #obtener el id de la imagen seleccionada
     if id is None: #no se ha seleccionado ninguna imagen
         return
     img = Application.get_images()[id]
     if item.text(0) == "Nombre":
         #actualizamos el nombre
         img.DisplayName = self._name_prop.text(1)
     elif item.text(0) in ["X","Y","Z"]:
         #actualizamos el espaciado
         spc = [self._spcX_prop.text(1),
                self._spcY_prop.text(1),
                self._spcZ_prop.text(1)]
         try:
             spc = map(float,spc)
             #verificar que no haya un espaciado mayor que 100 o menor o igual que 0
             if any(map(lambda x: 100.0<=x or x<=0.0,spc)):
                 raise ValueError()
             img.Spacing = spc
         except ValueError:
             pass
     self._update_image_properties()
예제 #6
0
 def _update_current_image_name(self, item, col):
     id = self._images_ui_synchronizer.get_selected_image_id()
     img = Application.get_current_image()
     if id is None or img is None:
         return
     if id == img.Id and col == 1 and item.text(0) == "Nombre":
         self._ui.imageName.setText(item.text(1))
예제 #7
0
def base(browser_type, base_url, path):
    driver = None
    if browser_type == "firefox":
        driver = webdriver.Firefox(path)
    elif browser_type == "chrome":
        driver = webdriver.Chrome(path)
    driver.maximize_window()
    yield Application(driver, base_url)
    driver.close()
예제 #8
0
def app(request, browser_type, base_url):
    if browser_type == "firefox":
        driver = webdriver.Firefox()
    elif browser_type == "chrome":
        driver = webdriver.Chrome()
    elif browser_type == "ie":
        driver = webdriver.Ie()
    request.addfinalizer(driver.quit)
    return Application(driver, base_url)
예제 #9
0
def app(request, browser_type, base_url):
    if browser_type == "firefox":
        driver = webdriver.Firefox()
    elif browser_type == "chrome":
        driver = webdriver.Chrome()
    elif browser_type == "ie":
        driver = webdriver.Ie()
    #driver.implicitly_wait(30)
    request.addfinalizer(driver.quit)  #close brawser
    return Application(driver, base_url)
예제 #10
0
 def application(self, request):
     """
     Фикстура для инициализации тестовой конфигурации
     :param request:
     :param driver: Appium driver
     :param test_path: директория с тестами
     :rtype class
     :return: объект класса Application
     """
     return Application(request)
예제 #11
0
 def _update_image(self):
     wt = WaitProcess
     wt.run()
     wt.change_info("Obteniendo imagen")
     wt.change_value(5)
     id = self._images_ui_synchronizer.get_selected_image_id()
     #verificar si la imagen seleccionada es distinta de la imagen actual
     clean_pipes = (Application.get_current_image_id() != id)
     #limpia las tuberías en caso de ser necesario
     if id is not None:
         if clean_pipes:
             Application.get_current_document().clean_pipes()
         wt.change_info("Cambiando imagen")
         wt.change_value(50)
         Application.set_current_image_id(id)  #cambiar la imagen actual
         img = Application.get_current_image()  #obtener la imagen actual
         self._ui.imageName.setText(
             img.DisplayName)  #actualiza el nombre mostrado de la imagen
         wt.change_info("Visualizando imagen")
         wt.change_value(65)
         #actualizar la vista de los tres planos de la imagen
         self._planes.Image = img
         #habilitar el procesameinto de la imagen
         self._ui.processImage.setEnabled(True)
         #habilitar la configuración de los filtros
         self._ui.filters.setEnabled(True)
         #habilitar la salva de la configuración de los filtros
         self._ui.actionGuardar_2.setEnabled(True)
         #habilitar la carga de la configuración de los filtros
         self._ui.actionCargar_configuraci_n.setEnabled(True)
         #actualizar la información de los filtros
         self._filters_ui_synchronizer.update()
     wt.stop()
예제 #12
0
def app(request, browser_type, base_url):
    if browser_type == "firefox":
        driver = webdriver.Remote('http://172.17.10.17:4444/wd/hub',
                                  webdriver.DesiredCapabilities.FIREFOX)
    # FIXME разобраться у удаленным запуском хрома(сервер пишет нужно указать какие-то опции)
    elif browser_type == "chrome":
        driver = webdriver.Remote('http://172.17.10.17:4444/wd/hub',
                                  webdriver.DesiredCapabilities.CHROME)
    # TODO установить драйвер для IE
    elif browser_type == "ie":
        driver = webdriver.Remote('http://172.17.10.17:4444/wd/hub',
                                  webdriver.DesiredCapabilities.Ie)
    # driver.implicitly_wait(10)
    request.addfinalizer(driver.quit)
    return Application(driver, base_url)
예제 #13
0
    def _calculate_data(self):
        img = Application.get_processed_image()
        if img is None:
            return

        self._ui.calculate.setEnabled(False)

        writer = itk.ImageFileWriter[
            img.ImageType].New()  #crear el writer de ITK
        writer.SetFileName(
            self._temp_file_path)  #ponerle el nombre seleccionado
        writer.SetInput(img.InternalImage)  #conectar la imagen a guardar
        writer.Update()  #guardar la imagen!

        subprocess.call([
            self._volume_exec_path, self._temp_file_path,
            self._volume_file_path
        ])
        #os.system('"'+self._volume_exec_path+'" "'+self._temp_file_path+'" '+self._volume_file_path)

        spc = img.Spacing
        spc_factor = spc[0] * spc[1] * spc[2]

        f = open(self._volume_file_path, 'rt')
        try:
            self._vol = float(f.readline()) * spc_factor

            self._lenX = float(f.readline()) * spc[0]
            self._startX = map(int, f.readline()[1:-2].split(", "))
            self._endX = map(int, f.readline()[1:-2].split(", "))

            self._lenY = float(f.readline()) * spc[1]
            self._startY = map(int, f.readline()[1:-2].split(", "))
            self._endY = map(int, f.readline()[1:-2].split(", "))

            self._lenZ = float(f.readline()) * spc[2]
            self._startZ = map(int, f.readline()[1:-2].split(", "))
            self._endZ = map(int, f.readline()[1:-2].split(", "))
        finally:
            f.close()

        self._update_labels()
        self._ui.calculate.setEnabled(True)
        self._ui.save.setEnabled(True)
예제 #14
0
    def save_configuration(self):
        res = self._file_save_dialog.exec_(
        )  #ejecutar el diálogo para obtener el nombre del fichero
        if res == QFileDialog.Rejected:  #se canceló la salva
            return
        file_name = unicode(self._file_save_dialog.selectedFiles()
                            [0])  #obtener el nombre del fichero
        doc = Application.get_current_document(
        )  #referencia al docmento actual de la aplicación
        f = open(file_name, "wt")
        try:
            smoother = doc._smooth_pipe
            f.write(str(doc.usingSmoother()) + "\n")
            f.write(str(smoother.NumberOfIterations) + "\n")
            f.write(str(smoother.TimeStep) + "\n")
            f.write(str(smoother.Conductance) + "\n")

            segmentor = doc._segment_pipe
            f.write(str(doc.usingSegmentor()) + "\n")
            f.write(str(segmentor.Seed) + "\n")
            f.write(str(segmentor.LowerThreshold) + "\n")
            f.write(str(segmentor.UpperThreshold) + "\n")
            f.write(str(segmentor.ReplaceValue) + "\n")

            conf_conn = doc._confidence_connected_pipe
            f.write(str(doc.usingConfidenceConnected()) + "\n")
            f.write(str(conf_conn.Seed) + "\n")
            f.write(str(conf_conn.InitialRadius) + "\n")
            f.write(str(conf_conn.Multiplier) + "\n")
            f.write(str(conf_conn.ReplaceValue) + "\n")
            f.write(str(conf_conn.NumberOfIterations) + "\n")

            voter = doc._voting_pipe
            f.write(str(doc.usingVoter()) + "\n")
            f.write(str(voter.Radius) + "\n")
            f.write(str(voter.Background) + "\n")
            f.write(str(voter.Foreground) + "\n")
            f.write(str(voter.SurvivalValue) + "\n")
            f.write(str(voter.BirthValue) + "\n")
        finally:
            f.close()
예제 #15
0
    def load_configuration(self):
        res = self._file_load_dialog.exec_(
        )  #ejecutar el diálogo para obtener el nombre del fichero
        if res == QFileDialog.Rejected:  #se canceló la salva
            return
        file_name = unicode(self._file_load_dialog.selectedFiles()
                            [0])  #obtener el nombre del fichero
        doc = Application.get_current_document(
        )  #referencia al docmento actual de la aplicación
        f = open(file_name, "rt")
        try:
            smoother = doc._smooth_pipe
            doc.useSmoother(self._read_bool(f))
            smoother.NumberOfIterations = self._read_int(f)
            smoother.TimeStep = self._read_float(f)
            smoother.Conductance = self._read_float(f)

            segmentor = doc._segment_pipe
            doc.useSegmentor(self._read_bool(f))
            segmentor.Seed = self._read_int_list(f)
            segmentor.LowerThreshold = self._read_float(f)
            segmentor.UpperThreshold = self._read_float(f)
            segmentor.ReplaceValue = self._read_float(f)

            conf_conn = doc._confidence_connected_pipe
            doc.useConfidenceConnected(self._read_bool(f))
            conf_conn.Seed = self._read_int_list(f)
            conf_conn.InitialRadius = self._read_int(f)
            conf_conn.Multiplier = self._read_float(f)
            conf_conn.ReplaceValue = self._read_float(f)
            conf_conn.NumberOfIterations = self._read_int(f)

            voter = doc._voting_pipe
            doc.useVoter(self._read_bool(f))
            voter.Radius = self._read_int_list(f)
            voter.Background = self._read_float(f)
            voter.Foreground = self._read_float(f)
            voter.SurvivalValue = self._read_int(f)
            voter.BirthValue = self._read_int(f)
        finally:
            f.close()
예제 #16
0
from graphviz import Digraph
from model.microservices import Microservices
from model.process import Process
from model.application import Application
from model.infrastructure import Infrastructure
from model.observability import Observability
from model.test import Test

dot = Digraph(comment='Microservices Roadmap', format='png')

root = Microservices()
root.build(dot)

application = Application()
application.build(dot)

infrastructure = Infrastructure()
infrastructure.build(dot)

observability = Observability()
observability.build(dot)

process = Process()
process.build(dot)

test = Test()
test.build(dot)

dot.render('images/roadmap.gv', view=True)
예제 #17
0
파일: test.py 프로젝트: maaxlee/php4dvd
class TestFirst:

    def setup(self):
        core.config.browser = webdriver.Firefox()
        core.config.browser.implicitly_wait(5)
        core.config.browser.get(core.config.url)
        self.app = Application()
        self.app.login(core.config.credentials)

    def teardown(self):
        self.app.logout()
        core.config.browser.close()

    @logger
    def test_001_add(self):
        """test_001_add"""
        self.app.add_movie(movie)
        self.app.check_movie_in_list(movie['title'])
        db_conditions.delete(movie)

    @logger
    def test_002_delete(self):
        """test_002_delete"""
        db_conditions.add(movie)
        self.app.refresh()
        self.app.navigate_to_movie(movie['title'])
        self.app.delete_movie()
        self.app.check_movie_is_not_on_page(movie['title'])
예제 #18
0
파일: test.py 프로젝트: maaxlee/php4dvd
 def setup(self):
     core.config.browser = webdriver.Firefox()
     core.config.browser.implicitly_wait(5)
     core.config.browser.get(core.config.url)
     self.app = Application()
     self.app.login(core.config.credentials)
예제 #19
0
 def app(self, driver, base_url: str, test_path):
     config_name = self.get_config_name()
     return Application(driver, base_url, test_path, config_name)
예제 #20
0
 def _save_image(self):
     img_svr = ImageSaver()  #crear el diálogo
     img_svr.saveImage(Application.get_processed_image())  #salvar la imagen
예제 #21
0
def app(request):
    driver = webdriver.Chrome()
    driver.implicitly_wait(10)
    request.addfinalizer(driver.quit)
    return Application(driver)
예제 #22
0
from tkinter import Tk
from model.application import Application

if __name__ == '__main__':
    root = Tk()
    root.title("Campo Minado")
    Application(root)
    root.mainloop()
예제 #23
0
파일: main.py 프로젝트: aj-fuentes/BrainApp
from controller.configuration_manager import ConfigurationManager
from controller.image_loader import ImageLoader
from controller.interface_runner import InterfaceRunner
from controller.main_window import MainWindow
from controller.slice_visualization import SliceVisualization
from controller.three_planes_visualization import ThreePlanesVisualization
from model.application import Application
from model.image import Image

__author__ = 'Alvaro Javier'

#app = QApplication([])

#app.exec_()

Application.init()
InterfaceRunner.init()
ConfigurationManager.init()
main_wnidow = MainWindow()
InterfaceRunner.start_even_loop(main_wnidow)

#img_ldr = ImageLoader()
#res,img = img_ldr.run()
#if res == ImageLoader.Canceled:
#    sys.exit(1)

#img = Application.Images()[0]

#img.InternalImage.SetSpacing((1.015625, 1.015625, 1.800000))
#img.InternalImage.SetSpacing((0.9375, 0.9375, 3.1))
예제 #24
0
def app(request):
    driver = webdriver.Firefox()
    # driver.implicitly_wait(30)
    request.addfinalizer(driver.quit)
    return Application(driver)
예제 #25
0
    def _update_filters(self,item,col):
        """
        Actualiza las propiedades de los filtros luego de editarlas
        @param item: item que se editó
        @param col: columna del item que se editó
        @return: None
        """
        #cambiaron la etiqueta de la propiedad no el valor
        if col == 0:
            self._update_editable_labels()
            if item.text(0) == "Suavizador":
                Application.get_current_document().useSmoother(item.checkState(0) == Qt.Checked)
            elif item.text(0) == "Segmentador":
                Application.get_current_document().useSegmentor(item.checkState(0) == Qt.Checked)
            elif item.text(0) == "Segmentador estadístico":
                Application.get_current_document().useConfidenceConnected(item.checkState(0) == Qt.Checked)
            elif item.text(0) == "Votación":
                Application.get_current_document().useVoter(item.checkState(0) == Qt.Checked)
            return
        if item.text(0) == "Iteraciones" and item.parent().text(0) == "Suavizador":
            try:
                num = int(item.text(1))
                if num<0 or num>20:
                    raise ValueError()
                Application.get_current_document()._smooth_pipe.NumberOfIterations = num
            except ValueError:
                pass
        elif item.text(0) == "Iteraciones" and item.parent().text(0) == "Segmentador estadístico":
            try:
                num = int(item.text(1))
                if num<0 or num>50:
                    raise ValueError()
                Application.get_current_document()._confidence_connected_pipe.NumberOfIterations = num
            except ValueError:
                pass
        elif item.text(0) == "Paso de tiempo":
            try:
                num = float(item.text(1))
                if num<0.0 or num>1.0: #límites del paso de tiempo
                    raise ValueError()
                Application.get_current_document()._smooth_pipe.TimeStep = num
            except ValueError:
                pass
        elif item.text(0) == "Conductancia":
            try:
                num = float(item.text(1))
                if num<0.0 or num>100.0: #límites rasonables de conductancia
                    raise ValueError()
                Application.get_current_document()._smooth_pipe.Conductance = num
            except ValueError:
                pass
        elif item.parent().text(0) == "Semilla" and item.parent().parent().text(0) == "Segmentador":
            #los hijos de 'Semilla' son las coordenadas
            seed = [ self._seedX_prop.text(1),
                     self._seedY_prop.text(1),
                     self._seedZ_prop.text(1) ]
            try:
                seed = map(int,seed)
                #verificar que no se incluya como semilla un valor mayor que el tamaño de la imagen o
                #menor que cero
                if any(map(lambda x: x<0,seed)) or\
                   any(imap(lambda x,y: x>=y,seed,Application.get_current_image().Size)):
                    raise ValueError()
                Application.get_current_document()._segment_pipe.Seed = seed
            except ValueError:
                pass
        elif item.parent().text(0) == "Semilla" and item.parent().parent().text(0) == "Segmentador estadístico":
            #los hijos de 'Semilla' son las coordenadas
            seed = [ self._conf_seedX_prop.text(1),
                     self._conf_seedY_prop.text(1),
                     self._conf_seedZ_prop.text(1) ]
            try:
                seed = map(int,seed)
                #verificar que no se incluya como semilla un valor mayor que el tamaño de la imagen o
                #menor que cero
                if any(map(lambda x: x<0,seed)) or\
                   any(imap(lambda x,y: x>=y,seed,Application.get_current_image().Size)):
                    raise ValueError()
                Application.get_current_document()._confidence_connected_pipe.Seed = seed
            except ValueError:
                pass
        elif item.text(0) == "Mínimo":
            try:
                min = float(self._min_threshold_prop.text(1))
                Application.get_current_document()._segment_pipe.LowerThreshold = min
            except ValueError:
                pass
        elif item.text(0) == "Máximo":
            try:
                max = float(self._max_threshold_prop.text(1))
                Application.get_current_document()._segment_pipe.UpperThreshold = max
            except ValueError:
                pass
        elif item.text(0) == "Relleno" and item.parent().parent().text(0) == "Segmentador":
            try:
                val = float(self._replace_value_prop.text(1))
                Application.get_current_document()._segment_pipe.ReplaceValue = val
            except ValueError:
                pass
        elif item.text(0) == "Relleno" and item.parent().parent().text(0) == "Segmentador estadístico":
            try:
                val = float(self._conf_repl_value_prop.text(1))
                Application.get_current_document()._confidence_connected_pipe.ReplaceValue = val
            except ValueError:
                pass
        elif item.parent().text(0) == "Radio":
            radius = [  self._radiusX_prop.text(1),
                        self._radiusY_prop.text(1),
                        self._radiusZ_prop.text(1) ]
            try:
                radius = map(str,radius)
                radius = map(int,radius)
                #verificar que no se incluya como radio un valor sensato (por ahora entre 0 y 20)
                if any(map(lambda x: x<0 or x>20,radius)):
                    raise ValueError()
                Application.get_current_document()._voting_pipe.Radius = radius
            except ValueError:
                pass
        elif item.text(0) == "Radio inicial":
            try:
                val = int(self._conf_radius_prop.text(1))
                if val<0 or val>20:
                    raise ValueError()
                Application.get_current_document()._confidence_connected_pipe.InitialRadius = val
            except ValueError:
                pass
        elif item.text(0) == "Multiplicador":
            try:
                val = float(self._conf_mult_value_prop.text(1))
                if val<0:
                    raise ValueError()
                Application.get_current_document()._confidence_connected_pipe.Multiplier = val
            except ValueError:
                pass
        elif item.text(0) == "Fondo":
            try:
                val = int(self._background_prop.text(1))
                if val<0 or val>255:
                    raise ValueError()
                Application.get_current_document()._voting_pipe.Background = val
            except ValueError:
                pass
        elif item.text(0) == "Máscara":
            try:
                val = int(self._foreground_prop.text(1))
                if val<0:
                    raise ValueError()
                Application.get_current_document()._voting_pipe.Foreground = val
            except ValueError:
                pass
        elif item.text(0) == "Supervivencia":
            try:
                val = int(self._survival_prop.text(1))
                if val<0:
                    raise ValueError()
                Application.get_current_document()._voting_pipe.SurvivalValue = val
            except ValueError:
                pass
        elif item.text(0) == "Nacimiento":
            try:
                val = int(self._birth_prop.text(1))
                if val<0:
                    raise ValueError()
                Application.get_current_document()._voting_pipe.BirthValue = val
            except ValueError:
                pass

        self._update_filters_properties()
예제 #26
0
def main():
    #
    app = Application()

    app.execute()
예제 #27
0
def base(browser_type, base_url):
    driver = Browser(browser_type).create()
    driver.maximize_window()
    yield Application(driver, base_url)
    driver.close()