示例#1
0
    def __init__(self, aoi_model, model, **kwargs):

        # gather the model
        self.aoi_model = aoi_model
        self.model = model

        # widgets
        self.visSelect = v.RadioGroup(
            v_model=pm.layer_select[0]["value"],
            children=[
                v.Radio(
                    # key=e['key'],
                    label=e["label"],
                    value=e["value"],
                ) for e in pm.layer_select
            ],
        )

        # add the widgets
        self.m = sm.SepalMap()

        # bindings
        self.model.bind(self.visSelect, "viz")

        # construct the Tile with the widget we have initialized
        super().__init__(
            id_=
            "visualization_widget",  # the id will be used to make the Tile appear and disapear
            title=ms.visualization.
            title,  # the Title will be displayed on the top of the tile
            inputs=[self.visSelect, self.m],  # self.asset,
            alert=sw.Alert(),
        )

        self.visSelect.observe(self._on_change, "v_model")
示例#2
0
    def __init__(self, model, aoi_model, viz_tile, export_tile, **kwargs):

        # Define the model and the aoi_model as class attribute so that they can be manipulated in its custom methods
        self.model = model
        self.aoi_model = aoi_model

        # LINK to the result tile
        self.viz_tile = viz_tile
        self.export_tile = export_tile

        # WIDGETS
        self.year_beg = v.Select(
            label=cm.process.slider_b,
            v_model=None,
            items=[i for i in range(pm.max_year, pm.min_year - 1, -1)],
        )

        self.year_end = v.Select(
            label=cm.process.slider_e,
            v_model=None,
            items=[i for i in range(pm.max_year, pm.min_year - 1, -1)],
        )

        self.type_tmf = v.RadioGroup(
            row=True,
            v_model=pm.layer_select[0]["value"],
            children=[
                v.Radio(key=e["key"], label=e["label"], value=e["value"])
                for e in pm.layer_select
            ],
        )

        # self.type_tmf.observe(self._on_change, 'v_model')

        # Create the alert alert
        self.model.bind(self.year_beg, "year_beg").bind(
            self.year_end, "year_end").bind(self.type_tmf, "type_tmf")

        # construct the Tile with the widget we have initialized
        super().__init__(
            id_=
            "process_widget",  # the id will be used to make the Tile appear and disapear
            title=cm.process.
            title,  # the Title will be displayed on the top of the tile
            inputs=[self.year_beg, self.year_end, self.type_tmf],
            btn=sw.Btn(cm.process.validate,
                       "mdi-check",
                       disabled=False,
                       class_="ma-5"),
            alert=sw.Alert(),
        )

        # now that the Tile is created we can link it to a specific function
        self.btn.on_event("click", self._on_run)
示例#3
0
文件: quiz.py 项目: 28left/110jupyter
    def __init__(self, statement, choices):

        # get number of choices
        self.num_choices = len(choices)
        self.choices = choices

        # Shuffle answers
        self.indices = [i for i in range(self.num_choices)]
        random.shuffle(self.indices)
        self.correct = self.indices.index(0)

        # Define CSS properties to make text larger
        display(HTML("<style>.large_font { font-size: 100% }</style>"))
        display(HTML("<style>.xlarge_font { font-size: 120% }</style>"))

        # store the statement in a widget
        self.statement = w.HTMLMath(value=statement)

        # enlarge text
        self.statement.add_class("xlarge_font")

        # Create labels for each answer choice
        answers = [
            w.Label(value=self.choices[self.indices[i]])
            for i in range(self.num_choices)
        ]

        # Enlarge text for labels
        for a in answers:
            a.add_class("large_font")

        # Create radio buttons with answers as labels (slots)
        self.choice_buttons = v.RadioGroup(v_model=None,
                                           children=[
                                               v.Radio(v_slots=[{
                                                   'name': 'label',
                                                   'children': [a]
                                               }]) for a in answers
                                           ])

        # Create a submit button
        self.check_button = v.Btn(color='primary', children=['Check Answer'])

        # If button is clicked, check the currently selected answer
        self.check_button.on_event("click", self.on_click_submit)

        # Create a feedback area
        self.feedback = w.Output()
