def __init__(
self,
children: ChildrenType = None,
show: PropValueType[bool] = None,
hide_on_scroll: bool = None, # this is the reveal prop
elevated: bool = None,
bordered: bool = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None):
props = build_props(
self.defaults['props'], props, {
'reveal': hide_on_scroll,
'elevated': elevated,
'bordered': bordered,
'show': show,
})
show = props['show']
model = show if isinstance(show, Reactive) else Model(show)
super().__init__(model=model,
children=children,
classes=classes,
styles=styles,
props=props,
events=events)
def __init__(self,
model: Renderable = None,
type: PropValueType[str] = None,
options: PropValueType = None,
children: ChildrenType = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None):
props = build_props(props or {}, {
'type': type,
'options': options,
})
if model is not None:
self._model = model
elif props.get('type', 'radio') == 'radio':
self._model = Model('')
else:
self._model = Model([])
super().__init__(model=self._model,
children=children,
classes=classes,
styles=styles,
props=props,
events=events)
def __init__(self,
children: ChildrenType = None,
menu_in_header: bool = True,
side: str = None,
show: Union[Model, bool] = True,
bordered: bool = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None):
"""
:menu_in_header: if used together with QLayout, it instructs to put a close menu into the header.
"""
self.menu_in_header = menu_in_header
children = children
props = build_props({}, props, {
'side': side,
'bordered': bordered,
})
model = show if isinstance(show, Reactive) else Model(show)
super().__init__(model=model,
children=children,
classes=classes,
styles=styles,
props=props,
events=events)
def __init__(self,
label: str = None,
model: Model = None,
type: PropValueType[str] = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None,
children: List[Slot] = None):
props = build_props({}, props, {
'label': label,
'type': type,
})
if props.get('type', '') == 'number':
model = model or Model(0)
model.modifiers.add('number')
elif props.get('type', '') in {'', 'text'}:
model = model or Model('')
used_slots = {slot.name for slot in children or []}
bottom_slots = {'error', 'hint', 'counter'}
bottom_slots_used = used_slots & bottom_slots
if bottom_slots_used and 'bottom-slots' not in props:
props['bottom-slots'] = True
if 'label' in used_slots and 'label-slot' not in props:
props['label-slot'] = True
super().__init__(model=model,
classes=classes,
styles=styles,
props=props,
events=events,
children=children)
def __init__(
self,
appearance: str = None,
color: PropValueType[str] = None,
size: PropValueType[str] = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None,
):
kwargs = dict(
props=build_props({}, props, {
'color': color,
'size': size
}),
classes=classes,
styles=styles,
events=events,
)
if appearance is not None:
if appearance not in self.appearances:
raise AssertionError('Appearance must be one of {}'.format(
self.appearances))
kwargs['component'] = 'q-spinner-{}'.format(appearance)
super().__init__(**kwargs)
def _build_defaults(cls, defaults, custom):
results = custom.copy()
for category, settings in defaults.items():
if category not in results:
results[category] = settings
elif '_classes' in category:
results[category] = merge_classes(settings, results[category])
elif isinstance(settings, dict):
results[category] = build_props(settings, results[category])
else:
continue
return results
def __init__(self,
title: str = None,
href: PropValueType[str] = None,
classes: ClassesType = None,
styles: StylesType = None,
children: ChildrenType = None,
events: EventsType = None):
if children is None and title is None:
raise AssertionError(
'either title or children parameter must be set')
props = build_props(self.defaults['props'], {'href': href})
styles = build_props(self.defaults['styles'], styles)
if props['target'] == '_blank' and children is None:
children = [QIcon('open_in_new')]
if title is not None:
children = [title] + (children or [])
classes = merge_classes(self.defaults['classes'], classes or '')
super().__init__(children=children,
props=props,
classes=classes,
styles=styles,
events=events)
def __init__(self,
src: PropValueType[str],
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None,
children: ChildrenType = None):
props = build_props({}, props, {'src': src})
super().__init__(classes=classes,
styles=styles,
props=props,
events=events,
children=children)
def __init__(self,
children: ChildrenType = None,
padding: PropValueType[bool] = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None):
props = build_props({}, props, {'padding': padding})
self.page = _Page(children=children,
classes=classes,
styles=styles,
props=props,
events=events)
super().__init__(children=[self.page])
def __init__(self,
label: str = None,
model: Model = None,
appearance: str = 'editor',
classes: ClassesType = None,
label_classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None,
children: List[Slot] = None):
"""
:param label:
:param model:
:param appearance: 'editor' or 'textarea'
:param classes:
:param styles:
:param props:
:param events:
:param children:
"""
model = model or Model('')
if appearance == 'editor':
raise NotImplementedError(
'Cannot use appearance == "editor" '
'at the moment since it is not editable for some reason'
'and we couldn\'t fix it.')
self.component = 'div'
children = [
label,
QEditor(model=model,
classes=classes,
styles=styles,
props=props,
events=events,
children=children)
]
label_classes = merge_classes(self.defaults['label_classes'],
label_classes)
super().__init__(classes=label_classes, children=children)
else:
self.component = 'q-input'
props = build_props({'type': 'textarea'}, props, {
'label': label,
'v-model': model
})
super().__init__(classes=classes,
styles=styles,
props=props,
events=events,
children=children)
def __init__(self,
model: Renderable = None,
options: PropValueType = None,
children: ChildrenType = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None):
props = build_props({}, props, {'options': options})
super().__init__(model=model,
children=children,
classes=classes,
styles=styles,
props=props,
events=events)
def __init__(self,
label: str = None,
model: Model = None,
props: PropsType = None,
classes: ClassesType = None,
styles: StylesType = None,
events: EventsType = None,
children: List[Slot] = None):
props = build_props({}, props, {'label': label})
model = self._get_model(model)
children = self._create_popup_slots(model) + (children or [])
super().__init__(model=model,
props=props,
classes=classes,
styles=styles,
events=events,
children=children)
def __init__(self,
name: PropValueType[str] = None,
icon: PropValueType[str] = None,
label: PropValueType[str] = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None,
children: ChildrenType = None):
props = build_props({}, props, {
'name': name,
'icon': icon,
'label': label
})
super().__init__(classes=classes,
styles=styles,
props=props,
events=events,
children=children)
def __init__(self,
name: PropValueType[str],
size: PropValueType[str] = None,
color: PropValueType[str] = None,
classes: ClassesType = None,
styles: StylesType = None,
events: EventsType = None,
props: PropsType = None,
children: ChildrenType = None):
props = build_props({}, props, {
'name': name,
'size': size,
'color': color
})
super().__init__(props=props,
classes=classes,
styles=styles,
events=events,
children=children)
def __init__(self,
label: PropValueType[str] = None,
icon: PropValueType[str] = None,
color: PropValueType[str] = None,
type: PropValueType[str] = None,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None,
events: EventsType = None,
children: ChildrenType = None):
props = build_props({}, props, {
'label': label,
'icon': icon,
'color': color,
'type': type
})
super().__init__(classes=classes,
styles=styles,
props=props,
events=events,
children=children)
def __init__(
self,
children: ChildrenType = None,
hide_on_scroll: bool = None, # this is the reveal prop
elevated: bool = None,
bordered: bool = None,
show: PropValueType[bool] = True,
classes: ClassesType = None,
styles: StylesType = None,
props: PropsType = None):
if 1 <= len(children) <= 2 and isinstance(children[-1], str):
children = [QToolbar([QToolbarTitle(children)])]
props = build_props({}, props, {
'reveal': hide_on_scroll,
'elevated': elevated,
'bordered': bordered,
})
model = show if isinstance(show, Reactive) else Model(show)
super().__init__(model=model,
children=children,
classes=classes,
styles=styles,
props=props)
def __init__(self,
label: str = None,
model: Model = None,
choices: Union[Renderable, list] = None,
multiple: bool = None,
appearance: str = 'auto',
item_props: PropsType = None,
label_props: PropsType = None,
props: PropsType = None,
classes: ClassesType = None,
styles: StylesType = None,
events: EventsType = None):
"""
:param label:
:param model:
the value of the model depends on the choices parameter (and the item_props).
List[str] choice format yields the displayed label as model value,
List[dict] format yields the value of 'value' field as value, if dict has only 'label' and 'value' fields.
Otherwise List[dict] format yields the whole dict of the selected item.
This behavior can be overridden with item_props
that is sent to QSelect ('select'), QOptionGroup ('radio') or QButtonToggle ('buttons') as props parameter.
:param choices: format is ['choice 1', 'choice 2', ...] or [{'label':'Choice 1', 'value': 1}, ...].
:param appearance:
if multiple=False: 'auto', 'radio', 'buttons' or 'select'.
'auto' means 'radio' for small lists, 'select' for large lists.
if multiple=True: 'auto', 'checkboxes', 'toggles', 'select' or 'tags'
'auto' means 'checkboxes' for small lists, 'select' for large lists, 'tags' if choices is None.
:param item_props: The props for the items. (also if appearance=='select', props for the QSelect)
:param classes:
:param styles:
:param label_props:
:param events:
"""
def is_lvc(choices_):
"""
is_label_value_choice
"""
# noinspection PyBroadException
try:
return set(choices_[0].keys()) == {'label', 'value'}
except Exception:
return False
single_only_appearances = {'input', 'radio', 'buttons'}
multiple_only_appearances = {'checkboxes', 'toggles', 'tags'}
props = props or {}
if multiple is None:
multiple = appearance in multiple_only_appearances
model = model or Model([] if multiple else '')
self.dependents = [model]
allowed_appearances = {
'auto', 'radio', 'checkboxes', 'toggles', 'buttons', 'select',
'tags'
}
if appearance not in allowed_appearances:
raise AssertionError(
'Wrong appearance {}. Must be one of {}'.format(
appearance, allowed_appearances))
if appearance in single_only_appearances and multiple:
raise AssertionError(
'appearance=={} can be only used if multiple==False'.format(
appearance))
elif appearance in multiple_only_appearances and not multiple:
raise AssertionError(
'appearance=={} can be only used if multiple==True'.format(
appearance))
if appearance == 'auto':
# auto is for providing the user a reasonable default.
if isinstance(choices, list):
n_choices = len(choices)
elif isinstance(choices, Reactive):
n_choices = len(choices.value)
else:
n_choices = 0
if multiple:
appearance = ('tags' if n_choices == 0 else
'checkboxes' if n_choices <= 10 else 'select')
else:
appearance = 'radio' if 0 < n_choices <= 5 else \
'input' if n_choices == 0 else \
'select'
if appearance == 'input':
self.component = 'q-input'
children = []
elif appearance in {'radio', 'buttons', 'checkboxes', 'toggles'}:
if (isinstance(choices, list) and len(choices)
and isinstance(choices[0], str)):
choices = [{
'label': choice,
'value': choice
} for choice in choices]
default_item_props = build_props(
self.defaults['item_props'],
{'type': 'radio'} if appearance == 'radio' else
{'type': 'checkbox'} if appearance == 'checkboxes' else
{'type': 'toggle'} if appearance == 'toggles' else {})
item_props = build_props(default_item_props, item_props)
children = [
Div([label], props=label_props),
]
if appearance in {'radio', 'checkboxes', 'toggles'}:
del item_props['clearable']
type_ = {
'radio': 'radio',
'checkboxes': 'checkbox',
'toggles': 'toggle',
}[appearance]
children += [
QOptionGroup(model=model,
type=type_,
options=choices,
props=item_props)
]
elif appearance == 'buttons':
children += [
QButtonToggle(model=model,
options=choices,
props=item_props)
]
elif appearance == 'select':
if isinstance(choices, Reactive):
is_label_value_choice = Computed(is_lvc, choices)
else:
is_label_value_choice = is_lvc(choices)
default_props = {
'emit-value': is_label_value_choice,
'map-options': is_label_value_choice
}
default_props = build_props(default_props,
self.defaults['item_props'])
item_props = build_props(default_props, item_props, {
'options': choices,
'multiple': multiple,
'use-chips': multiple
})
children = [QSelect(label=label, model=model, props=item_props)]
elif appearance == 'tags':
label_props = build_props({
'hide-bottom-space': True,
}, label_props)
item_props = build_props(
{
'placeholder': props.get('placeholder', ''),
'add-on-key': [13, ','],
# 'separators': [',']
},
item_props)
children = [
QField(label=label,
model=model,
props=label_props,
children=[
Slot('control',
[VueTagsInput(model, props=item_props)])
]),
]
else:
raise NotImplementedError(
'appearance=={} is not implemented.'.format(appearance))
super().__init__(label=label,
model=model,
classes=classes,
styles=styles,
props=props,
events=events,
children=children)
def __init__(self,
label: str = None,
model: Model = None,
appearance: str = None,
min: Union[int, float] = None,
max: Union[int, float] = None,
props: PropsType = None,
field_props: PropsType = None,
field_classes: ClassesType = None,
field_styles: StylesType = None,
children: List[Slot] = None,
classes: ClassesType = None,
styles: StylesType = None,
events: EventsType = None):
appearance = appearance or 'input'
self.component = {
'input': 'q-input',
'knob': 'q-field',
'slider': 'q-field'
}[appearance]
model = model or Model(0, self._type)
model.modifiers.add('number')
model.set_conversion(self._type)
special_props = {'min': min, 'max': max}
if appearance in {'knob', 'slider'}:
min = 0 if min is None else min
max = 100 if max is None else max
component_class = {'knob': QKnob, 'slider': QSlider}[appearance]
control_props = build_props({'snap': self._type == int}, props)
control_props = build_props(self.defaults['control_props'],
control_props)
if self._type == float:
control_props = build_props({'step': (max - min) / 1000},
control_props)
control_props = build_props(
{
'label-position':
'before' if appearance == 'knob' else 'top'
}, control_props, special_props)
control = component_class(
model=model,
props=control_props,
children=children,
classes=classes,
styles=styles,
events=events,
)
label_position = control_props['label-position']
field_props = build_props(
{
'borderless': True,
'stack-label': True,
}, field_props,
{'label': label if label_position == 'top' else None})
label_slot = []
if label and label_position != 'top':
field_classes = merge_classes(self.defaults['field_classes'],
field_classes or '')
if isinstance(label, str):
label = Div([label], classes=field_classes)
label_position = {
'left': 'before',
'right': 'after'
}.get(label_position, label_position)
label_slot = [Slot(label_position, children=[label])]
super().__init__(model=model,
props=field_props,
children=[Slot('control', [control])] +
label_slot)
else:
props = build_props({'type': 'number'}, props, special_props)
props = build_props(props, field_props, {'label': label})
classes = merge_classes(classes or '', field_classes or '')
styles = build_props(styles or {}, field_styles)
self.component = 'q-input'
super().__init__(model=model,
classes=classes,
styles=styles,
props=props,
events=events,
children=children)