示例#4
0
    def __init__(self):

        # init the downloadable informations
        self.geometry = None
        self.dataset = None
        self.name = None
        self.aoi_name = None

        # create the useful widgets
        self.w_scale = v.Slider(
            v_model=30,  # align on the landsat images
            min=10,
            max=300,
            thumb_label=True,
            step=10,
        )

        self.w_method = v.RadioGroup(
            v_model="gee",
            row=True,
            children=[
                v.Radio(label=cm.export.radio.sepal, value="sepal"),
                v.Radio(label=cm.export.radio.gee, value="gee"),
            ],
        )

        self.alert = sw.Alert()

        self.btn = sw.Btn(cm.export.apply, small=True)

        export_data = v.Card(children=[
            v.CardTitle(
                children=[v.Html(tag="h4", children=[cm.export.title])]),
            v.CardText(children=[
                v.Html(tag="h4", children=[cm.export.scale]),
                self.w_scale,
                v.Html(tag="h4", children=[cm.export.radio.label]),
                self.w_method,
                self.alert,
            ]),
            v.CardActions(children=[self.btn]),
        ])

        # the clickable icon
        self.download_btn = v.Btn(
            v_on="menu.on",
            color="primary",
            icon=True,
            children=[v.Icon(children=["mdi-cloud-download"])],
        )

        super().__init__(
            value=False,
            close_on_content_click=False,
            nudge_width=200,
            offset_x=True,
            children=[export_data],
            v_slots=[{
                "name": "activator",
                "variable": "menu",
                "children": self.download_btn
            }],
        )

        # add js behaviour
        self.btn.on_event("click", self._apply)
示例#5
0
    def __init__(self):

        # init the downloadable informations
        self.geometry = None
        self.names = []
        self.datasets = {}

        # create the useful widgets
        self.w_scale = v.Slider(
            class_="mt-5",
            v_model=30,  # align on the landsat images,
            ticks="always",
            tick_labels=[
                str(i) if i in self.TICKS_TO_SHOW else ""
                for i in range(10, 301, 10)
            ],
            min=10,
            max=300,
            thumb_label=True,
            step=10,
        )

        self.w_prefix = v.TextField(
            label=cm.export.name,
            small=True,
            dense=True,
            v_model=None,
        )

        self.w_datasets = v.Select(
            dense=True,
            small=True,
            label=cm.export.datasets,
            v_model=None,
            items=[*self.datasets],
            multiple=True,
            chips=True,
        )

        self.w_method = v.RadioGroup(
            v_model="gee",
            row=True,
            children=[
                v.Radio(label=cm.export.radio.sepal, value="sepal"),
                v.Radio(label=cm.export.radio.gee, value="gee"),
            ],
        )

        self.alert = sw.Alert()

        self.btn = sw.Btn(cm.export.apply, small=True)

        export_data = v.Card(children=[
            v.CardTitle(
                children=[v.Html(tag="h4", children=[cm.export.title])]),
            v.CardText(children=[
                self.w_prefix,
                self.w_datasets,
                v.Html(tag="h4", children=[cm.export.scale]),
                self.w_scale,
                v.Html(tag="h4", children=[cm.export.radio.label]),
                self.w_method,
                self.alert,
            ]),
            v.CardActions(children=[self.btn]),
        ])

        # the clickable icon
        self.w_down = v.Btn(
            v_on="menu.on",
            color="primary",
            icon=True,
            children=[v.Icon(children=["mdi-cloud-download"])],
        )

        super().__init__(
            value=False,
            close_on_content_click=False,
            nudge_width=200,
            offset_x=True,
            children=[export_data],
            v_slots=[{
                "name": "activator",
                "variable": "menu",
                "children": self.w_down
            }],
        )

        # add js behaviour
        self.btn.on_event("click", self._apply)
示例#6
0
 def __init__(self, viz_model, tb_model):
     
     # gather model
     self.viz_model = viz_model
     self.tb_model = tb_model
     
     # Create alert
     
     self.alert = sw.Alert()
     
     # create the widgets
     self.driver = v.RadioGroup(
         label = cm.viz.driver,
         row= True,
         v_model = self.viz_model.driver,
         children = [
             v.Radio(key=i, label=n, value=n) for i, n 
             in enumerate(cp.drivers)
         ]
     )
     
     self.sources = v.Select(
         items=cp.sources, 
         label=cm.viz.sources, 
         v_model=self.viz_model.sources, 
         multiple=True,
         chips=True
     )
     
     self.planet_key = sw.PasswordField(
         label = cm.planet.key_label
     ).hide()
     
     self.semester = v.RadioGroup(
         label = cm.viz.semester,
         row= True,
         v_model = None,
         children = [
             v.Radio(label=cp.planet_semesters[n], value=n) for n
             in [*cp.planet_date_ranges[cp.planet_min_start_year]]
         ]
     )
     
     su.hide_component(self.semester)
     
     self.bands = v.Select(
         items=[*cp.getAvailableBands()], 
         label=cm.viz.bands, 
         v_model=self.viz_model.bands
     )
     self.start = v.Select(
         class_='mr-5 ml-5', 
         items=[
             y for y 
             in range(cp.gee_min_start_year, cp.gee_max_end_year+1)
         ], 
         label=cm.viz.start_year, 
         v_model=self.viz_model.start_year
     )
     self.end = v.Select(
         class_='ml-5 mr-5',
         items=[y for y 
                in range(cp.gee_min_start_year, cp.gee_max_end_year+1)
         ], 
         label=cm.viz.end_year, 
         v_model=self.viz_model.end_year
     )
     years = v.Layout(
         xs=12, 
         row=True,  
         children=[self.start, self.end]
     )
     
     image_size = v.Slider(
         step=500, 
         min=cp.min_image, 
         max=cp.max_image, 
         label=cm.viz.image_size, 
         v_model=self.viz_model.image_size, 
         thumb_label='always', 
         class_='mt-5'
     )
     
     square_size = v.Slider(
         step=10, 
         min=cp.min_square, 
         max=cp.max_square, 
         label=cm.viz.square_size, 
         v_model=self.viz_model.square_size, 
         thumb_label='always', 
         class_='mt-5'
     )
     
     
     # bind the inputs
     self.viz_model.bind(self.sources, 'sources') \
             .bind(self.planet_key, 'planet_key') \
             .bind(self.bands, 'bands') \
             .bind(self.start, 'start_year') \
             .bind(self.end, 'end_year') \
             .bind(self.driver, 'driver') \
             .bind(image_size, 'image_size') \
             .bind(square_size, 'square_size') \
             .bind(self.semester, 'semester')
     
     # create the tile 
     super().__init__(
         id_ = "viz_widget",
         title = cm.viz.title,
         btn = sw.Btn(cm.viz.btn),
         inputs = [
             self.driver, self.sources, 
             self.planet_key, self.bands, 
             years, self.semester, 
             image_size, square_size
         ],
         alert = self.alert
     )
     
     # js behaviour 
     self.btn.on_event('click', self._display_data) 
     self.driver.observe(self._on_driver_change, 'v_model')
示例#7
0
def radio_buttons(choices,
                  row=False,
                  v_model=None,
                  label=None,
                  hint=None,
                  persistent_hint=False,
                  class_='px-2 my-0 py-2',
                  style_=None,
                  **kwargs):
    """
    Radio Button input field

    Function to generate an ipyvuetify Radio Buttons input widget.

    The value of the widget can be accessed or modified by the `v_model` property of the return value.

    See the vuetify documention for other arguments that can be passed as keyword arguments: https://vuetifyjs.com/en/components/selection-controls/

    Parameters:
    choices : list or dict
        Choices to appear in radio button

    v_model : str (optional, default None)
        Value of the time input, must be an element of choices

    row : bool
        If True choices will be displayed in a row, otherwise in a column

    label : str (optional, default None)
        Description of the input

    hint : str or callable (optional, default None)
        Hint text or function generating int based on input value for validating input

    persistent_hint : bool (optional, default False)
        Set to True to display the hint when widget is not focused

    class_ : str (optional, default None)
        ipyvuetify HTML class string

    style_ : str (optional, default None)
        ipyvuetify HTML CSS string

    **kwargs
        Other arguments supported by ipyvuetify.TextField

    Returns:
    ipyvuetify.TextInput
        An ipyvuetify time input widget
    """
    ret = ipyvuetify.RadioGroup(
        class_=class_,
        style_=style_,
        v_model=v_model,
        label=label,
        hint=hint,
        persistent_hint=persistent_hint,
        row=row,
        children=[])

    # Set other keyword arguments
    for arg in kwargs:
        setattr(ret, arg, kwargs[arg])

    if isinstance(choices,list):
        ret.children = [ipyvuetify.Radio(label=i, value=i) for i in choices]
    elif isinstance(choices,dict):
        ret.children = [ipyvuetify.Radio(label=i, value=choices[i]) for i in choices]
    else:
        raise Exception("choices must be a dict or a list")

    # If no default is given, set it to the first
    if v_model is None:
        ret.v_model = choices[0]

    # Return widget
    return ret
示例#8
0
        def doe_driver_change():
            """
            Adapt widgets & vbox widgets to only display widgets you need in this driver
            """

            self.vboxdriver.children[0].children = []
            self.vboxdriver.children[1].children = []

            drive = driver.doe_driver.DOEDriver()

            def onchangegenerator(widget, event, data):
                """
                A function which start the function you need for your generator
                """

                if data == "DOEGenerator":
                    doe_generator()
                elif data == "ListGenerator":
                    list_generator()
                elif data == "CSVGenerator":
                    csv_generator()
                elif data == "UniformGenerator":
                    uniform_generator()
                elif data == "_pyDOE_Generator":
                    pydoe_generator()
                elif data == "FullFactorialGenerator":
                    full_factorial_generator()
                elif data == "GeneralizedSubsetGenerator":
                    generalized_subset_generator()
                elif data == "PlackettBurmanGenerator":
                    plackett_burman_generator()
                elif data == "BoxBehnkenGenerator":
                    box_behnken_generator()
                elif data == "LatinHypercubeGenerator":
                    latin_hypercube_generator()

            self.generator = v.Select(
                items=[
                    "DOEGenerator",
                    "ListGenerator",
                    "CSVGenerator",
                    "UniformGenerator",
                    "_pyDOE_Generator",
                    "FullFactorialGenerator",
                    "GeneralizedSubsetGenerator",
                    "PlackettBurmanGenerator",
                    "BoxBehnkenGenerator",
                    "LatinHypercubeGenerator",
                ],
                v_model="DOEGenerator",
                label="Generator :",
                outlined=True,
                style_="width:500px;margin-top:5px",
            )

            self.vboxgenerator.children[0].children = [self.generator]
            self.generator.on_event("change", onchangegenerator)

            procspermodeldoe = v.TextField(
                v_model=drive.options.__dict__["_dict"]["procs_per_model"].get("value"),
                min=drive.options.__dict__["_dict"]["procs_per_model"].get("lower"),
                max=100,
                label="Processors per model :",
                outlined=True,
                type='number',
                style_='width:500px;margin-top:5px'
            )

            runparalleldoe = v.Checkbox(
                v_model=drive.options.__dict__["_dict"]["run_parallel"].get("value"),
                label="Run parallel",
                outlined=True,
                type='number',
                style_='width:500px;margin-left:50px'
            )

            drive = driver.doe_generators.DOEGenerator()

            def doe_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [procspermodeldoe]
                self.vboxdoedriver.children[1].children = [runparalleldoe]

            drive = driver.doe_generators.ListGenerator()

            _data = v.TextField(
                v_model="[]",
                label="List of collections of name :",
                outlined=True,
                style_='width:500px;margin-top:5px'
            )

            def list_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [_data, runparalleldoe]
                self.vboxdoedriver.children[1].children = [procspermodeldoe]


            _filename = v.TextField(
                label="File name  :",
                outlined=True,
                style_='width:500px;margin-top:5px'
            )

            def csv_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [_filename, runparalleldoe]
                self.vboxdoedriver.children[1].children = [procspermodeldoe]

            drive = driver.doe_generators.UniformGenerator()

            _num_samples = v.TextField(
                v_model=drive.__dict__["_num_samples"],
                min=0,
                max=100,
                label="Number of samples :",
                outlined=True,
                type='number',
                style_='width:500px;margin-top:5px'
            )

            _seeduniform = v.TextField(
                v_model=drive.__dict__["_seed"],
                min=0,
                max=100,
                label="Seed :",
                outlined=True,
                type='number',
                style_='width:500px;margin-left:50px;margin-top:5px',
            )

            def uniform_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [_num_samples, procspermodeldoe]
                self.vboxdoedriver.children[1].children = [_seeduniform, runparalleldoe]


            drive = driver.doe_generators._pyDOE_Generator()

            def onchangelevels(widget, event, data):
                """
                A function which change the type of the levels widget ( Int or Dict )
                """

                if self.generator.v_model == '_pyDOE_Generator':
                    drive = drive = driver.doe_generators._pyDOE_Generator()

                    if data == "Int":

                        _levelspydoe = v.TextField(
                            v_model=drive.__dict__["_levels"],
                            label="Levels  :",
                            min=0,
                            max=1000,
                            outlined=True,
                            type='number',
                            style_='width:500px;margin-top:27px'
                        )

                    elif data == "Dict":

                        _levelspydoe = v.TextField(
                            v_model="[]",
                            label="Levels  :",
                            outlined=True,
                            style_='width:500px;margin-top:27px'
                        )

                    self.vboxdoedriver.children[1].children = [_levelspydoe, procspermodeldoe]

                elif self.generator.v_model == 'FullFactorialGenerator':
                    drive = driver.doe_generators.FullFactorialGenerator()

                    if data == "Int":

                        _levelsfull = v.TextField(
                            v_model=drive.__dict__["_levels"],
                            label="Levels  :",
                            min=0,
                            max=1000,
                            outlined=True,
                            type='number',
                            style_='width:500px;margin-top:27px'
                        )

                    elif data == "Dict":

                        _levelsfull = v.TextField(
                            v_model="[]",
                            label="Levels  :",
                            outlined=True,
                            style_='width:500px;margin-top:27px'
                        )

                    self.vboxdoedriver.children[1].children = [_levelsfull, procspermodeldoe]

                elif self.generator.v_model == 'PlackettBurmanGenerator':
                    drive = driver.doe_generators.PlackettBurmanGenerator()

                    if data == "Int":

                        _levelsplackett = v.TextField(
                            v_model=drive.__dict__["_levels"],
                            label="Levels  :",
                            min=0,
                            max=1000,
                            outlined=True,
                            type='number',
                            style_='width:500px;margin-top:27px'
                        )

                    elif data == "Dict":

                        _levelsplackett = v.TextField(
                            v_model="[]",
                            label="Levels  :",
                            outlined=True,
                            style_='width:500px;margin-top:27px'
                        )

                    self.vboxdoedriver.children[1].children = [_levelsplackett, procspermodeldoe]

                elif self.generator.v_model == 'BoxBehnkenGenerator':
                    drive = driver.doe_generators.BoxBehnkenGenerator()

                    if data == "Int":

                        _levelsbox = v.TextField(
                            v_model=drive.__dict__["_levels"],
                            label="Levels  :",
                            min=0,
                            max=1000,
                            outlined=True,
                            type='number',
                            style_='width:500px;margin-top:27px'
                        )

                    elif data == "Dict":

                        _levelsbox = v.TextField(
                            v_model="[]",
                            label="Levels  :",
                            outlined=True,
                            style_='width:500px;margin-top:27px'
                        )

                    self.vboxdoedriver.children[1].children = [_levelsbox, procspermodeldoe]


            selectlevels = v.RadioGroup(
                children=[
                    v.Radio(label='Int', value='Int'),
                    v.Radio(label='Dict', value='Dict'),
                ],
                v_model="Int",
                label="Levels type  :",
            )

            selectlevels.on_event('change', onchangelevels)


            _levelspydoe = v.TextField(
                v_model=drive.__dict__["_levels"],
                label="Levels  :",
                min=0,
                max=1000,
                outlined=True,
                type='number',
                style_='width:500px;margin-top:27px'
            )

            _sizespy = v.TextField(
                v_model=drive.__dict__["_sizes"],
                min=0,
                max=100,
                label="Sizes  :",
                outlined=True,
                type='number',
                style_='width:500px'
            )

            def pydoe_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [selectlevels, _sizespy, runparalleldoe]
                self.vboxdoedriver.children[1].children = [_levelspydoe, procspermodeldoe]


            drive = driver.doe_generators.FullFactorialGenerator()

            _levelsfull = v.TextField(
                v_model=drive.__dict__["_levels"],
                label="Levels  :",
                min=0,
                max=1000,
                outlined=True,
                type='number',
                style_='width:500px;margin-top:27px'
            )

            _sizesfull = v.TextField(
                v_model=drive.__dict__["_sizes"],
                min=0,
                max=100,
                label="Sizes  :",
                outlined=True,
                type='number',
                style_='width:500px'
            )

            def full_factorial_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [selectlevels, _sizesfull, runparalleldoe]
                self.vboxdoedriver.children[1].children = [_levelsfull, procspermodeldoe]


            def generalized_subset_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [procspermodeldoe]
                self.vboxdoedriver.children[1].children = [runparalleldoe]

            drive = driver.doe_generators.PlackettBurmanGenerator()

            _levelsplackett = v.TextField(
                v_model=drive.__dict__["_levels"],
                label="Levels  :",
                min=0,
                max=1000,
                outlined=True,
                type='number',
                style_='width:500px;margin-top:27px'
            )

            _sizesplackett = v.TextField(
                v_model=drive.__dict__["_sizes"],
                min=0,
                max=100,
                label="Sizes  :",
                outlined=True,
                type='number',
                style_='width:500px'
            )

            def plackett_burman_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [selectlevels, _sizesplackett, runparalleldoe]
                self.vboxdoedriver.children[1].children = [_levelsplackett, procspermodeldoe]


            drive = driver.doe_generators.BoxBehnkenGenerator()

            _levelsbox = v.TextField(
                v_model=drive.__dict__["_levels"],
                label="Levels  :",
                min=0,
                max=1000,
                outlined=True,
                type='number',
                style_='width:500px;margin-top:27px;margin-left:50px'
            )

            _sizesbox = v.TextField(
                v_model=drive.__dict__["_sizes"],
                min=0,
                max=100,
                label="Sizes  :",
                outlined=True,
                type='number',
                style_='width:500px'
            )

            _center = v.TextField(
                v_model=drive.__dict__["_center"],
                min=0,
                max=100,
                label="Center  :",
                type='number',
                outlined=True,
                style_='width:500px;margin-top:5px;margin-left:50px'
            )

            def box_behnken_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [selectlevels, _sizesbox, procspermodeldoe]
                self.vboxdoedriver.children[1].children = [_levelsbox, _center, runparalleldoe]


            drive = driver.doe_generators.LatinHypercubeGenerator()

            _samples = v.TextField(
                v_model=drive.__dict__["_samples"],
                min=0,
                max=100,
                label="Number of samples to generate :",
                type='number',
                outlined=True,
                style_="width:500px;margin-top:5px",
            )

            _criterion = v.Select(
                items=["None", "center", "maximin", "centermaximin", "correlation"],
                v_model=drive.__dict__["_criterion"],
                label="Criterion :",
                outlined=True,
                style_="width:500px;margin-top:5px;margin-left:50px",
            )

            _iterations = v.TextField(
                v_model=drive.__dict__["_iterations"],
                min=0,
                max=100,
                label="Iterations  :",
                outlined=True,
                type='number',
                style_="width:500px;margin-top:5px",
            )

            _seedlatin = v.TextField(
                v_model=drive.__dict__["_seed"],
                min=0,
                max=100,
                label="Seed :",
                outlined=True,
                type='number',
                style_="width:500px;margin-top:5px;margin-left:50px",
            )

            def latin_hypercube_generator():
                """
                Adapt widgets & vbox widgets to only display widgets you need in this generator
                """

                self.vboxdoedriver.children[0].children = [_samples, _iterations, procspermodeldoe]
                self.vboxdoedriver.children[1].children = [_criterion, _seedlatin, runparalleldoe]

            doe_generator()